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"

#define TAKE_THIS_TAG 0
#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;
  int procIndex;

  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 < mpiSim->getNumberProcessors();
         procIndex++){
    if (worldRank == 0) {

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

      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,TAKE_THIS_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,TAKE_THIS_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,TAKE_THIS_TAG,MPI_COMM_WORLD);
      
      for ( i = nodeAtomsStart; i <= nodeAtomsEnd; 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,TAKE_THIS_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,TAKE_THIS_TAG,MPI_COMM_WORLD);
        mpiErr = MPI_Recv(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,MPI_COMM_WORLD,
                          istatus);
        if (sendError) MPIcheckPoint();

        masterIndex++;
      }
    }


    else if(worldRank == procIndex){
      nodeAtomsStart = mpiSim->getMyAtomStart();
      nodeAtomsEnd = mpiSim->getMyAtomEnd();
      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,TAKE_THIS_TAG,MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,TAKE_THIS_TAG,MPI_COMM_WORLD);
      
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,TAKE_THIS_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,TAKE_THIS_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,TAKE_THIS_TAG,MPI_COMM_WORLD);


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

#endif
}


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