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

Comparing:
trunk/src/io/DumpReader.cpp (file contents), Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
branches/development/src/io/DumpReader.cpp (file contents), Revision 1752 by gezelter, Sun Jun 10 14:05:02 2012 UTC

# Line 36 | Line 36
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).                        
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 142 | Line 143 | namespace OpenMD {
143        prevPos = currPos;
144        bool foundOpenSnapshotTag = false;
145        bool foundClosedSnapshotTag = false;
146 +      bool foundOpenSiteDataTag = false;
147        while(inFile_->getline(buffer, bufferSize)) {
148          ++lineNo;
149          
# 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 341 | Line 348 | namespace OpenMD {
348      
349      nTokens = tokenizer.countTokens();
350      
351 <    if (nTokens < 2) {
351 >    if (nTokens < 2) {  
352        sprintf(painCave.errMsg,
353                "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
354        painCave.isFatal = 1;
# Line 357 | Line 364 | namespace OpenMD {
364      }
365      std::string type = tokenizer.nextToken();
366      int size = type.size();
367 +
368 +    size_t found;
369 +    
370 +    if (needPos_) {
371 +      found = type.find("p");      
372 +      if (found == std::string::npos) {
373 +        sprintf(painCave.errMsg,
374 +                "DumpReader Error: StuntDouble %d has no Position\n"
375 +                "\tField (\"p\") specified.\n%s\n", index,
376 +                line.c_str());  
377 +        painCave.isFatal = 1;
378 +        simError();
379 +      }
380 +    }
381 +    
382 +    if (integrableObject->isDirectional()) {
383 +      if (needQuaternion_) {
384 +        found = type.find("q");      
385 +        if (found == std::string::npos) {
386 +          sprintf(painCave.errMsg,
387 +                  "DumpReader Error: Directional StuntDouble %d has no\n"
388 +                  "\tQuaternion Field (\"q\") specified.\n%s\n", index,
389 +                  line.c_str());  
390 +          painCave.isFatal = 1;
391 +          simError();
392 +        }
393 +      }      
394 +    }
395  
396      for(int i = 0; i < size; ++i) {
397        switch(type[i]) {
# Line 436 | Line 471 | namespace OpenMD {
471             torque[1] = tokenizer.nextTokenAsDouble();
472             torque[2] = tokenizer.nextTokenAsDouble();          
473             integrableObject->setTrq(torque);          
474 +           break;
475 +        }
476 +        case 'u' : {
477 +
478 +           RealType particlePot;
479 +           particlePot = tokenizer.nextTokenAsDouble();
480 +           integrableObject->setParticlePot(particlePot);          
481             break;
482          }
483 +        case 'c' : {
484 +
485 +           RealType flucQPos;
486 +           flucQPos = tokenizer.nextTokenAsDouble();
487 +           integrableObject->setFlucQPos(flucQPos);          
488 +           break;
489 +        }
490 +        case 'w' : {
491 +
492 +           RealType flucQVel;
493 +           flucQVel = tokenizer.nextTokenAsDouble();
494 +           integrableObject->setFlucQVel(flucQVel);          
495 +           break;
496 +        }
497 +        case 'g' : {
498 +
499 +           RealType flucQFrc;
500 +           flucQFrc = tokenizer.nextTokenAsDouble();
501 +           integrableObject->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 +           integrableObject->setElectricField(eField);          
511 +           break;
512 +        }
513          default: {
514                 sprintf(painCave.errMsg,
515                         "DumpReader Error: %s is an unrecognized type\n", type.c_str());
# Line 452 | 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* integrableObject = info_->getIOIndexToIntegrableObject(index);
547 +    if (integrableObject == NULL) {
548 +      return;
549 +    }
550 +    StuntDouble* sd = integrableObject;
551 +
552 +    /**
553 +     * Test to see if the next token is an integer or not.  If not,
554 +     * we've got data on the integrable object itself.  If there is an
555 +     * integer, we're parsing data for a site on a rigid body.
556 +     */
557 +
558 +    std::string indexTest = tokenizer.peekNextToken();
559 +    std::istringstream i(indexTest);
560 +    int siteIndex;
561 +    if (i >> siteIndex) {
562 +      // chew up this token and parse as an int:
563 +      siteIndex = tokenizer.nextTokenAsInt();
564 +      RigidBody* rb = static_cast<RigidBody*>(integrableObject);
565 +      sd = rb->getAtoms()[siteIndex];
566 +    }
567 +
568 +    /**
569 +     * The next token contains information on what follows.
570 +     */
571 +    std::string type = tokenizer.nextToken();
572 +    int size = type.size();
573 +    
574 +    for(int i = 0; i < size; ++i) {
575 +      switch(type[i]) {
576 +        
577 +      case 'u' : {
578 +        
579 +        RealType particlePot;
580 +        particlePot = tokenizer.nextTokenAsDouble();
581 +        sd->setParticlePot(particlePot);
582 +        break;
583 +      }
584 +      case 'c' : {
585 +        
586 +        RealType flucQPos;
587 +        flucQPos = tokenizer.nextTokenAsDouble();
588 +        sd->setFlucQPos(flucQPos);
589 +        break;
590 +      }
591 +      case 'w' : {
592 +        
593 +        RealType flucQVel;
594 +        flucQVel = tokenizer.nextTokenAsDouble();
595 +        sd->setFlucQVel(flucQVel);
596 +        break;
597 +      }
598 +      case 'g' : {
599 +        
600 +        RealType flucQFrc;
601 +        flucQFrc = tokenizer.nextTokenAsDouble();
602 +        sd->setFlucQFrc(flucQFrc);
603 +        break;
604 +      }
605 +      case 'e' : {
606 +        
607 +        Vector3d eField;
608 +        eField[0] = tokenizer.nextTokenAsDouble();
609 +        eField[1] = tokenizer.nextTokenAsDouble();
610 +        eField[2] = tokenizer.nextTokenAsDouble();  
611 +        sd->setElectricField(eField);          
612 +        break;
613 +      }
614 +      default: {
615 +        sprintf(painCave.errMsg,
616 +                "DumpReader Error: %s is an unrecognized type\n", type.c_str());
617 +        painCave.isFatal = 1;
618 +        simError();
619 +        break;  
620 +      }
621 +      }
622 +    }    
623 +  }
624 +  
625 +  
626 +  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
627 +    
628      inputStream.getline(buffer, bufferSize);
629      std::string line(buffer);
630      
# Line 476 | Line 647 | namespace OpenMD {
647    
648    }
649  
650 +  void  DumpReader::readSiteData(std::istream& inputStream) {
651 +
652 +    inputStream.getline(buffer, bufferSize);
653 +    std::string line(buffer);
654 +    
655 +    if (line.find("<SiteData>") == std::string::npos) {
656 +      // site data isn't required for a simulation, so skip
657 +      return;
658 +    }
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();

Comparing:
trunk/src/io/DumpReader.cpp (property svn:keywords), Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
branches/development/src/io/DumpReader.cpp (property svn:keywords), Revision 1752 by gezelter, Sun Jun 10 14:05:02 2012 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

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