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

Comparing trunk/src/brains/SimCreator.cpp (file contents):
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC vs.
Revision 1796 by gezelter, Mon Sep 10 18:38:44 2012 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
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
# 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   /**
# Line 55 | Line 56
56   #include "brains/SimCreator.hpp"
57   #include "brains/SimSnapshotManager.hpp"
58   #include "io/DumpReader.hpp"
59 < #include "UseTheForce/ForceFieldFactory.hpp"
59 > #include "brains/ForceField.hpp"
60   #include "utils/simError.h"
61   #include "utils/StringUtils.hpp"
62   #include "math/SeqRandNumGen.hpp"
# Line 75 | Line 76
76   #include "antlr/NoViableAltForCharException.hpp"
77   #include "antlr/NoViableAltException.hpp"
78  
79 + #include "types/DirectionalAdapter.hpp"
80 + #include "types/MultipoleAdapter.hpp"
81 + #include "types/EAMAdapter.hpp"
82 + #include "types/SuttonChenAdapter.hpp"
83 + #include "types/PolarizableAdapter.hpp"
84 + #include "types/FixedChargeAdapter.hpp"
85 + #include "types/FluctuatingChargeAdapter.hpp"
86 +
87   #ifdef IS_MPI
88 + #include "mpi.h"
89   #include "math/ParallelRandNumGen.hpp"
90   #endif
91  
92   namespace OpenMD {
93    
94 <  Globals* SimCreator::parseFile(std::istream& rawMetaDataStream, const std::string& filename, int startOfMetaDataBlock ){
94 >  Globals* SimCreator::parseFile(std::istream& rawMetaDataStream, const std::string& filename, int mdFileVersion, int startOfMetaDataBlock ){
95      Globals* simParams = NULL;
96      try {
97  
# Line 90 | Line 100 | namespace OpenMD {
100   #ifdef IS_MPI            
101        int streamSize;
102        const int masterNode = 0;
103 <      int commStatus;
103 >
104        if (worldRank == masterNode) {
105 < #endif
106 <                
105 >        MPI::COMM_WORLD.Bcast(&mdFileVersion, 1, MPI::INT, masterNode);
106 > #endif                
107          SimplePreprocessor preprocessor;
108 <        preprocessor.preprocess(rawMetaDataStream, filename, startOfMetaDataBlock, ppStream);
108 >        preprocessor.preprocess(rawMetaDataStream, filename, startOfMetaDataBlock,
109 >                                ppStream);
110                  
111   #ifdef IS_MPI            
112          //brocasting the stream size
113          streamSize = ppStream.str().size() +1;
114 <        commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);                  
115 <
116 <        commStatus = MPI_Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())), streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
106 <            
114 >        MPI::COMM_WORLD.Bcast(&streamSize, 1, MPI::LONG, masterNode);
115 >        MPI::COMM_WORLD.Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())),
116 >                              streamSize, MPI::CHAR, masterNode);
117                  
118        } else {
119 +
120 +        MPI::COMM_WORLD.Bcast(&mdFileVersion, 1, MPI::INT, masterNode);
121 +
122          //get stream size
123 <        commStatus = MPI_Bcast(&streamSize, 1, MPI_LONG, masterNode, MPI_COMM_WORLD);  
123 >        MPI::COMM_WORLD.Bcast(&streamSize, 1, MPI::LONG, masterNode);
124  
125          char* buf = new char[streamSize];
126          assert(buf);
127                  
128          //receive file content
129 <        commStatus = MPI_Bcast(buf, streamSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
129 >        MPI::COMM_WORLD.Bcast(buf, streamSize, MPI::CHAR, masterNode);
130                  
131          ppStream.str(buf);
132          delete [] buf;
# Line 229 | Line 242 | namespace OpenMD {
242        simError();
243      }
244  
245 +    simParams->setMDfileVersion(mdFileVersion);
246      return simParams;
247    }
248    
249    SimInfo*  SimCreator::createSim(const std::string & mdFileName,
250                                    bool loadInitCoords) {
251 <
251 >    
252      const int bufferSize = 65535;
253      char buffer[bufferSize];
254      int lineNo = 0;
# Line 242 | Line 256 | namespace OpenMD {
256      int metaDataBlockStart = -1;
257      int metaDataBlockEnd = -1;
258      int i;
259 <    int mdOffset;
259 >    streamoff mdOffset(0);
260 >    int mdFileVersion;
261  
262 +
263   #ifdef IS_MPI            
264      const int masterNode = 0;
265      if (worldRank == masterNode) {
266   #endif
267  
268 <      std::ifstream mdFile_(mdFileName.c_str());
268 >      std::ifstream mdFile_;
269 >      mdFile_.open(mdFileName.c_str(), ifstream::in | ifstream::binary);
270        
271        if (mdFile_.fail()) {
272          sprintf(painCave.errMsg,
# Line 276 | Line 293 | namespace OpenMD {
293          painCave.isFatal = 1;
294          simError();
295        }
296 +      
297 +      // found the correct opening string, now try to get the file
298 +      // format version number.
299  
300 +      StringTokenizer tokenizer(line, "=<> \t\n\r");
301 +      std::string fileType = tokenizer.nextToken();
302 +      toUpper(fileType);
303 +
304 +      mdFileVersion = 0;
305 +
306 +      if (fileType == "OPENMD") {
307 +        while (tokenizer.hasMoreTokens()) {
308 +          std::string token(tokenizer.nextToken());
309 +          toUpper(token);
310 +          if (token == "VERSION") {
311 +            mdFileVersion = tokenizer.nextTokenAsInt();
312 +            break;
313 +          }
314 +        }
315 +      }
316 +            
317        //scan through the input stream and find MetaData tag        
318        while(mdFile_.getline(buffer, bufferSize)) {
319          ++lineNo;
# Line 332 | Line 369 | namespace OpenMD {
369      std::stringstream rawMetaDataStream(mdRawData);
370  
371      //parse meta-data file
372 <    Globals* simParams = parseFile(rawMetaDataStream, mdFileName, metaDataBlockStart+1);
372 >    Globals* simParams = parseFile(rawMetaDataStream, mdFileName, mdFileVersion,
373 >                                   metaDataBlockStart + 1);
374      
375      //create the force field
376 <    ForceField * ff = ForceFieldFactory::getInstance()->createForceField(simParams->getForceField());
376 >    ForceField * ff = new ForceField(simParams->getForceField());
377  
378      if (ff == NULL) {
379        sprintf(painCave.errMsg,
# Line 369 | Line 407 | namespace OpenMD {
407      }
408      
409      ff->parse(forcefieldFileName);
372    ff->setFortranForceOptions();
410      //create SimInfo
411      SimInfo * info = new SimInfo(ff, simParams);
412  
# Line 387 | Line 424 | namespace OpenMD {
424      //create the molecules
425      createMolecules(info);
426      
427 <    
427 >    //find the storage layout
428 >
429 >    int storageLayout = computeStorageLayout(info);
430 >
431      //allocate memory for DataStorage(circular reference, need to
432      //break it)
433 <    info->setSnapshotManager(new SimSnapshotManager(info));
433 >    info->setSnapshotManager(new SimSnapshotManager(info, storageLayout));
434      
435      //set the global index of atoms, rigidbodies and cutoffgroups
436      //(only need to be set once, the global index will never change
# Line 413 | Line 453 | namespace OpenMD {
453      
454      if (loadInitCoords)
455        loadCoordinates(info, mdFileName);    
416    
456      return info;
457    }
458    
# Line 460 | Line 499 | namespace OpenMD {
499      int nTarget;
500      int done;
501      int i;
463    int j;
502      int loops;
503      int which_proc;
504      int nProcessors;
# Line 468 | Line 506 | namespace OpenMD {
506      int nGlobalMols = info->getNGlobalMolecules();
507      std::vector<int> molToProcMap(nGlobalMols, -1); // default to an error condition:
508      
509 <    MPI_Comm_size(MPI_COMM_WORLD, &nProcessors);
509 >    nProcessors = MPI::COMM_WORLD.Get_size();
510      
511      if (nProcessors > nGlobalMols) {
512        sprintf(painCave.errMsg,
# Line 583 | Line 621 | namespace OpenMD {
621        delete myRandom;
622        
623        // Spray out this nonsense to all other processors:
624 <      
587 <      MPI_Bcast(&molToProcMap[0], nGlobalMols, MPI_INT, 0, MPI_COMM_WORLD);
624 >      MPI::COMM_WORLD.Bcast(&molToProcMap[0], nGlobalMols, MPI::INT, 0);
625      } else {
626        
627        // Listen to your marching orders from processor 0:
628 <      
592 <      MPI_Bcast(&molToProcMap[0], nGlobalMols, MPI_INT, 0, MPI_COMM_WORLD);
628 >      MPI::COMM_WORLD.Bcast(&molToProcMap[0], nGlobalMols, MPI::INT, 0);
629      }
630      
631      info->setMolToProcMap(molToProcMap);
# Line 612 | Line 648 | namespace OpenMD {
648   #endif
649          
650          stampId = info->getMoleculeStampId(i);
651 <        Molecule * mol = molCreator.createMolecule(info->getForceField(), info->getMoleculeStamp(stampId),
652 <                                                   stampId, i, info->getLocalIndexManager());
651 >        Molecule * mol = molCreator.createMolecule(info->getForceField(),
652 >                                                   info->getMoleculeStamp(stampId),
653 >                                                   stampId, i,
654 >                                                   info->getLocalIndexManager());
655          
656          info->addMolecule(mol);
657          
# Line 626 | Line 664 | namespace OpenMD {
664      } //end for(int i=0)  
665    }
666      
667 +  int SimCreator::computeStorageLayout(SimInfo* info) {
668 +
669 +    Globals* simParams = info->getSimParams();
670 +    int nRigidBodies = info->getNGlobalRigidBodies();
671 +    set<AtomType*> atomTypes = info->getSimulatedAtomTypes();
672 +    set<AtomType*>::iterator i;
673 +    bool hasDirectionalAtoms = false;
674 +    bool hasFixedCharge = false;
675 +    bool hasMultipoles = false;    
676 +    bool hasPolarizable = false;    
677 +    bool hasFluctuatingCharge = false;    
678 +    bool hasMetallic = false;
679 +    int storageLayout = 0;
680 +    storageLayout |= DataStorage::dslPosition;
681 +    storageLayout |= DataStorage::dslVelocity;
682 +    storageLayout |= DataStorage::dslForce;
683 +
684 +    for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
685 +
686 +      DirectionalAdapter da = DirectionalAdapter( (*i) );
687 +      MultipoleAdapter ma = MultipoleAdapter( (*i) );
688 +      EAMAdapter ea = EAMAdapter( (*i) );
689 +      SuttonChenAdapter sca = SuttonChenAdapter( (*i) );
690 +      PolarizableAdapter pa = PolarizableAdapter( (*i) );
691 +      FixedChargeAdapter fca = FixedChargeAdapter( (*i) );
692 +      FluctuatingChargeAdapter fqa = FluctuatingChargeAdapter( (*i) );
693 +
694 +      if (da.isDirectional()){
695 +        hasDirectionalAtoms = true;
696 +      }
697 +      if (ma.isMultipole()){
698 +        hasMultipoles = true;
699 +      }
700 +      if (ea.isEAM() || sca.isSuttonChen()){
701 +        hasMetallic = true;
702 +      }
703 +      if ( fca.isFixedCharge() ){
704 +        hasFixedCharge = true;
705 +      }
706 +      if ( fqa.isFluctuatingCharge() ){
707 +        hasFluctuatingCharge = true;
708 +      }
709 +      if ( pa.isPolarizable() ){
710 +        hasPolarizable = true;
711 +      }
712 +    }
713 +    
714 +    if (nRigidBodies > 0 || hasDirectionalAtoms) {
715 +      storageLayout |= DataStorage::dslAmat;
716 +      if(storageLayout & DataStorage::dslVelocity) {
717 +        storageLayout |= DataStorage::dslAngularMomentum;
718 +      }
719 +      if (storageLayout & DataStorage::dslForce) {
720 +        storageLayout |= DataStorage::dslTorque;
721 +      }
722 +    }
723 +    if (hasMultipoles) {
724 +      storageLayout |= DataStorage::dslElectroFrame;
725 +    }
726 +    if (hasFixedCharge || hasFluctuatingCharge) {
727 +      storageLayout |= DataStorage::dslSkippedCharge;
728 +    }
729 +    if (hasMetallic) {
730 +      storageLayout |= DataStorage::dslDensity;
731 +      storageLayout |= DataStorage::dslFunctional;
732 +      storageLayout |= DataStorage::dslFunctionalDerivative;
733 +    }
734 +    if (hasPolarizable) {
735 +      storageLayout |= DataStorage::dslElectricField;
736 +    }
737 +    if (hasFluctuatingCharge){
738 +      storageLayout |= DataStorage::dslFlucQPosition;
739 +      if(storageLayout & DataStorage::dslVelocity) {
740 +        storageLayout |= DataStorage::dslFlucQVelocity;
741 +      }
742 +      if (storageLayout & DataStorage::dslForce) {
743 +        storageLayout |= DataStorage::dslFlucQForce;
744 +      }
745 +    }
746 +    
747 +    // if the user has asked for them, make sure we've got the memory for the
748 +    // objects defined.
749 +
750 +    if (simParams->getOutputParticlePotential()) {
751 +      storageLayout |= DataStorage::dslParticlePot;
752 +    }
753 +
754 +    if (simParams->havePrintHeatFlux()) {
755 +      if (simParams->getPrintHeatFlux()) {
756 +        storageLayout |= DataStorage::dslParticlePot;
757 +      }
758 +    }
759 +
760 +    if (simParams->getOutputElectricField()) {
761 +      storageLayout |= DataStorage::dslElectricField;
762 +    }
763 +    if (simParams->getOutputFluctuatingCharges()) {
764 +      storageLayout |= DataStorage::dslFlucQPosition;
765 +      storageLayout |= DataStorage::dslFlucQVelocity;
766 +      storageLayout |= DataStorage::dslFlucQForce;
767 +    }
768 +
769 +    return storageLayout;
770 +  }
771 +
772    void SimCreator::setGlobalIndex(SimInfo *info) {
773      SimInfo::MoleculeIterator mi;
774      Molecule::AtomIterator ai;
# Line 640 | Line 783 | namespace OpenMD {
783      int beginRigidBodyIndex;
784      int beginCutoffGroupIndex;
785      int nGlobalAtoms = info->getNGlobalAtoms();
643
644    /**@todo fixme */
645 #ifndef IS_MPI
786      
787      beginAtomIndex = 0;
648    beginRigidBodyIndex = 0;
649    beginCutoffGroupIndex = 0;
650    
651 #else
652    
653    int nproc;
654    int myNode;
655    
656    myNode = worldRank;
657    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
658    
659    std::vector < int > tmpAtomsInProc(nproc, 0);
660    std::vector < int > tmpRigidBodiesInProc(nproc, 0);
661    std::vector < int > tmpCutoffGroupsInProc(nproc, 0);
662    std::vector < int > NumAtomsInProc(nproc, 0);
663    std::vector < int > NumRigidBodiesInProc(nproc, 0);
664    std::vector < int > NumCutoffGroupsInProc(nproc, 0);
665    
666    tmpAtomsInProc[myNode] = info->getNAtoms();
667    tmpRigidBodiesInProc[myNode] = info->getNRigidBodies();
668    tmpCutoffGroupsInProc[myNode] = info->getNCutoffGroups();
669    
670    //do MPI_ALLREDUCE to exchange the total number of atoms, rigidbodies and cutoff groups
671    MPI_Allreduce(&tmpAtomsInProc[0], &NumAtomsInProc[0], nproc, MPI_INT,
672                  MPI_SUM, MPI_COMM_WORLD);
673    MPI_Allreduce(&tmpRigidBodiesInProc[0], &NumRigidBodiesInProc[0], nproc,
674                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
675    MPI_Allreduce(&tmpCutoffGroupsInProc[0], &NumCutoffGroupsInProc[0], nproc,
676                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
677    
678    beginAtomIndex = 0;
679    beginRigidBodyIndex = 0;
680    beginCutoffGroupIndex = 0;
681    
682    for(int i = 0; i < myNode; i++) {
683      beginAtomIndex += NumAtomsInProc[i];
684      beginRigidBodyIndex += NumRigidBodiesInProc[i];
685      beginCutoffGroupIndex += NumCutoffGroupsInProc[i];
686    }
687    
688 #endif
689    
788      //rigidbody's index begins right after atom's
789 <    beginRigidBodyIndex += info->getNGlobalAtoms();
790 <    
791 <    for(mol = info->beginMolecule(mi); mol != NULL;
792 <        mol = info->nextMolecule(mi)) {
789 >    beginRigidBodyIndex = info->getNGlobalAtoms();
790 >    beginCutoffGroupIndex = 0;
791 >
792 >    for(int i = 0; i < info->getNGlobalMolecules(); i++) {
793        
794 <      //local index(index in DataStorge) of atom is important
795 <      for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
796 <        atom->setGlobalIndex(beginAtomIndex++);
794 > #ifdef IS_MPI      
795 >      if (info->getMolToProc(i) == worldRank) {
796 > #endif        
797 >        // stuff to do if I own this molecule
798 >        mol = info->getMoleculeByGlobalIndex(i);
799 >
800 >        //local index(index in DataStorge) of atom is important
801 >        for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
802 >          atom->setGlobalIndex(beginAtomIndex++);
803 >        }
804 >        
805 >        for(rb = mol->beginRigidBody(ri); rb != NULL;
806 >            rb = mol->nextRigidBody(ri)) {
807 >          rb->setGlobalIndex(beginRigidBodyIndex++);
808 >        }
809 >        
810 >        //local index of cutoff group is trivial, it only depends on
811 >        //the order of travesing
812 >        for(cg = mol->beginCutoffGroup(ci); cg != NULL;
813 >            cg = mol->nextCutoffGroup(ci)) {
814 >          cg->setGlobalIndex(beginCutoffGroupIndex++);
815 >        }        
816 >        
817 > #ifdef IS_MPI        
818 >      }  else {
819 >
820 >        // stuff to do if I don't own this molecule
821 >        
822 >        int stampId = info->getMoleculeStampId(i);
823 >        MoleculeStamp* stamp = info->getMoleculeStamp(stampId);
824 >
825 >        beginAtomIndex += stamp->getNAtoms();
826 >        beginRigidBodyIndex += stamp->getNRigidBodies();
827 >        beginCutoffGroupIndex += stamp->getNCutoffGroups() + stamp->getNFreeAtoms();
828        }
829 <      
830 <      for(rb = mol->beginRigidBody(ri); rb != NULL;
831 <          rb = mol->nextRigidBody(ri)) {
832 <        rb->setGlobalIndex(beginRigidBodyIndex++);
704 <      }
705 <      
706 <      //local index of cutoff group is trivial, it only depends on the order of travesing
707 <      for(cg = mol->beginCutoffGroup(ci); cg != NULL;
708 <          cg = mol->nextCutoffGroup(ci)) {
709 <        cg->setGlobalIndex(beginCutoffGroupIndex++);
710 <      }
711 <    }
712 <    
829 > #endif          
830 >
831 >    } //end for(int i=0)  
832 >
833      //fill globalGroupMembership
834      std::vector<int> globalGroupMembership(info->getNGlobalAtoms(), 0);
835      for(mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {        
# Line 721 | Line 841 | namespace OpenMD {
841          
842        }      
843      }
844 <    
844 >  
845   #ifdef IS_MPI    
846      // Since the globalGroupMembership has been zero filled and we've only
847      // poked values into the atoms we know, we can do an Allreduce
# Line 729 | Line 849 | namespace OpenMD {
849      // This would be prettier if we could use MPI_IN_PLACE like the MPI-2
850      // docs said we could.
851      std::vector<int> tmpGroupMembership(info->getNGlobalAtoms(), 0);
852 <    MPI_Allreduce(&globalGroupMembership[0], &tmpGroupMembership[0], nGlobalAtoms,
853 <                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
852 >    MPI::COMM_WORLD.Allreduce(&globalGroupMembership[0],
853 >                              &tmpGroupMembership[0], nGlobalAtoms,
854 >                              MPI::INT, MPI::SUM);
855      info->setGlobalGroupMembership(tmpGroupMembership);
856   #else
857      info->setGlobalGroupMembership(globalGroupMembership);
# Line 747 | Line 868 | namespace OpenMD {
868      
869   #ifdef IS_MPI
870      std::vector<int> tmpMolMembership(info->getNGlobalAtoms(), 0);
871 +    MPI::COMM_WORLD.Allreduce(&globalMolMembership[0], &tmpMolMembership[0],
872 +                              nGlobalAtoms,
873 +                              MPI::INT, MPI::SUM);
874      
751    MPI_Allreduce(&globalMolMembership[0], &tmpMolMembership[0], nGlobalAtoms,
752                  MPI_INT, MPI_SUM, MPI_COMM_WORLD);
753    
875      info->setGlobalMolMembership(tmpMolMembership);
876   #else
877      info->setGlobalMolMembership(globalMolMembership);
# Line 766 | Line 887 | namespace OpenMD {
887      
888   #ifdef IS_MPI
889      std::vector<int> numIntegrableObjectsPerMol(info->getNGlobalMolecules(), 0);
890 <    MPI_Allreduce(&nIOPerMol[0], &numIntegrableObjectsPerMol[0],
891 <                  info->getNGlobalMolecules(), MPI_INT, MPI_SUM, MPI_COMM_WORLD);
890 >    MPI::COMM_WORLD.Allreduce(&nIOPerMol[0], &numIntegrableObjectsPerMol[0],
891 >                              info->getNGlobalMolecules(), MPI::INT, MPI::SUM);
892   #else
893      std::vector<int> numIntegrableObjectsPerMol = nIOPerMol;
894   #endif    
# Line 784 | Line 905 | namespace OpenMD {
905      for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
906        int myGlobalIndex = mol->getGlobalIndex();
907        int globalIO = startingIOIndexForMol[myGlobalIndex];
908 <      for (StuntDouble* integrableObject = mol->beginIntegrableObject(ioi); integrableObject != NULL;
909 <           integrableObject = mol->nextIntegrableObject(ioi)) {
910 <        integrableObject->setGlobalIntegrableObjectIndex(globalIO);
911 <        IOIndexToIntegrableObject[globalIO] = integrableObject;
908 >      for (StuntDouble* sd = mol->beginIntegrableObject(ioi); sd != NULL;
909 >           sd = mol->nextIntegrableObject(ioi)) {
910 >        sd->setGlobalIntegrableObjectIndex(globalIO);
911 >        IOIndexToIntegrableObject[globalIO] = sd;
912          globalIO++;
913        }
914      }
915 <    
915 >      
916      info->setIOIndexToIntegrableObject(IOIndexToIntegrableObject);
917      
918    }
919    
920    void SimCreator::loadCoordinates(SimInfo* info, const std::string& mdFileName) {
921 <    Globals* simParams;
801 <    simParams = info->getSimParams();
802 <    
803 <    
921 >
922      DumpReader reader(info, mdFileName);
923      int nframes = reader.getNFrames();
924 <    
924 >
925      if (nframes > 0) {
926        reader.readFrame(nframes - 1);
927      } else {
# Line 814 | Line 932 | namespace OpenMD {
932        painCave.isFatal = 1;
933        simError();
934      }
817    
935      //copy the current snapshot to previous snapshot
936      info->getSnapshotManager()->advance();
937    }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines