OOPSE/libmdtools/DumpWriter.cpp

#include <cstring>
#include <iostream>
#include <fstream>

#ifdef IS_MPI
#include <mpi.h>
#include <mpi++.h>
#include "mpiSimulation.hpp"
#define TAKE_THIS_TAG_CHAR 1
#define TAKE_THIS_TAG_INT 2
#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;
  char tempBuffer[BUFFERSIZE];
  char writeLine[BUFFERSIZE];

  int i, j, which_node, done, game_over, which_atom, local_index;
  double q[4];
  DirectionalAtom* dAtom;
  int nAtoms = entry_plug->n_atoms;
  Atom** atoms = entry_plug->atoms;
    

#ifndef IS_MPI
    
  outFile << nAtoms << "\n";
    
  outFile << currentTime << "\t" 
          << entry_plug->box_x << "\t"
          << entry_plug->box_y << "\t"
          << entry_plug->box_z << "\n";
    
  for( i=0; i<nAtoms; i++ ){
      

    sprintf( tempBuffer,
             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
             atoms[i]->getType(),
             atoms[i]->getX(),
             atoms[i]->getY(),
             atoms[i]->getZ(),
             atoms[i]->get_vx(),
             atoms[i]->get_vy(),
             atoms[i]->get_vz());
    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

  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->box_x << "\t"
            << entry_plug->box_y << "\t"
            << entry_plug->box_z << "\n";
    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 ) {
        
        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) {
          //format the line
          sprintf( tempBuffer,
                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                   atoms[local_index]->getType(),
                   atoms[local_index]->getX(),
                   atoms[local_index]->getY(),
                   atoms[local_index]->getZ(),
                   atoms[local_index]->get_vx(),
                   atoms[local_index]->get_vy(),
                   atoms[local_index]->get_vz()); // check here.
          strcpy( writeLine, tempBuffer );
          
          if( atoms[local_index]->isDirectional() ){
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            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" );       
        }
        else {
          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
        } 
      } 
      else {
        
        //std::cerr << "node 0: sending node " << which_node << " request for atom " << i << "\n";
        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
        //std::cerr << "node 0: sent!\n";
        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
                             TAKE_THIS_TAG_CHAR, istatus);
        //std::cerr << "node 0: got this line: " << writeLine;
      }
      
      outFile << writeLine;
      outFile.flush();
    }
    
    // kill everyone off:
    game_over = -1;
    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG_INT);
    }

  } else {
    
    done = 0;
    while (!done) {
      //std::cerr << "node: " << mpiSim->getMyNode() << " Waiting for receive \n";
      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0, 
                           TAKE_THIS_TAG_INT, istatus);
      //std::cerr << "node: " << mpiSim->getMyNode() << " got request for atom " << which_atom << "\n";
      if (which_atom == -1) {
        done=1;
        continue;
      } else {
        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) {
          //format the line
          sprintf( tempBuffer,
                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                   atoms[local_index]->getType(),
                   atoms[local_index]->getX(),
                   atoms[local_index]->getY(),
                   atoms[local_index]->getZ(),
                   atoms[local_index]->get_vx(),
                   atoms[local_index]->get_vy(),
                   atoms[local_index]->get_vz()); // check here.
          strcpy( writeLine, tempBuffer );
          
          if( atoms[local_index]->isDirectional() ){
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            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" );
          // std::cerr << "node: " << mpiSim->getMyNode() << " sending this line" << writeLine;
          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0, 
                               TAKE_THIS_TAG_CHAR);
        } else {
          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0, 
                               TAKE_THIS_TAG_CHAR);
        }
      }
    }
  }  
  outFile.flush();
  sprintf( checkPointMsg,
           "Sucessfully took a dump.\n");
  MPIcheckPoint();
#endif // is_mpi
}

