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

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

  n_atoms = atoi( read_buffer );

  if( n_atoms != simnfo->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, simnfo->n_atoms );
    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 < 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

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

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

  MPI_Status istatus;
  int *AtomToProcMap = mpiSim->getAtomToProcMap();


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

    n_atoms = atoi( read_buffer );

    // 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, simnfo->n_atoms );
      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->getTotAtoms(); 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 );
        haveError= 1;
        simError();
      }

      if(haveError) nodeZeroError();

      // Get the Node number which wants this atom:
      which_node = AtomToProcMap[i];
      if (which_node == 0) {
        parseErr = parseDumpLine( read_buffer, i );
        if( parseErr != NULL ){
          strcpy( painCave.errMsg, parseErr );
          haveError = 1;
          simError();
        }
        if(haveError) nodeZeroError();
      }

      else {

        myStatus = 1;
        MPI_Send(&myStatus, 1, MPI_INT, which_node,
                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
        MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
                 MPI_COMM_WORLD);
        MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
                 MPI_COMM_WORLD, &istatus);

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

  } else {

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


    done = 0;
    while (!done) {

      MPI_Recv(&myStatus, 1, MPI_INT, 0,
               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);

      if(!myStatus) anonymousNodeDie();

      if(myStatus < 0) break;

      MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
      MPI_Recv(&which_atom, 1, MPI_INT, 0,
               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);

      myStatus = 1;
      parseErr = parseDumpLine( read_buffer, which_atom );
      if( parseErr != NULL ){
        strcpy( painCave.errMsg, parseErr );
        myStatus = 0;;
        simError();
      }

      MPI_Send( &myStatus, 1, MPI_INT, 0,
                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);

    }
  }

 // last  thing last, enable  fatalities.
  painCave.isEventLoop = 0;


#endif
}

char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){

  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 jx, jy, jz; // angular velocity placeholders;
  double qSqr, qLength; // needed to normalize the quaternion vector.

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

  int n_atoms, atomIndex;

#ifdef IS_MPI
  int j;

  n_atoms = mpiSim->getTotAtoms();
  atomIndex=-1;
  for (j=0; j < mpiSim->getMyNlocal(); j++) {
    if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
  }
  if (atomIndex == -1) {
    sprintf( painCave.errMsg,
             "Initialize from file error. Atom at index %d "
             "in file %s does not exist on processor %d .\n",
             globalIndex, c_in_name, mpiSim->getMyNode() );
    return strdup( painCave.errMsg );
  }
#else
  n_atoms = simnfo->n_atoms;
  atomIndex = globalIndex;
#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 );
  }
  pos[0] = 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 );
  }
  pos[1] = 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 );
  }
  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"
             "natoms  = %d, index = %d\n",
             c_in_name, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vel[0] = 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 );
  }
  vel[1] = 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 );
  }
  vel[2] = 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]->setPos( pos );
  atoms[atomIndex]->setVel( vel );

  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
    for(int i = 0 ; i < 9; i++){
      foo = strtok(NULL, " ,;\t");
      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 );
    }
    
    //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:	906
