mdtools/md_code/DumpWriter.cpp

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

#ifdef IS_MPI
#include <mpi.h>
#include "mpiSimulation.hpp"
#define TAKE_THIS_TAG 0
#endif //is_mpi

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


DumpWriter::DumpWriter( SimInfo* the_entry_plug ){

#ifdef IS_MPI
  if(worldRank == 0 ){
#endif // is_mpi
    
    entry_plug = the_entry_plug;
    
    strcpy( outName, entry_plug->sampleName );
    
    std::cerr << "Opening " << outName << " for dumping.\n";

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

  int masterIndex;
  int nodeAtomsStart;
  int nodeAtomsEnd;
  int mpiErr;
  int sendError;
  int procIndex;
    
  MPI_Status istatus[MPI_STATUS_SIZE];

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

    masterIndex = 0;
    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;
      masterIndex++;
    }
    outFile.flush();
  }

  sprintf( checkPointMsg,
           "Sucessfully wrote node 0's dump configuration.\n");
  MPIcheckPoint();
    
  for (procIndex = 1; procIndex < mpiSim->getNumberProcessors();
       procIndex++){

    if( worldRank == 0 ){
      
      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
                        TAKE_THIS_TAG,MPI_COMM_WORLD,istatus);
      
      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
                        TAKE_THIS_TAG,MPI_COMM_WORLD, istatus);
      
      // Make sure where node 0 is writing to, matches where the
      // receiving node expects it to be.
      
      if (masterIndex != nodeAtomsStart){
        sendError = 1;
        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
                          MPI_COMM_WORLD);
        sprintf(painCave.errMsg,
                "DumpWriter error: atoms start index (%d) for "
                "node %d not equal to master index (%d)",
                nodeAtomsStart,procIndex,masterIndex );
        painCave.isFatal = 1;
        simError();
      }
      
      sendError = 0;
      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);
      
      // recieve the nodes writeLines
      
      for ( i = nodeAtomsStart; i <= nodeAtomsEnd; i++){
        
        mpiErr = MPI_Recv(writeLine,BUFFERSIZE,MPI_CHAR,procIndex,
                          TAKE_THIS_TAG,MPI_COMM_WORLD,istatus );
        
        outFile << writeLine;
        masterIndex++;
      }
    }

    else if( worldRank == procIndex ){

      nodeAtomsStart = mpiSim->getMyAtomStart();
      nodeAtomsEnd = mpiSim->getMyAtomEnd();
        
      fprintf( stderr,
               "node %d: myatomStart-> %d; myatomEnd-> %d\n",
               worldRank, nodeAtomsStart, nodeAtomsEnd );

      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);
        
      fprintf( stderr, "node %d: sent off the start and end\n", worldRank );

      sendError = -1;
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD, istatus);

      fprintf( stderr, "node %d: value of sendError is %d\n", worldRank, sendError );

      if (sendError) MPIcheckPoint();

      // send current node's configuration line by line.

      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" );
          
        fprintf( stderr,
                 "node %d: I'm sending the line:\n->%s\n", worldRank, writeLine );
        
        mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,TAKE_THIS_TAG,
                          MPI_COMM_WORLD);
      }
    }
      
    sprintf(checkPointMsg,"Node %d sent dump configuration.",
            procIndex);
    MPIcheckPoint();
  }
    
#endif // is_mpi
}


