/* write example NeXus/HDF data file using the napi.c library */

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef __MWERKS__
#include <console.h>
#include <sioux.h>
#endif

#define ENTRY_CLASS 	"NXentry"		/* name of all proper entrys */
#define SCAN_CLASS		"NXdata"		/* name of all proper data1 scans */
#define DEFAULT_CLASS	"NXdefault"		/* name of all proper data1 scans */
#define INSTRUMENT_CLASS "NXinstrument"	/* name of class for all instrument Vgroups */
#define SAMPLE_CLASS	"NXsample"		/* name of class for all sample Vgroups */

#define PI			3.14159265
#define CCDXY		32					/* small use 32, big use 64 */
#define CCDZ		3					/* small use 3,  big use 11 */

#include "napi.h"

#define LOCATION		"APS:6-BM-R"
#define PROG_NAM		"ORDIF"
#define VERSION			"0.2 alpha"

#define SECONDS(X)	( ((float)(clock()-X))/((float)CLOCKS_PER_SEC) )
clock_t startTick;

int reOpenTest(char *file_name, int num, int ientry_start);
void write100scan(NXhandle file_id, int ientry);
void NXstring(NXhandle file_id, char *name, char *str);
void NXputStringAttr(NXhandle file_id, char *name, char *str);

void main(int argc, char *argv[])
{

	NXhandle	file_id;

	int32		dims[10];
	int32		j, ii, iii;
	int			i;								/* index of loops [0,dim] */
	float32		x;
	int			one=1;							/* a 32 bit one, used with DFNT_INT32 */
	int			two=2;							/* a 32 bit two, used with DFNT_INT32 */
	int			three=3;						/* a 32 bit three, used with DFNT_INT32 */
	char		equation[255];
	char		*file_name = "Nexamples.hdf";
	char		*user_name = "John Q. Public";
	char		*user_mail = "Chemistry Dept.\rBerkeley U.\r CA  11111";
	char		*user_email = "joe@pdp8.chem.mit.edu";
	char		*user_phone = "900-555-1212";
	char		*user_fax = "900-555-1213";

	float32		*CCD_x_axis,*CCD_y_axis;
	int16		***ccd_data;

	float32		gain1, gain2;
	float32		hkl_near[3];

	float32		mono_energy[501];
	float32		theta[51];
	float32		ttheta[51];
	float32		chi[51];
	float32		phi[51];
	float32		h1[360], k1[360], l1[360];
	int32		ic1[501];
	int32		ic2[501];
	int32		scint[360];
	float32		computed[501];

	float32		h1a[21][21], k1a[21][21], l1a[21][21];
	int32		ic1a[21][21];
	float32		computeda[21][21];

	clock_t		endTick;
	int			time_test=0;

	#ifdef __MWERKS__
	argc = ccommand(&argv); 
	SIOUXSettings.autocloseonquit = FALSE;
	SIOUXSettings.asktosaveonclose = TRUE;
	SIOUXSettings.columns = 80;
	SIOUXSettings.rows = 50;
	#endif

/*
 *	if (argc<2) { printf("must use 'new' or 'old' in command line\r"); exit(1);}
 *	printf("argv[0] = '%s'",argv[0]);
 *	for (i=1;i<argc;i++) {
 *		printf("       argv[%d] = '%s'",i,argv[i]);
 *		if (strcmp(argv[i],"new")==0) new_help = 1;
 *		if (strcmp(argv[i],"old")==0) new_help = 0;
 *	}
 *	printf("\r");
 *	if (new_help<0) { printf("must use 'new' or 'old' in command line\r"); exit(1);}
 *
 *	if (new_help) strcpy(file_name,"Nexamples-new.hdf");
 *	else strcpy(file_name,"Nexamples-old.hdf");
 */

	time_test = 0;
	if (argc>1) {
		if (strcmp(argv[1],"time")==0) time_test = 1;
		printf(" argv[0] = '%s'\r",argv[1]);
	}
	printf("argc = %d,    time_test = %d\r",argc,time_test);


/* Open output file and output global attributes */
	printf("opening file\r");
	startTick = clock();
	NXopen (file_name, NXACC_CREATE, &file_id);
	NXputStringAttr(file_id,"user_name",user_name);
	NXputStringAttr(file_id,"location",LOCATION);
	NXputStringAttr(file_id,"program_name",PROG_NAM);
	NXputStringAttr(file_id,"user_mail",user_mail);
	NXputStringAttr(file_id,"user_email",user_email);
	NXputStringAttr(file_id,"user_phone",user_phone);
	NXputStringAttr(file_id,"user_fax",user_fax);

/* entry1,  The maximally minimal entry. */

	printf("\r\rstarting 'entry1'\r");
	NXmakegroup (file_id, "Entry1", "NXentry");
	NXopengroup (file_id, "Entry1", "NXentry");
	NXstring(file_id, "date", "22-feb-1996");
	NXstring(file_id, "hour", "23:59:59.00 UT");
	NXstring(file_id, "entry_analysis", "NONE");
	NXstring(file_id, "entry_intent", "misc");
	NXclosegroup (file_id);

/* entry2,  A simple EXAFS scan with log ratio stored in data file. */

	printf("\r\rstarting 'entry2'\r");
	for (i=0;i<501;i++) {				/* make a dummy scan of 501 points */
		mono_energy[i] = 20. + .001 * i;
		ic1[i] = 200000;
		ic2[i] = 100000 + 2*i;
	}
	dims[0]=501;						/* scan of 501 points, rank=1 */
	gain1 = gain2 = 1.e8;

	NXmakegroup (file_id, "Entry2", "NXentry");
	NXopengroup (file_id, "Entry2", "NXentry");
	NXstring(file_id, "date", "23-feb-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "00:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "data");
	NXstring(file_id, "entry_intent", "NONE");
	NXstring(file_id, "title", "Mo K-edge");
	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");

	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);

	NXmakedata (file_id, "ic1", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1);
	NXputStringAttr(file_id,"units","photons");
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);

	NXmakedata (file_id, "ic2", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic2");
	NXputdata (file_id, ic2);
	NXputStringAttr(file_id,"units","photons");
	NXputattr (file_id, "gain", &gain2, 1, DFNT_FLOAT32);
	NXputattr (file_id, "signal", &two, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &two, 1, DFNT_INT32);

	for (i=0;i<dims[0];i++) { computed[i] = log( (float) ic2[i]/ic1[i]); }
	strcpy(equation,"log(ic2/ic1)");
	NXmakedata (file_id, "corrected_signal", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "corrected_signal");
	NXputdata (file_id, computed);
	NXputStringAttr(file_id,"equation",equation);
	NXputStringAttr(file_id,"units",equation);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXclosegroup (file_id);
	NXclosegroup (file_id);

/*
 * entry3,  A theta scan of CCDZ-1 intervals with one counter and one CCD image
 * saved at each point (CCDXY x CCDXY).
 */
	printf("\r\rstarting 'entry3'\r");
	CCD_x_axis = calloc(CCDXY,sizeof(float32));		/* allocate space for CCD scan */
	CCD_y_axis = calloc(CCDXY,sizeof(float32));
	ccd_data = (int16 ***)calloc(CCDZ,sizeof(int16**));
	for (i=0;i<CCDXY;i++) {
		ccd_data[i] = (int16 **)calloc(CCDXY,sizeof(int16*));
		for (ii=0;ii<CCDXY;ii++) ccd_data[i][ii] = (int16 *)calloc(CCDXY,sizeof(int16));
	}
	for (i=0;i<CCDXY;i++) CCD_x_axis[i] = CCD_y_axis[i] = i*0.05;	/* pixel distance */
	for (i=0;i<CCDZ;i++) {				/* make a dummy scan of CCDZ points */
		theta[i] = 10.+ i;
		ic1[i] = 200000;
		scint[i] = 250 + i;
		for (ii=0;ii<CCDXY;ii++) {
			for (iii=0;iii<CCDXY;iii++) ccd_data[i][ii][iii] = 1000*i + 100*ii + iii;
		}
	}
	dims[0]=CCDZ;
	dims[1]=dims[2]=CCDXY;

	NXmakegroup (file_id, "Entry3", "NXentry");
	NXopengroup (file_id, "Entry3", "NXentry");

	NXstring(file_id, "date", "23-Feb-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "02:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "diffraction/misc");
	NXstring(file_id, "entry_intent", "data");
	NXstring(file_id, "title", "fancy CCD scan");
	NXstring(file_id, "constraint", "delta_h = delta_k = delta_l");
	mono_energy[0] = 8.047;
	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, &one);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");

	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");

	NXmakedata (file_id, "theta", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "theta");
	NXputdata (file_id, theta);
	NXputStringAttr(file_id,"units","degrees");
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);

	NXmakedata (file_id, "ic1", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1);
	NXputStringAttr(file_id,"units","photons");
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);

	NXmakedata (file_id, "scint", DFNT_INT32, 1, dims);
	NXopendata (file_id, "scint");
	NXputdata (file_id, scint);
	NXputStringAttr(file_id,"units","photons");
	NXputStringAttr(file_id,"long_name","flourescence detector");

	NXmakedata (file_id, "CCD", DFNT_INT16, 3, dims);
	NXopendata (file_id, "CCD");
	NXputdata (file_id, ccd_data);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"long_name","CCD detector");
	NXputStringAttr(file_id,"units","photons");

	NXmakedata (file_id, "CCD_x_axis", DFNT_FLOAT32, 1, &(dims[1]));
	NXopendata (file_id, "CCD_x_axis");
	NXputdata (file_id, CCD_x_axis);
	NXputStringAttr(file_id,"units","mm");
	NXputattr (file_id, "axis", &two, 1, DFNT_INT32);

	NXmakedata (file_id, "CCD_y_axis", DFNT_FLOAT32, 1, &(dims[2]));
	NXopendata (file_id, "CCD_y_axis");
	NXputdata (file_id, CCD_y_axis);
	NXputStringAttr(file_id,"units","mm");
	NXputattr (file_id, "axis", &three, 1, DFNT_INT32);

/*	dim_id = SDgetdimid(Dsid[Did],2);
	i = SDsetdimscale(dim_id,dims[1],DFNT_FLOAT32,(VOIDP) CCD_x_axis);
	dim_id = SDgetdimid(Dsid[Did],3);
	i = SDsetdimscale(dim_id,dims[2],DFNT_FLOAT32,(VOIDP) CCD_y_axis);
*/

/*	 Note, for a CCD there is more information to stored.  So, it is best to
 *	create another Vgroup called "CCD_spec", and attach it to the Vgroup vgN
 *	(not to vgD).  In this new Vgroup make numerous simple SDS's, one for each
 *	piece of information.  The reason for using SDS's is so that you can attach
 *	dimensions to the information.  For example to store an sid which refers
 *	to a dark current exposure, or distance from the CCD to the sample, etc.
 */

	NXclosegroup (file_id);
	NXclosegroup (file_id);

/* entry4,  A line in hkl space.  The scan direction is along the [111] */

	printf("\r\rstarting 'entry4'\r");
	for (i=0;i<51;i++) {				/* make a dummy scan of 51 points */
		theta[i] = 10. + .02*i;
		ttheta[i] = 2*theta[i];
		chi[i] = 45.;
		phi[i] = 20.;
		h1[i] = k1[i] = l1[i] = 1. + i*0.002;
		ic1[i]  = 2000000;
		x = theta[i]-10.5;
		scint[i] = 3000. * exp(-(x*x/.1));
	}
	dims[0]=51;

	NXmakegroup (file_id, "Entry4", "NXentry");
	NXopengroup (file_id, "Entry4", "NXentry");

	NXstring(file_id, "date", "25-Feb-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "02:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "diffraction/misc");
	NXstring(file_id, "entry_intent", "data");
	NXstring(file_id, "title", "along the [111] direction");
	NXstring(file_id, "constraint", "delta_h = delta_k = delta_l");
	mono_energy[0] = 8.047;
	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, &one);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");

	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");

	NXmakedata (file_id, "theta", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "theta");
	NXputdata (file_id, theta);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "2theta", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "2theta");
	NXputdata (file_id, ttheta);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "chi", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "chi");
	NXputdata (file_id, chi);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "phi", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "phi");
	NXputdata (file_id, phi);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "h1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "h1");
	NXputdata (file_id, h1);

	NXmakedata (file_id, "k1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "k1");
	NXputdata (file_id, k1);

	NXmakedata (file_id, "l1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "l1");
	NXputdata (file_id, l1);

	for (i=0;i<dims[0];i++) { computed[i] = sqrt(h1[i]*h1[i]+k1[i]*k1[i]+l1[i]*l1[i]); }
	strcpy(equation,"sqrt(h^2+k^2+l^2)");
	NXmakedata (file_id, "x-axis", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "x-axis");
	NXputdata (file_id, computed);
	NXputStringAttr(file_id,"equation",equation);
	NXputStringAttr(file_id,"units",equation);
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"long_name","distance along [111]");

	NXmakedata (file_id, "ic1", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1);
	NXputStringAttr(file_id,"units","photons");
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);

	NXmakedata (file_id, "scint", DFNT_INT32, 1, dims);
	NXopendata (file_id, "scint");
	NXputdata (file_id, scint);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");
	NXputStringAttr(file_id,"analyzer","Ge111");

	NXclosegroup (file_id);
	NXclosegroup (file_id);

/* entry5,  A surface in hkl space.  The scan directions are along

	the [100] and [011] */
	printf("\r\rstarting 'entry5'\r");
	for (j=0;j<21;j++) {				/* make a dummy scan of 21 x 21 points */
		for (i=0;i<21;i++) {
			h1a[j][i] = 1. + .1*j;
			k1a[j][i] = l1a[j][i] = 1. + .05*i;
			ic1a[j][i] = 20000;
			x = (i-10)*(i-10) /5. + (j-10)*(j-10)/5.;
			scint[i] = 1000. * exp(-x);
		}
	}
	dims[0]=dims[1]=21;

	NXmakegroup (file_id, "Entry5", "NXentry");
	NXopengroup (file_id, "Entry5", "NXentry");

	NXstring(file_id, "date", "25-Feb-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "03:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "diffraction/misc");
	NXstring(file_id, "entry_intent", "data");
	NXstring(file_id, "title", "the perpendicular surface");
	NXstring(file_id, "constraint", "perpendicular to (0 -1 1)");
	mono_energy[0] = 8.047;
	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, &one);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");

	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");

	NXmakedata (file_id, "h", DFNT_FLOAT32, 2, dims);
	NXopendata (file_id, "h");
	NXputdata (file_id, h1a);
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);

	NXmakedata (file_id, "k", DFNT_FLOAT32, 2, dims);
	NXopendata (file_id, "k");
	NXputdata (file_id, k1a);

	NXmakedata (file_id, "l", DFNT_FLOAT32, 2, dims);
	NXopendata (file_id, "l");
	NXputdata (file_id, l1a);

	for (j=0;j<dims[0];j++) {
		for (i=0;i<dims[1];i++) {
			computeda[j][i] = sqrt(k1a[j][i]*k1a[j][i]+l1a[j][i]*l1a[j][i]);
		}
	}

	NXmakedata (file_id, "y-axis", DFNT_FLOAT32, 2, dims);
	NXopendata (file_id, "y-axis");
	strcpy(equation,"sqrt(k*k+l*l)");
	NXputdata (file_id, computeda);
	NXputStringAttr(file_id,"equation",equation);
	NXputStringAttr(file_id,"long_name","distance along [011]");
	NXputattr (file_id, "axis", &two, 1, DFNT_INT32);

	NXmakedata (file_id, "ic1", DFNT_INT32, 2, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1a);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");

	NXmakedata (file_id, "scint", DFNT_INT32, 2, dims);
	NXopendata (file_id, "scint");
	NXputdata (file_id, scint);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");

	NXclosegroup (file_id);
	NXclosegroup (file_id);

