# | Line 54 | Line 54 | |
---|---|---|
54 | #include "math/Vector3.hpp" | |
55 | #include "primitives/Molecule.hpp" | |
56 | #include "primitives/StuntDouble.hpp" | |
57 | – | #include "UseTheForce/fCutoffPolicy.h" |
58 | – | #include "UseTheForce/DarkSide/fSwitchingFunctionType.h" |
59 | – | #include "UseTheForce/doForces_interface.h" |
57 | #include "UseTheForce/DarkSide/neighborLists_interface.h" | |
58 | < | #include "UseTheForce/DarkSide/switcheroo_interface.h" |
58 | > | #include "UseTheForce/doForces_interface.h" |
59 | #include "utils/MemoryUtils.hpp" | |
60 | #include "utils/simError.h" | |
61 | #include "selection/SelectionManager.hpp" | |
62 | #include "io/ForceFieldOptions.hpp" | |
63 | #include "UseTheForce/ForceField.hpp" | |
64 | + | #include "nonbonded/SwitchingFunction.hpp" |
65 | ||
68 | – | |
66 | #ifdef IS_MPI | |
67 | #include "UseTheForce/mpiComponentPlan.h" | |
68 | #include "UseTheForce/DarkSide/simParallel_interface.h" | |
69 | #endif | |
70 | ||
71 | + | using namespace std; |
72 | namespace OpenMD { | |
75 | – | std::set<int> getRigidSet(int index, std::map<int, std::set<int> >& container) { |
76 | – | std::map<int, std::set<int> >::iterator i = container.find(index); |
77 | – | std::set<int> result; |
78 | – | if (i != container.end()) { |
79 | – | result = i->second; |
80 | – | } |
81 | – | |
82 | – | return result; |
83 | – | } |
73 | ||
74 | SimInfo::SimInfo(ForceField* ff, Globals* simParams) : | |
75 | forceField_(ff), simParams_(simParams), | |
# | Line 90 | Line 79 | namespace OpenMD { | |
79 | nAtoms_(0), nBonds_(0), nBends_(0), nTorsions_(0), nInversions_(0), | |
80 | nRigidBodies_(0), nIntegrableObjects_(0), nCutoffGroups_(0), | |
81 | nConstraints_(0), sman_(NULL), fortranInitialized_(false), | |
82 | < | calcBoxDipole_(false), useAtomicVirial_(true) { |
83 | < | |
84 | < | |
85 | < | MoleculeStamp* molStamp; |
86 | < | int nMolWithSameStamp; |
87 | < | int nCutoffAtoms = 0; // number of atoms belong to cutoff groups |
88 | < | int nGroups = 0; //total cutoff groups defined in meta-data file |
89 | < | CutoffGroupStamp* cgStamp; |
90 | < | RigidBodyStamp* rbStamp; |
91 | < | int nRigidAtoms = 0; |
92 | < | |
93 | < | std::vector<Component*> components = simParams->getComponents(); |
82 | > | calcBoxDipole_(false), useAtomicVirial_(true) { |
83 | > | |
84 | > | MoleculeStamp* molStamp; |
85 | > | int nMolWithSameStamp; |
86 | > | int nCutoffAtoms = 0; // number of atoms belong to cutoff groups |
87 | > | int nGroups = 0; //total cutoff groups defined in meta-data file |
88 | > | CutoffGroupStamp* cgStamp; |
89 | > | RigidBodyStamp* rbStamp; |
90 | > | int nRigidAtoms = 0; |
91 | > | |
92 | > | vector<Component*> components = simParams->getComponents(); |
93 | > | |
94 | > | for (vector<Component*>::iterator i = components.begin(); i !=components.end(); ++i) { |
95 | > | molStamp = (*i)->getMoleculeStamp(); |
96 | > | nMolWithSameStamp = (*i)->getNMol(); |
97 | ||
98 | < | for (std::vector<Component*>::iterator i = components.begin(); i !=components.end(); ++i) { |
99 | < | molStamp = (*i)->getMoleculeStamp(); |
100 | < | nMolWithSameStamp = (*i)->getNMol(); |
101 | < | |
102 | < | addMoleculeStamp(molStamp, nMolWithSameStamp); |
103 | < | |
104 | < | //calculate atoms in molecules |
105 | < | nGlobalAtoms_ += molStamp->getNAtoms() *nMolWithSameStamp; |
106 | < | |
107 | < | //calculate atoms in cutoff groups |
108 | < | int nAtomsInGroups = 0; |
109 | < | int nCutoffGroupsInStamp = molStamp->getNCutoffGroups(); |
118 | < | |
119 | < | for (int j=0; j < nCutoffGroupsInStamp; j++) { |
120 | < | cgStamp = molStamp->getCutoffGroupStamp(j); |
121 | < | nAtomsInGroups += cgStamp->getNMembers(); |
122 | < | } |
123 | < | |
124 | < | nGroups += nCutoffGroupsInStamp * nMolWithSameStamp; |
125 | < | |
126 | < | nCutoffAtoms += nAtomsInGroups * nMolWithSameStamp; |
127 | < | |
128 | < | //calculate atoms in rigid bodies |
129 | < | int nAtomsInRigidBodies = 0; |
130 | < | int nRigidBodiesInStamp = molStamp->getNRigidBodies(); |
131 | < | |
132 | < | for (int j=0; j < nRigidBodiesInStamp; j++) { |
133 | < | rbStamp = molStamp->getRigidBodyStamp(j); |
134 | < | nAtomsInRigidBodies += rbStamp->getNMembers(); |
135 | < | } |
136 | < | |
137 | < | nGlobalRigidBodies_ += nRigidBodiesInStamp * nMolWithSameStamp; |
138 | < | nRigidAtoms += nAtomsInRigidBodies * nMolWithSameStamp; |
139 | < | |
98 | > | addMoleculeStamp(molStamp, nMolWithSameStamp); |
99 | > | |
100 | > | //calculate atoms in molecules |
101 | > | nGlobalAtoms_ += molStamp->getNAtoms() *nMolWithSameStamp; |
102 | > | |
103 | > | //calculate atoms in cutoff groups |
104 | > | int nAtomsInGroups = 0; |
105 | > | int nCutoffGroupsInStamp = molStamp->getNCutoffGroups(); |
106 | > | |
107 | > | for (int j=0; j < nCutoffGroupsInStamp; j++) { |
108 | > | cgStamp = molStamp->getCutoffGroupStamp(j); |
109 | > | nAtomsInGroups += cgStamp->getNMembers(); |
110 | } | |
111 | < | |
112 | < | //every free atom (atom does not belong to cutoff groups) is a cutoff |
113 | < | //group therefore the total number of cutoff groups in the system is |
114 | < | //equal to the total number of atoms minus number of atoms belong to |
115 | < | //cutoff group defined in meta-data file plus the number of cutoff |
116 | < | //groups defined in meta-data file |
117 | < | nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups; |
118 | < | |
119 | < | //every free atom (atom does not belong to rigid bodies) is an |
120 | < | //integrable object therefore the total number of integrable objects |
121 | < | //in the system is equal to the total number of atoms minus number of |
122 | < | //atoms belong to rigid body defined in meta-data file plus the number |
123 | < | //of rigid bodies defined in meta-data file |
124 | < | nGlobalIntegrableObjects_ = nGlobalAtoms_ - nRigidAtoms |
125 | < | + nGlobalRigidBodies_; |
126 | < | |
127 | < | nGlobalMols_ = molStampIds_.size(); |
128 | < | molToProcMap_.resize(nGlobalMols_); |
129 | < | } |
130 | < | |
111 | > | |
112 | > | nGroups += nCutoffGroupsInStamp * nMolWithSameStamp; |
113 | > | |
114 | > | nCutoffAtoms += nAtomsInGroups * nMolWithSameStamp; |
115 | > | |
116 | > | //calculate atoms in rigid bodies |
117 | > | int nAtomsInRigidBodies = 0; |
118 | > | int nRigidBodiesInStamp = molStamp->getNRigidBodies(); |
119 | > | |
120 | > | for (int j=0; j < nRigidBodiesInStamp; j++) { |
121 | > | rbStamp = molStamp->getRigidBodyStamp(j); |
122 | > | nAtomsInRigidBodies += rbStamp->getNMembers(); |
123 | > | } |
124 | > | |
125 | > | nGlobalRigidBodies_ += nRigidBodiesInStamp * nMolWithSameStamp; |
126 | > | nRigidAtoms += nAtomsInRigidBodies * nMolWithSameStamp; |
127 | > | |
128 | > | } |
129 | > | |
130 | > | //every free atom (atom does not belong to cutoff groups) is a cutoff |
131 | > | //group therefore the total number of cutoff groups in the system is |
132 | > | //equal to the total number of atoms minus number of atoms belong to |
133 | > | //cutoff group defined in meta-data file plus the number of cutoff |
134 | > | //groups defined in meta-data file |
135 | > | nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups; |
136 | > | |
137 | > | //every free atom (atom does not belong to rigid bodies) is an |
138 | > | //integrable object therefore the total number of integrable objects |
139 | > | //in the system is equal to the total number of atoms minus number of |
140 | > | //atoms belong to rigid body defined in meta-data file plus the number |
141 | > | //of rigid bodies defined in meta-data file |
142 | > | nGlobalIntegrableObjects_ = nGlobalAtoms_ - nRigidAtoms |
143 | > | + nGlobalRigidBodies_; |
144 | > | |
145 | > | nGlobalMols_ = molStampIds_.size(); |
146 | > | molToProcMap_.resize(nGlobalMols_); |
147 | > | } |
148 | > | |
149 | SimInfo::~SimInfo() { | |
150 | < | std::map<int, Molecule*>::iterator i; |
150 | > | map<int, Molecule*>::iterator i; |
151 | for (i = molecules_.begin(); i != molecules_.end(); ++i) { | |
152 | delete i->second; | |
153 | } | |
# | Line 170 | Line 158 | namespace OpenMD { | |
158 | delete forceField_; | |
159 | } | |
160 | ||
173 | – | int SimInfo::getNGlobalConstraints() { |
174 | – | int nGlobalConstraints; |
175 | – | #ifdef IS_MPI |
176 | – | MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM, |
177 | – | MPI_COMM_WORLD); |
178 | – | #else |
179 | – | nGlobalConstraints = nConstraints_; |
180 | – | #endif |
181 | – | return nGlobalConstraints; |
182 | – | } |
161 | ||
162 | bool SimInfo::addMolecule(Molecule* mol) { | |
163 | MoleculeIterator i; | |
164 | < | |
164 | > | |
165 | i = molecules_.find(mol->getGlobalIndex()); | |
166 | if (i == molecules_.end() ) { | |
167 | < | |
168 | < | molecules_.insert(std::make_pair(mol->getGlobalIndex(), mol)); |
169 | < | |
167 | > | |
168 | > | molecules_.insert(make_pair(mol->getGlobalIndex(), mol)); |
169 | > | |
170 | nAtoms_ += mol->getNAtoms(); | |
171 | nBonds_ += mol->getNBonds(); | |
172 | nBends_ += mol->getNBends(); | |
# | Line 198 | Line 176 | namespace OpenMD { | |
176 | nIntegrableObjects_ += mol->getNIntegrableObjects(); | |
177 | nCutoffGroups_ += mol->getNCutoffGroups(); | |
178 | nConstraints_ += mol->getNConstraintPairs(); | |
179 | < | |
179 | > | |
180 | addInteractionPairs(mol); | |
181 | < | |
181 | > | |
182 | return true; | |
183 | } else { | |
184 | return false; | |
185 | } | |
186 | } | |
187 | < | |
187 | > | |
188 | bool SimInfo::removeMolecule(Molecule* mol) { | |
189 | MoleculeIterator i; | |
190 | i = molecules_.find(mol->getGlobalIndex()); | |
# | Line 234 | Line 212 | namespace OpenMD { | |
212 | } else { | |
213 | return false; | |
214 | } | |
237 | – | |
238 | – | |
215 | } | |
216 | ||
217 | ||
# | Line 253 | Line 229 | namespace OpenMD { | |
229 | void SimInfo::calcNdf() { | |
230 | int ndf_local; | |
231 | MoleculeIterator i; | |
232 | < | std::vector<StuntDouble*>::iterator j; |
232 | > | vector<StuntDouble*>::iterator j; |
233 | Molecule* mol; | |
234 | StuntDouble* integrableObject; | |
235 | ||
# | Line 304 | Line 280 | namespace OpenMD { | |
280 | int ndfRaw_local; | |
281 | ||
282 | MoleculeIterator i; | |
283 | < | std::vector<StuntDouble*>::iterator j; |
283 | > | vector<StuntDouble*>::iterator j; |
284 | Molecule* mol; | |
285 | StuntDouble* integrableObject; | |
286 | ||
# | Line 353 | Line 329 | namespace OpenMD { | |
329 | ||
330 | void SimInfo::addInteractionPairs(Molecule* mol) { | |
331 | ForceFieldOptions& options_ = forceField_->getForceFieldOptions(); | |
332 | < | std::vector<Bond*>::iterator bondIter; |
333 | < | std::vector<Bend*>::iterator bendIter; |
334 | < | std::vector<Torsion*>::iterator torsionIter; |
335 | < | std::vector<Inversion*>::iterator inversionIter; |
332 | > | vector<Bond*>::iterator bondIter; |
333 | > | vector<Bend*>::iterator bendIter; |
334 | > | vector<Torsion*>::iterator torsionIter; |
335 | > | vector<Inversion*>::iterator inversionIter; |
336 | Bond* bond; | |
337 | Bend* bend; | |
338 | Torsion* torsion; | |
# | Line 374 | Line 350 | namespace OpenMD { | |
350 | // always be excluded. These are done at the bottom of this | |
351 | // function. | |
352 | ||
353 | < | std::map<int, std::set<int> > atomGroups; |
353 | > | map<int, set<int> > atomGroups; |
354 | Molecule::RigidBodyIterator rbIter; | |
355 | RigidBody* rb; | |
356 | Molecule::IntegrableObjectIterator ii; | |
# | Line 386 | Line 362 | namespace OpenMD { | |
362 | ||
363 | if (integrableObject->isRigidBody()) { | |
364 | rb = static_cast<RigidBody*>(integrableObject); | |
365 | < | std::vector<Atom*> atoms = rb->getAtoms(); |
366 | < | std::set<int> rigidAtoms; |
365 | > | vector<Atom*> atoms = rb->getAtoms(); |
366 | > | set<int> rigidAtoms; |
367 | for (int i = 0; i < static_cast<int>(atoms.size()); ++i) { | |
368 | rigidAtoms.insert(atoms[i]->getGlobalIndex()); | |
369 | } | |
370 | for (int i = 0; i < static_cast<int>(atoms.size()); ++i) { | |
371 | < | atomGroups.insert(std::map<int, std::set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms)); |
371 | > | atomGroups.insert(map<int, set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms)); |
372 | } | |
373 | } else { | |
374 | < | std::set<int> oneAtomSet; |
374 | > | set<int> oneAtomSet; |
375 | oneAtomSet.insert(integrableObject->getGlobalIndex()); | |
376 | < | atomGroups.insert(std::map<int, std::set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet)); |
376 | > | atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet)); |
377 | } | |
378 | } | |
379 | ||
# | Line 500 | Line 476 | namespace OpenMD { | |
476 | ||
477 | for (rb = mol->beginRigidBody(rbIter); rb != NULL; | |
478 | rb = mol->nextRigidBody(rbIter)) { | |
479 | < | std::vector<Atom*> atoms = rb->getAtoms(); |
479 | > | vector<Atom*> atoms = rb->getAtoms(); |
480 | for (int i = 0; i < static_cast<int>(atoms.size()) -1 ; ++i) { | |
481 | for (int j = i + 1; j < static_cast<int>(atoms.size()); ++j) { | |
482 | a = atoms[i]->getGlobalIndex(); | |
# | Line 514 | Line 490 | namespace OpenMD { | |
490 | ||
491 | void SimInfo::removeInteractionPairs(Molecule* mol) { | |
492 | ForceFieldOptions& options_ = forceField_->getForceFieldOptions(); | |
493 | < | std::vector<Bond*>::iterator bondIter; |
494 | < | std::vector<Bend*>::iterator bendIter; |
495 | < | std::vector<Torsion*>::iterator torsionIter; |
496 | < | std::vector<Inversion*>::iterator inversionIter; |
493 | > | vector<Bond*>::iterator bondIter; |
494 | > | vector<Bend*>::iterator bendIter; |
495 | > | vector<Torsion*>::iterator torsionIter; |
496 | > | vector<Inversion*>::iterator inversionIter; |
497 | Bond* bond; | |
498 | Bend* bend; | |
499 | Torsion* torsion; | |
# | Line 527 | Line 503 | namespace OpenMD { | |
503 | int c; | |
504 | int d; | |
505 | ||
506 | < | std::map<int, std::set<int> > atomGroups; |
506 | > | map<int, set<int> > atomGroups; |
507 | Molecule::RigidBodyIterator rbIter; | |
508 | RigidBody* rb; | |
509 | Molecule::IntegrableObjectIterator ii; | |
# | Line 539 | Line 515 | namespace OpenMD { | |
515 | ||
516 | if (integrableObject->isRigidBody()) { | |
517 | rb = static_cast<RigidBody*>(integrableObject); | |
518 | < | std::vector<Atom*> atoms = rb->getAtoms(); |
519 | < | std::set<int> rigidAtoms; |
518 | > | vector<Atom*> atoms = rb->getAtoms(); |
519 | > | set<int> rigidAtoms; |
520 | for (int i = 0; i < static_cast<int>(atoms.size()); ++i) { | |
521 | rigidAtoms.insert(atoms[i]->getGlobalIndex()); | |
522 | } | |
523 | for (int i = 0; i < static_cast<int>(atoms.size()); ++i) { | |
524 | < | atomGroups.insert(std::map<int, std::set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms)); |
524 | > | atomGroups.insert(map<int, set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms)); |
525 | } | |
526 | } else { | |
527 | < | std::set<int> oneAtomSet; |
527 | > | set<int> oneAtomSet; |
528 | oneAtomSet.insert(integrableObject->getGlobalIndex()); | |
529 | < | atomGroups.insert(std::map<int, std::set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet)); |
529 | > | atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet)); |
530 | } | |
531 | } | |
532 | ||
# | Line 653 | Line 629 | namespace OpenMD { | |
629 | ||
630 | for (rb = mol->beginRigidBody(rbIter); rb != NULL; | |
631 | rb = mol->nextRigidBody(rbIter)) { | |
632 | < | std::vector<Atom*> atoms = rb->getAtoms(); |
632 | > | vector<Atom*> atoms = rb->getAtoms(); |
633 | for (int i = 0; i < static_cast<int>(atoms.size()) -1 ; ++i) { | |
634 | for (int j = i + 1; j < static_cast<int>(atoms.size()); ++j) { | |
635 | a = atoms[i]->getGlobalIndex(); | |
# | Line 676 | Line 652 | namespace OpenMD { | |
652 | molStampIds_.insert(molStampIds_.end(), nmol, curStampId); | |
653 | } | |
654 | ||
679 | – | void SimInfo::update() { |
655 | ||
656 | < | setupSimType(); |
657 | < | |
658 | < | #ifdef IS_MPI |
659 | < | setupFortranParallel(); |
660 | < | #endif |
661 | < | |
662 | < | setupFortranSim(); |
663 | < | |
664 | < | //setup fortran force field |
690 | < | /** @deprecate */ |
691 | < | int isError = 0; |
692 | < | |
693 | < | setupCutoff(); |
694 | < | |
695 | < | setupElectrostaticSummationMethod( isError ); |
696 | < | setupSwitchingFunction(); |
697 | < | setupAccumulateBoxDipole(); |
698 | < | |
699 | < | if(isError){ |
700 | < | sprintf( painCave.errMsg, |
701 | < | "ForceField error: There was an error initializing the forceField in fortran.\n" ); |
702 | < | painCave.isFatal = 1; |
703 | < | simError(); |
704 | < | } |
705 | < | |
656 | > | /** |
657 | > | * update |
658 | > | * |
659 | > | * Performs the global checks and variable settings after the |
660 | > | * objects have been created. |
661 | > | * |
662 | > | */ |
663 | > | void SimInfo::update() { |
664 | > | setupSimVariables(); |
665 | calcNdf(); | |
666 | calcNdfRaw(); | |
667 | calcNdfTrans(); | |
709 | – | |
710 | – | fortranInitialized_ = true; |
668 | } | |
669 | < | |
670 | < | std::set<AtomType*> SimInfo::getUniqueAtomTypes() { |
669 | > | |
670 | > | /** |
671 | > | * getSimulatedAtomTypes |
672 | > | * |
673 | > | * Returns an STL set of AtomType* that are actually present in this |
674 | > | * simulation. Must query all processors to assemble this information. |
675 | > | * |
676 | > | */ |
677 | > | set<AtomType*> SimInfo::getSimulatedAtomTypes() { |
678 | SimInfo::MoleculeIterator mi; | |
679 | Molecule* mol; | |
680 | Molecule::AtomIterator ai; | |
681 | Atom* atom; | |
682 | < | std::set<AtomType*> atomTypes; |
683 | < | |
684 | < | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
721 | < | |
682 | > | set<AtomType*> atomTypes; |
683 | > | |
684 | > | for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { |
685 | for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) { | |
686 | atomTypes.insert(atom->getAtomType()); | |
687 | < | } |
688 | < | |
726 | < | } |
687 | > | } |
688 | > | } |
689 | ||
690 | < | return atomTypes; |
729 | < | } |
690 | > | #ifdef IS_MPI |
691 | ||
692 | < | void SimInfo::setupSimType() { |
693 | < | std::set<AtomType*>::iterator i; |
733 | < | std::set<AtomType*> atomTypes; |
734 | < | atomTypes = getUniqueAtomTypes(); |
735 | < | |
736 | < | int useLennardJones = 0; |
737 | < | int useElectrostatic = 0; |
738 | < | int useEAM = 0; |
739 | < | int useSC = 0; |
740 | < | int useCharge = 0; |
741 | < | int useDirectional = 0; |
742 | < | int useDipole = 0; |
743 | < | int useGayBerne = 0; |
744 | < | int useSticky = 0; |
745 | < | int useStickyPower = 0; |
746 | < | int useShape = 0; |
747 | < | int useFLARB = 0; //it is not in AtomType yet |
748 | < | int useDirectionalAtom = 0; |
749 | < | int useElectrostatics = 0; |
750 | < | //usePBC and useRF are from simParams |
751 | < | int usePBC = simParams_->getUsePeriodicBoundaryConditions(); |
752 | < | int useRF; |
753 | < | int useSF; |
754 | < | int useSP; |
755 | < | int useBoxDipole; |
692 | > | // loop over the found atom types on this processor, and add their |
693 | > | // numerical idents to a vector: |
694 | ||
695 | < | std::string myMethod; |
695 | > | vector<int> foundTypes; |
696 | > | set<AtomType*>::iterator i; |
697 | > | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) |
698 | > | foundTypes.push_back( (*i)->getIdent() ); |
699 | ||
700 | < | // set the useRF logical |
701 | < | useRF = 0; |
761 | < | useSF = 0; |
762 | < | useSP = 0; |
763 | < | useBoxDipole = 0; |
700 | > | // count_local holds the number of found types on this processor |
701 | > | int count_local = foundTypes.size(); |
702 | ||
703 | < | if (simParams_->haveElectrostaticSummationMethod()) { |
704 | < | std::string myMethod = simParams_->getElectrostaticSummationMethod(); |
705 | < | toUpper(myMethod); |
706 | < | if (myMethod == "REACTION_FIELD"){ |
707 | < | useRF = 1; |
708 | < | } else if (myMethod == "SHIFTED_FORCE"){ |
709 | < | useSF = 1; |
710 | < | } else if (myMethod == "SHIFTED_POTENTIAL"){ |
711 | < | useSP = 1; |
712 | < | } |
713 | < | } |
703 | > | // count holds the total number of found types on all processors |
704 | > | // (some will be redundant with the ones found locally): |
705 | > | int count; |
706 | > | MPI::COMM_WORLD.Allreduce(&count_local, &count, 1, MPI::INT, MPI::SUM); |
707 | > | |
708 | > | // create a vector to hold the globally found types, and resize it: |
709 | > | vector<int> ftGlobal; |
710 | > | ftGlobal.resize(count); |
711 | > | vector<int> counts; |
712 | > | |
713 | > | int nproc = MPI::COMM_WORLD.Get_size(); |
714 | > | counts.resize(nproc); |
715 | > | vector<int> disps; |
716 | > | disps.resize(nproc); |
717 | > | |
718 | > | // now spray out the foundTypes to all the other processors: |
719 | ||
720 | < | if (simParams_->haveAccumulateBoxDipole()) |
721 | < | if (simParams_->getAccumulateBoxDipole()) |
779 | < | useBoxDipole = 1; |
720 | > | MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT, |
721 | > | &ftGlobal[0], &counts[0], &disps[0], MPI::INT); |
722 | ||
723 | + | // foundIdents is a stl set, so inserting an already found ident |
724 | + | // will have no effect. |
725 | + | set<int> foundIdents; |
726 | + | vector<int>::iterator j; |
727 | + | for (j = ftGlobal.begin(); j != ftGlobal.end(); ++j) |
728 | + | foundIdents.insert((*j)); |
729 | + | |
730 | + | // now iterate over the foundIdents and get the actual atom types |
731 | + | // that correspond to these: |
732 | + | set<int>::iterator it; |
733 | + | for (it = foundIdents.begin(); it != foundIdents.end(); ++it) |
734 | + | atomTypes.insert( forceField_->getAtomType((*it)) ); |
735 | + | |
736 | + | #endif |
737 | + | |
738 | + | return atomTypes; |
739 | + | } |
740 | + | |
741 | + | void SimInfo::setupSimVariables() { |
742 | useAtomicVirial_ = simParams_->getUseAtomicVirial(); | |
743 | + | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
744 | + | calcBoxDipole_ = false; |
745 | + | if ( simParams_->haveAccumulateBoxDipole() ) |
746 | + | if ( simParams_->getAccumulateBoxDipole() ) { |
747 | + | calcBoxDipole_ = true; |
748 | + | } |
749 | ||
750 | + | set<AtomType*>::iterator i; |
751 | + | set<AtomType*> atomTypes; |
752 | + | atomTypes = getSimulatedAtomTypes(); |
753 | + | int usesElectrostatic = 0; |
754 | + | int usesMetallic = 0; |
755 | + | int usesDirectional = 0; |
756 | //loop over all of the atom types | |
757 | for (i = atomTypes.begin(); i != atomTypes.end(); ++i) { | |
758 | < | useLennardJones |= (*i)->isLennardJones(); |
759 | < | useElectrostatic |= (*i)->isElectrostatic(); |
760 | < | useEAM |= (*i)->isEAM(); |
788 | < | useSC |= (*i)->isSC(); |
789 | < | useCharge |= (*i)->isCharge(); |
790 | < | useDirectional |= (*i)->isDirectional(); |
791 | < | useDipole |= (*i)->isDipole(); |
792 | < | useGayBerne |= (*i)->isGayBerne(); |
793 | < | useSticky |= (*i)->isSticky(); |
794 | < | useStickyPower |= (*i)->isStickyPower(); |
795 | < | useShape |= (*i)->isShape(); |
758 | > | usesElectrostatic |= (*i)->isElectrostatic(); |
759 | > | usesMetallic |= (*i)->isMetal(); |
760 | > | usesDirectional |= (*i)->isDirectional(); |
761 | } | |
762 | ||
798 | – | if (useSticky || useStickyPower || useDipole || useGayBerne || useShape) { |
799 | – | useDirectionalAtom = 1; |
800 | – | } |
801 | – | |
802 | – | if (useCharge || useDipole) { |
803 | – | useElectrostatics = 1; |
804 | – | } |
805 | – | |
763 | #ifdef IS_MPI | |
764 | int temp; | |
765 | + | temp = usesDirectional; |
766 | + | MPI_Allreduce(&temp, &usesDirectionalAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
767 | ||
768 | < | temp = usePBC; |
769 | < | MPI_Allreduce(&temp, &usePBC, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
811 | < | |
812 | < | temp = useDirectionalAtom; |
813 | < | MPI_Allreduce(&temp, &useDirectionalAtom, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
814 | < | |
815 | < | temp = useLennardJones; |
816 | < | MPI_Allreduce(&temp, &useLennardJones, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
817 | < | |
818 | < | temp = useElectrostatics; |
819 | < | MPI_Allreduce(&temp, &useElectrostatics, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
820 | < | |
821 | < | temp = useCharge; |
822 | < | MPI_Allreduce(&temp, &useCharge, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
768 | > | temp = usesMetallic; |
769 | > | MPI_Allreduce(&temp, &usesMetallicAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
770 | ||
771 | < | temp = useDipole; |
772 | < | MPI_Allreduce(&temp, &useDipole, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
826 | < | |
827 | < | temp = useSticky; |
828 | < | MPI_Allreduce(&temp, &useSticky, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
829 | < | |
830 | < | temp = useStickyPower; |
831 | < | MPI_Allreduce(&temp, &useStickyPower, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
832 | < | |
833 | < | temp = useGayBerne; |
834 | < | MPI_Allreduce(&temp, &useGayBerne, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
835 | < | |
836 | < | temp = useEAM; |
837 | < | MPI_Allreduce(&temp, &useEAM, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
838 | < | |
839 | < | temp = useSC; |
840 | < | MPI_Allreduce(&temp, &useSC, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
841 | < | |
842 | < | temp = useShape; |
843 | < | MPI_Allreduce(&temp, &useShape, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
844 | < | |
845 | < | temp = useFLARB; |
846 | < | MPI_Allreduce(&temp, &useFLARB, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
847 | < | |
848 | < | temp = useRF; |
849 | < | MPI_Allreduce(&temp, &useRF, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
850 | < | |
851 | < | temp = useSF; |
852 | < | MPI_Allreduce(&temp, &useSF, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
853 | < | |
854 | < | temp = useSP; |
855 | < | MPI_Allreduce(&temp, &useSP, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
856 | < | |
857 | < | temp = useBoxDipole; |
858 | < | MPI_Allreduce(&temp, &useBoxDipole, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
859 | < | |
860 | < | temp = useAtomicVirial_; |
861 | < | MPI_Allreduce(&temp, &useAtomicVirial_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
862 | < | |
771 | > | temp = usesElectrostatic; |
772 | > | MPI_Allreduce(&temp, &usesElectrostaticAtoms_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD); |
773 | #endif | |
774 | < | fInfo_.SIM_uses_PBC = usePBC; |
775 | < | fInfo_.SIM_uses_DirectionalAtoms = useDirectionalAtom; |
776 | < | fInfo_.SIM_uses_LennardJones = useLennardJones; |
777 | < | fInfo_.SIM_uses_Electrostatics = useElectrostatics; |
778 | < | fInfo_.SIM_uses_Charges = useCharge; |
779 | < | fInfo_.SIM_uses_Dipoles = useDipole; |
870 | < | fInfo_.SIM_uses_Sticky = useSticky; |
871 | < | fInfo_.SIM_uses_StickyPower = useStickyPower; |
872 | < | fInfo_.SIM_uses_GayBerne = useGayBerne; |
873 | < | fInfo_.SIM_uses_EAM = useEAM; |
874 | < | fInfo_.SIM_uses_SC = useSC; |
875 | < | fInfo_.SIM_uses_Shapes = useShape; |
876 | < | fInfo_.SIM_uses_FLARB = useFLARB; |
877 | < | fInfo_.SIM_uses_RF = useRF; |
878 | < | fInfo_.SIM_uses_SF = useSF; |
879 | < | fInfo_.SIM_uses_SP = useSP; |
880 | < | fInfo_.SIM_uses_BoxDipole = useBoxDipole; |
881 | < | fInfo_.SIM_uses_AtomicVirial = useAtomicVirial_; |
774 | > | fInfo_.SIM_uses_PBC = usesPeriodicBoundaries_; |
775 | > | fInfo_.SIM_uses_DirectionalAtoms = usesDirectionalAtoms_; |
776 | > | fInfo_.SIM_uses_MetallicAtoms = usesMetallicAtoms_; |
777 | > | fInfo_.SIM_requires_SkipCorrection = usesElectrostaticAtoms_; |
778 | > | fInfo_.SIM_requires_SelfCorrection = usesElectrostaticAtoms_; |
779 | > | fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_; |
780 | } | |
781 | ||
782 | < | void SimInfo::setupFortranSim() { |
782 | > | void SimInfo::setupFortran() { |
783 | int isError; | |
784 | int nExclude, nOneTwo, nOneThree, nOneFour; | |
785 | < | std::vector<int> fortranGlobalGroupMembership; |
785 | > | vector<int> fortranGlobalGroupMembership; |
786 | ||
787 | isError = 0; | |
788 | ||
# | Line 894 | Line 792 | namespace OpenMD { | |
792 | } | |
793 | ||
794 | //calculate mass ratio of cutoff group | |
795 | < | std::vector<RealType> mfact; |
795 | > | vector<RealType> mfact; |
796 | SimInfo::MoleculeIterator mi; | |
797 | Molecule* mol; | |
798 | Molecule::CutoffGroupIterator ci; | |
# | Line 920 | Line 818 | namespace OpenMD { | |
818 | } | |
819 | } | |
820 | ||
821 | < | //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!) |
822 | < | std::vector<int> identArray; |
821 | > | //fill ident array of local atoms (it is actually ident of |
822 | > | //AtomType, it is so confusing !!!) |
823 | > | vector<int> identArray; |
824 | ||
825 | //to avoid memory reallocation, reserve enough space identArray | |
826 | identArray.reserve(getNAtoms()); | |
# | Line 934 | Line 833 | namespace OpenMD { | |
833 | ||
834 | //fill molMembershipArray | |
835 | //molMembershipArray is filled by SimCreator | |
836 | < | std::vector<int> molMembershipArray(nGlobalAtoms_); |
836 | > | vector<int> molMembershipArray(nGlobalAtoms_); |
837 | for (int i = 0; i < nGlobalAtoms_; i++) { | |
838 | molMembershipArray[i] = globalMolMembership_[i] + 1; | |
839 | } | |
# | Line 980 | Line 879 | namespace OpenMD { | |
879 | setNeighbors(&nlistNeighbors); | |
880 | } | |
881 | ||
983 | – | |
984 | – | } |
985 | – | |
986 | – | |
987 | – | void SimInfo::setupFortranParallel() { |
882 | #ifdef IS_MPI | |
883 | < | //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex |
884 | < | std::vector<int> localToGlobalAtomIndex(getNAtoms(), 0); |
885 | < | std::vector<int> localToGlobalCutoffGroupIndex; |
886 | < | SimInfo::MoleculeIterator mi; |
993 | < | Molecule::AtomIterator ai; |
994 | < | Molecule::CutoffGroupIterator ci; |
995 | < | Molecule* mol; |
996 | < | Atom* atom; |
997 | < | CutoffGroup* cg; |
883 | > | //SimInfo is responsible for creating localToGlobalAtomIndex and |
884 | > | //localToGlobalGroupIndex |
885 | > | vector<int> localToGlobalAtomIndex(getNAtoms(), 0); |
886 | > | vector<int> localToGlobalCutoffGroupIndex; |
887 | mpiSimData parallelData; | |
999 | – | int isError; |
888 | ||
889 | for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) { | |
890 | ||
# | Line 1036 | Line 924 | namespace OpenMD { | |
924 | ||
925 | sprintf(checkPointMsg, " mpiRefresh successful.\n"); | |
926 | errorCheckPoint(); | |
1039 | – | |
927 | #endif | |
1041 | – | } |
928 | ||
929 | < | void SimInfo::setupCutoff() { |
930 | < | |
931 | < | ForceFieldOptions& forceFieldOptions_ = forceField_->getForceFieldOptions(); |
932 | < | |
933 | < | // Check the cutoff policy |
934 | < | int cp = TRADITIONAL_CUTOFF_POLICY; // Set to traditional by default |
1049 | < | |
1050 | < | // Set LJ shifting bools to false |
1051 | < | ljsp_ = 0; |
1052 | < | ljsf_ = 0; |
1053 | < | |
1054 | < | std::string myPolicy; |
1055 | < | if (forceFieldOptions_.haveCutoffPolicy()){ |
1056 | < | myPolicy = forceFieldOptions_.getCutoffPolicy(); |
1057 | < | }else if (simParams_->haveCutoffPolicy()) { |
1058 | < | myPolicy = simParams_->getCutoffPolicy(); |
929 | > | initFortranFF(&isError); |
930 | > | if (isError) { |
931 | > | sprintf(painCave.errMsg, |
932 | > | "initFortranFF errror: fortran didn't like something we gave it.\n"); |
933 | > | painCave.isFatal = 1; |
934 | > | simError(); |
935 | } | |
936 | < | |
1061 | < | if (!myPolicy.empty()){ |
1062 | < | toUpper(myPolicy); |
1063 | < | if (myPolicy == "MIX") { |
1064 | < | cp = MIX_CUTOFF_POLICY; |
1065 | < | } else { |
1066 | < | if (myPolicy == "MAX") { |
1067 | < | cp = MAX_CUTOFF_POLICY; |
1068 | < | } else { |
1069 | < | if (myPolicy == "TRADITIONAL") { |
1070 | < | cp = TRADITIONAL_CUTOFF_POLICY; |
1071 | < | } else { |
1072 | < | // throw error |
1073 | < | sprintf( painCave.errMsg, |
1074 | < | "SimInfo error: Unknown cutoffPolicy. (Input file specified %s .)\n\tcutoffPolicy must be one of: \"Mix\", \"Max\", or \"Traditional\".", myPolicy.c_str() ); |
1075 | < | painCave.isFatal = 1; |
1076 | < | simError(); |
1077 | < | } |
1078 | < | } |
1079 | < | } |
1080 | < | } |
1081 | < | notifyFortranCutoffPolicy(&cp); |
1082 | < | |
1083 | < | // Check the Skin Thickness for neighborlists |
1084 | < | RealType skin; |
1085 | < | if (simParams_->haveSkinThickness()) { |
1086 | < | skin = simParams_->getSkinThickness(); |
1087 | < | notifyFortranSkinThickness(&skin); |
1088 | < | } |
1089 | < | |
1090 | < | // Check if the cutoff was set explicitly: |
1091 | < | if (simParams_->haveCutoffRadius()) { |
1092 | < | rcut_ = simParams_->getCutoffRadius(); |
1093 | < | if (simParams_->haveSwitchingRadius()) { |
1094 | < | rsw_ = simParams_->getSwitchingRadius(); |
1095 | < | } else { |
1096 | < | if (fInfo_.SIM_uses_Charges | |
1097 | < | fInfo_.SIM_uses_Dipoles | |
1098 | < | fInfo_.SIM_uses_RF) { |
1099 | < | |
1100 | < | rsw_ = 0.85 * rcut_; |
1101 | < | sprintf(painCave.errMsg, |
1102 | < | "SimCreator Warning: No value was set for the switchingRadius.\n" |
1103 | < | "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n" |
1104 | < | "\tswitchingRadius = %f. for this simulation\n", rsw_); |
1105 | < | painCave.isFatal = 0; |
1106 | < | simError(); |
1107 | < | } else { |
1108 | < | rsw_ = rcut_; |
1109 | < | sprintf(painCave.errMsg, |
1110 | < | "SimCreator Warning: No value was set for the switchingRadius.\n" |
1111 | < | "\tOpenMD will use the same value as the cutoffRadius.\n" |
1112 | < | "\tswitchingRadius = %f. for this simulation\n", rsw_); |
1113 | < | painCave.isFatal = 0; |
1114 | < | simError(); |
1115 | < | } |
1116 | < | } |
1117 | < | |
1118 | < | if (simParams_->haveElectrostaticSummationMethod()) { |
1119 | < | std::string myMethod = simParams_->getElectrostaticSummationMethod(); |
1120 | < | toUpper(myMethod); |
1121 | < | |
1122 | < | if (myMethod == "SHIFTED_POTENTIAL") { |
1123 | < | ljsp_ = 1; |
1124 | < | } else if (myMethod == "SHIFTED_FORCE") { |
1125 | < | ljsf_ = 1; |
1126 | < | } |
1127 | < | } |
1128 | < | |
1129 | < | notifyFortranCutoffs(&rcut_, &rsw_, &ljsp_, &ljsf_); |
1130 | < | |
1131 | < | } else { |
1132 | < | |
1133 | < | // For electrostatic atoms, we'll assume a large safe value: |
1134 | < | if (fInfo_.SIM_uses_Charges | fInfo_.SIM_uses_Dipoles | fInfo_.SIM_uses_RF) { |
1135 | < | sprintf(painCave.errMsg, |
1136 | < | "SimCreator Warning: No value was set for the cutoffRadius.\n" |
1137 | < | "\tOpenMD will use a default value of 15.0 angstroms" |
1138 | < | "\tfor the cutoffRadius.\n"); |
1139 | < | painCave.isFatal = 0; |
1140 | < | simError(); |
1141 | < | rcut_ = 15.0; |
1142 | < | |
1143 | < | if (simParams_->haveElectrostaticSummationMethod()) { |
1144 | < | std::string myMethod = simParams_->getElectrostaticSummationMethod(); |
1145 | < | toUpper(myMethod); |
1146 | < | |
1147 | < | // For the time being, we're tethering the LJ shifted behavior to the |
1148 | < | // electrostaticSummationMethod keyword options |
1149 | < | if (myMethod == "SHIFTED_POTENTIAL") { |
1150 | < | ljsp_ = 1; |
1151 | < | } else if (myMethod == "SHIFTED_FORCE") { |
1152 | < | ljsf_ = 1; |
1153 | < | } |
1154 | < | if (myMethod == "SHIFTED_POTENTIAL" || myMethod == "SHIFTED_FORCE") { |
1155 | < | if (simParams_->haveSwitchingRadius()){ |
1156 | < | sprintf(painCave.errMsg, |
1157 | < | "SimInfo Warning: A value was set for the switchingRadius\n" |
1158 | < | "\teven though the electrostaticSummationMethod was\n" |
1159 | < | "\tset to %s\n", myMethod.c_str()); |
1160 | < | painCave.isFatal = 1; |
1161 | < | simError(); |
1162 | < | } |
1163 | < | } |
1164 | < | } |
1165 | < | |
1166 | < | if (simParams_->haveSwitchingRadius()){ |
1167 | < | rsw_ = simParams_->getSwitchingRadius(); |
1168 | < | } else { |
1169 | < | sprintf(painCave.errMsg, |
1170 | < | "SimCreator Warning: No value was set for switchingRadius.\n" |
1171 | < | "\tOpenMD will use a default value of\n" |
1172 | < | "\t0.85 * cutoffRadius for the switchingRadius\n"); |
1173 | < | painCave.isFatal = 0; |
1174 | < | simError(); |
1175 | < | rsw_ = 0.85 * rcut_; |
1176 | < | } |
1177 | < | |
1178 | < | Electrostatic::setElectrostaticCutoffRadius(rcut_, rsw_); |
1179 | < | notifyFortranCutoffs(&rcut_, &rsw_, &ljsp_, &ljsf_); |
1180 | < | |
1181 | < | } else { |
1182 | < | // We didn't set rcut explicitly, and we don't have electrostatic atoms, so |
1183 | < | // We'll punt and let fortran figure out the cutoffs later. |
1184 | < | |
1185 | < | notifyFortranYouAreOnYourOwn(); |
1186 | < | |
1187 | < | } |
1188 | < | } |
936 | > | fortranInitialized_ = true; |
937 | } | |
938 | ||
1191 | – | void SimInfo::setupElectrostaticSummationMethod( int isError ) { |
1192 | – | |
1193 | – | int errorOut; |
1194 | – | ElectrostaticSummationMethod esm = NONE; |
1195 | – | ElectrostaticScreeningMethod sm = UNDAMPED; |
1196 | – | RealType alphaVal; |
1197 | – | RealType dielectric; |
1198 | – | |
1199 | – | errorOut = isError; |
1200 | – | |
1201 | – | if (simParams_->haveElectrostaticSummationMethod()) { |
1202 | – | std::string myMethod = simParams_->getElectrostaticSummationMethod(); |
1203 | – | toUpper(myMethod); |
1204 | – | if (myMethod == "NONE") { |
1205 | – | esm = NONE; |
1206 | – | } else { |
1207 | – | if (myMethod == "SWITCHING_FUNCTION") { |
1208 | – | esm = SWITCHING_FUNCTION; |
1209 | – | } else { |
1210 | – | if (myMethod == "SHIFTED_POTENTIAL") { |
1211 | – | esm = SHIFTED_POTENTIAL; |
1212 | – | } else { |
1213 | – | if (myMethod == "SHIFTED_FORCE") { |
1214 | – | esm = SHIFTED_FORCE; |
1215 | – | } else { |
1216 | – | if (myMethod == "REACTION_FIELD") { |
1217 | – | esm = REACTION_FIELD; |
1218 | – | dielectric = simParams_->getDielectric(); |
1219 | – | if (!simParams_->haveDielectric()) { |
1220 | – | // throw warning |
1221 | – | sprintf( painCave.errMsg, |
1222 | – | "SimInfo warning: dielectric was not specified in the input file\n\tfor the reaction field correction method.\n" |
1223 | – | "\tA default value of %f will be used for the dielectric.\n", dielectric); |
1224 | – | painCave.isFatal = 0; |
1225 | – | simError(); |
1226 | – | } |
1227 | – | } else { |
1228 | – | // throw error |
1229 | – | sprintf( painCave.errMsg, |
1230 | – | "SimInfo error: Unknown electrostaticSummationMethod.\n" |
1231 | – | "\t(Input file specified %s .)\n" |
1232 | – | "\telectrostaticSummationMethod must be one of: \"none\",\n" |
1233 | – | "\t\"shifted_potential\", \"shifted_force\", or \n" |
1234 | – | "\t\"reaction_field\".\n", myMethod.c_str() ); |
1235 | – | painCave.isFatal = 1; |
1236 | – | simError(); |
1237 | – | } |
1238 | – | } |
1239 | – | } |
1240 | – | } |
1241 | – | } |
1242 | – | } |
1243 | – | |
1244 | – | if (simParams_->haveElectrostaticScreeningMethod()) { |
1245 | – | std::string myScreen = simParams_->getElectrostaticScreeningMethod(); |
1246 | – | toUpper(myScreen); |
1247 | – | if (myScreen == "UNDAMPED") { |
1248 | – | sm = UNDAMPED; |
1249 | – | } else { |
1250 | – | if (myScreen == "DAMPED") { |
1251 | – | sm = DAMPED; |
1252 | – | if (!simParams_->haveDampingAlpha()) { |
1253 | – | // first set a cutoff dependent alpha value |
1254 | – | // we assume alpha depends linearly with rcut from 0 to 20.5 ang |
1255 | – | alphaVal = 0.5125 - rcut_* 0.025; |
1256 | – | // for values rcut > 20.5, alpha is zero |
1257 | – | if (alphaVal < 0) alphaVal = 0; |
1258 | – | |
1259 | – | // throw warning |
1260 | – | sprintf( painCave.errMsg, |
1261 | – | "SimInfo warning: dampingAlpha was not specified in the input file.\n" |
1262 | – | "\tA default value of %f (1/ang) will be used for the cutoff of\n\t%f (ang).\n", alphaVal, rcut_); |
1263 | – | painCave.isFatal = 0; |
1264 | – | simError(); |
1265 | – | } else { |
1266 | – | alphaVal = simParams_->getDampingAlpha(); |
1267 | – | } |
1268 | – | |
1269 | – | } else { |
1270 | – | // throw error |
1271 | – | sprintf( painCave.errMsg, |
1272 | – | "SimInfo error: Unknown electrostaticScreeningMethod.\n" |
1273 | – | "\t(Input file specified %s .)\n" |
1274 | – | "\telectrostaticScreeningMethod must be one of: \"undamped\"\n" |
1275 | – | "or \"damped\".\n", myScreen.c_str() ); |
1276 | – | painCave.isFatal = 1; |
1277 | – | simError(); |
1278 | – | } |
1279 | – | } |
1280 | – | } |
1281 | – | |
1282 | – | |
1283 | – | Electrostatic::setElectrostaticSummationMethod( esm ); |
1284 | – | Electrostatic::setElectrostaticScreeningMethod( sm ); |
1285 | – | Electrostatic::setDampingAlpha( alphaVal ); |
1286 | – | Electrostatic::setReactionFieldDielectric( dielectric ); |
1287 | – | initFortranFF( &errorOut ); |
1288 | – | } |
1289 | – | |
1290 | – | void SimInfo::setupSwitchingFunction() { |
1291 | – | int ft = CUBIC; |
1292 | – | |
1293 | – | if (simParams_->haveSwitchingFunctionType()) { |
1294 | – | std::string funcType = simParams_->getSwitchingFunctionType(); |
1295 | – | toUpper(funcType); |
1296 | – | if (funcType == "CUBIC") { |
1297 | – | ft = CUBIC; |
1298 | – | } else { |
1299 | – | if (funcType == "FIFTH_ORDER_POLYNOMIAL") { |
1300 | – | ft = FIFTH_ORDER_POLY; |
1301 | – | } else { |
1302 | – | // throw error |
1303 | – | sprintf( painCave.errMsg, |
1304 | – | "SimInfo error: Unknown switchingFunctionType. (Input file specified %s .)\n\tswitchingFunctionType must be one of: \"cubic\" or \"fifth_order_polynomial\".", funcType.c_str() ); |
1305 | – | painCave.isFatal = 1; |
1306 | – | simError(); |
1307 | – | } |
1308 | – | } |
1309 | – | } |
1310 | – | |
1311 | – | // send switching function notification to switcheroo |
1312 | – | setFunctionType(&ft); |
1313 | – | |
1314 | – | } |
1315 | – | |
1316 | – | void SimInfo::setupAccumulateBoxDipole() { |
1317 | – | |
1318 | – | // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true |
1319 | – | if ( simParams_->haveAccumulateBoxDipole() ) |
1320 | – | if ( simParams_->getAccumulateBoxDipole() ) { |
1321 | – | setAccumulateBoxDipole(); |
1322 | – | calcBoxDipole_ = true; |
1323 | – | } |
1324 | – | |
1325 | – | } |
1326 | – | |
939 | void SimInfo::addProperty(GenericData* genData) { | |
940 | properties_.addProperty(genData); | |
941 | } | |
942 | ||
943 | < | void SimInfo::removeProperty(const std::string& propName) { |
943 | > | void SimInfo::removeProperty(const string& propName) { |
944 | properties_.removeProperty(propName); | |
945 | } | |
946 | ||
# | Line 1336 | Line 948 | namespace OpenMD { | |
948 | properties_.clearProperties(); | |
949 | } | |
950 | ||
951 | < | std::vector<std::string> SimInfo::getPropertyNames() { |
951 | > | vector<string> SimInfo::getPropertyNames() { |
952 | return properties_.getPropertyNames(); | |
953 | } | |
954 | ||
955 | < | std::vector<GenericData*> SimInfo::getProperties() { |
955 | > | vector<GenericData*> SimInfo::getProperties() { |
956 | return properties_.getProperties(); | |
957 | } | |
958 | ||
959 | < | GenericData* SimInfo::getPropertyByName(const std::string& propName) { |
959 | > | GenericData* SimInfo::getPropertyByName(const string& propName) { |
960 | return properties_.getPropertyByName(propName); | |
961 | } | |
962 | ||
# | Line 1427 | Line 1039 | namespace OpenMD { | |
1039 | ||
1040 | } | |
1041 | ||
1042 | < | std::ostream& operator <<(std::ostream& o, SimInfo& info) { |
1042 | > | ostream& operator <<(ostream& o, SimInfo& info) { |
1043 | ||
1044 | return o; | |
1045 | } | |
# | Line 1577 | Line 1189 | namespace OpenMD { | |
1189 | return IOIndexToIntegrableObject.at(index); | |
1190 | } | |
1191 | ||
1192 | < | void SimInfo::setIOIndexToIntegrableObject(const std::vector<StuntDouble*>& v) { |
1192 | > | void SimInfo::setIOIndexToIntegrableObject(const vector<StuntDouble*>& v) { |
1193 | IOIndexToIntegrableObject= v; | |
1194 | } | |
1195 | ||
# | Line 1619 | Line 1231 | namespace OpenMD { | |
1231 | return; | |
1232 | } | |
1233 | /* | |
1234 | < | void SimInfo::setStuntDoubleFromGlobalIndex(std::vector<StuntDouble*> v) { |
1234 | > | void SimInfo::setStuntDoubleFromGlobalIndex(vector<StuntDouble*> v) { |
1235 | assert( v.size() == nAtoms_ + nRigidBodies_); | |
1236 | sdByGlobalIndex_ = v; | |
1237 | } | |
# | Line 1629 | Line 1241 | namespace OpenMD { | |
1241 | return sdByGlobalIndex_.at(index); | |
1242 | } | |
1243 | */ | |
1244 | + | int SimInfo::getNGlobalConstraints() { |
1245 | + | int nGlobalConstraints; |
1246 | + | #ifdef IS_MPI |
1247 | + | MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM, |
1248 | + | MPI_COMM_WORLD); |
1249 | + | #else |
1250 | + | nGlobalConstraints = nConstraints_; |
1251 | + | #endif |
1252 | + | return nGlobalConstraints; |
1253 | + | } |
1254 | + | |
1255 | }//end namespace OpenMD | |
1256 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |