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 670 by mmeineke, Thu Aug 7 21:47:18 2003 UTC

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

Diff Legend

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