xmd Code

/*
xmd - molecular dynamics for metals and ceramics
By Jonathan Rifkin <jon.rifkin@uconn.edu>
Copyright 1995-2004 Jonathan Rifkin

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/


/*  READ AND WRITE CMD STATE	*/

/*
************************************************************************
History
************************************************************************
*/
/*
2009-09-26 - To avoid warning, save fread() return value.
*/

/*
************************************************************************
Compiler Switches
************************************************************************
*/


/*
************************************************************************
File Includes
************************************************************************
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "particle.h"
#include "cdalloc.h"
#include "cdhouse.h"
#include "cdsubs.h"

/*
************************************************************************
Defines
************************************************************************
*/
#define BOOLEAN int
#define TRUE 1
#define FALSE 0

#define ENDIAN_TEST_VALUE 1

/*  Version and release of state file	*/
#define STATE_VERSION 1
#define STATE_RELEASE 5


/*
************************************************************************
Macros
************************************************************************
*/
#define WRITE_SCALAR(FILE,SCALAR) \
	fwrite (&SCALAR, sizeof(SCALAR), 1, FILE);

#define WRITE_ARRAY(FILE,ARRAY, N) \
	fwrite (ARRAY, sizeof(ARRAY[0]), N, FILE);


#define READ_SCALAR(FILE,SCALAR) \
	fread_return_m = fread (&SCALAR, sizeof(SCALAR), 1, FILE);

#define READ_ARRAY(FILE, ARRAY, N) \
	fread_return_m = fread (ARRAY, sizeof(ARRAY[0]), N, FILE);



/*
************************************************************************
Global Variables
************************************************************************
*/
extern int	XMD_Version_g;
extern int	XMD_Release_g;

/*
************************************************************************
Module-Wide variables
************************************************************************
*/
static int StateVersion_m = STATE_VERSION;
static int StateRelease_m = STATE_RELEASE;
static int InputStateVersion_m;
static int InputStateRelease_m;
size_t fread_return_m;

/*
************************************************************************
Local Function Prototypes
************************************************************************
*/
void writearray  (size_t, void  *, size_t, FILE *);
void readarray   (void **, FILE *);
void ReadParticleStructure  (Particle_t *, FILE *);
void WriteParticleStructure (Particle_t *, FILE *);
void ReadSimulationStructure	(Simulation_t *, FILE *);
void WriteSimulationStructure (Simulation_t *, FILE *);
void WriteVersion (FILE *);
void ReadVersion	(FILE *);
void WriteUserInfo(FILE *);
void ReadUserInfo (FILE *);
void WriteStringToBinaryFile	(FILE *, char *);
void ReadStringFromBinaryFile (FILE *, char *, int);
void WriteTitle	(FILE *, Particle_t *);
void ReadTitle 	(FILE *, Particle_t *);
void WriteDelimiter (FILE *);
void ReadDelimiter  (FILE *);

void WriteExternalVector (int NumVector, ExternalVector_t **Vector, FILE *fout);
void ReadExternalVector  (ExternalVector_t ***Vector, FILE *fin);


/*
************************************************************************
Exported Routines
************************************************************************
*/

