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 1442 by gezelter, Mon May 10 17:28:26 2010 UTC vs.
Revision 2069 by gezelter, Thu Mar 5 16:30:23 2015 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
44   #define _FILE_OFFSET_BITS 64
45  
46 + #ifdef IS_MPI
47 + #include <mpi.h>
48 + #endif
49 +
50   #include <sys/types.h>
51   #include <sys/stat.h>
52  
# Line 57 | Line 62
62   #include "utils/simError.h"
63   #include "utils/MemoryUtils.hpp"
64   #include "utils/StringTokenizer.hpp"
65 + #include "brains/Thermo.hpp"
66  
61 – #ifdef IS_MPI
67  
63 – #include <mpi.h>
64 – #define TAKE_THIS_TAG_CHAR 0
65 – #define TAKE_THIS_TAG_INT 1
66 –
67 – #endif // is_mpi
68 –
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 104 | Line 103 | namespace OpenMD {
103   #ifdef IS_MPI
104      
105      if (worldRank == 0) {
106 < #endif
107 <      
106 > #endif
107 >
108        delete inFile_;
109        
110   #ifdef IS_MPI
# 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 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 242 | Line 245 | namespace OpenMD {
245      readSet(whichFrame);
246  
247      if (needCOMprops_) {
248 <      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
248 >      Thermo thermo(info_);
249        Vector3d com;
250 <      Vector3d comvel;
251 <      Vector3d comw;
252 <      if (needPos_ && needVel_){
253 <        info_->getComAll(com, comvel);
254 <        comw = info_->getAngularMomentum();
255 <      }else{
256 <        com = info_->getCom();
257 <        comvel = 0.0;
258 <        comw   = 0.0;
256 <      }
257 <      s->setCOMprops(com, comvel, comw);      
250 >
251 >      if (needPos_ && needVel_) {
252 >        Vector3d comvel;
253 >        Vector3d comw;
254 >        thermo.getComAll(com, comvel);
255 >        comw = thermo.getAngularMomentum();
256 >      } else {
257 >        com = thermo.getCom();
258 >      }                    
259      }
259 –
260    }
261    
262    void DumpReader::readSet(int whichFrame) {    
# Line 289 | Line 289 | namespace OpenMD {
289  
290        int sendBufferSize = sendBuffer.size();
291        MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
292 <      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
292 >      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize,
293 >                MPI_CHAR, masterNode, MPI_COMM_WORLD);    
294        
295        sstream.str(sendBuffer);
296      } else {
297        int sendBufferSize;
298 <      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
298 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
299        char * recvBuffer = new char[sendBufferSize+1];
300        assert(recvBuffer);
301        recvBuffer[sendBufferSize] = '\0';
302 <      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
302 >      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
303        sstream.str(recvBuffer);
304        delete [] recvBuffer;
305      }      
# Line 324 | Line 325 | namespace OpenMD {
325  
326      inputStream.getline(buffer, bufferSize);
327      line = buffer;
328 <    if (line.find("</Snapshot>") == std::string::npos) {
329 <      sprintf(painCave.errMsg,
330 <              "DumpReader Error: can not find </Snapshot>\n");
331 <      painCave.isFatal = 1;
332 <      simError();
333 <    }        
334 <  
328 >
329 >    if (line.find("<SiteData>") != std::string::npos) {
330 >      //read SiteData
331 >      readSiteData(inputStream);        
332 >    } else {
333 >      if (line.find("</Snapshot>") == std::string::npos) {
334 >        sprintf(painCave.errMsg,
335 >                "DumpReader Error: can not find </Snapshot>\n");
336 >        painCave.isFatal = 1;
337 >        simError();
338 >      }        
339 >    }
340    }
341    
342    void DumpReader::parseDumpLine(const std::string& line) {
# Line 341 | Line 347 | namespace OpenMD {
347      
348      nTokens = tokenizer.countTokens();
349      
350 <    if (nTokens < 2) {
350 >    if (nTokens < 2) {  
351        sprintf(painCave.errMsg,
352                "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
353        painCave.isFatal = 1;
# Line 350 | Line 356 | namespace OpenMD {
356  
357      int index = tokenizer.nextTokenAsInt();
358  
359 <    StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index);
359 >    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
360  
361 <    if (integrableObject == NULL) {
361 >    if (sd == NULL) {
362        return;
363      }
364      std::string type = tokenizer.nextToken();
365      int size = type.size();
366  
367 +    size_t found;
368 +    
369 +    if (needPos_) {
370 +      found = type.find("p");      
371 +      if (found == std::string::npos) {
372 +        sprintf(painCave.errMsg,
373 +                "DumpReader Error: StuntDouble %d has no Position\n"
374 +                "\tField (\"p\") specified.\n%s\n", index,
375 +                line.c_str());  
376 +        painCave.isFatal = 1;
377 +        simError();
378 +      }
379 +    }
380 +    
381 +    if (sd->isDirectional()) {
382 +      if (needQuaternion_) {
383 +        found = type.find("q");      
384 +        if (found == std::string::npos) {
385 +          sprintf(painCave.errMsg,
386 +                  "DumpReader Error: Directional StuntDouble %d has no\n"
387 +                  "\tQuaternion Field (\"q\") specified.\n%s\n", index,
388 +                  line.c_str());  
389 +          painCave.isFatal = 1;
390 +          simError();
391 +        }
392 +      }      
393 +    }
394 +
395      for(int i = 0; i < size; ++i) {
396        switch(type[i]) {
397          
# Line 367 | Line 401 | namespace OpenMD {
401              pos[1] = tokenizer.nextTokenAsDouble();
402              pos[2] = tokenizer.nextTokenAsDouble();
403              if (needPos_) {
404 <              integrableObject->setPos(pos);
404 >              sd->setPos(pos);
405              }            
406              break;
407          }
# Line 377 | Line 411 | namespace OpenMD {
411              vel[1] = tokenizer.nextTokenAsDouble();
412              vel[2] = tokenizer.nextTokenAsDouble();
413              if (needVel_) {
414 <              integrableObject->setVel(vel);
414 >              sd->setVel(vel);
415              }
416              break;
417          }
418  
419          case 'q' : {
420             Quat4d q;
421 <           if (integrableObject->isDirectional()) {
421 >           if (sd->isDirectional()) {
422                
423               q[0] = tokenizer.nextTokenAsDouble();
424               q[1] = tokenizer.nextTokenAsDouble();
# Line 403 | Line 437 | namespace OpenMD {
437                
438               q.normalize();
439               if (needQuaternion_) {            
440 <               integrableObject->setQ(q);
440 >               sd->setQ(q);
441               }              
442             }            
443             break;
444          }  
445          case 'j' : {
446            Vector3d ji;
447 <          if (integrableObject->isDirectional()) {
447 >          if (sd->isDirectional()) {
448               ji[0] = tokenizer.nextTokenAsDouble();
449               ji[1] = tokenizer.nextTokenAsDouble();
450               ji[2] = tokenizer.nextTokenAsDouble();
451               if (needAngMom_) {
452 <               integrableObject->setJ(ji);
452 >               sd->setJ(ji);
453               }
454            }
455            break;
# Line 426 | Line 460 | namespace OpenMD {
460            force[0] = tokenizer.nextTokenAsDouble();
461            force[1] = tokenizer.nextTokenAsDouble();
462            force[2] = tokenizer.nextTokenAsDouble();          
463 <          integrableObject->setFrc(force);
463 >          sd->setFrc(force);
464            break;
465          }
466          case 't' : {
# Line 435 | Line 469 | namespace OpenMD {
469             torque[0] = tokenizer.nextTokenAsDouble();
470             torque[1] = tokenizer.nextTokenAsDouble();
471             torque[2] = tokenizer.nextTokenAsDouble();          
472 <           integrableObject->setTrq(torque);          
472 >           sd->setTrq(torque);          
473             break;
474          }
475 +        case 'u' : {
476 +
477 +           RealType particlePot;
478 +           particlePot = tokenizer.nextTokenAsDouble();
479 +           sd->setParticlePot(particlePot);          
480 +           break;
481 +        }
482 +        case 'c' : {
483 +
484 +           RealType flucQPos;
485 +           flucQPos = tokenizer.nextTokenAsDouble();
486 +           sd->setFlucQPos(flucQPos);          
487 +           break;
488 +        }
489 +        case 'w' : {
490 +
491 +           RealType flucQVel;
492 +           flucQVel = tokenizer.nextTokenAsDouble();
493 +           sd->setFlucQVel(flucQVel);          
494 +           break;
495 +        }
496 +        case 'g' : {
497 +
498 +           RealType flucQFrc;
499 +           flucQFrc = tokenizer.nextTokenAsDouble();
500 +           sd->setFlucQFrc(flucQFrc);          
501 +           break;
502 +        }
503 +        case 'e' : {
504 +
505 +           Vector3d eField;
506 +           eField[0] = tokenizer.nextTokenAsDouble();
507 +           eField[1] = tokenizer.nextTokenAsDouble();
508 +           eField[2] = tokenizer.nextTokenAsDouble();          
509 +           sd->setElectricField(eField);          
510 +           break;
511 +        }
512 +        case 's' : {
513 +
514 +           RealType sPot;
515 +           sPot = tokenizer.nextTokenAsDouble();
516 +           sd->setSitePotential(sPot);          
517 +           break;
518 +        }
519          default: {
520                 sprintf(painCave.errMsg,
521                         "DumpReader Error: %s is an unrecognized type\n", type.c_str());
# Line 448 | Line 526 | namespace OpenMD {
526  
527        }
528      }
451 –    
529    }
530    
531  
532 <  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
532 >  void DumpReader::parseSiteLine(const std::string& line) {
533  
534 +    StringTokenizer tokenizer(line);
535 +    int nTokens;
536 +        
537 +    nTokens = tokenizer.countTokens();
538 +    
539 +    if (nTokens < 2) {  
540 +      sprintf(painCave.errMsg,
541 +              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
542 +      painCave.isFatal = 1;
543 +      simError();
544 +    }
545 +
546 +    /**
547 +     * The first token is the global integrable object index.
548 +     */
549 +
550 +    int index = tokenizer.nextTokenAsInt();
551 +    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
552 +    if (sd == NULL) {
553 +      return;
554 +    }
555 +
556 +    /**
557 +     * Test to see if the next token is an integer or not.  If not,
558 +     * we've got data on the integrable object itself.  If there is an
559 +     * integer, we're parsing data for a site on a rigid body.
560 +     */
561 +
562 +    std::string indexTest = tokenizer.peekNextToken();
563 +    std::istringstream i(indexTest);
564 +    int siteIndex;
565 +    if (i >> siteIndex) {
566 +      // chew up this token and parse as an int:
567 +      siteIndex = tokenizer.nextTokenAsInt();
568 +
569 +      if (sd->isRigidBody()) {
570 +        RigidBody* rb = static_cast<RigidBody*>(sd);
571 +        sd = rb->getAtoms()[siteIndex];
572 +      }
573 +    }
574 +
575 +    /**
576 +     * The next token contains information on what follows.
577 +     */
578 +    std::string type = tokenizer.nextToken();
579 +    int size = type.size();
580 +    
581 +    for(int i = 0; i < size; ++i) {
582 +      switch(type[i]) {
583 +        
584 +      case 'u' : {
585 +        
586 +        RealType particlePot;
587 +        particlePot = tokenizer.nextTokenAsDouble();
588 +        sd->setParticlePot(particlePot);
589 +        break;
590 +      }
591 +      case 'c' : {
592 +        
593 +        RealType flucQPos;
594 +        flucQPos = tokenizer.nextTokenAsDouble();
595 +        sd->setFlucQPos(flucQPos);
596 +        break;
597 +      }
598 +      case 'w' : {
599 +        
600 +        RealType flucQVel;
601 +        flucQVel = tokenizer.nextTokenAsDouble();
602 +        sd->setFlucQVel(flucQVel);
603 +        break;
604 +      }
605 +      case 'g' : {
606 +        
607 +        RealType flucQFrc;
608 +        flucQFrc = tokenizer.nextTokenAsDouble();
609 +        sd->setFlucQFrc(flucQFrc);
610 +        break;
611 +      }
612 +      case 'e' : {
613 +        
614 +        Vector3d eField;
615 +        eField[0] = tokenizer.nextTokenAsDouble();
616 +        eField[1] = tokenizer.nextTokenAsDouble();
617 +        eField[2] = tokenizer.nextTokenAsDouble();  
618 +        sd->setElectricField(eField);          
619 +        break;
620 +      }
621 +      case 's' : {
622 +        
623 +        RealType sPot;
624 +        sPot = tokenizer.nextTokenAsDouble();
625 +        sd->setSitePotential(sPot);          
626 +        break;
627 +      }
628 +      default: {
629 +        sprintf(painCave.errMsg,
630 +                "DumpReader Error: %s is an unrecognized type\n", type.c_str());
631 +        painCave.isFatal = 1;
632 +        simError();
633 +        break;  
634 +      }
635 +      }
636 +    }    
637 +  }
638 +  
639 +  
640 +    void  DumpReader::readStuntDoubles(std::istream& inputStream) {
641 +    
642      inputStream.getline(buffer, bufferSize);
643      std::string line(buffer);
644      
# Line 476 | Line 661 | namespace OpenMD {
661    
662    }
663  
664 +  void  DumpReader::readSiteData(std::istream& inputStream) {
665 +
666 +    std::string line(buffer);
667 +
668 +    // We already found the starting <SiteData> tag or we wouldn't be
669 +    // here, so just start parsing until we get to the ending
670 +    // </SiteData> tag:
671 +    
672 +    while(inputStream.getline(buffer, bufferSize)) {
673 +      line = buffer;
674 +      
675 +      if(line.find("</SiteData>") != std::string::npos) {
676 +        break;
677 +      }
678 +
679 +      parseSiteLine(line);
680 +    }
681 +  
682 +  }
683 +
684    void DumpReader::readFrameProperties(std::istream& inputStream) {
685  
686      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
# Line 521 | Line 726 | namespace OpenMD {
726          hmat(2, 2) = tokenizer.nextTokenAsDouble();
727          s->setHmat(hmat);      
728        } else if (propertyName == "Thermostat") {
729 <        RealType chi = tokenizer.nextTokenAsDouble();
730 <        RealType integralOfChiDt = tokenizer.nextTokenAsDouble();
731 <        s->setChi(chi);
732 <        s->setIntegralOfChiDt(integralOfChiDt);        
729 >        pair<RealType, RealType> thermostat;
730 >        thermostat.first = tokenizer.nextTokenAsDouble();
731 >        thermostat.second = tokenizer.nextTokenAsDouble();
732 >        s->setThermostat(thermostat);
733       } else if (propertyName == "Barostat") {
734          Mat3x3d eta;
735          eta(0, 0) = tokenizer.nextTokenAsDouble();
# Line 536 | Line 741 | namespace OpenMD {
741          eta(2, 0) = tokenizer.nextTokenAsDouble();
742          eta(2, 1) = tokenizer.nextTokenAsDouble();
743          eta(2, 2) = tokenizer.nextTokenAsDouble();
744 <        s->setEta(eta);
744 >        s->setBarostat(eta);
745        } else {
746          sprintf(painCave.errMsg,
747                  "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str());

Diff Legend

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