void DumpWriter::writeFinal(){

  char finalName[500];
  ofstream finalOut;

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

  double q[4];
  DirectionalAtom* dAtom;
  int nAtoms = entry_plug->n_atoms;
  Atom** atoms = entry_plug->atoms;
  int i, j, which_node, done, game_over, which_atom, local_index;
  
  
#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 << entry_plug->box_x << "\t"
           << entry_plug->box_y << "\t"
           << entry_plug->box_z << "\n";
  
  for( i=0; i<nAtoms; i++ ){
      
    sprintf( tempBuffer,
             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
             atoms[i]->getType(),
             atoms[i]->getX(),
             atoms[i]->getY(),
             atoms[i]->getZ(),
             atoms[i]->get_vx(),
             atoms[i]->get_vy(),
             atoms[i]->get_vz());
    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
  
  MPI::Status istatus;
  int *AtomToProcMap = mpiSim->getAtomToProcMap();

  // write out header and node 0's coordinates
  
  if( worldRank == 0 ){
    finalOut << mpiSim->getTotAtoms() << "\n";
    
    finalOut << entry_plug->box_x << "\t"
            << entry_plug->box_y << "\t"
            << entry_plug->box_z << "\n";
    
    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
      // Get the Node number which has this molecule:
      
      which_node = AtomToProcMap[i];     
      
      if (which_node == mpiSim->getMyNode()) {
        
        sprintf( tempBuffer,
                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                 atoms[i]->getType(),
                 atoms[i]->getX(),
                 atoms[i]->getY(),
                 atoms[i]->getZ(),
                 atoms[i]->get_vx(),
                 atoms[i]->get_vy(),
                 atoms[i]->get_vz());
        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" );       
        
      } else {
        
        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
                                TAKE_THIS_TAG_CHAR, istatus);
      }
      
      finalOut << writeLine;
    }
    
    // kill everyone off:
    game_over = -1;
    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG_INT);
    }

  } else {
    
    done = 0;
    while (!done) {
      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0, 
                           TAKE_THIS_TAG_INT, istatus);

      if (which_atom == -1) {
        done=1;
        continue;
      } else {

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

          //format the line
          sprintf( tempBuffer,
                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
                   atoms[local_index]->getType(),
                   atoms[local_index]->getX(),
                   atoms[local_index]->getY(),
                   atoms[local_index]->getZ(),
                   atoms[local_index]->get_vx(),
                   atoms[local_index]->get_vy(),
                   atoms[local_index]->get_vz()); // check here.
          strcpy( writeLine, tempBuffer );
          
          if( atoms[local_index]->isDirectional() ){
            
            dAtom = (DirectionalAtom *)atoms[local_index];
            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" );
          
          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0, 
                               TAKE_THIS_TAG_CHAR);
        } else {
          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0, 
                               TAKE_THIS_TAG_CHAR);
        }
      }
    }
  }
  finalOut.flush();
  sprintf( checkPointMsg,
           "Sucessfully took a dump.\n");
  MPIcheckPoint();

  if( worldRank == 0 ) finalOut.close();    
#endif // is_mpi
}
Revision:	436
Committed:	Fri Mar 28 21:45:03 2003 UTC (21 years, 3 months ago) by chuckv
File size:	13369 byte(s)
Log Message:	Bug fixes in read-write routines.
#	User	Rev	Content
1	mmeineke	377	#include <cstring>
2			#include <iostream>
3			#include <fstream>
4
5			#ifdef IS_MPI
6			#include <mpi.h>
7	gezelter	416	#include <mpi++.h>
8	mmeineke	377	#include "mpiSimulation.hpp"
9	chuckv	436	#define TAKE_THIS_TAG_CHAR 1
10			#define TAKE_THIS_TAG_INT 2
11	mmeineke	377	#endif //is_mpi
12
13			#include "ReadWrite.hpp"
14			#include "simError.h"
15
16			DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
17
18			entry_plug = the_entry_plug;
19
20			#ifdef IS_MPI
21			if(worldRank == 0 ){
22			#endif // is_mpi
23
24
25
26			strcpy( outName, entry_plug->sampleName );
27
28			outFile.open(outName, ios::out \| ios::trunc );
29
30			if( !outFile ){
31
32			sprintf( painCave.errMsg,
33			"Could not open \"%s\" for dump output.\n",
34			outName);
35			painCave.isFatal = 1;
36			simError();
37			}
38
39			//outFile.setf( ios::scientific );
40
41			#ifdef IS_MPI
42			}
43
44			sprintf( checkPointMsg,
45			"Sucessfully opened output file for dumping.\n");
46			MPIcheckPoint();
47			#endif // is_mpi
48			}
49
50			DumpWriter::~DumpWriter( ){
51
52			#ifdef IS_MPI
53			if(worldRank == 0 ){
54			#endif // is_mpi
55
56			outFile.close();
57
58			#ifdef IS_MPI
59			}
60			#endif // is_mpi
61			}
62
63			void DumpWriter::writeDump( double currentTime ){
64
65			const int BUFFERSIZE = 2000;
66			char tempBuffer[BUFFERSIZE];
67			char writeLine[BUFFERSIZE];
68
69	gezelter	419	int i, j, which_node, done, game_over, which_atom, local_index;
70	mmeineke	377	double q[4];
71			DirectionalAtom* dAtom;
72			int nAtoms = entry_plug->n_atoms;
73			Atom** atoms = entry_plug->atoms;
74
75
76			#ifndef IS_MPI
77
78			outFile << nAtoms << "\n";
79
80			outFile << currentTime << "\t"
81			<< entry_plug->box_x << "\t"
82			<< entry_plug->box_y << "\t"
83			<< entry_plug->box_z << "\n";
84
85			for( i=0; i<nAtoms; i++ ){
86
87
88			sprintf( tempBuffer,
89			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
90			atoms[i]->getType(),
91			atoms[i]->getX(),
92			atoms[i]->getY(),
93			atoms[i]->getZ(),
94			atoms[i]->get_vx(),
95			atoms[i]->get_vy(),
96			atoms[i]->get_vz());
97			strcpy( writeLine, tempBuffer );
98
99			if( atoms[i]->isDirectional() ){
100
101			dAtom = (DirectionalAtom *)atoms[i];
102			dAtom->getQ( q );
103
104			sprintf( tempBuffer,
105			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
106			q[0],
107			q[1],
108			q[2],
109			q[3],
110			dAtom->getJx(),
111			dAtom->getJy(),
112			dAtom->getJz());
113			strcat( writeLine, tempBuffer );
114			}
115			else
116			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
117
118			outFile << writeLine;
119			}
120			outFile.flush();
121
122			#else // is_mpi
123	gezelter	416
124			MPI::Status istatus;
125			int *AtomToProcMap = mpiSim->getAtomToProcMap();
126	gezelter	415
127	mmeineke	377	// write out header and node 0's coordinates
128	gezelter	415
129	mmeineke	377	if( worldRank == 0 ){
130			outFile << mpiSim->getTotAtoms() << "\n";
131	gezelter	415
132	mmeineke	377	outFile << currentTime << "\t"
133			<< entry_plug->box_x << "\t"
134			<< entry_plug->box_y << "\t"
135			<< entry_plug->box_z << "\n";
136	chuckv	434	outFile.flush();
137	gezelter	416	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
138	gezelter	417	// Get the Node number which has this atom;
139	mmeineke	377
140	gezelter	415	which_node = AtomToProcMap[i];
141
142	chuckv	436	if (which_node == 0 ) {
143	mmeineke	377
144	chuckv	436	which_atom = i;
145			local_index=-1;
146			for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
147			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
148			}
149			if (local_index != -1) {
150			//format the line
151			sprintf( tempBuffer,
152			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
153			atoms[local_index]->getType(),
154			atoms[local_index]->getX(),
155			atoms[local_index]->getY(),
156			atoms[local_index]->getZ(),
157			atoms[local_index]->get_vx(),
158			atoms[local_index]->get_vy(),
159			atoms[local_index]->get_vz()); // check here.
160			strcpy( writeLine, tempBuffer );
161	mmeineke	377
162	chuckv	436	if( atoms[local_index]->isDirectional() ){
163
164			dAtom = (DirectionalAtom *)atoms[local_index];
165			dAtom->getQ( q );
166
167			sprintf( tempBuffer,
168			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
169			q[0],
170			q[1],
171			q[2],
172			q[3],
173			dAtom->getJx(),
174			dAtom->getJy(),
175			dAtom->getJz());
176			strcat( writeLine, tempBuffer );
177
178			}
179			else
180			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
181			}
182			else {
183			strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
184			}
185			}
186			else {
187	gezelter	415
188	chuckv	436	//std::cerr << "node 0: sending node " << which_node << " request for atom " << i << "\n";
189			MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
190			//std::cerr << "node 0: sent!\n";
191	gezelter	416	MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
192	chuckv	436	TAKE_THIS_TAG_CHAR, istatus);
193			//std::cerr << "node 0: got this line: " << writeLine;
194	mmeineke	377	}
195	gezelter	415
196	mmeineke	377	outFile << writeLine;
197	chuckv	434	outFile.flush();
198	mmeineke	377	}
199
200	gezelter	415	// kill everyone off:
201	gezelter	416	game_over = -1;
202			for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
203	chuckv	436	MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG_INT);
204	mmeineke	377	}
205
206	gezelter	415	} else {
207
208			done = 0;
209			while (!done) {
210	chuckv	436	//std::cerr << "node: " << mpiSim->getMyNode() << " Waiting for receive \n";
211	gezelter	416	MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
212	chuckv	436	TAKE_THIS_TAG_INT, istatus);
213			//std::cerr << "node: " << mpiSim->getMyNode() << " got request for atom " << which_atom << "\n";
214	gezelter	416	if (which_atom == -1) {
215	gezelter	415	done=1;
216			continue;
217			} else {
218	gezelter	419	local_index=-1;
219	chuckv	436	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
220	gezelter	419	if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
221			}
222			if (local_index != -1) {
223			//format the line
224			sprintf( tempBuffer,
225			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
226			atoms[local_index]->getType(),
227			atoms[local_index]->getX(),
228			atoms[local_index]->getY(),
229			atoms[local_index]->getZ(),
230			atoms[local_index]->get_vx(),
231			atoms[local_index]->get_vy(),
232			atoms[local_index]->get_vz()); // check here.
233			strcpy( writeLine, tempBuffer );
234	mmeineke	377
235	gezelter	419	if( atoms[local_index]->isDirectional() ){
236
237			dAtom = (DirectionalAtom *)atoms[local_index];
238			dAtom->getQ( q );
239
240			sprintf( tempBuffer,
241			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
242			q[0],
243			q[1],
244			q[2],
245			q[3],
246			dAtom->getJx(),
247			dAtom->getJy(),
248			dAtom->getJz());
249			strcat( writeLine, tempBuffer );
250			}
251			else
252			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
253	chuckv	436	// std::cerr << "node: " << mpiSim->getMyNode() << " sending this line" << writeLine;
254	gezelter	419	MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
255	chuckv	436	TAKE_THIS_TAG_CHAR);
256	gezelter	419	} else {
257			strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
258			MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
259	chuckv	436	TAKE_THIS_TAG_CHAR);
260	gezelter	419	}
261	mmeineke	377	}
262			}
263	gezelter	415	}
264			outFile.flush();
265			sprintf( checkPointMsg,
266			"Sucessfully took a dump.\n");
267			MPIcheckPoint();
268	mmeineke	377	#endif // is_mpi
269			}
270
271			void DumpWriter::writeFinal(){
272	gezelter	416
273	mmeineke	377	char finalName[500];
274			ofstream finalOut;
275	gezelter	416
276			const int BUFFERSIZE = 2000;
277			char tempBuffer[BUFFERSIZE];
278			char writeLine[BUFFERSIZE];
279
280			double q[4];
281			DirectionalAtom* dAtom;
282			int nAtoms = entry_plug->n_atoms;
283			Atom** atoms = entry_plug->atoms;
284	gezelter	419	int i, j, which_node, done, game_over, which_atom, local_index;
285	mmeineke	377
286	gezelter	416
287	mmeineke	377	#ifdef IS_MPI
288			if(worldRank == 0 ){
289			#endif // is_mpi
290
291			strcpy( finalName, entry_plug->finalName );
292
293			finalOut.open( finalName, ios::out \| ios::trunc );
294			if( !finalOut ){
295			sprintf( painCave.errMsg,
296			"Could not open \"%s\" for final dump output.\n",
297			finalName );
298			painCave.isFatal = 1;
299			simError();
300			}
301
302			// finalOut.setf( ios::scientific );
303
304			#ifdef IS_MPI
305			}
306
307			sprintf(checkPointMsg,"Opened file for final configuration\n");
308			MPIcheckPoint();
309
310			#endif //is_mpi
311
312	gezelter	415
313	mmeineke	377	#ifndef IS_MPI
314
315			finalOut << nAtoms << "\n";
316
317			finalOut << entry_plug->box_x << "\t"
318			<< entry_plug->box_y << "\t"
319			<< entry_plug->box_z << "\n";
320	gezelter	416
321	mmeineke	377	for( i=0; i<nAtoms; i++ ){
322
323			sprintf( tempBuffer,
324			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
325			atoms[i]->getType(),
326			atoms[i]->getX(),
327			atoms[i]->getY(),
328			atoms[i]->getZ(),
329			atoms[i]->get_vx(),
330			atoms[i]->get_vy(),
331			atoms[i]->get_vz());
332			strcpy( writeLine, tempBuffer );
333
334			if( atoms[i]->isDirectional() ){
335
336			dAtom = (DirectionalAtom *)atoms[i];
337			dAtom->getQ( q );
338
339			sprintf( tempBuffer,
340			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
341			q[0],
342			q[1],
343			q[2],
344			q[3],
345			dAtom->getJx(),
346			dAtom->getJy(),
347			dAtom->getJz());
348			strcat( writeLine, tempBuffer );
349			}
350			else
351			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
352
353			finalOut << writeLine;
354			}
355			finalOut.flush();
356	gezelter	415	finalOut.close();
357	mmeineke	377
358			#else // is_mpi
359	gezelter	415
360	gezelter	416	MPI::Status istatus;
361			int *AtomToProcMap = mpiSim->getAtomToProcMap();
362
363	mmeineke	377	// write out header and node 0's coordinates
364	gezelter	415
365	mmeineke	377	if( worldRank == 0 ){
366			finalOut << mpiSim->getTotAtoms() << "\n";
367	gezelter	415
368	mmeineke	377	finalOut << entry_plug->box_x << "\t"
369	gezelter	415	<< entry_plug->box_y << "\t"
370			<< entry_plug->box_z << "\n";
371	mmeineke	377
372	gezelter	416	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
373	gezelter	415	// Get the Node number which has this molecule:
374	mmeineke	377
375	gezelter	415	which_node = AtomToProcMap[i];
376
377	gezelter	416	if (which_node == mpiSim->getMyNode()) {
378	gezelter	415
379			sprintf( tempBuffer,
380			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
381			atoms[i]->getType(),
382			atoms[i]->getX(),
383			atoms[i]->getY(),
384			atoms[i]->getZ(),
385			atoms[i]->get_vx(),
386			atoms[i]->get_vy(),
387			atoms[i]->get_vz());
388			strcpy( writeLine, tempBuffer );
389	mmeineke	377
390	gezelter	415	if( atoms[i]->isDirectional() ){
391	mmeineke	377
392	gezelter	415	dAtom = (DirectionalAtom *)atoms[i];
393			dAtom->getQ( q );
394	mmeineke	377
395	gezelter	415	sprintf( tempBuffer,
396			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
397			q[0],
398			q[1],
399			q[2],
400			q[3],
401			dAtom->getJx(),
402			dAtom->getJy(),
403			dAtom->getJz());
404			strcat( writeLine, tempBuffer );
405			}
406			else
407			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
408
409			} else {
410
411	chuckv	436	MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
412	gezelter	416	MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
413	chuckv	436	TAKE_THIS_TAG_CHAR, istatus);
414	mmeineke	377	}
415	gezelter	415
416	mmeineke	377	finalOut << writeLine;
417			}
418
419	gezelter	415	// kill everyone off:
420	gezelter	416	game_over = -1;
421			for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
422	chuckv	436	MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG_INT);
423	mmeineke	377	}
424
425	gezelter	415	} else {
426
427			done = 0;
428			while (!done) {
429	gezelter	416	MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
430	chuckv	436	TAKE_THIS_TAG_INT, istatus);
431	mmeineke	377
432	gezelter	416	if (which_atom == -1) {
433	gezelter	415	done=1;
434			continue;
435			} else {
436	mmeineke	377
437	gezelter	419	local_index=-1;
438			for (j=0; j < mpiSim->getMyNlocal(); j++) {
439			if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
440			}
441			if (local_index != -1) {
442
443			//format the line
444			sprintf( tempBuffer,
445			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
446			atoms[local_index]->getType(),
447			atoms[local_index]->getX(),
448			atoms[local_index]->getY(),
449			atoms[local_index]->getZ(),
450			atoms[local_index]->get_vx(),
451			atoms[local_index]->get_vy(),
452			atoms[local_index]->get_vz()); // check here.
453			strcpy( writeLine, tempBuffer );
454	mmeineke	377
455	gezelter	419	if( atoms[local_index]->isDirectional() ){
456
457			dAtom = (DirectionalAtom *)atoms[local_index];
458			dAtom->getQ( q );
459	mmeineke	377
460	gezelter	419	sprintf( tempBuffer,
461			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
462			q[0],
463			q[1],
464			q[2],
465			q[3],
466			dAtom->getJx(),
467			dAtom->getJy(),
468			dAtom->getJz());
469			strcat( writeLine, tempBuffer );
470			}
471			else
472			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
473
474			MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
475	chuckv	436	TAKE_THIS_TAG_CHAR);
476	gezelter	419	} else {
477			strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
478			MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
479	chuckv	436	TAKE_THIS_TAG_CHAR);
480	gezelter	419	}
481	mmeineke	377	}
482			}
483	gezelter	419	}
484	gezelter	415	finalOut.flush();
485			sprintf( checkPointMsg,
486			"Sucessfully took a dump.\n");
487			MPIcheckPoint();
488	mmeineke	377
489	gezelter	415	if( worldRank == 0 ) finalOut.close();
490	mmeineke	377	#endif // is_mpi
491			}