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

Comparing trunk/src/io/DumpWriter.cpp (file contents):
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC vs.
Revision 1969 by gezelter, Wed Feb 26 14:14:50 2014 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).          
39 < * [4]  Vardeman & Gezelter, in progress (2009).                        
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   */
42 +
43 + #include "config.h"
44 +
45 + #ifdef IS_MPI
46 + #include <mpi.h>
47 + #endif
48  
49   #include "io/DumpWriter.hpp"
50   #include "primitives/Molecule.hpp"
51   #include "utils/simError.h"
52   #include "io/basic_teebuf.hpp"
53 + #ifdef HAVE_ZLIB
54   #include "io/gzstream.hpp"
55 + #endif
56   #include "io/Globals.hpp"
57  
58 + #ifdef _MSC_VER
59 + #define isnan(x) _isnan((x))
60 + #define isinf(x) (!_finite(x) && !_isnan(x))
61 + #endif
62  
50 – #ifdef IS_MPI
51 – #include <mpi.h>
52 – #endif //is_mpi
53 –
63   using namespace std;
64   namespace OpenMD {
65  
# Line 58 | Line 67 | namespace OpenMD {
67      : info_(info), filename_(info->getDumpFileName()), eorFilename_(info->getFinalConfigFileName()){
68  
69      Globals* simParams = info->getSimParams();
70 <    needCompression_ = simParams->getCompressDumpFile();
71 <    needForceVector_ = simParams->getOutputForceVector();
70 >    needCompression_   = simParams->getCompressDumpFile();
71 >    needForceVector_   = simParams->getOutputForceVector();
72 >    needParticlePot_   = simParams->getOutputParticlePotential();
73 >    needFlucQ_         = simParams->getOutputFluctuatingCharges();
74 >    needElectricField_ = simParams->getOutputElectricField();
75 >
76 >    if (needParticlePot_ || needFlucQ_ || needElectricField_) {
77 >      doSiteData_ = true;
78 >    } else {
79 >      doSiteData_ = false;
80 >    }
81 >
82      createDumpFile_ = true;
83   #ifdef HAVE_LIBZ
84      if (needCompression_) {
# Line 97 | Line 116 | namespace OpenMD {
116      Globals* simParams = info->getSimParams();
117      eorFilename_ = filename_.substr(0, filename_.rfind(".")) + ".eor";    
118  
119 <    needCompression_ = simParams->getCompressDumpFile();
120 <    needForceVector_ = simParams->getOutputForceVector();
119 >    needCompression_   = simParams->getCompressDumpFile();
120 >    needForceVector_   = simParams->getOutputForceVector();
121 >    needParticlePot_   = simParams->getOutputParticlePotential();
122 >    needFlucQ_         = simParams->getOutputFluctuatingCharges();
123 >    needElectricField_ = simParams->getOutputElectricField();
124 >
125 >    if (needParticlePot_ || needFlucQ_ || needElectricField_) {
126 >      doSiteData_ = true;
127 >    } else {
128 >      doSiteData_ = false;
129 >    }
130 >
131      createDumpFile_ = true;
132   #ifdef HAVE_LIBZ
133      if (needCompression_) {
# Line 136 | Line 165 | namespace OpenMD {
165      Globals* simParams = info->getSimParams();
166      eorFilename_ = filename_.substr(0, filename_.rfind(".")) + ".eor";    
167      
168 <    needCompression_ = simParams->getCompressDumpFile();
169 <    needForceVector_ = simParams->getOutputForceVector();
170 <    
168 >    needCompression_   = simParams->getCompressDumpFile();
169 >    needForceVector_   = simParams->getOutputForceVector();
170 >    needParticlePot_   = simParams->getOutputParticlePotential();
171 >    needFlucQ_         = simParams->getOutputFluctuatingCharges();
172 >    needElectricField_ = simParams->getOutputElectricField();
173 >
174 >    if (needParticlePot_ || needFlucQ_ || needElectricField_) {
175 >      doSiteData_ = true;
176 >    } else {
177 >      doSiteData_ = false;
178 >    }
179 >
180   #ifdef HAVE_LIBZ
181      if (needCompression_) {
182        filename_ += ".gz";
# Line 227 | Line 265 | namespace OpenMD {
265              hmat(0, 2), hmat(1, 2), hmat(2, 2));
266      os << buffer;
267  
268 <    RealType chi = s->getChi();
269 <    RealType integralOfChiDt = s->getIntegralOfChiDt();
270 <    if (isinf(chi) || isnan(chi) ||
271 <        isinf(integralOfChiDt) || isnan(integralOfChiDt)) {      
268 >    pair<RealType, RealType> thermostat = s->getThermostat();
269 >
270 >    if (isinf(thermostat.first)  || isnan(thermostat.first) ||
271 >        isinf(thermostat.second) || isnan(thermostat.second)) {      
272        sprintf( painCave.errMsg,
273                 "DumpWriter detected a numerical error writing the thermostat");
274        painCave.isFatal = 1;
275        simError();
276      }
277 <    sprintf(buffer, "  Thermostat: %.10g , %.10g\n", chi, integralOfChiDt);
277 >    sprintf(buffer, "  Thermostat: %.10g , %.10g\n", thermostat.first,
278 >            thermostat.second);
279      os << buffer;
280  
281      Mat3x3d eta;
282 <    eta = s->getEta();
282 >    eta = s->getBarostat();
283  
284      for (unsigned int i = 0; i < 3; i++) {
285        for (unsigned int j = 0; j < 3; j++) {
# Line 265 | Line 304 | namespace OpenMD {
304    void DumpWriter::writeFrame(std::ostream& os) {
305  
306   #ifdef IS_MPI
307 <    MPI_Status istatus;
307 >    MPI_Status* istatus;
308   #endif
309  
310      Molecule* mol;
311 <    StuntDouble* integrableObject;
311 >    StuntDouble* sd;
312      SimInfo::MoleculeIterator mi;
313      Molecule::IntegrableObjectIterator ii;
314 +    RigidBody::AtomIterator ai;
315  
316   #ifndef IS_MPI
317      os << "  <Snapshot>\n";
# Line 279 | Line 319 | namespace OpenMD {
319      writeFrameProperties(os, info_->getSnapshotManager()->getCurrentSnapshot());
320  
321      os << "    <StuntDoubles>\n";
322 <    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
323 <
322 >    for (mol = info_->beginMolecule(mi); mol != NULL;
323 >         mol = info_->nextMolecule(mi)) {
324        
325 <      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
326 <           integrableObject = mol->nextIntegrableObject(ii)) {  
327 <          os << prepareDumpLine(integrableObject);
325 >      for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
326 >           sd = mol->nextIntegrableObject(ii)) {        
327 >          os << prepareDumpLine(sd);
328            
329        }
330      }    
331      os << "    </StuntDoubles>\n";
332 <    
332 >
333 >    if (doSiteData_) {
334 >      os << "    <SiteData>\n";
335 >      for (mol = info_->beginMolecule(mi); mol != NULL;
336 >           mol = info_->nextMolecule(mi)) {
337 >              
338 >        for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
339 >           sd = mol->nextIntegrableObject(ii)) {        
340 >
341 >          int ioIndex = sd->getGlobalIntegrableObjectIndex();
342 >          // do one for the IO itself
343 >          os << prepareSiteLine(sd, ioIndex, 0);
344 >
345 >          if (sd->isRigidBody()) {
346 >            
347 >            RigidBody* rb = static_cast<RigidBody*>(sd);
348 >            int siteIndex = 0;
349 >            for (Atom* atom = rb->beginAtom(ai); atom != NULL;  
350 >                 atom = rb->nextAtom(ai)) {                                            
351 >              os << prepareSiteLine(atom, ioIndex, siteIndex);
352 >              siteIndex++;
353 >            }
354 >          }
355 >        }
356 >      }    
357 >      os << "    </SiteData>\n";
358 >    }
359      os << "  </Snapshot>\n";
360  
361      os.flush();
362   #else
297 –    //every node prepares the dump lines for integrable objects belong to itself
298 –    std::string buffer;
299 –    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
363  
301 –
302 –      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
303 –           integrableObject = mol->nextIntegrableObject(ii)) {  
304 –          buffer += prepareDumpLine(integrableObject);
305 –      }
306 –    }
307 –    
364      const int masterNode = 0;
365 +    int worldRank;
366 +    int nProc;
367  
368 +    MPI_Comm_size( MPI_COMM_WORLD, &nProc);
369 +    MPI_Comm_rank( MPI_COMM_WORLD, &worldRank);
370 +
371 +
372      if (worldRank == masterNode) {      
373        os << "  <Snapshot>\n";  
374 <      writeFrameProperties(os, info_->getSnapshotManager()->getCurrentSnapshot());
374 >      writeFrameProperties(os,
375 >                           info_->getSnapshotManager()->getCurrentSnapshot());
376        os << "    <StuntDoubles>\n";
377 <        
315 <      os << buffer;
377 >    }
378  
379 <      int nProc;
380 <      MPI_Comm_size(MPI_COMM_WORLD, &nProc);
379 >    //every node prepares the dump lines for integrable objects belong to itself
380 >    std::string buffer;
381 >    for (mol = info_->beginMolecule(mi); mol != NULL;
382 >         mol = info_->nextMolecule(mi)) {
383 >      for (sd = mol->beginIntegrableObject(ii); sd != NULL;
384 >           sd = mol->nextIntegrableObject(ii)) {        
385 >        buffer += prepareDumpLine(sd);
386 >      }
387 >    }
388 >    
389 >    if (worldRank == masterNode) {      
390 >      os << buffer;
391 >      
392        for (int i = 1; i < nProc; ++i) {
393 +        // tell processor i to start sending us data:
394 +        MPI_Bcast(&i, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
395  
396          // receive the length of the string buffer that was
397 <        // prepared by processor i
323 <
397 >        // prepared by processor i:        
398          int recvLength;
399 <        MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &istatus);
399 >        MPI_Recv(&recvLength, 1, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD,
400 >                 istatus);
401 >
402 >        // create a buffer to receive the data
403          char* recvBuffer = new char[recvLength];
404          if (recvBuffer == NULL) {
405          } else {
406 <          MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD, &istatus);
406 >          // receive the data:
407 >          MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i,
408 >                               MPI_ANY_TAG, MPI_COMM_WORLD, istatus);
409 >          // send it to the file:
410            os << recvBuffer;
411 +          // get rid of the receive buffer:
412            delete [] recvBuffer;
413          }
414        }
334 –      os << "    </StuntDoubles>\n";
335 –      
336 –      os << "  </Snapshot>\n";
337 –      os.flush();
415      } else {
416        int sendBufferLength = buffer.size() + 1;
417 <      MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
418 <      MPI_Send((void *)buffer.c_str(), sendBufferLength, MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
417 >      int myturn = 0;
418 >      for (int i = 1; i < nProc; ++i){
419 >        // wait for the master node to call our number:
420 >        MPI_Bcast(&myturn, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
421 >        if (myturn == worldRank){
422 >          // send the length of our buffer:
423 >          MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
424 >
425 >          // send our buffer:
426 >          MPI_Send((void *)buffer.c_str(), sendBufferLength,
427 >                   MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
428 >
429 >        }
430 >      }
431      }
432 +    
433 +    if (worldRank == masterNode) {      
434 +      os << "    </StuntDoubles>\n";
435 +    }
436  
437 < #endif // is_mpi
437 >    if (doSiteData_) {
438 >      if (worldRank == masterNode) {
439 >        os << "    <SiteData>\n";
440 >      }
441 >      buffer.clear();
442 >      for (mol = info_->beginMolecule(mi); mol != NULL;
443 >           mol = info_->nextMolecule(mi)) {
444 >              
445 >        for (sd = mol->beginIntegrableObject(ii); sd != NULL;  
446 >             sd = mol->nextIntegrableObject(ii)) {      
447 >          
448 >          int ioIndex = sd->getGlobalIntegrableObjectIndex();
449 >          // do one for the IO itself
450 >          buffer += prepareSiteLine(sd, ioIndex, 0);
451  
452 +          if (sd->isRigidBody()) {
453 +            
454 +            RigidBody* rb = static_cast<RigidBody*>(sd);
455 +            int siteIndex = 0;
456 +            for (Atom* atom = rb->beginAtom(ai); atom != NULL;  
457 +                 atom = rb->nextAtom(ai)) {                                            
458 +              buffer += prepareSiteLine(atom, ioIndex, siteIndex);
459 +              siteIndex++;
460 +            }
461 +          }
462 +        }
463 +      }
464 +
465 +      if (worldRank == masterNode) {    
466 +        os << buffer;
467 +        
468 +        for (int i = 1; i < nProc; ++i) {
469 +          
470 +          // tell processor i to start sending us data:
471 +          MPI_Bcast(&i, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
472 +          
473 +          // receive the length of the string buffer that was
474 +          // prepared by processor i:        
475 +          int recvLength;
476 +          MPI_Recv(&recvLength, 1, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD,
477 +                   istatus);
478 +          
479 +          // create a buffer to receive the data
480 +          char* recvBuffer = new char[recvLength];
481 +          if (recvBuffer == NULL) {
482 +          } else {
483 +            // receive the data:
484 +            MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i,
485 +                     MPI_ANY_TAG, MPI_COMM_WORLD, istatus);
486 +            // send it to the file:
487 +            os << recvBuffer;
488 +            // get rid of the receive buffer:
489 +            delete [] recvBuffer;
490 +          }
491 +        }      
492 +      } else {
493 +        int sendBufferLength = buffer.size() + 1;
494 +        int myturn = 0;
495 +        for (int i = 1; i < nProc; ++i){
496 +          // wait for the master node to call our number:
497 +          MPI_Bcast(&myturn, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
498 +          if (myturn == worldRank){
499 +            // send the length of our buffer:
500 +            MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
501 +            // send our buffer:
502 +            MPI_Send((void *)buffer.c_str(), sendBufferLength,
503 +                     MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
504 +          }
505 +        }
506 +      }
507 +      
508 +      if (worldRank == masterNode) {    
509 +        os << "    </SiteData>\n";
510 +      }
511 +    }
512 +    
513 +    if (worldRank == masterNode) {
514 +      os << "  </Snapshot>\n";
515 +      os.flush();
516 +    }
517 +    
518 + #endif // is_mpi
519 +    
520    }
521  
522 <  std::string DumpWriter::prepareDumpLine(StuntDouble* integrableObject) {
522 >  std::string DumpWriter::prepareDumpLine(StuntDouble* sd) {
523          
524 <    int index = integrableObject->getGlobalIntegrableObjectIndex();
524 >    int index = sd->getGlobalIntegrableObjectIndex();
525      std::string type("pv");
526      std::string line;
527      char tempBuffer[4096];
528  
529      Vector3d pos;
530      Vector3d vel;
531 <    pos = integrableObject->getPos();
531 >    pos = sd->getPos();
532  
533      if (isinf(pos[0]) || isnan(pos[0]) ||
534          isinf(pos[1]) || isnan(pos[1]) ||
# Line 366 | Line 540 | namespace OpenMD {
540        simError();
541      }
542  
543 <    vel = integrableObject->getVel();          
543 >    vel = sd->getVel();        
544  
545      if (isinf(vel[0]) || isnan(vel[0]) ||
546          isinf(vel[1]) || isnan(vel[1]) ||
# Line 383 | Line 557 | namespace OpenMD {
557              vel[0], vel[1], vel[2]);                    
558      line += tempBuffer;
559  
560 <    if (integrableObject->isDirectional()) {
560 >    if (sd->isDirectional()) {
561        type += "qj";
562        Quat4d q;
563        Vector3d ji;
564 <      q = integrableObject->getQ();
564 >      q = sd->getQ();
565  
566        if (isinf(q[0]) || isnan(q[0]) ||
567            isinf(q[1]) || isnan(q[1]) ||
# Line 400 | Line 574 | namespace OpenMD {
574          simError();
575        }
576  
577 <      ji = integrableObject->getJ();
577 >      ji = sd->getJ();
578  
579        if (isinf(ji[0]) || isnan(ji[0]) ||
580            isinf(ji[1]) || isnan(ji[1]) ||
# Line 420 | Line 594 | namespace OpenMD {
594  
595      if (needForceVector_) {
596        type += "f";
597 <      Vector3d frc;
424 <
425 <      frc = integrableObject->getFrc();
426 <
597 >      Vector3d frc = sd->getFrc();
598        if (isinf(frc[0]) || isnan(frc[0]) ||
599            isinf(frc[1]) || isnan(frc[1]) ||
600            isinf(frc[2]) || isnan(frc[2]) ) {      
# Line 437 | Line 608 | namespace OpenMD {
608                frc[0], frc[1], frc[2]);
609        line += tempBuffer;
610        
611 <      if (integrableObject->isDirectional()) {
611 >      if (sd->isDirectional()) {
612          type += "t";
613 <        Vector3d trq;
443 <        
444 <        trq = integrableObject->getTrq();
445 <        
613 >        Vector3d trq = sd->getTrq();        
614          if (isinf(trq[0]) || isnan(trq[0]) ||
615              isinf(trq[1]) || isnan(trq[1]) ||
616              isinf(trq[2]) || isnan(trq[2]) ) {      
# Line 451 | Line 619 | namespace OpenMD {
619                     " for object %d", index);      
620            painCave.isFatal = 1;
621            simError();
622 <        }
455 <        
622 >        }        
623          sprintf(tempBuffer, " %13e %13e %13e",
624                  trq[0], trq[1], trq[2]);
625          line += tempBuffer;
626        }      
627      }
628 <    
628 >
629      sprintf(tempBuffer, "%10d %7s %s\n", index, type.c_str(), line.c_str());
630      return std::string(tempBuffer);
631    }
632  
633 +  std::string DumpWriter::prepareSiteLine(StuntDouble* sd, int ioIndex, int siteIndex) {
634 +    int storageLayout = info_->getSnapshotManager()->getStorageLayout();
635 +
636 +    std::string id;
637 +    std::string type;
638 +    std::string line;
639 +    char tempBuffer[4096];
640 +
641 +    if (sd->isRigidBody()) {
642 +      sprintf(tempBuffer, "%10d           ", ioIndex);
643 +      id = std::string(tempBuffer);
644 +    } else {
645 +      sprintf(tempBuffer, "%10d %10d", ioIndex, siteIndex);
646 +      id = std::string(tempBuffer);
647 +    }
648 +              
649 +    if (needFlucQ_) {
650 +      if (storageLayout & DataStorage::dslFlucQPosition) {
651 +        type += "c";
652 +        RealType fqPos = sd->getFlucQPos();
653 +        if (isinf(fqPos) || isnan(fqPos) ) {      
654 +          sprintf( painCave.errMsg,
655 +                   "DumpWriter detected a numerical error writing the"
656 +                   " fluctuating charge for object %s", id.c_str());      
657 +          painCave.isFatal = 1;
658 +          simError();
659 +        }
660 +        sprintf(tempBuffer, " %13e ", fqPos);
661 +        line += tempBuffer;
662 +      }
663 +
664 +      if (storageLayout & DataStorage::dslFlucQVelocity) {
665 +        type += "w";    
666 +        RealType fqVel = sd->getFlucQVel();
667 +        if (isinf(fqVel) || isnan(fqVel) ) {      
668 +          sprintf( painCave.errMsg,
669 +                   "DumpWriter detected a numerical error writing the"
670 +                   " fluctuating charge velocity for object %s", id.c_str());      
671 +          painCave.isFatal = 1;
672 +          simError();
673 +        }
674 +        sprintf(tempBuffer, " %13e ", fqVel);
675 +        line += tempBuffer;
676 +      }
677 +
678 +      if (needForceVector_) {
679 +        if (storageLayout & DataStorage::dslFlucQForce) {          
680 +          type += "g";
681 +          RealType fqFrc = sd->getFlucQFrc();        
682 +          if (isinf(fqFrc) || isnan(fqFrc) ) {      
683 +            sprintf( painCave.errMsg,
684 +                     "DumpWriter detected a numerical error writing the"
685 +                     " fluctuating charge force for object %s", id.c_str());      
686 +            painCave.isFatal = 1;
687 +            simError();
688 +          }
689 +          sprintf(tempBuffer, " %13e ", fqFrc);        
690 +          line += tempBuffer;
691 +        }
692 +      }
693 +    }
694 +    
695 +    if (needElectricField_) {
696 +      if (storageLayout & DataStorage::dslElectricField) {
697 +        type += "e";
698 +        Vector3d eField= sd->getElectricField();
699 +        if (isinf(eField[0]) || isnan(eField[0]) ||
700 +            isinf(eField[1]) || isnan(eField[1]) ||
701 +            isinf(eField[2]) || isnan(eField[2]) ) {      
702 +          sprintf( painCave.errMsg,
703 +                   "DumpWriter detected a numerical error writing the electric"
704 +                   " field for object %s", id.c_str());      
705 +          painCave.isFatal = 1;
706 +          simError();
707 +        }
708 +        sprintf(tempBuffer, " %13e %13e %13e",
709 +                eField[0], eField[1], eField[2]);
710 +        line += tempBuffer;
711 +      }
712 +    }
713 +
714 +
715 +    if (needParticlePot_) {
716 +      if (storageLayout & DataStorage::dslParticlePot) {
717 +        type += "u";
718 +        RealType particlePot = sd->getParticlePot();
719 +        if (isinf(particlePot) || isnan(particlePot)) {      
720 +          sprintf( painCave.errMsg,
721 +                   "DumpWriter detected a numerical error writing the particle "
722 +                   " potential for object %s", id.c_str());      
723 +          painCave.isFatal = 1;
724 +          simError();
725 +        }
726 +        sprintf(tempBuffer, " %13e", particlePot);
727 +        line += tempBuffer;
728 +      }
729 +    }
730 +  
731 +    sprintf(tempBuffer, "%s %7s %s\n", id.c_str(), type.c_str(), line.c_str());
732 +    return std::string(tempBuffer);
733 +  }
734 +
735    void DumpWriter::writeDump() {
736      writeFrame(*dumpFile_);
737    }
# Line 473 | Line 742 | namespace OpenMD {
742   #ifdef IS_MPI
743      if (worldRank == 0) {
744   #endif // is_mpi
745 <
745 >      
746        eorStream = createOStream(eorFilename_);
747  
748   #ifdef IS_MPI
749      }
750 < #endif // is_mpi    
751 <
750 > #endif
751 >    
752      writeFrame(*eorStream);
753 <
753 >      
754   #ifdef IS_MPI
755      if (worldRank == 0) {
756 < #endif // is_mpi
756 > #endif
757 >      
758        writeClosing(*eorStream);
759        delete eorStream;
760 +      
761   #ifdef IS_MPI
762      }
763   #endif // is_mpi  
# Line 500 | Line 771 | namespace OpenMD {
771   #ifdef IS_MPI
772      if (worldRank == 0) {
773   #endif // is_mpi
503 –
774        buffers.push_back(dumpFile_->rdbuf());
505 –
775        eorStream = createOStream(eorFilename_);
507 –
776        buffers.push_back(eorStream->rdbuf());
509 –        
777   #ifdef IS_MPI
778      }
779   #endif // is_mpi    
780  
781      TeeBuf tbuf(buffers.begin(), buffers.end());
782      std::ostream os(&tbuf);
516 –
783      writeFrame(os);
784  
785   #ifdef IS_MPI
# Line 523 | Line 789 | namespace OpenMD {
789        delete eorStream;
790   #ifdef IS_MPI
791      }
792 < #endif // is_mpi  
527 <    
792 > #endif // is_mpi      
793    }
794  
795    std::ostream* DumpWriter::createOStream(const std::string& filename) {
796  
797      std::ostream* newOStream;
798 < #ifdef HAVE_LIBZ
798 > #ifdef HAVE_ZLIB
799      if (needCompression_) {
800        newOStream = new ogzstream(filename.c_str());
801      } else {
# Line 540 | Line 805 | namespace OpenMD {
805      newOStream = new std::ofstream(filename.c_str());
806   #endif
807      //write out MetaData first
808 <    (*newOStream) << "<OpenMD version=1>" << std::endl;
808 >    (*newOStream) << "<OpenMD version=2>" << std::endl;
809      (*newOStream) << "  <MetaData>" << std::endl;
810      (*newOStream) << info_->getRawMetaData();
811      (*newOStream) << "  </MetaData>" << std::endl;

Diff Legend

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