ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DumpWriter.cpp
Revision: 804
Committed: Thu Oct 16 19:16:24 2003 UTC (20 years, 8 months ago) by mmeineke
File size: 15245 byte(s)
Log Message: 
Changed DumpReader to use linked lists instead of a vector.

Fixed the makefile to build DumpReader.cpp

Removed a comment output in Exclude.cpp

Modified DumpWriter and Integrator to write an eor file every time a frame is written.
This lets the .eor file represent the last written frame of a simulation.

File Contents

# User Rev Content
1 mmeineke 723 #define _FILE_OFFSET_BITS 64
2    
3 mmeineke 377 #include <cstring>
4     #include <iostream>
5     #include <fstream>
6    
7     #ifdef IS_MPI
8     #include <mpi.h>
9     #include "mpiSimulation.hpp"
10 chuckv 436 #define TAKE_THIS_TAG_CHAR 1
11     #define TAKE_THIS_TAG_INT 2
12 mmeineke 440
13     namespace dWrite{
14     void nodeZeroError( void );
15     void anonymousNodeDie( void );
16     }
17    
18     using namespace dWrite;
19 mmeineke 377 #endif //is_mpi
20    
21     #include "ReadWrite.hpp"
22     #include "simError.h"
23    
24     DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
25    
26     entry_plug = the_entry_plug;
27    
28     #ifdef IS_MPI
29     if(worldRank == 0 ){
30     #endif // is_mpi
31    
32     strcpy( outName, entry_plug->sampleName );
33    
34     outFile.open(outName, ios::out | ios::trunc );
35    
36     if( !outFile ){
37    
38     sprintf( painCave.errMsg,
39     "Could not open \"%s\" for dump output.\n",
40     outName);
41     painCave.isFatal = 1;
42     simError();
43     }
44 mmeineke 469
45 mmeineke 377 //outFile.setf( ios::scientific );
46    
47     #ifdef IS_MPI
48     }
49    
50     sprintf( checkPointMsg,
51     "Sucessfully opened output file for dumping.\n");
52     MPIcheckPoint();
53     #endif // is_mpi
54     }
55    
56     DumpWriter::~DumpWriter( ){
57    
58     #ifdef IS_MPI
59     if(worldRank == 0 ){
60     #endif // is_mpi
61    
62     outFile.close();
63    
64     #ifdef IS_MPI
65     }
66     #endif // is_mpi
67     }
68    
69     void DumpWriter::writeDump( double currentTime ){
70    
71     const int BUFFERSIZE = 2000;
72     char tempBuffer[BUFFERSIZE];
73     char writeLine[BUFFERSIZE];
74    
75 mmeineke 787 int i;
76     #ifdef IS_MPI
77     int j, which_node, done, which_atom, local_index;
78     #else //is_mpi
79     int nAtoms = entry_plug->n_atoms;
80     #endif //is_mpi
81    
82 mmeineke 377 double q[4];
83     DirectionalAtom* dAtom;
84     Atom** atoms = entry_plug->atoms;
85 mmeineke 670 double pos[3], vel[3];
86 mmeineke 377
87 mmeineke 804
88     // write current frame to the eor file
89 mmeineke 377
90 mmeineke 804 this->writeFinal( currentTime );
91    
92 mmeineke 377 #ifndef IS_MPI
93    
94     outFile << nAtoms << "\n";
95    
96 mmeineke 586 outFile << currentTime << ";\t"
97 mmeineke 590 << entry_plug->Hmat[0][0] << "\t"
98     << entry_plug->Hmat[1][0] << "\t"
99     << entry_plug->Hmat[2][0] << ";\t"
100 mmeineke 572
101 mmeineke 590 << entry_plug->Hmat[0][1] << "\t"
102     << entry_plug->Hmat[1][1] << "\t"
103     << entry_plug->Hmat[2][1] << ";\t"
104 mmeineke 572
105 mmeineke 590 << entry_plug->Hmat[0][2] << "\t"
106     << entry_plug->Hmat[1][2] << "\t"
107     << entry_plug->Hmat[2][2] << ";\n";
108 mmeineke 377
109     for( i=0; i<nAtoms; i++ ){
110    
111 mmeineke 670 atoms[i]->getPos(pos);
112     atoms[i]->getVel(vel);
113 mmeineke 377
114     sprintf( tempBuffer,
115     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
116     atoms[i]->getType(),
117 mmeineke 670 pos[0],
118     pos[1],
119     pos[2],
120     vel[0],
121     vel[1],
122     vel[2]);
123 mmeineke 377 strcpy( writeLine, tempBuffer );
124    
125     if( atoms[i]->isDirectional() ){
126    
127     dAtom = (DirectionalAtom *)atoms[i];
128     dAtom->getQ( q );
129    
130     sprintf( tempBuffer,
131     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
132     q[0],
133     q[1],
134     q[2],
135     q[3],
136     dAtom->getJx(),
137     dAtom->getJy(),
138     dAtom->getJz());
139     strcat( writeLine, tempBuffer );
140     }
141     else
142     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
143    
144     outFile << writeLine;
145     }
146     outFile.flush();
147    
148     #else // is_mpi
149 gezelter 416
150 mmeineke 440 // first thing first, suspend fatalities.
151     painCave.isEventLoop = 1;
152    
153     int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
154     int haveError;
155    
156 mmeineke 447 MPI_Status istatus;
157 gezelter 416 int *AtomToProcMap = mpiSim->getAtomToProcMap();
158 gezelter 415
159 mmeineke 377 // write out header and node 0's coordinates
160 gezelter 415
161 mmeineke 377 if( worldRank == 0 ){
162     outFile << mpiSim->getTotAtoms() << "\n";
163 mmeineke 572
164 gezelter 591 outFile << currentTime << ";\t"
165     << entry_plug->Hmat[0][0] << "\t"
166     << entry_plug->Hmat[1][0] << "\t"
167     << entry_plug->Hmat[2][0] << ";\t"
168 mmeineke 572
169 gezelter 591 << entry_plug->Hmat[0][1] << "\t"
170     << entry_plug->Hmat[1][1] << "\t"
171     << entry_plug->Hmat[2][1] << ";\t"
172 mmeineke 572
173 gezelter 591 << entry_plug->Hmat[0][2] << "\t"
174     << entry_plug->Hmat[1][2] << "\t"
175     << entry_plug->Hmat[2][2] << ";\n";
176    
177 chuckv 434 outFile.flush();
178 gezelter 416 for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
179 gezelter 417 // Get the Node number which has this atom;
180 mmeineke 377
181 gezelter 415 which_node = AtomToProcMap[i];
182    
183 chuckv 436 if (which_node == 0 ) {
184 mmeineke 377
185 mmeineke 440 haveError = 0;
186 chuckv 436 which_atom = i;
187     local_index=-1;
188     for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
189     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
190     }
191     if (local_index != -1) {
192     //format the line
193 mmeineke 670
194     atoms[local_index]->getPos(pos);
195     atoms[local_index]->getVel(vel);
196    
197 chuckv 436 sprintf( tempBuffer,
198     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
199     atoms[local_index]->getType(),
200 mmeineke 670 pos[0],
201     pos[1],
202     pos[2],
203     vel[0],
204     vel[1],
205     vel[2]); // check here.
206 chuckv 436 strcpy( writeLine, tempBuffer );
207 mmeineke 377
208 chuckv 436 if( atoms[local_index]->isDirectional() ){
209    
210     dAtom = (DirectionalAtom *)atoms[local_index];
211     dAtom->getQ( q );
212    
213     sprintf( tempBuffer,
214     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
215     q[0],
216     q[1],
217     q[2],
218     q[3],
219     dAtom->getJx(),
220     dAtom->getJy(),
221     dAtom->getJz());
222     strcat( writeLine, tempBuffer );
223    
224     }
225     else
226     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
227     }
228     else {
229 mmeineke 440 sprintf(painCave.errMsg,
230     "Atom %d not found on processor %d\n",
231     i, worldRank );
232     haveError= 1;
233     simError();
234 chuckv 436 }
235 mmeineke 440
236     if(haveError) nodeZeroError();
237    
238     }
239 chuckv 436 else {
240 mmeineke 440 myStatus = 1;
241 mmeineke 447 MPI_Send(&myStatus, 1, MPI_INT, which_node,
242     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
243     MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
244     MPI_COMM_WORLD);
245     MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
246     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
247     MPI_Recv(&myStatus, 1, MPI_INT, which_node,
248     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
249 mmeineke 440
250     if(!myStatus) nodeZeroError();
251    
252 mmeineke 377 }
253 gezelter 415
254 mmeineke 377 outFile << writeLine;
255 chuckv 434 outFile.flush();
256 mmeineke 377 }
257    
258 gezelter 415 // kill everyone off:
259 mmeineke 440 myStatus = -1;
260 gezelter 416 for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
261 mmeineke 447 MPI_Send(&myStatus, 1, MPI_INT, j,
262     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
263 mmeineke 377 }
264    
265 gezelter 415 } else {
266    
267     done = 0;
268     while (!done) {
269 mmeineke 440
270 mmeineke 447 MPI_Recv(&myStatus, 1, MPI_INT, 0,
271     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
272 mmeineke 440
273     if(!myStatus) anonymousNodeDie();
274    
275     if(myStatus < 0) break;
276    
277 mmeineke 447 MPI_Recv(&which_atom, 1, MPI_INT, 0,
278     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
279 mmeineke 440
280     myStatus = 1;
281     local_index=-1;
282     for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
283     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
284     }
285     if (local_index != -1) {
286     //format the line
287 mmeineke 670
288     atoms[local_index]->getPos(pos);
289     atoms[local_index]->getVel(vel);
290    
291 mmeineke 440 sprintf( tempBuffer,
292     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
293     atoms[local_index]->getType(),
294 mmeineke 670 pos[0],
295     pos[1],
296     pos[2],
297     vel[0],
298     vel[1],
299     vel[2]); // check here.
300 mmeineke 440 strcpy( writeLine, tempBuffer );
301    
302     if( atoms[local_index]->isDirectional() ){
303 mmeineke 377
304 mmeineke 440 dAtom = (DirectionalAtom *)atoms[local_index];
305     dAtom->getQ( q );
306    
307     sprintf( tempBuffer,
308     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
309     q[0],
310     q[1],
311     q[2],
312     q[3],
313     dAtom->getJx(),
314     dAtom->getJy(),
315     dAtom->getJz());
316     strcat( writeLine, tempBuffer );
317     }
318     else{
319     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
320     }
321     }
322     else {
323     sprintf(painCave.errMsg,
324     "Atom %d not found on processor %d\n",
325     which_atom, worldRank );
326     myStatus = 0;
327     simError();
328    
329     strcpy( writeLine, "Hello, I'm an error.\n");
330 mmeineke 377 }
331 mmeineke 440
332 mmeineke 447 MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
333     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
334     MPI_Send( &myStatus, 1, MPI_INT, 0,
335     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
336 mmeineke 377 }
337 gezelter 415 }
338     outFile.flush();
339     sprintf( checkPointMsg,
340     "Sucessfully took a dump.\n");
341     MPIcheckPoint();
342 mmeineke 440
343     // last thing last, enable fatalities.
344     painCave.isEventLoop = 0;
345    
346 mmeineke 377 #endif // is_mpi
347     }
348    
349 mmeineke 572 void DumpWriter::writeFinal(double finalTime){
350 gezelter 416
351 mmeineke 377 char finalName[500];
352     ofstream finalOut;
353 gezelter 416
354     const int BUFFERSIZE = 2000;
355     char tempBuffer[BUFFERSIZE];
356     char writeLine[BUFFERSIZE];
357    
358     double q[4];
359     DirectionalAtom* dAtom;
360 mmeineke 787 Atom** atoms = entry_plug->atoms;
361     int i;
362     #ifdef IS_MPI
363     int j, which_node, done, which_atom, local_index;
364     #else //is_mpi
365 gezelter 416 int nAtoms = entry_plug->n_atoms;
366 mmeineke 787 #endif //is_mpi
367 mmeineke 377
368 mmeineke 670 double pos[3], vel[3];
369 gezelter 416
370 mmeineke 377 #ifdef IS_MPI
371     if(worldRank == 0 ){
372     #endif // is_mpi
373    
374     strcpy( finalName, entry_plug->finalName );
375    
376     finalOut.open( finalName, ios::out | ios::trunc );
377     if( !finalOut ){
378     sprintf( painCave.errMsg,
379     "Could not open \"%s\" for final dump output.\n",
380     finalName );
381     painCave.isFatal = 1;
382     simError();
383     }
384    
385     // finalOut.setf( ios::scientific );
386    
387     #ifdef IS_MPI
388     }
389    
390     sprintf(checkPointMsg,"Opened file for final configuration\n");
391     MPIcheckPoint();
392    
393     #endif //is_mpi
394    
395 gezelter 415
396 mmeineke 377 #ifndef IS_MPI
397    
398     finalOut << nAtoms << "\n";
399    
400 gezelter 591 finalOut << finalTime << ";\t"
401 mmeineke 590 << entry_plug->Hmat[0][0] << "\t"
402     << entry_plug->Hmat[1][0] << "\t"
403 gezelter 591 << entry_plug->Hmat[2][0] << ";\t"
404 mmeineke 572
405 mmeineke 590 << entry_plug->Hmat[0][1] << "\t"
406     << entry_plug->Hmat[1][1] << "\t"
407 gezelter 591 << entry_plug->Hmat[2][1] << ";\t"
408 mmeineke 572
409 mmeineke 590 << entry_plug->Hmat[0][2] << "\t"
410     << entry_plug->Hmat[1][2] << "\t"
411 gezelter 591 << entry_plug->Hmat[2][2] << ";\n";
412 gezelter 416
413 mmeineke 377 for( i=0; i<nAtoms; i++ ){
414    
415 mmeineke 670 atoms[i]->getPos(pos);
416     atoms[i]->getVel(vel);
417    
418 mmeineke 377 sprintf( tempBuffer,
419     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
420     atoms[i]->getType(),
421 mmeineke 670 pos[0],
422     pos[1],
423     pos[2],
424     vel[0],
425     vel[1],
426     vel[2]);
427 mmeineke 377 strcpy( writeLine, tempBuffer );
428    
429     if( atoms[i]->isDirectional() ){
430    
431     dAtom = (DirectionalAtom *)atoms[i];
432     dAtom->getQ( q );
433    
434     sprintf( tempBuffer,
435     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
436     q[0],
437     q[1],
438     q[2],
439     q[3],
440     dAtom->getJx(),
441     dAtom->getJy(),
442     dAtom->getJz());
443     strcat( writeLine, tempBuffer );
444     }
445     else
446     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
447    
448     finalOut << writeLine;
449     }
450     finalOut.flush();
451 gezelter 415 finalOut.close();
452 mmeineke 377
453     #else // is_mpi
454 gezelter 415
455 mmeineke 440 // first thing first, suspend fatalities.
456     painCave.isEventLoop = 1;
457    
458     int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
459     int haveError;
460    
461 mmeineke 447 MPI_Status istatus;
462 gezelter 416 int *AtomToProcMap = mpiSim->getAtomToProcMap();
463    
464 mmeineke 377 // write out header and node 0's coordinates
465 gezelter 415
466 mmeineke 440 haveError = 0;
467 mmeineke 377 if( worldRank == 0 ){
468     finalOut << mpiSim->getTotAtoms() << "\n";
469 gezelter 415
470 gezelter 591 finalOut << finalTime << ";\t"
471     << entry_plug->Hmat[0][0] << "\t"
472     << entry_plug->Hmat[1][0] << "\t"
473     << entry_plug->Hmat[2][0] << ";\t"
474 mmeineke 572
475 gezelter 591 << entry_plug->Hmat[0][1] << "\t"
476     << entry_plug->Hmat[1][1] << "\t"
477     << entry_plug->Hmat[2][1] << ";\t"
478 mmeineke 572
479 gezelter 591 << entry_plug->Hmat[0][2] << "\t"
480     << entry_plug->Hmat[1][2] << "\t"
481     << entry_plug->Hmat[2][2] << ";\n";
482 mmeineke 377
483 gezelter 416 for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
484 gezelter 415 // Get the Node number which has this molecule:
485 mmeineke 377
486 gezelter 415 which_node = AtomToProcMap[i];
487    
488 gezelter 416 if (which_node == mpiSim->getMyNode()) {
489 chuckv 437
490     which_atom = i;
491     local_index=-1;
492     for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
493     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
494     }
495 mmeineke 670 if (local_index != -1) {
496    
497     atoms[local_index]->getPos(pos);
498     atoms[local_index]->getVel(vel);
499    
500 chuckv 437 sprintf( tempBuffer,
501     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
502     atoms[local_index]->getType(),
503 mmeineke 670 pos[0],
504     pos[1],
505     pos[2],
506     vel[0],
507     vel[1],
508     vel[2]);
509 chuckv 437 strcpy( writeLine, tempBuffer );
510 mmeineke 377
511 chuckv 437 if( atoms[local_index]->isDirectional() ){
512    
513     dAtom = (DirectionalAtom *)atoms[local_index];
514     dAtom->getQ( q );
515    
516     sprintf( tempBuffer,
517     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
518     q[0],
519     q[1],
520     q[2],
521     q[3],
522     dAtom->getJx(),
523     dAtom->getJy(),
524     dAtom->getJz());
525     strcat( writeLine, tempBuffer );
526     }
527     else
528     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
529     }
530     else {
531 mmeineke 440 sprintf(painCave.errMsg,
532     "Atom %d not found on processor %d\n",
533     i, worldRank );
534     haveError= 1;
535     simError();
536 chuckv 437 }
537 mmeineke 440
538     if(haveError) nodeZeroError();
539 chuckv 437
540 mmeineke 440 }
541     else {
542 gezelter 415
543 mmeineke 440 myStatus = 1;
544 mmeineke 447 MPI_Send(&myStatus, 1, MPI_INT, which_node,
545     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
546     MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
547     MPI_COMM_WORLD);
548     MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
549     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
550     MPI_Recv(&myStatus, 1, MPI_INT, which_node,
551     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
552 mmeineke 440
553     if(!myStatus) nodeZeroError();
554 mmeineke 377 }
555 gezelter 415
556 mmeineke 377 finalOut << writeLine;
557     }
558    
559 gezelter 415 // kill everyone off:
560 mmeineke 440 myStatus = -1;
561     for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
562 mmeineke 447 MPI_Send(&myStatus, 1, MPI_INT, j,
563     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
564 mmeineke 377 }
565    
566 gezelter 415 } else {
567    
568     done = 0;
569     while (!done) {
570 mmeineke 440
571 mmeineke 447 MPI_Recv(&myStatus, 1, MPI_INT, 0,
572     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
573 mmeineke 440
574     if(!myStatus) anonymousNodeDie();
575    
576     if(myStatus < 0) break;
577    
578 mmeineke 447 MPI_Recv(&which_atom, 1, MPI_INT, 0,
579     TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
580 mmeineke 440
581     myStatus = 1;
582     local_index=-1;
583     for (j=0; j < mpiSim->getMyNlocal(); j++) {
584     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
585     }
586     if (local_index != -1) {
587 mmeineke 377
588 mmeineke 670 atoms[local_index]->getPos(pos);
589     atoms[local_index]->getVel(vel);
590    
591 mmeineke 440 //format the line
592     sprintf( tempBuffer,
593     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
594     atoms[local_index]->getType(),
595 mmeineke 670 pos[0],
596     pos[1],
597     pos[2],
598     vel[0],
599     vel[1],
600     vel[2]); // check here.
601 mmeineke 440 strcpy( writeLine, tempBuffer );
602    
603     if( atoms[local_index]->isDirectional() ){
604 mmeineke 377
605 mmeineke 440 dAtom = (DirectionalAtom *)atoms[local_index];
606     dAtom->getQ( q );
607    
608     sprintf( tempBuffer,
609     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
610     q[0],
611     q[1],
612     q[2],
613     q[3],
614     dAtom->getJx(),
615     dAtom->getJy(),
616     dAtom->getJz());
617     strcat( writeLine, tempBuffer );
618     }
619     else{
620     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
621     }
622     }
623     else {
624     sprintf(painCave.errMsg,
625     "Atom %d not found on processor %d\n",
626     which_atom, worldRank );
627     myStatus = 0;
628     simError();
629    
630     strcpy( writeLine, "Hello, I'm an error.\n");
631 mmeineke 377 }
632 mmeineke 440
633 mmeineke 447 MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
634     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
635     MPI_Send( &myStatus, 1, MPI_INT, 0,
636     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
637 mmeineke 377 }
638 gezelter 419 }
639 gezelter 415 finalOut.flush();
640     sprintf( checkPointMsg,
641     "Sucessfully took a dump.\n");
642     MPIcheckPoint();
643 mmeineke 440
644 gezelter 415 if( worldRank == 0 ) finalOut.close();
645 mmeineke 377 #endif // is_mpi
646     }
647 mmeineke 440
648    
649    
650     #ifdef IS_MPI
651    
652     // a couple of functions to let us escape the write loop
653    
654     void dWrite::nodeZeroError( void ){
655     int j, myStatus;
656    
657     myStatus = 0;
658     for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
659 mmeineke 447 MPI_Send( &myStatus, 1, MPI_INT, j,
660     TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
661 mmeineke 440 }
662    
663    
664     MPI_Finalize();
665     exit (0);
666    
667     }
668    
669     void dWrite::anonymousNodeDie( void ){
670    
671     MPI_Finalize();
672     exit (0);
673     }
674    
675     #endif //is_mpi