mdtools/md_code/DumpWriter.cpp

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

#ifdef IS_MPI
#include <mpi.h>
#include "mpiSimulation.hpp"
#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
  }
#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[500];
  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 << entry_plug->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();
  }
    
  for (procIndex = 1; procIndex < entry_plug->mpiSim->getNumberProcessors();
       procIndex++){

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

      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
                        MPI_ANY_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,MPI_ANY_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,MPI_ANY_TAG,
                        MPI_COMM_WORLD);

      // recieve the nodes writeLines

      for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
          
        mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,
                          MPI_ANY_TAG,MPI_COMM_WORLD,istatus );

        outFile << writeLine;
        masterIndex++;
      }
    }

    else if( worldRank == procIndex ){

      nodeAtomStart = entry_plug->mpiSim->getMyAtomStart();
      nodeAtomEnd = entry_plug->mpiSim->getMyAtomEnd();
        
      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,
                        MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,
                        MPI_COMM_WORLD);
        
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_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,MPI_ANY_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",procIndex);
  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 << entry_plug->mpiSim->getTotAtoms() << "\n";
      
    finalOut << 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++;
    }
    finalOut.flush();
  }
    
  for (procIndex = 1; procIndex < entry_plug->mpiSim->getNumberProcessors();
       procIndex++){

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

      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
                        MPI_ANY_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,MPI_ANY_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,MPI_ANY_TAG,
                        MPI_COMM_WORLD);

      // recieve the nodes writeLines

      for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
          
        mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,
                          MPI_ANY_TAG,MPI_COMM_WORLD,istatus );

        finalOut << writeLine;
        masterIndex++;
      }

      finalOut.flush();
    }

    else if( worldRank == procIndex ){

      nodeAtomStart = entry_plug->mpiSim->getMyAtomStart();
      nodeAtomEnd = entry_plug->mpiSim->getMyAtomEnd();
        
      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,
                        MPI_COMM_WORLD);
      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,
                        MPI_COMM_WORLD);
        
      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_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,MPI_ANY_TAG,
                          MPI_COMM_WORLD);
      }
    }
      
    sprintf(checkPointMsg,"Node %d sent dump configuration.",
            procIndex);
    mpiCheckPoint();
  }

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

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