OOPSE/libmdtools/DumpReader.cpp

#define _FILE_OFFSET_BITS 64

#include <iostream>
#include <cmath>
#include <vector>

#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
#endif // is_mpi

namespace dumpRead{

#ifdef IS_MPI
  void nodeZeroError( void );
  void anonymousNodeDie( void );
#endif // is_mpi
  
  class FilePos{
    
  public:
    FilePos(){ myPos = NULL; }
    FilePos( fpos_t* thePos ) { myPos = thePos; }
    ~FilePos(){ if( myPos != NULL ) delete myPos; }

    FilePos &operator=(fpos_t *thePos){ myPos = thePos; return *this; }

    void setPos( fpos_t *thePos ){ myPos = thePos; }
    fpos_t *getPos( void ){ return myPos; }
   
  private:
    
    fpos_t *myPos

  };

  bool operator<(FilePos a, FilePos b){
    return (a.getPos())->__pos < (b.getPos())->__pos; }

  bool operator==(FilePos a, FilePos b){
    return (a.getPos())->__pos == (b.getPos())->__pos; }

  vector<FilePos> frameStart;
}

using namespace dumpRead;


DumpReader :: DumpReader( char *in_name ){

  isScanned = false;

#ifdef IS_MPI
  if (worldRank == 0) {
#endif

  inFile = fopen(in_name, "r");
  if(inFile == NULL){
    sprintf(painCave.errMsg,
            "Cannot open file: %s\n", in_name);
    painCave.isFatal = 1;
    simError();
  }
  
  strcpy( inName, in_name);
#ifdef IS_MPI
  }
  strcpy( checkPointMsg, "Dump file opened for reading successfully." );
  MPIcheckPoint();
#endif
  return;  
}

DumpReader :: ~DumpReader( ){
#ifdef IS_MPI
  if (worldRank == 0) {
#endif
  int error;
  error = fclose( inFile );
  if( error ){
    sprintf( painCave.errMsg,
             "Error closing %s\n", inName );
    simError();
  }
#ifdef IS_MPI
  }
  strcpy( checkPointMsg, "Dump file closed successfully." );
  MPIcheckPoint();
#endif

  return;
}

int DumpReader::getNframes( void ){

  if( !isScanned ) scanFile();
  return nFrames;
}

