OOPSE/libmdtools/DumpWriter.cpp

#define _FILE_OFFSET_BITS 64

#include <string.h>
#include <iostream>
#include <fstream>

#ifdef IS_MPI
#include <mpi.h>
#include "mpiSimulation.hpp"

namespace dWrite{
  void DieDieDie( void );
}

using namespace dWrite;
#endif //is_mpi

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

DumpWriter::DumpWriter( SimInfo* the_entry_plug ){

  entry_plug = the_entry_plug;

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

    strcpy( outName, entry_plug->sampleName );

    outFile.open(outName, ios::out | ios::trunc );

    if( !outFile ){

      sprintf( painCave.errMsg,
               "Could not open \"%s\" for dump output.\n",
               outName);
      painCave.isFatal = 1;
      simError();
    }

    //outFile.setf( ios::scientific );

#ifdef IS_MPI
  }

  sprintf( checkPointMsg,
           "Sucessfully opened output file for dumping.\n");
  MPIcheckPoint();
#endif // is_mpi
}

DumpWriter::~DumpWriter( ){

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

    outFile.close();

#ifdef IS_MPI
  }
#endif // is_mpi
}

void DumpWriter::writeDump( double currentTime ){

  const int BUFFERSIZE = 2000;
  const int MINIBUFFERSIZE = 10;

  char tempBuffer[BUFFERSIZE];
  char writeLine[BUFFERSIZE];

  int i;
#ifdef IS_MPI
  int j, which_node, done, which_atom, local_index;
  double atomTransData[6];
  double atomOrientData[7];
  int isDirectional;
  char* atomTypeString;
  int me;
  int atomTypeTag;
  int atomIsDirectionalTag;
  int atomTransDataTag;
  int atomOrientDataTag;
#else //is_mpi
  int nAtoms = entry_plug->n_atoms;
#endif //is_mpi

  double q[4];
  DirectionalAtom* dAtom;
  Atom** atoms = entry_plug->atoms;
  double pos[3], vel[3];

  // write current frame to the eor file

  this->writeFinal( currentTime );

#ifndef IS_MPI

  outFile << nAtoms << "\n";

  outFile << currentTime << ";\t"
          << entry_plug->Hmat[0][0] << "\t"
          << entry_plug->Hmat[1][0] << "\t"
          << entry_plug->Hmat[2][0] << ";\t"

          << entry_plug->Hmat[0][1] << "\t"
          << entry_plug->Hmat[1][1] << "\t"
          << entry_plug->Hmat[2][1] << ";\t"

          << entry_plug->Hmat[0][2] << "\t"
          << entry_plug->Hmat[1][2] << "\t"
          << entry_plug->Hmat[2][2] << ";";
  //write out additional parameters, such as chi and eta
  outFile << entry_plug->the_integrator->getAdditionalParameters();
  outFile << endl;

  for( i=0; i<nAtoms; i++ ){

    atoms[i]->getPos(pos);
    atoms[i]->getVel(vel);

    sprintf( tempBuffer,
             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
             atoms[i]->getType(),
             pos[0],
             pos[1],
             pos[2],
             vel[0],
             vel[1],
             vel[2]);
    strcpy( writeLine, tempBuffer );

    if( atoms[i]->isDirectional() ){

      dAtom = (DirectionalAtom *)atoms[i];
      dAtom->getQ( q );

      sprintf( tempBuffer,
               "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
               q[0],
               q[1],
               q[2],
               q[3],
               dAtom->getJx(),
               dAtom->getJy(),
               dAtom->getJz());
      strcat( writeLine, tempBuffer );
    }
    else
      strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );

    outFile << writeLine;
  }
  outFile.flush();

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

  // write out header and node 0's coordinates

  if( worldRank == 0 ){
    outFile << mpiSim->getTotAtoms() << "\n";

    outFile << currentTime << ";\t"
            << entry_plug->Hmat[0][0] << "\t"
            << entry_plug->Hmat[1][0] << "\t"
            << entry_plug->Hmat[2][0] << ";\t"

            << entry_plug->Hmat[0][1] << "\t"
            << entry_plug->Hmat[1][1] << "\t"
            << entry_plug->Hmat[2][1] << ";\t"

            << entry_plug->Hmat[0][2] << "\t"
            << entry_plug->Hmat[1][2] << "\t"
            << entry_plug->Hmat[2][2] << ";";

    outFile << entry_plug->the_integrator->getAdditionalParameters();
    outFile << endl;
    outFile.flush();
    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
      // Get the Node number which has this atom;

      which_node = AtomToProcMap[i];

      if (which_node != 0) {
        
        atomTypeTag          = 4*i;
        atomIsDirectionalTag = 4*i + 1;
        atomTransDataTag     = 4*i + 2;
        atomOrientDataTag    = 4*i + 3;

        MPI_Recv(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
                 atomTypeTag, MPI_COMM_WORLD, &istatus);
        
        MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
                 atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
        
        MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
                 atomTransDataTag, MPI_COMM_WORLD, &istatus);

        if (isDirectional) {

          MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
                   atomOrientDataTag, MPI_COMM_WORLD, &istatus);

        }

      } else {
        
        haveError = 0;
        which_atom = i;
        local_index=-1;

        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
        }

        if (local_index != -1) {

          atomTypeString = atoms[local_index]->getType();

          atoms[local_index]->getPos(pos);
          atoms[local_index]->getVel(vel);

          atomTransData[0] = pos[0];
          atomTransData[1] = pos[1];
          atomTransData[2] = pos[2];

          atomTransData[3] = vel[0];
          atomTransData[4] = vel[1];
          atomTransData[5] = vel[2];
          
          isDirectional = 0;

          if( atoms[local_index]->isDirectional() ){

            isDirectional = 1;
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            dAtom->getQ( q );
            
            atomOrientData[0] = q[0];
            atomOrientData[1] = q[1];
            atomOrientData[2] = q[2];
            atomOrientData[3] = q[3];

            atomOrientData[4] = dAtom->getJx();
            atomOrientData[5] = dAtom->getJy();
            atomOrientData[6] = dAtom->getJz();
          }

        } else {
          sprintf(painCave.errMsg,
                  "Atom %d not found on processor %d\n",
                  i, worldRank );
          haveError= 1;
          simError();
        }

        if(haveError) DieDieDie();
                              
        // If we've survived to here, format the line:
        
        sprintf( tempBuffer,
                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                 atomTypeString,
                 atomTransData[0],
                 atomTransData[1],
                 atomTransData[2],
                 atomTransData[3],
                 atomTransData[4],
                 atomTransData[5]);

        strcpy( writeLine, tempBuffer );

        if (isDirectional) {

          sprintf( tempBuffer,
                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
                   atomOrientData[0],
                   atomOrientData[1],
                   atomOrientData[2],
                   atomOrientData[3],
                   atomOrientData[4],
                   atomOrientData[5],
                   atomOrientData[6]);
          strcat( writeLine, tempBuffer );

        } else {
          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
        }

        outFile << writeLine;
        outFile.flush();
      }
    }

    outFile.flush();
    sprintf( checkPointMsg,
             "Sucessfully took a dump.\n");
    MPIcheckPoint();        
    
  } else {

    // worldRank != 0, so I'm a remote node.  
    
    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
      
      // Am I the node which has this atom?
      
      if (AtomToProcMap[i] == worldRank) {

        local_index=-1;
        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
        }
        if (local_index != -1) {
         
          atomTypeString = atoms[local_index]->getType();

          atoms[local_index]->getPos(pos);
          atoms[local_index]->getVel(vel);

          atomTransData[0] = pos[0];
          atomTransData[1] = pos[1];
          atomTransData[2] = pos[2];

          atomTransData[3] = vel[0];
          atomTransData[4] = vel[1];
          atomTransData[5] = vel[2];
          
          isDirectional = 0;

          if( atoms[local_index]->isDirectional() ){

            isDirectional = 1;
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            dAtom->getQ( q );
            
            atomOrientData[0] = q[0];
            atomOrientData[1] = q[1];
            atomOrientData[2] = q[2];
            atomOrientData[3] = q[3];

            atomOrientData[4] = dAtom->getJx();
            atomOrientData[5] = dAtom->getJy();
            atomOrientData[6] = dAtom->getJz();
          }

        } else {
          sprintf(painCave.errMsg,
                  "Atom %d not found on processor %d\n",
                  i, worldRank );
          haveError= 1;
          simError();
        }

        // I've survived this far, so send off the data!

        atomTypeTag          = 4*i;
        atomIsDirectionalTag = 4*i + 1;
        atomTransDataTag     = 4*i + 2;
        atomOrientDataTag    = 4*i + 3;

        MPI_Send(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
                 atomTypeTag, MPI_COMM_WORLD);
        
        MPI_Send(&isDirectional, 1, MPI_INT, 0,
                 atomIsDirectionalTag, MPI_COMM_WORLD);
        
        MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
                 atomTransDataTag, MPI_COMM_WORLD);

        if (isDirectional) {

          MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
                   atomOrientDataTag, MPI_COMM_WORLD);
          
        }
      
      }
    }

    sprintf( checkPointMsg,
             "Sucessfully took a dump.\n");
    MPIcheckPoint();        
    
  }
  
  painCave.isEventLoop = 0;