Committed:	Thu Jan 8 15:44:47 2004 UTC (20 years, 6 months ago) by mmeineke
File size:	16240 byte(s)
Log Message:	added support for the ignore XS state info flag
#	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			int n_atoms; // 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	mmeineke	586	simnfo = the_simnfo;
95	mmeineke	377
96
97			#ifndef IS_MPI
98			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
99			if( eof_test == NULL ){
100			sprintf( painCave.errMsg,
101			"InitializeFromFile error: error reading 1st line of \"%s\"\n",
102			c_in_name );
103			painCave.isFatal = 1;
104			simError();
105			}
106
107			n_atoms = atoi( read_buffer );
108
109	mmeineke	586	if( n_atoms != simnfo->n_atoms ){
110	mmeineke	377	sprintf( painCave.errMsg,
111			"Initialize from File error. %s n_atoms, %d, "
112			"does not match the BASS file's n_atoms, %d.\n",
113	mmeineke	586	c_in_name, n_atoms, simnfo->n_atoms );
114	mmeineke	377	painCave.isFatal = 1;
115			simError();
116			}
117	tim	837
118			//read the box mat from the comment line
119
120	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
121			if(eof_test == NULL){
122			sprintf( painCave.errMsg,
123			"error in reading commment in %s\n", c_in_name);
124			painCave.isFatal = 1;
125			simError();
126			}
127
128	tim	837
129
130			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	837	for( i=0; i < n_atoms; i++){
140	mmeineke	586
141	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
142			if(eof_test == NULL){
143			sprintf(painCave.errMsg,
144			"error in reading file %s\n"
145			"natoms = %d; index = %d\n"
146			"error reading the line from the file.\n",
147			c_in_name, n_atoms, i );
148			painCave.isFatal = 1;
149			simError();
150			}
151
152	tim	837
153	mmeineke	377	parseErr = parseDumpLine( read_buffer, i );
154			if( parseErr != NULL ){
155			strcpy( painCave.errMsg, parseErr );
156			painCave.isFatal = 1;
157			simError();
158	mmeineke	586	}
159	mmeineke	377	}
160
161
162			// MPI Section of code..........
163			#else //IS_MPI
164
165	chuckv	436	// first thing first, suspend fatalities.
166			painCave.isEventLoop = 1;
167
168			int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
169			int haveError;
170	tim	837
171	mmeineke	447	MPI_Status istatus;
172	gezelter	417	int *AtomToProcMap = mpiSim->getAtomToProcMap();
173	mmeineke	377
174	tim	837
175	chuckv	436	haveError = 0;
176	mmeineke	377	if (worldRank == 0) {
177	chuckv	436
178	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
179			if( eof_test == NULL ){
180			sprintf( painCave.errMsg,
181	mmeineke	787	"Error reading 1st line of %s \n ",c_in_name);
182	chuckv	436	haveError = 1;
183	mmeineke	377	simError();
184			}
185	tim	837
186	mmeineke	377	n_atoms = atoi( read_buffer );
187	tim	837
188	mmeineke	377	// Check to see that the number of atoms in the intial configuration file is the
189			// same as declared in simBass.
190	tim	837
191	mmeineke	377	if( n_atoms != mpiSim->getTotAtoms() ){
192			sprintf( painCave.errMsg,
193			"Initialize from File error. %s n_atoms, %d, "
194			"does not match the BASS file's n_atoms, %d.\n",
195	mmeineke	586	c_in_name, n_atoms, simnfo->n_atoms );
196	chuckv	436	haveError= 1;
197	mmeineke	377	simError();
198			}
199	tim	837
200			//read the boxMat from the comment line
201
202	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
203			if(eof_test == NULL){
204			sprintf( painCave.errMsg,
205			"error in reading commment in %s\n", c_in_name);
206	mmeineke	586	haveError = 1;
207	mmeineke	377	simError();
208			}
209	tim	837
210			//Every single processor will parse the comment line by itself
211			//By using this way, we might lose some efficiency, but if we want to add
212			//more parameters into comment line, we only need to modify function
213			//parseCommentLine
214
215			MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
216
217			parseErr = parseCommentLine( read_buffer, simnfo);
218
219	mmeineke	586	if( parseErr != NULL ){
220			strcpy( painCave.errMsg, parseErr );
221			haveError = 1;
222			simError();
223			}
224
225	tim	837	for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
226	gezelter	417
227	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
228			if(eof_test == NULL){
229			sprintf(painCave.errMsg,
230			"error in reading file %s\n"
231			"natoms = %d; index = %d\n"
232			"error reading the line from the file.\n",
233			c_in_name, n_atoms, i );
234	chuckv	436	haveError= 1;
235	mmeineke	377	simError();
236			}
237	tim	837
238	chuckv	436	if(haveError) nodeZeroError();
239
240	gezelter	417	// Get the Node number which wants this atom:
241	tim	837	which_node = AtomToProcMap[i];
242	chuckv	436	if (which_node == 0) {
243	gezelter	417	parseErr = parseDumpLine( read_buffer, i );
244			if( parseErr != NULL ){
245			strcpy( painCave.errMsg, parseErr );
246	chuckv	436	haveError = 1;
247	gezelter	417	simError();
248	tim	837	}
249	chuckv	436	if(haveError) nodeZeroError();
250	tim	837	}
251
252	chuckv	436	else {
253	tim	837
254	chuckv	436	myStatus = 1;
255	tim	837	MPI_Send(&myStatus, 1, MPI_INT, which_node,
256	mmeineke	447	TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
257	tim	837	MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
258	mmeineke	447	TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
259			MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
260			MPI_COMM_WORLD);
261	tim	837	MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
262	mmeineke	447	MPI_COMM_WORLD, &istatus);
263	tim	837
264	chuckv	436	if(!myStatus) nodeZeroError();
265	mmeineke	377	}
266			}
267	chuckv	436	myStatus = -1;
268	tim	905	for (j = 1; j < mpiSim->getNumberProcessors(); j++) {
269	tim	837	MPI_Send( &myStatus, 1, MPI_INT, j,
270	mmeineke	447	TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
271	gezelter	417	}
272	tim	837
273	gezelter	417	} else {
274	mmeineke	586
275	tim	837	MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
276
277			parseErr = parseCommentLine( read_buffer, simnfo);
278
279			if( parseErr != NULL ){
280			strcpy( painCave.errMsg, parseErr );
281			haveError = 1;
282			simError();
283			}
284
285
286	gezelter	417	done = 0;
287			while (!done) {
288	chuckv	436
289	tim	837	MPI_Recv(&myStatus, 1, MPI_INT, 0,
290	mmeineke	447	TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
291	tim	837
292	chuckv	436	if(!myStatus) anonymousNodeDie();
293	tim	837
294	chuckv	436	if(myStatus < 0) break;
295
296	tim	837	MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
297	mmeineke	447	TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
298	tim	837	MPI_Recv(&which_atom, 1, MPI_INT, 0,
299	mmeineke	447	TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
300	tim	837
301	chuckv	436	myStatus = 1;
302			parseErr = parseDumpLine( read_buffer, which_atom );
303			if( parseErr != NULL ){
304			strcpy( painCave.errMsg, parseErr );
305			myStatus = 0;;
306			simError();
307	mmeineke	377	}
308	tim	837
309			MPI_Send( &myStatus, 1, MPI_INT, 0,
310	mmeineke	447	TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
311	tim	837
312	mmeineke	377	}
313			}
314	tim	837
315	chuckv	436	// last thing last, enable fatalities.
316			painCave.isEventLoop = 0;
317	mmeineke	586
318	mmeineke	590
319
320	mmeineke	377	#endif
321			}
322
323	gezelter	419	char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){
324	mmeineke	377
325	tim	837	char *foo; // the pointer to the current string token
326
327	mmeineke	670	double pos[3]; // position place holders
328			double vel[3]; // velocity placeholders
329	mmeineke	377	double q[4]; // the quaternions
330			double jx, jy, jz; // angular velocity placeholders;
331			double qSqr, qLength; // needed to normalize the quaternion vector.
332	tim	837
333	mmeineke	586	Atom **atoms = simnfo->atoms;
334	mmeineke	377	DirectionalAtom* dAtom;
335	tim	837
336	mmeineke	787	int n_atoms, atomIndex;
337	mmeineke	377
338			#ifdef IS_MPI
339	mmeineke	787	int j;
340
341	mmeineke	377	n_atoms = mpiSim->getTotAtoms();
342	tim	837	atomIndex=-1;
343	gezelter	419	for (j=0; j < mpiSim->getMyNlocal(); j++) {
344			if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
345			}
346			if (atomIndex == -1) {
347			sprintf( painCave.errMsg,
348			"Initialize from file error. Atom at index %d "
349			"in file %s does not exist on processor %d .\n",
350			globalIndex, c_in_name, mpiSim->getMyNode() );
351			return strdup( painCave.errMsg );
352	tim	837	}
353	mmeineke	377	#else
354	mmeineke	586	n_atoms = simnfo->n_atoms;
355	gezelter	419	atomIndex = globalIndex;
356	mmeineke	377	#endif // is_mpi
357
358			// set the string tokenizer
359	tim	837
360	mmeineke	377	foo = strtok(readLine, " ,;\t");
361	tim	837
362	mmeineke	377	// check the atom name to the current atom
363	tim	837
364	mmeineke	377	if( strcmp( foo, atoms[atomIndex]->getType() ) ){
365			sprintf( painCave.errMsg,
366			"Initialize from file error. Atom %s at index %d "
367			"in file %s does not"
368			" match the BASS atom %s.\n",
369			foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
370			return strdup( painCave.errMsg );
371			}
372	tim	837
373	mmeineke	377	// get the positions
374
375			foo = strtok(NULL, " ,;\t");
376			if(foo == NULL){
377			sprintf( painCave.errMsg,
378			"error in reading postition x from %s\n"
379			"natoms = %d, index = %d\n",
380			c_in_name, n_atoms, atomIndex );
381			return strdup( painCave.errMsg );
382			}
383	mmeineke	670	pos[0] = atof( foo );
384	tim	837
385	mmeineke	377	foo = strtok(NULL, " ,;\t");
386			if(foo == NULL){
387			sprintf( painCave.errMsg,
388			"error in reading postition y from %s\n"
389			"natoms = %d, index = %d\n",
390			c_in_name, n_atoms, atomIndex );
391			return strdup( painCave.errMsg );
392			}
393	mmeineke	670	pos[1] = atof( foo );
394	tim	837
395	mmeineke	377	foo = strtok(NULL, " ,;\t");
396			if(foo == NULL){
397			sprintf( painCave.errMsg,
398			"error in reading postition z from %s\n"
399			"natoms = %d, index = %d\n",
400			c_in_name, n_atoms, atomIndex );
401			return strdup( painCave.errMsg );
402			}
403	tim	837	pos[2] = atof( foo );
404	mmeineke	377
405
406			// get the velocities
407
408			foo = strtok(NULL, " ,;\t");
409			if(foo == NULL){
410			sprintf( painCave.errMsg,
411			"error in reading velocity x from %s\n"
412			"natoms = %d, index = %d\n",
413			c_in_name, n_atoms, atomIndex );
414			return strdup( painCave.errMsg );
415			}
416	mmeineke	670	vel[0] = atof( foo );
417	tim	837
418	mmeineke	377	foo = strtok(NULL, " ,;\t");
419			if(foo == NULL){
420			sprintf( painCave.errMsg,
421			"error in reading velocity y from %s\n"
422			"natoms = %d, index = %d\n",
423			c_in_name, n_atoms, atomIndex );
424			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			"error in reading velocity z from %s\n"
432			"natoms = %d, index = %d\n",
433			c_in_name, n_atoms, atomIndex );
434			return strdup( painCave.errMsg );
435			}
436	mmeineke	670	vel[2] = atof( foo );
437	tim	837
438
439	mmeineke	377	// get the quaternions
440	tim	837
441	mmeineke	377	if( atoms[atomIndex]->isDirectional() ){
442	tim	837
443	mmeineke	377	foo = strtok(NULL, " ,;\t");
444			if(foo == NULL){
445			sprintf(painCave.errMsg,
446			"error in reading quaternion 0 from %s\n"
447			"natoms = %d, index = %d\n",
448			c_in_name, n_atoms, atomIndex );
449			return strdup( painCave.errMsg );
450			}
451			q[0] = atof( foo );
452	tim	837
453	mmeineke	377	foo = strtok(NULL, " ,;\t");
454			if(foo == NULL){
455			sprintf( painCave.errMsg,
456			"error in reading quaternion 1 from %s\n"
457			"natoms = %d, index = %d\n",
458			c_in_name, n_atoms, atomIndex );
459			return strdup( painCave.errMsg );
460			}
461			q[1] = atof( foo );
462	tim	837
463	mmeineke	377	foo = strtok(NULL, " ,;\t");
464			if(foo == NULL){
465			sprintf( painCave.errMsg,
466			"error in reading quaternion 2 from %s\n"
467			"natoms = %d, index = %d\n",
468			c_in_name, n_atoms, atomIndex );
469			return strdup( painCave.errMsg );
470			}
471			q[2] = atof( foo );
472	tim	837
473	mmeineke	377	foo = strtok(NULL, " ,;\t");
474			if(foo == NULL){
475			sprintf( painCave.errMsg,
476			"error in reading quaternion 3 from %s\n"
477			"natoms = %d, index = %d\n",
478			c_in_name, n_atoms, atomIndex );
479			return strdup( painCave.errMsg );
480			}
481			q[3] = atof( foo );
482	tim	837
483	mmeineke	377	// get the angular velocities
484	tim	837
485	mmeineke	377	foo = strtok(NULL, " ,;\t");
486			if(foo == NULL){
487			sprintf( painCave.errMsg,
488			"error in reading angular momentum jx from %s\n"
489			"natoms = %d, index = %d\n",
490			c_in_name, n_atoms, atomIndex );
491			return strdup( painCave.errMsg );
492			}
493			jx = atof( foo );
494	tim	837
495	mmeineke	377	foo = strtok(NULL, " ,;\t");
496			if(foo == NULL){
497			sprintf( painCave.errMsg,
498			"error in reading angular momentum jy from %s\n"
499			"natoms = %d, index = %d\n",
500			c_in_name, n_atoms, atomIndex );
501			return strdup( painCave.errMsg );
502			}
503			jy = atof(foo );
504	tim	837
505	mmeineke	377	foo = strtok(NULL, " ,;\t");
506			if(foo == NULL){
507			sprintf( painCave.errMsg,
508			"error in reading angular momentum jz from %s\n"
509			"natoms = %d, index = %d\n",
510			c_in_name, n_atoms, atomIndex );
511			return strdup( painCave.errMsg );
512			}
513			jz = atof( foo );
514	tim	837
515	mmeineke	377	dAtom = ( DirectionalAtom* )atoms[atomIndex];
516
517			// check that the quaternion vector is normalized
518
519			qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
520	tim	837
521	mmeineke	377	qLength = sqrt( qSqr );
522			q[0] = q[0] / qLength;
523			q[1] = q[1] / qLength;
524			q[2] = q[2] / qLength;
525			q[3] = q[3] / qLength;
526	tim	837
527	mmeineke	377	dAtom->setQ( q );
528	tim	837
529	mmeineke	377	// add the angular velocities
530
531			dAtom->setJx( jx );
532			dAtom->setJy( jy );
533			dAtom->setJz( jz );
534			}
535	tim	837
536	mmeineke	377	// add the positions and velocities to the atom
537	tim	837
538	mmeineke	670	atoms[atomIndex]->setPos( pos );
539			atoms[atomIndex]->setVel( vel );
540	mmeineke	377
541			return NULL;
542			}
543	chuckv	436
544
545	tim	837	char* InitializeFromFile::parseCommentLine(char* readLine, SimInfo* entry_plug){
546	mmeineke	586
547	tim	837	double currTime;
548			double boxMat[9];
549			double theBoxMat3[3][3];
550			double chi;
551			double integralOfChidt;
552			double eta[9];
553	mmeineke	586
554	tim	837	char *foo; // the pointer to the current string token
555
556	mmeineke	586	// set the string tokenizer
557	tim	837
558	mmeineke	586	foo = strtok(readLine, " ,;\t");
559	mmeineke	641	// set the timeToken.
560	mmeineke	586
561	mmeineke	641	if(foo == NULL){
562			sprintf( painCave.errMsg,
563			"error in reading Time from %s\n",
564			c_in_name );
565			return strdup( painCave.errMsg );
566			}
567	mmeineke	586
568	tim	837	currTime = atof( foo );
569			entry_plug->setTime( currTime );
570	mmeineke	586
571	tim	837	//get H-Matrix
572
573			for(int i = 0 ; i < 9; i++){
574			foo = strtok(NULL, " ,;\t");
575			if(foo == NULL){
576			sprintf( painCave.errMsg,
577			"error in reading H[%d] from %s\n", i, c_in_name );
578			return strdup( painCave.errMsg );
579			}
580			boxMat[i] = atof( foo );
581	mmeineke	586	}
582
583	tim	837	for(int i=0;i<3;i++)
584			for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
585	mmeineke	586
586	tim	837	//set H-Matrix
587			entry_plug->setBoxM( theBoxMat3 );
588	mmeineke	586
589	tim	837	//get chi and integralOfChidt, they should appear by pair
590	mmeineke	586
591	mmeineke	906	if( entry_plug->useInitXSstate ){
592	tim	837	foo = strtok(NULL, " ,;\t\n");
593	mmeineke	906	if(foo != NULL){
594			chi = atof(foo);
595
596			foo = strtok(NULL, " ,;\t\n");
597			if(foo == NULL){
598			sprintf( painCave.errMsg,
599			"chi and integralOfChidt should appear by pair in %s\n", c_in_name );
600			return strdup( painCave.errMsg );
601			}
602			integralOfChidt = atof( foo );
603
604			//push chi and integralOfChidt into SimInfo::properties which can be
605			//retrieved by integrator later
606			DoubleData* chiValue = new DoubleData();
607			chiValue->setID(CHIVALUE_ID);
608			chiValue->setData(chi);
609			entry_plug->addProperty(chiValue);
610
611			DoubleData* integralOfChidtValue = new DoubleData();
612			integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
613			integralOfChidtValue->setData(integralOfChidt);
614			entry_plug->addProperty(integralOfChidtValue);
615
616	tim	837	}
617	mmeineke	906	else
618			return NULL;
619
620			//get eta
621			for(int i = 0 ; i < 9; i++){
622			foo = strtok(NULL, " ,;\t");
623			if(foo == NULL){
624			sprintf( painCave.errMsg,
625			"error in reading eta[%d] from %s\n", i, c_in_name );
626			return strdup( painCave.errMsg );
627			}
628			eta[i] = atof( foo );
629			}
630
631			//push eta into SimInfo::properties which can be
632	tim	837	//retrieved by integrator later
633	mmeineke	906	//entry_plug->setBoxM( theBoxMat3 );
634			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