/*  WRITE STATE  */
void writestate (Particle_t *a, Simulation_t *s, char *fname)
	{
	int i;
	int TestWord = ENDIAN_TEST_VALUE;
	BOOLEAN TempBoolean;

	/*  DECLARE AND SET ARRAY SIZES	*/
	size_t np = a->np;
	size_t ng = a->ng;

	/*  OPEN OUTPUT FILE  */
	FILE *fout = fopen (fname, "wb");
	if (fout==NULL)
		return;


	/*  Write user readable info	*/

	/*  Write user readable version information	*/
	WriteUserInfo (fout);

	/* Write title */
	WriteTitle (fout, a);

	/*  Write ascii text delimiter  */
	WriteDelimiter (fout);


	/*  Write machine info	*/

	/*
	Write test word
	(to be used by computer reading file to check "endian" type)
	*/
	WRITE_SCALAR (fout, TestWord);

	/*  Write version information  */
	WriteVersion (fout);

	/*  WRITE ARRAY SIZES  */
	fwrite (&np, sizeof(np), 1, fout);
	fwrite (&ng, sizeof(ng), 1, fout);

	/*  STORE STRUCTURES  */
	WriteParticleStructure	 (a, fout);
	WriteSimulationStructure (s, fout);

	/*  WRITE PARTICLE ARRAYS	*/
	writearray	(3 * np, (void  *) a->cur, 	sizeof(a->cur	[0]), fout);
	writearray	(3 * np, (void  *) a->ref, 	sizeof(a->ref	[0]), fout);
	writearray	(3 * np, (void  *) a->ngh, 	sizeof(a->ngh	[0]), fout);
	writearray	(3 * np, (void  *) a->v,		sizeof(a->v 	[0]), fout);
	writearray	(3 * np, (void  *) a->f,		sizeof(a->f 	[0]), fout);
	writearray	(3 * np, (void  *) a->c2 , 	sizeof(a->c2	[0]), fout);
	writearray	(3 * np, (void  *) a->c3 , 	sizeof(a->c3	[0]), fout);
	writearray	(3 * np, (void  *) a->c4 , 	sizeof(a->c4	[0]), fout);
	writearray	(3 * np, (void  *) a->c5 , 	sizeof(a->c5	[0]), fout);
	writearray	(	  np, (void  *) a->type,	sizeof(a->type [0]), fout);
	writearray	(	  np, (void  *) a->rtype,	sizeof(a->rtype[0]), fout);
	writearray	(	  np, (void  *) a->mass,	sizeof(a->mass [0]), fout);
	writearray	(	  np, (void  *) a->eatom,	sizeof(a->eatom[0]), fout);
	writearray	(	  np, (void  *) a->tag, 	sizeof(a->tag	[0]), fout);
	writearray	(	  np, (void  *) a->Selection, sizeof(a->Selection[0]), fout);


	/*  Write ExternalVector_t structures	*/
/*test*/
#if 0
	WriteExternalVector ( np, a->ForcePtrList,	fout);
	WriteExternalVector ( np, a->SpringPtrList, fout);
#endif

	/*  Write Temp CLAMP info  */
	LOOP (i, NUM_CLAMP_TAG)
		WRITE_SCALAR(fout,a->UseClamp[i])
	LOOP (i, NUM_CLAMP_TAG)
		WRITE_SCALAR(fout,a->ClampTemp[i])
	LOOP (i, NUM_CLAMP_TAG)
		WRITE_SCALAR(fout,a->ClampStep[i])

	/*  
	Write Volume CLAMP info 
	( a->UseVolClamp replaced by a->BoxMotionAlgorithm==BMA_CLAMP )
	 */
	TempBoolean = (a->BoxMotionAlgorithm==BMA_CLAMP);
	WRITE_SCALAR(fout, TempBoolean);
	WRITE_SCALAR(fout, a->VolClampStep)
	WRITE_SCALAR(fout, a->BulkModulus)

#if 0
	writearray
		(NUM_CLAMP_TAG, (void  *) &(a->UseClamp[0]), sizeof(a->UseClamp [0]), fout);
	writearray
		(NUM_CLAMP_TAG, (void  *) &(a->ClampTemp[0]),sizeof(a->ClampTemp[0]), fout);
	writearray
		(NUM_CLAMP_TAG, (void  *) &a->ClampStep,sizeof(a->ClampStep[0]), fout);
#endif


	/*  Write pressure info  */
	WRITE_SCALAR(fout, a->BoxMotionGeometry)
	WRITE_SCALAR(fout, a->BoxMotionAlgorithm)
	WRITE_SCALAR(fout, a->EpotBox)
	WRITE_SCALAR(fout, a->BulkModulus)
	WRITE_SCALAR(fout, a->VolClampStep)
		
	WRITE_ARRAY (fout, a->Pressure,  NDIR)
	WRITE_ARRAY (fout, a->EkinBox,   NDIR)
	WRITE_ARRAY (fout, a->BoxMotion, NDIR*NDERIV)
	WRITE_ARRAY (fout, a->BoxForce,  NDIR)
	WRITE_ARRAY (fout, a->BoxMass,   NDIR)

	/*  Close output file  */
	fclose(fout);
}



