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 437 by chuckv, Fri Mar 28 22:34:02 2003 UTC vs.
Revision 723 by mmeineke, Tue Aug 26 20:12:51 2003 UTC

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

Diff Legend

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