# | 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 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |