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 ){

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

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