OOPSE/libmdtools/InitializeFromFile.cpp

#include <iostream>
#include <cmath>

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

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

#ifdef IS_MPI
#include <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
  }
 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, done, which_node, which_atom; // loop counter

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

  char *eof_test; // ptr to see when we reach the end of the file 
  char *parseErr;
  int procIndex;
  double currTime;
  double boxMat[9];
  double theBoxMat3[3][3];

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

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

  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 = parseBoxLine( read_buffer, boxMat, currTime );
  if( parseErr != NULL ){
    strcpy( painCave.errMsg, parseErr );
    painCave.isFatal = 1;
    simError();
  }

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

  simnfo->setBoxM( theBoxMat3 );
  simnfo->setTime( currTime );


  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 %d \n ",c_in_name);
      haveError = 1;
      simError();
    }
    
    n_atoms = atoi( read_buffer );
    
    Atom **atoms = simnfo->atoms;
    DirectionalAtom* dAtom;
 
    // Check to see that the number of atoms in the intial configuration file is the
    // same as declared in simBass.
    
    if( n_atoms != mpiSim->getTotAtoms() ){
      sprintf( painCave.errMsg,
               "Initialize from File error. %s n_atoms, %d, "
               "does not match the BASS file's n_atoms, %d.\n",
               c_in_name, n_atoms, 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();
    }
    
    parseErr = parseBoxLine( read_buffer, boxMat, currTime );
    if( parseErr != NULL ){
      strcpy( painCave.errMsg, parseErr );
      haveError = 1;
      simError();
    }

    MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
    MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
  
    if(haveError) nodeZeroError();

    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 = 0; j < mpiSim->getNumberProcessors(); j++) {      
      MPI_Send( &myStatus, 1, MPI_INT, j, 
                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
    }
    
  } else {
    
    MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    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;

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

  simnfo->setBoxM( theBoxMat3 );
  simnfo->setTime( currTime );

   
#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 j, n_atoms, atomIndex;

#ifdef IS_MPI
  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::parseBoxLine(char* readLine, double boxMat[9],
                                       double &time ){

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

  // 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 );
  }
  time = atof( foo );

  // get the Hx vector

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

  // get the Hy vector

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hy[0] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[3] = atof( foo );
   
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hy[1] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[4] = atof( foo );
     
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hy[2] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[5] = atof( foo );    

  // get the Hz vector

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hz[0] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[6] = atof( foo );
   
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hz[1] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[7] = atof( foo );
     
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading Hz[2] from %s\n",
             c_in_name );
    return strdup( painCave.errMsg );
  }
  boxMat[8] = atof( foo );    

  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:	690
