mdtools/md_code/InitializeFromFile.cpp

#include <iostream>
#include <cmath>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "ReadWrite.hpp"
#include "simError.h"

#ifdef IS_MPI
#include "mpiSimulation.hpp"
#endif // is_mpi

InitializeFromFile :: InitializeFromFile( char *in_name ){
#ifdef IS_MPI
  if (worldRank == 0) {
#endif

  c_in_file = fopen(in_name, "r");
  if(c_in_file == NULL){
    sprintf(painCave.errMsg,
            "Cannot open file: %s\n", in_name);
    painCave.isFatal = 1;
    simError();
  }
  
  strcpy( c_in_name, in_name);
#ifdef IS_MPI
  }
 strcpy( checkPointMsg, "Infile opened for reading successfully." );
  MPIcheckPoint();
#endif
  return;  
}

InitializeFromFile :: ~InitializeFromFile( ){
#ifdef IS_MPI
  if (worldRank == 0) {
#endif
  int error;
  error = fclose( c_in_file );
  if( error ){
    sprintf( painCave.errMsg,
             "Error closing %s\n", c_in_name );
    simError();
  }
#ifdef IS_MPI
  }
  strcpy( checkPointMsg, "Infile closed successfully." );
  MPIcheckPoint();
#endif

  return;
}


