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 1152 by tim, Mon May 10 20:28:14 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 216 | Line 216 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
216  
217    int nProc;
218    int j, which_node, done, which_atom, local_index, currentIndex;
219 <  double atomData6[6];
220 <  double atomData13[13];
219 >  double atomData[13];
220    int isDirectional;
221    char* atomTypeString;
222    char MPIatomTypeString[MINIBUFFERSIZE];
223    int nObjects;
224 +  int msgLen; // the length of message actually recieved at master nodes
225   #endif //is_mpi
226  
227    double q[4], ji[3];
# Line 366 | Line 366 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
366            // so wrap this processor potato back to 0:        
367  
368            potatoes[which_node] = 0;          
369 <          MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
369 >          MPI_Send(&potatoes[which_node], 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
370            
371          }
372  
# Line 375 | Line 375 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
375          //recieve the number of integrableObject in current molecule
376          MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
377                   myPotato, MPI_COMM_WORLD, &istatus);
378 +        myPotato++;
379          
380          for(int l = 0; l < nCurObj; l++){
381  
382 <          if (potatoes[which_node] + 3 >= MAXTAG) {
382 >          if (potatoes[which_node] + 2 >= MAXTAG) {
383              // The potato was going to exceed the maximum value,
384              // so wrap this processor potato back to 0:        
385  
386              potatoes[which_node] = 0;          
387 <            MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
387 >            MPI_Send(&potatoes[which_node], 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
388              
389            }
390  
# Line 394 | Line 395 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
395  
396            myPotato++;
397  
398 <          MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
398 <          myPotato, MPI_COMM_WORLD, &istatus);
399 <              
398 >          MPI_Recv(atomData, 13, MPI_DOUBLE, which_node, myPotato, MPI_COMM_WORLD, &istatus);
399            myPotato++;
400  
401 <          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);          
408 <          }
401 >          MPI_Get_count(&istatus, MPI_DOUBLE, &msgLen);
402  
403 <          myPotato++;
403 >          if(msgLen  == 13)
404 >            isDirectional = 1;
405 >          else
406 >            isDirectional = 0;
407 >            
408          }
409          potatoes[which_node] = myPotato;
410  
# Line 426 | Line 423 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
423              sd->getPos(pos);
424              sd->getVel(vel);          
425            
426 <            atomData6[0] = pos[0];
427 <            atomData6[1] = pos[1];
428 <            atomData6[2] = pos[2];
426 >            atomData[0] = pos[0];
427 >            atomData[1] = pos[1];
428 >            atomData[2] = pos[2];
429  
430 <            atomData6[3] = vel[0];
431 <            atomData6[4] = vel[1];
432 <            atomData6[5] = vel[2];
430 >            atomData[3] = vel[0];
431 >            atomData[4] = vel[1];
432 >            atomData[5] = vel[2];
433                
434              isDirectional = 0;
435  
# Line 444 | Line 441 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
441                sd->getJ( ji );
442  
443                for (int j = 0; j < 6 ; j++)
444 <                atomData13[j] = atomData6[j];            
444 >                atomData[j] = atomData[j];            
445                
446 <              atomData13[6] = q[0];
447 <              atomData13[7] = q[1];
448 <              atomData13[8] = q[2];
449 <              atomData13[9] = q[3];
446 >              atomData[6] = q[0];
447 >              atomData[7] = q[1];
448 >              atomData[8] = q[2];
449 >              atomData[9] = q[3];
450                
451 <              atomData13[10] = ji[0];
452 <              atomData13[11] = ji[1];
453 <              atomData13[12] = ji[2];
451 >              atomData[10] = ji[0];
452 >              atomData[11] = ji[1];
453 >              atomData[12] = ji[2];
454              }
455              
456          }
# Line 467 | Line 464 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
464          sprintf( writeLine,
465                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
466                   atomTypeString,
467 <                 atomData6[0],
468 <                 atomData6[1],
469 <                 atomData6[2],
470 <                 atomData6[3],
471 <                 atomData6[4],
472 <                 atomData6[5]);
467 >                 atomData[0],
468 >                 atomData[1],
469 >                 atomData[2],
470 >                 atomData[3],
471 >                 atomData[4],
472 >                 atomData[5]);
473          
474          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
475          
# Line 481 | Line 478 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
478          sprintf( writeLine,
479                   "%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",
480                   atomTypeString,
481 <                 atomData13[0],
482 <                 atomData13[1],
483 <                 atomData13[2],
484 <                 atomData13[3],
485 <                 atomData13[4],
486 <                 atomData13[5],
487 <                 atomData13[6],
488 <                 atomData13[7],
489 <                 atomData13[8],
490 <                 atomData13[9],
491 <                 atomData13[10],
492 <                 atomData13[11],
493 <                 atomData13[12]);
481 >                 atomData[0],
482 >                 atomData[1],
483 >                 atomData[2],
484 >                 atomData[3],
485 >                 atomData[4],
486 >                 atomData[5],
487 >                 atomData[6],
488 >                 atomData[7],
489 >                 atomData[8],
490 >                 atomData[9],
491 >                 atomData[10],
492 >                 atomData[11],
493 >                 atomData[12]);
494          
495        }
496        
# Line 544 | Line 541 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
541                        
542            MPI_Send(&nCurObj, 1, MPI_INT, 0,
543                               myPotato, MPI_COMM_WORLD);
544 +          myPotato++;
545  
546            for( iter = integrableObjects.begin(); iter  != integrableObjects.end(); iter++){
547  
548 <            if (myPotato + 3 >= MAXTAG) {
548 >            if (myPotato + 2 >= MAXTAG) {
549            
550                // The potato was going to exceed the maximum value,
551                // so wrap this processor potato back to 0 (and block until
# Line 564 | Line 562 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
562              sd->getPos(pos);
563              sd->getVel(vel);
564  
565 <            atomData6[0] = pos[0];
566 <            atomData6[1] = pos[1];
567 <            atomData6[2] = pos[2];
565 >            atomData[0] = pos[0];
566 >            atomData[1] = pos[1];
567 >            atomData[2] = pos[2];
568  
569 <            atomData6[3] = vel[0];
570 <            atomData6[4] = vel[1];
571 <            atomData6[5] = vel[2];
569 >            atomData[3] = vel[0];
570 >            atomData[4] = vel[1];
571 >            atomData[5] = vel[2];
572                
573              isDirectional = 0;
574  
# Line 581 | Line 579 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
579                  sd->getQ( q );
580                  sd->getJ( ji );
581                  
584 –                for (int j = 0; j < 6 ; j++)
585 –                  atomData13[j] = atomData6[j];
582                  
583 <                atomData13[6] = q[0];
584 <                atomData13[7] = q[1];
585 <                atomData13[8] = q[2];
586 <                atomData13[9] = q[3];
583 >                atomData[6] = q[0];
584 >                atomData[7] = q[1];
585 >                atomData[8] = q[2];
586 >                atomData[9] = q[3];
587        
588 <                atomData13[10] = ji[0];
589 <                atomData13[11] = ji[1];
590 <                atomData13[12] = ji[2];
588 >                atomData[10] = ji[0];
589 >                atomData[11] = ji[1];
590 >                atomData[12] = ji[2];
591                }
592  
593              
# Line 604 | Line 600 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
600                               myPotato, MPI_COMM_WORLD);
601              
602              myPotato++;
607 –
608 –            MPI_Send(&isDirectional, 1, MPI_INT, 0,
609 –                             myPotato, MPI_COMM_WORLD);
603              
611 –            myPotato++;
612 –            
604              if (isDirectional) {
605  
606 <              MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
606 >              MPI_Send(atomData, 13, MPI_DOUBLE, 0,
607                         myPotato, MPI_COMM_WORLD);
608                
609              } else {
610  
611 <              MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
611 >              MPI_Send(atomData, 6, MPI_DOUBLE, 0,
612                         myPotato, MPI_COMM_WORLD);
613              }
614  
# Line 630 | Line 621 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
621          }
622        
623        }
633 –    
634 –    }
624  
625      sprintf( checkPointMsg,
626               "Sucessfully took a dump.\n");
627 <    MPIcheckPoint();        
627 >    MPIcheckPoint();                
628      
629 +    }
630 +
631 +
632    
633   #endif // is_mpi
634   }

Diff Legend

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