OOPSE/libmdtools/InitializeFromFile.cpp

#define _FILE_OFFSET_BITS 64
#include <iostream>
#include <math.h>

#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"
#include "GenericData.hpp"

#ifdef IS_MPI
#include <mpi.h>
#include "mpiSimulation.hpp"
#define TAKE_THIS_TAG_CHAR 0
#define TAKE_THIS_TAG_INT 1

namespace initFile{
  void nodeZeroError( void );
  void anonymousNodeDie( void );
}

using namespace initFile;

#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
  }
  else{
          sprintf( c_in_name, "mpiNodeParser_%d", worldRank );
  }
  
  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 :: readInit( SimInfo* the_simnfo ){

  int i, j;

#ifdef IS_MPI
  int done, which_node, which_atom; // loop counter
#endif //is_mpi

  const int BUFFERSIZE = 2000; // size of the read buffer
  int nTotObjs; // the number of atoms
  char read_buffer[BUFFERSIZE]; //the line buffer for reading

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

  vector<StuntDouble*> integrableObjects;
  vector<StuntDouble*>::iterator iter;

  simnfo = the_simnfo;


#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();
  }

  nTotObjs = atoi( read_buffer );

  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
    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, nTotObjs, simnfo->getTotIntegrableObjects());
    painCave.isFatal = 1;
    simError();
  }

  //read the box mat from 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();
  }

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

  //parse dump lines

  for( i=0; i < simnfo->n_mol; i++){

    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();

    for(iter = integrableObjects.begin(); iter!= integrableObjects.end(); iter++)

      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, nTotObjs, i );
        painCave.isFatal = 1;
        simError();
      }
      
      parseErr = parseDumpLine( read_buffer, *iter);
      if( parseErr != NULL ){
        strcpy( painCave.errMsg, parseErr );
        painCave.isFatal = 1;
        simError();
      }
  }


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

  // first thing first, suspend fatalities.
  painCave.isEventLoop = 1;

  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
  int haveError;

  MPI_Status istatus;
  int *MolToProcMap = mpiSim->getMolToProcMap();
  int localIndex;
  int nCurObj;

  haveError = 0;
  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 %s \n ",c_in_name);
      haveError = 1;
      simError();
    }

    nTotObjs = atoi( read_buffer );

    // Check to see that the number of integrable objects  in the intial configuration file is the
    // same as declared in simBass.

    if( nTotObjs != simnfo->getTotIntegrableObjects()){
      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, nTotObjs, simnfo->getTotIntegrableObjects());
      haveError= 1;
      simError();
    }

    //read the boxMat from 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);
      haveError = 1;
      simError();
    }

    //Every single processor will parse the comment line by itself
    //By using this way, we might lose some efficiency, but if we want to add
    //more parameters into comment line, we only need to modify function
    //parseCommentLine

    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);

    parseErr = parseCommentLine( read_buffer, simnfo);

    if( parseErr != NULL ){
      strcpy( painCave.errMsg, parseErr );
      haveError = 1;
      simError();
    }

    for (i=0 ; i < mpiSim->getTotNmol(); i++) {
      which_node = MolToProcMap[i];
      if(which_node == 0){
       //molecules belong to master node

      localIndex = mpiSim->getGlobalToLocalMol(i);

      if(localIndex == -1) {
        strcpy(painCave.errMsg, "Molecule not found on node 0!");
        haveError = 1;
        simError();
      }

       integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
       for(j=0; j < integrableObjects.size(); j++){
        
          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, nTotObjs, i );
                haveError= 1;
                simError();
          }
          
          if(haveError) nodeZeroError();

          parseDumpLine(read_buffer, integrableObjects[i]);
           
       }


      }
      else{
      //molecule belongs to slave nodes

        MPI_Recv(&nCurObj, 1, MPI_INT, 0,
               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
      
       for(j=0; j < integrableObjects.size(); j++){
        
          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, nTotObjs, i );
                haveError= 1;
                simError();
          }
          
          if(haveError) nodeZeroError();

            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
           
       }

      }
      
    }
    
  }
  else{
  //actions taken at slave nodes
    for (i=0 ; i < mpiSim->getTotNmol(); i++) {
      which_node = MolToProcMap[i];
      
      if(which_node == worldRank){
      //molecule with global index i belongs to this processor
      
        localIndex = mpiSim->getGlobalToLocalMol(i);

        if(localIndex == -1) {
          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
          haveError = 1;
          simError();
        }

        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        

        nCurObj = integrableObjects.size();
        
        MPI_Recv(&nCurObj, 1, MPI_INT, 0,
                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);

        for(j = 0; j < integrableObjects.size(); j++){

          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);

          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);

          if( parseErr != NULL ){
                strcpy( painCave.errMsg, parseErr );
                simError();
          }

        }
          
      }
      
    }

  }