void DumpWriter::writeFinal(){


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

  int i;
  double q[4];
  DirectionalAtom* dAtom;
  int nAtoms = entry_plug->n_atoms;
  Atom** atoms = entry_plug->atoms;
  
  ofstream finalOut;
  
#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();

#else // is_mpi

  int masterIndex;
  int nodeAtomsStart;
  int nodeAtomsEnd;
  int mpiErr;
  int sendError;
  int procIndex;
    
  MPI_Status istatus[MPI_STATUS_SIZE];

    
  // 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";
    
    masterIndex = 0;
    
    std::cerr << "about to write node 0 aztoms. nAtoms = " << nAtoms << "\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;
      masterIndex++;
    }
    finalOut.flush();
  }
    
  for (procIndex = 1; procIndex < mpiSim->getNumberProcessors();
       procIndex++){

    if( worldRank == 0 ){
        
      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
                        TAKE_THIS_TAG,MPI_COMM_WORLD,istatus);

      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
                        TAKE_THIS_TAG,MPI_COMM_WORLD, istatus);
        
      // Make sure where node 0 is writing to, matches where the
      // receiving node expects it to be.
        
      if (masterIndex != nodeAtomsStart){
        sendError = 1;
        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
                          MPI_COMM_WORLD);
        sprintf(painCave.errMsg,
                "DumpWriter error: atoms start index (%d) for "
                "node %d not equal to master index (%d)",
                nodeAtomsStart,procIndex,masterIndex );
        painCave.isFatal = 1;
        simError();
      }
        
      sendError = 0;
      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);

      // recieve the nodes writeLines

      for ( i = nodeAtomsStart; i <= nodeAtomsEnd; i++){
          
        mpiErr = MPI_Recv(writeLine,BUFFERSIZE,MPI_CHAR,procIndex,
                          TAKE_THIS_TAG,MPI_COMM_WORLD,istatus );

        finalOut << writeLine;
        masterIndex++;
      }

      finalOut.flush();
    }

    else if( worldRank == procIndex ){

      nodeAtomsStart = mpiSim->getMyAtomStart();
      nodeAtomsEnd = mpiSim->getMyAtomEnd();
        
      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD);
        
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,TAKE_THIS_TAG,
                        MPI_COMM_WORLD, istatus);
      if (sendError) MPIcheckPoint();

      // send current node's configuration line by line.

      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" );
          
        mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,TAKE_THIS_TAG,
                          MPI_COMM_WORLD);
      }
    }
      
    sprintf(checkPointMsg,"Node %d sent dump configuration.",
            procIndex);
    MPIcheckPoint();
  }

  if( worldRank == 0 ) finalOut.close();

    
