mdtools/md_code/DumpWriter.cpp

#include <cstring>
#include <iostream>
#include <fstream>
#include <mpi.h>

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