ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DumpWriter.cpp
Revision: 927
Committed: Mon Jan 12 22:54:42 2004 UTC (20 years, 5 months ago) by tim
File size: 21384 byte(s)
Log Message: 
fix a bug in copying string

File Contents

# User Rev Content
1 mmeineke 723 #define _FILE_OFFSET_BITS 64
2    
3 gezelter 829 #include <string.h>
4 mmeineke 377 #include <iostream>
5     #include <fstream>
6    
7     #ifdef IS_MPI
8     #include <mpi.h>
9     #include "mpiSimulation.hpp"
10 mmeineke 440
11     namespace dWrite{
12 gezelter 907 void DieDieDie( void );
13 mmeineke 440 }
14    
15     using namespace dWrite;
16 mmeineke 377 #endif //is_mpi
17    
18     #include "ReadWrite.hpp"
19     #include "simError.h"
20    
21     DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
22    
23     entry_plug = the_entry_plug;
24    
25     #ifdef IS_MPI
26     if(worldRank == 0 ){
27     #endif // is_mpi
28 tim 837
29 mmeineke 377 strcpy( outName, entry_plug->sampleName );
30 tim 837
31 mmeineke 377 outFile.open(outName, ios::out | ios::trunc );
32 tim 837
33 mmeineke 377 if( !outFile ){
34 tim 837
35 mmeineke 377 sprintf( painCave.errMsg,
36     "Could not open \"%s\" for dump output.\n",
37     outName);
38     painCave.isFatal = 1;
39     simError();
40     }
41 mmeineke 469
42 mmeineke 377 //outFile.setf( ios::scientific );
43    
44     #ifdef IS_MPI
45     }
46    
47     sprintf( checkPointMsg,
48     "Sucessfully opened output file for dumping.\n");
49     MPIcheckPoint();
50     #endif // is_mpi
51     }
52    
53     DumpWriter::~DumpWriter( ){
54    
55     #ifdef IS_MPI
56     if(worldRank == 0 ){
57     #endif // is_mpi
58    
59     outFile.close();
60    
61     #ifdef IS_MPI
62     }
63     #endif // is_mpi
64     }
65    
66     void DumpWriter::writeDump( double currentTime ){
67 tim 837
68 mmeineke 377 const int BUFFERSIZE = 2000;
69 gezelter 912 const int MINIBUFFERSIZE = 100;
70 gezelter 907
71 mmeineke 377 char tempBuffer[BUFFERSIZE];
72     char writeLine[BUFFERSIZE];
73    
74 mmeineke 787 int i;
75 gezelter 916
76 mmeineke 787 #ifdef IS_MPI
77 gezelter 916
78     int *potatoes;
79     int myPotato;
80    
81     int nProc;
82 mmeineke 787 int j, which_node, done, which_atom, local_index;
83 gezelter 916 double atomData6[6];
84     double atomData13[13];
85 gezelter 907 int isDirectional;
86     char* atomTypeString;
87 gezelter 910 char MPIatomTypeString[MINIBUFFERSIZE];
88 gezelter 916
89 mmeineke 787 #else //is_mpi
90     int nAtoms = entry_plug->n_atoms;
91     #endif //is_mpi
92    
93 mmeineke 377 double q[4];
94     DirectionalAtom* dAtom;
95     Atom** atoms = entry_plug->atoms;
96 mmeineke 670 double pos[3], vel[3];
97 tim 837
98 mmeineke 804 // write current frame to the eor file
99 mmeineke 377
100 mmeineke 804 this->writeFinal( currentTime );
101    
102 mmeineke 377 #ifndef IS_MPI
103 tim 837
104 mmeineke 377 outFile << nAtoms << "\n";
105 tim 837
106     outFile << currentTime << ";\t"
107 mmeineke 590 << entry_plug->Hmat[0][0] << "\t"
108     << entry_plug->Hmat[1][0] << "\t"
109     << entry_plug->Hmat[2][0] << ";\t"
110 mmeineke 572
111 mmeineke 590 << entry_plug->Hmat[0][1] << "\t"
112     << entry_plug->Hmat[1][1] << "\t"
113     << entry_plug->Hmat[2][1] << ";\t"
114 mmeineke 572
115 mmeineke 590 << entry_plug->Hmat[0][2] << "\t"
116     << entry_plug->Hmat[1][2] << "\t"
117 tim 837 << entry_plug->Hmat[2][2] << ";";
118     //write out additional parameters, such as chi and eta
119     outFile << entry_plug->the_integrator->getAdditionalParameters();
120     outFile << endl;
121    
122 mmeineke 377 for( i=0; i<nAtoms; i++ ){
123 tim 837
124 mmeineke 670 atoms[i]->getPos(pos);
125     atoms[i]->getVel(vel);
126 mmeineke 377
127     sprintf( tempBuffer,
128     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
129     atoms[i]->getType(),
130 mmeineke 670 pos[0],
131     pos[1],
132     pos[2],
133     vel[0],
134     vel[1],
135     vel[2]);
136 mmeineke 377 strcpy( writeLine, tempBuffer );
137    
138     if( atoms[i]->isDirectional() ){
139 tim 837
140 mmeineke 377 dAtom = (DirectionalAtom *)atoms[i];
141     dAtom->getQ( q );
142 tim 837
143 mmeineke 377 sprintf( tempBuffer,
144     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
145     q[0],
146     q[1],
147     q[2],
148     q[3],
149     dAtom->getJx(),
150     dAtom->getJy(),
151     dAtom->getJz());
152     strcat( writeLine, tempBuffer );
153     }
154     else
155     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
156 tim 837
157 mmeineke 377 outFile << writeLine;
158     }
159     outFile.flush();
160    
161     #else // is_mpi
162 gezelter 416
163 chuckv 913 /* code to find maximum tag value */
164 tim 919
165 tim 920 int *tagub, flag, MAXTAG;
166 chuckv 913 MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
167     if (flag) {
168 tim 920 MAXTAG = *tagub;
169 chuckv 913 } else {
170     MAXTAG = 32767;
171 gezelter 916 }
172 mmeineke 440
173     int haveError;
174    
175 mmeineke 447 MPI_Status istatus;
176 gezelter 416 int *AtomToProcMap = mpiSim->getAtomToProcMap();
177 tim 837
178 mmeineke 377 // write out header and node 0's coordinates
179 tim 837
180 mmeineke 377 if( worldRank == 0 ){
181 gezelter 916
182     // Node 0 needs a list of the magic potatoes for each processor;
183    
184     nProc = mpiSim->getNumberProcessors();
185     potatoes = new int[nProc];
186    
187     for (i = 0; i < nProc; i++)
188     potatoes[i] = 0;
189    
190 mmeineke 377 outFile << mpiSim->getTotAtoms() << "\n";
191 tim 837
192     outFile << currentTime << ";\t"
193 gezelter 591 << entry_plug->Hmat[0][0] << "\t"
194     << entry_plug->Hmat[1][0] << "\t"
195     << entry_plug->Hmat[2][0] << ";\t"
196 tim 837
197 gezelter 591 << entry_plug->Hmat[0][1] << "\t"
198     << entry_plug->Hmat[1][1] << "\t"
199     << entry_plug->Hmat[2][1] << ";\t"
200 tim 837
201 gezelter 591 << entry_plug->Hmat[0][2] << "\t"
202     << entry_plug->Hmat[1][2] << "\t"
203 tim 837 << entry_plug->Hmat[2][2] << ";";
204    
205     outFile << entry_plug->the_integrator->getAdditionalParameters();
206     outFile << endl;
207 chuckv 434 outFile.flush();
208 chuckv 913
209 gezelter 416 for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
210 chuckv 913
211 gezelter 417 // Get the Node number which has this atom;
212 chuckv 913
213 tim 837 which_node = AtomToProcMap[i];
214 chuckv 913
215 gezelter 907 if (which_node != 0) {
216 gezelter 916
217     if (potatoes[which_node] + 3 >= MAXTAG) {
218     // The potato was going to exceed the maximum value,
219     // so wrap this processor potato back to 0:
220    
221     potatoes[which_node] = 0;
222     MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
223    
224     }
225    
226     myPotato = potatoes[which_node];
227 gezelter 907
228 gezelter 910 MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
229 gezelter 916 myPotato, MPI_COMM_WORLD, &istatus);
230 gezelter 907
231 tim 920 //strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
232 gezelter 912
233     // Null terminate the atomTypeString just in case:
234 gezelter 910
235 tim 920 //atomTypeString[strlen(atomTypeString) - 1] = '\0';
236     atomTypeString = MPIatomTypeString;
237    
238 gezelter 916 myPotato++;
239    
240 gezelter 907 MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
241 gezelter 916 myPotato, MPI_COMM_WORLD, &istatus);
242    
243     myPotato++;
244 gezelter 907
245 gezelter 916 if (isDirectional) {
246     MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
247     myPotato, MPI_COMM_WORLD, &istatus);
248     } else {
249     MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
250     myPotato, MPI_COMM_WORLD, &istatus);
251 gezelter 907 }
252 gezelter 916
253     myPotato++;
254     potatoes[which_node] = myPotato;
255 gezelter 907
256     } else {
257    
258 mmeineke 440 haveError = 0;
259 chuckv 436 which_atom = i;
260 tim 837 local_index=-1;
261 gezelter 916
262 chuckv 436 for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
263     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
264     }
265 gezelter 916
266 chuckv 436 if (local_index != -1) {
267 gezelter 916
268 gezelter 907 atomTypeString = atoms[local_index]->getType();
269    
270 mmeineke 670 atoms[local_index]->getPos(pos);
271 gezelter 916 atoms[local_index]->getVel(vel);
272 mmeineke 670
273 gezelter 916 atomData6[0] = pos[0];
274     atomData6[1] = pos[1];
275     atomData6[2] = pos[2];
276 tim 837
277 gezelter 916 atomData6[3] = vel[0];
278     atomData6[4] = vel[1];
279     atomData6[5] = vel[2];
280 gezelter 907
281     isDirectional = 0;
282    
283 chuckv 436 if( atoms[local_index]->isDirectional() ){
284 tim 837
285 gezelter 907 isDirectional = 1;
286    
287 chuckv 436 dAtom = (DirectionalAtom *)atoms[local_index];
288     dAtom->getQ( q );
289 gezelter 916
290     for (int j = 0; j < 6 ; j++)
291     atomData13[j] = atomData6[j];
292 gezelter 907
293 gezelter 916 atomData13[6] = q[0];
294     atomData13[7] = q[1];
295     atomData13[8] = q[2];
296     atomData13[9] = q[3];
297    
298     atomData13[10] = dAtom->getJx();
299     atomData13[11] = dAtom->getJy();
300     atomData13[12] = dAtom->getJz();
301 gezelter 907 }
302 gezelter 916
303 gezelter 907 } else {
304 mmeineke 440 sprintf(painCave.errMsg,
305     "Atom %d not found on processor %d\n",
306     i, worldRank );
307     haveError= 1;
308     simError();
309 tim 837 }
310 gezelter 916
311 gezelter 907 if(haveError) DieDieDie();
312 gezelter 916
313 tim 926 }
314     // If we've survived to here, format the line:
315    
316     if (!isDirectional) {
317    
318     sprintf( tempBuffer,
319     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
320     atomTypeString,
321     atomData6[0],
322     atomData6[1],
323     atomData6[2],
324     atomData6[3],
325     atomData6[4],
326     atomData6[5]);
327    
328     strcpy( writeLine, tempBuffer );
329     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
330    
331     } else {
332    
333     sprintf( tempBuffer,
334     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
335     atomTypeString,
336     atomData13[0],
337     atomData13[1],
338     atomData13[2],
339     atomData13[3],
340     atomData13[4],
341     atomData13[5],
342     atomData13[6],
343     atomData13[7],
344     atomData13[8],
345     atomData13[9],
346     atomData13[10],
347     atomData13[11],
348     atomData13[12]);
349    
350 tim 927 strcpy( writeLine, tempBuffer );
351 gezelter 907
352     }
353 tim 926
354     outFile << writeLine;
355     outFile.flush();
356 mmeineke 377 }
357 tim 926
358 mmeineke 377
359 gezelter 907 outFile.flush();
360     sprintf( checkPointMsg,
361     "Sucessfully took a dump.\n");
362     MPIcheckPoint();
363 tim 919 delete[] potatoes;
364 gezelter 415 } else {
365 tim 837
366 gezelter 907 // worldRank != 0, so I'm a remote node.
367 gezelter 916
368     // Set my magic potato to 0:
369    
370     myPotato = 0;
371 gezelter 907
372     for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
373    
374     // Am I the node which has this atom?
375    
376     if (AtomToProcMap[i] == worldRank) {
377 tim 837
378 gezelter 916 if (myPotato + 3 >= MAXTAG) {
379    
380     // The potato was going to exceed the maximum value,
381     // so wrap this processor potato back to 0 (and block until
382     // node 0 says we can go:
383    
384     MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
385    
386     }
387 tim 919 which_atom = i;
388     local_index=-1;
389 gezelter 907 for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
390     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
391     }
392     if (local_index != -1) {
393    
394     atomTypeString = atoms[local_index]->getType();
395 mmeineke 440
396 gezelter 907 atoms[local_index]->getPos(pos);
397     atoms[local_index]->getVel(vel);
398 tim 837
399 gezelter 916 atomData6[0] = pos[0];
400     atomData6[1] = pos[1];
401     atomData6[2] = pos[2];
402 mmeineke 440
403 gezelter 916 atomData6[3] = vel[0];
404     atomData6[4] = vel[1];
405     atomData6[5] = vel[2];
406 gezelter 907
407     isDirectional = 0;
408 tim 837
409 gezelter 907 if( atoms[local_index]->isDirectional() ){
410 mmeineke 670
411 gezelter 907 isDirectional = 1;
412    
413     dAtom = (DirectionalAtom *)atoms[local_index];
414     dAtom->getQ( q );
415    
416 gezelter 916 for (int j = 0; j < 6 ; j++)
417     atomData13[j] = atomData6[j];
418    
419     atomData13[6] = q[0];
420     atomData13[7] = q[1];
421     atomData13[8] = q[2];
422     atomData13[9] = q[3];
423 mmeineke 670
424 gezelter 916 atomData13[10] = dAtom->getJx();
425     atomData13[11] = dAtom->getJy();
426     atomData13[12] = dAtom->getJz();
427 gezelter 907 }
428 tim 837
429 gezelter 907 } else {
430     sprintf(painCave.errMsg,
431     "Atom %d not found on processor %d\n",
432     i, worldRank );
433     haveError= 1;
434     simError();
435     }
436 tim 837
437 gezelter 910 strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
438    
439 gezelter 912 // null terminate the string before sending (just in case):
440     MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
441    
442 gezelter 910 MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
443 gezelter 916 myPotato, MPI_COMM_WORLD);
444 gezelter 907
445 gezelter 916 myPotato++;
446    
447 gezelter 907 MPI_Send(&isDirectional, 1, MPI_INT, 0,
448 gezelter 916 myPotato, MPI_COMM_WORLD);
449 gezelter 907
450 gezelter 916 myPotato++;
451    
452 gezelter 907 if (isDirectional) {
453    
454 gezelter 916 MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
455     myPotato, MPI_COMM_WORLD);
456 gezelter 907
457 gezelter 916 } else {
458    
459     MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
460     myPotato, MPI_COMM_WORLD);
461 gezelter 907 }
462 gezelter 916
463     myPotato++;
464 mmeineke 377 }
465 gezelter 907 }
466 mmeineke 440
467 gezelter 907 sprintf( checkPointMsg,
468     "Sucessfully took a dump.\n");
469     MPIcheckPoint();
470    
471 gezelter 916 }
472 gezelter 907
473 mmeineke 377 #endif // is_mpi
474     }
475    
476 mmeineke 572 void DumpWriter::writeFinal(double finalTime){
477 gezelter 416
478 mmeineke 377 char finalName[500];
479     ofstream finalOut;
480 gezelter 416
481     const int BUFFERSIZE = 2000;
482 gezelter 912 const int MINIBUFFERSIZE = 100;
483 gezelter 416 char tempBuffer[BUFFERSIZE];
484 tim 837 char writeLine[BUFFERSIZE];
485 gezelter 416
486     double q[4];
487     DirectionalAtom* dAtom;
488 mmeineke 787 Atom** atoms = entry_plug->atoms;
489     int i;
490     #ifdef IS_MPI
491 gezelter 916
492     int *potatoes;
493     int myPotato;
494    
495     int nProc;
496 mmeineke 787 int j, which_node, done, which_atom, local_index;
497 gezelter 916 double atomData6[6];
498     double atomData13[13];
499 gezelter 907 int isDirectional;
500     char* atomTypeString;
501 gezelter 910 char MPIatomTypeString[MINIBUFFERSIZE];
502 gezelter 916
503 mmeineke 787 #else //is_mpi
504 gezelter 416 int nAtoms = entry_plug->n_atoms;
505 mmeineke 787 #endif //is_mpi
506 tim 837
507 mmeineke 670 double pos[3], vel[3];
508 tim 837
509 mmeineke 377 #ifdef IS_MPI
510     if(worldRank == 0 ){
511     #endif // is_mpi
512 tim 837
513 mmeineke 377 strcpy( finalName, entry_plug->finalName );
514 tim 837
515 mmeineke 377 finalOut.open( finalName, ios::out | ios::trunc );
516     if( !finalOut ){
517     sprintf( painCave.errMsg,
518     "Could not open \"%s\" for final dump output.\n",
519     finalName );
520     painCave.isFatal = 1;
521     simError();
522     }
523 tim 837
524 mmeineke 377 // finalOut.setf( ios::scientific );
525 tim 837
526 mmeineke 377 #ifdef IS_MPI
527     }
528 tim 837
529 mmeineke 377 sprintf(checkPointMsg,"Opened file for final configuration\n");
530 tim 837 MPIcheckPoint();
531    
532 mmeineke 377 #endif //is_mpi
533    
534 tim 837
535 mmeineke 377 #ifndef IS_MPI
536 tim 837
537 mmeineke 377 finalOut << nAtoms << "\n";
538 tim 837
539 gezelter 591 finalOut << finalTime << ";\t"
540 mmeineke 590 << entry_plug->Hmat[0][0] << "\t"
541     << entry_plug->Hmat[1][0] << "\t"
542 gezelter 591 << entry_plug->Hmat[2][0] << ";\t"
543 tim 837
544 mmeineke 590 << entry_plug->Hmat[0][1] << "\t"
545     << entry_plug->Hmat[1][1] << "\t"
546 gezelter 591 << entry_plug->Hmat[2][1] << ";\t"
547 tim 837
548 mmeineke 590 << entry_plug->Hmat[0][2] << "\t"
549     << entry_plug->Hmat[1][2] << "\t"
550 tim 837 << entry_plug->Hmat[2][2] << ";";
551    
552     //write out additional parameters, such as chi and eta
553     finalOut << entry_plug->the_integrator->getAdditionalParameters();
554     finalOut << endl;
555    
556 mmeineke 377 for( i=0; i<nAtoms; i++ ){
557 tim 837
558 mmeineke 670 atoms[i]->getPos(pos);
559     atoms[i]->getVel(vel);
560 tim 837
561 mmeineke 377 sprintf( tempBuffer,
562     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
563     atoms[i]->getType(),
564 mmeineke 670 pos[0],
565     pos[1],
566     pos[2],
567     vel[0],
568     vel[1],
569     vel[2]);
570 mmeineke 377 strcpy( writeLine, tempBuffer );
571    
572     if( atoms[i]->isDirectional() ){
573 tim 837
574 mmeineke 377 dAtom = (DirectionalAtom *)atoms[i];
575     dAtom->getQ( q );
576 tim 837
577 mmeineke 377 sprintf( tempBuffer,
578     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
579     q[0],
580     q[1],
581     q[2],
582     q[3],
583     dAtom->getJx(),
584     dAtom->getJy(),
585     dAtom->getJz());
586     strcat( writeLine, tempBuffer );
587     }
588     else
589     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
590 tim 837
591 mmeineke 377 finalOut << writeLine;
592     }
593     finalOut.flush();
594 gezelter 415 finalOut.close();
595 mmeineke 377
596     #else // is_mpi
597 tim 837
598 gezelter 916 /* code to find maximum tag value */
599     int *tagub, flag, MAXTAG;
600     MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
601     if (flag) {
602     MAXTAG = *tagub;
603     } else {
604     MAXTAG = 32767;
605     }
606 mmeineke 440
607     int haveError;
608    
609 mmeineke 447 MPI_Status istatus;
610 gezelter 416 int *AtomToProcMap = mpiSim->getAtomToProcMap();
611    
612 mmeineke 377 // write out header and node 0's coordinates
613 tim 837
614 mmeineke 377 if( worldRank == 0 ){
615 gezelter 916
616     // Node 0 needs a list of the magic potatoes for each processor;
617    
618     nProc = mpiSim->getNumberProcessors();
619     potatoes = new int[nProc];
620    
621     for (i = 0; i < nProc; i++)
622     potatoes[i] = 0;
623    
624 mmeineke 377 finalOut << mpiSim->getTotAtoms() << "\n";
625 tim 837
626 gezelter 591 finalOut << finalTime << ";\t"
627 gezelter 907 << entry_plug->Hmat[0][0] << "\t"
628     << entry_plug->Hmat[1][0] << "\t"
629     << entry_plug->Hmat[2][0] << ";\t"
630 tim 837
631 gezelter 907 << entry_plug->Hmat[0][1] << "\t"
632     << entry_plug->Hmat[1][1] << "\t"
633     << entry_plug->Hmat[2][1] << ";\t"
634 tim 837
635 gezelter 907 << entry_plug->Hmat[0][2] << "\t"
636     << entry_plug->Hmat[1][2] << "\t"
637     << entry_plug->Hmat[2][2] << ";";
638 tim 837
639     finalOut << entry_plug->the_integrator->getAdditionalParameters();
640     finalOut << endl;
641 gezelter 907 finalOut.flush();
642 gezelter 916
643 gezelter 416 for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
644 gezelter 916
645 gezelter 907 // Get the Node number which has this atom;
646 gezelter 916
647 tim 837 which_node = AtomToProcMap[i];
648 gezelter 916
649     if (which_node != 0) {
650 tim 837
651 gezelter 916 if (potatoes[which_node] + 3 >= MAXTAG) {
652     // The potato was going to exceed the maximum value,
653     // so wrap this processor potato back to 0:
654    
655     potatoes[which_node] = 0;
656     MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
657    
658     }
659    
660     myPotato = potatoes[which_node];
661 gezelter 907
662 gezelter 910 MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
663 gezelter 916 myPotato, MPI_COMM_WORLD, &istatus);
664 gezelter 907
665 tim 920 atomTypeString = MPIatomTypeString;
666    
667 gezelter 916 myPotato++;
668 gezelter 907
669 gezelter 916 MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
670     myPotato, MPI_COMM_WORLD, &istatus);
671    
672     myPotato++;
673    
674     if (isDirectional) {
675     MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
676     myPotato, MPI_COMM_WORLD, &istatus);
677     } else {
678     MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
679     myPotato, MPI_COMM_WORLD, &istatus);
680 gezelter 907 }
681 gezelter 916
682     myPotato++;
683     potatoes[which_node] = myPotato;
684 gezelter 907
685     } else {
686    
687     haveError = 0;
688 chuckv 437 which_atom = i;
689 tim 837 local_index=-1;
690 gezelter 916
691 chuckv 437 for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
692     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
693     }
694 gezelter 916
695 tim 837 if (local_index != -1) {
696 gezelter 916
697 gezelter 907 atomTypeString = atoms[local_index]->getType();
698    
699 mmeineke 670 atoms[local_index]->getPos(pos);
700 gezelter 916 atoms[local_index]->getVel(vel);
701 tim 837
702 gezelter 916 atomData6[0] = pos[0];
703     atomData6[1] = pos[1];
704     atomData6[2] = pos[2];
705 tim 837
706 gezelter 916 atomData6[3] = vel[0];
707     atomData6[4] = vel[1];
708     atomData6[5] = vel[2];
709 gezelter 907
710     isDirectional = 0;
711 tim 837
712 gezelter 907 if( atoms[local_index]->isDirectional() ){
713 tim 837
714 gezelter 907 isDirectional = 1;
715    
716     dAtom = (DirectionalAtom *)atoms[local_index];
717     dAtom->getQ( q );
718 gezelter 916
719     for (int j = 0; j < 6 ; j++)
720     atomData13[j] = atomData6[j];
721 gezelter 907
722 gezelter 916 atomData13[6] = q[0];
723     atomData13[7] = q[1];
724     atomData13[8] = q[2];
725     atomData13[9] = q[3];
726    
727     atomData13[10] = dAtom->getJx();
728     atomData13[11] = dAtom->getJy();
729     atomData13[12] = dAtom->getJz();
730 gezelter 907 }
731 gezelter 916
732 gezelter 907 } else {
733 mmeineke 440 sprintf(painCave.errMsg,
734     "Atom %d not found on processor %d\n",
735     i, worldRank );
736     haveError= 1;
737     simError();
738 tim 837 }
739 gezelter 916
740 gezelter 907 if(haveError) DieDieDie();
741 gezelter 916
742 tim 926 }
743 tim 837
744    
745 tim 926 // If we've survived to here, format the line:
746    
747     if (!isDirectional) {
748    
749     sprintf( tempBuffer,
750     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
751     atomTypeString,
752     atomData6[0],
753     atomData6[1],
754     atomData6[2],
755     atomData6[3],
756     atomData6[4],
757     atomData6[5]);
758    
759     strcpy( writeLine, tempBuffer );
760     strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
761    
762     } else {
763    
764     sprintf( tempBuffer,
765     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
766     atomTypeString,
767     atomData13[0],
768     atomData13[1],
769     atomData13[2],
770     atomData13[3],
771     atomData13[4],
772     atomData13[5],
773     atomData13[6],
774     atomData13[7],
775     atomData13[8],
776     atomData13[9],
777     atomData13[10],
778     atomData13[11],
779     atomData13[12]);
780    
781 tim 927 strcpy( writeLine, tempBuffer );
782 gezelter 916
783 gezelter 907 }
784 tim 926
785     finalOut << writeLine;
786     finalOut.flush();
787 mmeineke 377 }
788 tim 926
789 gezelter 907 finalOut.flush();
790     sprintf( checkPointMsg,
791     "Sucessfully took a dump.\n");
792 tim 919 delete[] potatoes;
793 tim 926
794 gezelter 907 MPIcheckPoint();
795    
796 gezelter 415 } else {
797 tim 837
798 gezelter 907 // worldRank != 0, so I'm a remote node.
799 gezelter 916
800     // Set my magic potato to 0:
801    
802     myPotato = 0;
803 gezelter 907
804     for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
805    
806     // Am I the node which has this atom?
807    
808     if (AtomToProcMap[i] == worldRank) {
809 mmeineke 440
810 gezelter 916 if (myPotato + 3 >= MAXTAG) {
811    
812     // The potato was going to exceed the maximum value,
813     // so wrap this processor potato back to 0 (and block until
814     // node 0 says we can go:
815    
816     MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
817    
818     }
819 tim 919 which_atom = i;
820 gezelter 907 local_index=-1;
821     for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
822     if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
823     }
824     if (local_index != -1) {
825    
826     atomTypeString = atoms[local_index]->getType();
827 tim 837
828 gezelter 907 atoms[local_index]->getPos(pos);
829     atoms[local_index]->getVel(vel);
830 tim 837
831 gezelter 916 atomData6[0] = pos[0];
832     atomData6[1] = pos[1];
833     atomData6[2] = pos[2];
834 tim 837
835 gezelter 916 atomData6[3] = vel[0];
836     atomData6[4] = vel[1];
837     atomData6[5] = vel[2];
838 gezelter 907
839     isDirectional = 0;
840 tim 837
841 gezelter 907 if( atoms[local_index]->isDirectional() ){
842 mmeineke 377
843 gezelter 907 isDirectional = 1;
844    
845     dAtom = (DirectionalAtom *)atoms[local_index];
846     dAtom->getQ( q );
847    
848 gezelter 916 for (int j = 0; j < 6 ; j++)
849     atomData13[j] = atomData6[j];
850    
851     atomData13[6] = q[0];
852     atomData13[7] = q[1];
853     atomData13[8] = q[2];
854     atomData13[9] = q[3];
855 mmeineke 670
856 gezelter 916 atomData13[10] = dAtom->getJx();
857     atomData13[11] = dAtom->getJy();
858     atomData13[12] = dAtom->getJz();
859 gezelter 907 }
860 tim 837
861 gezelter 907 } else {
862     sprintf(painCave.errMsg,
863     "Atom %d not found on processor %d\n",
864     i, worldRank );
865     haveError= 1;
866     simError();
867     }
868 tim 837
869 gezelter 916 strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
870 tim 837
871 gezelter 916 // null terminate the string before sending (just in case):
872     MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
873 tim 837
874 gezelter 910 MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
875 gezelter 916 myPotato, MPI_COMM_WORLD);
876 gezelter 907
877 gezelter 916 myPotato++;
878    
879 gezelter 907 MPI_Send(&isDirectional, 1, MPI_INT, 0,
880 gezelter 916 myPotato, MPI_COMM_WORLD);
881 gezelter 907
882 gezelter 916 myPotato++;
883    
884 gezelter 907 if (isDirectional) {
885    
886 gezelter 916 MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
887     myPotato, MPI_COMM_WORLD);
888 gezelter 907
889 gezelter 916 } else {
890    
891     MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
892     myPotato, MPI_COMM_WORLD);
893 gezelter 907 }
894 gezelter 916
895     myPotato++;
896 mmeineke 377 }
897 gezelter 907 }
898 mmeineke 440
899 gezelter 907 sprintf( checkPointMsg,
900 gezelter 916 "Sucessfully took a dump.\n");
901 gezelter 907 MPIcheckPoint();
902    
903 gezelter 916 }
904 gezelter 907
905 tim 837 if( worldRank == 0 ) finalOut.close();
906 mmeineke 377 #endif // is_mpi
907     }
908 mmeineke 440
909    
910    
911     #ifdef IS_MPI
912    
913     // a couple of functions to let us escape the write loop
914    
915 gezelter 907 void dWrite::DieDieDie( void ){
916 tim 837
917 mmeineke 440 MPI_Finalize();
918     exit (0);
919     }
920    
921     #endif //is_mpi