Committed:	Tue Aug 12 21:44:06 2003 UTC (20 years, 10 months ago) by mmeineke
File size:	16530 byte(s)
Log Message:	fixed a really annoying bug in Directional Atom, where mu was getting written to pseudorandom memory location.
#	User	Rev	Content
1	mmeineke	377	#include <iostream>
2			#include <cmath>
3
4			#include <stdio.h>
5			#include <stdlib.h>
6			#include <string.h>
7			#include <unistd.h>
8			#include <sys/types.h>
9			#include <sys/stat.h>
10
11			#include "ReadWrite.hpp"
12			#include "simError.h"
13
14			#ifdef IS_MPI
15	gezelter	417	#include <mpi.h>
16	mmeineke	377	#include "mpiSimulation.hpp"
17	chuckv	436	#define TAKE_THIS_TAG_CHAR 0
18			#define TAKE_THIS_TAG_INT 1
19
20	mmeineke	440	namespace initFile{
21			void nodeZeroError( void );
22			void anonymousNodeDie( void );
23			}
24	chuckv	436
25	mmeineke	440	using namespace initFile;
26
27	mmeineke	377	#endif // is_mpi
28
29	tim	689	InitializeFromFile::InitializeFromFile( char *in_name ){
30
31	mmeineke	377	#ifdef IS_MPI
32			if (worldRank == 0) {
33			#endif
34
35			c_in_file = fopen(in_name, "r");
36			if(c_in_file == NULL){
37			sprintf(painCave.errMsg,
38			"Cannot open file: %s\n", in_name);
39			painCave.isFatal = 1;
40			simError();
41			}
42
43			strcpy( c_in_name, in_name);
44			#ifdef IS_MPI
45			}
46			strcpy( checkPointMsg, "Infile opened for reading successfully." );
47			MPIcheckPoint();
48			#endif
49			return;
50			}
51
52	tim	689	InitializeFromFile::~InitializeFromFile( ){
53	mmeineke	377	#ifdef IS_MPI
54			if (worldRank == 0) {
55			#endif
56			int error;
57			error = fclose( c_in_file );
58			if( error ){
59			sprintf( painCave.errMsg,
60			"Error closing %s\n", c_in_name );
61			simError();
62			}
63			#ifdef IS_MPI
64			}
65			strcpy( checkPointMsg, "Infile closed successfully." );
66			MPIcheckPoint();
67			#endif
68
69			return;
70			}
71
72
73	mmeineke	641	void InitializeFromFile :: readInit( SimInfo* the_simnfo ){
74	mmeineke	377
75	gezelter	417	int i, j, done, which_node, which_atom; // loop counter
76	mmeineke	377
77			const int BUFFERSIZE = 2000; // size of the read buffer
78			int n_atoms; // the number of atoms
79			char read_buffer[BUFFERSIZE]; //the line buffer for reading
80			#ifdef IS_MPI
81			char send_buffer[BUFFERSIZE];
82			#endif
83
84			char *eof_test; // ptr to see when we reach the end of the file
85			char *parseErr;
86			int procIndex;
87	mmeineke	644	double currTime;
88	mmeineke	586	double boxMat[9];
89	mmeineke	590	double theBoxMat3[3][3];
90	mmeineke	377
91	mmeineke	586	simnfo = the_simnfo;
92	mmeineke	377
93
94			#ifndef IS_MPI
95			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
96			if( eof_test == NULL ){
97			sprintf( painCave.errMsg,
98			"InitializeFromFile error: error reading 1st line of \"%s\"\n",
99			c_in_name );
100			painCave.isFatal = 1;
101			simError();
102			}
103
104			n_atoms = atoi( read_buffer );
105
106	mmeineke	586	Atom **atoms = simnfo->atoms;
107	mmeineke	377	DirectionalAtom* dAtom;
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
118	mmeineke	586	//read the box mat from the comment line
119	mmeineke	377
120			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	mmeineke	644	parseErr = parseBoxLine( read_buffer, boxMat, currTime );
129	mmeineke	586	if( parseErr != NULL ){
130			strcpy( painCave.errMsg, parseErr );
131			painCave.isFatal = 1;
132			simError();
133			}
134
135	mmeineke	590	for(i=0;i<3;i++)
136			for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
137	mmeineke	586
138	mmeineke	590	simnfo->setBoxM( theBoxMat3 );
139	mmeineke	644	simnfo->setTime( currTime );
140	mmeineke	586
141	mmeineke	590
142	mmeineke	377	for( i=0; i < n_atoms; i++){
143
144			eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
145			if(eof_test == NULL){
146			sprintf(painCave.errMsg,
147			"error in reading file %s\n"
148			"natoms = %d; index = %d\n"
149			"error reading the line from the file.\n",
150			c_in_name, n_atoms, i );
151			painCave.isFatal = 1;
152			simError();
153			}
154
155
156			parseErr = parseDumpLine( read_buffer, i );
157			if( parseErr != NULL ){
158			strcpy( painCave.errMsg, parseErr );
159			painCave.isFatal = 1;
160			simError();
161	mmeineke	586	}
162	mmeineke	377	}
163
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
174	mmeineke	447	MPI_Status istatus;
175	gezelter	417	int *AtomToProcMap = mpiSim->getAtomToProcMap();
176	mmeineke	377
177	chuckv	436
178			haveError = 0;
179	mmeineke	377	if (worldRank == 0) {
180	chuckv	436
181	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
182			if( eof_test == NULL ){
183			sprintf( painCave.errMsg,
184			"Error reading 1st line of %d \n ",c_in_name);
185	chuckv	436	haveError = 1;
186	mmeineke	377	simError();
187			}
188
189			n_atoms = atoi( read_buffer );
190
191	mmeineke	586	Atom **atoms = simnfo->atoms;
192	mmeineke	377	DirectionalAtom* dAtom;
193
194			// Check to see that the number of atoms in the intial configuration file is the
195			// same as declared in simBass.
196
197			if( n_atoms != mpiSim->getTotAtoms() ){
198			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	mmeineke	586	c_in_name, n_atoms, simnfo->n_atoms );
202	chuckv	436	haveError= 1;
203	mmeineke	377	simError();
204			}
205
206	mmeineke	586	//read the boxMat from the comment line
207	mmeineke	377
208			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	mmeineke	586
216	mmeineke	644	parseErr = parseBoxLine( read_buffer, boxMat, currTime );
217	mmeineke	586	if( parseErr != NULL ){
218			strcpy( painCave.errMsg, parseErr );
219			haveError = 1;
220			simError();
221			}
222
223			MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
224	mmeineke	644	MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
225	mmeineke	377
226	chuckv	436	if(haveError) nodeZeroError();
227	gezelter	417
228			for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
229
230	mmeineke	377	eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
231			if(eof_test == NULL){
232			sprintf(painCave.errMsg,
233			"error in reading file %s\n"
234			"natoms = %d; index = %d\n"
235			"error reading the line from the file.\n",
236			c_in_name, n_atoms, i );
237	chuckv	436	haveError= 1;
238	mmeineke	377	simError();
239			}
240
241	chuckv	436	if(haveError) nodeZeroError();
242
243	gezelter	417	// Get the Node number which wants this atom:
244			which_node = AtomToProcMap[i];
245	chuckv	436	if (which_node == 0) {
246	gezelter	417	parseErr = parseDumpLine( read_buffer, i );
247			if( parseErr != NULL ){
248			strcpy( painCave.errMsg, parseErr );
249	chuckv	436	haveError = 1;
250	gezelter	417	simError();
251			}
252	chuckv	436	if(haveError) nodeZeroError();
253			}
254
255			else {
256
257			myStatus = 1;
258	mmeineke	447	MPI_Send(&myStatus, 1, MPI_INT, which_node,
259			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
260			MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
261			TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
262			MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
263			MPI_COMM_WORLD);
264			MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
265			MPI_COMM_WORLD, &istatus);
266	chuckv	436
267			if(!myStatus) nodeZeroError();
268	mmeineke	377	}
269			}
270	chuckv	436	myStatus = -1;
271	gezelter	417	for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
272	mmeineke	447	MPI_Send( &myStatus, 1, MPI_INT, j,
273			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
274	gezelter	417	}
275	gezelter	419
276	gezelter	417	} else {
277	gezelter	419
278	mmeineke	586	MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
279	mmeineke	644	MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
280	mmeineke	586
281	gezelter	417	done = 0;
282			while (!done) {
283	chuckv	436
284	mmeineke	447	MPI_Recv(&myStatus, 1, MPI_INT, 0,
285			TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
286	chuckv	436
287			if(!myStatus) anonymousNodeDie();
288
289			if(myStatus < 0) break;
290
291	mmeineke	447	MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
292			TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
293			MPI_Recv(&which_atom, 1, MPI_INT, 0,
294			TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
295	chuckv	436
296			myStatus = 1;
297			parseErr = parseDumpLine( read_buffer, which_atom );
298			if( parseErr != NULL ){
299			strcpy( painCave.errMsg, parseErr );
300			myStatus = 0;;
301			simError();
302	mmeineke	377	}
303	chuckv	436
304	mmeineke	447	MPI_Send( &myStatus, 1, MPI_INT, 0,
305			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
306	chuckv	436
307	mmeineke	377	}
308			}
309	chuckv	436
310			// last thing last, enable fatalities.
311			painCave.isEventLoop = 0;
312	mmeineke	586
313	mmeineke	590	for(i=0;i<3;i++)
314			for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
315
316			simnfo->setBoxM( theBoxMat3 );
317	mmeineke	644	simnfo->setTime( currTime );
318	mmeineke	590
319	chuckv	436
320	mmeineke	377	#endif
321			}
322
323	gezelter	419	char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){
324	mmeineke	377
325			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
333	mmeineke	586	Atom **atoms = simnfo->atoms;
334	mmeineke	377	DirectionalAtom* dAtom;
335
336	gezelter	419	int j, n_atoms, atomIndex;
337	mmeineke	377
338			#ifdef IS_MPI
339			n_atoms = mpiSim->getTotAtoms();
340	gezelter	419	atomIndex=-1;
341			for (j=0; j < mpiSim->getMyNlocal(); j++) {
342			if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
343			}
344			if (atomIndex == -1) {
345			sprintf( painCave.errMsg,
346			"Initialize from file error. Atom at index %d "
347			"in file %s does not exist on processor %d .\n",
348			globalIndex, c_in_name, mpiSim->getMyNode() );
349			return strdup( painCave.errMsg );
350			}
351	mmeineke	377	#else
352	mmeineke	586	n_atoms = simnfo->n_atoms;
353	gezelter	419	atomIndex = globalIndex;
354	mmeineke	377	#endif // is_mpi
355
356			// set the string tokenizer
357
358			foo = strtok(readLine, " ,;\t");
359
360			// check the atom name to the current atom
361
362			if( strcmp( foo, atoms[atomIndex]->getType() ) ){
363			sprintf( painCave.errMsg,
364			"Initialize from file error. Atom %s at index %d "
365			"in file %s does not"
366			" match the BASS atom %s.\n",
367			foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
368			return strdup( painCave.errMsg );
369			}
370
371			// get the positions
372
373			foo = strtok(NULL, " ,;\t");
374			if(foo == NULL){
375			sprintf( painCave.errMsg,
376			"error in reading postition x from %s\n"
377			"natoms = %d, index = %d\n",
378			c_in_name, n_atoms, atomIndex );
379			return strdup( painCave.errMsg );
380			}
381	mmeineke	670	pos[0] = atof( foo );
382	mmeineke	377
383			foo = strtok(NULL, " ,;\t");
384			if(foo == NULL){
385			sprintf( painCave.errMsg,
386			"error in reading postition y from %s\n"
387			"natoms = %d, index = %d\n",
388			c_in_name, n_atoms, atomIndex );
389			return strdup( painCave.errMsg );
390			}
391	mmeineke	670	pos[1] = atof( foo );
392	mmeineke	377
393			foo = strtok(NULL, " ,;\t");
394			if(foo == NULL){
395			sprintf( painCave.errMsg,
396			"error in reading postition z from %s\n"
397			"natoms = %d, index = %d\n",
398			c_in_name, n_atoms, atomIndex );
399			return strdup( painCave.errMsg );
400			}
401	mmeineke	670	pos[2] = atof( foo );
402	mmeineke	377
403
404			// get the velocities
405
406			foo = strtok(NULL, " ,;\t");
407			if(foo == NULL){
408			sprintf( painCave.errMsg,
409			"error in reading velocity x from %s\n"
410			"natoms = %d, index = %d\n",
411			c_in_name, n_atoms, atomIndex );
412			return strdup( painCave.errMsg );
413			}
414	mmeineke	670	vel[0] = atof( foo );
415	mmeineke	377
416			foo = strtok(NULL, " ,;\t");
417			if(foo == NULL){
418			sprintf( painCave.errMsg,
419			"error in reading velocity y from %s\n"
420			"natoms = %d, index = %d\n",
421			c_in_name, n_atoms, atomIndex );
422			return strdup( painCave.errMsg );
423			}
424	mmeineke	670	vel[1] = atof( foo );
425	mmeineke	377
426			foo = strtok(NULL, " ,;\t");
427			if(foo == NULL){
428			sprintf( painCave.errMsg,
429			"error in reading velocity z from %s\n"
430			"natoms = %d, index = %d\n",
431			c_in_name, n_atoms, atomIndex );
432			return strdup( painCave.errMsg );
433			}
434	mmeineke	670	vel[2] = atof( foo );
435	mmeineke	377
436
437			// get the quaternions
438
439			if( atoms[atomIndex]->isDirectional() ){
440
441			foo = strtok(NULL, " ,;\t");
442			if(foo == NULL){
443			sprintf(painCave.errMsg,
444			"error in reading quaternion 0 from %s\n"
445			"natoms = %d, index = %d\n",
446			c_in_name, n_atoms, atomIndex );
447			return strdup( painCave.errMsg );
448			}
449			q[0] = atof( foo );
450
451			foo = strtok(NULL, " ,;\t");
452			if(foo == NULL){
453			sprintf( painCave.errMsg,
454			"error in reading quaternion 1 from %s\n"
455			"natoms = %d, index = %d\n",
456			c_in_name, n_atoms, atomIndex );
457			return strdup( painCave.errMsg );
458			}
459			q[1] = atof( foo );
460
461			foo = strtok(NULL, " ,;\t");
462			if(foo == NULL){
463			sprintf( painCave.errMsg,
464			"error in reading quaternion 2 from %s\n"
465			"natoms = %d, index = %d\n",
466			c_in_name, n_atoms, atomIndex );
467			return strdup( painCave.errMsg );
468			}
469			q[2] = atof( foo );
470
471			foo = strtok(NULL, " ,;\t");
472			if(foo == NULL){
473			sprintf( painCave.errMsg,
474			"error in reading quaternion 3 from %s\n"
475			"natoms = %d, index = %d\n",
476			c_in_name, n_atoms, atomIndex );
477			return strdup( painCave.errMsg );
478			}
479			q[3] = atof( foo );
480
481			// get the angular velocities
482
483			foo = strtok(NULL, " ,;\t");
484			if(foo == NULL){
485			sprintf( painCave.errMsg,
486			"error in reading angular momentum jx from %s\n"
487			"natoms = %d, index = %d\n",
488			c_in_name, n_atoms, atomIndex );
489			return strdup( painCave.errMsg );
490			}
491			jx = atof( foo );
492
493			foo = strtok(NULL, " ,;\t");
494			if(foo == NULL){
495			sprintf( painCave.errMsg,
496			"error in reading angular momentum jy from %s\n"
497			"natoms = %d, index = %d\n",
498			c_in_name, n_atoms, atomIndex );
499			return strdup( painCave.errMsg );
500			}
501			jy = atof(foo );
502
503			foo = strtok(NULL, " ,;\t");
504			if(foo == NULL){
505			sprintf( painCave.errMsg,
506			"error in reading angular momentum jz from %s\n"
507			"natoms = %d, index = %d\n",
508			c_in_name, n_atoms, atomIndex );
509			return strdup( painCave.errMsg );
510			}
511			jz = atof( foo );
512
513			dAtom = ( DirectionalAtom* )atoms[atomIndex];
514
515			// check that the quaternion vector is normalized
516
517			qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
518
519			qLength = sqrt( qSqr );
520			q[0] = q[0] / qLength;
521			q[1] = q[1] / qLength;
522			q[2] = q[2] / qLength;
523			q[3] = q[3] / qLength;
524
525			dAtom->setQ( q );
526
527			// add the angular velocities
528
529			dAtom->setJx( jx );
530			dAtom->setJy( jy );
531			dAtom->setJz( jz );
532			}
533
534			// add the positions and velocities to the atom
535
536	mmeineke	670	atoms[atomIndex]->setPos( pos );
537			atoms[atomIndex]->setVel( vel );
538	mmeineke	377
539			return NULL;
540			}
541	chuckv	436
542
543	mmeineke	644	char* InitializeFromFile::parseBoxLine(char* readLine, double boxMat[9],
544			double &time ){
545	mmeineke	586
546			char *foo; // the pointer to the current string token
547			int j;
548
549			// set the string tokenizer
550
551			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	644	time = atof( foo );
561	mmeineke	586
562			// get the Hx vector
563
564			foo = strtok(NULL, " ,;\t");
565			if(foo == NULL){
566			sprintf( painCave.errMsg,
567			"error in reading Hx[0] from %s\n",
568			c_in_name );
569			return strdup( painCave.errMsg );
570			}
571			boxMat[0] = atof( foo );
572
573			foo = strtok(NULL, " ,;\t");
574			if(foo == NULL){
575			sprintf( painCave.errMsg,
576			"error in reading Hx[1] from %s\n",
577			c_in_name );
578			return strdup( painCave.errMsg );
579			}
580			boxMat[1] = atof( foo );
581
582			foo = strtok(NULL, " ,;\t");
583			if(foo == NULL){
584			sprintf( painCave.errMsg,
585			"error in reading Hx[2] from %s\n",
586			c_in_name );
587			return strdup( painCave.errMsg );
588			}
589			boxMat[2] = atof( foo );
590
591			// get the Hy vector
592
593			foo = strtok(NULL, " ,;\t");
594			if(foo == NULL){
595			sprintf( painCave.errMsg,
596			"error in reading Hy[0] from %s\n",
597			c_in_name );
598			return strdup( painCave.errMsg );
599			}
600			boxMat[3] = atof( foo );
601
602			foo = strtok(NULL, " ,;\t");
603			if(foo == NULL){
604			sprintf( painCave.errMsg,
605			"error in reading Hy[1] from %s\n",
606			c_in_name );
607			return strdup( painCave.errMsg );
608			}
609			boxMat[4] = atof( foo );
610
611			foo = strtok(NULL, " ,;\t");
612			if(foo == NULL){
613			sprintf( painCave.errMsg,
614			"error in reading Hy[2] from %s\n",
615			c_in_name );
616			return strdup( painCave.errMsg );
617			}
618			boxMat[5] = atof( foo );
619
620			// get the Hz vector
621
622			foo = strtok(NULL, " ,;\t");
623			if(foo == NULL){
624			sprintf( painCave.errMsg,
625			"error in reading Hz[0] from %s\n",
626			c_in_name );
627			return strdup( painCave.errMsg );
628			}
629			boxMat[6] = atof( foo );
630
631			foo = strtok(NULL, " ,;\t");
632			if(foo == NULL){
633			sprintf( painCave.errMsg,
634			"error in reading Hz[1] from %s\n",
635			c_in_name );
636			return strdup( painCave.errMsg );
637			}
638			boxMat[7] = atof( foo );
639
640			foo = strtok(NULL, " ,;\t");
641			if(foo == NULL){
642			sprintf( painCave.errMsg,
643			"error in reading Hz[2] from %s\n",
644			c_in_name );
645			return strdup( painCave.errMsg );
646			}
647			boxMat[8] = atof( foo );
648
649			return NULL;
650			}
651
652
653	chuckv	436	#ifdef IS_MPI
654
655			// a couple of functions to let us escape the read loop
656
657	mmeineke	440	void initFile::nodeZeroError( void ){
658	chuckv	436	int j, myStatus;
659
660			myStatus = 0;
661			for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
662	mmeineke	447	MPI_Send( &myStatus, 1, MPI_INT, j,
663			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
664	chuckv	436	}
665
666
667			MPI_Finalize();
668			exit (0);
669
670			}
671
672	mmeineke	440	void initFile::anonymousNodeDie( void ){
673	chuckv	436
674			MPI_Finalize();
675			exit (0);
676			}
677
678			#endif //is_mpi