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

Comparing trunk/src/io/DumpReader.cpp (file contents):
Revision 1610 by gezelter, Fri Aug 12 14:37:25 2011 UTC vs.
Revision 1897 by gezelter, Wed Jul 3 20:21:00 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).          
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   #define _LARGEFILE_SOURCE64
# Line 57 | Line 58
58   #include "utils/simError.h"
59   #include "utils/MemoryUtils.hpp"
60   #include "utils/StringTokenizer.hpp"
61 + #include "brains/Thermo.hpp"
62  
63   #ifdef IS_MPI
62 –
64   #include <mpi.h>
65 < #define TAKE_THIS_TAG_CHAR 0
65 < #define TAKE_THIS_TAG_INT 1
65 > #endif
66  
67 – #endif // is_mpi
67  
69 –
68   namespace OpenMD {
69    
70    DumpReader::DumpReader(SimInfo* info, const std::string& filename)
# Line 77 | Line 75 | namespace OpenMD {
75      if (worldRank == 0) {
76   #endif
77        
78 <      inFile_ = new std::ifstream(filename_.c_str());
78 >      inFile_ = new std::ifstream(filename_.c_str(),  
79 >                                  ifstream::in | ifstream::binary);
80        
81        if (inFile_->fail()) {
82          sprintf(painCave.errMsg,
# Line 129 | Line 128 | namespace OpenMD {
128    }
129    
130    void DumpReader::scanFile(void) {
131 <    int lineNo = 0;
131 >
132      std::streampos prevPos;
133      std::streampos  currPos;
134      
# Line 142 | Line 141 | namespace OpenMD {
141        prevPos = currPos;
142        bool foundOpenSnapshotTag = false;
143        bool foundClosedSnapshotTag = false;
144 +
145 +      int lineNo = 0;
146        while(inFile_->getline(buffer, bufferSize)) {
147          ++lineNo;
148          
# Line 202 | Line 203 | namespace OpenMD {
203   #ifdef IS_MPI
204      }
205      
206 <    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
206 >    MPI::COMM_WORLD.Bcast(&nframes_, 1, MPI::INT, 0);
207      
208   #endif // is_mpi
209      
# Line 227 | Line 228 | namespace OpenMD {
228        needVel_ = false;
229      }
230      
231 <    if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) {
231 >    if (storageLayout & DataStorage::dslAmat ||
232 >        storageLayout & DataStorage::dslDipole ||
233 >        storageLayout & DataStorage::dslQuadrupole) {
234        needQuaternion_ = true;
235      } else {
236        needQuaternion_ = false;
# Line 243 | Line 246 | namespace OpenMD {
246  
247      if (needCOMprops_) {
248        Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
249 +      Thermo thermo(info_);
250        Vector3d com;
251 <      Vector3d comvel;
252 <      Vector3d comw;
253 <      if (needPos_ && needVel_){
254 <        info_->getComAll(com, comvel);
255 <        comw = info_->getAngularMomentum();
256 <      }else{
257 <        com = info_->getCom();
258 <        comvel = 0.0;
259 <        comw   = 0.0;
256 <      }
257 <      s->setCOMprops(com, comvel, comw);      
251 >
252 >      if (needPos_ && needVel_) {
253 >        Vector3d comvel;
254 >        Vector3d comw;
255 >        thermo.getComAll(com, comvel);
256 >        comw = thermo.getAngularMomentum();
257 >      } else {
258 >        com = thermo.getCom();
259 >      }                    
260      }
259 –
261    }
262    
263    void DumpReader::readSet(int whichFrame) {    
# Line 288 | Line 289 | namespace OpenMD {
289        }
290  
291        int sendBufferSize = sendBuffer.size();
292 <      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
293 <      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
292 >      MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode);    
293 >      MPI::COMM_WORLD.Bcast((void *)sendBuffer.c_str(), sendBufferSize,
294 >                            MPI::CHAR, masterNode);    
295        
296        sstream.str(sendBuffer);
297      } else {
298        int sendBufferSize;
299 <      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
299 >      MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode);
300        char * recvBuffer = new char[sendBufferSize+1];
301        assert(recvBuffer);
302        recvBuffer[sendBufferSize] = '\0';
303 <      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
303 >      MPI::COMM_WORLD.Bcast(recvBuffer, sendBufferSize, MPI::CHAR, masterNode);
304        sstream.str(recvBuffer);
305        delete [] recvBuffer;
306      }      
# Line 324 | Line 326 | namespace OpenMD {
326  
327      inputStream.getline(buffer, bufferSize);
328      line = buffer;
329 <    if (line.find("</Snapshot>") == std::string::npos) {
330 <      sprintf(painCave.errMsg,
331 <              "DumpReader Error: can not find </Snapshot>\n");
332 <      painCave.isFatal = 1;
333 <      simError();
334 <    }        
335 <  
329 >
330 >    if (line.find("<SiteData>") != std::string::npos) {
331 >      //read SiteData
332 >      readSiteData(inputStream);        
333 >    } else {
334 >      if (line.find("</Snapshot>") == std::string::npos) {
335 >        sprintf(painCave.errMsg,
336 >                "DumpReader Error: can not find </Snapshot>\n");
337 >        painCave.isFatal = 1;
338 >        simError();
339 >      }        
340 >    }
341    }
342    
343    void DumpReader::parseDumpLine(const std::string& line) {
# Line 350 | Line 357 | namespace OpenMD {
357  
358      int index = tokenizer.nextTokenAsInt();
359  
360 <    StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index);
360 >    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
361  
362 <    if (integrableObject == NULL) {
362 >    if (sd == NULL) {
363        return;
364      }
365      std::string type = tokenizer.nextToken();
# Line 372 | Line 379 | namespace OpenMD {
379        }
380      }
381      
382 <    if (integrableObject->isDirectional()) {
382 >    if (sd->isDirectional()) {
383        if (needQuaternion_) {
384          found = type.find("q");      
385          if (found == std::string::npos) {
# Line 395 | Line 402 | namespace OpenMD {
402              pos[1] = tokenizer.nextTokenAsDouble();
403              pos[2] = tokenizer.nextTokenAsDouble();
404              if (needPos_) {
405 <              integrableObject->setPos(pos);
405 >              sd->setPos(pos);
406              }            
407              break;
408          }
# Line 405 | Line 412 | namespace OpenMD {
412              vel[1] = tokenizer.nextTokenAsDouble();
413              vel[2] = tokenizer.nextTokenAsDouble();
414              if (needVel_) {
415 <              integrableObject->setVel(vel);
415 >              sd->setVel(vel);
416              }
417              break;
418          }
419  
420          case 'q' : {
421             Quat4d q;
422 <           if (integrableObject->isDirectional()) {
422 >           if (sd->isDirectional()) {
423                
424               q[0] = tokenizer.nextTokenAsDouble();
425               q[1] = tokenizer.nextTokenAsDouble();
# Line 431 | Line 438 | namespace OpenMD {
438                
439               q.normalize();
440               if (needQuaternion_) {            
441 <               integrableObject->setQ(q);
441 >               sd->setQ(q);
442               }              
443             }            
444             break;
445          }  
446          case 'j' : {
447            Vector3d ji;
448 <          if (integrableObject->isDirectional()) {
448 >          if (sd->isDirectional()) {
449               ji[0] = tokenizer.nextTokenAsDouble();
450               ji[1] = tokenizer.nextTokenAsDouble();
451               ji[2] = tokenizer.nextTokenAsDouble();
452               if (needAngMom_) {
453 <               integrableObject->setJ(ji);
453 >               sd->setJ(ji);
454               }
455            }
456            break;
# Line 454 | Line 461 | namespace OpenMD {
461            force[0] = tokenizer.nextTokenAsDouble();
462            force[1] = tokenizer.nextTokenAsDouble();
463            force[2] = tokenizer.nextTokenAsDouble();          
464 <          integrableObject->setFrc(force);
464 >          sd->setFrc(force);
465            break;
466          }
467          case 't' : {
# Line 463 | Line 470 | namespace OpenMD {
470             torque[0] = tokenizer.nextTokenAsDouble();
471             torque[1] = tokenizer.nextTokenAsDouble();
472             torque[2] = tokenizer.nextTokenAsDouble();          
473 <           integrableObject->setTrq(torque);          
473 >           sd->setTrq(torque);          
474             break;
475          }
476          case 'u' : {
477  
478             RealType particlePot;
479             particlePot = tokenizer.nextTokenAsDouble();
480 <           integrableObject->setParticlePot(particlePot);          
480 >           sd->setParticlePot(particlePot);          
481             break;
482          }
483 +        case 'c' : {
484 +
485 +           RealType flucQPos;
486 +           flucQPos = tokenizer.nextTokenAsDouble();
487 +           sd->setFlucQPos(flucQPos);          
488 +           break;
489 +        }
490 +        case 'w' : {
491 +
492 +           RealType flucQVel;
493 +           flucQVel = tokenizer.nextTokenAsDouble();
494 +           sd->setFlucQVel(flucQVel);          
495 +           break;
496 +        }
497 +        case 'g' : {
498 +
499 +           RealType flucQFrc;
500 +           flucQFrc = tokenizer.nextTokenAsDouble();
501 +           sd->setFlucQFrc(flucQFrc);          
502 +           break;
503 +        }
504 +        case 'e' : {
505 +
506 +           Vector3d eField;
507 +           eField[0] = tokenizer.nextTokenAsDouble();
508 +           eField[1] = tokenizer.nextTokenAsDouble();
509 +           eField[2] = tokenizer.nextTokenAsDouble();          
510 +           sd->setElectricField(eField);          
511 +           break;
512 +        }
513          default: {
514                 sprintf(painCave.errMsg,
515                         "DumpReader Error: %s is an unrecognized type\n", type.c_str());
# Line 487 | Line 524 | namespace OpenMD {
524    }
525    
526  
527 <  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
527 >  void DumpReader::parseSiteLine(const std::string& line) {
528 >
529 >    StringTokenizer tokenizer(line);
530 >    int nTokens;
531 >        
532 >    nTokens = tokenizer.countTokens();
533 >    
534 >    if (nTokens < 2) {  
535 >      sprintf(painCave.errMsg,
536 >              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
537 >      painCave.isFatal = 1;
538 >      simError();
539 >    }
540  
541 +    /**
542 +     * The first token is the global integrable object index.
543 +     */
544 +
545 +    int index = tokenizer.nextTokenAsInt();
546 +    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
547 +    if (sd == NULL) {
548 +      return;
549 +    }
550 +
551 +    /**
552 +     * Test to see if the next token is an integer or not.  If not,
553 +     * we've got data on the integrable object itself.  If there is an
554 +     * integer, we're parsing data for a site on a rigid body.
555 +     */
556 +
557 +    std::string indexTest = tokenizer.peekNextToken();
558 +    std::istringstream i(indexTest);
559 +    int siteIndex;
560 +    if (i >> siteIndex) {
561 +      // chew up this token and parse as an int:
562 +      siteIndex = tokenizer.nextTokenAsInt();
563 +
564 +      if (sd->isRigidBody()) {
565 +        RigidBody* rb = static_cast<RigidBody*>(sd);
566 +        sd = rb->getAtoms()[siteIndex];
567 +      }
568 +    }
569 +
570 +    /**
571 +     * The next token contains information on what follows.
572 +     */
573 +    std::string type = tokenizer.nextToken();
574 +    int size = type.size();
575 +    
576 +    for(int i = 0; i < size; ++i) {
577 +      switch(type[i]) {
578 +        
579 +      case 'u' : {
580 +        
581 +        RealType particlePot;
582 +        particlePot = tokenizer.nextTokenAsDouble();
583 +        sd->setParticlePot(particlePot);
584 +        break;
585 +      }
586 +      case 'c' : {
587 +        
588 +        RealType flucQPos;
589 +        flucQPos = tokenizer.nextTokenAsDouble();
590 +        sd->setFlucQPos(flucQPos);
591 +        break;
592 +      }
593 +      case 'w' : {
594 +        
595 +        RealType flucQVel;
596 +        flucQVel = tokenizer.nextTokenAsDouble();
597 +        sd->setFlucQVel(flucQVel);
598 +        break;
599 +      }
600 +      case 'g' : {
601 +        
602 +        RealType flucQFrc;
603 +        flucQFrc = tokenizer.nextTokenAsDouble();
604 +        sd->setFlucQFrc(flucQFrc);
605 +        break;
606 +      }
607 +      case 'e' : {
608 +        
609 +        Vector3d eField;
610 +        eField[0] = tokenizer.nextTokenAsDouble();
611 +        eField[1] = tokenizer.nextTokenAsDouble();
612 +        eField[2] = tokenizer.nextTokenAsDouble();  
613 +        sd->setElectricField(eField);          
614 +        break;
615 +      }
616 +      default: {
617 +        sprintf(painCave.errMsg,
618 +                "DumpReader Error: %s is an unrecognized type\n", type.c_str());
619 +        painCave.isFatal = 1;
620 +        simError();
621 +        break;  
622 +      }
623 +      }
624 +    }    
625 +  }
626 +  
627 +  
628 +  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
629 +    
630      inputStream.getline(buffer, bufferSize);
631      std::string line(buffer);
632      
# Line 511 | Line 649 | namespace OpenMD {
649    
650    }
651  
652 +  void  DumpReader::readSiteData(std::istream& inputStream) {
653 +
654 +    std::string line(buffer);
655 +
656 +    // We already found the starting <SiteData> tag or we wouldn't be
657 +    // here, so just start parsing until we get to the ending
658 +    // </SiteData> tag:
659 +    
660 +    while(inputStream.getline(buffer, bufferSize)) {
661 +      line = buffer;
662 +      
663 +      if(line.find("</SiteData>") != std::string::npos) {
664 +        break;
665 +      }
666 +
667 +      parseSiteLine(line);
668 +    }
669 +  
670 +  }
671 +
672    void DumpReader::readFrameProperties(std::istream& inputStream) {
673  
674      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
# Line 556 | Line 714 | namespace OpenMD {
714          hmat(2, 2) = tokenizer.nextTokenAsDouble();
715          s->setHmat(hmat);      
716        } else if (propertyName == "Thermostat") {
717 <        RealType chi = tokenizer.nextTokenAsDouble();
718 <        RealType integralOfChiDt = tokenizer.nextTokenAsDouble();
719 <        s->setChi(chi);
720 <        s->setIntegralOfChiDt(integralOfChiDt);        
717 >        pair<RealType, RealType> thermostat;
718 >        thermostat.first = tokenizer.nextTokenAsDouble();
719 >        thermostat.second = tokenizer.nextTokenAsDouble();
720 >        s->setThermostat(thermostat);
721       } else if (propertyName == "Barostat") {
722          Mat3x3d eta;
723          eta(0, 0) = tokenizer.nextTokenAsDouble();
# Line 571 | Line 729 | namespace OpenMD {
729          eta(2, 0) = tokenizer.nextTokenAsDouble();
730          eta(2, 1) = tokenizer.nextTokenAsDouble();
731          eta(2, 2) = tokenizer.nextTokenAsDouble();
732 <        s->setEta(eta);
732 >        s->setBarostat(eta);
733        } else {
734          sprintf(painCave.errMsg,
735                  "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str());

Diff Legend

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