int  
readstate
(
Particle_t **InputParticleStructure,
Simulation_t *s,
char *fname
)
	{
	size_t np;
	size_t ng;
	FILE *fin;
	int  TestWord;
	int  i;
	BOOLEAN IsInitializedPotential;
	BOOLEAN TempBoolean;
	Particle_t *a = *InputParticleStructure;

	/*  Save potential status  */
	IsInitializedPotential = a->IsInitializedPotential;

	/*  Open input file	*/
	fin = fopen (fname, "rb");
	if (fin==NULL)
		{
		ERROR_PREFIX
		printf ("Cannot open file <%s>\n", fname);
		CleanAfterError();
		}

	/*  Read user readable info  */

	/*  Read user readable version information  */
	ReadUserInfo (fin);

	/* Read title */
	ReadTitle (fin, a);

	/*  Read ascii text delimiter  */
	ReadDelimiter (fin);


	/*  Machine readable info	*/

	/*  Check "endian" type  */
	READ_SCALAR (fin, TestWord);

	if (TestWord != ENDIAN_TEST_VALUE)
		{
		ERROR_PREFIX
		printf ("State file was written by incompatible computer.\n");
		printf ("  (Wrong endian type.\n");
		CleanAfterError();
		}

	/*  Read Version Information	*/
	ReadVersion (fin);

	/*  Free arrays inside particle structure  */
	pfree (a);

	/*  Free particle structure itself	*/
	FREE (a)

	/*  READ ARRAY SIZES  */
	fread_return_m = fread (&np, sizeof(np), 1, fin);
	fread_return_m = fread (&ng, sizeof(ng), 1, fin);

	/*
	Allocate new particle structure
	(and set global value of limits of number of particles and neighbors)
	*/
	/*  Set initial neighbor array to small value  */
	a = palloc (np, 4);

	/*  Read particle record  */
	ReadParticleStructure (a, fin);

	/* Read simulation record */
	ReadSimulationStructure (s, fin);

	/*  Original data for stat file version 1 release 0  */

	/*  READ  PARTICLE ARRAYS	*/
	readarray  ( (void  **) &a->cur, 	fin);
	readarray  ( (void  **) &a->ref, 	fin);
	readarray  ( (void  **) &a->ngh, 	fin);
	readarray  ( (void  **) &a->v,		fin);
	readarray  ( (void  **) &a->f,		fin);
	readarray  ( (void  **) &a->c2,		fin);
	readarray  ( (void  **) &a->c3,		fin);
	readarray  ( (void  **) &a->c4,		fin);
	readarray  ( (void  **) &a->c5,		fin);
	readarray  ( (void  **) &a->type,	fin);
	readarray  ( (void  **) &a->rtype,	fin);
	readarray  ( (void  **) &a->mass,	fin);
	readarray  ( (void  **) &a->eatom,	fin);

	/*  Determine if masses are initialized  */
	a->IsInitializedMass = (a->mass != NULL);

	/*  Attempt to read data previous to version.release 1.2  */
	if (InputStateVersion_m==1 && InputStateRelease_m<2)
		{
		int i;
		BYTE *sel = NULL;
		BYTE *set = NULL;
		BYTE *fix = NULL;
		
		/*  Read temp and perm arrays  */
		readarray  ( (void  **) &sel	    , fin);
		readarray  ( (void  **) &a->tag	 , fin);
		readarray  ( (void  **) &set	    , fin);
		readarray  ( (void  **) &fix	    , fin);

		/*  Combine sel, set and fix into *Selection  */
		/*  Read set data into Selection[]  */
		if (set!=NULL)
			{
			LOOP (i, np)
				a->Selection[i] = set[i];
			}

		/*  Merge sel data into Selection[]  */
		if (sel!=NULL)
			{
			LOOP (i, np)
				{
				REMOVE_SELECT(i)
				if (sel[i])
					APPLY_SELECT(i)
				}
			}

		/*  Merge fix data into Selection[]  */
		if (fix!=NULL)
			{
			LOOP (i, np)
				{
				REMOVE_FIX(i)
				if (fix[i])
					APPLY_FIX(i)
				}
			}


		/*  Free temporary storage  */
		FREE(sel)
		FREE(set)
		FREE(fix)
		}

	else
		{
		readarray  ( (void  **) &a->tag	 , fin);
		readarray  ( (void  **) &a->Selection	 , fin);
		}


	/*  Following code added for state file version 1 release 1  */
	if (InputStateRelease_m > 0)
		{
		/*  Read ExternalVector_t structures  */
/*test*/
#if 0
		ReadExternalVector ( &a->ForcePtrList,  fin);
		ReadExternalVector ( &a->SpringPtrList, fin);
#endif
		}

	/*  read CLAMP info (state version 1.4)  */
	if (InputStateRelease_m > 3)
		{
		
		LOOP (i, NUM_CLAMP_TAG)
			READ_SCALAR(fin, a->UseClamp[i])
		LOOP (i, NUM_CLAMP_TAG)
			READ_SCALAR(fin, a->ClampTemp[i])
		LOOP (i, NUM_CLAMP_TAG)
			READ_SCALAR(fin, a->ClampStep[i])

#if 0
	READ_SCALAR(fin, a->UseVolClamp)
#endif
		READ_SCALAR(fin, TempBoolean);
		READ_SCALAR(fin, a->VolClampStep)
		READ_SCALAR(fin, a->BulkModulus)
		if (TempBoolean)
			{
			a->BoxMotionAlgorithm = BMA_CLAMP;
			}

#if 0
		readarray ( (void **) &(a->UseClamp[0]) , fin);
		readarray ( (void **) &(a->ClampTemp), fin);
		readarray ( (void **) &(a->ClampStep), fin);
#endif
		}


	/*  read PRESSURE info (state version 1.5)  */
	if (InputStateRelease_m > 4)
		{

		READ_SCALAR(fin, a->BoxMotionGeometry)
		READ_SCALAR(fin, a->BoxMotionAlgorithm)
		READ_SCALAR(fin, a->EpotBox)
		READ_SCALAR(fin, a->BulkModulus)
		READ_SCALAR(fin, a->VolClampStep)
			
		READ_ARRAY (fin, a->Pressure,  NDIR)
		READ_ARRAY (fin, a->EkinBox,   NDIR)
		READ_ARRAY (fin, a->BoxMotion, NDIR*NDERIV)
		READ_ARRAY (fin, a->BoxForce,  NDIR)
		READ_ARRAY (fin, a->BoxMass,   NDIR)

		}


	/*  Close input file  */
	fclose(fin);

	/*  Pass address of new pointer back to calling routine	*/
	*InputParticleStructure = a;

	/*  Restore potential status  */
	a->IsInitializedPotential = IsInitializedPotential;


	return 0;
	}


