ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DumpWriter.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 417 by gezelter, Thu Mar 27 01:49:45 2003 UTC vs.
Revision 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 0
10 > #define TAKE_THIS_TAG_CHAR 1
11 > #define TAKE_THIS_TAG_INT 2
12 >
13 > namespace dWrite{
14 >  void nodeZeroError( void );
15 >  void anonymousNodeDie( void );
16 > }
17 >
18 > using namespace dWrite;
19   #endif //is_mpi
20  
21   #include "ReadWrite.hpp"
# Line 20 | Line 29 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
29    if(worldRank == 0 ){
30   #endif // is_mpi
31      
23 –
24 –    
32      strcpy( outName, entry_plug->sampleName );
33      
34      outFile.open(outName, ios::out | ios::trunc );
# Line 34 | Line 41 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
41        painCave.isFatal = 1;
42        simError();
43      }
44 <  
44 >
45      //outFile.setf( ios::scientific );
46  
47   #ifdef IS_MPI
# Line 65 | Line 72 | void DumpWriter::writeDump( double currentTime ){
72    char tempBuffer[BUFFERSIZE];
73    char writeLine[BUFFERSIZE];
74  
75 <  int i, j, which_node, done, game_over, which_atom;
75 >  int i, 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      
169 <    outFile << currentTime << "\t"
132 <            << entry_plug->box_x << "\t"
133 <            << entry_plug->box_y << "\t"
134 <            << entry_plug->box_z << "\n";
135 <    
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 <        
143 <        sprintf( tempBuffer,
144 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
145 <                 atoms[i]->getType(),
146 <                 atoms[i]->getX(),
147 <                 atoms[i]->getY(),
148 <                 atoms[i]->getZ(),
149 <                 atoms[i]->get_vx(),
150 <                 atoms[i]->get_vy(),
151 <                 atoms[i]->get_vz());
152 <        strcpy( writeLine, tempBuffer );
175 >      if (which_node == 0 ) {
176          
177 <        if( atoms[i]->isDirectional() ){
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 <          dAtom = (DirectionalAtom *)atoms[i];
187 <          dAtom->getQ( q );
188 <          
186 >          atoms[local_index]->getPos(pos);
187 >          atoms[local_index]->getVel(vel);
188 >
189            sprintf( tempBuffer,
190 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
191 <                   q[0],
192 <                   q[1],
193 <                   q[2],
194 <                   q[3],
195 <                   dAtom->getJx(),
196 <                   dAtom->getJy(),
197 <                   dAtom->getJz());
198 <          strcat( writeLine, tempBuffer );
199 <        }
200 <        else
201 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
202 <        
203 <      } else {
204 <        
205 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
206 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
207 <                                TAKE_THIS_TAG, istatus);
190 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
191 >                   atoms[local_index]->getType(),
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() ){
201 >            
202 >            dAtom = (DirectionalAtom *)atoms[local_index];
203 >            dAtom->getQ( q );
204 >            
205 >            sprintf( tempBuffer,
206 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
207 >                     q[0],
208 >                     q[1],
209 >                     q[2],
210 >                     q[3],
211 >                     dAtom->getJx(),
212 >                     dAtom->getJy(),
213 >                     dAtom->getJz());
214 >            strcat( writeLine, tempBuffer );
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 <    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);
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 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
262 <                              TAKE_THIS_TAG, istatus);
261 >      
262 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
263 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
264  
265 <      if (which_atom == -1) {
266 <        done=1;
267 <        continue;
199 <      } else {
265 >      if(!myStatus) anonymousNodeDie();
266 >      
267 >      if(myStatus < 0) break;
268  
269 <        //format the line
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[which_atom]->getType(),
286 <                 atoms[which_atom]->getX(),
287 <                 atoms[which_atom]->getY(),
288 <                 atoms[which_atom]->getZ(),
289 <                 atoms[which_atom]->get_vx(),
290 <                 atoms[which_atom]->get_vy(),
291 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
214 <            
215 <          dAtom = (DirectionalAtom *)atoms[which_atom];
296 >          dAtom = (DirectionalAtom *)atoms[local_index];
297            dAtom->getQ( q );
298 <            
298 >          
299            sprintf( tempBuffer,
300                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
301                     q[0],
# Line 226 | Line 307 | void DumpWriter::writeDump( double currentTime ){
307                     dAtom->getJz());
308            strcat( writeLine, tempBuffer );
309          }
310 <        else
310 >        else{
311            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
312 <        
313 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
314 <                             TAKE_THIS_TAG);
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 254 | Line 351 | void DumpWriter::writeFinal(){
351    DirectionalAtom* dAtom;
352    int nAtoms = entry_plug->n_atoms;
353    Atom** atoms = entry_plug->atoms;
354 <  int i, j, which_node, done, game_over, which_atom;
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 287 | 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 330 | 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 348 | 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());
361 <        strcpy( writeLine, tempBuffer );
362 <        
363 <        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) {
402 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
403 –                           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 <        //format the line
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[which_atom]->getType(),
583 <                 atoms[which_atom]->getX(),
584 <                 atoms[which_atom]->getY(),
585 <                 atoms[which_atom]->getZ(),
586 <                 atoms[which_atom]->get_vx(),
587 <                 atoms[which_atom]->get_vy(),
588 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
423 <            
424 <          dAtom = (DirectionalAtom *)atoms[which_atom];
593 >          dAtom = (DirectionalAtom *)atoms[local_index];
594            dAtom->getQ( q );
595 <            
595 >          
596            sprintf( tempBuffer,
597                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
598                     q[0],
# Line 435 | Line 604 | void DumpWriter::writeFinal(){
604                     dAtom->getJz());
605            strcat( writeLine, tempBuffer );
606          }
607 <        else
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);
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 <  }  
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