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

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1767 by gezelter, Fri Jul 6 22:01:58 2012 UTC vs.
Revision 1825 by gezelter, Wed Jan 9 19:27:52 2013 UTC

# Line 88 | Line 88 | namespace OpenMD {
88      
89      vector<Component*> components = simParams->getComponents();
90      
91 <    for (vector<Component*>::iterator i = components.begin(); i !=components.end(); ++i) {
91 >    for (vector<Component*>::iterator i = components.begin();
92 >         i !=components.end(); ++i) {
93        molStamp = (*i)->getMoleculeStamp();
94        nMolWithSameStamp = (*i)->getNMol();
95        
# Line 231 | Line 232 | namespace OpenMD {
232      vector<Atom*>::iterator k;
233  
234      Molecule* mol;
235 <    StuntDouble* integrableObject;
235 >    StuntDouble* sd;
236      Atom* atom;
237  
238      ndf_local = 0;
239      nfq_local = 0;
240      
241      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
241 –      for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
242 –           integrableObject = mol->nextIntegrableObject(j)) {
242  
243 +      for (sd = mol->beginIntegrableObject(j); sd != NULL;
244 +           sd = mol->nextIntegrableObject(j)) {
245 +
246          ndf_local += 3;
247  
248 <        if (integrableObject->isDirectional()) {
249 <          if (integrableObject->isLinear()) {
248 >        if (sd->isDirectional()) {
249 >          if (sd->isLinear()) {
250              ndf_local += 2;
251            } else {
252              ndf_local += 3;
253            }
254          }
255        }
256 +
257        for (atom = mol->beginFluctuatingCharge(k); atom != NULL;
258             atom = mol->nextFluctuatingCharge(k)) {
259          if (atom->isFluctuatingCharge()) {
# Line 265 | Line 268 | namespace OpenMD {
268      ndf_local -= nConstraints_;
269  
270   #ifdef IS_MPI
271 <    MPI_Allreduce(&ndf_local,&ndf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
272 <    MPI_Allreduce(&nfq_local,&nGlobalFluctuatingCharges_,1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
271 >    MPI::COMM_WORLD.Allreduce(&ndf_local, &ndf_, 1, MPI::INT,MPI::SUM);
272 >    MPI::COMM_WORLD.Allreduce(&nfq_local, &nGlobalFluctuatingCharges_, 1,
273 >                              MPI::INT, MPI::SUM);
274   #else
275      ndf_ = ndf_local;
276      nGlobalFluctuatingCharges_ = nfq_local;
# Line 280 | Line 284 | namespace OpenMD {
284  
285    int SimInfo::getFdf() {
286   #ifdef IS_MPI
287 <    MPI_Allreduce(&fdf_local,&fdf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
287 >    MPI::COMM_WORLD.Allreduce(&fdf_local, &fdf_, 1, MPI::INT, MPI::SUM);
288   #else
289      fdf_ = fdf_local;
290   #endif
# Line 312 | Line 316 | namespace OpenMD {
316      MoleculeIterator i;
317      vector<StuntDouble*>::iterator j;
318      Molecule* mol;
319 <    StuntDouble* integrableObject;
319 >    StuntDouble* sd;
320  
321      // Raw degrees of freedom that we have to set
322      ndfRaw_local = 0;
323      
324      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
321 –      for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
322 –           integrableObject = mol->nextIntegrableObject(j)) {
325  
326 +      for (sd = mol->beginIntegrableObject(j); sd != NULL;
327 +           sd = mol->nextIntegrableObject(j)) {
328 +
329          ndfRaw_local += 3;
330  
331 <        if (integrableObject->isDirectional()) {
332 <          if (integrableObject->isLinear()) {
331 >        if (sd->isDirectional()) {
332 >          if (sd->isLinear()) {
333              ndfRaw_local += 2;
334            } else {
335              ndfRaw_local += 3;
# Line 335 | Line 340 | namespace OpenMD {
340      }
341      
342   #ifdef IS_MPI
343 <    MPI_Allreduce(&ndfRaw_local,&ndfRaw_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
343 >    MPI::COMM_WORLD.Allreduce(&ndfRaw_local, &ndfRaw_, 1, MPI::INT, MPI::SUM);
344   #else
345      ndfRaw_ = ndfRaw_local;
346   #endif
# Line 348 | Line 353 | namespace OpenMD {
353  
354  
355   #ifdef IS_MPI
356 <    MPI_Allreduce(&ndfTrans_local,&ndfTrans_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
356 >    MPI::COMM_WORLD.Allreduce(&ndfTrans_local, &ndfTrans_, 1,
357 >                              MPI::INT, MPI::SUM);
358   #else
359      ndfTrans_ = ndfTrans_local;
360   #endif
# Line 384 | Line 390 | namespace OpenMD {
390      Molecule::RigidBodyIterator rbIter;
391      RigidBody* rb;
392      Molecule::IntegrableObjectIterator ii;
393 <    StuntDouble* integrableObject;
393 >    StuntDouble* sd;
394      
395 <    for (integrableObject = mol->beginIntegrableObject(ii);
396 <         integrableObject != NULL;
391 <         integrableObject = mol->nextIntegrableObject(ii)) {
395 >    for (sd = mol->beginIntegrableObject(ii); sd != NULL;
396 >         sd = mol->nextIntegrableObject(ii)) {
397        
398 <      if (integrableObject->isRigidBody()) {
399 <        rb = static_cast<RigidBody*>(integrableObject);
398 >      if (sd->isRigidBody()) {
399 >        rb = static_cast<RigidBody*>(sd);
400          vector<Atom*> atoms = rb->getAtoms();
401          set<int> rigidAtoms;
402          for (int i = 0; i < static_cast<int>(atoms.size()); ++i) {
# Line 402 | Line 407 | namespace OpenMD {
407          }      
408        } else {
409          set<int> oneAtomSet;
410 <        oneAtomSet.insert(integrableObject->getGlobalIndex());
411 <        atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
410 >        oneAtomSet.insert(sd->getGlobalIndex());
411 >        atomGroups.insert(map<int, set<int> >::value_type(sd->getGlobalIndex(), oneAtomSet));        
412        }
413      }  
414            
# Line 537 | Line 542 | namespace OpenMD {
542      Molecule::RigidBodyIterator rbIter;
543      RigidBody* rb;
544      Molecule::IntegrableObjectIterator ii;
545 <    StuntDouble* integrableObject;
545 >    StuntDouble* sd;
546      
547 <    for (integrableObject = mol->beginIntegrableObject(ii);
548 <         integrableObject != NULL;
544 <         integrableObject = mol->nextIntegrableObject(ii)) {
547 >    for (sd = mol->beginIntegrableObject(ii); sd != NULL;
548 >         sd = mol->nextIntegrableObject(ii)) {
549        
550 <      if (integrableObject->isRigidBody()) {
551 <        rb = static_cast<RigidBody*>(integrableObject);
550 >      if (sd->isRigidBody()) {
551 >        rb = static_cast<RigidBody*>(sd);
552          vector<Atom*> atoms = rb->getAtoms();
553          set<int> rigidAtoms;
554          for (int i = 0; i < static_cast<int>(atoms.size()); ++i) {
# Line 555 | Line 559 | namespace OpenMD {
559          }      
560        } else {
561          set<int> oneAtomSet;
562 <        oneAtomSet.insert(integrableObject->getGlobalIndex());
563 <        atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
562 >        oneAtomSet.insert(sd->getGlobalIndex());
563 >        atomGroups.insert(map<int, set<int> >::value_type(sd->getGlobalIndex(), oneAtomSet));        
564        }
565      }  
566  
# Line 780 | Line 784 | namespace OpenMD {
784  
785    void SimInfo::setupSimVariables() {
786      useAtomicVirial_ = simParams_->getUseAtomicVirial();
787 <    // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true
787 >    // we only call setAccumulateBoxDipole if the accumulateBoxDipole
788 >    // parameter is true
789      calcBoxDipole_ = false;
790      if ( simParams_->haveAccumulateBoxDipole() )
791        if ( simParams_->getAccumulateBoxDipole() ) {
# Line 874 | Line 879 | namespace OpenMD {
879  
880  
881    void SimInfo::prepareTopology() {
877 –    int nExclude, nOneTwo, nOneThree, nOneFour;
882  
883      //calculate mass ratio of cutoff group
884      SimInfo::MoleculeIterator mi;
# Line 923 | Line 927 | namespace OpenMD {
927      
928      //scan topology
929  
926 –    nExclude = excludedInteractions_.getSize();
927 –    nOneTwo = oneTwoInteractions_.getSize();
928 –    nOneThree = oneThreeInteractions_.getSize();
929 –    nOneFour = oneFourInteractions_.getSize();
930 –
930      int* excludeList = excludedInteractions_.getPairList();
931      int* oneTwoList = oneTwoInteractions_.getPairList();
932      int* oneThreeList = oneThreeInteractions_.getPairList();
# Line 978 | Line 977 | namespace OpenMD {
977  
978      for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
979          
980 <      for (atom = mol->beginAtom(atomIter); atom != NULL; atom = mol->nextAtom(atomIter)) {
980 >      for (atom = mol->beginAtom(atomIter); atom != NULL;
981 >           atom = mol->nextAtom(atomIter)) {
982          atom->setSnapshotManager(sman_);
983        }
984          
985 <      for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
985 >      for (rb = mol->beginRigidBody(rbIter); rb != NULL;
986 >           rb = mol->nextRigidBody(rbIter)) {
987          rb->setSnapshotManager(sman_);
988        }
989  
990 <      for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) {
990 >      for (cg = mol->beginCutoffGroup(cgIter); cg != NULL;
991 >           cg = mol->nextCutoffGroup(cgIter)) {
992          cg->setSnapshotManager(sman_);
993        }
994      }    
# Line 1001 | Line 1003 | namespace OpenMD {
1003    
1004    
1005    StuntDouble* SimInfo::getIOIndexToIntegrableObject(int index) {
1006 <    return IOIndexToIntegrableObject.at(index);
1006 >    if (index >= IOIndexToIntegrableObject.size()) {
1007 >      sprintf(painCave.errMsg,
1008 >              "SimInfo::getIOIndexToIntegrableObject Error: Integrable Object\n"
1009 >              "\tindex exceeds number of known objects!\n");
1010 >      painCave.isFatal = 1;
1011 >      simError();
1012 >      return NULL;
1013 >    } else
1014 >      return IOIndexToIntegrableObject.at(index);
1015    }
1016    
1017    void SimInfo::setIOIndexToIntegrableObject(const vector<StuntDouble*>& v) {
1018      IOIndexToIntegrableObject= v;
1019    }
1010 – /*
1011 –   void SimInfo::setStuntDoubleFromGlobalIndex(vector<StuntDouble*> v) {
1012 –      assert( v.size() == nAtoms_ + nRigidBodies_);
1013 –      sdByGlobalIndex_ = v;
1014 –    }
1020  
1016 –    StuntDouble* SimInfo::getStuntDoubleFromGlobalIndex(int index) {
1017 –      //assert(index < nAtoms_ + nRigidBodies_);
1018 –      return sdByGlobalIndex_.at(index);
1019 –    }  
1020 – */  
1021    int SimInfo::getNGlobalConstraints() {
1022      int nGlobalConstraints;
1023   #ifdef IS_MPI
1024 <    MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM,
1025 <                  MPI_COMM_WORLD);    
1024 >    MPI::COMM_WORLD.Allreduce(&nConstraints_, &nGlobalConstraints, 1,
1025 >                              MPI::INT, MPI::SUM);
1026   #else
1027      nGlobalConstraints =  nConstraints_;
1028   #endif

Diff Legend

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