void InitializeFromFile :: read_xyz( SimInfo* the_entry_plug ){

  int i; // loop counter

  const int BUFFERSIZE = 2000; // size of the read buffer
  int n_atoms; // the number of atoms
  char read_buffer[BUFFERSIZE]; //the line buffer for reading 
#ifdef IS_MPI
  char send_buffer[BUFFERSIZE];
#endif

  char *eof_test; // ptr to see when we reach the end of the file 
  char *parseErr;


  entry_plug = the_entry_plug


#ifndef IS_MPI
  eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
  if( eof_test == NULL ){
    sprintf( painCave.errMsg,
             "InitializeFromFile error: error reading 1st line of \"%s\"\n",
             c_in_name );
    painCave.isFatal = 1;
    simError();
  }

  n_atoms = atoi( read_buffer );

  Atom **atoms = entry_plug->atoms;
  DirectionalAtom* dAtom;

  if( n_atoms != entry_plug->n_atoms ){
    sprintf( painCave.errMsg,
             "Initialize from File error. %s n_atoms, %d, "
             "does not match the BASS file's n_atoms, %d.\n",
             c_in_name, n_atoms, entry_plug->n_atoms );
    painCave.isFatal = 1;
    simError();
  }
  
  //read and toss the comment line 
  
  eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
  if(eof_test == NULL){
    sprintf( painCave.errMsg,
             "error in reading commment in %s\n", c_in_name);
    painCave.isFatal = 1;
    simError();
  }

  for( i=0; i < n_atoms; i++){
    
    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
    if(eof_test == NULL){
      sprintf(painCave.errMsg,
              "error in reading file %s\n"
              "natoms  = %d; index = %d\n"
              "error reading the line from the file.\n",
              c_in_name, n_atoms, i );
      painCave.isFatal = 1;
      simError();
    }

    
    parseErr = parseDumpLine( read_buffer, i );
    if( parseErr != NULL ){
      strcpy( painCave.errMsg, parseErr );
      painCave.isFatal = 1;
      simError();
    }    
  }


  // MPI Section of code..........
#else //IS_MPI

  int masterIndex;
  int nodeAtomsStart;
  int nodeAtomsEnd;
  int mpiErr;
  int sendError;

  MPI_Status istatus[MPI_STATUS_SIZE];

  if (worldRank == 0) {
    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
    if( eof_test == NULL ){
      sprintf( painCave.errMsg,
               "Error reading 1st line of %d \n ",c_in_name);
      painCave.isFatal = 1;
      simError();
    }
    
    n_atoms = atoi( read_buffer );
    
    Atom **atoms = entry_plug->atoms;
    DirectionalAtom* dAtom;
 
    // Check to see that the number of atoms in the intial configuration file is the
    // same as declared in simBass.
    
    if( n_atoms != mpiSim->getTotAtoms() ){
      sprintf( painCave.errMsg,
               "Initialize from File error. %s n_atoms, %d, "
               "does not match the BASS file's n_atoms, %d.\n",
               c_in_name, n_atoms, entry_plug->n_atoms );
      painCave.isFatal = 1;
      simError();
    }
    
    //read and toss the comment line 
    
    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
    if(eof_test == NULL){
      sprintf( painCave.errMsg,
               "error in reading commment in %s\n", c_in_name);
      painCave.isFatal = 1;
      simError();
    }
  
    // Read Proc 0 share of the xyz file...
    masterIndex = 0;
    for( i=0; i <= mpiSim->getMyAtomEnd(); i++){
    
      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
      if(eof_test == NULL){
        sprintf(painCave.errMsg,
                "error in reading file %s\n"
                "natoms  = %d; index = %d\n"
                "error reading the line from the file.\n",
                c_in_name, n_atoms, i );
        painCave.isFatal = 1;
        simError();
      }
    
      parseErr = parseDumpLine( read_buffer, i );
      if( parseErr != NULL ){
        strcpy( painCave.errMsg, parseErr );
        painCave.isFatal = 1;
        simError();
      }    
      masterIndex++;
    }
  }

  sprintf(checkPointMsg,
          "Node 0 has successfully read positions from input file.");
  mpiCheckPoint();

  for (procIndex = 1; procIndex < entryPlug->mpiSim->getNumberProcessors();
         procIndex++){
    if (worldRank == 0) {

      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
               istatus);

      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
               istatus);
      // Make sure where node 0 is reading from, matches where the receiving node
      // expects it to be.

      if (masterIndex != nodeAtomsStart){
        sendError = 1;
        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
        sprintf(painCave.errMsg,
                "Initialize from file error: atoms start index (%d) for "
                "node %d not equal to master index (%d)",nodeAtomsStart,procIndex,masterIndex );
        painCave.isFatal = 1;
        simError();
      }
      sendError = 0;
      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
      
      for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
        eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
        if(eof_test == NULL){
          
          sprintf(read_buffer,"ERROR");
          mpiErr = MPI_Send(read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
          
          sprintf(painCave.errMsg,
                  "error in reading file %s\n"
                  "natoms  = %d; index = %d\n"
                  "error reading the line from the file.\n",
                  c_in_name, n_atoms, i );
          painCave.isFatal = 1;
          simError();
        }
        
        mpiErr = MPI_Send(read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
        mpiErr = MPI_Recv(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
                          istatus);
        if (sendError) mpiCheckpoint();

        masterIndex++;
      }
    }


    else if(worldRank == procIndex){
      nodeAtomStart = mpiSim->getMyAtomStart();
      nodeAtomEnd = mpiSim->getMyAtomEnd();
      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
      
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD,
               istatus);
      if (sendError) mpiCheckpoint();

      for ( i = 0; i < entry_plug->n_atoms, i++){

        mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,0,MPI_ANY_TAG,MPI_COMM_WORLD,
                          istatus);
        
        if(!strcmp(read_buffer, "ERROR")) mpiCheckPoint();
        
        parseErr = parseDumpLine( read_buffer, i );
        if( parseErr != NULL ){
          sendError = 1;
          mpiErr = MPI_Send(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);


          strcpy( painCave.errMsg, parseErr );
          painCave.isFatal = 1;
          simError();
        }
        sendError = 0;
        mpiErr = MPI_Send(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
      }
    }
    sprintf(checkPointMsg,"Node %d received initial configuration.",procIndex);
    mpiCheckPoint();
  }

#endif
}