#endif // is_mpi
}

void DumpWriter::writeFinal(double finalTime){

  char finalName[500];
  ofstream finalOut;

  const int BUFFERSIZE = 2000;
  const int MINIBUFFERSIZE = 10;
  char tempBuffer[BUFFERSIZE];
  char writeLine[BUFFERSIZE];

  double q[4];
  DirectionalAtom* dAtom;
  Atom** atoms = entry_plug->atoms;
  int i;
#ifdef IS_MPI
  int j, which_node, done, which_atom, local_index;
  double atomTransData[6];
  double atomOrientData[7];
  int isDirectional;
  char* atomTypeString;
  int atomTypeTag;
  int atomIsDirectionalTag;
  int atomTransDataTag;
  int atomOrientDataTag;
#else //is_mpi
  int nAtoms = entry_plug->n_atoms;
#endif //is_mpi

  double pos[3], vel[3];

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

    strcpy( finalName, entry_plug->finalName );

    finalOut.open( finalName, ios::out | ios::trunc );
    if( !finalOut ){
      sprintf( painCave.errMsg,
               "Could not open \"%s\" for final dump output.\n",
               finalName );
      painCave.isFatal = 1;
      simError();
    }

    // finalOut.setf( ios::scientific );

#ifdef IS_MPI
  }

  sprintf(checkPointMsg,"Opened file for final configuration\n");
  MPIcheckPoint();

#endif //is_mpi