#endif
}

char* InitializeFromFile::parseDumpLine(char* readLine, StuntDouble* sd){

  char *foo; // the pointer to the current string token

  double pos[3]; // position place holders
  double vel[3]; // velocity placeholders
  double q[4]; // the quaternions
  double ji[3]; // angular velocity placeholders;
  double qSqr, qLength; // needed to normalize the quaternion vector.


  // set the string tokenizer

  foo = strtok(readLine, " ,;\t");

  // check the atom name to the current atom

  if( strcmp( foo, sd->getType() ) ){
    sprintf( painCave.errMsg,
             "Initialize from file error.  Does not"
             " match the BASS atom %s.\n",
             sd->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",
             c_in_name);
    return strdup( painCave.errMsg );
  }
  pos[0] = atof( foo );

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition y from %s\n",
             c_in_name);
    return strdup( painCave.errMsg );
  }
  pos[1] = atof( foo );

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition z from %s\n",
             c_in_name);
    return strdup( painCave.errMsg );
  }
  pos[2] = atof( foo );


  // get the velocities

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity x from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  vel[0] = atof( foo );

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity x from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  vel[1] = atof( foo );

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity x from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  vel[2] = atof( foo );


  // add the positions and velocities to the atom

  sd->setPos( pos );
  sd->setVel( vel );

  if (!sd->isDirectional())
    return NULL;

  // get the quaternions

  if( sd->isDirectional() ){

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    q[0] = atof( foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    q[1] = atof( foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    q[2] = atof( foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      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 velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    ji[0] = atof( foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    ji[1] = atof(foo );

    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
                     "error in reading velocity x from %s\n",
                      c_in_name );
      return strdup( painCave.errMsg );
    }
    ji[2] = atof( foo );


    // 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;

    // add quaternion and angular velocities

    sd->setQ( q );
    sd->setJ( ji );
  }


  return NULL;
}


char* InitializeFromFile::parseCommentLine(char* readLine, SimInfo* entry_plug){

  double currTime;
  double boxMat[9];
  double theBoxMat3[3][3];
  double chi;
  double integralOfChidt;
  double eta[9];

  char *foo; // the pointer to the current string token

  // set the string tokenizer

  foo = strtok(readLine, " ,;\t");
  // set the timeToken.

  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Time from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }

  currTime = atof( foo );
  entry_plug->setTime( currTime );

  //get H-Matrix

  for(int i = 0 ; i < 9; i++){
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf( painCave.errMsg,
               "error in reading H[%d] from %s\n", i, c_in_name );
      return strdup( painCave.errMsg );
    }
    boxMat[i] = atof( foo );
  }

  for(int i=0;i<3;i++)
    for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];

  //set H-Matrix
  entry_plug->setBoxM( theBoxMat3 );

  //get chi and integralOfChidt, they should appear by pair

  if( entry_plug->useInitXSstate ){
    foo = strtok(NULL, " ,;\t\n");
    if(foo != NULL){
      chi = atof(foo);
      
      foo = strtok(NULL, " ,;\t\n");
      if(foo == NULL){
        sprintf( painCave.errMsg,
                 "chi and integralOfChidt should appear by pair in %s\n", c_in_name );
        return strdup( painCave.errMsg );
      }
      integralOfChidt = atof( foo );
      
      //push chi and integralOfChidt into SimInfo::properties which can be
      //retrieved by integrator later
      DoubleData* chiValue = new DoubleData();
      chiValue->setID(CHIVALUE_ID);
      chiValue->setData(chi);
      entry_plug->addProperty(chiValue);
      
      DoubleData* integralOfChidtValue = new DoubleData();
      integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
      integralOfChidtValue->setData(integralOfChidt);
      entry_plug->addProperty(integralOfChidtValue);
      
    }
    else
      return NULL;
    
    //get eta
    foo = strtok(NULL, " ,;\t\n");
    if(foo != NULL ){
  
      for(int i = 0 ; i < 9; i++){
        
        if(foo == NULL){
          sprintf( painCave.errMsg,
                   "error in reading eta[%d] from %s\n", i, c_in_name );
          return strdup( painCave.errMsg );
        }
        eta[i] = atof( foo );
        foo = strtok(NULL, " ,;\t\n");
      }
    }
    else
      return NULL;
    
    //push eta into SimInfo::properties which can be
    //retrieved by integrator later
    //entry_plug->setBoxM( theBoxMat3 );
    DoubleArrayData* etaValue = new DoubleArrayData();
    etaValue->setID(ETAVALUE_ID);
    etaValue->setData(eta, 9);
    entry_plug->addProperty(etaValue);
  }

  return NULL;
}

#ifdef IS_MPI

// a couple of functions to let us escape the read loop

void initFile::nodeZeroError( void ){
  int j, myStatus;

  myStatus = 0;
  for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
    MPI_Send( &myStatus, 1, MPI_INT, j,
              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
  }


  MPI_Finalize();
  exit (0);

}

void initFile::anonymousNodeDie( void ){

  MPI_Finalize();
  exit (0);
}

#endif //is_mpi
Revision:	1108
Committed:	Wed Apr 14 15:37:41 2004 UTC (20 years, 2 months ago) by tim
File size:	15806 byte(s)
Log Message:	Change DumpWriter and InitFromFile
#	Content
1	#define _FILE_OFFSET_BITS 64
2	#include <iostream>
3	#include <math.h>
4
5	#include <stdio.h>
6	#include <stdlib.h>
7	#include <string.h>
8	#include <unistd.h>
9	#include <sys/types.h>
10	#include <sys/stat.h>
11
12	#include "ReadWrite.hpp"
13	#include "simError.h"
14	#include "GenericData.hpp"
15
16	#ifdef IS_MPI
17	#include <mpi.h>
18	#include "mpiSimulation.hpp"
19	#define TAKE_THIS_TAG_CHAR 0
20	#define TAKE_THIS_TAG_INT 1
21
22	namespace initFile{
23	void nodeZeroError( void );
24	void anonymousNodeDie( void );
25	}
26
27	using namespace initFile;
28
29	#endif // is_mpi
30
31	InitializeFromFile::InitializeFromFile( char *in_name ){
32
33	#ifdef IS_MPI
34	if (worldRank == 0) {
35	#endif
36
37	c_in_file = fopen(in_name, "r");
38	if(c_in_file == NULL){
39	sprintf(painCave.errMsg,
40	"Cannot open file: %s\n", in_name);
41	painCave.isFatal = 1;
42	simError();
43	}
44
45	strcpy( c_in_name, in_name);
46	#ifdef IS_MPI
47	}
48	else{
49	sprintf( c_in_name, "mpiNodeParser_%d", worldRank );
50	}
51
52	strcpy( checkPointMsg, "Infile opened for reading successfully." );
53	MPIcheckPoint();
54	#endif
55	return;
56	}
57
58	InitializeFromFile::~InitializeFromFile( ){
59	#ifdef IS_MPI
60	if (worldRank == 0) {
61	#endif
62	int error;
63	error = fclose( c_in_file );
64	if( error ){
65	sprintf( painCave.errMsg,
66	"Error closing %s\n", c_in_name );
67	simError();
68	}
69	#ifdef IS_MPI
70	}
71	strcpy( checkPointMsg, "Infile closed successfully." );
72	MPIcheckPoint();
73	#endif
74
75	return;
76	}
77
78
79	void InitializeFromFile :: readInit( SimInfo* the_simnfo ){
80
81	int i, j;
82
83	#ifdef IS_MPI
84	int done, which_node, which_atom; // loop counter
85	#endif //is_mpi
86
87	const int BUFFERSIZE = 2000; // size of the read buffer
88	int nTotObjs; // the number of atoms
89	char read_buffer[BUFFERSIZE]; //the line buffer for reading
90
91	char *eof_test; // ptr to see when we reach the end of the file
92	char *parseErr;
93
94	vector<StuntDouble*> integrableObjects;
95	vector<StuntDouble*>::iterator iter;
96
97	simnfo = the_simnfo;
98
99
100	#ifndef IS_MPI
101	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
102	if( eof_test == NULL ){
103	sprintf( painCave.errMsg,
104	"InitializeFromFile error: error reading 1st line of \"%s\"\n",
105	c_in_name );
106	painCave.isFatal = 1;
107	simError();
108	}
109
110	nTotObjs = atoi( read_buffer );
111
112	if( nTotObjs != simnfo->getTotIntegrableObjects() ){
113	sprintf( painCave.errMsg,
114	"Initialize from File error. %s n_atoms, %d, "
115	"does not match the BASS file's n_atoms, %d.\n",
116	c_in_name, nTotObjs, simnfo->getTotIntegrableObjects());
117	painCave.isFatal = 1;
118	simError();
119	}
120
121	//read the box mat from the comment line
122
123	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
124	if(eof_test == NULL){
125	sprintf( painCave.errMsg,
126	"error in reading commment in %s\n", c_in_name);
127	painCave.isFatal = 1;
128	simError();
129	}
130
131	parseErr = parseCommentLine( read_buffer, simnfo);
132	if( parseErr != NULL ){
133	strcpy( painCave.errMsg, parseErr );
134	painCave.isFatal = 1;
135	simError();
136	}
137
138	//parse dump lines
139
140	for( i=0; i < simnfo->n_mol; i++){
141
142	integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
143
144	for(iter = integrableObjects.begin(); iter!= integrableObjects.end(); iter++)
145
146	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
147	if(eof_test == NULL){
148	sprintf(painCave.errMsg,
149	"error in reading file %s\n"
150	"natoms = %d; index = %d\n"
151	"error reading the line from the file.\n",
152	c_in_name, nTotObjs, i );
153	painCave.isFatal = 1;
154	simError();
155	}
156
157	parseErr = parseDumpLine( read_buffer, *iter);
158	if( parseErr != NULL ){
159	strcpy( painCave.errMsg, parseErr );
160	painCave.isFatal = 1;
161	simError();
162	}
163	}
164
165
166	// MPI Section of code..........
167	#else //IS_MPI
168
169	// first thing first, suspend fatalities.
170	painCave.isEventLoop = 1;
171
172	int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
173	int haveError;
174
175	MPI_Status istatus;
176	int *MolToProcMap = mpiSim->getMolToProcMap();
177	int localIndex;
178	int nCurObj;
179
180	haveError = 0;
181	if (worldRank == 0) {
182
183	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
184	if( eof_test == NULL ){
185	sprintf( painCave.errMsg,
186	"Error reading 1st line of %s \n ",c_in_name);
187	haveError = 1;
188	simError();
189	}
190
191	nTotObjs = atoi( read_buffer );
192
193	// Check to see that the number of integrable objects in the intial configuration file is the
194	// same as declared in simBass.
195
196	if( nTotObjs != simnfo->getTotIntegrableObjects()){
197	sprintf( painCave.errMsg,
198	"Initialize from File error. %s n_atoms, %d, "
199	"does not match the BASS file's n_atoms, %d.\n",
200	c_in_name, nTotObjs, simnfo->getTotIntegrableObjects());
201	haveError= 1;
202	simError();
203	}
204
205	//read the boxMat from the comment line
206
207	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
208	if(eof_test == NULL){
209	sprintf( painCave.errMsg,
210	"error in reading commment in %s\n", c_in_name);
211	haveError = 1;
212	simError();
213	}
214
215	//Every single processor will parse the comment line by itself
216	//By using this way, we might lose some efficiency, but if we want to add
217	//more parameters into comment line, we only need to modify function
218	//parseCommentLine
219
220	MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
221
222	parseErr = parseCommentLine( read_buffer, simnfo);
223
224	if( parseErr != NULL ){
225	strcpy( painCave.errMsg, parseErr );
226	haveError = 1;
227	simError();
228	}
229
230	for (i=0 ; i < mpiSim->getTotNmol(); i++) {
231	which_node = MolToProcMap[i];
232	if(which_node == 0){
233	//molecules belong to master node
234
235	localIndex = mpiSim->getGlobalToLocalMol(i);
236
237	if(localIndex == -1) {
238	strcpy(painCave.errMsg, "Molecule not found on node 0!");
239	haveError = 1;
240	simError();
241	}
242
243	integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
244	for(j=0; j < integrableObjects.size(); j++){
245
246	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
247	if(eof_test == NULL){
248	sprintf(painCave.errMsg,
249	"error in reading file %s\n"
250	"natoms = %d; index = %d\n"
251	"error reading the line from the file.\n",
252	c_in_name, nTotObjs, i );
253	haveError= 1;
254	simError();
255	}
256
257	if(haveError) nodeZeroError();
258
259	parseDumpLine(read_buffer, integrableObjects[i]);
260
261	}
262
263
264	}
265	else{
266	//molecule belongs to slave nodes
267
268	MPI_Recv(&nCurObj, 1, MPI_INT, 0,
269	TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
270
271	for(j=0; j < integrableObjects.size(); j++){
272
273	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
274	if(eof_test == NULL){
275	sprintf(painCave.errMsg,
276	"error in reading file %s\n"
277	"natoms = %d; index = %d\n"
278	"error reading the line from the file.\n",
279	c_in_name, nTotObjs, i );
280	haveError= 1;
281	simError();
282	}
283
284	if(haveError) nodeZeroError();
285
286	MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
287	TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
288
289	}
290
291	}
292
293	}
294
295	}
296	else{
297	//actions taken at slave nodes
298	for (i=0 ; i < mpiSim->getTotNmol(); i++) {
299	which_node = MolToProcMap[i];
300
301	if(which_node == worldRank){
302	//molecule with global index i belongs to this processor
303
304	localIndex = mpiSim->getGlobalToLocalMol(i);
305
306	if(localIndex == -1) {
307	sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
308	haveError = 1;
309	simError();
310	}
311
312	integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
313
314	nCurObj = integrableObjects.size();
315
316	MPI_Recv(&nCurObj, 1, MPI_INT, 0,
317	TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
318
319	for(j = 0; j < integrableObjects.size(); j++){
320
321	MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
322	TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
323
324	parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
325
326	if( parseErr != NULL ){
327	strcpy( painCave.errMsg, parseErr );
328	simError();
329	}
330
331	}
332
333	}
334
335	}
336
337	}
338	#endif
339	}
340
341	char* InitializeFromFile::parseDumpLine(char* readLine, StuntDouble* sd){
342
343	char *foo; // the pointer to the current string token
344
345	double pos[3]; // position place holders
346	double vel[3]; // velocity placeholders
347	double q[4]; // the quaternions
348	double ji[3]; // angular velocity placeholders;
349	double qSqr, qLength; // needed to normalize the quaternion vector.
350
351
352	// set the string tokenizer
353
354	foo = strtok(readLine, " ,;\t");
355
356	// check the atom name to the current atom
357
358	if( strcmp( foo, sd->getType() ) ){
359	sprintf( painCave.errMsg,
360	"Initialize from file error. Does not"
361	" match the BASS atom %s.\n",
362	sd->getType() );
363	return strdup( painCave.errMsg );
364	}
365
366	// get the positions
367
368	foo = strtok(NULL, " ,;\t");
369	if(foo == NULL){
370	sprintf( painCave.errMsg,
371	"error in reading postition x from %s\n",
372	c_in_name);
373	return strdup( painCave.errMsg );
374	}
375	pos[0] = atof( foo );
376
377	foo = strtok(NULL, " ,;\t");
378	if(foo == NULL){
379	sprintf( painCave.errMsg,
380	"error in reading postition y from %s\n",
381	c_in_name);
382	return strdup( painCave.errMsg );
383	}
384	pos[1] = atof( foo );
385
386	foo = strtok(NULL, " ,;\t");
387	if(foo == NULL){
388	sprintf( painCave.errMsg,
389	"error in reading postition z from %s\n",
390	c_in_name);
391	return strdup( painCave.errMsg );
392	}
393	pos[2] = atof( foo );
394
395
396	// get the velocities
397
398	foo = strtok(NULL, " ,;\t");
399	if(foo == NULL){
400	sprintf( painCave.errMsg,
401	"error in reading velocity x from %s\n",
402	c_in_name );
403	return strdup( painCave.errMsg );
404	}
405	vel[0] = atof( foo );
406
407	foo = strtok(NULL, " ,;\t");
408	if(foo == NULL){
409	sprintf( painCave.errMsg,
410	"error in reading velocity x from %s\n",
411	c_in_name );
412	return strdup( painCave.errMsg );
413	}
414	vel[1] = atof( foo );
415
416	foo = strtok(NULL, " ,;\t");
417	if(foo == NULL){
418	sprintf( painCave.errMsg,
419	"error in reading velocity x from %s\n",
420	c_in_name );
421	return strdup( painCave.errMsg );
422	}
423	vel[2] = atof( foo );
424
425
426	// add the positions and velocities to the atom
427
428	sd->setPos( pos );
429	sd->setVel( vel );
430
431	if (!sd->isDirectional())
432	return NULL;
433
434	// get the quaternions
435
436	if( sd->isDirectional() ){
437
438	foo = strtok(NULL, " ,;\t");
439	if(foo == NULL){
440	sprintf( painCave.errMsg,
441	"error in reading velocity x from %s\n",
442	c_in_name );
443	return strdup( painCave.errMsg );
444	}
445	q[0] = atof( foo );
446
447	foo = strtok(NULL, " ,;\t");
448	if(foo == NULL){
449	sprintf( painCave.errMsg,
450	"error in reading velocity x from %s\n",
451	c_in_name );
452	return strdup( painCave.errMsg );
453	}
454	q[1] = atof( foo );
455
456	foo = strtok(NULL, " ,;\t");
457	if(foo == NULL){
458	sprintf( painCave.errMsg,
459	"error in reading velocity x from %s\n",
460	c_in_name );
461	return strdup( painCave.errMsg );
462	}
463	q[2] = atof( foo );
464
465	foo = strtok(NULL, " ,;\t");
466	if(foo == NULL){
467	sprintf( painCave.errMsg,
468	"error in reading velocity x from %s\n",
469	c_in_name );
470	return strdup( painCave.errMsg );
471	}
472	q[3] = atof( foo );
473
474	// get the angular velocities
475
476	foo = strtok(NULL, " ,;\t");
477	if(foo == NULL){
478	sprintf( painCave.errMsg,
479	"error in reading velocity x from %s\n",
480	c_in_name );
481	return strdup( painCave.errMsg );
482	}
483	ji[0] = atof( foo );
484
485	foo = strtok(NULL, " ,;\t");
486	if(foo == NULL){
487	sprintf( painCave.errMsg,
488	"error in reading velocity x from %s\n",
489	c_in_name );
490	return strdup( painCave.errMsg );
491	}
492	ji[1] = atof(foo );
493
494	foo = strtok(NULL, " ,;\t");
495	if(foo == NULL){
496	sprintf( painCave.errMsg,
497	"error in reading velocity x from %s\n",
498	c_in_name );
499	return strdup( painCave.errMsg );
500	}
501	ji[2] = atof( foo );
502
503
504	// check that the quaternion vector is normalized
505
506	qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
507
508	qLength = sqrt( qSqr );
509	q[0] = q[0] / qLength;
510	q[1] = q[1] / qLength;
511	q[2] = q[2] / qLength;
512	q[3] = q[3] / qLength;
513
514	// add quaternion and angular velocities
515
516	sd->setQ( q );
517	sd->setJ( ji );
518	}
519
520
521
522	return NULL;
523	}
524
525
526	char* InitializeFromFile::parseCommentLine(char* readLine, SimInfo* entry_plug){
527
528	double currTime;
529	double boxMat[9];
530	double theBoxMat3[3][3];
531	double chi;
532	double integralOfChidt;
533	double eta[9];
534
535	char *foo; // the pointer to the current string token
536
537	// set the string tokenizer
538
539	foo = strtok(readLine, " ,;\t");
540	// set the timeToken.
541
542	if(foo == NULL){
543	sprintf( painCave.errMsg,
544	"error in reading Time from %s\n",
545	c_in_name );
546	return strdup( painCave.errMsg );
547	}
548
549	currTime = atof( foo );
550	entry_plug->setTime( currTime );
551
552	//get H-Matrix
553
554	for(int i = 0 ; i < 9; i++){
555	foo = strtok(NULL, " ,;\t");
556	if(foo == NULL){
557	sprintf( painCave.errMsg,
558	"error in reading H[%d] from %s\n", i, c_in_name );
559	return strdup( painCave.errMsg );
560	}
561	boxMat[i] = atof( foo );
562	}
563
564	for(int i=0;i<3;i++)
565	for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
566
567	//set H-Matrix
568	entry_plug->setBoxM( theBoxMat3 );
569
570	//get chi and integralOfChidt, they should appear by pair
571
572	if( entry_plug->useInitXSstate ){
573	foo = strtok(NULL, " ,;\t\n");
574	if(foo != NULL){
575	chi = atof(foo);
576
577	foo = strtok(NULL, " ,;\t\n");
578	if(foo == NULL){
579	sprintf( painCave.errMsg,
580	"chi and integralOfChidt should appear by pair in %s\n", c_in_name );
581	return strdup( painCave.errMsg );
582	}
583	integralOfChidt = atof( foo );
584
585	//push chi and integralOfChidt into SimInfo::properties which can be
586	//retrieved by integrator later
587	DoubleData* chiValue = new DoubleData();
588	chiValue->setID(CHIVALUE_ID);
589	chiValue->setData(chi);
590	entry_plug->addProperty(chiValue);
591
592	DoubleData* integralOfChidtValue = new DoubleData();
593	integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
594	integralOfChidtValue->setData(integralOfChidt);
595	entry_plug->addProperty(integralOfChidtValue);
596
597	}
598	else
599	return NULL;
600
601	//get eta
602	foo = strtok(NULL, " ,;\t\n");
603	if(foo != NULL ){
604
605	for(int i = 0 ; i < 9; i++){
606
607	if(foo == NULL){
608	sprintf( painCave.errMsg,
609	"error in reading eta[%d] from %s\n", i, c_in_name );
610	return strdup( painCave.errMsg );
611	}
612	eta[i] = atof( foo );
613	foo = strtok(NULL, " ,;\t\n");
614	}
615	}
616	else
617	return NULL;
618
619	//push eta into SimInfo::properties which can be
620	//retrieved by integrator later
621	//entry_plug->setBoxM( theBoxMat3 );
622	DoubleArrayData* etaValue = new DoubleArrayData();
623	etaValue->setID(ETAVALUE_ID);
624	etaValue->setData(eta, 9);
625	entry_plug->addProperty(etaValue);
626	}
627
628	return NULL;
629	}
630
631	#ifdef IS_MPI
632
633	// a couple of functions to let us escape the read loop
634
635	void initFile::nodeZeroError( void ){
636	int j, myStatus;
637
638	myStatus = 0;
639	for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
640	MPI_Send( &myStatus, 1, MPI_INT, j,
641	TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
642	}
643
644
645	MPI_Finalize();
646	exit (0);
647
648	}
649
650	void initFile::anonymousNodeDie( void ){
651
652	MPI_Finalize();
653	exit (0);
654	}
655
656	#endif //is_mpi