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 434 by chuckv, Fri Mar 28 19:30:59 2003 UTC vs.
Revision 804 by mmeineke, Thu Oct 16 19:16:24 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 1
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, 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;
71 –  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 147 | void DumpWriter::writeDump( double currentTime ){
147  
148   #else // is_mpi
149  
150 <  MPI::Status istatus;
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    
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      
131 –    outFile << currentTime << "\t"
132 –            << entry_plug->box_x << "\t"
133 –            << entry_plug->box_y << "\t"
134 –            << entry_plug->box_z << "\n";
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 == mpiSim->getMyNode()) {
142 <                sprintf( tempBuffer,
143 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
144 <                 atoms[i]->getType(),
145 <                 atoms[i]->getX(),
146 <                 atoms[i]->getY(),
147 <                 atoms[i]->getZ(),
148 <                 atoms[i]->get_vx(),
149 <                 atoms[i]->get_vy(),
150 <                 atoms[i]->get_vz());
151 <        strcpy( writeLine, tempBuffer );
183 >      if (which_node == 0 ) {
184          
185 <        if( atoms[i]->isDirectional() ){
186 <          
187 <          dAtom = (DirectionalAtom *)atoms[i];
188 <          dAtom->getQ( q );
157 <          
158 <          sprintf( tempBuffer,
159 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
160 <                   q[0],
161 <                   q[1],
162 <                   q[2],
163 <                   q[3],
164 <                   dAtom->getJx(),
165 <                   dAtom->getJy(),
166 <                   dAtom->getJz());
167 <          strcat( writeLine, tempBuffer );
168 <        }
169 <        else
170 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
171 <        
172 <      } else {
173 <        
174 <        std::cerr << "node 0: sending node " << which_node << " request for atom " << i << "\n";
175 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
176 <        std::cerr << "node 0: sent!\n";
177 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
178 <                                TAKE_THIS_TAG, istatus);
179 <        std::cerr << "node 0: got this line: " << writeLine;
180 <      }
181 <      
182 <      outFile << writeLine;
183 <      outFile.flush();
184 <    }
185 <    
186 <    // kill everyone off:
187 <    game_over = -1;
188 <    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
189 <      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG);
190 <    }
191 <
192 <  } else {
193 <    
194 <    done = 0;
195 <    while (!done) {
196 <      std::cerr << "node: " << mpiSim->getMyNode() << " Waiting for receive \n";
197 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
198 <                           TAKE_THIS_TAG, istatus);
199 <      std::cerr << "node: " << mpiSim->getMyNode() << " got request for atom " << which_atom << "\n";
200 <      if (which_atom == -1) {
201 <        done=1;
202 <        continue;
203 <      } else {
204 <        local_index=-1;        
205 <        for (j=0; j < mpiSim->getMyNlocal(); j++) {
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 +          atoms[local_index]->getPos(pos);
195 +          atoms[local_index]->getVel(vel);
196 +
197            sprintf( tempBuffer,
198                     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
199                     atoms[local_index]->getType(),
200 <                   atoms[local_index]->getX(),
201 <                   atoms[local_index]->getY(),
202 <                   atoms[local_index]->getZ(),
203 <                   atoms[local_index]->get_vx(),
204 <                   atoms[local_index]->get_vy(),
205 <                   atoms[local_index]->get_vz()); // check here.
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() ){
# Line 233 | Line 220 | void DumpWriter::writeDump( double currentTime ){
220                       dAtom->getJy(),
221                       dAtom->getJz());
222              strcat( writeLine, tempBuffer );
223 <          }
224 <          else
225 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
226 <          std::cerr << "node: " << mpiSim->getMyNode() << " sending this line" << writeLine;
227 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
228 <                               TAKE_THIS_TAG);
229 <        } else {
230 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
231 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
232 <                               TAKE_THIS_TAG);
233 <        }
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 +    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 +      
270 +      MPI_Recv(&myStatus, 1, MPI_INT, 0,
271 +               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
272 +
273 +      if(!myStatus) anonymousNodeDie();
274 +      
275 +      if(myStatus < 0) break;
276 +
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[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 +          dAtom = (DirectionalAtom *)atoms[local_index];
305 +          dAtom->getQ( q );
306 +          
307 +          sprintf( tempBuffer,
308 +                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
309 +                   q[0],
310 +                   q[1],
311 +                   q[2],
312 +                   q[3],
313 +                   dAtom->getJx(),
314 +                   dAtom->getJy(),
315 +                   dAtom->getJz());
316 +          strcat( writeLine, tempBuffer );
317 +        }
318 +        else{
319 +          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
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(){
349 > void DumpWriter::writeFinal(double finalTime){
350  
351    char finalName[500];
352    ofstream finalOut;
# Line 265 | Line 357 | void DumpWriter::writeFinal(){
357  
358    double q[4];
359    DirectionalAtom* dAtom;
268 –  int nAtoms = entry_plug->n_atoms;
360    Atom** atoms = entry_plug->atoms;
361 <  int i, j, which_node, done, game_over, which_atom, local_index;
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 ){
# Line 300 | 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 343 | Line 452 | void DumpWriter::writeFinal(){
452  
453   #else // is_mpi
454    
455 <  MPI::Status istatus;
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 < mpiSim->getTotAtoms(); i++ ) {
484        // Get the Node number which has this molecule:
# Line 361 | Line 486 | void DumpWriter::writeFinal(){
486        which_node = AtomToProcMap[i];    
487        
488        if (which_node == mpiSim->getMyNode()) {
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());
374 <        strcpy( writeLine, tempBuffer );
375 <        
376 <        if( atoms[i]->isDirectional() ){
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.Recv(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 <    game_over = -1;
561 <    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
562 <      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) {
415 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
416 –                           TAKE_THIS_TAG, istatus);
570  
571 <      if (which_atom == -1) {
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 <        local_index=-1;        
589 <        for (j=0; j < mpiSim->getMyNlocal(); j++) {
425 <          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
426 <        }
427 <        if (local_index != -1) {
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[local_index]->getType(),
595 <                   atoms[local_index]->getX(),
596 <                   atoms[local_index]->getY(),
597 <                   atoms[local_index]->getZ(),
598 <                   atoms[local_index]->get_vx(),
599 <                   atoms[local_index]->get_vy(),
600 <                   atoms[local_index]->get_vz()); // check here.
601 <          strcpy( writeLine, tempBuffer );
591 >        //format the line
592 >        sprintf( tempBuffer,
593 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
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[local_index]->isDirectional() ){
606 <            
607 <            dAtom = (DirectionalAtom *)atoms[local_index];
608 <            dAtom->getQ( q );
609 <            
610 <            sprintf( tempBuffer,
611 <                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
612 <                     q[0],
613 <                     q[1],
614 <                     q[2],
615 <                     q[3],
616 <                     dAtom->getJx(),
617 <                     dAtom->getJy(),
618 <                     dAtom->getJz());
619 <            strcat( writeLine, tempBuffer );
620 <          }
621 <          else
622 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
623 <          
624 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
625 <                               TAKE_THIS_TAG);
626 <        } else {
627 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
628 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
629 <                               TAKE_THIS_TAG);
630 <        }
605 >          dAtom = (DirectionalAtom *)atoms[local_index];
606 >          dAtom->getQ( q );
607 >          
608 >          sprintf( tempBuffer,
609 >                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
610 >                   q[0],
611 >                   q[1],
612 >                   q[2],
613 >                   q[3],
614 >                   dAtom->getJx(),
615 >                   dAtom->getJy(),
616 >                   dAtom->getJz());
617 >          strcat( writeLine, tempBuffer );
618 >        }
619 >        else{
620 >          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
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    }
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