#ifndef IS_MPI

  finalOut << nAtoms << "\n";

  finalOut << finalTime << ";\t"
           << entry_plug->Hmat[0][0] << "\t"
           << entry_plug->Hmat[1][0] << "\t"
           << entry_plug->Hmat[2][0] << ";\t"

           << entry_plug->Hmat[0][1] << "\t"
           << entry_plug->Hmat[1][1] << "\t"
           << entry_plug->Hmat[2][1] << ";\t"

           << entry_plug->Hmat[0][2] << "\t"
           << entry_plug->Hmat[1][2] << "\t"
           << entry_plug->Hmat[2][2] << ";";

  //write out additional parameters, such as chi and eta
  finalOut << entry_plug->the_integrator->getAdditionalParameters();
  finalOut << endl;

  for( i=0; i<nAtoms; i++ ){

    atoms[i]->getPos(pos);
    atoms[i]->getVel(vel);

    sprintf( tempBuffer,
             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
             atoms[i]->getType(),
             pos[0],
             pos[1],
             pos[2],
             vel[0],
             vel[1],
             vel[2]);
    strcpy( writeLine, tempBuffer );

    if( atoms[i]->isDirectional() ){

      dAtom = (DirectionalAtom *)atoms[i];
      dAtom->getQ( q );

      sprintf( tempBuffer,
               "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
               q[0],
               q[1],
               q[2],
               q[3],
               dAtom->getJx(),
               dAtom->getJy(),
               dAtom->getJz());
      strcat( writeLine, tempBuffer );
    }
    else
      strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );

    finalOut << writeLine;
  }
  finalOut.flush();
  finalOut.close();

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

  // write out header and node 0's coordinates

  if( worldRank == 0 ){
    finalOut << mpiSim->getTotAtoms() << "\n";

    finalOut << finalTime << ";\t"
            << entry_plug->Hmat[0][0] << "\t"
            << entry_plug->Hmat[1][0] << "\t"
            << entry_plug->Hmat[2][0] << ";\t"

            << entry_plug->Hmat[0][1] << "\t"
            << entry_plug->Hmat[1][1] << "\t"
            << entry_plug->Hmat[2][1] << ";\t"

            << entry_plug->Hmat[0][2] << "\t"
            << entry_plug->Hmat[1][2] << "\t"
            << entry_plug->Hmat[2][2] << ";";

    finalOut << entry_plug->the_integrator->getAdditionalParameters();
    finalOut << endl;
    finalOut.flush();
    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
      // Get the Node number which has this atom;

      which_node = AtomToProcMap[i];

      if (which_node != 0) {
        
        atomTypeTag          = 4*i;
        atomIsDirectionalTag = 4*i + 1;
        atomTransDataTag     = 4*i + 2;
        atomOrientDataTag    = 4*i + 3;

        MPI_Recv(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
                 atomTypeTag, MPI_COMM_WORLD, &istatus);
        
        MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
                 atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
        
        MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
                 atomTransDataTag, MPI_COMM_WORLD, &istatus);

        if (isDirectional) {

          MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
                   atomOrientDataTag, MPI_COMM_WORLD, &istatus);

        }

      } else {
        
        haveError = 0;
        which_atom = i;
        local_index=-1;

        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
        }

        if (local_index != -1) {

          atomTypeString = atoms[local_index]->getType();

          atoms[local_index]->getPos(pos);
          atoms[local_index]->getVel(vel);

          atomTransData[0] = pos[0];
          atomTransData[1] = pos[1];
          atomTransData[2] = pos[2];

          atomTransData[3] = vel[0];
          atomTransData[4] = vel[1];
          atomTransData[5] = vel[2];
          
          isDirectional = 0;

          if( atoms[local_index]->isDirectional() ){

            isDirectional = 1;
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            dAtom->getQ( q );
            
            atomOrientData[0] = q[0];
            atomOrientData[1] = q[1];
            atomOrientData[2] = q[2];
            atomOrientData[3] = q[3];

            atomOrientData[4] = dAtom->getJx();
            atomOrientData[5] = dAtom->getJy();
            atomOrientData[6] = dAtom->getJz();
          }

        } else {
          sprintf(painCave.errMsg,
                  "Atom %d not found on processor %d\n",
                  i, worldRank );
          haveError= 1;
          simError();
        }

        if(haveError) DieDieDie();
                              
        // If we've survived to here, format the line:
        
        sprintf( tempBuffer,
                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                 atomTypeString,
                 atomTransData[0],
                 atomTransData[1],
                 atomTransData[2],
                 atomTransData[3],
                 atomTransData[4],
                 atomTransData[5]);

        strcpy( writeLine, tempBuffer );

        if (isDirectional) {

          sprintf( tempBuffer,
                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
                   atomOrientData[0],
                   atomOrientData[1],
                   atomOrientData[2],
                   atomOrientData[3],
                   atomOrientData[4],
                   atomOrientData[5],
                   atomOrientData[6]);
          strcat( writeLine, tempBuffer );

        } else {
          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
        }

        finalOut << writeLine;
        finalOut.flush();
      }
    }

    finalOut.flush();
    sprintf( checkPointMsg,
             "Sucessfully took a dump.\n");
    MPIcheckPoint();        
    
  } else {

    // worldRank != 0, so I'm a remote node.  
    
    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
      
      // Am I the node which has this atom?
      
      if (AtomToProcMap[i] == worldRank) {

        local_index=-1;
        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
        }
        if (local_index != -1) {
         
          atomTypeString = atoms[local_index]->getType();

          atoms[local_index]->getPos(pos);
          atoms[local_index]->getVel(vel);

          atomTransData[0] = pos[0];
          atomTransData[1] = pos[1];
          atomTransData[2] = pos[2];

          atomTransData[3] = vel[0];
          atomTransData[4] = vel[1];
          atomTransData[5] = vel[2];
          
          isDirectional = 0;

          if( atoms[local_index]->isDirectional() ){

            isDirectional = 1;
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            dAtom->getQ( q );
            
            atomOrientData[0] = q[0];
            atomOrientData[1] = q[1];
            atomOrientData[2] = q[2];
            atomOrientData[3] = q[3];

            atomOrientData[4] = dAtom->getJx();
            atomOrientData[5] = dAtom->getJy();
            atomOrientData[6] = dAtom->getJz();
          }

        } else {
          sprintf(painCave.errMsg,
                  "Atom %d not found on processor %d\n",
                  i, worldRank );
          haveError= 1;
          simError();
        }

        // I've survived this far, so send off the data!

        atomTypeTag          = 4*i;
        atomIsDirectionalTag = 4*i + 1;
        atomTransDataTag     = 4*i + 2;
        atomOrientDataTag    = 4*i + 3;

        MPI_Send(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
                 atomTypeTag, MPI_COMM_WORLD);
        
        MPI_Send(&isDirectional, 1, MPI_INT, 0,
                 atomIsDirectionalTag, MPI_COMM_WORLD);
        
        MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
                 atomTransDataTag, MPI_COMM_WORLD);

        if (isDirectional) {

          MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
                   atomOrientDataTag, MPI_COMM_WORLD);
          
        }
      
      }
    }

    sprintf( checkPointMsg,
             "Sucessfully wrote final file.\n");
    MPIcheckPoint();        
    
  }
  
  painCave.isEventLoop = 0;

  if( worldRank == 0 ) finalOut.close();
