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

Comparing branches/development/src/io/DumpReader.cpp (file contents):
Revision 1764 by gezelter, Tue Jul 3 18:32:27 2012 UTC vs.
Revision 1850 by gezelter, Wed Feb 20 15:39:39 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).          
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   */
# Line 75 | 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 140 | Line 141 | namespace OpenMD {
141        prevPos = currPos;
142        bool foundOpenSnapshotTag = false;
143        bool foundClosedSnapshotTag = false;
144 <      bool foundOpenSiteDataTag = false;
144 >
145        while(inFile_->getline(buffer, bufferSize)) {
146          ++lineNo;
147          
# Line 201 | Line 202 | namespace OpenMD {
202   #ifdef IS_MPI
203      }
204      
205 <    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
205 >    MPI::COMM_WORLD.Bcast(&nframes_, 1, MPI::INT, 0);
206      
207   #endif // is_mpi
208      
# Line 226 | Line 227 | namespace OpenMD {
227        needVel_ = false;
228      }
229      
230 <    if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) {
230 >    if (storageLayout & DataStorage::dslAmat ||
231 >        storageLayout & DataStorage::dslDipole ||
232 >        storageLayout & DataStorage::dslQuadrupole) {
233        needQuaternion_ = true;
234      } else {
235        needQuaternion_ = false;
# Line 285 | Line 288 | namespace OpenMD {
288        }
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);    
291 >      MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode);    
292 >      MPI::COMM_WORLD.Bcast((void *)sendBuffer.c_str(), sendBufferSize,
293 >                            MPI::CHAR, masterNode);    
294        
295        sstream.str(sendBuffer);
296      } else {
297        int sendBufferSize;
298 <      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
298 >      MPI::COMM_WORLD.Bcast(&sendBufferSize, 1, MPI::INT, masterNode);
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::COMM_WORLD.Bcast(recvBuffer, sendBufferSize, MPI::CHAR, masterNode);
303        sstream.str(recvBuffer);
304        delete [] recvBuffer;
305      }      
# Line 352 | 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();
# Line 374 | Line 378 | namespace OpenMD {
378        }
379      }
380      
381 <    if (integrableObject->isDirectional()) {
381 >    if (sd->isDirectional()) {
382        if (needQuaternion_) {
383          found = type.find("q");      
384          if (found == std::string::npos) {
# Line 397 | 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 407 | 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 433 | 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 456 | 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 465 | 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 <           integrableObject->setParticlePot(particlePot);          
479 >           sd->setParticlePot(particlePot);          
480             break;
481          }
482          case 'c' : {
483  
484             RealType flucQPos;
485             flucQPos = tokenizer.nextTokenAsDouble();
486 <           integrableObject->setFlucQPos(flucQPos);          
486 >           sd->setFlucQPos(flucQPos);          
487             break;
488          }
489          case 'w' : {
490  
491             RealType flucQVel;
492             flucQVel = tokenizer.nextTokenAsDouble();
493 <           integrableObject->setFlucQVel(flucQVel);          
493 >           sd->setFlucQVel(flucQVel);          
494             break;
495          }
496          case 'g' : {
497  
498             RealType flucQFrc;
499             flucQFrc = tokenizer.nextTokenAsDouble();
500 <           integrableObject->setFlucQFrc(flucQFrc);          
500 >           sd->setFlucQFrc(flucQFrc);          
501             break;
502          }
503          case 'e' : {
# Line 502 | Line 506 | namespace OpenMD {
506             eField[0] = tokenizer.nextTokenAsDouble();
507             eField[1] = tokenizer.nextTokenAsDouble();
508             eField[2] = tokenizer.nextTokenAsDouble();          
509 <           integrableObject->setElectricField(eField);          
509 >           sd->setElectricField(eField);          
510             break;
511          }
512          default: {
# Line 538 | Line 542 | namespace OpenMD {
542       */
543  
544      int index = tokenizer.nextTokenAsInt();
545 <    StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index);
546 <    if (integrableObject == NULL) {
545 >    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
546 >    if (sd == NULL) {
547        return;
548      }
545 –    StuntDouble* sd = integrableObject;
549  
550      /**
551       * Test to see if the next token is an integer or not.  If not,
# Line 556 | Line 559 | namespace OpenMD {
559      if (i >> siteIndex) {
560        // chew up this token and parse as an int:
561        siteIndex = tokenizer.nextTokenAsInt();
562 <      RigidBody* rb = static_cast<RigidBody*>(integrableObject);
562 >      RigidBody* rb = static_cast<RigidBody*>(sd);
563        sd = rb->getAtoms()[siteIndex];
564      }
565  

Diff Legend

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