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 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 0
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;
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      
167 <    outFile << currentTime << "\t"
132 <            << entry_plug->box_x << "\t"
133 <            << entry_plug->box_y << "\t"
134 <            << entry_plug->box_z << "\n";
135 <    
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 <        
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 );
173 >      if (which_node == 0 ) {
174          
175 <        if( atoms[i]->isDirectional() ){
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 <          dAtom = (DirectionalAtom *)atoms[i];
185 <          dAtom->getQ( q );
186 <          
184 >          atoms[local_index]->getPos(pos);
185 >          atoms[local_index]->getVel(vel);
186 >
187            sprintf( tempBuffer,
188 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
189 <                   q[0],
190 <                   q[1],
191 <                   q[2],
192 <                   q[3],
193 <                   dAtom->getJx(),
194 <                   dAtom->getJy(),
195 <                   dAtom->getJz());
196 <          strcat( writeLine, tempBuffer );
197 <        }
198 <        else
199 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
200 <        
201 <      } else {
202 <        
203 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
204 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
205 <                                TAKE_THIS_TAG, istatus);
188 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
189 >                   atoms[local_index]->getType(),
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() ){
199 >            
200 >            dAtom = (DirectionalAtom *)atoms[local_index];
201 >            dAtom->getQ( q );
202 >            
203 >            sprintf( tempBuffer,
204 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
205 >                     q[0],
206 >                     q[1],
207 >                     q[2],
208 >                     q[3],
209 >                     dAtom->getJx(),
210 >                     dAtom->getJy(),
211 >                     dAtom->getJz());
212 >            strcat( writeLine, tempBuffer );
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 <    game_over = -1;
249 >    myStatus = -1;
250      for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
251 <      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG);
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 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
260 <                              TAKE_THIS_TAG, istatus);
259 >      
260 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
261 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
262  
263 <      if (which_atom == -1) {
264 <        done=1;
265 <        continue;
199 <      } else {
263 >      if(!myStatus) anonymousNodeDie();
264 >      
265 >      if(myStatus < 0) break;
266  
267 <        //format the line
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[which_atom]->getType(),
284 <                 atoms[which_atom]->getX(),
285 <                 atoms[which_atom]->getY(),
286 <                 atoms[which_atom]->getZ(),
287 <                 atoms[which_atom]->get_vx(),
288 <                 atoms[which_atom]->get_vy(),
289 <                 atoms[which_atom]->get_vz()); // check here.
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 <        if( atoms[which_atom]->isDirectional() ){
214 <            
215 <          dAtom = (DirectionalAtom *)atoms[which_atom];
294 >          dAtom = (DirectionalAtom *)atoms[local_index];
295            dAtom->getQ( q );
296 <            
296 >          
297            sprintf( tempBuffer,
298                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
299                     q[0],
# Line 226 | Line 305 | void DumpWriter::writeDump( double currentTime ){
305                     dAtom->getJz());
306            strcat( writeLine, tempBuffer );
307          }
308 <        else
308 >        else{
309            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
310 <        
311 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
312 <                             TAKE_THIS_TAG);
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 254 | Line 349 | void DumpWriter::writeFinal(){
349    DirectionalAtom* dAtom;
350    int nAtoms = entry_plug->n_atoms;
351    Atom** atoms = entry_plug->atoms;
352 <  int i, j, which_node, done, game_over, which_atom;
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 287 | 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 330 | 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 348 | 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());
361 <        strcpy( writeLine, tempBuffer );
362 <        
363 <        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) {
402 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
403 –                           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 <        //format the line
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[which_atom]->getType(),
581 <                 atoms[which_atom]->getX(),
582 <                 atoms[which_atom]->getY(),
583 <                 atoms[which_atom]->getZ(),
584 <                 atoms[which_atom]->get_vx(),
585 <                 atoms[which_atom]->get_vy(),
586 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
423 <            
424 <          dAtom = (DirectionalAtom *)atoms[which_atom];
591 >          dAtom = (DirectionalAtom *)atoms[local_index];
592            dAtom->getQ( q );
593 <            
593 >          
594            sprintf( tempBuffer,
595                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
596                     q[0],
# Line 435 | Line 602 | void DumpWriter::writeFinal(){
602                     dAtom->getJz());
603            strcat( writeLine, tempBuffer );
604          }
605 <        else
605 >        else{
606            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
607 <        
608 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
609 <                             TAKE_THIS_TAG);
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 <  }  
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