/* entry6,  A circle in hkl space, with points every degree. */

	printf("\r\rstarting 'entry6'\r");
	for (i=0;i<360;i++) {				/* make a dummy scan of 360 points */
		x = i * PI/180.;
		h1[i] = .1 * cos(x);
		k1[i] = .1 * sin(x);
		l1[i] = 2.;
		ic1[i] = 200000;
		scint[i] = pow(sin(x),5.);
	}
	dims[0]=360;


	NXmakegroup (file_id, "Entry6", "NXentry");
	NXopengroup (file_id, "Entry6", "NXentry");

	NXstring(file_id, "date", "25-Feb-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "02:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "diffraction/misc");
	NXstring(file_id, "entry_intent", "data");
	NXstring(file_id, "title", "t0.1 rad circle about (002)");
	NXstring(file_id, "constraint", "|(hkl)-(002)|=.1 and (hkl)-(002) perpendicular to (002)");
	mono_energy[0] = 8.047;
	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, &one);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");

	hkl_near[0]=0;  hkl_near[1]=0;  hkl_near[2]=2;
	dims[0]=3;
	NXmakedata (file_id, "hkl_near", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "hkl_near");
	NXputdata (file_id, hkl_near);

	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");
	dims[0]=360;

	NXmakedata (file_id, "h1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "h1");
	NXputdata (file_id, h1);

	NXmakedata (file_id, "k1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "k1");
	NXputdata (file_id, k1);

	NXmakedata (file_id, "l1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "l1");
	NXputdata (file_id, l1);


	for (i=0;i<dims[0];i++) { computed[i] = i; }
	strcpy(equation,"angle");
	NXmakedata (file_id, "circle", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "circle");
	NXputdata (file_id, computed);
	NXputStringAttr(file_id,"equation",equation);
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"long_name","angle on circle");
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "ic1", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);
	i = 1;
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");

	NXmakedata (file_id, "scint", DFNT_INT32, 1, dims);
	NXopendata (file_id, "scint");
	NXputdata (file_id, scint);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");

	NXclosegroup (file_id);
	NXclosegroup (file_id);


	printf("\r\rcalling end routines and closing the file\r");
	endTick = clock();
  	NXclose (&file_id);
	printf (" call to NXclose took %.2f sec\r",SECONDS(endTick));
 	printf ("execution to here took %.2f sec\r",SECONDS(startTick));


/* Now test reopening the file and writing some more */
/* open the file for Vset and SD */

	if (time_test) {
		i = 7;
		while(i<15) {
			i = reOpenTest(file_name,3,i);
		}
	}

	printf ("total execution took %.2f sec\a\r",SECONDS(startTick));
}





