ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/io/DumpWriter.cpp
(Generate patch)

Comparing branches/development/src/io/DumpWriter.cpp (file contents):
Revision 1769 by gezelter, Mon Jul 9 14:15:52 2012 UTC vs.
Revision 1875 by gezelter, Fri May 17 14:41:42 2013 UTC

# Line 35 | Line 35
35   *                                                                      
36   * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37   * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 < * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39   * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40   * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
# Line 302 | Line 302 | namespace OpenMD {
302    void DumpWriter::writeFrame(std::ostream& os) {
303  
304   #ifdef IS_MPI
305 <    MPI_Status istatus;
305 >    MPI::Status istatus;
306   #endif
307  
308      Molecule* mol;
# Line 310 | Line 310 | namespace OpenMD {
310      SimInfo::MoleculeIterator mi;
311      Molecule::IntegrableObjectIterator ii;
312      RigidBody::AtomIterator ai;
313 –    Atom* atom;
313  
314   #ifndef IS_MPI
315      os << "  <Snapshot>\n";
# Line 318 | Line 317 | namespace OpenMD {
317      writeFrameProperties(os, info_->getSnapshotManager()->getCurrentSnapshot());
318  
319      os << "    <StuntDoubles>\n";
320 <    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
321 <
320 >    for (mol = info_->beginMolecule(mi); mol != NULL;
321 >         mol = info_->nextMolecule(mi)) {
322        
323        for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
324             sd = mol->nextIntegrableObject(ii)) {        
# Line 331 | Line 330 | namespace OpenMD {
330  
331      if (doSiteData_) {
332        os << "    <SiteData>\n";
333 <      for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
333 >      for (mol = info_->beginMolecule(mi); mol != NULL;
334 >           mol = info_->nextMolecule(mi)) {
335                
336          for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
337             sd = mol->nextIntegrableObject(ii)) {        
# Line 344 | Line 344 | namespace OpenMD {
344              
345              RigidBody* rb = static_cast<RigidBody*>(sd);
346              int siteIndex = 0;
347 <            for (atom = rb->beginAtom(ai); atom != NULL;  
347 >            for (Atom* atom = rb->beginAtom(ai); atom != NULL;  
348                   atom = rb->nextAtom(ai)) {                                            
349                os << prepareSiteLine(atom, ioIndex, siteIndex);
350                siteIndex++;
# Line 358 | Line 358 | namespace OpenMD {
358  
359      os.flush();
360   #else
361 –    //every node prepares the dump lines for integrable objects belong to itself
362 –    std::string buffer;
363 –    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
361  
362 +    const int masterNode = 0;
363 +    int worldRank = MPI::COMM_WORLD.Get_rank();
364 +    int nProc = MPI::COMM_WORLD.Get_size();
365 +
366 +    if (worldRank == masterNode) {      
367 +      os << "  <Snapshot>\n";  
368 +      writeFrameProperties(os,
369 +                           info_->getSnapshotManager()->getCurrentSnapshot());
370 +      os << "    <StuntDoubles>\n";
371 +    }
372  
373 +    //every node prepares the dump lines for integrable objects belong to itself
374 +    std::string buffer;
375 +    for (mol = info_->beginMolecule(mi); mol != NULL;
376 +         mol = info_->nextMolecule(mi)) {
377        for (sd = mol->beginIntegrableObject(ii); sd != NULL;
378             sd = mol->nextIntegrableObject(ii)) {        
379 <          buffer += prepareDumpLine(sd);
379 >        buffer += prepareDumpLine(sd);
380        }
381      }
382      
372 –    const int masterNode = 0;
373 –    int nProc;
374 –    MPI_Comm_size(MPI_COMM_WORLD, &nProc);
383      if (worldRank == masterNode) {      
376 –      os << "  <Snapshot>\n";  
377 –      writeFrameProperties(os, info_->getSnapshotManager()->getCurrentSnapshot());
378 –      os << "    <StuntDoubles>\n";
379 –        
384        os << buffer;
385 <
385 >      
386        for (int i = 1; i < nProc; ++i) {
387 +        // tell processor i to start sending us data:
388 +        MPI::COMM_WORLD.Bcast(&i, 1, MPI::INT, masterNode);
389  
390          // receive the length of the string buffer that was
391 <        // prepared by processor i
391 >        // prepared by processor i:        
392 >        int recvLength;
393 >        MPI::COMM_WORLD.Recv(&recvLength, 1, MPI::INT, i, MPI::ANY_TAG,
394 >                             istatus);
395  
396 <        MPI_Bcast(&i, 1, MPI_INT,masterNode,MPI_COMM_WORLD);
388 <        int recvLength;
389 <        MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &istatus);
396 >        // create a buffer to receive the data
397          char* recvBuffer = new char[recvLength];
398          if (recvBuffer == NULL) {
399          } else {
400 <          MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD, &istatus);
400 >          // receive the data:
401 >          MPI::COMM_WORLD.Recv(recvBuffer, recvLength, MPI::CHAR, i,
402 >                               MPI::ANY_TAG, istatus);
403 >          // send it to the file:
404            os << recvBuffer;
405 +          // get rid of the receive buffer:
406            delete [] recvBuffer;
407          }
408        }
398 –      os << "    </StuntDoubles>\n";
399 –      
400 –      os << "  </Snapshot>\n";
401 –      os.flush();
409      } else {
410        int sendBufferLength = buffer.size() + 1;
411        int myturn = 0;
412        for (int i = 1; i < nProc; ++i){
413 <        MPI_Bcast(&myturn,1, MPI_INT,masterNode,MPI_COMM_WORLD);
413 >        // wait for the master node to call our number:
414 >        MPI::COMM_WORLD.Bcast(&myturn, 1, MPI::INT, masterNode);
415          if (myturn == worldRank){
416 <          MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
417 <          MPI_Send((void *)buffer.c_str(), sendBufferLength, MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
416 >          // send the length of our buffer:
417 >          MPI::COMM_WORLD.Send(&sendBufferLength, 1, MPI::INT, masterNode, 0);
418 >
419 >          // send our buffer:
420 >          MPI::COMM_WORLD.Send((void *)buffer.c_str(), sendBufferLength,
421 >                               MPI::CHAR, masterNode, 0);
422          }
423        }
424      }
425 +    
426 +    if (worldRank == masterNode) {      
427 +      os << "    </StuntDoubles>\n";
428 +    }
429  
430 < #endif // is_mpi
430 >    if (doSiteData_) {
431 >      if (worldRank == masterNode) {
432 >        os << "    <SiteData>\n";
433 >      }
434 >      buffer.clear();
435 >      for (mol = info_->beginMolecule(mi); mol != NULL;
436 >           mol = info_->nextMolecule(mi)) {
437 >              
438 >        for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
439 >             sd = mol->nextIntegrableObject(ii)) {      
440 >          
441 >          int ioIndex = sd->getGlobalIntegrableObjectIndex();
442 >          // do one for the IO itself
443 >          buffer += prepareSiteLine(sd, ioIndex, 0);
444  
445 +          if (sd->isRigidBody()) {
446 +            
447 +            RigidBody* rb = static_cast<RigidBody*>(sd);
448 +            int siteIndex = 0;
449 +            for (Atom* atom = rb->beginAtom(ai); atom != NULL;  
450 +                 atom = rb->nextAtom(ai)) {                                            
451 +              buffer += prepareSiteLine(atom, ioIndex, siteIndex);
452 +              siteIndex++;
453 +            }
454 +          }
455 +        }
456 +      }
457 +
458 +      if (worldRank == masterNode) {    
459 +        os << buffer;
460 +        
461 +        for (int i = 1; i < nProc; ++i) {
462 +          
463 +          // tell processor i to start sending us data:
464 +          MPI::COMM_WORLD.Bcast(&i, 1, MPI::INT, masterNode);
465 +          
466 +          // receive the length of the string buffer that was
467 +          // prepared by processor i:        
468 +          int recvLength;
469 +          MPI::COMM_WORLD.Recv(&recvLength, 1, MPI::INT, i, MPI::ANY_TAG,
470 +                               istatus);
471 +          
472 +          // create a buffer to receive the data
473 +          char* recvBuffer = new char[recvLength];
474 +          if (recvBuffer == NULL) {
475 +          } else {
476 +            // receive the data:
477 +            MPI::COMM_WORLD.Recv(recvBuffer, recvLength, MPI::CHAR, i,
478 +                                 MPI::ANY_TAG, istatus);
479 +            // send it to the file:
480 +            os << recvBuffer;
481 +            // get rid of the receive buffer:
482 +            delete [] recvBuffer;
483 +          }
484 +        }      
485 +      } else {
486 +        int sendBufferLength = buffer.size() + 1;
487 +        int myturn = 0;
488 +        for (int i = 1; i < nProc; ++i){
489 +          // wait for the master node to call our number:
490 +          MPI::COMM_WORLD.Bcast(&myturn, 1, MPI::INT, masterNode);
491 +          if (myturn == worldRank){
492 +            // send the length of our buffer:
493 +            MPI::COMM_WORLD.Send(&sendBufferLength, 1, MPI::INT, masterNode, 0);
494 +            // send our buffer:
495 +            MPI::COMM_WORLD.Send((void *)buffer.c_str(), sendBufferLength,
496 +                                 MPI::CHAR, masterNode, 0);
497 +          }
498 +        }
499 +      }
500 +      
501 +      if (worldRank == masterNode) {    
502 +        os << "    </SiteData>\n";
503 +      }
504 +    }
505 +    
506 +    if (worldRank == masterNode) {
507 +      os << "  </Snapshot>\n";
508 +      os.flush();
509 +    }
510 +    
511 + #endif // is_mpi
512 +    
513    }
514  
515    std::string DumpWriter::prepareDumpLine(StuntDouble* sd) {
# Line 628 | Line 725 | namespace OpenMD {
725   #ifdef IS_MPI
726      if (worldRank == 0) {
727   #endif // is_mpi
728 <
728 >      
729        eorStream = createOStream(eorFilename_);
730 <
730 >      writeFrame(*eorStream);
731 >      
732   #ifdef IS_MPI
733      }
636 – #endif // is_mpi    
637 –
638 –    writeFrame(*eorStream);
639 –
640 – #ifdef IS_MPI
734      if (worldRank == 0) {
735   #endif // is_mpi
736 +
737        writeClosing(*eorStream);
738        delete eorStream;
739 +
740   #ifdef IS_MPI
741      }
742   #endif // is_mpi  

Diff Legend

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