ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DumpWriter.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 415 by gezelter, Wed Mar 26 22:24:49 2003 UTC vs.
Revision 829 by gezelter, Tue Oct 28 16:03:37 2003 UTC

# Line 1 | Line 1
1 < #include <cstring>
1 > #define _FILE_OFFSET_BITS 64
2 >
3 > #include <string.h>
4   #include <iostream>
5   #include <fstream>
6  
7   #ifdef IS_MPI
8   #include <mpi.h>
9   #include "mpiSimulation.hpp"
10 < #define TAKE_THIS_TAG 0
10 > #define TAKE_THIS_TAG_CHAR 1
11 > #define TAKE_THIS_TAG_INT 2
12 >
13 > namespace dWrite{
14 >  void nodeZeroError( void );
15 >  void anonymousNodeDie( void );
16 > }
17 >
18 > using namespace dWrite;
19   #endif //is_mpi
20  
21   #include "ReadWrite.hpp"
22   #include "simError.h"
23  
14 – #define GAME_OVER -1
15 –
24   DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
25  
26    entry_plug = the_entry_plug;
# Line 21 | Line 29 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
29    if(worldRank == 0 ){
30   #endif // is_mpi
31      
24 –
25 –    
32      strcpy( outName, entry_plug->sampleName );
33      
34      outFile.open(outName, ios::out | ios::trunc );
# Line 35 | Line 41 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
41        painCave.isFatal = 1;
42        simError();
43      }
44 <  
44 >
45      //outFile.setf( ios::scientific );
46  
47   #ifdef IS_MPI
# Line 67 | Line 73 | void DumpWriter::writeDump( double currentTime ){
73    char writeLine[BUFFERSIZE];
74  
75    int i;
76 + #ifdef IS_MPI
77 +  int j, which_node, done, which_atom, local_index;
78 + #else //is_mpi
79 +  int nAtoms = entry_plug->n_atoms;
80 + #endif //is_mpi
81 +
82    double q[4];
83    DirectionalAtom* dAtom;
72 –  int nAtoms = entry_plug->n_atoms;
84    Atom** atoms = entry_plug->atoms;
85 +  double pos[3], vel[3];
86      
87 +  
88 +  // write current frame to the eor file
89  
90 +  this->writeFinal( currentTime );
91 +
92   #ifndef IS_MPI
93      
94    outFile << nAtoms << "\n";
95      
96 <  outFile << currentTime << "\t"
97 <          << entry_plug->box_x << "\t"
98 <          << entry_plug->box_y << "\t"
99 <          << entry_plug->box_z << "\n";
96 >  outFile << currentTime << ";\t"
97 >          << entry_plug->Hmat[0][0] << "\t"
98 >          << entry_plug->Hmat[1][0] << "\t"
99 >          << entry_plug->Hmat[2][0] << ";\t"
100 >
101 >          << entry_plug->Hmat[0][1] << "\t"
102 >          << entry_plug->Hmat[1][1] << "\t"
103 >          << entry_plug->Hmat[2][1] << ";\t"
104 >
105 >          << entry_plug->Hmat[0][2] << "\t"
106 >          << entry_plug->Hmat[1][2] << "\t"
107 >          << entry_plug->Hmat[2][2] << ";\n";
108      
109    for( i=0; i<nAtoms; i++ ){
110        
111 +    atoms[i]->getPos(pos);
112 +    atoms[i]->getVel(vel);
113  
114      sprintf( tempBuffer,
115               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
116               atoms[i]->getType(),
117 <             atoms[i]->getX(),
118 <             atoms[i]->getY(),
119 <             atoms[i]->getZ(),
120 <             atoms[i]->get_vx(),
121 <             atoms[i]->get_vy(),
122 <             atoms[i]->get_vz());
117 >             pos[0],
118 >             pos[1],
119 >             pos[2],
120 >             vel[0],
121 >             vel[1],
122 >             vel[2]);
123      strcpy( writeLine, tempBuffer );
124  
125      if( atoms[i]->isDirectional() ){
# Line 120 | Line 146 | void DumpWriter::writeDump( double currentTime ){
146    outFile.flush();
147  
148   #else // is_mpi
149 +
150 +  // first thing first, suspend fatalities.
151 +  painCave.isEventLoop = 1;
152 +
153 +  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
154 +  int haveError;
155 +
156 +  MPI_Status istatus;
157 +  int *AtomToProcMap = mpiSim->getAtomToProcMap();
158    
124 –  MPI_Status istatus[MPI_STATUS_SIZE];
125 –  
159    // write out header and node 0's coordinates
160    
161    if( worldRank == 0 ){
162      outFile << mpiSim->getTotAtoms() << "\n";
163 +  
164 +    outFile << currentTime << ";\t"
165 +            << entry_plug->Hmat[0][0] << "\t"
166 +            << entry_plug->Hmat[1][0] << "\t"
167 +            << entry_plug->Hmat[2][0] << ";\t"
168 +      
169 +            << entry_plug->Hmat[0][1] << "\t"
170 +            << entry_plug->Hmat[1][1] << "\t"
171 +            << entry_plug->Hmat[2][1] << ";\t"
172 +      
173 +            << entry_plug->Hmat[0][2] << "\t"
174 +            << entry_plug->Hmat[1][2] << "\t"
175 +            << entry_plug->Hmat[2][2] << ";\n";
176      
177 <    outFile << currentTime << "\t"
178 <            << entry_plug->box_x << "\t"
179 <            << entry_plug->box_y << "\t"
134 <            << entry_plug->box_z << "\n";
135 <    
136 <    for (i = 0 ; i < mpiPlug->nAtomsGlobal; i++ ) {
137 <      // Get the Node number which has this molecule:
177 >    outFile.flush();
178 >    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
179 >      // Get the Node number which has this atom;
180        
181        which_node = AtomToProcMap[i];    
182        
183 <      if (which_node == mpiPlug->myNode) {
142 <        
143 <        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 );
183 >      if (which_node == 0 ) {
184          
185 <        if( atoms[i]->isDirectional() ){
185 >        haveError = 0;
186 >        which_atom = i;
187 >        local_index=-1;        
188 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
189 >          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
190 >        }
191 >        if (local_index != -1) {
192 >          //format the line
193            
194 <          dAtom = (DirectionalAtom *)atoms[i];
195 <          dAtom->getQ( q );
196 <          
194 >          atoms[local_index]->getPos(pos);
195 >          atoms[local_index]->getVel(vel);
196 >
197            sprintf( tempBuffer,
198 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
199 <                   q[0],
200 <                   q[1],
201 <                   q[2],
202 <                   q[3],
203 <                   dAtom->getJx(),
204 <                   dAtom->getJy(),
205 <                   dAtom->getJz());
206 <          strcat( writeLine, tempBuffer );
207 <        }
208 <        else
209 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
210 <        
211 <      } else {
212 <        
213 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
214 <        MPI::COMM_WORLD.Receive(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
215 <                                TAKE_THIS_TAG, istatus);
198 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
199 >                   atoms[local_index]->getType(),
200 >                   pos[0],
201 >                   pos[1],
202 >                   pos[2],
203 >                   vel[0],
204 >                   vel[1],
205 >                   vel[2]); // check here.
206 >          strcpy( writeLine, tempBuffer );
207 >          
208 >          if( atoms[local_index]->isDirectional() ){
209 >            
210 >            dAtom = (DirectionalAtom *)atoms[local_index];
211 >            dAtom->getQ( q );
212 >            
213 >            sprintf( tempBuffer,
214 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
215 >                     q[0],
216 >                     q[1],
217 >                     q[2],
218 >                     q[3],
219 >                     dAtom->getJx(),
220 >                     dAtom->getJy(),
221 >                     dAtom->getJz());
222 >            strcat( writeLine, tempBuffer );
223 >            
224 >          }
225 >          else
226 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
227 >        }
228 >        else {
229 >          sprintf(painCave.errMsg,
230 >                  "Atom %d not found on processor %d\n",
231 >                  i, worldRank );
232 >          haveError= 1;
233 >          simError();
234 >        }
235 >        
236 >        if(haveError) nodeZeroError();
237 >
238        }
239 +      else {
240 +        myStatus = 1;
241 +        MPI_Send(&myStatus, 1, MPI_INT, which_node,
242 +                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
243 +        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
244 +                 MPI_COMM_WORLD);
245 +        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
246 +                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
247 +        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
248 +                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
249 +        
250 +        if(!myStatus) nodeZeroError();
251 +
252 +      }
253        
254        outFile << writeLine;
255 +      outFile.flush();
256      }
257      
258      // kill everyone off:
259 <    for (j = 0; j < mpiPlug->numberProcessors; j++) {
260 <      MPI::COMM_WORLD.Send(GAME_OVER, 1, MPI_INT, j, TAKE_THIS_TAG);
259 >    myStatus = -1;
260 >    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
261 >      MPI_Send(&myStatus, 1, MPI_INT, j,
262 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
263      }
264  
265    } else {
266      
267      done = 0;
268      while (!done) {
269 <      MPI::COMM_WORLD.Receive(&which_atom, 1, MPI_INT, 0,
270 <                              TAKE_THIS_TAG, istatus);
269 >      
270 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
271 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
272  
273 <      if (which_atom == GAME_OVER) {
274 <        done=1;
275 <        continue;
198 <      } else {
273 >      if(!myStatus) anonymousNodeDie();
274 >      
275 >      if(myStatus < 0) break;
276  
277 <        //format the line
277 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
278 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
279 >      
280 >      myStatus = 1;
281 >      local_index=-1;        
282 >      for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
283 >        if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
284 >      }
285 >      if (local_index != -1) {
286 >        //format the line
287 >
288 >        atoms[local_index]->getPos(pos);
289 >        atoms[local_index]->getVel(vel);
290 >
291          sprintf( tempBuffer,
292                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
293 <                 atoms[which_atom]->getType(),
294 <                 atoms[which_atom]->getX(),
295 <                 atoms[which_atom]->getY(),
296 <                 atoms[which_atom]->getZ(),
297 <                 atoms[which_atom]->get_vx(),
298 <                 atoms[which_atom]->get_vy(),
299 <                 atoms[which_atom]->get_vz()); // check here.
293 >                 atoms[local_index]->getType(),
294 >                 pos[0],
295 >                 pos[1],
296 >                 pos[2],
297 >                 vel[0],
298 >                 vel[1],
299 >                 vel[2]); // check here.
300          strcpy( writeLine, tempBuffer );
301 +        
302 +        if( atoms[local_index]->isDirectional() ){
303            
304 <        if( atoms[which_atom]->isDirectional() ){
213 <            
214 <          dAtom = (DirectionalAtom *)atoms[which_atom];
304 >          dAtom = (DirectionalAtom *)atoms[local_index];
305            dAtom->getQ( q );
306 <            
306 >          
307            sprintf( tempBuffer,
308                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
309                     q[0],
# Line 225 | Line 315 | void DumpWriter::writeDump( double currentTime ){
315                     dAtom->getJz());
316            strcat( writeLine, tempBuffer );
317          }
318 <        else
318 >        else{
319            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
320 <        
321 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
322 <                             TAKE_THIS_TAG);
320 >        }
321 >      }
322 >      else {
323 >        sprintf(painCave.errMsg,
324 >                "Atom %d not found on processor %d\n",
325 >                which_atom, worldRank );
326 >        myStatus = 0;
327 >        simError();
328 >
329 >        strcpy( writeLine, "Hello, I'm an error.\n");
330        }
331 +
332 +      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
333 +               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
334 +      MPI_Send( &myStatus, 1, MPI_INT, 0,
335 +                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
336      }
337    }  
338    outFile.flush();
339    sprintf( checkPointMsg,
340             "Sucessfully took a dump.\n");
341    MPIcheckPoint();
342 +
343 + // last  thing last, enable  fatalities.
344 +  painCave.isEventLoop = 0;
345 +
346   #endif // is_mpi
347   }
348  
349 < void DumpWriter::writeFinal(){
350 <  
349 > void DumpWriter::writeFinal(double finalTime){
350 >
351    char finalName[500];
352    ofstream finalOut;
353 +
354 +  const int BUFFERSIZE = 2000;
355 +  char tempBuffer[BUFFERSIZE];
356 +  char writeLine[BUFFERSIZE];  
357 +
358 +  double q[4];
359 +  DirectionalAtom* dAtom;
360 +  Atom** atoms = entry_plug->atoms;
361 +  int i;
362 + #ifdef IS_MPI
363 +  int j, which_node, done, which_atom, local_index;
364 + #else //is_mpi
365 +  int nAtoms = entry_plug->n_atoms;
366 + #endif //is_mpi
367    
368 +  double pos[3], vel[3];
369 +  
370   #ifdef IS_MPI
371    if(worldRank == 0 ){
372   #endif // is_mpi
# Line 275 | Line 397 | void DumpWriter::writeFinal(){
397      
398    finalOut << nAtoms << "\n";
399      
400 <  finalOut << entry_plug->box_x << "\t"
401 <           << entry_plug->box_y << "\t"
402 <           << entry_plug->box_z << "\n";
400 >  finalOut << finalTime << ";\t"
401 >           << entry_plug->Hmat[0][0] << "\t"
402 >           << entry_plug->Hmat[1][0] << "\t"
403 >           << entry_plug->Hmat[2][0] << ";\t"
404      
405 +           << entry_plug->Hmat[0][1] << "\t"
406 +           << entry_plug->Hmat[1][1] << "\t"
407 +           << entry_plug->Hmat[2][1] << ";\t"
408 +    
409 +           << entry_plug->Hmat[0][2] << "\t"
410 +           << entry_plug->Hmat[1][2] << "\t"
411 +           << entry_plug->Hmat[2][2] << ";\n";
412 +  
413    for( i=0; i<nAtoms; i++ ){
414        
415 +    atoms[i]->getPos(pos);
416 +    atoms[i]->getVel(vel);
417 +    
418      sprintf( tempBuffer,
419               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
420               atoms[i]->getType(),
421 <             atoms[i]->getX(),
422 <             atoms[i]->getY(),
423 <             atoms[i]->getZ(),
424 <             atoms[i]->get_vx(),
425 <             atoms[i]->get_vy(),
426 <             atoms[i]->get_vz());
421 >             pos[0],
422 >             pos[1],
423 >             pos[2],
424 >             vel[0],
425 >             vel[1],
426 >             vel[2]);
427      strcpy( writeLine, tempBuffer );
428  
429      if( atoms[i]->isDirectional() ){
# Line 318 | Line 452 | void DumpWriter::writeFinal(){
452  
453   #else // is_mpi
454    
455 <  MPI_Status istatus[MPI_STATUS_SIZE];
456 <  
455 >  // first thing first, suspend fatalities.
456 >  painCave.isEventLoop = 1;
457 >
458 >  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
459 >  int haveError;
460 >
461 >  MPI_Status istatus;
462 >  int *AtomToProcMap = mpiSim->getAtomToProcMap();
463 >
464    // write out header and node 0's coordinates
465    
466 +  haveError = 0;
467    if( worldRank == 0 ){
468      finalOut << mpiSim->getTotAtoms() << "\n";
469      
470 <    finalOut << entry_plug->box_x << "\t"
471 <            << entry_plug->box_y << "\t"
472 <            << entry_plug->box_z << "\n";
470 >    finalOut << finalTime << ";\t"
471 >             << entry_plug->Hmat[0][0] << "\t"
472 >             << entry_plug->Hmat[1][0] << "\t"
473 >             << entry_plug->Hmat[2][0] << ";\t"
474 >      
475 >             << entry_plug->Hmat[0][1] << "\t"
476 >             << entry_plug->Hmat[1][1] << "\t"
477 >             << entry_plug->Hmat[2][1] << ";\t"
478 >      
479 >             << entry_plug->Hmat[0][2] << "\t"
480 >             << entry_plug->Hmat[1][2] << "\t"
481 >             << entry_plug->Hmat[2][2] << ";\n";
482      
483 <    for (i = 0 ; i < mpiPlug->nAtomsGlobal; i++ ) {
483 >    for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
484        // Get the Node number which has this molecule:
485        
486        which_node = AtomToProcMap[i];    
487        
488 <      if (which_node == mpiPlug->myNode) {
489 <        
490 <        sprintf( tempBuffer,
491 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
492 <                 atoms[i]->getType(),
493 <                 atoms[i]->getX(),
494 <                 atoms[i]->getY(),
495 <                 atoms[i]->getZ(),
496 <                 atoms[i]->get_vx(),
497 <                 atoms[i]->get_vy(),
498 <                 atoms[i]->get_vz());
348 <        strcpy( writeLine, tempBuffer );
349 <        
350 <        if( atoms[i]->isDirectional() ){
488 >      if (which_node == mpiSim->getMyNode()) {
489 >
490 >        which_atom = i;
491 >        local_index=-1;        
492 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
493 >          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
494 >        }
495 >        if (local_index != -1) {    
496 >
497 >          atoms[local_index]->getPos(pos);
498 >          atoms[local_index]->getVel(vel);
499            
500 <          dAtom = (DirectionalAtom *)atoms[i];
501 <          dAtom->getQ( q );
500 >          sprintf( tempBuffer,
501 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
502 >                   atoms[local_index]->getType(),
503 >                   pos[0],
504 >                   pos[1],
505 >                   pos[2],
506 >                   vel[0],
507 >                   vel[1],
508 >                   vel[2]);
509 >          strcpy( writeLine, tempBuffer );
510            
511 <          sprintf( tempBuffer,
512 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
513 <                   q[0],
514 <                   q[1],
515 <                   q[2],
516 <                   q[3],
517 <                   dAtom->getJx(),
518 <                   dAtom->getJy(),
519 <                   dAtom->getJz());
520 <          strcat( writeLine, tempBuffer );
521 <        }
522 <        else
523 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
511 >          if( atoms[local_index]->isDirectional() ){
512 >            
513 >            dAtom = (DirectionalAtom *)atoms[local_index];
514 >            dAtom->getQ( q );
515 >            
516 >            sprintf( tempBuffer,
517 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
518 >                     q[0],
519 >                     q[1],
520 >                     q[2],
521 >                     q[3],
522 >                     dAtom->getJx(),
523 >                     dAtom->getJy(),
524 >                     dAtom->getJz());
525 >            strcat( writeLine, tempBuffer );
526 >          }
527 >          else
528 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
529 >        }
530 >        else {
531 >          sprintf(painCave.errMsg,
532 >                  "Atom %d not found on processor %d\n",
533 >                  i, worldRank );
534 >          haveError= 1;
535 >          simError();
536 >        }
537 >
538 >        if(haveError) nodeZeroError();
539 >    
540 >      }
541 >      else {
542          
543 <      } else {
544 <        
545 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
546 <        MPI::COMM_WORLD.Receive(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
547 <                                TAKE_THIS_TAG, istatus);
543 >        myStatus = 1;
544 >        MPI_Send(&myStatus, 1, MPI_INT, which_node,
545 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
546 >        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
547 >                 MPI_COMM_WORLD);
548 >        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
549 >                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
550 >        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
551 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
552 >        
553 >        if(!myStatus) nodeZeroError();
554        }
555        
556        finalOut << writeLine;
557      }
558      
559      // kill everyone off:
560 <    for (j = 0; j < mpiPlug->numberProcessors; j++) {
561 <      MPI::COMM_WORLD.Send(GAME_OVER, 1, MPI_INT, j, TAKE_THIS_TAG);
560 >    myStatus = -1;
561 >    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
562 >      MPI_Send(&myStatus, 1, MPI_INT, j,
563 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
564      }
565  
566    } else {
567      
568      done = 0;
569      while (!done) {
388 –      MPI::COMM_WORLD.Receive(&which_atom, 1, MPI_INT, 0,
389 –                              TAKE_THIS_TAG, istatus);
570  
571 <      if (which_atom == GAME_OVER) {
572 <        done=1;
573 <        continue;
574 <      } else {
571 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
572 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
573 >      
574 >      if(!myStatus) anonymousNodeDie();
575 >      
576 >      if(myStatus < 0) break;
577 >      
578 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
579 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
580 >      
581 >      myStatus = 1;
582 >      local_index=-1;        
583 >      for (j=0; j < mpiSim->getMyNlocal(); j++) {
584 >        if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
585 >      }
586 >      if (local_index != -1) {
587  
588 <        //format the line
588 >        atoms[local_index]->getPos(pos);
589 >        atoms[local_index]->getVel(vel);
590 >
591 >        //format the line
592          sprintf( tempBuffer,
593                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
594 <                 atoms[which_atom]->getType(),
595 <                 atoms[which_atom]->getX(),
596 <                 atoms[which_atom]->getY(),
597 <                 atoms[which_atom]->getZ(),
598 <                 atoms[which_atom]->get_vx(),
599 <                 atoms[which_atom]->get_vy(),
600 <                 atoms[which_atom]->get_vz()); // check here.
594 >                 atoms[local_index]->getType(),
595 >                 pos[0],
596 >                 pos[1],
597 >                 pos[2],
598 >                 vel[0],
599 >                 vel[1],
600 >                 vel[2]); // check here.
601          strcpy( writeLine, tempBuffer );
602 +        
603 +        if( atoms[local_index]->isDirectional() ){
604            
605 <        if( atoms[which_atom]->isDirectional() ){
409 <            
410 <          dAtom = (DirectionalAtom *)atoms[which_atom];
605 >          dAtom = (DirectionalAtom *)atoms[local_index];
606            dAtom->getQ( q );
607 <            
607 >          
608            sprintf( tempBuffer,
609                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
610                     q[0],
# Line 421 | Line 616 | void DumpWriter::writeFinal(){
616                     dAtom->getJz());
617            strcat( writeLine, tempBuffer );
618          }
619 <        else
619 >        else{
620            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
621 <        
622 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
623 <                             TAKE_THIS_TAG);
621 >        }
622 >      }
623 >      else {
624 >        sprintf(painCave.errMsg,
625 >                "Atom %d not found on processor %d\n",
626 >                which_atom, worldRank );
627 >        myStatus = 0;
628 >        simError();
629 >        
630 >        strcpy( writeLine, "Hello, I'm an error.\n");
631        }
632 +
633 +      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
634 +               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
635 +      MPI_Send( &myStatus, 1, MPI_INT, 0,
636 +                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
637      }
638 <  }  
638 >  }
639    finalOut.flush();
640    sprintf( checkPointMsg,
641             "Sucessfully took a dump.\n");
642    MPIcheckPoint();
643 <
643 >  
644    if( worldRank == 0 ) finalOut.close();    
645   #endif // is_mpi
646   }
647 +
648 +
649 +
650 + #ifdef IS_MPI
651 +
652 + // a couple of functions to let us escape the write loop
653 +
654 + void dWrite::nodeZeroError( void ){
655 +  int j, myStatus;
656 +  
657 +  myStatus = 0;
658 +  for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
659 +    MPI_Send( &myStatus, 1, MPI_INT, j,
660 +              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
661 +  }  
662 +  
663 +
664 +  MPI_Finalize();
665 +  exit (0);
666 +  
667 + }
668 +
669 + void dWrite::anonymousNodeDie( void ){
670 +
671 +  MPI_Finalize();
672 +  exit (0);
673 + }
674 +
675 + #endif //is_mpi

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines