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 1108 by tim, Wed Apr 14 15:37:41 2004 UTC vs.
Revision 1252 by gezelter, Mon Jun 7 14:26:33 2004 UTC

# Line 91 | Line 91 | void DumpWriter::sortByGlobalIndex(){
91    Molecule* mols = entry_plug->molecules;  
92    indexArray.clear();
93    
94 <  for(int i = 0; i < mpiSim->getMyNlocal();i++)
94 >  for(int i = 0; i < entry_plug->n_mol;i++)
95      indexArray.push_back(make_pair(i, mols[i].getGlobalIndex()));
96    
97    sort(indexArray.begin(), indexArray.end(), indexSortingCriterion);    
# Line 170 | Line 170 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
170    char tempBuffer[BUFFERSIZE];  
171    char writeLine[BUFFERSIZE];
172  
173 <  int i, k;
173 >  int i;
174 >  unsigned int k;
175  
176   #ifdef IS_MPI
177    
# Line 216 | Line 217 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
217  
218    int nProc;
219    int j, which_node, done, which_atom, local_index, currentIndex;
220 <  double atomData6[6];
220 <  double atomData13[13];
220 >  double atomData[13];
221    int isDirectional;
222    char* atomTypeString;
223    char MPIatomTypeString[MINIBUFFERSIZE];
224    int nObjects;
225 +  int msgLen; // the length of message actually recieved at master nodes
226   #endif //is_mpi
227  
228    double q[4], ji[3];
# Line 294 | Line 295 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
295        }
296        else
297          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
298 +    
299 +      for(k = 0; k < outFile.size(); k++)
300 +        *outFile[k] << writeLine;      
301      }
302  
299 –    
300 –    for(k = 0; k < outFile.size(); k++)
301 –      *outFile[k] << writeLine;
303   }
304  
305   #else // is_mpi
# Line 325 | Line 326 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
326  
327      // Node 0 needs a list of the magic potatoes for each processor;
328  
329 <    nProc = mpiSim->getNumberProcessors();
329 >    nProc = mpiSim->getNProcessors();
330      potatoes = new int[nProc];
331  
332      //write out the comment lines
# Line 353 | Line 354 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
354  
355      currentIndex = 0;
356  
357 <    for (i = 0 ; i < mpiSim->getTotNmol(); i++ ) {
357 >    for (i = 0 ; i < mpiSim->getNMolGlobal(); i++ ) {
358        
359        // Get the Node number which has this atom;
360        
# Line 366 | Line 367 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
367            // so wrap this processor potato back to 0:        
368  
369            potatoes[which_node] = 0;          
370 <          MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
370 >          MPI_Send(&potatoes[which_node], 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
371            
372          }
373  
# Line 375 | Line 376 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
376          //recieve the number of integrableObject in current molecule
377          MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
378                   myPotato, MPI_COMM_WORLD, &istatus);
379 +        myPotato++;
380          
381          for(int l = 0; l < nCurObj; l++){
382  
383 <          if (potatoes[which_node] + 3 >= MAXTAG) {
383 >          if (potatoes[which_node] + 2 >= MAXTAG) {
384              // The potato was going to exceed the maximum value,
385              // so wrap this processor potato back to 0:        
386  
387              potatoes[which_node] = 0;          
388 <            MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
388 >            MPI_Send(&potatoes[which_node], 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
389              
390            }
391  
# Line 394 | Line 396 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
396  
397            myPotato++;
398  
399 <          MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
398 <          myPotato, MPI_COMM_WORLD, &istatus);
399 <              
399 >          MPI_Recv(atomData, 13, MPI_DOUBLE, which_node, myPotato, MPI_COMM_WORLD, &istatus);
400            myPotato++;
401  
402 <          if (isDirectional) {          
403 <          MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
404 <                   myPotato, MPI_COMM_WORLD, &istatus);
405 <          } else {
406 <          MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
407 <                   myPotato, MPI_COMM_WORLD, &istatus);          
402 >          MPI_Get_count(&istatus, MPI_DOUBLE, &msgLen);
403 >
404 >          if(msgLen  == 13)
405 >            isDirectional = 1;
406 >          else
407 >            isDirectional = 0;
408 >          
409 >          // If we've survived to here, format the line:
410 >            
411 >          if (!isDirectional) {
412 >        
413 >            sprintf( writeLine,
414 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
415 >                 atomTypeString,
416 >                 atomData[0],
417 >                 atomData[1],
418 >                 atomData[2],
419 >                 atomData[3],
420 >                 atomData[4],
421 >                 atomData[5]);
422 >        
423 >           strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
424 >        
425 >          }
426 >          else {
427 >        
428 >                sprintf( writeLine,
429 >                         "%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",
430 >                         atomTypeString,
431 >                         atomData[0],
432 >                         atomData[1],
433 >                         atomData[2],
434 >                         atomData[3],
435 >                         atomData[4],
436 >                         atomData[5],
437 >                         atomData[6],
438 >                         atomData[7],
439 >                         atomData[8],
440 >                         atomData[9],
441 >                         atomData[10],
442 >                         atomData[11],
443 >                         atomData[12]);
444 >            
445            }
446 +          
447 +          for(k = 0; k < outFile.size(); k++)
448 +            *outFile[k] << writeLine;            
449  
450 <          myPotato++;
411 <        }
450 >        }// end for(int l =0)
451          potatoes[which_node] = myPotato;
452  
453 <      } else {
453 >      }
454 >      else {
455          
456          haveError = 0;
457          
# Line 426 | Line 466 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
466              sd->getPos(pos);
467              sd->getVel(vel);          
468            
469 <            atomData6[0] = pos[0];
470 <            atomData6[1] = pos[1];
471 <            atomData6[2] = pos[2];
469 >            atomData[0] = pos[0];
470 >            atomData[1] = pos[1];
471 >            atomData[2] = pos[2];
472  
473 <            atomData6[3] = vel[0];
474 <            atomData6[4] = vel[1];
475 <            atomData6[5] = vel[2];
473 >            atomData[3] = vel[0];
474 >            atomData[4] = vel[1];
475 >            atomData[5] = vel[2];
476                
477              isDirectional = 0;
478  
# Line 444 | Line 484 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
484                sd->getJ( ji );
485  
486                for (int j = 0; j < 6 ; j++)
487 <                atomData13[j] = atomData6[j];            
487 >                atomData[j] = atomData[j];            
488                
489 <              atomData13[6] = q[0];
490 <              atomData13[7] = q[1];
491 <              atomData13[8] = q[2];
492 <              atomData13[9] = q[3];
489 >              atomData[6] = q[0];
490 >              atomData[7] = q[1];
491 >              atomData[8] = q[2];
492 >              atomData[9] = q[3];
493                
494 <              atomData13[10] = ji[0];
495 <              atomData13[11] = ji[1];
496 <              atomData13[12] = ji[2];
494 >              atomData[10] = ji[0];
495 >              atomData[11] = ji[1];
496 >              atomData[12] = ji[2];
497              }
498              
499 <        }
499 >            // If we've survived to here, format the line:
500 >            
501 >            if (!isDirectional) {
502 >        
503 >              sprintf( writeLine,
504 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
505 >                 atomTypeString,
506 >                 atomData[0],
507 >                 atomData[1],
508 >                 atomData[2],
509 >                 atomData[3],
510 >                 atomData[4],
511 >                 atomData[5]);
512 >        
513 >             strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
514 >        
515 >            }
516 >            else {
517 >        
518 >                sprintf( writeLine,
519 >                         "%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",
520 >                         atomTypeString,
521 >                         atomData[0],
522 >                         atomData[1],
523 >                         atomData[2],
524 >                         atomData[3],
525 >                         atomData[4],
526 >                         atomData[5],
527 >                         atomData[6],
528 >                         atomData[7],
529 >                         atomData[8],
530 >                         atomData[9],
531 >                         atomData[10],
532 >                         atomData[11],
533 >                         atomData[12]);
534 >              
535 >            }
536 >            
537 >            for(k = 0; k < outFile.size(); k++)
538 >              *outFile[k] << writeLine;
539 >            
540 >            
541 >        }//end for(iter = integrableObject.begin())
542          
543        currentIndex++;
544        }
545 <      // If we've survived to here, format the line:
546 <      
465 <      if (!isDirectional) {
466 <        
467 <        sprintf( writeLine,
468 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
469 <                 atomTypeString,
470 <                 atomData6[0],
471 <                 atomData6[1],
472 <                 atomData6[2],
473 <                 atomData6[3],
474 <                 atomData6[4],
475 <                 atomData6[5]);
476 <        
477 <        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
478 <        
479 <      } else {
480 <        
481 <        sprintf( writeLine,
482 <                 "%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",
483 <                 atomTypeString,
484 <                 atomData13[0],
485 <                 atomData13[1],
486 <                 atomData13[2],
487 <                 atomData13[3],
488 <                 atomData13[4],
489 <                 atomData13[5],
490 <                 atomData13[6],
491 <                 atomData13[7],
492 <                 atomData13[8],
493 <                 atomData13[9],
494 <                 atomData13[10],
495 <                 atomData13[11],
496 <                 atomData13[12]);
497 <        
498 <      }
499 <      
500 <      for(k = 0; k < outFile.size(); k++)
501 <        *outFile[k] << writeLine;
502 <    }
545 >
546 >    }//end for(i = 0; i < mpiSim->getNmol())
547      
548      for(k = 0; k < outFile.size(); k++)
549        outFile[k]->flush();
# Line 520 | Line 564 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
564      myPotato = 0;
565      currentIndex = 0;
566      
567 <    for (i = 0 ; i < mpiSim->getTotNmol(); i++ ) {
567 >    for (i = 0 ; i < mpiSim->getNMolGlobal(); i++ ) {
568        
569        // Am I the node which has this integrableObject?
570        
# Line 544 | Line 588 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
588                        
589            MPI_Send(&nCurObj, 1, MPI_INT, 0,
590                               myPotato, MPI_COMM_WORLD);
591 +          myPotato++;
592  
593            for( iter = integrableObjects.begin(); iter  != integrableObjects.end(); iter++){
594  
595 <            if (myPotato + 3 >= MAXTAG) {
595 >            if (myPotato + 2 >= MAXTAG) {
596            
597                // The potato was going to exceed the maximum value,
598                // so wrap this processor potato back to 0 (and block until
# Line 564 | Line 609 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
609              sd->getPos(pos);
610              sd->getVel(vel);
611  
612 <            atomData6[0] = pos[0];
613 <            atomData6[1] = pos[1];
614 <            atomData6[2] = pos[2];
612 >            atomData[0] = pos[0];
613 >            atomData[1] = pos[1];
614 >            atomData[2] = pos[2];
615  
616 <            atomData6[3] = vel[0];
617 <            atomData6[4] = vel[1];
618 <            atomData6[5] = vel[2];
616 >            atomData[3] = vel[0];
617 >            atomData[4] = vel[1];
618 >            atomData[5] = vel[2];
619                
620              isDirectional = 0;
621  
# Line 581 | Line 626 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
626                  sd->getQ( q );
627                  sd->getJ( ji );
628                  
584 –                for (int j = 0; j < 6 ; j++)
585 –                  atomData13[j] = atomData6[j];
629                  
630 <                atomData13[6] = q[0];
631 <                atomData13[7] = q[1];
632 <                atomData13[8] = q[2];
633 <                atomData13[9] = q[3];
630 >                atomData[6] = q[0];
631 >                atomData[7] = q[1];
632 >                atomData[8] = q[2];
633 >                atomData[9] = q[3];
634        
635 <                atomData13[10] = ji[0];
636 <                atomData13[11] = ji[1];
637 <                atomData13[12] = ji[2];
635 >                atomData[10] = ji[0];
636 >                atomData[11] = ji[1];
637 >                atomData[12] = ji[2];
638                }
639  
640              
# Line 604 | Line 647 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
647                               myPotato, MPI_COMM_WORLD);
648              
649              myPotato++;
607 –
608 –            MPI_Send(&isDirectional, 1, MPI_INT, 0,
609 –                             myPotato, MPI_COMM_WORLD);
650              
611 –            myPotato++;
612 –            
651              if (isDirectional) {
652  
653 <              MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
653 >              MPI_Send(atomData, 13, MPI_DOUBLE, 0,
654                         myPotato, MPI_COMM_WORLD);
655                
656              } else {
657  
658 <              MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
658 >              MPI_Send(atomData, 6, MPI_DOUBLE, 0,
659                         myPotato, MPI_COMM_WORLD);
660              }
661  
# Line 630 | Line 668 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
668          }
669        
670        }
633 –    
634 –    }
671  
672      sprintf( checkPointMsg,
673               "Sucessfully took a dump.\n");
674 <    MPIcheckPoint();        
674 >    MPIcheckPoint();                
675      
676 +    }
677 +
678 +
679    
680   #endif // is_mpi
681   }

Diff Legend

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