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

Comparing:
trunk/src/brains/SimInfo.cpp (file contents), Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC vs.
branches/development/src/brains/SimInfo.cpp (file contents), Revision 1569 by gezelter, Thu May 26 13:55:04 2011 UTC

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

Diff Legend

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