#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <assert.h>


#include "hdf5.h"
#include "h5trav.h"


/*

Example 1
dset1 dset2 h5diff_test1.h5 h5diff_test2.h5
Example 2
dset1 dset2 -v h5diff_test1.h5 h5diff_test2.h5
Example 3
-v h5diff_test1.h5 h5diff_test2.h5
Example 4
-v -r h5diff_test1.h5 h5diff_test2.h5
Example 5
dset1 dset2 -n 2 h5diff_test1.h5 h5diff_test2.h5
Example 6
dset3 dset4 -m 0.01 h5diff_test1.h5 h5diff_test2.h5
Example 7
dset5 dset6 -p 0.05 h5diff_test1.h5 h5diff_test2.h5

*/



#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif


typedef struct options_t
{
	int    d_;
	int    g_;
	int    t_;
	int    r_; /* report only what objects differ */
 int    m_;
	double m_limit;
	int    p_;
	double p_percent;
	int    n_;
	int    n_number_count;
	int    a_;
	int    v_; /* verbose */
} options_t;

int do_test_files();

int diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name, 
                  const char *obj2_name, options_t options );
int array_diff( void *buf1, void *buf2, hsize_t tot_cnt, hid_t type_id, int rank,
																 hsize_t *dims, options_t options );
void print_pos( hsize_t curr_pos, hsize_t *acc, hsize_t *pos, int rank );




/*-------------------------------------------------------------------------
 * Function: usage
 *
 * Purpose: print a usage message  
 *
 * Return: void
 *
 * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
 *
 * Date: October 8, 2002
 *
 * Comments:
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */

void usage( const char *progname )
{
#define USAGE   "\
  [-m ]             Print a basic help message\n\
  [-v ]             Print a verbose output message\n\
  [-r ]             Print only what objects differ \n\
  [-d ]             Compare only datasets\n\
  [-g ]             Compare only groups\n\
  [-n count]        Print difference up to count number for each variable\n\
  [-m delta]        Print difference when it is greater than limit delta\n\
  [-p percent]      Print differences which are within a certain percent value\n\
  file1             File name of the first HDF5 file\n\
  file2             File name of the second HDF5 file\n"

 fprintf(stderr,
  "%s [-d delta] file1 file2\n%s",
  progname,
  USAGE);
 exit(EXIT_FAILURE);
}


/*-------------------------------------------------------------------------
 * Function: main
 *
 * Purpose: H5diff 
 *
 * Return: Success: 0, Failure: 1
 *
 * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
 *
 * Date: October 8, 2002
 *
 * Comments:
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */

int main(int argc, const char *argv[])
{
 
 const char *progname = argv[0];
 int        dset_only  = FALSE;
 int        have_group = FALSE;
 int        argno, i, j;
 const char *s = NULL;
 const char *file1_name = NULL;
 const char *file2_name = NULL;
 char       *obj1_name = NULL;
 char       *obj2_name = NULL;
 hid_t      file1_id, file2_id; 
 herr_t     status;
 int        nobjects1, nobjects2;
 info_t     *info1=NULL;
	info_t     *info2=NULL;
	char       *attr1_name = NULL;
 char       *attr2_name = NULL;
	options_t  options = {0,0,0,0,0,0,0,0,0,0,0,0};


	/* string compare */
	char *pdest;
 int  result;
	int  len;



 do_test_files();


/*-------------------------------------------------------------------------
 * parse command line options
 *-------------------------------------------------------------------------
 */
 
 if (argc < 2) {
  usage( progname );
  exit(EXIT_FAILURE);
 }
 
 /* last 2 items are the file names */
 for (argno=1; argno<argc-2 ; argno++) 
 {
		
  /* get the single-letter switches */
  if ( '-'==argv[argno][0] )
  {
   
   for (s=argv[argno]+1; *s; s++) 
   {
    switch (*s) {
    case 'h': 
     usage(progname);
     exit(EXIT_SUCCESS);
				case 'v': 
					options.v_ = 1;
     break;
				case 'd': 
					options.d_ = 1;
     break;
				case 'g': 
					options.g_ = 1;
     break;
				case 't': 
					options.t_ = 1;
     break;
				case 'r': 
					options.r_ = 1;
     break;
				case 'a': 
					options.a_ = 1;
     break;
    case 'm': 
					/* if it is not another option */
					if ( '-' !=argv[argno+1][0] )
					{
						options.m_      = 1;
						options.m_limit = atof(argv[argno+1]);
					}
     break;
 			case 'p': 
					if ( '-' !=argv[argno+1][0] )
					{
						options.p_         = 1;
						options.p_percent  = atof(argv[argno+1]);
					}
     break;
				case 'n': 
					if ( '-' !=argv[argno+1][0] )
					{
						options.n_             = 1;
						options.n_number_count = atoi(argv[argno+1]);
					}
     break;
    } /*switch*/
   } /*for*/ 
  } /*if*/
		
		else
			
		{
			
			/* 2 last args are the file names, and it is not a -switch parameter */
			if ( argno < argc-2 && '-' !=argv[argno-1][0] )
			{
				if ( obj1_name == NULL )
				 obj1_name = argv[argno];

				if ( obj2_name == NULL )
				{
					
					/* check if we have a second object name */
					if ( '-' !=argv[argno+1][0] )
						/* yes */
						obj2_name = argv[argno+1];
					else
						/* no */
						obj2_name = obj1_name;
				}
			}
			
		}
		
 }/*for*/
	

/*-------------------------------------------------------------------------
 * process the files
 *-------------------------------------------------------------------------
 */
 
 file1_name = argv[argc-2];
 file2_name = argv[argc-1];
 
 /* Open the files */
 if ((file1_id=H5Fopen(file1_name,H5F_ACC_RDONLY,H5P_DEFAULT))<0 ||
     (file2_id=H5Fopen(file2_name,H5F_ACC_RDONLY,H5P_DEFAULT))<0)
  exit(EXIT_FAILURE);


/*-------------------------------------------------------------------------
 * get the number of objects in the files
 *-------------------------------------------------------------------------
 */

 nobjects1 = H5get_object_info( file1_id, NULL );
	nobjects2 = H5get_object_info( file2_id, NULL );

/*-------------------------------------------------------------------------
 * get the list of objects in the files
 *-------------------------------------------------------------------------
 */

 info1 = (info_t*) malloc( nobjects1 * sizeof(info_t));
	info2 = (info_t*) malloc( nobjects2 * sizeof(info_t));

 H5get_object_info( file1_id, info1 );
	H5get_object_info( file2_id, info2 );

	if ( options.v_ )
	{
		printf("File 1: # of entries = %d\n", nobjects1);
		for ( i = 0; i < nobjects1; i++)
		{
			switch ( info1[i].type )
			{
			case H5G_GROUP:
				printf("%s \t %s\n", info1[i].name, "group" );
				break;
			case H5G_DATASET:
				printf("%s \t %s\n", info1[i].name, "dataset" );
				break;
			case H5G_TYPE:
				printf("%s \t %s\n", info1[i].name, "datatype" );
				break;
			}
		}
		
		printf("File 2: # of entries = %d\n", nobjects2);
		for ( i = 0; i < nobjects2; i++)
		{
			switch ( info2[i].type )
			{
			case H5G_GROUP:
				printf("%s \t %s\n", info2[i].name, "group" );
				break;
			case H5G_DATASET:
				printf("%s \t %s\n", info2[i].name, "dataset" );
				break;
			case H5G_TYPE:
				printf("%s \t %s\n", info2[i].name, "datatype" );
				break;
			}
		}
		printf("\n");
	}
  



/*-------------------------------------------------------------------------
 * object name was supplied
 *-------------------------------------------------------------------------
 */
	
	/* object name was supplied, find obj1_name */
	if ( obj1_name )
	{

		for ( i = 0; i < nobjects1; i++)
		{

			pdest = strstr( info1[i].name, obj1_name );
   result = pdest - info1[i].name;
   len = strlen(obj1_name);
			
			/* found at position result */
			if( pdest != NULL && 
				/* check if it is not a substring */
				info1[i].name[result-1] == '/' &&
				/* check if it is the last or in the middle */
				(info1[i].name[result+len]=='/' || 
				 info1[i].name[result+len]=='\0') )
   {
				if ( options.v_ )
     printf( "%s found in file %s\n\n", info1[i].name, file1_name);

   /* go to second file and find obj2_name */
    for ( j = 0; j < nobjects2; j++)
    {
     
					pdest = strstr( info2[j].name, obj2_name );
					result = pdest - info2[j].name;

					len = strlen(obj2_name);
					
					/* found at position result */
					if( pdest != NULL && 
						/* check if it is not a substring */
						info2[j].name[result-1] == '/' &&
						/* check if it is the last or in the middle */
						(info2[j].name[result+len]=='/' || info2[j].name[result+len]=='\0') &&
							/* objects are the same type */
					  info1[i].type == info2[j].type )
					{
						
						switch ( info1[i].type )
						{
							
					/*-------------------------------------------------------------------------
						* H5G_GROUP
						*-------------------------------------------------------------------------
						*/ 
							
						case H5G_GROUP:

							if ( options.d_==1 || options.t_==1 ) break;
						 printf( "%s found in file %s, %s found in file %s\n", info1[i].name, file1_name,
							 info2[j].name, file2_name ); 
						
							
							break;
							
						/*-------------------------------------------------------------------------
							* H5G_DATASET
							*-------------------------------------------------------------------------
							*/
							
						case H5G_DATASET:
							if ( options.g_==1 || options.t_==1 ) break;
							if ( options.v_ )
							 printf( "%s found in file %s\n\n", info2[j].name, file2_name);
							if ( options.r_==1 ) break;
							/* compare with the absolute name */
							diff_dataset(file1_id,file2_id,info1[i].name,info2[j].name,options);
							printf("\n");
							break;
							
						/*-------------------------------------------------------------------------
							* H5G_TYPE
							*-------------------------------------------------------------------------
							*/
							
						case H5G_TYPE:
							
							break;
							
						} /* switch */
											
					}
					
				} /* j */
				
			}
			
		} /* i */

	}
		
		
		
/*-------------------------------------------------------------------------
	* compare all datasets
 *-------------------------------------------------------------------------
 */

 else
		
 {
		for ( i = 0; i < nobjects1; i++)
		{
			obj1_name = info1[i].name;
			len = strlen(obj1_name);
			
			for ( j = 0; j < nobjects2; j++)
			{
				/* find an object in file2 with same name as in file 1 */
		
				pdest = strstr( info2[j].name, obj1_name );
				result = pdest - info2[j].name;
				
				/* found at position result */
				if( pdest != NULL && 
					/* check if it is not a substring */
					info2[j].name[result] == '/' &&
					/* check if it is the last or in the middle */
					(info2[j].name[result+len]=='/' || info2[j].name[result+len]=='\0') &&
					/* objects are the same type */
					info1[i].type == info2[j].type )
				{
					
					switch ( info1[i].type )
					{
						
					/*-------------------------------------------------------------------------
					* H5G_GROUP
					*-------------------------------------------------------------------------
						*/ 
						
					case H5G_GROUP:

						if ( options.d_==1 || options.t_==1 ) break;
						printf( "%s found in file %s, %s found in file %s\n", info1[i].name, file1_name,
							 info2[j].name, file2_name ); 
						
						break;
						
						/*-------------------------------------------------------------------------
						* H5G_DATASET
						*-------------------------------------------------------------------------
						*/
						
					case H5G_DATASET:
						
						if ( options.g_==1 || options.t_==1 ) break;
						if ( options.v_ )
							printf( "%s found in file %s, %s found in file %s\n", info1[i].name, file1_name,
							 info2[j].name, file2_name ); 
						if ( options.r_==1 ) break;
    		/* compare with the absolute name */
						diff_dataset(file1_id,file2_id,info1[i].name,info2[j].name,options);
						printf("\n");
						break;
						
						/*-------------------------------------------------------------------------
						* H5G_TYPE
						*-------------------------------------------------------------------------
						*/
						
					case H5G_TYPE:
						
						break;
						
					}
					
				}
				
			} /* j */
		} /* i */
		
	}

 /* close */
 status = H5Fclose(file1_id);
 status = H5Fclose(file2_id);

 if ( info1 )
  free(info1);
	if ( info2 )
  free(info2);

 return 0;

}






/*-------------------------------------------------------------------------
 * Function: diff_dataset
 *
 * Purpose: 
 *
 * Return: Success: 0, Failure: -11
 *
 * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
 *
 * Date: October 8, 2002
 *
 * Comments:
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */



int diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name,
                  const char *obj2_name, options_t options )
{

 hid_t   dset1_id, dset2_id; 
 hid_t   space1_id, space2_id; 
 hid_t   type1_id, type2_id;
 hid_t   rank1, rank2; 
 void    *buf1, *buf2;
 hsize_t tot_cnt, tot_cnt1, tot_cnt2;
 hsize_t dims1[32], dims2[32];
 int     i;
 herr_t  status;

/*-------------------------------------------------------------------------
 * open the handles
 *-------------------------------------------------------------------------
 */

 /* Open the datasets */
 if ( (dset1_id = H5Dopen(file1_id,obj1_name)) < 0 )
  return -1;

 if ( (dset2_id = H5Dopen(file2_id,obj2_name)) < 0 )
  return -1;

 /* Get the datatype */
 if ( (type1_id = H5Dget_type(dset1_id)) < 0 )
  goto out;

 /* Get the datatype */
 if ( (type2_id = H5Dget_type(dset2_id)) < 0 )
  goto out;

 /* Get the dataspace handle */
 if ( (space1_id = H5Dget_space(dset1_id)) < 0 )
  return -1;

 /* Get rank */
 if ( (rank1 = H5Sget_simple_extent_ndims(space1_id)) < 0 )
  return -1;

 /* Get the dataspace handle */
 if ( (space2_id = H5Dget_space(dset2_id)) < 0 )
  return -1;

 /* Get rank */
 if ( (rank2 = H5Sget_simple_extent_ndims(space2_id)) < 0 )
  return -1;

 /* Get dimensions */
 if ( H5Sget_simple_extent_dims(space1_id,dims1,NULL) < 0 )
  goto out;

 /* Get dimensions */
 if ( H5Sget_simple_extent_dims(space2_id,dims2,NULL) < 0 )
  goto out;


/*-------------------------------------------------------------------------
 * compare
 *-------------------------------------------------------------------------
 */
	
 if ( rank1 != rank2 )
 {
  goto out;
 }

 printf("Dataset Names: %s and %s .... Comparing\n", obj1_name, obj2_name);

 tot_cnt1 = 1;
 for (i = 0; i < rank1; i++) 
 {
  tot_cnt1 *= dims1[i];
 }
 
 tot_cnt2 = 1;
 for (i = 0; i < rank2; i++) 
 {
  tot_cnt2 *= dims2[i];
 }

 buf1 = (void *) malloc((unsigned) (tot_cnt1*H5Tget_size(type1_id)));
 buf2 = (void *) malloc((unsigned) (tot_cnt2*H5Tget_size(type2_id)));


 if ( H5Dread(dset1_id,type1_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
  goto out;

 if ( H5Dread(dset2_id,type2_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
  goto out;
 
 if (tot_cnt1 > tot_cnt2)
  tot_cnt = tot_cnt2;
 else
  tot_cnt = tot_cnt1; 

 if ( array_diff(buf1,buf2,tot_cnt,type1_id,rank1,dims1,options) == 0 )
		printf("No differences found\n" );


 free((char *) buf1);
 free((char *) buf2);
	
/*-------------------------------------------------------------------------
 * attributes
 *-------------------------------------------------------------------------
 */

	if ( options.a_==1 ) 
	{



	}


/*-------------------------------------------------------------------------
 * close
 *-------------------------------------------------------------------------
 */


out:
 
 /* Close */
 status = H5Dclose(dset1_id);
 status = H5Dclose(dset2_id);
 status = H5Sclose(space1_id);
 status = H5Sclose(space2_id);
 status = H5Tclose(type1_id);
 status = H5Tclose(type2_id);
 
 return 0;

}



/*-------------------------------------------------------------------------
 * Function: array_diff
 *
 * Purpose: 
 *
 * Return: Success: 0, Failure: -11
 *
 * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
 *
 * Date: October 8, 2002
 *
 * Comments:
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */

 
int array_diff( void *buf1, void *buf2, hsize_t tot_cnt, hid_t type_id, int rank,
																 hsize_t *dims, options_t options )
{
 char   *i1ptr1, *i1ptr2;
 short  *i2ptr1, *i2ptr2;
	int    *i4ptr1, *i4ptr2;
 float  *fptr1, *fptr2;
 double *dptr1, *dptr2;
	int    found = 0;

	/* accumulator and matrix position */
	hsize_t acc[32];
	hsize_t pos[32];
 int i;

 H5T_class_t type_class;
 size_t      type_size;

	acc[rank-1]=1;
	for(i=(rank-2); i>=0; i--)
	{
		acc[i]=acc[i+1]*dims[i+1];
	}

 /* Get the class. */
 type_class = H5Tget_class( type_id );

 /* Get the size. */
 type_size = H5Tget_size( type_id );


 switch(type_class)
 {
  case H5T_INTEGER:


   switch(type_size)
   {

	 /*-------------------------------------------------------------------------
   * H5T_INTEGER 1
   *-------------------------------------------------------------------------
   */

			case 1:
				i1ptr1 = (char *) buf1;
				i1ptr2 = (char *) buf2;
		
				break;

		/*-------------------------------------------------------------------------
   * H5T_INTEGER 2
   *-------------------------------------------------------------------------
   */

			case 2:
				i2ptr1 = (short *) buf1;
				i2ptr2 = (short *) buf2;
			
				break;

		/*-------------------------------------------------------------------------
   * H5T_INTEGER 4
   *-------------------------------------------------------------------------
   */

			case 4:
				i4ptr1 = (int *) buf1;
				i4ptr2 = (int *) buf2;
				for ( i = 0; i < tot_cnt; i++)
				{

					if (*i4ptr1 != *i4ptr2)
					{
						print_pos( i, acc, pos, rank );
						printf(" %d, %d\n", *i4ptr1, *i4ptr2);
						found++;
				
					 if ( options.n_ && found>options.n_number_count-1)
					 	return found;
					}                                               
					i4ptr1++;  i4ptr2++;
				}
				break;
				
							
   } /*switch*/

   
   break; /* H5T_INTEGER */


			case H5T_FLOAT:


   switch(type_size)
   {

		/*-------------------------------------------------------------------------
   * H5T_FLOAT 4
   *-------------------------------------------------------------------------
   */
			case 4:
				fptr1 = (float *) buf1;
				fptr2 = (float *) buf2;
		
				for ( i = 0; i < tot_cnt; i++)
				{
					if ( options.n_ && i>options.n_number_count-1)
						return found;

						/* delta but not percentage */
					if ( options.m_ && !options.p_ )
					{
					 if ( fabs(*fptr1 - *fptr2) > options.m_limit )
						{
							print_pos( i, acc, pos, rank );
							printf(" %f, %f\n", *fptr1, *fptr2);
							found=1;
						}
					}
						
					/* percentage but not delta */
					else if ( !options.m_ && options.p_ )
					{
					 if ( 1 - *fptr1 / *fptr2  > options.p_percent  )
						{
							print_pos( i, acc, pos, rank );
							printf(" %f, %f\n", *fptr1, *fptr2);
							found=1;
						}
					}
			
					/* percentage and delta */
					else if ( options.m_ && options.p_ )
					{
					 if ( 1 - *fptr1 / *fptr2  > options.p_percent &&
							    fabs(*fptr1 - *fptr2) > options.m_limit )
						{
							print_pos( i, acc, pos, rank );
							printf(" %f, %f\n", *fptr1, *fptr2);
							found=1;
						}
					}
					
					else
										
					if (*fptr1 != *fptr2)
					{
						print_pos( i, acc, pos, rank );
						printf(" %f, %f\n", *fptr1, *fptr2);
						found=1;
					}                                               
					fptr1++;  fptr2++;
				}
				break;
	
		/*-------------------------------------------------------------------------
   * H5T_FLOAT 8
   *-------------------------------------------------------------------------
   */

			case 8:
				dptr1 = (double *) buf1;
				dptr2 = (double *) buf2;
			


				break;
						
   } /*switch*/


   
   break; /* H5T_FLOAT */
   
 } /*switch*/
   
 
  return found;
}


/*-------------------------------------------------------------------------
 * Function: print_pos
 *
 * Purpose: conver an array index position to matrix notation
 *
 * Return: pos matrix array
 *
 * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
 *
 * Date: December 19, 2002
 *
 * Comments:
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */



void print_pos( hsize_t curr_pos, hsize_t *acc, hsize_t *pos, int rank )
{
 int i;

	for ( i = 0; i < rank; i++)
	 pos[i]=0;

	for ( i = 0; i < rank; i++)
	{
		pos[i] = curr_pos/acc[i];
		curr_pos -= acc[i]*pos[i];
	}
	assert( curr_pos == 0 );

	printf("[ " );		
	for ( i = 0; i < rank; i++)
	{
		printf("%d ", pos[i]+1  );
	}
	printf("] :" );


}


/*-------------------------------------------------------------------------
 * do some test files 
 *-------------------------------------------------------------------------
 */

int do_test_files()
{

 hid_t   file1_id, file2_id; 
 hid_t   dataset_id;
 hid_t   space_id;  
	hid_t   group_id, group2_id;
 hsize_t dims  [1] = { 7 };
	hsize_t dims2 [2] = { 3,2 };
 int     data1[7] = {1,1,1,1,1,1,1};
 int     data2[7] = {1,1,1,4,5,6,7};
	float   data3[7] = {1,1,3,4,5,6,7};
	float   data4[7] = {1,1,3.02f,4.002f,5.00002f,6,7};
	float   data5[3][2] = {1,1,3,4,5,6};
	float   data6[3][2] = {1,1.1f,3.02f,4.002f,5.00002f,6};

	/* attribute */
	size_t  size_attr = 5;
	float   attr_data1[5] = {1,2,3,4,5};
	float   attr_data2[5] = {1,2.1f,3.01f,4.001f,5.00001f};
 herr_t  status;

/*-------------------------------------------------------------------------
 * Create two files
 *-------------------------------------------------------------------------
 */
  
 /* Create a file */
 file1_id = H5Fcreate ("h5diff_test1.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); 

 /* Create a file */
 file2_id = H5Fcreate ("h5diff_test2.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); 

/*-------------------------------------------------------------------------
 * Make dataset "dset1" on file1
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

 /* Create a dataset "dset1" */
 dataset_id = H5Dcreate(file1_id,"dset1",H5T_NATIVE_INT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_INT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data1);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);

/*-------------------------------------------------------------------------
 * Make dataset "dset3" on file1
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

 /* Create a dataset "dset3" */
 dataset_id = H5Dcreate(file1_id,"dset3",H5T_NATIVE_FLOAT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_FLOAT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data3);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);

/*-------------------------------------------------------------------------
 * Make group "g1" on file1
 *-------------------------------------------------------------------------
 */

	/* Create a group. */
 group_id = H5Gcreate(file1_id, "g1", 0);

 /* Close */
 status = H5Gclose(group_id);


/*-------------------------------------------------------------------------
 * Make dataset "dset1" on file2
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

 /* Create a dataset "dset1" */
 dataset_id = H5Dcreate(file2_id,"dset1",H5T_NATIVE_INT,space_id,H5P_DEFAULT);

 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_INT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data2);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);


	/*-------------------------------------------------------------------------
 * Make dataset "dset2" on file2
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

 /* Create a dataset "dset1" */
 dataset_id = H5Dcreate(file2_id,"dset2",H5T_NATIVE_INT,space_id,H5P_DEFAULT);

 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_INT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data2);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);


/*-------------------------------------------------------------------------
 * Make dataset "g1/dset1" on file2
 *-------------------------------------------------------------------------
 */

	/* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

	/* Create a group. */
 group_id = H5Gcreate(file2_id, "g1", 0);

	/* Create a dataset "g1/dset1" */
 dataset_id = H5Dcreate(group_id,"dset1",H5T_NATIVE_INT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_INT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data2);

 /* Close */
	status = H5Dclose(dataset_id);
 status = H5Gclose(group_id);
	status = H5Sclose(space_id);

/*-------------------------------------------------------------------------
 * Make group "g2/g1" on file2
 *-------------------------------------------------------------------------
 */

	/* Create a group. */
 group_id = H5Gcreate(file2_id, "g2", 0);
	group2_id = H5Gcreate(group_id, "g1", 0);

 /* Close */
 status = H5Gclose(group_id);
	status = H5Gclose(group2_id);

/*-------------------------------------------------------------------------
 * Make dataset "dset4" on file2
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(1,dims,NULL);

 /* Create a dataset "dset" */
 dataset_id = H5Dcreate(file2_id,"dset4",H5T_NATIVE_FLOAT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_FLOAT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data4);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);

/*-------------------------------------------------------------------------
 * Make dataset "dset5" on file1
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(2,dims2,NULL);

 /* Create a dataset "dset" */
 dataset_id = H5Dcreate(file1_id,"dset5",H5T_NATIVE_FLOAT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_FLOAT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data5);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);

/*-------------------------------------------------------------------------
 * Make dataset "dset6" on file2
 *-------------------------------------------------------------------------
 */

 /* Create a data space  */
 space_id = H5Screate_simple(2,dims2,NULL);

 /* Create a dataset "dset" */
 dataset_id = H5Dcreate(file2_id,"dset6",H5T_NATIVE_FLOAT,space_id,H5P_DEFAULT);
  
 /* Write the data */
 status = H5Dwrite(dataset_id,H5T_NATIVE_FLOAT,H5S_ALL,H5S_ALL,H5P_DEFAULT,data6);

 /* Close */
 status = H5Dclose(dataset_id);
 status = H5Sclose(space_id);
	
/*-------------------------------------------------------------------------
 * Close files
 *-------------------------------------------------------------------------
 */
 status = H5Fclose(file1_id);
 status = H5Fclose(file2_id);


 return 0;


}