cdstate.c

一个很好的分子动力学程序

	if (NumChars>0)
		{
		FREE(*ArrayPointer)
		ALLOCATE (*ArrayPointer, char, NumChars)
		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 (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 (&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)
	}