/*
************************************************************************
Local routines
************************************************************************
*/


/*  Write array and its length in bytes  */
void writearray
(
size_t NumElements,
void	 *ArrayPointer,
size_t ElementSize,
FILE	 *OutputFile
)
	{
	size_t NumChars;

	/*  If array holds data write it out  */
	if (NumElements>0 && ArrayPointer!=NULL && OutputFile!=NULL)
		{
		NumChars = NumElements * ElementSize;
		fwrite (&NumChars,	 sizeof(NumChars), sizeof(char), OutputFile);
		fwrite (ArrayPointer, ElementSize,		 NumElements,	OutputFile);
		}

	/*  .. else write a zero  */
	else
		{
		NumChars = 0;
		fwrite (&NumChars, sizeof(NumChars), sizeof(char), OutputFile);
		}
	}



/*  Read array and its length in bytes  */
void readarray (void **ArrayPointer, FILE *InputFile)
	{
	size_t NumChars;

	/*  Read array size	*/
	fread_return_m = fread (&NumChars, sizeof(NumChars), 1, InputFile);
#ifdef DEBUG
	printf ("File %s Line %i : NumChars = %i\n",
		__FILE__, __LINE__, NumChars);
#endif

	/*  If not null array allocate memory and read array	*/
	if (NumChars>0)
		{
		FREE(*ArrayPointer)
		ALLOCATE (*ArrayPointer, char, NumChars)
		fread_return_m = fread (*ArrayPointer, NumChars, sizeof(char), InputFile);
		}

	/*  .. initilialze pointer to NULL	*/
	else
		*ArrayPointer = NULL;
	}

/*
Write external vector type (used for external force and external springs
*/
void WriteExternalVector (int NumVector, ExternalVector_t **Vector, FILE *fout)
	{
	int ivector;
	int NumAlloc;

	/*  If null vector then write no elements  */
	if (Vector==NULL)
		NumVector = 0;

	/*
	Write vector length (this is number of pointers, all of which could be NULL
	*/
	WRITE_SCALAR (fout, NumVector);


	/*  If count is zero then return  */
	if (NumVector==0)
		return;

	/*  Count number of external vectors allocated	*/
	NumAlloc = 0;
	LOOP (ivector, NumVector)
		if (Vector[ivector]!=NULL)
			NumAlloc++;

	/*  Write number of allocated vectors	*/
	WRITE_SCALAR (fout, NumAlloc);

	/*  Write out vectors  */
	LOOP (ivector, NumVector)
		if (Vector[ivector]!=NULL)
			{
			WRITE_SCALAR(fout, ivector);
			WRITE_ARRAY (fout, Vector[ivector]->Origin, NDIR);
			WRITE_ARRAY (fout, Vector[ivector]->Vector, NDIR);
			NumAlloc--;
			}

	/*  Double check that correct number of vectors was written  */
	if (NumAlloc != 0)
		{
		printf ("INTERNAL ERROR: File %s line %i.\n", __FILE__, __LINE__);
		printf ("Inconsistency in length of Vector.\n");
		CleanAfterError();
		}

	}


