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 1241 by gezelter, Fri Apr 25 15:14:47 2008 UTC vs.
Revision 2001 by gezelter, Sun Jun 1 00:34:30 2014 UTC

# Line 1 | Line 1
1 < /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 < *
4 < * The University of Notre Dame grants you ("Licensee") a
5 < * non-exclusive, royalty free, license to use, modify and
6 < * redistribute this software in source and binary code form, provided
7 < * that the following conditions are met:
8 < *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
19 < *    notice, this list of conditions and the following disclaimer.
20 < *
21 < * 3. Redistributions in binary form must reproduce the above copyright
22 < *    notice, this list of conditions and the following disclaimer in the
23 < *    documentation and/or other materials provided with the
24 < *    distribution.
25 < *
26 < * This software is provided "AS IS," without a warranty of any
27 < * kind. All express or implied conditions, representations and
28 < * warranties, including any implied warranty of merchantability,
29 < * fitness for a particular purpose or non-infringement, are hereby
30 < * excluded.  The University of Notre Dame and its licensors shall not
31 < * be liable for any damages suffered by licensee as a result of
32 < * using, modifying or distributing the software or its
33 < * derivatives. In no event will the University of Notre Dame or its
34 < * licensors be liable for any lost revenue, profit or data, or for
35 < * direct, indirect, special, consequential, incidental or punitive
36 < * damages, however caused and regardless of the theory of liability,
37 < * arising out of the use of or inability to use software, even if the
38 < * University of Notre Dame has been advised of the possibility of
39 < * such damages.
40 < */
1 > /*
2 > * Copyright (c) 2009 The University of Notre Dame. All Rights Reserved.
3 > *
4 > * The University of Notre Dame grants you ("Licensee") a
5 > * non-exclusive, royalty free, license to use, modify and
6 > * redistribute this software in source and binary code form, provided
7 > * that the following conditions are met:
8 > *
9 > * 1. Redistributions of source code must retain the above copyright
10 > *    notice, this list of conditions and the following disclaimer.
11 > *
12 > * 2. Redistributions in binary form must reproduce the above copyright
13 > *    notice, this list of conditions and the following disclaimer in the
14 > *    documentation and/or other materials provided with the
15 > *    distribution.
16 > *
17 > * This software is provided "AS IS," without a warranty of any
18 > * kind. All express or implied conditions, representations and
19 > * warranties, including any implied warranty of merchantability,
20 > * fitness for a particular purpose or non-infringement, are hereby
21 > * excluded.  The University of Notre Dame and its licensors shall not
22 > * be liable for any damages suffered by licensee as a result of
23 > * using, modifying or distributing the software or its
24 > * derivatives. In no event will the University of Notre Dame or its
25 > * licensors be liable for any lost revenue, profit or data, or for
26 > * direct, indirect, special, consequential, incidental or punitive
27 > * damages, however caused and regardless of the theory of liability,
28 > * arising out of the use of or inability to use software, even if the
29 > * University of Notre Dame has been advised of the possibility of
30 > * such damages.
31 > *
32 > * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 > * research, please cite the appropriate papers when you publish your
34 > * work.  Good starting points are:
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, 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  
68 < #include <mpi.h>
64 < #define TAKE_THIS_TAG_CHAR 0
65 < #define TAKE_THIS_TAG_INT 1
66 <
67 < #endif // is_mpi
68 <
69 <
70 < namespace oopse {
68 > namespace OpenMD {
69    
70    DumpReader::DumpReader(SimInfo* info, const std::string& filename)
71      : info_(info), filename_(filename), isScanned_(false), nframes_(0), needCOMprops_(false) {
# Line 77 | Line 75 | namespace oopse {
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 oopse {
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 oopse {
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 oopse {
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 oopse {
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 oopse {
246  
247      if (needCOMprops_) {
248        Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
249 +      Thermo thermo(info_);
250        Vector3d com;
247      Vector3d comvel;
248      Vector3d comw;
249      if (needPos_ && needVel_){
250        info_->getComAll(com, comvel);
251        comw = info_->getAngularMomentum();
252      }else{
253        com = info_->getCom();
254        comvel = 0.0;
255        comw   = 0.0;
256      }
257      s->setCOMprops(com, comvel, comw);      
258    }
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 +    }
261    }
262    
263    void DumpReader::readSet(int whichFrame) {    
264      std::string line;
265  
266   #ifndef IS_MPI
266
267      inFile_->clear();  
268      inFile_->seekg(framePos_[whichFrame]);
269  
# Line 290 | Line 290 | namespace oopse {
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);    
293 >      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize,
294 >                MPI_CHAR, masterNode, MPI_COMM_WORLD);    
295        
296        sstream.str(sendBuffer);
297      } else {
298        int sendBufferSize;
299 <      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
299 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);
300        char * recvBuffer = new char[sendBufferSize+1];
301 <      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
301 >      assert(recvBuffer);
302 >      recvBuffer[sendBufferSize] = '\0';
303 >      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
304        sstream.str(recvBuffer);
305 +      delete [] recvBuffer;
306      }      
307  
308      std::istream& inputStream = sstream;  
# Line 322 | Line 326 | namespace oopse {
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 339 | Line 348 | namespace oopse {
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 348 | Line 357 | namespace oopse {
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();
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 (sd->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]) {
398          
# Line 365 | Line 402 | namespace oopse {
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 375 | Line 412 | namespace oopse {
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 390 | Line 427 | namespace oopse {
427               q[3] = tokenizer.nextTokenAsDouble();
428                
429               RealType qlen = q.length();
430 <             if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
430 >             if (qlen < OpenMD::epsilon) { //check quaternion is not equal to 0
431                  
432                 sprintf(painCave.errMsg,
433                         "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
# Line 401 | Line 438 | namespace oopse {
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 424 | Line 461 | namespace oopse {
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 433 | Line 470 | namespace oopse {
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 +           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 +        case 's' : {
514 +
515 +           RealType sPot;
516 +           sPot = tokenizer.nextTokenAsDouble();
517 +           sd->setSitePotential(sPot);          
518 +           break;
519 +        }
520          default: {
521                 sprintf(painCave.errMsg,
522                         "DumpReader Error: %s is an unrecognized type\n", type.c_str());
# Line 446 | Line 527 | namespace oopse {
527  
528        }
529      }
449    
530    }
531    
532  
533 <  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
533 >  void DumpReader::parseSiteLine(const std::string& line) {
534  
535 +    StringTokenizer tokenizer(line);
536 +    int nTokens;
537 +        
538 +    nTokens = tokenizer.countTokens();
539 +    
540 +    if (nTokens < 2) {  
541 +      sprintf(painCave.errMsg,
542 +              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
543 +      painCave.isFatal = 1;
544 +      simError();
545 +    }
546 +
547 +    /**
548 +     * The first token is the global integrable object index.
549 +     */
550 +
551 +    int index = tokenizer.nextTokenAsInt();
552 +    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
553 +    if (sd == NULL) {
554 +      return;
555 +    }
556 +
557 +    /**
558 +     * Test to see if the next token is an integer or not.  If not,
559 +     * we've got data on the integrable object itself.  If there is an
560 +     * integer, we're parsing data for a site on a rigid body.
561 +     */
562 +
563 +    std::string indexTest = tokenizer.peekNextToken();
564 +    std::istringstream i(indexTest);
565 +    int siteIndex;
566 +    if (i >> siteIndex) {
567 +      // chew up this token and parse as an int:
568 +      siteIndex = tokenizer.nextTokenAsInt();
569 +
570 +      if (sd->isRigidBody()) {
571 +        RigidBody* rb = static_cast<RigidBody*>(sd);
572 +        sd = rb->getAtoms()[siteIndex];
573 +      }
574 +    }
575 +
576 +    /**
577 +     * The next token contains information on what follows.
578 +     */
579 +    std::string type = tokenizer.nextToken();
580 +    int size = type.size();
581 +    
582 +    for(int i = 0; i < size; ++i) {
583 +      switch(type[i]) {
584 +        
585 +      case 'u' : {
586 +        
587 +        RealType particlePot;
588 +        particlePot = tokenizer.nextTokenAsDouble();
589 +        sd->setParticlePot(particlePot);
590 +        break;
591 +      }
592 +      case 'c' : {
593 +        
594 +        RealType flucQPos;
595 +        flucQPos = tokenizer.nextTokenAsDouble();
596 +        sd->setFlucQPos(flucQPos);
597 +        break;
598 +      }
599 +      case 'w' : {
600 +        
601 +        RealType flucQVel;
602 +        flucQVel = tokenizer.nextTokenAsDouble();
603 +        sd->setFlucQVel(flucQVel);
604 +        break;
605 +      }
606 +      case 'g' : {
607 +        
608 +        RealType flucQFrc;
609 +        flucQFrc = tokenizer.nextTokenAsDouble();
610 +        sd->setFlucQFrc(flucQFrc);
611 +        break;
612 +      }
613 +      case 'e' : {
614 +        
615 +        Vector3d eField;
616 +        eField[0] = tokenizer.nextTokenAsDouble();
617 +        eField[1] = tokenizer.nextTokenAsDouble();
618 +        eField[2] = tokenizer.nextTokenAsDouble();  
619 +        sd->setElectricField(eField);          
620 +        break;
621 +      }
622 +      case 's' : {
623 +        
624 +        RealType sPot;
625 +        sPot = tokenizer.nextTokenAsDouble();
626 +        sd->setSitePotential(sPot);          
627 +        break;
628 +      }
629 +      default: {
630 +        sprintf(painCave.errMsg,
631 +                "DumpReader Error: %s is an unrecognized type\n", type.c_str());
632 +        painCave.isFatal = 1;
633 +        simError();
634 +        break;  
635 +      }
636 +      }
637 +    }    
638 +  }
639 +  
640 +  
641 +    void  DumpReader::readStuntDoubles(std::istream& inputStream) {
642 +    
643      inputStream.getline(buffer, bufferSize);
644      std::string line(buffer);
645      
# Line 474 | Line 662 | namespace oopse {
662    
663    }
664  
665 +  void  DumpReader::readSiteData(std::istream& inputStream) {
666 +
667 +    std::string line(buffer);
668 +
669 +    // We already found the starting <SiteData> tag or we wouldn't be
670 +    // here, so just start parsing until we get to the ending
671 +    // </SiteData> tag:
672 +    
673 +    while(inputStream.getline(buffer, bufferSize)) {
674 +      line = buffer;
675 +      
676 +      if(line.find("</SiteData>") != std::string::npos) {
677 +        break;
678 +      }
679 +
680 +      parseSiteLine(line);
681 +    }
682 +  
683 +  }
684 +
685    void DumpReader::readFrameProperties(std::istream& inputStream) {
686  
687      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
# Line 519 | Line 727 | namespace oopse {
727          hmat(2, 2) = tokenizer.nextTokenAsDouble();
728          s->setHmat(hmat);      
729        } else if (propertyName == "Thermostat") {
730 <        RealType chi = tokenizer.nextTokenAsDouble();
731 <        RealType integralOfChiDt = tokenizer.nextTokenAsDouble();
732 <        s->setChi(chi);
733 <        s->setIntegralOfChiDt(integralOfChiDt);        
730 >        pair<RealType, RealType> thermostat;
731 >        thermostat.first = tokenizer.nextTokenAsDouble();
732 >        thermostat.second = tokenizer.nextTokenAsDouble();
733 >        s->setThermostat(thermostat);
734       } else if (propertyName == "Barostat") {
735          Mat3x3d eta;
736          eta(0, 0) = tokenizer.nextTokenAsDouble();
# Line 534 | Line 742 | namespace oopse {
742          eta(2, 0) = tokenizer.nextTokenAsDouble();
743          eta(2, 1) = tokenizer.nextTokenAsDouble();
744          eta(2, 2) = tokenizer.nextTokenAsDouble();
745 <        s->setEta(eta);
745 >        s->setBarostat(eta);
746        } else {
747          sprintf(painCave.errMsg,
748                  "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str());
# Line 547 | Line 755 | namespace oopse {
755    }
756  
757    
758 < }//end namespace oopse
758 > }//end namespace OpenMD

Comparing trunk/src/io/DumpReader.cpp (property svn:keywords):
Revision 1241 by gezelter, Fri Apr 25 15:14:47 2008 UTC vs.
Revision 2001 by gezelter, Sun Jun 1 00:34:30 2014 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines