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 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 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, 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 120 | 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      
131 –    outFile << currentTime << "\t"
132 –            << entry_plug->box_x << "\t"
133 –            << entry_plug->box_y << "\t"
134 –            << 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;
172        
173        which_node = AtomToProcMap[i];    
174        
175 <      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 );
175 >      if (which_node == 0 ) {
176          
177 <        if( atoms[i]->isDirectional() ){
178 <          
179 <          dAtom = (DirectionalAtom *)atoms[i];
180 <          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++) {
177 >        haveError = 0;
178 >        which_atom = i;
179 >        local_index=-1;        
180 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
181            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
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 233 | Line 212 | void DumpWriter::writeDump( double currentTime ){
212                       dAtom->getJy(),
213                       dAtom->getJz());
214              strcat( writeLine, tempBuffer );
215 <          }
216 <          else
217 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
218 <          std::cerr << "node: " << mpiSim->getMyNode() << " sending this line" << writeLine;
219 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
220 <                               TAKE_THIS_TAG);
221 <        } else {
222 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
223 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
224 <                               TAKE_THIS_TAG);
225 <        }
215 >            
216 >          }
217 >          else
218 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
219 >        }
220 >        else {
221 >          sprintf(painCave.errMsg,
222 >                  "Atom %d not found on processor %d\n",
223 >                  i, worldRank );
224 >          haveError= 1;
225 >          simError();
226 >        }
227 >        
228 >        if(haveError) nodeZeroError();
229 >
230        }
231 +      else {
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;
247 +      outFile.flush();
248      }
249 +    
250 +    // kill everyone off:
251 +    myStatus = -1;
252 +    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
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 +      
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 +          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 269 | 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 300 | 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 343 | 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 361 | Line 474 | void DumpWriter::writeFinal(){
474        which_node = AtomToProcMap[i];    
475        
476        if (which_node == mpiSim->getMyNode()) {
477 <        
478 <        sprintf( tempBuffer,
479 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
480 <                 atoms[i]->getType(),
481 <                 atoms[i]->getX(),
482 <                 atoms[i]->getY(),
483 <                 atoms[i]->getZ(),
484 <                 atoms[i]->get_vx(),
485 <                 atoms[i]->get_vy(),
486 <                 atoms[i]->get_vz());
374 <        strcpy( writeLine, tempBuffer );
375 <        
376 <        if( atoms[i]->isDirectional() ){
477 >
478 >        which_atom = i;
479 >        local_index=-1;        
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) {    
484 >
485 >          atoms[local_index]->getPos(pos);
486 >          atoms[local_index]->getVel(vel);
487            
488 <          dAtom = (DirectionalAtom *)atoms[i];
489 <          dAtom->getQ( q );
488 >          sprintf( tempBuffer,
489 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
490 >                   atoms[local_index]->getType(),
491 >                   pos[0],
492 >                   pos[1],
493 >                   pos[2],
494 >                   vel[0],
495 >                   vel[1],
496 >                   vel[2]);
497 >          strcpy( writeLine, tempBuffer );
498            
499 <          sprintf( tempBuffer,
500 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
501 <                   q[0],
502 <                   q[1],
503 <                   q[2],
504 <                   q[3],
505 <                   dAtom->getJx(),
506 <                   dAtom->getJy(),
507 <                   dAtom->getJz());
508 <          strcat( writeLine, tempBuffer );
509 <        }
510 <        else
511 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
499 >          if( atoms[local_index]->isDirectional() ){
500 >            
501 >            dAtom = (DirectionalAtom *)atoms[local_index];
502 >            dAtom->getQ( q );
503 >            
504 >            sprintf( tempBuffer,
505 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
506 >                     q[0],
507 >                     q[1],
508 >                     q[2],
509 >                     q[3],
510 >                     dAtom->getJx(),
511 >                     dAtom->getJy(),
512 >                     dAtom->getJz());
513 >            strcat( writeLine, tempBuffer );
514 >          }
515 >          else
516 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
517 >        }
518 >        else {
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 >      }
529 >      else {
530          
531 <      } else {
532 <        
533 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
534 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
535 <                                TAKE_THIS_TAG, 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);
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) {
415 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
416 –                           TAKE_THIS_TAG, 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++) {
425 <          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
426 <        }
427 <        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);
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);
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