/*
Read external vector type (used for external force and external springs
*/
void ReadExternalVector (ExternalVector_t ***Vector, FILE *fin)
	{
	int ialloc;
	int ivector;
	int NumVector;
	int NumAlloc;

	/*
	Read vector length (this is number of pointers, all of which could be NULL
	*/
	READ_SCALAR (fin, NumVector)

	/*  If count is zero then return  */
	if (NumVector==0)
		{
		*Vector = NULL;
		return;
		}

	/*  Read number of external vectors allocated  */
	READ_SCALAR (fin, NumAlloc)

	/*  Allocate list of pointers  */
	ALLOCATE (*Vector, ExternalVector_t *, NumVector);

	/*  Allocate individual pointers  */
	LOOP (ialloc, NumAlloc)
		{
		READ_SCALAR (fin, ivector)
		ALLOCATE ((*Vector)[ivector], ExternalVector_t, 1)
		READ_ARRAY (fin, (*Vector)[ivector]->Origin, NDIR)
		READ_ARRAY (fin, (*Vector)[ivector]->Vector, NDIR)
		}

	}


/*  Write particle structure data (but not pointers or arrays)  */
void WriteParticleStructure (Particle_t *a, FILE *fout)
	{

	/*  Write data  */
	WRITE_ARRAY  (fout, a->bcur,	NDIR);
	WRITE_ARRAY  (fout, a->bref,	NDIR);
	WRITE_ARRAY  (fout, a->trans, NDIR);
	WRITE_SCALAR (fout, a->IsInitializedBox);
	WRITE_SCALAR (fout, a->IsInitializedCoord);
	WRITE_SCALAR (fout, a->selkeep);
	WRITE_ARRAY  (fout, a->surf, 3);
	WRITE_SCALAR (fout, a->ebath);
	WRITE_SCALAR (fout, a->etot);
	WRITE_SCALAR (fout, a->temp);
	WRITE_SCALAR (fout, a->epot);
	WRITE_SCALAR (fout, a->ekin);
	WRITE_SCALAR (fout, a->epavg);
	WRITE_SCALAR (fout, a->navg);
	WRITE_SCALAR (fout, a->np);
	WRITE_SCALAR (fout, a->ng);
	WRITE_SCALAR (fout, a->nsel);
	WRITE_SCALAR (fout, a->nfix);
	WRITE_SCALAR (fout, a->nbin);
	WRITE_SCALAR (fout, a->run);
	WRITE_SCALAR (fout, a->step);
	WRITE_SCALAR (fout, a->ndim);
	WRITE_SCALAR (fout, a->time);
	WRITE_SCALAR (fout, a->tempc);
	WRITE_SCALAR (fout, a->dtime);
	WRITE_SCALAR (fout, a->size);
	WRITE_SCALAR (fout, a->cutoff);
	WRITE_SCALAR (fout, a->rmin);
	}


void ReadParticleStructure (Particle_t *a, FILE *fin)
	{

	/*  Read data	*/
	READ_ARRAY	(fin, a->bcur,  NDIR);
	READ_ARRAY	(fin, a->bref,  NDIR);
	READ_ARRAY	(fin, a->trans, NDIR);
	READ_SCALAR (fin, a->IsInitializedBox);
	READ_SCALAR (fin, a->IsInitializedCoord);
	READ_SCALAR (fin, a->selkeep);
	READ_ARRAY	(fin, a->surf, 3);
	READ_SCALAR (fin, a->ebath);
	READ_SCALAR (fin, a->etot);
	READ_SCALAR (fin, a->temp);
	READ_SCALAR (fin, a->epot);
	READ_SCALAR (fin, a->ekin);
	READ_SCALAR (fin, a->epavg);
	READ_SCALAR (fin, a->navg);
	READ_SCALAR (fin, a->np);
	READ_SCALAR (fin, a->ng);
	READ_SCALAR (fin, a->nsel);
	READ_SCALAR (fin, a->nfix);
	READ_SCALAR (fin, a->nbin);
	READ_SCALAR (fin, a->run);
	READ_SCALAR (fin, a->step);
	READ_SCALAR (fin, a->ndim);
	READ_SCALAR (fin, a->time);
	READ_SCALAR (fin, a->tempc);
	READ_SCALAR (fin, a->dtime);
	READ_SCALAR (fin, a->size);
	READ_SCALAR (fin, a->cutoff);
	READ_SCALAR (fin, a->rmin);

	/*  Invalidate Neighbor List	*/
	a->InvalidNeighborList = TRUE;
	}