int reOpenTest(char *file_name, int num, int ientry_start)
{
	NXhandle	file_id;
	clock_t		endTick;
	int			ientry;

/* a test of re-re-opening the file and writing some more */
/* open the file for Vset and SD */
	printf("re-opening test of file\r");
	NXopen (file_name, NXACC_RDWR, &file_id);

	for (ientry=ientry_start;ientry<ientry_start+num;ientry++) {
		write100scan(file_id,ientry);
	}

	printf("\r\rcalling end routines and closing the file\r");
	endTick = clock();
	NXclose (&file_id);
	printf (" call to NXclose took %.2f sec\r",SECONDS(endTick));
	printf ("execution to here took %.2f sec\r",SECONDS(startTick));
	return ientry;
}
void write100scan(NXhandle file_id, int ientry)
{
	int32		dims[10];
	int			i;								/* index of loops [0,dim] */
	float32		x;
	int			one=1;							/* a 32 bit one, used with DFNT_INT32 */
	char		entName[80];
	float32		gain1;

	float32		mono_energy[501];
	float32		theta[51];
	float32		ttheta[51];
	float32		chi[51];
	float32		phi[51];
	float32		h1[51], k1[51], l1[51];
	int32		ic1[51];
	int32		scint[51];

	sprintf(entName,"entry%d",ientry);

/* entry_ientry,  A line in hkl space.  The scan direction is along the [100] */
	printf("\r\rstarting '%s'\r",entName);
	for (i=0;i<51;i++) {				/* make a dummy scan of 51 points */
		theta[i] = 10. + .02*i;
		ttheta[i] = 2*theta[i];
		chi[i] = 45.;
		phi[i] = 20.;
		h1[i] = 1. + i*0.002;
		k1[i] = l1[i] = 2.;
		ic1[i]  = 2000000;
		x = theta[i]-10.5;
		scint[i] = 3000. * exp(-(x*x/.1));
	}
	dims[0]=51;

	NXmakegroup (file_id, entName, "NXentry");
	NXopengroup (file_id, entName, "NXentry");

	NXstring(file_id, "date", "25-Apr-1996");		/* data for whole entry */
	NXstring(file_id, "hour", "05:10:59.10 -7");
	NXstring(file_id, "entry_analysis", "diffraction/misc");
	NXstring(file_id, "entry_intent", "data");
	NXstring(file_id, "title", "along the [111] direction");
	NXstring(file_id, "constraint", "delta_h = delta_k = delta_l");
	mono_energy[0] = 8.047;
	NXmakedata (file_id, "mono_energy", DFNT_FLOAT32, 1, &one);
	NXopendata (file_id, "mono_energy");
	NXputdata (file_id, mono_energy);
	NXputStringAttr(file_id,"units","keV");

	NXmakegroup (file_id, "Data1", "NXdata");
	NXopengroup (file_id, "Data1", "NXdata");

	NXmakedata (file_id, "theta", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "theta");
	NXputdata (file_id, theta);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "2theta", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "2theta");
	NXputdata (file_id, ttheta);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "chi", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "chi");
	NXputdata (file_id, chi);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "phi", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "phi");
	NXputdata (file_id, phi);
	NXputStringAttr(file_id,"units","degrees");

	NXmakedata (file_id, "h1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "h1");
	NXputdata (file_id, h1);
	NXputattr (file_id, "axis", &one, 1, DFNT_INT32);

	NXmakedata (file_id, "k1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "k1");
	NXputdata (file_id, k1);

	NXmakedata (file_id, "l1", DFNT_FLOAT32, 1, dims);
	NXopendata (file_id, "l1");
	NXputdata (file_id, l1);

	NXmakedata (file_id, "ic1", DFNT_INT32, 1, dims);
	NXopendata (file_id, "ic1");
	NXputdata (file_id, ic1);
	NXputStringAttr(file_id,"units","photons");
	NXputattr (file_id, "I_monitor", &one, 1, DFNT_INT32);
	NXputattr (file_id, "gain", &gain1, 1, DFNT_FLOAT32);

	NXmakedata (file_id, "scint", DFNT_INT32, 1, dims);
	NXopendata (file_id, "scint");
	NXputdata (file_id, scint);
	NXputattr (file_id, "signal", &one, 1, DFNT_INT32);
	NXputattr (file_id, "primary", &one, 1, DFNT_INT32);
	NXputStringAttr(file_id,"units","photons");
	NXputStringAttr(file_id,"analyzer","Ge111");

	NXclosegroup (file_id);
	NXclosegroup (file_id);
	return;
}










void NXstring(
	NXhandle	file_id,
	char		*name,		/* name of string to write */
	char		*str)		/* value of string to write */
{
	long nd;			/* length of string */
	nd = strlen(str);
	NXmakedata (file_id, name, DFNT_CHAR8, 1, &nd);
	NXopendata (file_id, name);
	NXputdata (file_id, str);
	return;
}

void NXputStringAttr(
	NXhandle	file_id,
	char		*name,		/* name of string to write */
	char		*str)		/* value of string to write */
{
	NXputattr(file_id, name, str, strlen(str), DFNT_CHAR8);
	return;
}