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;

  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(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 );
        painCave.isFatal = 1;
        simError();
      }
      
      parseErr = parseDumpLine( read_buffer, integrableObjects[j]);
      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;
  int nItems;

  nTotObjs = simnfo->getTotIntegrableObjects();
  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();
    }

    nItems = 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 != nItems){
      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[j]);
           
       }


      }
      else{
      //molecule belongs to slave nodes

        MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
               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

    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 == 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_Send(&nCurObj, 1, MPI_INT, 0,
                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD);

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