char* IntitializeFromFile::parseDumpLine(char* readLine, int atomIndex){

  char *foo; // the pointer to the current string token 
  
  double rx, ry, rz; // position place holders
  double vx, vy, vz; // velocity placeholders
  double q[4]; // the quaternions
  double jx, jy, jz; // angular velocity placeholders;
  double qSqr, qLength; // needed to normalize the quaternion vector.
  
  Atom **atoms = entry_plug->atoms;
  DirectionalAtom* dAtom;
  
  int n_atoms;

#ifdef IS_MPI
  n_atoms = mpiSim->getTotAtoms();
#else
  n_atoms = entry_plug->n_atoms;
#endi // is_mpi


  // set the string tokenizer
  
  foo = strtok(readLine, " ,;\t");
  
  // check the atom name to the current atom
  
  if( strcmp( foo, atoms[atomIndex]->getType() ) ){
    sprintf( painCave.errMsg,
             "Initialize from file error. Atom %s at index %d "
             "in file %s does not"
             " match the BASS atom %s.\n",
             foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
    return strdup( painCave.errMsg );
  }
    
  // get the positions

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition x from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  rx = atof( foo );
   
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition y from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  ry = atof( foo );
     
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition z from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  rz = atof( foo );    


  // get the velocities

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity x from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vx = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity y from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vy = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity z from %s\n"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vz = atof( foo );
    
    
  // get the quaternions
    
  if( atoms[atomIndex]->isDirectional() ){
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf(painCave.errMsg,
              "error in reading quaternion 0 from %s\n"
              "natoms  = %d, index = %d\n",
              c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    q[0] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading quaternion 1 from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    q[1] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading quaternion 2 from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    q[2] = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading quaternion 3 from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    q[3] = atof( foo );
      
    // get the angular velocities
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading angular momentum jx from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    jx = atof( foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading angular momentum jy from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    jy = atof(foo );
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading angular momentum jz from %s\n"
               "natoms  = %d, index = %d\n",
               c_in_name, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    jz = atof( foo );
      
    dAtom = ( DirectionalAtom* )atoms[atomIndex];

    // check that the quaternion vector is normalized

    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
      
    qLength = sqrt( qSqr );
    q[0] = q[0] / qLength;
    q[1] = q[1] / qLength;
    q[2] = q[2] / qLength;
    q[3] = q[3] / qLength;
      
    dAtom->setQ( q );
      
    // add the angular velocities

    dAtom->setJx( jx );
    dAtom->setJy( jy );
    dAtom->setJz( jz );
  }
    
  // add the positions and velocities to the atom
    
  atoms[atomIndex]->setX( rx );
  atoms[atomIndex]->setY( ry );
  atoms[atomIndex]->setZ( rz );
    
  atoms[atomIndex]->set_vx( vx );
  atoms[atomIndex]->set_vy( vy );
  atoms[atomIndex]->set_vz( vz );

  return NULL;
}
Revision:	215
Committed:	Thu Dec 19 21:59:51 2002 UTC (21 years, 6 months ago) by chuckv
File size:	13280 byte(s)
Log Message:	+ added lennard-jones force module and corresponding class. + created forceFactory directory.
#	User	Rev	Content
1	mmeineke	10	#include <iostream>
2			#include <cmath>
3
4			#include <stdio.h>
5			#include <stdlib.h>
6			#include <string.h>
7			#include <unistd.h>
8			#include <sys/types.h>
9			#include <sys/stat.h>
10
11			#include "ReadWrite.hpp"
12	mmeineke	162	#include "simError.h"
13	mmeineke	10
14	chuckv	215	#ifdef IS_MPI
15			#include "mpiSimulation.hpp"
16			#endif // is_mpi
17	mmeineke	10
18			InitializeFromFile :: InitializeFromFile( char *in_name ){
19	chuckv	206	#ifdef IS_MPI
20			if (worldRank == 0) {
21			#endif
22	mmeineke	10
23			c_in_file = fopen(in_name, "r");
24			if(c_in_file == NULL){
25	mmeineke	162	sprintf(painCave.errMsg,
26			"Cannot open file: %s\n", in_name);
27			painCave.isFatal = 1;
28			simError();
29	mmeineke	10	}
30
31			strcpy( c_in_name, in_name);
32	chuckv	206	#ifdef IS_MPI
33			}
34			strcpy( checkPointMsg, "Infile opened for reading successfully." );
35			MPIcheckPoint();
36			#endif
37	mmeineke	10	return;
38			}
39
40			InitializeFromFile :: ~InitializeFromFile( ){
41	chuckv	206	#ifdef IS_MPI
42			if (worldRank == 0) {
43			#endif
44	mmeineke	10	int error;
45			error = fclose( c_in_file );
46			if( error ){
47	mmeineke	162	sprintf( painCave.errMsg,
48			"Error closing %s\n", c_in_name );
49			simError();
50	mmeineke	10	}
51	chuckv	206	#ifdef IS_MPI
52			}
53			strcpy( checkPointMsg, "Infile closed successfully." );
54			MPIcheckPoint();
55			#endif
56
57	mmeineke	10	return;
58			}
59
60
61	chuckv	206	void InitializeFromFile :: read_xyz( SimInfo* the_entry_plug ){
62	mmeineke	10
63			int i; // loop counter
64
65	mmeineke	209	const int BUFFERSIZE = 2000; // size of the read buffer
66	mmeineke	10	int n_atoms; // the number of atoms
67	mmeineke	209	char read_buffer[BUFFERSIZE]; //the line buffer for reading
68	chuckv	206	#ifdef IS_MPI
69	mmeineke	209	char send_buffer[BUFFERSIZE];
70	chuckv	206	#endif
71
72	mmeineke	10	char *eof_test; // ptr to see when we reach the end of the file
73	mmeineke	209	char *parseErr;
74	mmeineke	10
75
76	chuckv	206	entry_plug = the_entry_plug
77
78
79			#ifndef IS_MPI
80	mmeineke	10	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
81			if( eof_test == NULL ){
82	mmeineke	209	sprintf( painCave.errMsg,
83			"InitializeFromFile error: error reading 1st line of \"%s\"\n",
84			c_in_name );
85			painCave.isFatal = 1;
86			simError();
87	mmeineke	10	}
88
89	mmeineke	209	n_atoms = atoi( read_buffer );
90	mmeineke	10
91			Atom **atoms = entry_plug->atoms;
92			DirectionalAtom* dAtom;
93
94			if( n_atoms != entry_plug->n_atoms ){
95	mmeineke	162	sprintf( painCave.errMsg,
96	mmeineke	10	"Initialize from File error. %s n_atoms, %d, "
97			"does not match the BASS file's n_atoms, %d.\n",
98			c_in_name, n_atoms, entry_plug->n_atoms );
99	mmeineke	162	painCave.isFatal = 1;
100			simError();
101	mmeineke	10	}
102
103			//read and toss the comment line
104
105			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
106			if(eof_test == NULL){
107	mmeineke	162	sprintf( painCave.errMsg,
108			"error in reading commment in %s\n", c_in_name);
109			painCave.isFatal = 1;
110			simError();
111	mmeineke	10	}
112
113			for( i=0; i < n_atoms; i++){
114
115			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
116			if(eof_test == NULL){
117	mmeineke	162	sprintf(painCave.errMsg,
118			"error in reading file %s\n"
119			"natoms = %d; index = %d\n"
120			"error reading the line from the file.\n",
121			c_in_name, n_atoms, i );
122			painCave.isFatal = 1;
123			simError();
124	mmeineke	10	}
125
126
127	mmeineke	209	parseErr = parseDumpLine( read_buffer, i );
128			if( parseErr != NULL ){
129			strcpy( painCave.errMsg, parseErr );
130	mmeineke	162	painCave.isFatal = 1;
131			simError();
132	mmeineke	209	}
133	mmeineke	10	}
134	chuckv	206
135
136			// MPI Section of code..........
137			#else //IS_MPI
138
139	chuckv	212	int masterIndex;
140			int nodeAtomsStart;
141			int nodeAtomsEnd;
142			int mpiErr;
143			int sendError;
144	chuckv	206
145	chuckv	212	MPI_Status istatus[MPI_STATUS_SIZE];
146	chuckv	206
147			if (worldRank == 0) {
148			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
149			if( eof_test == NULL ){
150			sprintf( painCave.errMsg,
151			"Error reading 1st line of %d \n ",c_in_name);
152			painCave.isFatal = 1;
153			simError();
154			}
155
156	mmeineke	209	n_atoms = atoi( read_buffer );
157	chuckv	206
158			Atom **atoms = entry_plug->atoms;
159			DirectionalAtom* dAtom;
160	chuckv	212
161			// Check to see that the number of atoms in the intial configuration file is the
162			// same as declared in simBass.
163	chuckv	206
164	chuckv	215	if( n_atoms != mpiSim->getTotAtoms() ){
165	chuckv	206	sprintf( painCave.errMsg,
166			"Initialize from File error. %s n_atoms, %d, "
167			"does not match the BASS file's n_atoms, %d.\n",
168			c_in_name, n_atoms, entry_plug->n_atoms );
169			painCave.isFatal = 1;
170			simError();
171			}
172
173			//read and toss the comment line
174
175			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
176			if(eof_test == NULL){
177			sprintf( painCave.errMsg,
178			"error in reading commment in %s\n", c_in_name);
179			painCave.isFatal = 1;
180			simError();
181			}
182	chuckv	212
183			// Read Proc 0 share of the xyz file...
184			masterIndex = 0;
185	chuckv	215	for( i=0; i <= mpiSim->getMyAtomEnd(); i++){
186	chuckv	212
187			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
188			if(eof_test == NULL){
189			sprintf(painCave.errMsg,
190			"error in reading file %s\n"
191			"natoms = %d; index = %d\n"
192			"error reading the line from the file.\n",
193			c_in_name, n_atoms, i );
194			painCave.isFatal = 1;
195			simError();
196			}
197
198			parseErr = parseDumpLine( read_buffer, i );
199			if( parseErr != NULL ){
200			strcpy( painCave.errMsg, parseErr );
201			painCave.isFatal = 1;
202			simError();
203			}
204			masterIndex++;
205			}
206	chuckv	206	}
207	mmeineke	209
208	chuckv	212	sprintf(checkPointMsg,
209			"Node 0 has successfully read positions from input file.");
210			mpiCheckPoint();
211
212			for (procIndex = 1; procIndex < entryPlug->mpiSim->getNumberProcessors();
213			procIndex++){
214			if (worldRank == 0) {
215
216			mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
217			istatus);
218
219			mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
220			istatus);
221			// Make sure where node 0 is reading from, matches where the receiving node
222			// expects it to be.
223
224			if (masterIndex != nodeAtomsStart){
225			sendError = 1;
226			mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
227			sprintf(painCave.errMsg,
228			"Initialize from file error: atoms start index (%d) for "
229			"node %d not equal to master index (%d)",nodeAtomsStart,procIndex,masterIndex );
230			painCave.isFatal = 1;
231			simError();
232			}
233			sendError = 0;
234			mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
235
236			for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
237			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
238			if(eof_test == NULL){
239
240			sprintf(read_buffer,"ERROR");
241			mpiErr = MPI_Send(read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
242
243			sprintf(painCave.errMsg,
244			"error in reading file %s\n"
245			"natoms = %d; index = %d\n"
246			"error reading the line from the file.\n",
247			c_in_name, n_atoms, i );
248			painCave.isFatal = 1;
249			simError();
250			}
251
252			mpiErr = MPI_Send(read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD);
253			mpiErr = MPI_Recv(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,MPI_COMM_WORLD,
254			istatus);
255			if (sendError) mpiCheckpoint();
256
257			masterIndex++;
258			}
259	chuckv	206	}
260	chuckv	212
261
262			else if(worldRank == procIndex){
263	chuckv	215	nodeAtomStart = mpiSim->getMyAtomStart();
264			nodeAtomEnd = mpiSim->getMyAtomEnd();
265	chuckv	212	mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
266			mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
267
268			mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD,
269			istatus);
270			if (sendError) mpiCheckpoint();
271
272			for ( i = 0; i < entry_plug->n_atoms, i++){
273
274			mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,0,MPI_ANY_TAG,MPI_COMM_WORLD,
275			istatus);
276
277			if(!strcmp(read_buffer, "ERROR")) mpiCheckPoint();
278
279			parseErr = parseDumpLine( read_buffer, i );
280			if( parseErr != NULL ){
281			sendError = 1;
282			mpiErr = MPI_Send(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
283
284
285			strcpy( painCave.errMsg, parseErr );
286			painCave.isFatal = 1;
287			simError();
288			}
289			sendError = 0;
290			mpiErr = MPI_Send(&sendError,1,MPI_INT,0,MPI_ANY_TAG,MPI_COMM_WORLD);
291			}
292			}
293			sprintf(checkPointMsg,"Node %d received initial configuration.",procIndex);
294			mpiCheckPoint();
295	mmeineke	209	}
296	chuckv	212
297	mmeineke	209	#endif
298			}
299
300
301			char* IntitializeFromFile::parseDumpLine(char* readLine, int atomIndex){
302
303			char *foo; // the pointer to the current string token
304
305			double rx, ry, rz; // position place holders
306			double vx, vy, vz; // velocity placeholders
307			double q[4]; // the quaternions
308			double jx, jy, jz; // angular velocity placeholders;
309			double qSqr, qLength; // needed to normalize the quaternion vector.
310
311			Atom **atoms = entry_plug->atoms;
312			DirectionalAtom* dAtom;
313
314			int n_atoms;
315
316			#ifdef IS_MPI
317	chuckv	215	n_atoms = mpiSim->getTotAtoms();
318	mmeineke	209	#else
319			n_atoms = entry_plug->n_atoms;
320			#endi // is_mpi
321
322
323			// set the string tokenizer
324
325			foo = strtok(readLine, " ,;\t");
326
327			// check the atom name to the current atom
328
329			if( strcmp( foo, atoms[atomIndex]->getType() ) ){
330			sprintf( painCave.errMsg,
331			"Initialize from file error. Atom %s at index %d "
332			"in file %s does not"
333			" match the BASS atom %s.\n",
334			foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
335			return strdup( painCave.errMsg );
336			}
337	chuckv	206
338	mmeineke	209	// get the positions
339	chuckv	206
340	mmeineke	209	foo = strtok(NULL, " ,;\t");
341			if(foo == NULL){
342			sprintf( painCave.errMsg,
343			"error in reading postition x from %s\n"
344			"natoms = %d, index = %d\n",
345			c_in_name, n_atoms, atomIndex );
346			return strdup( painCave.errMsg );
347			}
348			rx = atof( foo );
349
350			foo = strtok(NULL, " ,;\t");
351			if(foo == NULL){
352			sprintf( painCave.errMsg,
353			"error in reading postition y from %s\n"
354			"natoms = %d, index = %d\n",
355			c_in_name, n_atoms, atomIndex );
356			return strdup( painCave.errMsg );
357			}
358			ry = atof( foo );
359
360			foo = strtok(NULL, " ,;\t");
361			if(foo == NULL){
362			sprintf( painCave.errMsg,
363			"error in reading postition z from %s\n"
364			"natoms = %d, index = %d\n",
365			c_in_name, n_atoms, atomIndex );
366			return strdup( painCave.errMsg );
367			}
368			rz = atof( foo );
369
370
371			// get the velocities
372
373			foo = strtok(NULL, " ,;\t");
374			if(foo == NULL){
375			sprintf( painCave.errMsg,
376			"error in reading velocity x from %s\n"
377			"natoms = %d, index = %d\n",
378			c_in_name, n_atoms, atomIndex );
379			return strdup( painCave.errMsg );
380			}
381			vx = atof( foo );
382
383			foo = strtok(NULL, " ,;\t");
384			if(foo == NULL){
385			sprintf( painCave.errMsg,
386			"error in reading velocity y from %s\n"
387			"natoms = %d, index = %d\n",
388			c_in_name, n_atoms, atomIndex );
389			return strdup( painCave.errMsg );
390			}
391			vy = atof( foo );
392
393			foo = strtok(NULL, " ,;\t");
394			if(foo == NULL){
395			sprintf( painCave.errMsg,
396			"error in reading velocity z from %s\n"
397			"natoms = %d, index = %d\n",
398			c_in_name, n_atoms, atomIndex );
399			return strdup( painCave.errMsg );
400			}
401			vz = atof( foo );
402
403
404			// get the quaternions
405
406			if( atoms[atomIndex]->isDirectional() ){
407
408	chuckv	206	foo = strtok(NULL, " ,;\t");
409			if(foo == NULL){
410	mmeineke	209	sprintf(painCave.errMsg,
411			"error in reading quaternion 0 from %s\n"
412			"natoms = %d, index = %d\n",
413			c_in_name, n_atoms, atomIndex );
414			return strdup( painCave.errMsg );
415			}
416			q[0] = atof( foo );
417
418			foo = strtok(NULL, " ,;\t");
419			if(foo == NULL){
420	chuckv	206	sprintf( painCave.errMsg,
421	mmeineke	209	"error in reading quaternion 1 from %s\n"
422	chuckv	206	"natoms = %d, index = %d\n",
423	mmeineke	209	c_in_name, n_atoms, atomIndex );
424			return strdup( painCave.errMsg );
425	chuckv	206	}
426	mmeineke	209	q[1] = atof( foo );
427
428	chuckv	206	foo = strtok(NULL, " ,;\t");
429			if(foo == NULL){
430			sprintf( painCave.errMsg,
431	mmeineke	209	"error in reading quaternion 2 from %s\n"
432	chuckv	206	"natoms = %d, index = %d\n",
433	mmeineke	209	c_in_name, n_atoms, atomIndex );
434			return strdup( painCave.errMsg );
435	chuckv	206	}
436	mmeineke	209	q[2] = atof( foo );
437
438	chuckv	206	foo = strtok(NULL, " ,;\t");
439			if(foo == NULL){
440			sprintf( painCave.errMsg,
441	mmeineke	209	"error in reading quaternion 3 from %s\n"
442	chuckv	206	"natoms = %d, index = %d\n",
443	mmeineke	209	c_in_name, n_atoms, atomIndex );
444			return strdup( painCave.errMsg );
445	chuckv	206	}
446	mmeineke	209	q[3] = atof( foo );
447
448			// get the angular velocities
449
450	chuckv	206	foo = strtok(NULL, " ,;\t");
451			if(foo == NULL){
452			sprintf( painCave.errMsg,
453	mmeineke	209	"error in reading angular momentum jx from %s\n"
454	chuckv	206	"natoms = %d, index = %d\n",
455	mmeineke	209	c_in_name, n_atoms, atomIndex );
456			return strdup( painCave.errMsg );
457	chuckv	206	}
458	mmeineke	209	jx = atof( foo );
459
460	chuckv	206	foo = strtok(NULL, " ,;\t");
461			if(foo == NULL){
462			sprintf( painCave.errMsg,
463	mmeineke	209	"error in reading angular momentum jy from %s\n"
464	chuckv	206	"natoms = %d, index = %d\n",
465	mmeineke	209	c_in_name, n_atoms, atomIndex );
466			return strdup( painCave.errMsg );
467	chuckv	206	}
468	mmeineke	209	jy = atof(foo );
469
470	chuckv	206	foo = strtok(NULL, " ,;\t");
471			if(foo == NULL){
472			sprintf( painCave.errMsg,
473	mmeineke	209	"error in reading angular momentum jz from %s\n"
474	chuckv	206	"natoms = %d, index = %d\n",
475	mmeineke	209	c_in_name, n_atoms, atomIndex );
476			return strdup( painCave.errMsg );
477	chuckv	206	}
478	mmeineke	209	jz = atof( foo );
479	chuckv	206
480	mmeineke	209	dAtom = ( DirectionalAtom* )atoms[atomIndex];
481	chuckv	206
482	mmeineke	209	// check that the quaternion vector is normalized
483	chuckv	206
484	mmeineke	209	qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
485	chuckv	206
486	mmeineke	209	qLength = sqrt( qSqr );
487			q[0] = q[0] / qLength;
488			q[1] = q[1] / qLength;
489			q[2] = q[2] / qLength;
490			q[3] = q[3] / qLength;
491	chuckv	206
492	mmeineke	209	dAtom->setQ( q );
493	chuckv	206
494	mmeineke	209	// add the angular velocities
495	chuckv	206
496	mmeineke	209	dAtom->setJx( jx );
497			dAtom->setJy( jy );
498			dAtom->setJz( jz );
499			}
500	chuckv	206
501	mmeineke	209	// add the positions and velocities to the atom
502	chuckv	206
503	mmeineke	209	atoms[atomIndex]->setX( rx );
504			atoms[atomIndex]->setY( ry );
505			atoms[atomIndex]->setZ( rz );
506	chuckv	206
507	mmeineke	209	atoms[atomIndex]->set_vx( vx );
508			atoms[atomIndex]->set_vy( vy );
509			atoms[atomIndex]->set_vz( vz );
510
511			return NULL;
512	mmeineke	10	}