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 436 by chuckv, Fri Mar 28 21:45:03 2003 UTC vs.
Revision 787 by mmeineke, Thu Sep 25 19:27:15 2003 UTC

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

Diff Legend

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