void DumpReader::scanFile( void ){

  int vectorSize;
  int i, j, k;
  int lineNum = 0;
  char readBuffer[2000];
  char* foo;
  fpos_t *currPos;

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif // is_mpi
    
    rewind( inFile );
    
    currPos = new fpos_t;
    fgetpos( inFile, currPos );
    fgets( readBuffer, sizeof( readBuffer ), in_file );
    lineNum++;
    if( feof( in_file ) ){
      sprintf( painCave.errMsg,
               "File \"%s\" ended unexpectedly at line %d\n", 
               inName,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    while( !feof( in_file ) ){
      
      frameStart.push_back( FilePos( currPos ) );
      i = atoi(readBuffer);
      
      fgets( readBuffer, sizeof( readBuffer ), in_file );
      lineNum++;    
      if( feof( in_file ) ){
        sprintf( painCave.errMsg,
                 "File \"%s\" ended unexpectedly at line %d\n",
                 inName,
                 lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      if(outTime){
        foo = strtok( readBuffer, " ,;\t" );
        time = atof( foo );
      }
      
      for(j=0; j<i; j++){
        
        fgets( readBuffer, sizeof( readBuffer ), in_file );
        lineNum++;    
        if( feof( in_file ) ){
          sprintf( painCave.errMsg,
                   "File \"%s\" ended unexpectedly at line %d,"
                   " with atom %d\n", 
                   inName,
                   lineNum, 
                   j );
          painCave.isFatal = 1;
          simError();
        }
        
      }
      
      currPos = new fpos_t;
      fgetpos( inFile, currPos );
      fgets( readBuffer, sizeof( readBuffer ), in_file );
      lineNum++;
    }
    
    delete currPos;
    vectorSize = frameStart.size();
    rewind( inFile );
    
#ifdef IS_MPI
  }
  strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
  MPIcheckPoint();
#endif // is_mpi

  nFrames = vectorSize;
  isScanned = true;
}


void DumpReader :: getFrame( SimInfo* the_simnfo, int whichFrame){

  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 boxMat[9];
  double theBoxMat3[3][3];

  simnfo = the_simnfo;

#ifndef IS_MPI
  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
  if( eof_test == NULL ){
    sprintf( painCave.errMsg,
             "DumpReader error: error reading 1st line of \"%s\"\n",
             inName );
    painCave.isFatal = 1;
    simError();
  }
  
  n_atoms = atoi( read_buffer );

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

  if( n_atoms != simnfo->n_atoms ){
    sprintf( painCave.errMsg,
             "DumpReader error. %s n_atoms, %d, "
             "does not match the BASS file's n_atoms, %d.\n",
             inName, 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), inFile);
  if(eof_test == NULL){
    sprintf( painCave.errMsg,
             "error in reading commment in %s\n", inName);
    painCave.isFatal = 1;
    simError();
  }

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

  simnfo->setTime( time );
  
  for(i=0;i<3;i++)
    for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
  

  simnfo->setBoxM( theBoxMat3 );
  

  for( i=0; i < n_atoms; i++){
    
    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
    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",
              inName, 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), inFile);
    if( eof_test == NULL ){
      sprintf( painCave.errMsg,
               "Error reading 1st line of %d \n ",inName);
      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",
               inName, n_atoms, simnfo->n_atoms );
      haveError= 1;
      simError();
    }
    
    //read the time and boxMat from the comment line 
    
    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
    if(eof_test == NULL){
      sprintf( painCave.errMsg,
               "error in reading commment in %s\n", inName);
      haveError = 1;
      simError();
    }
    
    parseErr = parseCommentLine( read_buffer, time, boxMat );
    if( parseErr != NULL ){
      strcpy( painCave.errMsg, parseErr );
      haveError = 1;
      simError();
    }

    MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
    
    MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
    
    if(haveError) nodeZeroError();
    
    for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
      
      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
      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",
                inName, 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(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Bcast(boxMat, 9, 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;

  simnfo->setTime( time );

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

  simnfo->setBoxM( theBoxMat3 );

   
#endif
}

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

  char *foo; // the pointer to the current string token 
  
  double rx, ry, rz; // position place holders
  double vx, vy, vz; // velocity placeholders
  double q[4]; // the quaternions
  double jx, jy, jz; // angular velocity placeholders;
  double qSqr, qLength; // needed to normalize the quaternion vector.
  
  Atom **atoms = 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, inName, 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, inName, 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",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  rx = atof( foo );
   
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition y from %s\n"
             "natoms  = %d, index = %d\n",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  ry = atof( foo );
     
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading postition z from %s\n"
             "natoms  = %d, index = %d\n",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  rz = atof( foo );    


  // get the velocities

  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity x from %s\n"
             "natoms  = %d, index = %d\n",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vx = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity y from %s\n"
             "natoms  = %d, index = %d\n",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vy = atof( foo );
    
  foo = strtok(NULL, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading velocity z from %s\n"
             "natoms  = %d, index = %d\n",
             inName, n_atoms, atomIndex );
    return strdup( painCave.errMsg );
  }
  vz = atof( foo );
    
    
  // get the quaternions
    
  if( atoms[atomIndex]->isDirectional() ){
      
    foo = strtok(NULL, " ,;\t");
    if(foo == NULL){
      sprintf(painCave.errMsg,
              "error in reading quaternion 0 from %s\n"
              "natoms  = %d, index = %d\n",
              inName, 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",
               inName, 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",
               inName, 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",
               inName, 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",
               inName, 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",
               inName, 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",
               inName, n_atoms, atomIndex );
      return strdup( painCave.errMsg );
    }
    jz = atof( foo );
      
    dAtom = ( DirectionalAtom* )atoms[atomIndex];

    // check that the quaternion vector is normalized

    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
      
    qLength = sqrt( qSqr );
    q[0] = q[0] / qLength;
    q[1] = q[1] / qLength;
    q[2] = q[2] / qLength;
    q[3] = q[3] / qLength;
      
    dAtom->setQ( q );
      
    // add the angular velocities

    dAtom->setJx( jx );
    dAtom->setJy( jy );
    dAtom->setJz( jz );
  }
    
  // add the positions and velocities to the atom
    
  atoms[atomIndex]->setX( rx );
  atoms[atomIndex]->setY( ry );
  atoms[atomIndex]->setZ( rz );
    
  atoms[atomIndex]->set_vx( vx );
  atoms[atomIndex]->set_vy( vy );
  atoms[atomIndex]->set_vz( vz );

  return NULL;
}


char* DumpReader::parseCommentLine(char* readLine, double time, 
                                   double boxMat[9]){

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

  // set the string tokenizer
  
  foo = strtok(readLine, " ,;\t");
  if(foo == NULL){
    sprintf( painCave.errMsg,
             "error in reading time from %s\n",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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",
             inName );
    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:	647
Committed:	Tue Jul 22 21:49:38 2003 UTC (20 years, 11 months ago) by mmeineke
File size:	19028 byte(s)
Log Message:	added the scan function to the DumpReader. It should now save the start of each frame in a vector.
#	User	Rev	Content
1	mmeineke	643	#define _FILE_OFFSET_BITS 64
2
3	gezelter	637	#include <iostream>
4			#include <cmath>
5	mmeineke	646	#include <vector>
6	gezelter	637
7			#include <stdio.h>
8			#include <stdlib.h>
9			#include <string.h>
10			#include <unistd.h>
11			#include <sys/types.h>
12			#include <sys/stat.h>
13
14			#include "ReadWrite.hpp"
15			#include "simError.h"
16
17			#ifdef IS_MPI
18			#include <mpi.h>
19			#include "mpiSimulation.hpp"
20			#define TAKE_THIS_TAG_CHAR 0
21			#define TAKE_THIS_TAG_INT 1
22	mmeineke	647	#endif // is_mpi
23	gezelter	637
24			namespace dumpRead{
25	mmeineke	647
26			#ifdef IS_MPI
27	gezelter	637	void nodeZeroError( void );
28			void anonymousNodeDie( void );
29	mmeineke	647	#endif // is_mpi
30	mmeineke	646
31			class FilePos{
32	mmeineke	647
33	mmeineke	646	public:
34	mmeineke	647	FilePos(){ myPos = NULL; }
35			FilePos( fpos_t* thePos ) { myPos = thePos; }
36			~FilePos(){ if( myPos != NULL ) delete myPos; }
37	mmeineke	646
38	mmeineke	647	FilePos &operator=(fpos_t thePos){ myPos = thePos; return this; }
39
40			void setPos( fpos_t *thePos ){ myPos = thePos; }
41			fpos_t *getPos( void ){ return myPos; }
42
43	mmeineke	646	private:
44
45	mmeineke	647	fpos_t *myPos
46	mmeineke	646
47			};
48
49	mmeineke	647	bool operator<(FilePos a, FilePos b){
50			return (a.getPos())->__pos < (b.getPos())->__pos; }
51
52			bool operator==(FilePos a, FilePos b){
53			return (a.getPos())->__pos == (b.getPos())->__pos; }
54
55	mmeineke	646	vector<FilePos> frameStart;
56	gezelter	637	}
57
58			using namespace dumpRead;
59
60
61			DumpReader :: DumpReader( char *in_name ){
62	mmeineke	647
63			isScanned = false;
64
65	gezelter	637	#ifdef IS_MPI
66			if (worldRank == 0) {
67			#endif
68
69	mmeineke	647	inFile = fopen(in_name, "r");
70			if(inFile == NULL){
71	gezelter	637	sprintf(painCave.errMsg,
72			"Cannot open file: %s\n", in_name);
73			painCave.isFatal = 1;
74			simError();
75			}
76
77	mmeineke	647	strcpy( inName, in_name);
78	gezelter	637	#ifdef IS_MPI
79			}
80			strcpy( checkPointMsg, "Dump file opened for reading successfully." );
81			MPIcheckPoint();
82			#endif
83			return;
84			}
85
86			DumpReader :: ~DumpReader( ){
87			#ifdef IS_MPI
88			if (worldRank == 0) {
89			#endif
90			int error;
91	mmeineke	647	error = fclose( inFile );
92	gezelter	637	if( error ){
93			sprintf( painCave.errMsg,
94	mmeineke	647	"Error closing %s\n", inName );
95	gezelter	637	simError();
96			}
97			#ifdef IS_MPI
98			}
99			strcpy( checkPointMsg, "Dump file closed successfully." );
100			MPIcheckPoint();
101			#endif
102
103			return;
104			}
105
106	mmeineke	647	int DumpReader::getNframes( void ){
107	gezelter	637
108	mmeineke	647	if( !isScanned ) scanFile();
109			return nFrames;
110			}
111	mmeineke	643
112	mmeineke	647	void DumpReader::scanFile( void ){
113
114			int vectorSize;
115			int i, j, k;
116			int lineNum = 0;
117			char readBuffer[2000];
118			char* foo;
119			fpos_t *currPos;
120
121			#ifdef IS_MPI
122			if( worldRank == 0 ){
123			#endif // is_mpi
124
125			rewind( inFile );
126
127			currPos = new fpos_t;
128			fgetpos( inFile, currPos );
129			fgets( readBuffer, sizeof( readBuffer ), in_file );
130			lineNum++;
131			if( feof( in_file ) ){
132			sprintf( painCave.errMsg,
133			"File \"%s\" ended unexpectedly at line %d\n",
134			inName,
135			lineNum );
136			painCave.isFatal = 1;
137			simError();
138			}
139
140			while( !feof( in_file ) ){
141
142			frameStart.push_back( FilePos( currPos ) );
143			i = atoi(readBuffer);
144
145			fgets( readBuffer, sizeof( readBuffer ), in_file );
146			lineNum++;
147			if( feof( in_file ) ){
148			sprintf( painCave.errMsg,
149			"File \"%s\" ended unexpectedly at line %d\n",
150			inName,
151			lineNum );
152			painCave.isFatal = 1;
153			simError();
154			}
155
156			if(outTime){
157			foo = strtok( readBuffer, " ,;\t" );
158			time = atof( foo );
159			}
160
161			for(j=0; j<i; j++){
162
163			fgets( readBuffer, sizeof( readBuffer ), in_file );
164			lineNum++;
165			if( feof( in_file ) ){
166			sprintf( painCave.errMsg,
167			"File \"%s\" ended unexpectedly at line %d,"
168			" with atom %d\n",
169			inName,
170			lineNum,
171			j );
172			painCave.isFatal = 1;
173			simError();
174			}
175
176			}
177
178			currPos = new fpos_t;
179			fgetpos( inFile, currPos );
180			fgets( readBuffer, sizeof( readBuffer ), in_file );
181			lineNum++;
182			}
183
184			delete currPos;
185			vectorSize = frameStart.size();
186			rewind( inFile );
187
188			#ifdef IS_MPI
189			}
190			strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
191			MPIcheckPoint();
192			#endif // is_mpi
193
194			nFrames = vectorSize;
195			isScanned = true;
196			}
197
198
199
200	gezelter	637	void DumpReader :: getFrame( SimInfo* the_simnfo, int whichFrame){
201
202			int i, j, done, which_node, which_atom; // loop counter
203
204			const int BUFFERSIZE = 2000; // size of the read buffer
205			int n_atoms; // the number of atoms
206			char read_buffer[BUFFERSIZE]; //the line buffer for reading
207			#ifdef IS_MPI
208			char send_buffer[BUFFERSIZE];
209			#endif
210
211			char *eof_test; // ptr to see when we reach the end of the file
212			char *parseErr;
213			int procIndex;
214			double boxMat[9];
215			double theBoxMat3[3][3];
216
217			simnfo = the_simnfo;
218
219			#ifndef IS_MPI
220	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
221	gezelter	637	if( eof_test == NULL ){
222			sprintf( painCave.errMsg,
223			"DumpReader error: error reading 1st line of \"%s\"\n",
224	mmeineke	647	inName );
225	gezelter	637	painCave.isFatal = 1;
226			simError();
227			}
228
229			n_atoms = atoi( read_buffer );
230
231			Atom **atoms = simnfo->atoms;
232			DirectionalAtom* dAtom;
233
234			if( n_atoms != simnfo->n_atoms ){
235			sprintf( painCave.errMsg,
236			"DumpReader error. %s n_atoms, %d, "
237			"does not match the BASS file's n_atoms, %d.\n",
238	mmeineke	647	inName, n_atoms, simnfo->n_atoms );
239	gezelter	637	painCave.isFatal = 1;
240			simError();
241			}
242
243			//read the box mat from the comment line
244
245	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
246	gezelter	637	if(eof_test == NULL){
247			sprintf( painCave.errMsg,
248	mmeineke	647	"error in reading commment in %s\n", inName);
249	gezelter	637	painCave.isFatal = 1;
250			simError();
251			}
252
253			parseErr = parseCommentLine( read_buffer, time, boxMat );
254			if( parseErr != NULL ){
255			strcpy( painCave.errMsg, parseErr );
256			painCave.isFatal = 1;
257			simError();
258			}
259
260			simnfo->setTime( time );
261
262			for(i=0;i<3;i++)
263			for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
264
265
266			simnfo->setBoxM( theBoxMat3 );
267
268
269			for( i=0; i < n_atoms; i++){
270
271	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
272	gezelter	637	if(eof_test == NULL){
273			sprintf(painCave.errMsg,
274			"error in reading file %s\n"
275			"natoms = %d; index = %d\n"
276			"error reading the line from the file.\n",
277	mmeineke	647	inName, n_atoms, i );
278	gezelter	637	painCave.isFatal = 1;
279			simError();
280			}
281
282
283			parseErr = parseDumpLine( read_buffer, i );
284			if( parseErr != NULL ){
285			strcpy( painCave.errMsg, parseErr );
286			painCave.isFatal = 1;
287			simError();
288			}
289			}
290
291
292			// MPI Section of code..........
293			#else //IS_MPI
294
295			// first thing first, suspend fatalities.
296			painCave.isEventLoop = 1;
297
298			int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
299			int haveError;
300
301			MPI_Status istatus;
302			int *AtomToProcMap = mpiSim->getAtomToProcMap();
303
304
305			haveError = 0;
306			if (worldRank == 0) {
307
308	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
309	gezelter	637	if( eof_test == NULL ){
310			sprintf( painCave.errMsg,
311	mmeineke	647	"Error reading 1st line of %d \n ",inName);
312	gezelter	637	haveError = 1;
313			simError();
314			}
315
316			n_atoms = atoi( read_buffer );
317
318			Atom **atoms = simnfo->atoms;
319			DirectionalAtom* dAtom;
320
321			// Check to see that the number of atoms in the intial configuration file is the
322			// same as declared in simBass.
323
324			if( n_atoms != mpiSim->getTotAtoms() ){
325			sprintf( painCave.errMsg,
326			"Initialize from File error. %s n_atoms, %d, "
327			"does not match the BASS file's n_atoms, %d.\n",
328	mmeineke	647	inName, n_atoms, simnfo->n_atoms );
329	gezelter	637	haveError= 1;
330			simError();
331			}
332
333			//read the time and boxMat from the comment line
334
335	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
336	gezelter	637	if(eof_test == NULL){
337			sprintf( painCave.errMsg,
338	mmeineke	647	"error in reading commment in %s\n", inName);
339	gezelter	637	haveError = 1;
340			simError();
341			}
342
343			parseErr = parseCommentLine( read_buffer, time, boxMat );
344			if( parseErr != NULL ){
345			strcpy( painCave.errMsg, parseErr );
346			haveError = 1;
347			simError();
348			}
349
350			MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
351
352			MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
353
354			if(haveError) nodeZeroError();
355
356			for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
357
358	mmeineke	647	eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
359	gezelter	637	if(eof_test == NULL){
360			sprintf(painCave.errMsg,
361			"error in reading file %s\n"
362			"natoms = %d; index = %d\n"
363			"error reading the line from the file.\n",
364	mmeineke	647	inName, n_atoms, i );
365	gezelter	637	haveError= 1;
366			simError();
367			}
368
369			if(haveError) nodeZeroError();
370
371			// Get the Node number which wants this atom:
372			which_node = AtomToProcMap[i];
373			if (which_node == 0) {
374			parseErr = parseDumpLine( read_buffer, i );
375			if( parseErr != NULL ){
376			strcpy( painCave.errMsg, parseErr );
377			haveError = 1;
378			simError();
379			}
380			if(haveError) nodeZeroError();
381			}
382
383			else {
384
385			myStatus = 1;
386			MPI_Send(&myStatus, 1, MPI_INT, which_node,
387			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
388			MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
389			TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
390			MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
391			MPI_COMM_WORLD);
392			MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
393			MPI_COMM_WORLD, &istatus);
394
395			if(!myStatus) nodeZeroError();
396			}
397			}
398			myStatus = -1;
399			for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
400			MPI_Send( &myStatus, 1, MPI_INT, j,
401			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
402			}
403
404			} else {
405
406			MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
407			MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
408
409			done = 0;
410			while (!done) {
411
412			MPI_Recv(&myStatus, 1, MPI_INT, 0,
413			TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
414
415			if(!myStatus) anonymousNodeDie();
416
417			if(myStatus < 0) break;
418
419			MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
420			TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
421			MPI_Recv(&which_atom, 1, MPI_INT, 0,
422			TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
423
424			myStatus = 1;
425			parseErr = parseDumpLine( read_buffer, which_atom );
426			if( parseErr != NULL ){
427			strcpy( painCave.errMsg, parseErr );
428			myStatus = 0;;
429			simError();
430			}
431
432			MPI_Send( &myStatus, 1, MPI_INT, 0,
433			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
434
435			}
436			}
437
438			// last thing last, enable fatalities.
439			painCave.isEventLoop = 0;
440
441			simnfo->setTime( time );
442
443			for(i=0;i<3;i++)
444			for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
445
446			simnfo->setBoxM( theBoxMat3 );
447
448
449			#endif
450			}
451
452			char* DumpReader::parseDumpLine(char* readLine, int globalIndex){
453
454			char *foo; // the pointer to the current string token
455
456			double rx, ry, rz; // position place holders
457			double vx, vy, vz; // velocity placeholders
458			double q[4]; // the quaternions
459			double jx, jy, jz; // angular velocity placeholders;
460			double qSqr, qLength; // needed to normalize the quaternion vector.
461
462			Atom **atoms = simnfo->atoms;
463			DirectionalAtom* dAtom;
464
465			int j, n_atoms, atomIndex;
466
467			#ifdef IS_MPI
468			n_atoms = mpiSim->getTotAtoms();
469			atomIndex=-1;
470			for (j=0; j < mpiSim->getMyNlocal(); j++) {
471			if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
472			}
473			if (atomIndex == -1) {
474			sprintf( painCave.errMsg,
475			"Initialize from file error. Atom at index %d "
476			"in file %s does not exist on processor %d .\n",
477	mmeineke	647	globalIndex, inName, mpiSim->getMyNode() );
478	gezelter	637	return strdup( painCave.errMsg );
479			}
480			#else
481			n_atoms = simnfo->n_atoms;
482			atomIndex = globalIndex;
483			#endif // is_mpi
484
485			// set the string tokenizer
486
487			foo = strtok(readLine, " ,;\t");
488
489			// check the atom name to the current atom
490
491			if( strcmp( foo, atoms[atomIndex]->getType() ) ){
492			sprintf( painCave.errMsg,
493			"Initialize from file error. Atom %s at index %d "
494			"in file %s does not"
495			" match the BASS atom %s.\n",
496	mmeineke	647	foo, atomIndex, inName, atoms[atomIndex]->getType() );
497	gezelter	637	return strdup( painCave.errMsg );
498			}
499
500			// get the positions
501
502			foo = strtok(NULL, " ,;\t");
503			if(foo == NULL){
504			sprintf( painCave.errMsg,
505			"error in reading postition x from %s\n"
506			"natoms = %d, index = %d\n",
507	mmeineke	647	inName, n_atoms, atomIndex );
508	gezelter	637	return strdup( painCave.errMsg );
509			}
510			rx = atof( foo );
511
512			foo = strtok(NULL, " ,;\t");
513			if(foo == NULL){
514			sprintf( painCave.errMsg,
515			"error in reading postition y from %s\n"
516			"natoms = %d, index = %d\n",
517	mmeineke	647	inName, n_atoms, atomIndex );
518	gezelter	637	return strdup( painCave.errMsg );
519			}
520			ry = atof( foo );
521
522			foo = strtok(NULL, " ,;\t");
523			if(foo == NULL){
524			sprintf( painCave.errMsg,
525			"error in reading postition z from %s\n"
526			"natoms = %d, index = %d\n",
527	mmeineke	647	inName, n_atoms, atomIndex );
528	gezelter	637	return strdup( painCave.errMsg );
529			}
530			rz = atof( foo );
531
532
533			// get the velocities
534
535			foo = strtok(NULL, " ,;\t");
536			if(foo == NULL){
537			sprintf( painCave.errMsg,
538			"error in reading velocity x from %s\n"
539			"natoms = %d, index = %d\n",
540	mmeineke	647	inName, n_atoms, atomIndex );
541	gezelter	637	return strdup( painCave.errMsg );
542			}
543			vx = atof( foo );
544
545			foo = strtok(NULL, " ,;\t");
546			if(foo == NULL){
547			sprintf( painCave.errMsg,
548			"error in reading velocity y from %s\n"
549			"natoms = %d, index = %d\n",
550	mmeineke	647	inName, n_atoms, atomIndex );
551	gezelter	637	return strdup( painCave.errMsg );
552			}
553			vy = atof( foo );
554
555			foo = strtok(NULL, " ,;\t");
556			if(foo == NULL){
557			sprintf( painCave.errMsg,
558			"error in reading velocity z from %s\n"
559			"natoms = %d, index = %d\n",
560	mmeineke	647	inName, n_atoms, atomIndex );
561	gezelter	637	return strdup( painCave.errMsg );
562			}
563			vz = atof( foo );
564
565
566			// get the quaternions
567
568			if( atoms[atomIndex]->isDirectional() ){
569
570			foo = strtok(NULL, " ,;\t");
571			if(foo == NULL){
572			sprintf(painCave.errMsg,
573			"error in reading quaternion 0 from %s\n"
574			"natoms = %d, index = %d\n",
575	mmeineke	647	inName, n_atoms, atomIndex );
576	gezelter	637	return strdup( painCave.errMsg );
577			}
578			q[0] = atof( foo );
579
580			foo = strtok(NULL, " ,;\t");
581			if(foo == NULL){
582			sprintf( painCave.errMsg,
583			"error in reading quaternion 1 from %s\n"
584			"natoms = %d, index = %d\n",
585	mmeineke	647	inName, n_atoms, atomIndex );
586	gezelter	637	return strdup( painCave.errMsg );
587			}
588			q[1] = atof( foo );
589
590			foo = strtok(NULL, " ,;\t");
591			if(foo == NULL){
592			sprintf( painCave.errMsg,
593			"error in reading quaternion 2 from %s\n"
594			"natoms = %d, index = %d\n",
595	mmeineke	647	inName, n_atoms, atomIndex );
596	gezelter	637	return strdup( painCave.errMsg );
597			}
598			q[2] = atof( foo );
599
600			foo = strtok(NULL, " ,;\t");
601			if(foo == NULL){
602			sprintf( painCave.errMsg,
603			"error in reading quaternion 3 from %s\n"
604			"natoms = %d, index = %d\n",
605	mmeineke	647	inName, n_atoms, atomIndex );
606	gezelter	637	return strdup( painCave.errMsg );
607			}
608			q[3] = atof( foo );
609
610			// get the angular velocities
611
612			foo = strtok(NULL, " ,;\t");
613			if(foo == NULL){
614			sprintf( painCave.errMsg,
615			"error in reading angular momentum jx from %s\n"
616			"natoms = %d, index = %d\n",
617	mmeineke	647	inName, n_atoms, atomIndex );
618	gezelter	637	return strdup( painCave.errMsg );
619			}
620			jx = atof( foo );
621
622			foo = strtok(NULL, " ,;\t");
623			if(foo == NULL){
624			sprintf( painCave.errMsg,
625			"error in reading angular momentum jy from %s\n"
626			"natoms = %d, index = %d\n",
627	mmeineke	647	inName, n_atoms, atomIndex );
628	gezelter	637	return strdup( painCave.errMsg );
629			}
630			jy = atof(foo );
631
632			foo = strtok(NULL, " ,;\t");
633			if(foo == NULL){
634			sprintf( painCave.errMsg,
635			"error in reading angular momentum jz from %s\n"
636			"natoms = %d, index = %d\n",
637	mmeineke	647	inName, n_atoms, atomIndex );
638	gezelter	637	return strdup( painCave.errMsg );
639			}
640			jz = atof( foo );
641
642			dAtom = ( DirectionalAtom* )atoms[atomIndex];
643
644			// check that the quaternion vector is normalized
645
646			qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
647
648			qLength = sqrt( qSqr );
649			q[0] = q[0] / qLength;
650			q[1] = q[1] / qLength;
651			q[2] = q[2] / qLength;
652			q[3] = q[3] / qLength;
653
654			dAtom->setQ( q );
655
656			// add the angular velocities
657
658			dAtom->setJx( jx );
659			dAtom->setJy( jy );
660			dAtom->setJz( jz );
661			}
662
663			// add the positions and velocities to the atom
664
665			atoms[atomIndex]->setX( rx );
666			atoms[atomIndex]->setY( ry );
667			atoms[atomIndex]->setZ( rz );
668
669			atoms[atomIndex]->set_vx( vx );
670			atoms[atomIndex]->set_vy( vy );
671			atoms[atomIndex]->set_vz( vz );
672
673			return NULL;
674			}
675
676
677			char* DumpReader::parseCommentLine(char* readLine, double time,
678			double boxMat[9]){
679
680			char *foo; // the pointer to the current string token
681			int j;
682
683			// set the string tokenizer
684
685			foo = strtok(readLine, " ,;\t");
686			if(foo == NULL){
687			sprintf( painCave.errMsg,
688			"error in reading time from %s\n",
689	mmeineke	647	inName );
690	gezelter	637	return strdup( painCave.errMsg );
691			}
692			time = atof( foo );
693
694			// get the Hx vector
695
696			foo = strtok(NULL, " ,;\t");
697			if(foo == NULL){
698			sprintf( painCave.errMsg,
699			"error in reading Hx[0] from %s\n",
700	mmeineke	647	inName );
701	gezelter	637	return strdup( painCave.errMsg );
702			}
703			boxMat[0] = atof( foo );
704
705			foo = strtok(NULL, " ,;\t");
706			if(foo == NULL){
707			sprintf( painCave.errMsg,
708			"error in reading Hx[1] from %s\n",
709	mmeineke	647	inName );
710	gezelter	637	return strdup( painCave.errMsg );
711			}
712			boxMat[1] = atof( foo );
713
714			foo = strtok(NULL, " ,;\t");
715			if(foo == NULL){
716			sprintf( painCave.errMsg,
717			"error in reading Hx[2] from %s\n",
718	mmeineke	647	inName );
719	gezelter	637	return strdup( painCave.errMsg );
720			}
721			boxMat[2] = atof( foo );
722
723			// get the Hy vector
724
725			foo = strtok(NULL, " ,;\t");
726			if(foo == NULL){
727			sprintf( painCave.errMsg,
728			"error in reading Hy[0] from %s\n",
729	mmeineke	647	inName );
730	gezelter	637	return strdup( painCave.errMsg );
731			}
732			boxMat[3] = atof( foo );
733
734			foo = strtok(NULL, " ,;\t");
735			if(foo == NULL){
736			sprintf( painCave.errMsg,
737			"error in reading Hy[1] from %s\n",
738	mmeineke	647	inName );
739	gezelter	637	return strdup( painCave.errMsg );
740			}
741			boxMat[4] = atof( foo );
742
743			foo = strtok(NULL, " ,;\t");
744			if(foo == NULL){
745			sprintf( painCave.errMsg,
746			"error in reading Hy[2] from %s\n",
747	mmeineke	647	inName );
748	gezelter	637	return strdup( painCave.errMsg );
749			}
750			boxMat[5] = atof( foo );
751
752			// get the Hz vector
753
754			foo = strtok(NULL, " ,;\t");
755			if(foo == NULL){
756			sprintf( painCave.errMsg,
757			"error in reading Hz[0] from %s\n",
758	mmeineke	647	inName );
759	gezelter	637	return strdup( painCave.errMsg );
760			}
761			boxMat[6] = atof( foo );
762
763			foo = strtok(NULL, " ,;\t");
764			if(foo == NULL){
765			sprintf( painCave.errMsg,
766			"error in reading Hz[1] from %s\n",
767	mmeineke	647	inName );
768	gezelter	637	return strdup( painCave.errMsg );
769			}
770			boxMat[7] = atof( foo );
771
772			foo = strtok(NULL, " ,;\t");
773			if(foo == NULL){
774			sprintf( painCave.errMsg,
775			"error in reading Hz[2] from %s\n",
776	mmeineke	647	inName );
777	gezelter	637	return strdup( painCave.errMsg );
778			}
779			boxMat[8] = atof( foo );
780
781			return NULL;
782			}
783
784
785			#ifdef IS_MPI
786
787			// a couple of functions to let us escape the read loop
788
789			void initFile::nodeZeroError( void ){
790			int j, myStatus;
791
792			myStatus = 0;
793			for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
794			MPI_Send( &myStatus, 1, MPI_INT, j,
795			TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
796			}
797
798
799			MPI_Finalize();
800			exit (0);
801
802			}
803
804			void initFile::anonymousNodeDie( void ){
805
806			MPI_Finalize();
807			exit (0);
808			}
809
810			#endif //is_mpi