#endif // is_mpi
}


#ifdef IS_MPI

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

void dWrite::DieDieDie( void ){

  MPI_Finalize();
  exit (0);
}

#endif //is_mpi
Revision:	907
Committed:	Thu Jan 8 17:40:56 2004 UTC (20 years, 6 months ago) by gezelter
File size:	19093 byte(s)
Log Message:	First Stab at fixing DumpWriter
#	User	Rev	Content
1	mmeineke	723	#define _FILE_OFFSET_BITS 64
2
3	gezelter	829	#include <string.h>
4	mmeineke	377	#include <iostream>
5			#include <fstream>
6
7			#ifdef IS_MPI
8			#include <mpi.h>
9			#include "mpiSimulation.hpp"
10	mmeineke	440
11			namespace dWrite{
12	gezelter	907	void DieDieDie( void );
13	mmeineke	440	}
14
15			using namespace dWrite;
16	mmeineke	377	#endif //is_mpi
17
18			#include "ReadWrite.hpp"
19			#include "simError.h"
20
21			DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
22
23			entry_plug = the_entry_plug;
24
25			#ifdef IS_MPI
26			if(worldRank == 0 ){
27			#endif // is_mpi
28	tim	837
29	mmeineke	377	strcpy( outName, entry_plug->sampleName );
30	tim	837
31	mmeineke	377	outFile.open(outName, ios::out \| ios::trunc );
32	tim	837
33	mmeineke	377	if( !outFile ){
34	tim	837
35	mmeineke	377	sprintf( painCave.errMsg,
36			"Could not open \"%s\" for dump output.\n",
37			outName);
38			painCave.isFatal = 1;
39			simError();
40			}
41	mmeineke	469
42	mmeineke	377	//outFile.setf( ios::scientific );
43
44			#ifdef IS_MPI
45			}
46
47			sprintf( checkPointMsg,
48			"Sucessfully opened output file for dumping.\n");
49			MPIcheckPoint();
50			#endif // is_mpi
51			}
52
53			DumpWriter::~DumpWriter( ){
54
55			#ifdef IS_MPI
56			if(worldRank == 0 ){
57			#endif // is_mpi
58
59			outFile.close();
60
61			#ifdef IS_MPI
62			}
63			#endif // is_mpi
64			}
65
66			void DumpWriter::writeDump( double currentTime ){
67	tim	837
68	mmeineke	377	const int BUFFERSIZE = 2000;
69	gezelter	907	const int MINIBUFFERSIZE = 10;
70
71	mmeineke	377	char tempBuffer[BUFFERSIZE];
72			char writeLine[BUFFERSIZE];
73
74	mmeineke	787	int i;
75			#ifdef IS_MPI
76			int j, which_node, done, which_atom, local_index;
77	gezelter	907	double atomTransData[6];
78			double atomOrientData[7];
79			int isDirectional;
80			char* atomTypeString;
81			int me;
82			int atomTypeTag;
83			int atomIsDirectionalTag;
84			int atomTransDataTag;
85			int atomOrientDataTag;
86	mmeineke	787	#else //is_mpi
87			int nAtoms = entry_plug->n_atoms;
88			#endif //is_mpi
89
90	mmeineke	377	double q[4];
91			DirectionalAtom* dAtom;
92			Atom** atoms = entry_plug->atoms;
93	mmeineke	670	double pos[3], vel[3];
94	tim	837
95	mmeineke	804	// write current frame to the eor file
96	mmeineke	377
97	mmeineke	804	this->writeFinal( currentTime );
98
99	mmeineke	377	#ifndef IS_MPI
100	tim	837
101	mmeineke	377	outFile << nAtoms << "\n";
102	tim	837
103			outFile << currentTime << ";\t"
104	mmeineke	590	<< entry_plug->Hmat[0][0] << "\t"
105			<< entry_plug->Hmat[1][0] << "\t"
106			<< entry_plug->Hmat[2][0] << ";\t"
107	mmeineke	572
108	mmeineke	590	<< entry_plug->Hmat[0][1] << "\t"
109			<< entry_plug->Hmat[1][1] << "\t"
110			<< entry_plug->Hmat[2][1] << ";\t"
111	mmeineke	572
112	mmeineke	590	<< entry_plug->Hmat[0][2] << "\t"
113			<< entry_plug->Hmat[1][2] << "\t"
114	tim	837	<< entry_plug->Hmat[2][2] << ";";
115			//write out additional parameters, such as chi and eta
116			outFile << entry_plug->the_integrator->getAdditionalParameters();
117			outFile << endl;
118
119	mmeineke	377	for( i=0; i<nAtoms; i++ ){
120	tim	837
121	mmeineke	670	atoms[i]->getPos(pos);
122			atoms[i]->getVel(vel);
123	mmeineke	377
124			sprintf( tempBuffer,
125			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
126			atoms[i]->getType(),
127	mmeineke	670	pos[0],
128			pos[1],
129			pos[2],
130			vel[0],
131			vel[1],
132			vel[2]);
133	mmeineke	377	strcpy( writeLine, tempBuffer );
134
135			if( atoms[i]->isDirectional() ){
136	tim	837
137	mmeineke	377	dAtom = (DirectionalAtom *)atoms[i];
138			dAtom->getQ( q );
139	tim	837
140	mmeineke	377	sprintf( tempBuffer,
141			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
142			q[0],
143			q[1],
144			q[2],
145			q[3],
146			dAtom->getJx(),
147			dAtom->getJy(),
148			dAtom->getJz());
149			strcat( writeLine, tempBuffer );
150			}
151			else
152			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
153	tim	837
154	mmeineke	377	outFile << writeLine;
155			}
156			outFile.flush();
157
158			#else // is_mpi
159	gezelter	416
160	mmeineke	440	// first thing first, suspend fatalities.
161			painCave.isEventLoop = 1;
162
163			int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
164			int haveError;
165
166	mmeineke	447	MPI_Status istatus;
167	gezelter	416	int *AtomToProcMap = mpiSim->getAtomToProcMap();
168	tim	837
169	mmeineke	377	// write out header and node 0's coordinates
170	tim	837
171	mmeineke	377	if( worldRank == 0 ){
172			outFile << mpiSim->getTotAtoms() << "\n";
173	tim	837
174			outFile << currentTime << ";\t"
175	gezelter	591	<< entry_plug->Hmat[0][0] << "\t"
176			<< entry_plug->Hmat[1][0] << "\t"
177			<< entry_plug->Hmat[2][0] << ";\t"
178	tim	837
179	gezelter	591	<< entry_plug->Hmat[0][1] << "\t"
180			<< entry_plug->Hmat[1][1] << "\t"
181			<< entry_plug->Hmat[2][1] << ";\t"
182	tim	837
183	gezelter	591	<< entry_plug->Hmat[0][2] << "\t"
184			<< entry_plug->Hmat[1][2] << "\t"
185	tim	837	<< entry_plug->Hmat[2][2] << ";";
186
187			outFile << entry_plug->the_integrator->getAdditionalParameters();
188			outFile << endl;
189	chuckv	434	outFile.flush();
190	gezelter	416	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
191	gezelter	417	// Get the Node number which has this atom;
192	tim	837
193			which_node = AtomToProcMap[i];
194
195	gezelter	907	if (which_node != 0) {
196
197			atomTypeTag = 4*i;
198			atomIsDirectionalTag = 4*i + 1;
199			atomTransDataTag = 4*i + 2;
200			atomOrientDataTag = 4*i + 3;
201	tim	837
202	gezelter	907	MPI_Recv(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
203			atomTypeTag, MPI_COMM_WORLD, &istatus);
204
205			MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
206			atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
207
208			MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
209			atomTransDataTag, MPI_COMM_WORLD, &istatus);
210
211			if (isDirectional) {
212
213			MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
214			atomOrientDataTag, MPI_COMM_WORLD, &istatus);
215
216			}
217
218			} else {
219
220	mmeineke	440	haveError = 0;
221	chuckv	436	which_atom = i;
222	tim	837	local_index=-1;
223	gezelter	907
224	chuckv	436	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
225			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
226			}
227	gezelter	907
228	chuckv	436	if (local_index != -1) {
229	tim	837
230	gezelter	907	atomTypeString = atoms[local_index]->getType();
231
232	mmeineke	670	atoms[local_index]->getPos(pos);
233			atoms[local_index]->getVel(vel);
234
235	gezelter	907	atomTransData[0] = pos[0];
236			atomTransData[1] = pos[1];
237			atomTransData[2] = pos[2];
238	tim	837
239	gezelter	907	atomTransData[3] = vel[0];
240			atomTransData[4] = vel[1];
241			atomTransData[5] = vel[2];
242
243			isDirectional = 0;
244
245	chuckv	436	if( atoms[local_index]->isDirectional() ){
246	tim	837
247	gezelter	907	isDirectional = 1;
248
249	chuckv	436	dAtom = (DirectionalAtom *)atoms[local_index];
250			dAtom->getQ( q );
251	gezelter	907
252			atomOrientData[0] = q[0];
253			atomOrientData[1] = q[1];
254			atomOrientData[2] = q[2];
255			atomOrientData[3] = q[3];
256	tim	837
257	gezelter	907	atomOrientData[4] = dAtom->getJx();
258			atomOrientData[5] = dAtom->getJy();
259			atomOrientData[6] = dAtom->getJz();
260			}
261	tim	837
262	gezelter	907	} else {
263	mmeineke	440	sprintf(painCave.errMsg,
264			"Atom %d not found on processor %d\n",
265			i, worldRank );
266			haveError= 1;
267			simError();
268	tim	837	}
269
270	gezelter	907	if(haveError) DieDieDie();
271
272			// If we've survived to here, format the line:
273
274			sprintf( tempBuffer,
275			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
276			atomTypeString,
277			atomTransData[0],
278			atomTransData[1],
279			atomTransData[2],
280			atomTransData[3],
281			atomTransData[4],
282			atomTransData[5]);
283	mmeineke	440
284	gezelter	907	strcpy( writeLine, tempBuffer );
285	tim	837
286	gezelter	907	if (isDirectional) {
287	mmeineke	440
288	gezelter	907	sprintf( tempBuffer,
289			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
290			atomOrientData[0],
291			atomOrientData[1],
292			atomOrientData[2],
293			atomOrientData[3],
294			atomOrientData[4],
295			atomOrientData[5],
296			atomOrientData[6]);
297			strcat( writeLine, tempBuffer );
298	tim	837
299	gezelter	907	} else {
300			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
301			}
302	tim	837
303	gezelter	907	outFile << writeLine;
304			outFile.flush();
305			}
306	mmeineke	377	}
307
308	gezelter	907	outFile.flush();
309			sprintf( checkPointMsg,
310			"Sucessfully took a dump.\n");
311			MPIcheckPoint();
312
313	gezelter	415	} else {
314	tim	837
315	gezelter	907	// worldRank != 0, so I'm a remote node.
316
317			for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
318
319			// Am I the node which has this atom?
320
321			if (AtomToProcMap[i] == worldRank) {
322	tim	837
323	gezelter	907	local_index=-1;
324			for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
325			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
326			}
327			if (local_index != -1) {
328
329			atomTypeString = atoms[local_index]->getType();
330	mmeineke	440
331	gezelter	907	atoms[local_index]->getPos(pos);
332			atoms[local_index]->getVel(vel);
333	tim	837
334	gezelter	907	atomTransData[0] = pos[0];
335			atomTransData[1] = pos[1];
336			atomTransData[2] = pos[2];
337	mmeineke	440
338	gezelter	907	atomTransData[3] = vel[0];
339			atomTransData[4] = vel[1];
340			atomTransData[5] = vel[2];
341
342			isDirectional = 0;
343	tim	837
344	gezelter	907	if( atoms[local_index]->isDirectional() ){
345	mmeineke	670
346	gezelter	907	isDirectional = 1;
347
348			dAtom = (DirectionalAtom *)atoms[local_index];
349			dAtom->getQ( q );
350
351			atomOrientData[0] = q[0];
352			atomOrientData[1] = q[1];
353			atomOrientData[2] = q[2];
354			atomOrientData[3] = q[3];
355	mmeineke	670
356	gezelter	907	atomOrientData[4] = dAtom->getJx();
357			atomOrientData[5] = dAtom->getJy();
358			atomOrientData[6] = dAtom->getJz();
359			}
360	tim	837
361	gezelter	907	} else {
362			sprintf(painCave.errMsg,
363			"Atom %d not found on processor %d\n",
364			i, worldRank );
365			haveError= 1;
366			simError();
367			}
368	tim	837
369	gezelter	907	// I've survived this far, so send off the data!
370	tim	837
371	gezelter	907	atomTypeTag = 4*i;
372			atomIsDirectionalTag = 4*i + 1;
373			atomTransDataTag = 4*i + 2;
374			atomOrientDataTag = 4*i + 3;
375	mmeineke	440
376	gezelter	907	MPI_Send(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
377			atomTypeTag, MPI_COMM_WORLD);
378
379			MPI_Send(&isDirectional, 1, MPI_INT, 0,
380			atomIsDirectionalTag, MPI_COMM_WORLD);
381
382			MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
383			atomTransDataTag, MPI_COMM_WORLD);
384
385			if (isDirectional) {
386
387			MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
388			atomOrientDataTag, MPI_COMM_WORLD);
389
390			}
391
392	mmeineke	377	}
393	gezelter	907	}
394	mmeineke	440
395	gezelter	907	sprintf( checkPointMsg,
396			"Sucessfully took a dump.\n");
397			MPIcheckPoint();
398
399	tim	837	}
400	gezelter	907
401	mmeineke	440	painCave.isEventLoop = 0;
402
403	mmeineke	377	#endif // is_mpi
404			}
405
406	mmeineke	572	void DumpWriter::writeFinal(double finalTime){
407	gezelter	416
408	mmeineke	377	char finalName[500];
409			ofstream finalOut;
410	gezelter	416
411			const int BUFFERSIZE = 2000;
412	gezelter	907	const int MINIBUFFERSIZE = 10;
413	gezelter	416	char tempBuffer[BUFFERSIZE];
414	tim	837	char writeLine[BUFFERSIZE];
415	gezelter	416
416			double q[4];
417			DirectionalAtom* dAtom;
418	mmeineke	787	Atom** atoms = entry_plug->atoms;
419			int i;
420			#ifdef IS_MPI
421			int j, which_node, done, which_atom, local_index;
422	gezelter	907	double atomTransData[6];
423			double atomOrientData[7];
424			int isDirectional;
425			char* atomTypeString;
426			int atomTypeTag;
427			int atomIsDirectionalTag;
428			int atomTransDataTag;
429			int atomOrientDataTag;
430	mmeineke	787	#else //is_mpi
431	gezelter	416	int nAtoms = entry_plug->n_atoms;
432	mmeineke	787	#endif //is_mpi
433	tim	837
434	mmeineke	670	double pos[3], vel[3];
435	tim	837
436	mmeineke	377	#ifdef IS_MPI
437			if(worldRank == 0 ){
438			#endif // is_mpi
439	tim	837
440	mmeineke	377	strcpy( finalName, entry_plug->finalName );
441	tim	837
442	mmeineke	377	finalOut.open( finalName, ios::out \| ios::trunc );
443			if( !finalOut ){
444			sprintf( painCave.errMsg,
445			"Could not open \"%s\" for final dump output.\n",
446			finalName );
447			painCave.isFatal = 1;
448			simError();
449			}
450	tim	837
451	mmeineke	377	// finalOut.setf( ios::scientific );
452	tim	837
453	mmeineke	377	#ifdef IS_MPI
454			}
455	tim	837
456	mmeineke	377	sprintf(checkPointMsg,"Opened file for final configuration\n");
457	tim	837	MPIcheckPoint();
458
459	mmeineke	377	#endif //is_mpi
460
461	tim	837
462	mmeineke	377	#ifndef IS_MPI
463	tim	837
464	mmeineke	377	finalOut << nAtoms << "\n";
465	tim	837
466	gezelter	591	finalOut << finalTime << ";\t"
467	mmeineke	590	<< entry_plug->Hmat[0][0] << "\t"
468			<< entry_plug->Hmat[1][0] << "\t"
469	gezelter	591	<< entry_plug->Hmat[2][0] << ";\t"
470	tim	837
471	mmeineke	590	<< entry_plug->Hmat[0][1] << "\t"
472			<< entry_plug->Hmat[1][1] << "\t"
473	gezelter	591	<< entry_plug->Hmat[2][1] << ";\t"
474	tim	837
475	mmeineke	590	<< entry_plug->Hmat[0][2] << "\t"
476			<< entry_plug->Hmat[1][2] << "\t"
477	tim	837	<< entry_plug->Hmat[2][2] << ";";
478
479			//write out additional parameters, such as chi and eta
480			finalOut << entry_plug->the_integrator->getAdditionalParameters();
481			finalOut << endl;
482
483	mmeineke	377	for( i=0; i<nAtoms; i++ ){
484	tim	837
485	mmeineke	670	atoms[i]->getPos(pos);
486			atoms[i]->getVel(vel);
487	tim	837
488	mmeineke	377	sprintf( tempBuffer,
489			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
490			atoms[i]->getType(),
491	mmeineke	670	pos[0],
492			pos[1],
493			pos[2],
494			vel[0],
495			vel[1],
496			vel[2]);
497	mmeineke	377	strcpy( writeLine, tempBuffer );
498
499			if( atoms[i]->isDirectional() ){
500	tim	837
501	mmeineke	377	dAtom = (DirectionalAtom *)atoms[i];
502			dAtom->getQ( q );
503	tim	837
504	mmeineke	377	sprintf( tempBuffer,
505			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
506			q[0],
507			q[1],
508			q[2],
509			q[3],
510			dAtom->getJx(),
511			dAtom->getJy(),
512			dAtom->getJz());
513			strcat( writeLine, tempBuffer );
514			}
515			else
516			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
517	tim	837
518	mmeineke	377	finalOut << writeLine;
519			}
520			finalOut.flush();
521	gezelter	415	finalOut.close();
522	mmeineke	377
523			#else // is_mpi
524	tim	837
525	mmeineke	440	// first thing first, suspend fatalities.
526			painCave.isEventLoop = 1;
527
528			int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
529			int haveError;
530
531	mmeineke	447	MPI_Status istatus;
532	gezelter	416	int *AtomToProcMap = mpiSim->getAtomToProcMap();
533
534	mmeineke	377	// write out header and node 0's coordinates
535	tim	837
536	mmeineke	377	if( worldRank == 0 ){
537			finalOut << mpiSim->getTotAtoms() << "\n";
538	tim	837
539	gezelter	591	finalOut << finalTime << ";\t"
540	gezelter	907	<< entry_plug->Hmat[0][0] << "\t"
541			<< entry_plug->Hmat[1][0] << "\t"
542			<< entry_plug->Hmat[2][0] << ";\t"
543	tim	837
544	gezelter	907	<< entry_plug->Hmat[0][1] << "\t"
545			<< entry_plug->Hmat[1][1] << "\t"
546			<< entry_plug->Hmat[2][1] << ";\t"
547	tim	837
548	gezelter	907	<< entry_plug->Hmat[0][2] << "\t"
549			<< entry_plug->Hmat[1][2] << "\t"
550			<< entry_plug->Hmat[2][2] << ";";
551	tim	837
552			finalOut << entry_plug->the_integrator->getAdditionalParameters();
553			finalOut << endl;
554	gezelter	907	finalOut.flush();
555	gezelter	416	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
556	gezelter	907	// Get the Node number which has this atom;
557	tim	837
558			which_node = AtomToProcMap[i];
559
560	gezelter	907	if (which_node != 0) {
561
562			atomTypeTag = 4*i;
563			atomIsDirectionalTag = 4*i + 1;
564			atomTransDataTag = 4*i + 2;
565			atomOrientDataTag = 4*i + 3;
566	chuckv	437
567	gezelter	907	MPI_Recv(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
568			atomTypeTag, MPI_COMM_WORLD, &istatus);
569
570			MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
571			atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
572
573			MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
574			atomTransDataTag, MPI_COMM_WORLD, &istatus);
575
576			if (isDirectional) {
577
578			MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
579			atomOrientDataTag, MPI_COMM_WORLD, &istatus);
580
581			}
582
583			} else {
584
585			haveError = 0;
586	chuckv	437	which_atom = i;
587	tim	837	local_index=-1;
588	gezelter	907
589	chuckv	437	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
590			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
591			}
592	gezelter	907
593	tim	837	if (local_index != -1) {
594	mmeineke	670
595	gezelter	907	atomTypeString = atoms[local_index]->getType();
596
597	mmeineke	670	atoms[local_index]->getPos(pos);
598			atoms[local_index]->getVel(vel);
599	tim	837
600	gezelter	907	atomTransData[0] = pos[0];
601			atomTransData[1] = pos[1];
602			atomTransData[2] = pos[2];
603	tim	837
604	gezelter	907	atomTransData[3] = vel[0];
605			atomTransData[4] = vel[1];
606			atomTransData[5] = vel[2];
607
608			isDirectional = 0;
609	tim	837
610	gezelter	907	if( atoms[local_index]->isDirectional() ){
611	tim	837
612	gezelter	907	isDirectional = 1;
613
614			dAtom = (DirectionalAtom *)atoms[local_index];
615			dAtom->getQ( q );
616
617			atomOrientData[0] = q[0];
618			atomOrientData[1] = q[1];
619			atomOrientData[2] = q[2];
620			atomOrientData[3] = q[3];
621
622			atomOrientData[4] = dAtom->getJx();
623			atomOrientData[5] = dAtom->getJy();
624			atomOrientData[6] = dAtom->getJz();
625			}
626
627			} else {
628	mmeineke	440	sprintf(painCave.errMsg,
629			"Atom %d not found on processor %d\n",
630			i, worldRank );
631			haveError= 1;
632			simError();
633	tim	837	}
634	mmeineke	440
635	gezelter	907	if(haveError) DieDieDie();
636
637			// If we've survived to here, format the line:
638
639			sprintf( tempBuffer,
640			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
641			atomTypeString,
642			atomTransData[0],
643			atomTransData[1],
644			atomTransData[2],
645			atomTransData[3],
646			atomTransData[4],
647			atomTransData[5]);
648	tim	837
649	gezelter	907	strcpy( writeLine, tempBuffer );
650	tim	837
651	gezelter	907	if (isDirectional) {
652	tim	837
653	gezelter	907	sprintf( tempBuffer,
654			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
655			atomOrientData[0],
656			atomOrientData[1],
657			atomOrientData[2],
658			atomOrientData[3],
659			atomOrientData[4],
660			atomOrientData[5],
661			atomOrientData[6]);
662			strcat( writeLine, tempBuffer );
663	tim	837
664	gezelter	907	} else {
665			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
666			}
667	tim	837
668	gezelter	907	finalOut << writeLine;
669			finalOut.flush();
670			}
671	mmeineke	377	}
672
673	gezelter	907	finalOut.flush();
674			sprintf( checkPointMsg,
675			"Sucessfully took a dump.\n");
676			MPIcheckPoint();
677
678	gezelter	415	} else {
679	tim	837
680	gezelter	907	// worldRank != 0, so I'm a remote node.
681
682			for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
683
684			// Am I the node which has this atom?
685
686			if (AtomToProcMap[i] == worldRank) {
687	mmeineke	440
688	gezelter	907	local_index=-1;
689			for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
690			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
691			}
692			if (local_index != -1) {
693
694			atomTypeString = atoms[local_index]->getType();
695	tim	837
696	gezelter	907	atoms[local_index]->getPos(pos);
697			atoms[local_index]->getVel(vel);
698	tim	837
699	gezelter	907	atomTransData[0] = pos[0];
700			atomTransData[1] = pos[1];
701			atomTransData[2] = pos[2];
702	tim	837
703	gezelter	907	atomTransData[3] = vel[0];
704			atomTransData[4] = vel[1];
705			atomTransData[5] = vel[2];
706
707			isDirectional = 0;
708	tim	837
709	gezelter	907	if( atoms[local_index]->isDirectional() ){
710	mmeineke	377
711	gezelter	907	isDirectional = 1;
712
713			dAtom = (DirectionalAtom *)atoms[local_index];
714			dAtom->getQ( q );
715
716			atomOrientData[0] = q[0];
717			atomOrientData[1] = q[1];
718			atomOrientData[2] = q[2];
719			atomOrientData[3] = q[3];
720	mmeineke	670
721	gezelter	907	atomOrientData[4] = dAtom->getJx();
722			atomOrientData[5] = dAtom->getJy();
723			atomOrientData[6] = dAtom->getJz();
724			}
725	tim	837
726	gezelter	907	} else {
727			sprintf(painCave.errMsg,
728			"Atom %d not found on processor %d\n",
729			i, worldRank );
730			haveError= 1;
731			simError();
732			}
733	tim	837
734	gezelter	907	// I've survived this far, so send off the data!
735	tim	837
736	gezelter	907	atomTypeTag = 4*i;
737			atomIsDirectionalTag = 4*i + 1;
738			atomTransDataTag = 4*i + 2;
739			atomOrientDataTag = 4*i + 3;
740	tim	837
741	gezelter	907	MPI_Send(atomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
742			atomTypeTag, MPI_COMM_WORLD);
743
744			MPI_Send(&isDirectional, 1, MPI_INT, 0,
745			atomIsDirectionalTag, MPI_COMM_WORLD);
746
747			MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
748			atomTransDataTag, MPI_COMM_WORLD);
749
750			if (isDirectional) {
751
752			MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
753			atomOrientDataTag, MPI_COMM_WORLD);
754
755			}
756
757	mmeineke	377	}
758	gezelter	907	}
759	mmeineke	440
760	gezelter	907	sprintf( checkPointMsg,
761			"Sucessfully wrote final file.\n");
762			MPIcheckPoint();
763
764	gezelter	419	}
765	gezelter	907
766			painCave.isEventLoop = 0;
767	tim	837
768			if( worldRank == 0 ) finalOut.close();
769	mmeineke	377	#endif // is_mpi
770			}
771	mmeineke	440
772
773
774			#ifdef IS_MPI
775
776			// a couple of functions to let us escape the write loop
777
778	gezelter	907	void dWrite::DieDieDie( void ){
779	tim	837
780	mmeineke	440	MPI_Finalize();
781			exit (0);
782			}
783
784			#endif //is_mpi