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 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 1
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 20 | Line 27 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
27    if(worldRank == 0 ){
28   #endif // is_mpi
29      
23 –
24 –    
30      strcpy( outName, entry_plug->sampleName );
31      
32      outFile.open(outName, ios::out | ios::trunc );
# Line 34 | 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 65 | 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 120 | 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      
131 –    outFile << currentTime << "\t"
132 –            << entry_plug->box_x << "\t"
133 –            << entry_plug->box_y << "\t"
134 –            << 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;
170        
171        which_node = AtomToProcMap[i];    
172        
173 <      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 );
173 >      if (which_node == 0 ) {
174          
175 <        if( atoms[i]->isDirectional() ){
176 <          
177 <          dAtom = (DirectionalAtom *)atoms[i];
178 <          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++) {
175 >        haveError = 0;
176 >        which_atom = i;
177 >        local_index=-1;        
178 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
179            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
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 233 | Line 210 | void DumpWriter::writeDump( double currentTime ){
210                       dAtom->getJy(),
211                       dAtom->getJz());
212              strcat( writeLine, tempBuffer );
213 <          }
214 <          else
215 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
216 <          std::cerr << "node: " << mpiSim->getMyNode() << " sending this line" << writeLine;
217 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
218 <                               TAKE_THIS_TAG);
219 <        } else {
220 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
221 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
222 <                               TAKE_THIS_TAG);
223 <        }
213 >            
214 >          }
215 >          else
216 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
217 >        }
218 >        else {
219 >          sprintf(painCave.errMsg,
220 >                  "Atom %d not found on processor %d\n",
221 >                  i, worldRank );
222 >          haveError= 1;
223 >          simError();
224 >        }
225 >        
226 >        if(haveError) nodeZeroError();
227 >
228        }
229 +      else {
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;
245 +      outFile.flush();
246      }
247 +    
248 +    // kill everyone off:
249 +    myStatus = -1;
250 +    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
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 +      
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 +          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 269 | 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 300 | 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 343 | 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 361 | 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());
374 <        strcpy( writeLine, tempBuffer );
375 <        
376 <        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);
532 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
533 <                                TAKE_THIS_TAG, 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);
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) {
415 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
416 –                           TAKE_THIS_TAG, 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++) {
425 <          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
426 <        }
427 <        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);
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);
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