void WriteVersion (FILE *fout)
	{

	/*  Write version info	*/
	WRITE_SCALAR (fout, XMD_Version_g);
	WRITE_SCALAR (fout, XMD_Release_g);
	WRITE_SCALAR (fout, StateVersion_m);
	WRITE_SCALAR (fout, StateRelease_m);
	}

void ReadVersion (FILE *fin)
	{
	int InputXMD_Version;
	int InputXMD_Release;
	BOOLEAN WrongVersion;
	BOOLEAN WrongRelease;

	/*  Read version into  */
	READ_SCALAR (fin, InputXMD_Version);
	READ_SCALAR (fin, InputXMD_Release);
	READ_SCALAR (fin, InputStateVersion_m);
	READ_SCALAR (fin, InputStateRelease_m);

	/*  Test State file version  */
	WrongVersion = (InputStateVersion_m != StateVersion_m);
	WrongRelease = (InputStateRelease_m != StateRelease_m);

	/*  Print error or warning if wrong version or release  */
	if (WrongVersion)
		printf ("ERROR\n");
	else if (WrongRelease)
		{
		printf ("WARNING\n");
		IncrementNumberOfWarnings();
		}

	if (WrongVersion || WrongRelease)
		{
		printf ("Input Particle State File is version %i.%i\n",
			InputStateVersion_m, InputStateRelease_m);
		printf ("It was written by XMD version %i.%i.\n",
			InputXMD_Version, InputXMD_Release);
		printf ("The expected Particle State File version is %i.%i.\n",
			StateVersion_m, StateRelease_m);
		printf ("The current XMD version is %i.%i.\n",
			XMD_Version_g, XMD_Release_g);
		}

	/*  Exit if wrong version	*/
	if (WrongVersion)
		CleanAfterError();

	/*  Warning if wrong release	*/
	if (WrongRelease)
		printf ("Program will attempt to continue.\n");
	}


void WriteUserInfo (FILE *fout)
	{
	char	  StringBuffer[256];
	time_t  TimeInSeconds;
	struct tm *TimePtr;

	/*  Write XMD STATE FILE ID STRING	*/
	WriteStringToBinaryFile (fout, "XMD STATE FILE");

	/*  Write STATE FILE VERSION STRING  */
	sprintf (StringBuffer, "Version: %i.%i", StateVersion_m, StateRelease_m);
	WriteStringToBinaryFile (fout, StringBuffer);

	/*  Write DATE  */
	time (&TimeInSeconds);
	TimePtr = localtime (&TimeInSeconds);
	sprintf (StringBuffer, "Date: %02d/%02d/%04d",
				TimePtr->tm_mon+1, TimePtr->tm_mday, TimePtr->tm_year+1900);
	WriteStringToBinaryFile (fout, StringBuffer);

	/*  Write TIME  */
	sprintf (StringBuffer, "Time: %02d:%02d:%02d",
				TimePtr->tm_hour, TimePtr->tm_min, TimePtr->tm_sec);
	WriteStringToBinaryFile (fout, StringBuffer);

	}


void ReadUserInfo (FILE *fin)
	{
	char StringBuffer[256];

	/*  Test file State file ID string	*/
	ReadStringFromBinaryFile (fin, StringBuffer, 256);

	if (strcmpi (StringBuffer, "XMD STATE FILE") != 0)
		{
		ERROR_PREFIX
		printf ("Input file is not a state file.\n");
		CleanAfterError();
		}

	/*  Skip version string  */
	ReadStringFromBinaryFile (fin, StringBuffer, 256);

	/*  Skip date	  string  */
	ReadStringFromBinaryFile (fin, StringBuffer, 256);

	/*  Skip time	  string  */
	ReadStringFromBinaryFile (fin, StringBuffer, 256);

	}


void WriteTitle (FILE *fout, Particle_t *a)
	{
	int ititle;

	/*  Write title  */
	for (ititle=0; ititle<8; ititle++)
		WriteStringToBinaryFile (fout, a->title[ititle]);
	}


