ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DumpWriter.cpp
Revision: 787
Committed: Thu Sep 25 19:27:15 2003 UTC (20 years, 9 months ago) by mmeineke
File size: 15165 byte(s)
Log Message: 
cleaned things with gcc -Wall and g++ -Wall

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