src/UseTheForce/LJFF.cpp

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

#include <iostream>
using namespace std;

#ifdef IS_MPI
#include <mpi.h>
#endif //is_mpi

#include "UseTheForce/ForceFields.hpp"
#include "primitives/SRI.hpp"
#include "utils/simError.h"
#include "types/AtomType.hpp"
#include "UseTheForce/DarkSide/lj_interface.h"


#ifdef IS_MPI
#include "UseTheForce/mpiForceField.h"
#endif // is_mpi


namespace LJ_NS{

  // Declare the structures that will be passed by the parser and  MPI
  
  typedef struct{
    char name[15];
    double mass;
    double epslon;
    double sigma;
    int ident;
    int last;      //  0  -> default
                   //  1  -> in MPI: tells nodes to stop listening
  } atomStruct;

  int parseAtom( char *lineBuffer, int lineNum, atomStruct &info );
  
#ifdef IS_MPI
  
  MPI_Datatype mpiAtomStructType;
  
#endif

  class LinkedAtomType {
  public:
    LinkedAtomType(){ 
      next = NULL;
      name[0] = '\0';
    }
    ~LinkedAtomType(){ if( next != NULL ) delete next; }

    LinkedAtomType* find(char* key){ 
      if( !strcmp(name, key) ) return this;
      if( next != NULL ) return next->find(key);
      return NULL;
    }
    

    void add( atomStruct &info ){
    
      // check for duplicates
      
      if( !strcmp( info.name, name ) ){
        sprintf( painCave.errMsg,
                 "Duplicate LJ atom type \"%s\" found in "
                 "the LJFF param file./n",
                 name );
        painCave.isFatal = 1;
        simError();
      }
      
      if( next != NULL ) next->add(info);
      else{
        next = new LinkedAtomType();
        strcpy(next->name, info.name);
        next->mass     = info.mass;
        next->epslon   = info.epslon;
        next->sigma    = info.sigma;
        next->ident    = info.ident;
      }
    }
    

#ifdef IS_MPI
    
    void duplicate( atomStruct &info ){
      strcpy(info.name, name);
      info.mass     = mass;
      info.epslon   = epslon;
      info.sigma    = sigma;
      info.ident    = ident;
      info.last     = 0;
    }


#endif

    char name[15];
    double mass;
    double epslon;
    double sigma;
    int ident;
    LinkedAtomType* next;
  };

  LinkedAtomType* headAtomType; 
  LinkedAtomType* currentAtomType;

}

using namespace LJ_NS;

//****************************************************************
// begins the actual forcefield stuff.  
//****************************************************************


LJFF::LJFF(){

  char fileName[200];
  char* ffPath_env = "FORCE_PARAM_PATH";
  char* ffPath;
  char temp[200];

  headAtomType = NULL;
  currentAtomType = NULL;

  // do the funtion wrapping
 // wrapMeFF( this );

#ifdef IS_MPI
  int i;
  
   // **********************************************************************
  // Init the atomStruct mpi type

  atomStruct atomProto; // mpiPrototype
  int atomBC[3] = {15,3,2};  // block counts
  MPI_Aint atomDspls[3];           // displacements
  MPI_Datatype atomMbrTypes[3];    // member mpi types

  MPI_Address(&atomProto.name, &atomDspls[0]);
  MPI_Address(&atomProto.mass, &atomDspls[1]);
  MPI_Address(&atomProto.ident, &atomDspls[2]);
  
  atomMbrTypes[0] = MPI_CHAR;
  atomMbrTypes[1] = MPI_DOUBLE;
  atomMbrTypes[2] = MPI_INT;
  
  for (i=2; i >= 0; i--) atomDspls[i] -= atomDspls[0];
  
  MPI_Type_struct(3, atomBC, atomDspls, atomMbrTypes, &mpiAtomStructType);
  MPI_Type_commit(&mpiAtomStructType);

  // ***********************************************************************
  
  if( worldRank == 0 ){
#endif
    
    // generate the force file name
    
    strcpy( fileName, "LJFF.frc" ); 
    // fprintf( stderr,"Trying to open %s\n", fileName );
    
    // attempt to open the file in the current directory first.
    
    frcFile = fopen( fileName, "r" );
    
    if( frcFile == NULL ){
      
      // next see if the force path enviorment variable is set
      
      ffPath = getenv( ffPath_env );
      if( ffPath == NULL ) {
        STR_DEFINE(ffPath, FRC_PATH );
      }
      
      
      strcpy( temp, ffPath );
      strcat( temp, "/" );
      strcat( temp, fileName );
      strcpy( fileName, temp );
      
      frcFile = fopen( fileName, "r" );
      
      if( frcFile == NULL ){

        sprintf( painCave.errMsg,
                 "Error opening the force field parameter file:\n"
                 "\t%s\n"
                 "\tHave you tried setting the FORCE_PARAM_PATH environment "
                 "variable?\n",
                 fileName );
        painCave.severity = OOPSE_ERROR;
        painCave.isFatal = 1;
        simError();
      }
    }
    
#ifdef IS_MPI
  }
  
  sprintf( checkPointMsg, "LJFF file opened sucessfully." );
  MPIcheckPoint();
  
#endif // is_mpi
}


LJFF::~LJFF(){

  if( headAtomType != NULL ) delete headAtomType;

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif // is_mpi
    
    fclose( frcFile );
    
#ifdef IS_MPI
  }
#endif // is_mpi
}

void LJFF::initForceField(){
  
  initFortran(0);
}

void LJFF::cleanMe( void ){

#ifdef IS_MPI
  
  // keep the linked list in the mpi version

#else // is_mpi

  // delete the linked list in the single processor version

  if( headAtomType != NULL ) delete headAtomType;

#endif // is_mpi
}

void LJFF::readParams( void ){

  atomStruct info;
  info.last = 1; // initialize last to have the last set. 
                 // if things go well, last will be set to 0

  int identNum;
  int isError;

  bigSigma = 0.0;
#ifdef IS_MPI
  if( worldRank == 0 ){
#endif
    
    // read in the atom types.

    headAtomType = new LinkedAtomType;
    
    fastForward( "AtomTypes", "initializeAtoms" );

    // we are now at the AtomTypes section.
    
    eof_test = fgets( readLine, sizeof(readLine), frcFile );
    lineNum++;
    
    
    // read a line, and start parseing out the atom types 

    if( eof_test == NULL ){
      sprintf( painCave.errMsg, 
               "Error in reading Atoms from force file at line %d.\n",
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    identNum = 1;
    // stop reading at end of file, or at next section
    while( readLine[0] != '#' && eof_test != NULL ){

      // toss comment lines
      if( readLine[0] != '!' ){
        
        // the parser returns 0 if the line was blank
        if( parseAtom( readLine, lineNum, info ) ){
          info.ident = identNum;
          headAtomType->add( info );;
          identNum++;
        }
      }
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }

#ifdef IS_MPI
    
    // send out the linked list to all the other processes

    sprintf( checkPointMsg,
             "LJFF atom structures read successfully." );
    MPIcheckPoint();

    currentAtomType = headAtomType->next; //skip the first element who is a place holder.
    while( currentAtomType != NULL ){
      currentAtomType->duplicate( info );

 
      sendFrcStruct( &info, mpiAtomStructType );

      sprintf( checkPointMsg,
               "successfully sent lJ force type: \"%s\"\n",
               info.name );
      MPIcheckPoint();

      currentAtomType = currentAtomType->next;
    }
    info.last = 1;
    sendFrcStruct( &info, mpiAtomStructType );
    
  }

  else{
    
    // listen for node 0 to send out the force params
    
    MPIcheckPoint();

    headAtomType = new LinkedAtomType;
    receiveFrcStruct( &info, mpiAtomStructType );
    
    while( !info.last ){


      headAtomType->add( info );
      
      MPIcheckPoint();

      receiveFrcStruct( &info, mpiAtomStructType );
    }
  }
#endif // is_mpi
  
  currentAtomType = headAtomType;
  while( currentAtomType != NULL ){
    
    if( currentAtomType->name[0] != '\0' ){

      AtomType* at = new AtomType();
      at->setIdent(currentAtomType->ident);
      at->setName(currentAtomType->name);     
      at->setLennardJones();
      at->complete();
      
    }
    currentAtomType = currentAtomType->next;
  }

  currentAtomType = headAtomType;
  while( currentAtomType != NULL ){
    
    if( currentAtomType->name[0] != '\0' ){
      isError = 0;
      newLJtype( &(currentAtomType->ident), &(currentAtomType->sigma), 
                 &(currentAtomType->epslon), &isError);
      if( isError ){
        sprintf( painCave.errMsg,
                 "Error initializing the \"%s\" LJ type in fortran\n",
                 currentAtomType->name );
        painCave.isFatal = 1;
        simError();
      }
    }
    
    currentAtomType = currentAtomType->next;
  }
  
  entry_plug->useLJ = 1;

#ifdef IS_MPI
  sprintf( checkPointMsg,
           "LJFF atom structures successfully sent to fortran\n" );
  MPIcheckPoint();
#endif // is_mpi

}

double LJFF::getAtomTypeMass (char* atomType) {

  currentAtomType = headAtomType->find( atomType );
  if( currentAtomType == NULL ){
    sprintf( painCave.errMsg,
            "AtomType error, %s not found in force file.\n",
             atomType );
    painCave.isFatal = 1;
    simError();
  }

  return currentAtomType->mass;
}

void LJFF::initializeAtoms( int nAtoms, Atom** the_atoms ){
  
  int i;

  // initialize the atoms
  

  for( i=0; i<nAtoms; i++ ){
    
    currentAtomType = headAtomType->find( the_atoms[i]->getType() );
    if( currentAtomType == NULL ){
      sprintf( painCave.errMsg, 
               "AtomType error, %s not found in force file.\n",
               the_atoms[i]->getType() );
      painCave.isFatal = 1;
      simError();
    }
    
    the_atoms[i]->setMass( currentAtomType->mass );
    the_atoms[i]->setIdent( currentAtomType->ident );

    if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;
  }
}

void LJFF::initializeBonds( int nBonds, Bond** BondArray,
                             bond_pair* the_bonds ){
  
    if( nBonds ){
      sprintf( painCave.errMsg,
               "LJFF does not support bonds.\n" );
      painCave.isFatal = 1;
      simError();
    }
}

void LJFF::initializeBends( int nBends, Bend** bendArray,
                             bend_set* the_bends ){

    if( nBends ){
      sprintf( painCave.errMsg,
               "LJFF does not support bends.\n" );
      painCave.isFatal = 1;
      simError();
    }
}

void LJFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
                                torsion_set* the_torsions ){

    if( nTorsions ){
      sprintf( painCave.errMsg,
               "LJFF does not support torsions.\n" );
      painCave.isFatal = 1;
      simError();
    }
}

void LJFF::fastForward( char* stopText, char* searchOwner ){

  int foundText = 0;
  char* the_token;

  rewind( frcFile );
  lineNum = 0;

  eof_test = fgets( readLine, sizeof(readLine), frcFile );
  lineNum++;
  if( eof_test == NULL ){
    sprintf( painCave.errMsg, "Error fast forwarding force file for %s: "
             " file is empty.\n",
             searchOwner );
    painCave.isFatal = 1;
    simError();
  }
  
  
  while( !foundText ){
    while( eof_test != NULL && readLine[0] != '#' ){
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }
    if( eof_test == NULL ){
      sprintf( painCave.errMsg,
               "Error fast forwarding force file for %s at "
               "line %d: file ended unexpectedly.\n",
               searchOwner,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    the_token = strtok( readLine, " ,;\t#\n" );
    foundText = !strcmp( stopText, the_token );
    
    if( !foundText ){
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
      
      if( eof_test == NULL ){
        sprintf( painCave.errMsg, 
                 "Error fast forwarding force file for %s at "
                 "line %d: file ended unexpectedly.\n",
                 searchOwner,
                 lineNum );
        painCave.isFatal = 1;
        simError();
      } 
    }
  }  
}


int LJ_NS::parseAtom( char *lineBuffer, int lineNum,  atomStruct &info ){

  char* the_token;
  
  the_token = strtok( lineBuffer, " \n\t,;" );
  if( the_token != NULL ){
    
    strcpy( info.name, the_token );
          
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    info.mass = atof( the_token );
    
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
        
    info.epslon = atof( the_token );
          
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
        
    info.sigma = atof( the_token );
    
    return 1;
  }
  else return 0;
}


Revision:	1634
Committed:	Fri Oct 22 21:21:02 2004 UTC (19 years, 8 months ago) by gezelter
Original Path:	*trunk/OOPSE-4/src/UseTheForce/LJFF.cpp*
File size:	12340 byte(s)
Log Message:	fixey fixey
#	User	Rev	Content
1	gezelter	1490	#include <stdlib.h>
2			#include <stdio.h>
3			#include <string.h>
4
5			#include <iostream>
6			using namespace std;
7
8			#ifdef IS_MPI
9			#include <mpi.h>
10			#endif //is_mpi
11
12	tim	1492	#include "UseTheForce/ForceFields.hpp"
13			#include "primitives/SRI.hpp"
14			#include "utils/simError.h"
15	gezelter	1634	#include "types/AtomType.hpp"
16			#include "UseTheForce/DarkSide/lj_interface.h"
17	gezelter	1490
18
19			#ifdef IS_MPI
20	tim	1492	#include "UseTheForce/mpiForceField.h"
21	gezelter	1490	#endif // is_mpi
22
23
24
25			namespace LJ_NS{
26
27			// Declare the structures that will be passed by the parser and MPI
28
29			typedef struct{
30			char name[15];
31			double mass;
32			double epslon;
33			double sigma;
34			int ident;
35			int last; // 0 -> default
36			// 1 -> in MPI: tells nodes to stop listening
37			} atomStruct;
38
39			int parseAtom( char *lineBuffer, int lineNum, atomStruct &info );
40
41			#ifdef IS_MPI
42
43			MPI_Datatype mpiAtomStructType;
44
45			#endif
46
47			class LinkedAtomType {
48			public:
49			LinkedAtomType(){
50			next = NULL;
51			name[0] = '\0';
52			}
53			~LinkedAtomType(){ if( next != NULL ) delete next; }
54
55			LinkedAtomType* find(char* key){
56			if( !strcmp(name, key) ) return this;
57			if( next != NULL ) return next->find(key);
58			return NULL;
59			}
60
61
62			void add( atomStruct &info ){
63
64			// check for duplicates
65
66			if( !strcmp( info.name, name ) ){
67			sprintf( painCave.errMsg,
68			"Duplicate LJ atom type \"%s\" found in "
69			"the LJFF param file./n",
70			name );
71			painCave.isFatal = 1;
72			simError();
73			}
74
75			if( next != NULL ) next->add(info);
76			else{
77			next = new LinkedAtomType();
78			strcpy(next->name, info.name);
79			next->mass = info.mass;
80			next->epslon = info.epslon;
81			next->sigma = info.sigma;
82			next->ident = info.ident;
83			}
84			}
85
86
87			#ifdef IS_MPI
88
89			void duplicate( atomStruct &info ){
90			strcpy(info.name, name);
91			info.mass = mass;
92			info.epslon = epslon;
93			info.sigma = sigma;
94			info.ident = ident;
95			info.last = 0;
96			}
97
98
99			#endif
100
101			char name[15];
102			double mass;
103			double epslon;
104			double sigma;
105			int ident;
106			LinkedAtomType* next;
107			};
108
109			LinkedAtomType* headAtomType;
110			LinkedAtomType* currentAtomType;
111
112			}
113
114			using namespace LJ_NS;
115
116			//****************************************************************
117			// begins the actual forcefield stuff.
118			//****************************************************************
119
120
121			LJFF::LJFF(){
122
123			char fileName[200];
124			char* ffPath_env = "FORCE_PARAM_PATH";
125			char* ffPath;
126			char temp[200];
127
128			headAtomType = NULL;
129			currentAtomType = NULL;
130
131			// do the funtion wrapping
132	chuckv	1617	// wrapMeFF( this );
133	gezelter	1490
134			#ifdef IS_MPI
135			int i;
136
137			// **********************************************************************
138			// Init the atomStruct mpi type
139
140			atomStruct atomProto; // mpiPrototype
141			int atomBC[3] = {15,3,2}; // block counts
142			MPI_Aint atomDspls[3]; // displacements
143			MPI_Datatype atomMbrTypes[3]; // member mpi types
144
145			MPI_Address(&atomProto.name, &atomDspls[0]);
146			MPI_Address(&atomProto.mass, &atomDspls[1]);
147			MPI_Address(&atomProto.ident, &atomDspls[2]);
148
149			atomMbrTypes[0] = MPI_CHAR;
150			atomMbrTypes[1] = MPI_DOUBLE;
151			atomMbrTypes[2] = MPI_INT;
152
153			for (i=2; i >= 0; i--) atomDspls[i] -= atomDspls[0];
154
155			MPI_Type_struct(3, atomBC, atomDspls, atomMbrTypes, &mpiAtomStructType);
156			MPI_Type_commit(&mpiAtomStructType);
157
158			// ***********************************************************************
159
160			if( worldRank == 0 ){
161			#endif
162
163			// generate the force file name
164
165			strcpy( fileName, "LJFF.frc" );
166			// fprintf( stderr,"Trying to open %s\n", fileName );
167
168			// attempt to open the file in the current directory first.
169
170			frcFile = fopen( fileName, "r" );
171
172			if( frcFile == NULL ){
173
174			// next see if the force path enviorment variable is set
175
176			ffPath = getenv( ffPath_env );
177			if( ffPath == NULL ) {
178			STR_DEFINE(ffPath, FRC_PATH );
179			}
180
181
182			strcpy( temp, ffPath );
183			strcat( temp, "/" );
184			strcat( temp, fileName );
185			strcpy( fileName, temp );
186
187			frcFile = fopen( fileName, "r" );
188
189			if( frcFile == NULL ){
190
191			sprintf( painCave.errMsg,
192			"Error opening the force field parameter file:\n"
193			"\t%s\n"
194			"\tHave you tried setting the FORCE_PARAM_PATH environment "
195			"variable?\n",
196			fileName );
197			painCave.severity = OOPSE_ERROR;
198			painCave.isFatal = 1;
199			simError();
200			}
201			}
202
203			#ifdef IS_MPI
204			}
205
206			sprintf( checkPointMsg, "LJFF file opened sucessfully." );
207			MPIcheckPoint();
208
209			#endif // is_mpi
210			}
211
212
213			LJFF::~LJFF(){
214
215			if( headAtomType != NULL ) delete headAtomType;
216
217			#ifdef IS_MPI
218			if( worldRank == 0 ){
219			#endif // is_mpi
220
221			fclose( frcFile );
222
223			#ifdef IS_MPI
224			}
225			#endif // is_mpi
226			}
227
228	gezelter	1628	void LJFF::initForceField(){
229	gezelter	1490
230	gezelter	1628	initFortran(0);
231	gezelter	1490	}
232
233			void LJFF::cleanMe( void ){
234
235			#ifdef IS_MPI
236
237			// keep the linked list in the mpi version
238
239			#else // is_mpi
240
241			// delete the linked list in the single processor version
242
243			if( headAtomType != NULL ) delete headAtomType;
244
245			#endif // is_mpi
246			}
247
248			void LJFF::readParams( void ){
249
250			atomStruct info;
251			info.last = 1; // initialize last to have the last set.
252			// if things go well, last will be set to 0
253
254			int identNum;
255	gezelter	1634	int isError;
256	gezelter	1490
257			bigSigma = 0.0;
258			#ifdef IS_MPI
259			if( worldRank == 0 ){
260			#endif
261
262			// read in the atom types.
263
264			headAtomType = new LinkedAtomType;
265
266			fastForward( "AtomTypes", "initializeAtoms" );
267
268			// we are now at the AtomTypes section.
269
270			eof_test = fgets( readLine, sizeof(readLine), frcFile );
271			lineNum++;
272
273
274			// read a line, and start parseing out the atom types
275
276			if( eof_test == NULL ){
277			sprintf( painCave.errMsg,
278			"Error in reading Atoms from force file at line %d.\n",
279			lineNum );
280			painCave.isFatal = 1;
281			simError();
282			}
283
284			identNum = 1;
285			// stop reading at end of file, or at next section
286			while( readLine[0] != '#' && eof_test != NULL ){
287
288			// toss comment lines
289			if( readLine[0] != '!' ){
290
291			// the parser returns 0 if the line was blank
292			if( parseAtom( readLine, lineNum, info ) ){
293			info.ident = identNum;
294			headAtomType->add( info );;
295			identNum++;
296			}
297			}
298			eof_test = fgets( readLine, sizeof(readLine), frcFile );
299			lineNum++;
300			}
301
302			#ifdef IS_MPI
303
304			// send out the linked list to all the other processes
305
306			sprintf( checkPointMsg,
307			"LJFF atom structures read successfully." );
308			MPIcheckPoint();
309
310			currentAtomType = headAtomType->next; //skip the first element who is a place holder.
311			while( currentAtomType != NULL ){
312			currentAtomType->duplicate( info );
313
314
315
316			sendFrcStruct( &info, mpiAtomStructType );
317
318			sprintf( checkPointMsg,
319			"successfully sent lJ force type: \"%s\"\n",
320			info.name );
321			MPIcheckPoint();
322
323			currentAtomType = currentAtomType->next;
324			}
325			info.last = 1;
326			sendFrcStruct( &info, mpiAtomStructType );
327
328			}
329
330			else{
331
332			// listen for node 0 to send out the force params
333
334			MPIcheckPoint();
335
336			headAtomType = new LinkedAtomType;
337			receiveFrcStruct( &info, mpiAtomStructType );
338
339			while( !info.last ){
340
341
342
343			headAtomType->add( info );
344
345			MPIcheckPoint();
346
347			receiveFrcStruct( &info, mpiAtomStructType );
348			}
349			}
350			#endif // is_mpi
351
352	gezelter	1634	currentAtomType = headAtomType;
353			while( currentAtomType != NULL ){
354
355			if( currentAtomType->name[0] != '\0' ){
356	gezelter	1490
357	gezelter	1634	AtomType* at = new AtomType();
358			at->setIdent(currentAtomType->ident);
359			at->setName(currentAtomType->name);
360			at->setLennardJones();
361			at->complete();
362
363			}
364			currentAtomType = currentAtomType->next;
365			}
366
367	gezelter	1490	currentAtomType = headAtomType;
368			while( currentAtomType != NULL ){
369
370			if( currentAtomType->name[0] != '\0' ){
371			isError = 0;
372	gezelter	1634	newLJtype( &(currentAtomType->ident), &(currentAtomType->sigma),
373			&(currentAtomType->epslon), &isError);
374	gezelter	1490	if( isError ){
375	gezelter	1634	sprintf( painCave.errMsg,
376			"Error initializing the \"%s\" LJ type in fortran\n",
377			currentAtomType->name );
378			painCave.isFatal = 1;
379			simError();
380	gezelter	1490	}
381			}
382	gezelter	1634
383	gezelter	1490	currentAtomType = currentAtomType->next;
384			}
385	gezelter	1634
386	gezelter	1490	entry_plug->useLJ = 1;
387
388			#ifdef IS_MPI
389			sprintf( checkPointMsg,
390			"LJFF atom structures successfully sent to fortran\n" );
391			MPIcheckPoint();
392			#endif // is_mpi
393
394			}
395
396			double LJFF::getAtomTypeMass (char* atomType) {
397
398			currentAtomType = headAtomType->find( atomType );
399			if( currentAtomType == NULL ){
400			sprintf( painCave.errMsg,
401			"AtomType error, %s not found in force file.\n",
402			atomType );
403			painCave.isFatal = 1;
404			simError();
405			}
406
407			return currentAtomType->mass;
408			}
409
410			void LJFF::initializeAtoms( int nAtoms, Atom** the_atoms ){
411
412			int i;
413
414			// initialize the atoms
415
416
417			for( i=0; i<nAtoms; i++ ){
418
419			currentAtomType = headAtomType->find( the_atoms[i]->getType() );
420			if( currentAtomType == NULL ){
421			sprintf( painCave.errMsg,
422			"AtomType error, %s not found in force file.\n",
423			the_atoms[i]->getType() );
424			painCave.isFatal = 1;
425			simError();
426			}
427
428			the_atoms[i]->setMass( currentAtomType->mass );
429			the_atoms[i]->setIdent( currentAtomType->ident );
430
431			if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;
432			}
433			}
434
435			void LJFF::initializeBonds( int nBonds, Bond** BondArray,
436			bond_pair* the_bonds ){
437
438			if( nBonds ){
439			sprintf( painCave.errMsg,
440			"LJFF does not support bonds.\n" );
441			painCave.isFatal = 1;
442			simError();
443			}
444			}
445
446			void LJFF::initializeBends( int nBends, Bend** bendArray,
447			bend_set* the_bends ){
448
449			if( nBends ){
450			sprintf( painCave.errMsg,
451			"LJFF does not support bends.\n" );
452			painCave.isFatal = 1;
453			simError();
454			}
455			}
456
457			void LJFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
458			torsion_set* the_torsions ){
459
460			if( nTorsions ){
461			sprintf( painCave.errMsg,
462			"LJFF does not support torsions.\n" );
463			painCave.isFatal = 1;
464			simError();
465			}
466			}
467
468			void LJFF::fastForward( char* stopText, char* searchOwner ){
469
470			int foundText = 0;
471			char* the_token;
472
473			rewind( frcFile );
474			lineNum = 0;
475
476			eof_test = fgets( readLine, sizeof(readLine), frcFile );
477			lineNum++;
478			if( eof_test == NULL ){
479			sprintf( painCave.errMsg, "Error fast forwarding force file for %s: "
480			" file is empty.\n",
481			searchOwner );
482			painCave.isFatal = 1;
483			simError();
484			}
485
486
487			while( !foundText ){
488			while( eof_test != NULL && readLine[0] != '#' ){
489			eof_test = fgets( readLine, sizeof(readLine), frcFile );
490			lineNum++;
491			}
492			if( eof_test == NULL ){
493			sprintf( painCave.errMsg,
494			"Error fast forwarding force file for %s at "
495			"line %d: file ended unexpectedly.\n",
496			searchOwner,
497			lineNum );
498			painCave.isFatal = 1;
499			simError();
500			}
501
502			the_token = strtok( readLine, " ,;\t#\n" );
503			foundText = !strcmp( stopText, the_token );
504
505			if( !foundText ){
506			eof_test = fgets( readLine, sizeof(readLine), frcFile );
507			lineNum++;
508
509			if( eof_test == NULL ){
510			sprintf( painCave.errMsg,
511			"Error fast forwarding force file for %s at "
512			"line %d: file ended unexpectedly.\n",
513			searchOwner,
514			lineNum );
515			painCave.isFatal = 1;
516			simError();
517			}
518			}
519			}
520			}
521
522
523
524			int LJ_NS::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){
525
526			char* the_token;
527
528			the_token = strtok( lineBuffer, " \n\t,;" );
529			if( the_token != NULL ){
530
531			strcpy( info.name, the_token );
532
533			if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
534			sprintf( painCave.errMsg,
535			"Error parseing AtomTypes: line %d\n", lineNum );
536			painCave.isFatal = 1;
537			simError();
538			}
539
540			info.mass = atof( the_token );
541
542			if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
543			sprintf( painCave.errMsg,
544			"Error parseing AtomTypes: line %d\n", lineNum );
545			painCave.isFatal = 1;
546			simError();
547			}
548
549			info.epslon = atof( the_token );
550
551			if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
552			sprintf( painCave.errMsg,
553			"Error parseing AtomTypes: line %d\n", lineNum );
554			painCave.isFatal = 1;
555			simError();
556			}
557
558			info.sigma = atof( the_token );
559
560			return 1;
561			}
562			else return 0;
563			}
564
565