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 910 by gezelter, Thu Jan 8 18:05:37 2004 UTC vs.
Revision 920 by tim, Sat Jan 10 09:46:47 2004 UTC

# Line 66 | Line 66 | void DumpWriter::writeDump( double currentTime ){
66   void DumpWriter::writeDump( double currentTime ){
67  
68    const int BUFFERSIZE = 2000;
69 <  const int MINIBUFFERSIZE = 10;
69 >  const int MINIBUFFERSIZE = 100;
70  
71    char tempBuffer[BUFFERSIZE];
72    char writeLine[BUFFERSIZE];
73  
74    int i;
75 +
76   #ifdef IS_MPI
77 +  
78 +  int *potatoes;
79 +  int myPotato;
80 +
81 +  int nProc;
82    int j, which_node, done, which_atom, local_index;
83 <  double atomTransData[6];
84 <  double atomOrientData[7];
83 >  double atomData6[6];
84 >  double atomData13[13];
85    int isDirectional;
86    char* atomTypeString;
87    char MPIatomTypeString[MINIBUFFERSIZE];
88 <  int me;
83 <  int atomTypeTag;
84 <  int atomIsDirectionalTag;
85 <  int atomTransDataTag;
86 <  int atomOrientDataTag;
88 >
89   #else //is_mpi
90    int nAtoms = entry_plug->n_atoms;
91   #endif //is_mpi
# Line 158 | Line 160 | void DumpWriter::writeDump( double currentTime ){
160  
161   #else // is_mpi
162  
163 <  // first thing first, suspend fatalities.
164 <  painCave.isEventLoop = 1;
163 >  /* code to find maximum tag value */
164 >  
165 >  int *tagub, flag, MAXTAG;
166 >  MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
167 >  if (flag) {
168 >    MAXTAG = *tagub;
169 >  } else {
170 >    MAXTAG = 32767;
171 >  }  
172  
164 –  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
173    int haveError;
174  
175    MPI_Status istatus;
# Line 170 | Line 178 | void DumpWriter::writeDump( double currentTime ){
178    // write out header and node 0's coordinates
179  
180    if( worldRank == 0 ){
181 +
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      outFile << mpiSim->getTotAtoms() << "\n";
191  
192      outFile << currentTime << ";\t"
# Line 188 | Line 205 | void DumpWriter::writeDump( double currentTime ){
205      outFile << entry_plug->the_integrator->getAdditionalParameters();
206      outFile << endl;
207      outFile.flush();
208 +
209      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
210 +      
211        // Get the Node number which has this atom;
212 <
212 >      
213        which_node = AtomToProcMap[i];
214 <
214 >      
215        if (which_node != 0) {
197 –        
198 –        atomTypeTag          = 4*i;
199 –        atomIsDirectionalTag = 4*i + 1;
200 –        atomTransDataTag     = 4*i + 2;
201 –        atomOrientDataTag    = 4*i + 3;
216  
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 +        
228          MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
229 <                 atomTypeTag, MPI_COMM_WORLD, &istatus);
229 >                 myPotato, MPI_COMM_WORLD, &istatus);
230          
231 <        strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
207 <
208 <        MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
209 <                 atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
231 >        //strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
232          
233 <        MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
212 <                 atomTransDataTag, MPI_COMM_WORLD, &istatus);
233 >        // Null terminate the atomTypeString just in case:
234  
235 <        if (isDirectional) {
235 >        //atomTypeString[strlen(atomTypeString) - 1] = '\0';
236 >        atomTypeString = MPIatomTypeString;
237 >        
238 >        myPotato++;
239  
240 <          MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
241 <                   atomOrientDataTag, MPI_COMM_WORLD, &istatus);
240 >        MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
241 >                 myPotato, MPI_COMM_WORLD, &istatus);
242 >              
243 >        myPotato++;
244  
245 +        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          }
252 +        
253 +        myPotato++;
254 +        potatoes[which_node] = myPotato;
255  
256        } else {
257          
258          haveError = 0;
259          which_atom = i;
260          local_index=-1;
261 <
261 >        
262          for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
263            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
264          }
265 <
265 >        
266          if (local_index != -1) {
267 <
267 >          
268            atomTypeString = atoms[local_index]->getType();
269  
270            atoms[local_index]->getPos(pos);
271 <          atoms[local_index]->getVel(vel);
271 >          atoms[local_index]->getVel(vel);          
272  
273 <          atomTransData[0] = pos[0];
274 <          atomTransData[1] = pos[1];
275 <          atomTransData[2] = pos[2];
273 >          atomData6[0] = pos[0];
274 >          atomData6[1] = pos[1];
275 >          atomData6[2] = pos[2];
276  
277 <          atomTransData[3] = vel[0];
278 <          atomTransData[4] = vel[1];
279 <          atomTransData[5] = vel[2];
277 >          atomData6[3] = vel[0];
278 >          atomData6[4] = vel[1];
279 >          atomData6[5] = vel[2];
280            
281            isDirectional = 0;
282  
# Line 251 | Line 286 | void DumpWriter::writeDump( double currentTime ){
286              
287              dAtom = (DirectionalAtom *)atoms[local_index];
288              dAtom->getQ( q );
254 –            
255 –            atomOrientData[0] = q[0];
256 –            atomOrientData[1] = q[1];
257 –            atomOrientData[2] = q[2];
258 –            atomOrientData[3] = q[3];
289  
290 <            atomOrientData[4] = dAtom->getJx();
291 <            atomOrientData[5] = dAtom->getJy();
292 <            atomOrientData[6] = dAtom->getJz();
290 >            for (int j = 0; j < 6 ; j++)
291 >              atomData13[j] = atomData6[j];            
292 >            
293 >            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            }
302 <
302 >          
303          } else {
304            sprintf(painCave.errMsg,
305                    "Atom %d not found on processor %d\n",
# Line 269 | Line 307 | void DumpWriter::writeDump( double currentTime ){
307            haveError= 1;
308            simError();
309          }
310 <
310 >        
311          if(haveError) DieDieDie();
312 <                              
312 >        
313          // If we've survived to here, format the line:
314          
315 <        sprintf( tempBuffer,
278 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
279 <                 atomTypeString,
280 <                 atomTransData[0],
281 <                 atomTransData[1],
282 <                 atomTransData[2],
283 <                 atomTransData[3],
284 <                 atomTransData[4],
285 <                 atomTransData[5]);
315 >        if (!isDirectional) {
316  
317 <        strcpy( writeLine, tempBuffer );
318 <
319 <        if (isDirectional) {
317 >          sprintf( tempBuffer,
318 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
319 >                   atomTypeString,
320 >                   atomData6[0],
321 >                   atomData6[1],
322 >                   atomData6[2],
323 >                   atomData6[3],
324 >                   atomData6[4],
325 >                   atomData6[5]);
326 >          
327 >          strcpy( writeLine, tempBuffer );
328 >          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
329  
330 +        } else {
331 +          
332            sprintf( tempBuffer,
333 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
334 <                   atomOrientData[0],
335 <                   atomOrientData[1],
336 <                   atomOrientData[2],
337 <                   atomOrientData[3],
338 <                   atomOrientData[4],
339 <                   atomOrientData[5],
340 <                   atomOrientData[6]);
333 >                   "%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",
334 >                   atomTypeString,
335 >                   atomData13[0],
336 >                   atomData13[1],
337 >                   atomData13[2],
338 >                   atomData13[3],
339 >                   atomData13[4],
340 >                   atomData13[5],
341 >                   atomData13[6],
342 >                   atomData13[7],
343 >                   atomData13[8],
344 >                   atomData13[9],
345 >                   atomData13[10],
346 >                   atomData13[11],
347 >                   atomData13[12]);
348 >          
349            strcat( writeLine, tempBuffer );
350 <
302 <        } else {
303 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
350 >          
351          }
352 <
352 >        
353          outFile << writeLine;
354          outFile.flush();
355        }
# Line 312 | Line 359 | void DumpWriter::writeDump( double currentTime ){
359      sprintf( checkPointMsg,
360               "Sucessfully took a dump.\n");
361      MPIcheckPoint();        
362 <    
362 >    delete[] potatoes;
363    } else {
364  
365      // worldRank != 0, so I'm a remote node.  
366 +
367 +    // Set my magic potato to 0:
368 +
369 +    myPotato = 0;
370      
371      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
372        
# Line 323 | Line 374 | void DumpWriter::writeDump( double currentTime ){
374        
375        if (AtomToProcMap[i] == worldRank) {
376  
377 <        local_index=-1;
377 >        if (myPotato + 3 >= MAXTAG) {
378 >
379 >          // The potato was going to exceed the maximum value,
380 >          // so wrap this processor potato back to 0 (and block until
381 >          // node 0 says we can go:
382 >
383 >          MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
384 >          
385 >        }
386 >        which_atom = i;
387 >        local_index=-1;
388          for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
389            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
390          }
# Line 334 | Line 395 | void DumpWriter::writeDump( double currentTime ){
395            atoms[local_index]->getPos(pos);
396            atoms[local_index]->getVel(vel);
397  
398 <          atomTransData[0] = pos[0];
399 <          atomTransData[1] = pos[1];
400 <          atomTransData[2] = pos[2];
398 >          atomData6[0] = pos[0];
399 >          atomData6[1] = pos[1];
400 >          atomData6[2] = pos[2];
401  
402 <          atomTransData[3] = vel[0];
403 <          atomTransData[4] = vel[1];
404 <          atomTransData[5] = vel[2];
402 >          atomData6[3] = vel[0];
403 >          atomData6[4] = vel[1];
404 >          atomData6[5] = vel[2];
405            
406            isDirectional = 0;
407  
# Line 351 | Line 412 | void DumpWriter::writeDump( double currentTime ){
412              dAtom = (DirectionalAtom *)atoms[local_index];
413              dAtom->getQ( q );
414              
415 <            atomOrientData[0] = q[0];
416 <            atomOrientData[1] = q[1];
417 <            atomOrientData[2] = q[2];
418 <            atomOrientData[3] = q[3];
415 >            for (int j = 0; j < 6 ; j++)
416 >              atomData13[j] = atomData6[j];
417 >            
418 >            atomData13[6] = q[0];
419 >            atomData13[7] = q[1];
420 >            atomData13[8] = q[2];
421 >            atomData13[9] = q[3];
422  
423 <            atomOrientData[4] = dAtom->getJx();
424 <            atomOrientData[5] = dAtom->getJy();
425 <            atomOrientData[6] = dAtom->getJz();
423 >            atomData13[10] = dAtom->getJx();
424 >            atomData13[11] = dAtom->getJy();
425 >            atomData13[12] = dAtom->getJz();
426            }
427  
428          } else {
# Line 369 | Line 433 | void DumpWriter::writeDump( double currentTime ){
433            simError();
434          }
435  
372 –        // I've survived this far, so send off the data!
373 –
374 –        atomTypeTag          = 4*i;
375 –        atomIsDirectionalTag = 4*i + 1;
376 –        atomTransDataTag     = 4*i + 2;
377 –        atomOrientDataTag    = 4*i + 3;
378 –
379 –
436          strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
437  
438 +        // null terminate the string before sending (just in case):
439 +        MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
440 +
441          MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
442 <                 atomTypeTag, MPI_COMM_WORLD);
442 >                 myPotato, MPI_COMM_WORLD);
443          
444 +        myPotato++;
445 +
446          MPI_Send(&isDirectional, 1, MPI_INT, 0,
447 <                 atomIsDirectionalTag, MPI_COMM_WORLD);
447 >                 myPotato, MPI_COMM_WORLD);
448          
449 <        MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
450 <                 atomTransDataTag, MPI_COMM_WORLD);
390 <
449 >        myPotato++;
450 >        
451          if (isDirectional) {
452  
453 <          MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
454 <                   atomOrientDataTag, MPI_COMM_WORLD);
453 >          MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
454 >                   myPotato, MPI_COMM_WORLD);
455            
456 +        } else {
457 +
458 +          MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
459 +                   myPotato, MPI_COMM_WORLD);
460          }
461 <      
461 >
462 >        myPotato++;      
463        }
464      }
465  
# Line 402 | Line 467 | void DumpWriter::writeDump( double currentTime ){
467               "Sucessfully took a dump.\n");
468      MPIcheckPoint();        
469      
470 <  }
470 >  }
471    
407 –  painCave.isEventLoop = 0;
408 –
472   #endif // is_mpi
473   }
474  
# Line 415 | Line 478 | void DumpWriter::writeFinal(double finalTime){
478    ofstream finalOut;
479  
480    const int BUFFERSIZE = 2000;
481 <  const int MINIBUFFERSIZE = 10;
481 >  const int MINIBUFFERSIZE = 100;
482    char tempBuffer[BUFFERSIZE];
483    char writeLine[BUFFERSIZE];
484  
# Line 424 | Line 487 | void DumpWriter::writeFinal(double finalTime){
487    Atom** atoms = entry_plug->atoms;
488    int i;
489   #ifdef IS_MPI
490 +  
491 +  int *potatoes;
492 +  int myPotato;
493 +
494 +  int nProc;
495    int j, which_node, done, which_atom, local_index;
496 <  double atomTransData[6];
497 <  double atomOrientData[7];
496 >  double atomData6[6];
497 >  double atomData13[13];
498    int isDirectional;
499    char* atomTypeString;
500    char MPIatomTypeString[MINIBUFFERSIZE];
501 <  int atomTypeTag;
434 <  int atomIsDirectionalTag;
435 <  int atomTransDataTag;
436 <  int atomOrientDataTag;
501 >
502   #else //is_mpi
503    int nAtoms = entry_plug->n_atoms;
504   #endif //is_mpi
# Line 529 | Line 594 | void DumpWriter::writeFinal(double finalTime){
594  
595   #else // is_mpi
596  
597 <  // first thing first, suspend fatalities.
598 <  painCave.isEventLoop = 1;
597 >  /* code to find maximum tag value */
598 >  int *tagub, flag, MAXTAG;
599 >  MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
600 >  if (flag) {
601 >    MAXTAG = *tagub;
602 >  } else {
603 >    MAXTAG = 32767;
604 >  }  
605  
535 –  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
606    int haveError;
607  
608    MPI_Status istatus;
# Line 541 | Line 611 | void DumpWriter::writeFinal(double finalTime){
611    // write out header and node 0's coordinates
612  
613    if( worldRank == 0 ){
614 +
615 +    // Node 0 needs a list of the magic potatoes for each processor;
616 +
617 +    nProc = mpiSim->getNumberProcessors();
618 +    potatoes = new int[nProc];
619 +
620 +    for (i = 0; i < nProc; i++)
621 +      potatoes[i] = 0;
622 +    
623      finalOut << mpiSim->getTotAtoms() << "\n";
624  
625      finalOut << finalTime << ";\t"
# Line 559 | Line 638 | void DumpWriter::writeFinal(double finalTime){
638      finalOut << entry_plug->the_integrator->getAdditionalParameters();
639      finalOut << endl;
640      finalOut.flush();
641 +
642      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
643 +      
644        // Get the Node number which has this atom;
645 <
645 >      
646        which_node = AtomToProcMap[i];
647 <
647 >      
648        if (which_node != 0) {
568 –        
569 –        atomTypeTag          = 4*i;
570 –        atomIsDirectionalTag = 4*i + 1;
571 –        atomTransDataTag     = 4*i + 2;
572 –        atomOrientDataTag    = 4*i + 3;
649  
650 +        if (potatoes[which_node] + 3 >= MAXTAG) {
651 +          // The potato was going to exceed the maximum value,
652 +          // so wrap this processor potato back to 0:        
653 +
654 +          potatoes[which_node] = 0;          
655 +          MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
656 +          
657 +        }
658 +
659 +        myPotato = potatoes[which_node];        
660 +        
661          MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
662 <                 atomTypeTag, MPI_COMM_WORLD, &istatus);
662 >                 myPotato, MPI_COMM_WORLD, &istatus);
663          
664 <        strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
664 >        atomTypeString = MPIatomTypeString;
665 >                
666 >        myPotato++;
667  
668          MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
669 <                 atomIsDirectionalTag, MPI_COMM_WORLD, &istatus);
670 <        
671 <        MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node,
583 <                 atomTransDataTag, MPI_COMM_WORLD, &istatus);
669 >                 myPotato, MPI_COMM_WORLD, &istatus);
670 >              
671 >        myPotato++;
672  
673 <        if (isDirectional) {
674 <
675 <          MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node,
676 <                   atomOrientDataTag, MPI_COMM_WORLD, &istatus);
677 <
673 >        if (isDirectional) {          
674 >          MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
675 >                   myPotato, MPI_COMM_WORLD, &istatus);
676 >        } else {
677 >          MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
678 >                   myPotato, MPI_COMM_WORLD, &istatus);          
679          }
680 +        
681 +        myPotato++;
682 +        potatoes[which_node] = myPotato;
683  
684        } else {
685          
686          haveError = 0;
687          which_atom = i;
688          local_index=-1;
689 <
689 >        
690          for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
691            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
692          }
693 <
693 >        
694          if (local_index != -1) {
695 <
695 >          
696            atomTypeString = atoms[local_index]->getType();
697  
698            atoms[local_index]->getPos(pos);
699 <          atoms[local_index]->getVel(vel);
699 >          atoms[local_index]->getVel(vel);          
700  
701 <          atomTransData[0] = pos[0];
702 <          atomTransData[1] = pos[1];
703 <          atomTransData[2] = pos[2];
701 >          atomData6[0] = pos[0];
702 >          atomData6[1] = pos[1];
703 >          atomData6[2] = pos[2];
704  
705 <          atomTransData[3] = vel[0];
706 <          atomTransData[4] = vel[1];
707 <          atomTransData[5] = vel[2];
705 >          atomData6[3] = vel[0];
706 >          atomData6[4] = vel[1];
707 >          atomData6[5] = vel[2];
708            
709            isDirectional = 0;
710  
# Line 622 | Line 714 | void DumpWriter::writeFinal(double finalTime){
714              
715              dAtom = (DirectionalAtom *)atoms[local_index];
716              dAtom->getQ( q );
625 –            
626 –            atomOrientData[0] = q[0];
627 –            atomOrientData[1] = q[1];
628 –            atomOrientData[2] = q[2];
629 –            atomOrientData[3] = q[3];
717  
718 <            atomOrientData[4] = dAtom->getJx();
719 <            atomOrientData[5] = dAtom->getJy();
720 <            atomOrientData[6] = dAtom->getJz();
718 >            for (int j = 0; j < 6 ; j++)
719 >              atomData13[j] = atomData6[j];            
720 >            
721 >            atomData13[6] = q[0];
722 >            atomData13[7] = q[1];
723 >            atomData13[8] = q[2];
724 >            atomData13[9] = q[3];
725 >            
726 >            atomData13[10] = dAtom->getJx();
727 >            atomData13[11] = dAtom->getJy();
728 >            atomData13[12] = dAtom->getJz();
729            }
730 <
730 >          
731          } else {
732            sprintf(painCave.errMsg,
733                    "Atom %d not found on processor %d\n",
# Line 640 | Line 735 | void DumpWriter::writeFinal(double finalTime){
735            haveError= 1;
736            simError();
737          }
738 <
738 >        
739          if(haveError) DieDieDie();
740 <                              
740 >        
741          // If we've survived to here, format the line:
742          
743 <        sprintf( tempBuffer,
649 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
650 <                 atomTypeString,
651 <                 atomTransData[0],
652 <                 atomTransData[1],
653 <                 atomTransData[2],
654 <                 atomTransData[3],
655 <                 atomTransData[4],
656 <                 atomTransData[5]);
743 >        if (!isDirectional) {
744  
745 <        strcpy( writeLine, tempBuffer );
746 <
747 <        if (isDirectional) {
745 >          sprintf( tempBuffer,
746 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
747 >                   atomTypeString,
748 >                   atomData6[0],
749 >                   atomData6[1],
750 >                   atomData6[2],
751 >                   atomData6[3],
752 >                   atomData6[4],
753 >                   atomData6[5]);
754 >          
755 >          strcpy( writeLine, tempBuffer );
756 >          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
757  
758 +        } else {
759 +          
760            sprintf( tempBuffer,
761 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
762 <                   atomOrientData[0],
763 <                   atomOrientData[1],
764 <                   atomOrientData[2],
765 <                   atomOrientData[3],
766 <                   atomOrientData[4],
767 <                   atomOrientData[5],
768 <                   atomOrientData[6]);
761 >                   "%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",
762 >                   atomTypeString,
763 >                   atomData13[0],
764 >                   atomData13[1],
765 >                   atomData13[2],
766 >                   atomData13[3],
767 >                   atomData13[4],
768 >                   atomData13[5],
769 >                   atomData13[6],
770 >                   atomData13[7],
771 >                   atomData13[8],
772 >                   atomData13[9],
773 >                   atomData13[10],
774 >                   atomData13[11],
775 >                   atomData13[12]);
776 >          
777            strcat( writeLine, tempBuffer );
778 <
673 <        } else {
674 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
778 >          
779          }
780 <
780 >        
781          finalOut << writeLine;
782          finalOut.flush();
783        }
# Line 682 | Line 786 | void DumpWriter::writeFinal(double finalTime){
786      finalOut.flush();
787      sprintf( checkPointMsg,
788               "Sucessfully took a dump.\n");
789 +    delete[] potatoes;
790 +      
791      MPIcheckPoint();        
792      
793    } else {
794  
795      // worldRank != 0, so I'm a remote node.  
796 +
797 +    // Set my magic potato to 0:
798 +
799 +    myPotato = 0;
800      
801      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
802        
# Line 694 | Line 804 | void DumpWriter::writeFinal(double finalTime){
804        
805        if (AtomToProcMap[i] == worldRank) {
806  
807 +        if (myPotato + 3 >= MAXTAG) {
808 +
809 +          // The potato was going to exceed the maximum value,
810 +          // so wrap this processor potato back to 0 (and block until
811 +          // node 0 says we can go:
812 +
813 +          MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
814 +          
815 +        }
816 +        which_atom = i;  
817          local_index=-1;
818          for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
819            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
# Line 705 | Line 825 | void DumpWriter::writeFinal(double finalTime){
825            atoms[local_index]->getPos(pos);
826            atoms[local_index]->getVel(vel);
827  
828 <          atomTransData[0] = pos[0];
829 <          atomTransData[1] = pos[1];
830 <          atomTransData[2] = pos[2];
828 >          atomData6[0] = pos[0];
829 >          atomData6[1] = pos[1];
830 >          atomData6[2] = pos[2];
831  
832 <          atomTransData[3] = vel[0];
833 <          atomTransData[4] = vel[1];
834 <          atomTransData[5] = vel[2];
832 >          atomData6[3] = vel[0];
833 >          atomData6[4] = vel[1];
834 >          atomData6[5] = vel[2];
835            
836            isDirectional = 0;
837  
# Line 722 | Line 842 | void DumpWriter::writeFinal(double finalTime){
842              dAtom = (DirectionalAtom *)atoms[local_index];
843              dAtom->getQ( q );
844              
845 <            atomOrientData[0] = q[0];
846 <            atomOrientData[1] = q[1];
847 <            atomOrientData[2] = q[2];
848 <            atomOrientData[3] = q[3];
845 >            for (int j = 0; j < 6 ; j++)
846 >              atomData13[j] = atomData6[j];
847 >            
848 >            atomData13[6] = q[0];
849 >            atomData13[7] = q[1];
850 >            atomData13[8] = q[2];
851 >            atomData13[9] = q[3];
852  
853 <            atomOrientData[4] = dAtom->getJx();
854 <            atomOrientData[5] = dAtom->getJy();
855 <            atomOrientData[6] = dAtom->getJz();
853 >            atomData13[10] = dAtom->getJx();
854 >            atomData13[11] = dAtom->getJy();
855 >            atomData13[12] = dAtom->getJz();
856            }
857  
858          } else {
# Line 740 | Line 863 | void DumpWriter::writeFinal(double finalTime){
863            simError();
864          }
865  
743 –        // I've survived this far, so send off the data!
744 –
745 –        atomTypeTag          = 4*i;
746 –        atomIsDirectionalTag = 4*i + 1;
747 –        atomTransDataTag     = 4*i + 2;
748 –        atomOrientDataTag    = 4*i + 3;
749 –
866          strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
867  
868 +        // null terminate the string before sending (just in case):
869 +        MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
870 +
871          MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
872 <                 atomTypeTag, MPI_COMM_WORLD);
872 >                 myPotato, MPI_COMM_WORLD);
873          
874 +        myPotato++;
875 +
876          MPI_Send(&isDirectional, 1, MPI_INT, 0,
877 <                 atomIsDirectionalTag, MPI_COMM_WORLD);
877 >                 myPotato, MPI_COMM_WORLD);
878          
879 <        MPI_Send(atomTransData, 6, MPI_DOUBLE, 0,
880 <                 atomTransDataTag, MPI_COMM_WORLD);
760 <
879 >        myPotato++;
880 >        
881          if (isDirectional) {
882  
883 <          MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0,
884 <                   atomOrientDataTag, MPI_COMM_WORLD);
883 >          MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
884 >                   myPotato, MPI_COMM_WORLD);
885            
886 +        } else {
887 +
888 +          MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
889 +                   myPotato, MPI_COMM_WORLD);
890          }
891 <      
891 >
892 >        myPotato++;      
893        }
894      }
895  
896      sprintf( checkPointMsg,
897 <             "Sucessfully wrote final file.\n");
897 >             "Sucessfully took a dump.\n");
898      MPIcheckPoint();        
899      
900 <  }
900 >  }
901    
777 –  painCave.isEventLoop = 0;
778 –
902    if( worldRank == 0 ) finalOut.close();
903   #endif // is_mpi
904   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines