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 417 by gezelter, Thu Mar 27 01:49:45 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 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"
# Line 20 | Line 29 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
29    if(worldRank == 0 ){
30   #endif // is_mpi
31      
23 –
24 –    
32      strcpy( outName, entry_plug->sampleName );
33      
34      outFile.open(outName, ios::out | ios::trunc );
# Line 34 | 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 65 | 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;
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;
71 –  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 120 | 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      
173 <    outFile << currentTime << "\t"
132 <            << entry_plug->box_x << "\t"
133 <            << entry_plug->box_y << "\t"
134 <            << entry_plug->box_z << "\n";
135 <    
173 >    outFile.flush();
174      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
175        // Get the Node number which has this atom;
176        
177        which_node = AtomToProcMap[i];    
178        
179 <      if (which_node == mpiSim->getMyNode()) {
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 );
179 >      if (which_node == 0 ) {
180          
181 <        if( atoms[i]->isDirectional() ){
181 >        haveError = 0;
182 >        which_atom = i;
183 >        local_index=-1;        
184 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
185 >          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
186 >        }
187 >        if (local_index != -1) {
188 >          //format the line
189            
190 <          dAtom = (DirectionalAtom *)atoms[i];
191 <          dAtom->getQ( q );
192 <          
190 >          atoms[local_index]->getPos(pos);
191 >          atoms[local_index]->getVel(vel);
192 >
193            sprintf( tempBuffer,
194 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
195 <                   q[0],
196 <                   q[1],
197 <                   q[2],
198 <                   q[3],
199 <                   dAtom->getJx(),
200 <                   dAtom->getJy(),
201 <                   dAtom->getJz());
202 <          strcat( writeLine, tempBuffer );
203 <        }
204 <        else
205 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
206 <        
207 <      } else {
208 <        
209 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
210 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
211 <                                TAKE_THIS_TAG, istatus);
194 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
195 >                   atoms[local_index]->getType(),
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() ){
205 >            
206 >            dAtom = (DirectionalAtom *)atoms[local_index];
207 >            dAtom->getQ( q );
208 >            
209 >            sprintf( tempBuffer,
210 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
211 >                     q[0],
212 >                     q[1],
213 >                     q[2],
214 >                     q[3],
215 >                     dAtom->getJx(),
216 >                     dAtom->getJy(),
217 >                     dAtom->getJz());
218 >            strcat( writeLine, tempBuffer );
219 >            
220 >          }
221 >          else
222 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
223 >        }
224 >        else {
225 >          sprintf(painCave.errMsg,
226 >                  "Atom %d not found on processor %d\n",
227 >                  i, worldRank );
228 >          haveError= 1;
229 >          simError();
230 >        }
231 >        
232 >        if(haveError) nodeZeroError();
233 >
234        }
235 +      else {
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;
251 +      outFile.flush();
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);
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 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
266 <                              TAKE_THIS_TAG, istatus);
265 >      
266 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
267 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
268  
269 <      if (which_atom == -1) {
270 <        done=1;
271 <        continue;
199 <      } else {
269 >      if(!myStatus) anonymousNodeDie();
270 >      
271 >      if(myStatus < 0) break;
272  
273 <        //format the line
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[which_atom]->getType(),
290 <                 atoms[which_atom]->getX(),
291 <                 atoms[which_atom]->getY(),
292 <                 atoms[which_atom]->getZ(),
293 <                 atoms[which_atom]->get_vx(),
294 <                 atoms[which_atom]->get_vy(),
295 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
214 <            
215 <          dAtom = (DirectionalAtom *)atoms[which_atom];
300 >          dAtom = (DirectionalAtom *)atoms[local_index];
301            dAtom->getQ( q );
302 <            
302 >          
303            sprintf( tempBuffer,
304                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
305                     q[0],
# Line 226 | Line 311 | void DumpWriter::writeDump( double currentTime ){
311                     dAtom->getJz());
312            strcat( writeLine, tempBuffer );
313          }
314 <        else
314 >        else{
315            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
316 <        
317 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
318 <                             TAKE_THIS_TAG);
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 252 | Line 353 | void DumpWriter::writeFinal(){
353  
354    double q[4];
355    DirectionalAtom* dAtom;
255 –  int nAtoms = entry_plug->n_atoms;
356    Atom** atoms = entry_plug->atoms;
357 <  int i, j, which_node, done, game_over, which_atom;
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 287 | 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 330 | 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 348 | 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());
361 <        strcpy( writeLine, tempBuffer );
362 <        
363 <        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);
542 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
543 <                                TAKE_THIS_TAG, 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);
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) {
402 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
403 –                           TAKE_THIS_TAG, 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 <        //format the line
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[which_atom]->getType(),
591 <                 atoms[which_atom]->getX(),
592 <                 atoms[which_atom]->getY(),
593 <                 atoms[which_atom]->getZ(),
594 <                 atoms[which_atom]->get_vx(),
595 <                 atoms[which_atom]->get_vy(),
596 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
423 <            
424 <          dAtom = (DirectionalAtom *)atoms[which_atom];
601 >          dAtom = (DirectionalAtom *)atoms[local_index];
602            dAtom->getQ( q );
603 <            
603 >          
604            sprintf( tempBuffer,
605                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
606                     q[0],
# Line 435 | Line 612 | void DumpWriter::writeFinal(){
612                     dAtom->getJz());
613            strcat( writeLine, tempBuffer );
614          }
615 <        else
615 >        else{
616            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
617 <        
618 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
619 <                             TAKE_THIS_TAG);
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 <  }  
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