#endif // is_mpi
}
Revision:	260
Committed:	Fri Jan 31 21:04:27 2003 UTC (21 years, 5 months ago) by chuckv
File size:	12508 byte(s)
Log Message:	Fixed some bugs, made some more.
#	User	Rev	Content
1	mmeineke	10	#include <cstring>
2			#include <iostream>
3			#include <fstream>
4	chuckv	215
5			#ifdef IS_MPI
6	mmeineke	214	#include <mpi.h>
7	chuckv	215	#include "mpiSimulation.hpp"
8	chuckv	260	#define TAKE_THIS_TAG 0
9	chuckv	215	#endif //is_mpi
10	mmeineke	10
11			#include "ReadWrite.hpp"
12	mmeineke	162	#include "simError.h"
13	mmeineke	10
14
15	chuckv	215
16
17
18	mmeineke	10	DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
19
20	mmeineke	184	#ifdef IS_MPI
21	mmeineke	189	if(worldRank == 0 ){
22	mmeineke	184	#endif // is_mpi
23
24			entry_plug = the_entry_plug;
25
26			strcpy( outName, entry_plug->sampleName );
27
28			std::cerr << "Opening " << outName << " for dumping.\n";
29
30			outFile.open(outName, ios::out \| ios::trunc );
31
32			if( !outFile ){
33
34			sprintf( painCave.errMsg,
35			"Could not open \"%s\" for dump output.\n",
36			outName);
37			painCave.isFatal = 1;
38			simError();
39			}
40	mmeineke	10
41	mmeineke	184	//outFile.setf( ios::scientific );
42
43			#ifdef IS_MPI
44	mmeineke	10	}
45	chuckv	260
46			sprintf( checkPointMsg,
47			"Sucessfully opened output file for dumping.\n");
48			MPIcheckPoint();
49	mmeineke	184	#endif // is_mpi
50	mmeineke	10	}
51
52			DumpWriter::~DumpWriter( ){
53
54	mmeineke	184	#ifdef IS_MPI
55	mmeineke	189	if(worldRank == 0 ){
56	mmeineke	184	#endif // is_mpi
57
58			outFile.close();
59
60			#ifdef IS_MPI
61			}
62			#endif // is_mpi
63	mmeineke	10	}
64
65			void DumpWriter::writeDump( double currentTime ){
66	mmeineke	214
67			const int BUFFERSIZE = 2000;
68	chuckv	260	char tempBuffer[BUFFERSIZE];
69	mmeineke	214	char writeLine[BUFFERSIZE];
70	mmeineke	10
71	mmeineke	214	int i;
72			double q[4];
73			DirectionalAtom* dAtom;
74			int nAtoms = entry_plug->n_atoms;
75			Atom** atoms = entry_plug->atoms;
76
77	mmeineke	10
78	mmeineke	214	#ifndef IS_MPI
79
80			outFile << nAtoms << "\n";
81
82			outFile << currentTime << "\t"
83			<< entry_plug->box_x << "\t"
84			<< entry_plug->box_y << "\t"
85			<< entry_plug->box_z << "\n";
86
87			for( i=0; i<nAtoms; i++ ){
88
89			sprintf( tempBuffer,
90			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
91			atoms[i]->getType(),
92			atoms[i]->getX(),
93			atoms[i]->getY(),
94			atoms[i]->getZ(),
95			atoms[i]->get_vx(),
96			atoms[i]->get_vy(),
97			atoms[i]->get_vz());
98			strcpy( writeLine, tempBuffer );
99	mmeineke	10
100	mmeineke	214	if( atoms[i]->isDirectional() ){
101
102			dAtom = (DirectionalAtom *)atoms[i];
103			dAtom->getQ( q );
104
105			sprintf( tempBuffer,
106			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
107			q[0],
108			q[1],
109			q[2],
110			q[3],
111			dAtom->getJx(),
112			dAtom->getJy(),
113			dAtom->getJz());
114			strcat( writeLine, tempBuffer );
115			}
116			else
117			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
118
119			outFile << writeLine;
120			}
121			outFile.flush();
122
123			#else // is_mpi
124
125			int masterIndex;
126			int nodeAtomsStart;
127			int nodeAtomsEnd;
128			int mpiErr;
129			int sendError;
130			int procIndex;
131	mmeineke	184
132	mmeineke	214	MPI_Status istatus[MPI_STATUS_SIZE];
133
134	mmeineke	184
135	mmeineke	214	// write out header and node 0's coordinates
136
137			if( worldRank == 0 ){
138	chuckv	254	outFile << mpiSim->getTotAtoms() << "\n";
139	mmeineke	214
140	mmeineke	184	outFile << currentTime << "\t"
141			<< entry_plug->box_x << "\t"
142			<< entry_plug->box_y << "\t"
143			<< entry_plug->box_z << "\n";
144	mmeineke	214
145			masterIndex = 0;
146	mmeineke	184	for( i=0; i<nAtoms; i++ ){
147	mmeineke	10
148	mmeineke	214	sprintf( tempBuffer,
149			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
150			atoms[i]->getType(),
151			atoms[i]->getX(),
152			atoms[i]->getY(),
153			atoms[i]->getZ(),
154			atoms[i]->get_vx(),
155			atoms[i]->get_vy(),
156			atoms[i]->get_vz());
157			strcpy( writeLine, tempBuffer );
158
159	mmeineke	184	if( atoms[i]->isDirectional() ){
160	mmeineke	214
161	mmeineke	184	dAtom = (DirectionalAtom *)atoms[i];
162			dAtom->getQ( q );
163	mmeineke	214
164			sprintf( tempBuffer,
165			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
166			q[0],
167			q[1],
168			q[2],
169			q[3],
170			dAtom->getJx(),
171			dAtom->getJy(),
172			dAtom->getJz());
173			strcat( writeLine, tempBuffer );
174			}
175			else
176			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
177	mmeineke	184
178	chuckv	254	outFile << writeLine;
179	mmeineke	214	masterIndex++;
180			}
181			outFile.flush();
182			}
183	chuckv	260
184			sprintf( checkPointMsg,
185			"Sucessfully wrote node 0's dump configuration.\n");
186			MPIcheckPoint();
187	mmeineke	214
188	chuckv	254	for (procIndex = 1; procIndex < mpiSim->getNumberProcessors();
189	mmeineke	214	procIndex++){
190
191			if( worldRank == 0 ){
192	chuckv	260
193	mmeineke	214	mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
194	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD,istatus);
195
196	mmeineke	214	mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
197	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD, istatus);
198
199	mmeineke	214	// Make sure where node 0 is writing to, matches where the
200			// receiving node expects it to be.
201	chuckv	260
202	mmeineke	214	if (masterIndex != nodeAtomsStart){
203			sendError = 1;
204	chuckv	260	mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
205	mmeineke	214	MPI_COMM_WORLD);
206			sprintf(painCave.errMsg,
207			"DumpWriter error: atoms start index (%d) for "
208			"node %d not equal to master index (%d)",
209			nodeAtomsStart,procIndex,masterIndex );
210			painCave.isFatal = 1;
211			simError();
212	mmeineke	184	}
213	chuckv	260
214	mmeineke	214	sendError = 0;
215	chuckv	260	mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
216	mmeineke	214	MPI_COMM_WORLD);
217	chuckv	260
218	mmeineke	214	// recieve the nodes writeLines
219	chuckv	260
220	chuckv	254	for ( i = nodeAtomsStart; i <= nodeAtomsEnd; i++){
221	chuckv	260
222	chuckv	254	mpiErr = MPI_Recv(writeLine,BUFFERSIZE,MPI_CHAR,procIndex,
223	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD,istatus );
224
225	mmeineke	214	outFile << writeLine;
226			masterIndex++;
227	mmeineke	184	}
228	mmeineke	10	}
229	mmeineke	184
230	mmeineke	214	else if( worldRank == procIndex ){
231
232	chuckv	254	nodeAtomsStart = mpiSim->getMyAtomStart();
233			nodeAtomsEnd = mpiSim->getMyAtomEnd();
234	mmeineke	214
235	chuckv	260	fprintf( stderr,
236			"node %d: myatomStart-> %d; myatomEnd-> %d\n",
237			worldRank, nodeAtomsStart, nodeAtomsEnd );
238
239			mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,TAKE_THIS_TAG,
240	mmeineke	214	MPI_COMM_WORLD);
241	chuckv	260	mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,TAKE_THIS_TAG,
242	mmeineke	214	MPI_COMM_WORLD);
243
244	chuckv	260	fprintf( stderr, "node %d: sent off the start and end\n", worldRank );
245
246			sendError = -1;
247			mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,TAKE_THIS_TAG,
248	mmeineke	214	MPI_COMM_WORLD, istatus);
249	chuckv	260
250			fprintf( stderr, "node %d: value of sendError is %d\n", worldRank, sendError );
251
252	chuckv	254	if (sendError) MPIcheckPoint();
253	mmeineke	214
254			// send current node's configuration line by line.
255
256			for( i=0; i<nAtoms; i++ ){
257
258			sprintf( tempBuffer,
259			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
260			atoms[i]->getType(),
261			atoms[i]->getX(),
262			atoms[i]->getY(),
263			atoms[i]->getZ(),
264			atoms[i]->get_vx(),
265			atoms[i]->get_vy(),
266			atoms[i]->get_vz());
267			strcpy( writeLine, tempBuffer );
268
269			if( atoms[i]->isDirectional() ){
270
271			dAtom = (DirectionalAtom *)atoms[i];
272			dAtom->getQ( q );
273
274			sprintf( tempBuffer,
275			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
276			q[0],
277			q[1],
278			q[2],
279			q[3],
280			dAtom->getJx(),
281			dAtom->getJy(),
282			dAtom->getJz());
283			strcat( writeLine, tempBuffer );
284			}
285			else
286			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
287
288	chuckv	260	fprintf( stderr,
289			"node %d: I'm sending the line:\n->%s\n", worldRank, writeLine );
290
291			mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,TAKE_THIS_TAG,
292	mmeineke	214	MPI_COMM_WORLD);
293			}
294			}
295
296			sprintf(checkPointMsg,"Node %d sent dump configuration.",
297			procIndex);
298	chuckv	254	MPIcheckPoint();
299	mmeineke	10	}
300	mmeineke	214
301	mmeineke	184	#endif // is_mpi
302	mmeineke	10	}
303
304
305	mmeineke	184
306	mmeineke	10	void DumpWriter::writeFinal(){
307
308	mmeineke	214
309			const int BUFFERSIZE = 2000;
310			char tempBuffer[500];
311			char writeLine[BUFFERSIZE];
312
313			char finalName[500];
314
315			int i;
316			double q[4];
317			DirectionalAtom* dAtom;
318			int nAtoms = entry_plug->n_atoms;
319			Atom** atoms = entry_plug->atoms;
320
321			ofstream finalOut;
322
323	mmeineke	184	#ifdef IS_MPI
324	mmeineke	189	if(worldRank == 0 ){
325	mmeineke	184	#endif // is_mpi
326	mmeineke	214
327	mmeineke	184	strcpy( finalName, entry_plug->finalName );
328	mmeineke	214
329			finalOut.open( finalName, ios::out \| ios::trunc );
330	mmeineke	184	if( !finalOut ){
331			sprintf( painCave.errMsg,
332			"Could not open \"%s\" for final dump output.\n",
333			finalName );
334			painCave.isFatal = 1;
335			simError();
336			}
337	mmeineke	10
338	mmeineke	184	// finalOut.setf( ios::scientific );
339
340	mmeineke	214	#ifdef IS_MPI
341			}
342
343	chuckv	254	sprintf(checkPointMsg,"Opened file for final configuration\n");
344			MPIcheckPoint();
345	mmeineke	214
346			#endif //is_mpi
347
348	mmeineke	184
349	mmeineke	214
350			#ifndef IS_MPI
351	mmeineke	184
352	mmeineke	214	finalOut << nAtoms << "\n";
353	mmeineke	184
354	chuckv	249	finalOut << entry_plug->box_x << "\t"
355			<< entry_plug->box_y << "\t"
356			<< entry_plug->box_z << "\n";
357	mmeineke	184
358	mmeineke	214	for( i=0; i<nAtoms; i++ ){
359
360			sprintf( tempBuffer,
361			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
362			atoms[i]->getType(),
363			atoms[i]->getX(),
364			atoms[i]->getY(),
365			atoms[i]->getZ(),
366			atoms[i]->get_vx(),
367			atoms[i]->get_vy(),
368			atoms[i]->get_vz());
369			strcpy( writeLine, tempBuffer );
370
371			if( atoms[i]->isDirectional() ){
372
373			dAtom = (DirectionalAtom *)atoms[i];
374			dAtom->getQ( q );
375
376			sprintf( tempBuffer,
377			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
378			q[0],
379			q[1],
380			q[2],
381			q[3],
382			dAtom->getJx(),
383			dAtom->getJy(),
384			dAtom->getJz());
385			strcat( writeLine, tempBuffer );
386			}
387			else
388			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
389
390			finalOut << writeLine;
391			}
392			finalOut.flush();
393
394			#else // is_mpi
395
396			int masterIndex;
397			int nodeAtomsStart;
398			int nodeAtomsEnd;
399			int mpiErr;
400			int sendError;
401			int procIndex;
402	mmeineke	184
403	mmeineke	214	MPI_Status istatus[MPI_STATUS_SIZE];
404
405
406			// write out header and node 0's coordinates
407
408			if( worldRank == 0 ){
409	chuckv	254	finalOut << mpiSim->getTotAtoms() << "\n";
410	mmeineke	214
411	chuckv	249	finalOut << entry_plug->box_x << "\t"
412			<< entry_plug->box_y << "\t"
413			<< entry_plug->box_z << "\n";
414
415	mmeineke	214	masterIndex = 0;
416	chuckv	256
417			std::cerr << "about to write node 0 aztoms. nAtoms = " << nAtoms << "\n";
418
419	mmeineke	184	for( i=0; i<nAtoms; i++ ){
420	mmeineke	10
421	mmeineke	214	sprintf( tempBuffer,
422			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
423			atoms[i]->getType(),
424			atoms[i]->getX(),
425			atoms[i]->getY(),
426			atoms[i]->getZ(),
427			atoms[i]->get_vx(),
428			atoms[i]->get_vy(),
429			atoms[i]->get_vz());
430			strcpy( writeLine, tempBuffer );
431
432	mmeineke	184	if( atoms[i]->isDirectional() ){
433	mmeineke	214
434	mmeineke	184	dAtom = (DirectionalAtom *)atoms[i];
435			dAtom->getQ( q );
436	mmeineke	214
437			sprintf( tempBuffer,
438			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
439			q[0],
440			q[1],
441			q[2],
442			q[3],
443			dAtom->getJx(),
444			dAtom->getJy(),
445			dAtom->getJz());
446			strcat( writeLine, tempBuffer );
447			}
448			else
449			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
450	mmeineke	184
451	chuckv	256	finalOut << writeLine;
452	mmeineke	214	masterIndex++;
453			}
454			finalOut.flush();
455			}
456
457	chuckv	254	for (procIndex = 1; procIndex < mpiSim->getNumberProcessors();
458	mmeineke	214	procIndex++){
459
460			if( worldRank == 0 ){
461
462			mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
463	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD,istatus);
464	mmeineke	214
465			mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
466	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD, istatus);
467	mmeineke	214
468			// Make sure where node 0 is writing to, matches where the
469			// receiving node expects it to be.
470
471			if (masterIndex != nodeAtomsStart){
472			sendError = 1;
473	chuckv	260	mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
474	mmeineke	214	MPI_COMM_WORLD);
475			sprintf(painCave.errMsg,
476			"DumpWriter error: atoms start index (%d) for "
477			"node %d not equal to master index (%d)",
478			nodeAtomsStart,procIndex,masterIndex );
479			painCave.isFatal = 1;
480			simError();
481	mmeineke	184	}
482	mmeineke	214
483			sendError = 0;
484	chuckv	260	mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,TAKE_THIS_TAG,
485	mmeineke	214	MPI_COMM_WORLD);
486
487			// recieve the nodes writeLines
488
489	chuckv	254	for ( i = nodeAtomsStart; i <= nodeAtomsEnd; i++){
490	mmeineke	214
491	chuckv	254	mpiErr = MPI_Recv(writeLine,BUFFERSIZE,MPI_CHAR,procIndex,
492	chuckv	260	TAKE_THIS_TAG,MPI_COMM_WORLD,istatus );
493	mmeineke	214
494			finalOut << writeLine;
495			masterIndex++;
496	mmeineke	184	}
497	mmeineke	214
498			finalOut.flush();
499	mmeineke	10	}
500	mmeineke	214
501			else if( worldRank == procIndex ){
502
503	chuckv	254	nodeAtomsStart = mpiSim->getMyAtomStart();
504			nodeAtomsEnd = mpiSim->getMyAtomEnd();
505	mmeineke	214
506	chuckv	260	mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,TAKE_THIS_TAG,
507	mmeineke	214	MPI_COMM_WORLD);
508	chuckv	260	mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,TAKE_THIS_TAG,
509	mmeineke	214	MPI_COMM_WORLD);
510
511	chuckv	260	mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,TAKE_THIS_TAG,
512	mmeineke	214	MPI_COMM_WORLD, istatus);
513	chuckv	254	if (sendError) MPIcheckPoint();
514	mmeineke	214
515			// send current node's configuration line by line.
516
517			for( i=0; i<nAtoms; i++ ){
518
519			sprintf( tempBuffer,
520			"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
521			atoms[i]->getType(),
522			atoms[i]->getX(),
523			atoms[i]->getY(),
524			atoms[i]->getZ(),
525			atoms[i]->get_vx(),
526			atoms[i]->get_vy(),
527			atoms[i]->get_vz());
528			strcpy( writeLine, tempBuffer );
529
530			if( atoms[i]->isDirectional() ){
531
532			dAtom = (DirectionalAtom *)atoms[i];
533			dAtom->getQ( q );
534
535			sprintf( tempBuffer,
536			"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
537			q[0],
538			q[1],
539			q[2],
540			q[3],
541			dAtom->getJx(),
542			dAtom->getJy(),
543			dAtom->getJz());
544			strcat( writeLine, tempBuffer );
545			}
546			else
547			strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
548
549	chuckv	260	mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,TAKE_THIS_TAG,
550	mmeineke	214	MPI_COMM_WORLD);
551			}
552			}
553
554			sprintf(checkPointMsg,"Node %d sent dump configuration.",
555			procIndex);
556	chuckv	254	MPIcheckPoint();
557	mmeineke	214	}
558
559			if( worldRank == 0 ) finalOut.close();
560
561	mmeineke	184
562			#endif // is_mpi
563	mmeineke	10	}