void ReadTitle (FILE *fin, Particle_t *a)
	{
	int ititle;
	int ichar;

	/*  Initialize title to null	*/
	for (ititle=0; ititle<8; ititle++)
	for (ichar=0; ichar<NTITLESTR; ichar++)
		a->title[ititle][ichar] = '\0';

	/*  Read title  */
	for (ititle=0; ititle<8; ititle++)
		ReadStringFromBinaryFile (fin, a->title[ititle], NTITLESTR);
	}


void WriteDelimiter (FILE *fout)
	{
	char StringBuffer[2];

	/*  Write delimiter for both UNIX head command and DOS Type command	*/
	StringBuffer[0] = '\0';
	StringBuffer[1] = 26;
	WRITE_ARRAY (fout, StringBuffer, 2);
	}


void ReadDelimiter (FILE *fin)
	{
	char StringBuffer[2];

	/*  Skip file delimiters  */
	fread_return_m = fread (StringBuffer, sizeof(char), 2, fin);
	}


void WriteStringToBinaryFile (FILE *fout, char *String)
	{
	char LineFeed = '\n';
	WRITE_ARRAY (fout, String, strlen (String) );
	WRITE_SCALAR(fout, LineFeed);
	}


void ReadStringFromBinaryFile (FILE *fin, char *StringBuffer, int NumChar)
	{
	int ichar;
	char InputChar;

	ichar = 0;
	do
		{

		/*  Read one character	*/
		fread_return_m = fread (&InputChar, sizeof(char), 1, fin);

		/*  Add to buffer  */
		if (InputChar == '\n' || InputChar =='\r')
			StringBuffer[ichar] = '\0';
		else
			StringBuffer[ichar] = InputChar;

		/*  Increment counter  */
		ichar++;

		/*  Until newline read or buffer filled	*/
		} while (InputChar != '\n' && ichar<NumChar);

	}



void WriteSimulationStructure (Simulation_t *s, FILE *OutputFile)
	{
	WRITE_SCALAR(OutputFile, s->tempc)
	WRITE_SCALAR(OutputFile, s->cutoff)
	WRITE_SCALAR(OutputFile, s->cutmin)
	WRITE_SCALAR(OutputFile, s->uratio)
	WRITE_SCALAR(OutputFile, s->size)
	WRITE_SCALAR(OutputFile, s->dtime)
	WRITE_SCALAR(OutputFile, s->cstep)
	WRITE_SCALAR(OutputFile, s->nrej)
	WRITE_SCALAR(OutputFile, s->nacc)
	WRITE_SCALAR(OutputFile, s->nstep)
	WRITE_SCALAR(OutputFile, s->quench)
	WRITE_SCALAR(OutputFile, s->echo)
	WRITE_SCALAR(OutputFile, s->eulabel)
	WRITE_SCALAR(OutputFile, s->eunit)
	WRITE_SCALAR(OutputFile, s->seed)

	/*  esave flag and file */
	WRITE_SCALAR(OutputFile, s->EnergyStepOutput.FileName)
	WRITE_SCALAR(OutputFile, s->EnergyStepOutput.Save)
	WRITE_SCALAR(OutputFile, s->EnergyStepOutput.IsFileNew)
	WRITE_SCALAR(OutputFile, s->EnergyStepOutput.StepIncrement)
	WRITE_SCALAR(OutputFile, s->EnergyStepOutput.CurrentStep)

	/*  ssave flag and file */
	WRITE_SCALAR(OutputFile, s->StressStepOutput.FileName)
	WRITE_SCALAR(OutputFile, s->StressStepOutput.Save)
	WRITE_SCALAR(OutputFile, s->StressStepOutput.IsFileNew)
	WRITE_SCALAR(OutputFile, s->StressStepOutput.StepIncrement)
	WRITE_SCALAR(OutputFile, s->StressStepOutput.CurrentStep)

	/*  bsave flag and file */
	WRITE_SCALAR(OutputFile, s->BoxStepOutput.FileName)
	WRITE_SCALAR(OutputFile, s->BoxStepOutput.Save)
	WRITE_SCALAR(OutputFile, s->BoxStepOutput.IsFileNew)
	WRITE_SCALAR(OutputFile, s->BoxStepOutput.StepIncrement)
	WRITE_SCALAR(OutputFile, s->BoxStepOutput.CurrentStep)

	/*  Debug flag  */
	WRITE_SCALAR(OutputFile, s->debug)
	Debug_g = s->debug;

	/*  Stop signal  */
	WRITE_SCALAR(OutputFile, s->signal)

	/*  Potential Name  */
	WRITE_SCALAR(OutputFile, s->pottype)

	/*  Compare Info	*/
	WRITE_SCALAR(OutputFile, s->UseCompare)
	WRITE_SCALAR(OutputFile, s->UseInverseCompare)
	WRITE_SCALAR(OutputFile, s->NewCompareFile)
	WRITE_SCALAR(OutputFile, s->CompareFileName)
	WRITE_SCALAR(OutputFile, s->CompareRadius)
	WRITE_SCALAR(OutputFile, s->CompareEnergy)

	/*  tsave flag and file */
	WRITE_SCALAR(OutputFile, s->TrajectoryStepOutput.FileName)
	WRITE_SCALAR(OutputFile, s->TrajectoryStepOutput.Save)
	WRITE_SCALAR(OutputFile, s->TrajectoryStepOutput.IsFileNew)
	WRITE_SCALAR(OutputFile, s->TrajectoryStepOutput.StepIncrement)
	WRITE_SCALAR(OutputFile, s->TrajectoryStepOutput.CurrentStep)
	}


