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 1752 by gezelter, Sun Jun 10 14:05:02 2012 UTC vs.
Revision 1878 by gezelter, Thu Jun 13 14:26:09 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 44 | Line 44
44   #include "primitives/Molecule.hpp"
45   #include "utils/simError.h"
46   #include "io/basic_teebuf.hpp"
47 + #ifdef HAVE_ZLIB
48   #include "io/gzstream.hpp"
49 + #endif
50   #include "io/Globals.hpp"
51  
52 + #ifdef _MSC_VER
53 + #define isnan(x) _isnan((x))
54 + #define isinf(x) (!_finite(x) && !_isnan(x))
55 + #endif
56  
57   #ifdef IS_MPI
58   #include <mpi.h>
59 < #endif //is_mpi
59 > #endif
60  
61   using namespace std;
62   namespace OpenMD {
# Line 257 | Line 263 | namespace OpenMD {
263              hmat(0, 2), hmat(1, 2), hmat(2, 2));
264      os << buffer;
265  
266 <    RealType chi = s->getChi();
267 <    RealType integralOfChiDt = s->getIntegralOfChiDt();
268 <    if (isinf(chi) || isnan(chi) ||
269 <        isinf(integralOfChiDt) || isnan(integralOfChiDt)) {      
266 >    pair<RealType, RealType> thermostat = s->getThermostat();
267 >
268 >    if (isinf(thermostat.first)  || isnan(thermostat.first) ||
269 >        isinf(thermostat.second) || isnan(thermostat.second)) {      
270        sprintf( painCave.errMsg,
271                 "DumpWriter detected a numerical error writing the thermostat");
272        painCave.isFatal = 1;
273        simError();
274      }
275 <    sprintf(buffer, "  Thermostat: %.10g , %.10g\n", chi, integralOfChiDt);
275 >    sprintf(buffer, "  Thermostat: %.10g , %.10g\n", thermostat.first,
276 >            thermostat.second);
277      os << buffer;
278  
279      Mat3x3d eta;
280 <    eta = s->getEta();
280 >    eta = s->getBarostat();
281  
282      for (unsigned int i = 0; i < 3; i++) {
283        for (unsigned int j = 0; j < 3; j++) {
# Line 295 | 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;
309 <    StuntDouble* integrableObject;
309 >    StuntDouble* sd;
310      SimInfo::MoleculeIterator mi;
311      Molecule::IntegrableObjectIterator ii;
312      RigidBody::AtomIterator ai;
306 –    Atom* atom;
313  
314   #ifndef IS_MPI
315      os << "  <Snapshot>\n";
# Line 311 | 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 (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
324 <           integrableObject = mol->nextIntegrableObject(ii)) {  
325 <          os << prepareDumpLine(integrableObject);
323 >      for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
324 >           sd = mol->nextIntegrableObject(ii)) {        
325 >          os << prepareDumpLine(sd);
326            
327        }
328      }    
# Line 324 | Line 330 | namespace OpenMD {
330  
331      if (doSiteData_) {
332        os << "    <SiteData>\n";
333 <      for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
334 <              
335 <        for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
336 <           integrableObject = mol->nextIntegrableObject(ii)) {  
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)) {        
338  
339 <          int ioIndex = integrableObject->getGlobalIntegrableObjectIndex();
339 >          int ioIndex = sd->getGlobalIntegrableObjectIndex();
340            // do one for the IO itself
341 <          os << prepareSiteLine(integrableObject, ioIndex, 0);
341 >          os << prepareSiteLine(sd, ioIndex, 0);
342  
343 <          if (integrableObject->isRigidBody()) {
343 >          if (sd->isRigidBody()) {
344              
345 <            RigidBody* rb = static_cast<RigidBody*>(integrableObject);
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 351 | Line 358 | namespace OpenMD {
358  
359      os.flush();
360   #else
354 –    //every node prepares the dump lines for integrable objects belong to itself
355 –    std::string buffer;
356 –    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 <      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
367 <           integrableObject = mol->nextIntegrableObject(ii)) {  
368 <          buffer += prepareDumpLine(integrableObject);
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);
380        }
381      }
382      
365 –    const int masterNode = 0;
366 –    int nProc;
367 –    MPI_Comm_size(MPI_COMM_WORLD, &nProc);
383      if (worldRank == masterNode) {      
369 –      os << "  <Snapshot>\n";  
370 –      writeFrameProperties(os, info_->getSnapshotManager()->getCurrentSnapshot());
371 –      os << "    <StuntDoubles>\n";
372 –        
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
379 <
380 <        MPI_Bcast(&i, 1, MPI_INT,masterNode,MPI_COMM_WORLD);
391 >        // prepared by processor i:        
392          int recvLength;
393 <        MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &istatus);
393 >        MPI::COMM_WORLD.Recv(&recvLength, 1, MPI::INT, i, MPI::ANY_TAG,
394 >                             istatus);
395 >
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        }
391 –      os << "    </StuntDoubles>\n";
392 –      
393 –      os << "  </Snapshot>\n";
394 –      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 +    
427 +    if (worldRank == masterNode) {      
428 +      os << "    </StuntDoubles>\n";
429 +    }
430  
431 < #endif // is_mpi
431 >    if (doSiteData_) {
432 >      if (worldRank == masterNode) {
433 >        os << "    <SiteData>\n";
434 >      }
435 >      buffer.clear();
436 >      for (mol = info_->beginMolecule(mi); mol != NULL;
437 >           mol = info_->nextMolecule(mi)) {
438 >              
439 >        for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
440 >             sd = mol->nextIntegrableObject(ii)) {      
441 >          
442 >          int ioIndex = sd->getGlobalIntegrableObjectIndex();
443 >          // do one for the IO itself
444 >          buffer += prepareSiteLine(sd, ioIndex, 0);
445  
446 <  }
446 >          if (sd->isRigidBody()) {
447 >            
448 >            RigidBody* rb = static_cast<RigidBody*>(sd);
449 >            int siteIndex = 0;
450 >            for (Atom* atom = rb->beginAtom(ai); atom != NULL;  
451 >                 atom = rb->nextAtom(ai)) {                                            
452 >              buffer += prepareSiteLine(atom, ioIndex, siteIndex);
453 >              siteIndex++;
454 >            }
455 >          }
456 >        }
457 >      }
458  
459 <  std::string DumpWriter::prepareDumpLine(StuntDouble* integrableObject) {
459 >      if (worldRank == masterNode) {    
460 >        os << buffer;
461 >        
462 >        for (int i = 1; i < nProc; ++i) {
463 >          
464 >          // tell processor i to start sending us data:
465 >          MPI::COMM_WORLD.Bcast(&i, 1, MPI::INT, masterNode);
466 >          
467 >          // receive the length of the string buffer that was
468 >          // prepared by processor i:        
469 >          int recvLength;
470 >          MPI::COMM_WORLD.Recv(&recvLength, 1, MPI::INT, i, MPI::ANY_TAG,
471 >                               istatus);
472 >          
473 >          // create a buffer to receive the data
474 >          char* recvBuffer = new char[recvLength];
475 >          if (recvBuffer == NULL) {
476 >          } else {
477 >            // receive the data:
478 >            MPI::COMM_WORLD.Recv(recvBuffer, recvLength, MPI::CHAR, i,
479 >                                 MPI::ANY_TAG, istatus);
480 >            // send it to the file:
481 >            os << recvBuffer;
482 >            // get rid of the receive buffer:
483 >            delete [] recvBuffer;
484 >          }
485 >        }      
486 >      } else {
487 >        int sendBufferLength = buffer.size() + 1;
488 >        int myturn = 0;
489 >        for (int i = 1; i < nProc; ++i){
490 >          // wait for the master node to call our number:
491 >          MPI::COMM_WORLD.Bcast(&myturn, 1, MPI::INT, masterNode);
492 >          if (myturn == worldRank){
493 >            // send the length of our buffer:
494 >            MPI::COMM_WORLD.Send(&sendBufferLength, 1, MPI::INT, masterNode, 0);
495 >            // send our buffer:
496 >            MPI::COMM_WORLD.Send((void *)buffer.c_str(), sendBufferLength,
497 >                                 MPI::CHAR, masterNode, 0);
498 >          }
499 >        }
500 >      }
501 >      
502 >      if (worldRank == masterNode) {    
503 >        os << "    </SiteData>\n";
504 >      }
505 >    }
506 >    
507 >    if (worldRank == masterNode) {
508 >      os << "  </Snapshot>\n";
509 >      os.flush();
510 >    }
511 >    
512 > #endif // is_mpi
513 >    
514 >  }
515 >
516 >  std::string DumpWriter::prepareDumpLine(StuntDouble* sd) {
517          
518 <    int index = integrableObject->getGlobalIntegrableObjectIndex();
518 >    int index = sd->getGlobalIntegrableObjectIndex();
519      std::string type("pv");
520      std::string line;
521      char tempBuffer[4096];
522  
523      Vector3d pos;
524      Vector3d vel;
525 <    pos = integrableObject->getPos();
525 >    pos = sd->getPos();
526  
527      if (isinf(pos[0]) || isnan(pos[0]) ||
528          isinf(pos[1]) || isnan(pos[1]) ||
# Line 429 | Line 534 | namespace OpenMD {
534        simError();
535      }
536  
537 <    vel = integrableObject->getVel();          
537 >    vel = sd->getVel();        
538  
539      if (isinf(vel[0]) || isnan(vel[0]) ||
540          isinf(vel[1]) || isnan(vel[1]) ||
# Line 446 | Line 551 | namespace OpenMD {
551              vel[0], vel[1], vel[2]);                    
552      line += tempBuffer;
553  
554 <    if (integrableObject->isDirectional()) {
554 >    if (sd->isDirectional()) {
555        type += "qj";
556        Quat4d q;
557        Vector3d ji;
558 <      q = integrableObject->getQ();
558 >      q = sd->getQ();
559  
560        if (isinf(q[0]) || isnan(q[0]) ||
561            isinf(q[1]) || isnan(q[1]) ||
# Line 463 | Line 568 | namespace OpenMD {
568          simError();
569        }
570  
571 <      ji = integrableObject->getJ();
571 >      ji = sd->getJ();
572  
573        if (isinf(ji[0]) || isnan(ji[0]) ||
574            isinf(ji[1]) || isnan(ji[1]) ||
# Line 483 | Line 588 | namespace OpenMD {
588  
589      if (needForceVector_) {
590        type += "f";
591 <      Vector3d frc = integrableObject->getFrc();
591 >      Vector3d frc = sd->getFrc();
592        if (isinf(frc[0]) || isnan(frc[0]) ||
593            isinf(frc[1]) || isnan(frc[1]) ||
594            isinf(frc[2]) || isnan(frc[2]) ) {      
# Line 497 | Line 602 | namespace OpenMD {
602                frc[0], frc[1], frc[2]);
603        line += tempBuffer;
604        
605 <      if (integrableObject->isDirectional()) {
605 >      if (sd->isDirectional()) {
606          type += "t";
607 <        Vector3d trq = integrableObject->getTrq();        
607 >        Vector3d trq = sd->getTrq();        
608          if (isinf(trq[0]) || isnan(trq[0]) ||
609              isinf(trq[1]) || isnan(trq[1]) ||
610              isinf(trq[2]) || isnan(trq[2]) ) {      
# Line 519 | Line 624 | namespace OpenMD {
624      return std::string(tempBuffer);
625    }
626  
627 <  std::string DumpWriter::prepareSiteLine(StuntDouble* integrableObject, int ioIndex, int siteIndex) {
627 >  std::string DumpWriter::prepareSiteLine(StuntDouble* sd, int ioIndex, int siteIndex) {
628          
629  
630      std::string id;
# Line 527 | Line 632 | namespace OpenMD {
632      std::string line;
633      char tempBuffer[4096];
634  
635 <    if (integrableObject->isRigidBody()) {
635 >    if (sd->isRigidBody()) {
636        sprintf(tempBuffer, "%10d           ", ioIndex);
637        id = std::string(tempBuffer);
638      } else {
# Line 537 | Line 642 | namespace OpenMD {
642                
643      if (needFlucQ_) {
644        type += "cw";
645 <      RealType fqPos = integrableObject->getFlucQPos();
645 >      RealType fqPos = sd->getFlucQPos();
646        if (isinf(fqPos) || isnan(fqPos) ) {      
647          sprintf( painCave.errMsg,
648                   "DumpWriter detected a numerical error writing the"
# Line 548 | Line 653 | namespace OpenMD {
653        sprintf(tempBuffer, " %13e ", fqPos);
654        line += tempBuffer;
655      
656 <      RealType fqVel = integrableObject->getFlucQVel();
656 >      RealType fqVel = sd->getFlucQVel();
657        if (isinf(fqVel) || isnan(fqVel) ) {      
658          sprintf( painCave.errMsg,
659                   "DumpWriter detected a numerical error writing the"
# Line 561 | Line 666 | namespace OpenMD {
666  
667        if (needForceVector_) {
668          type += "g";
669 <        RealType fqFrc = integrableObject->getFlucQFrc();        
669 >        RealType fqFrc = sd->getFlucQFrc();        
670          if (isinf(fqFrc) || isnan(fqFrc) ) {      
671            sprintf( painCave.errMsg,
672                     "DumpWriter detected a numerical error writing the"
# Line 576 | Line 681 | namespace OpenMD {
681  
682      if (needElectricField_) {
683        type += "e";
684 <      Vector3d eField= integrableObject->getElectricField();
684 >      Vector3d eField= sd->getElectricField();
685        if (isinf(eField[0]) || isnan(eField[0]) ||
686            isinf(eField[1]) || isnan(eField[1]) ||
687            isinf(eField[2]) || isnan(eField[2]) ) {      
# Line 594 | Line 699 | namespace OpenMD {
699  
700      if (needParticlePot_) {
701        type += "u";
702 <      RealType particlePot = integrableObject->getParticlePot();
702 >      RealType particlePot = sd->getParticlePot();
703        if (isinf(particlePot) || isnan(particlePot)) {      
704          sprintf( painCave.errMsg,
705                   "DumpWriter detected a numerical error writing the particle "
# Line 621 | Line 726 | namespace OpenMD {
726   #ifdef IS_MPI
727      if (worldRank == 0) {
728   #endif // is_mpi
729 <
729 >      
730        eorStream = createOStream(eorFilename_);
731  
732   #ifdef IS_MPI
733      }
734 < #endif // is_mpi    
735 <
734 > #endif
735 >    
736      writeFrame(*eorStream);
737 <
737 >      
738   #ifdef IS_MPI
739      if (worldRank == 0) {
740 < #endif // is_mpi
740 > #endif
741 >      
742        writeClosing(*eorStream);
743        delete eorStream;
744 +      
745   #ifdef IS_MPI
746      }
747   #endif // is_mpi  
# Line 678 | Line 785 | namespace OpenMD {
785    std::ostream* DumpWriter::createOStream(const std::string& filename) {
786  
787      std::ostream* newOStream;
788 < #ifdef HAVE_LIBZ
788 > #ifdef HAVE_ZLIB
789      if (needCompression_) {
790        newOStream = new ogzstream(filename.c_str());
791      } else {

Diff Legend

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