void ReadSimulationStructure (Simulation_t *s, FILE *InputFile)
	{

	READ_SCALAR(InputFile, s->tempc)
	READ_SCALAR(InputFile, s->cutoff)
	READ_SCALAR(InputFile, s->cutmin)
	READ_SCALAR(InputFile, s->uratio)
	READ_SCALAR(InputFile, s->size)
	READ_SCALAR(InputFile, s->dtime)
	READ_SCALAR(InputFile, s->cstep)
	READ_SCALAR(InputFile, s->nrej)
	READ_SCALAR(InputFile, s->nacc)
	READ_SCALAR(InputFile, s->nstep)
	READ_SCALAR(InputFile, s->quench)
	READ_SCALAR(InputFile, s->echo)
	READ_SCALAR(InputFile, s->eulabel)
	READ_SCALAR(InputFile, s->eunit)
	READ_SCALAR(InputFile, s->seed)

	/*  esave flag and file */
	READ_SCALAR(InputFile, s->EnergyStepOutput.FileName)
	READ_SCALAR(InputFile, s->EnergyStepOutput.Save)
	READ_SCALAR(InputFile, s->EnergyStepOutput.IsFileNew)
	READ_SCALAR(InputFile, s->EnergyStepOutput.StepIncrement)
	READ_SCALAR(InputFile, s->EnergyStepOutput.CurrentStep)

	/*  ssave flag and file */
	READ_SCALAR(InputFile, s->StressStepOutput.FileName)
	READ_SCALAR(InputFile, s->StressStepOutput.Save)
	READ_SCALAR(InputFile, s->StressStepOutput.IsFileNew)
	READ_SCALAR(InputFile, s->StressStepOutput.StepIncrement)
	READ_SCALAR(InputFile, s->StressStepOutput.CurrentStep)

	/*  bsave flag and file */
	READ_SCALAR(InputFile, s->BoxStepOutput.FileName)
	READ_SCALAR(InputFile, s->BoxStepOutput.Save)
	READ_SCALAR(InputFile, s->BoxStepOutput.IsFileNew)
	READ_SCALAR(InputFile, s->BoxStepOutput.StepIncrement)
	READ_SCALAR(InputFile, s->BoxStepOutput.CurrentStep)

	/*  Debug flag  */
	READ_SCALAR(InputFile, s->debug)

	/*  Stop signal  */
	READ_SCALAR(InputFile, s->signal)

	/*  Potential Name  */
	READ_SCALAR(InputFile, s->pottype)

	/*  Compare Info	*/
	READ_SCALAR(InputFile, s->UseCompare)
	READ_SCALAR(InputFile, s->UseInverseCompare)
	READ_SCALAR(InputFile, s->NewCompareFile)
	READ_SCALAR(InputFile, s->CompareFileName)
	READ_SCALAR(InputFile, s->CompareRadius)
	READ_SCALAR(InputFile, s->CompareEnergy)

	/*  Skip following information if state file prior to 1.2  */
	if (InputStateRelease_m < 2)
		return;

	/*  tsave flag and file */
	READ_SCALAR(InputFile, s->TrajectoryStepOutput.FileName)
	READ_SCALAR(InputFile, s->TrajectoryStepOutput.Save)
	READ_SCALAR(InputFile, s->TrajectoryStepOutput.IsFileNew)
	READ_SCALAR(InputFile, s->TrajectoryStepOutput.StepIncrement)
	READ_SCALAR(InputFile, s->TrajectoryStepOutput.CurrentStep)
	}