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 334 by tim, Mon Feb 14 17:57:01 2005 UTC vs.
branches/development/src/brains/SimInfo.cpp (file contents), Revision 1550 by gezelter, Wed Apr 27 21:49:59 2011 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42   /**
# Line 48 | Line 48
48  
49   #include <algorithm>
50   #include <set>
51 + #include <map>
52  
53   #include "brains/SimInfo.hpp"
54   #include "math/Vector3.hpp"
55   #include "primitives/Molecule.hpp"
56 < #include "UseTheForce/doForces_interface.h"
56 < #include "UseTheForce/notifyCutoffs_interface.h"
56 > #include "primitives/StuntDouble.hpp"
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 < #ifdef IS_MPI
65 < #include "UseTheForce/mpiComponentPlan.h"
66 < #include "UseTheForce/DarkSide/simParallel_interface.h"
67 < #endif
68 <
69 < namespace oopse {
70 <
71 < SimInfo::SimInfo(std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs,
72 <                                ForceField* ff, Globals* simParams) :
73 <                                forceField_(ff), simParams_(simParams),
74 <                                ndf_(0), ndfRaw_(0), ndfTrans_(0), nZconstraint_(0),
75 <                                nGlobalMols_(0), nGlobalAtoms_(0), nGlobalCutoffGroups_(0),
76 <                                nGlobalIntegrableObjects_(0), nGlobalRigidBodies_(0),
74 <                                nAtoms_(0), nBonds_(0),  nBends_(0), nTorsions_(0), nRigidBodies_(0),
75 <                                nIntegrableObjects_(0),  nCutoffGroups_(0), nConstraints_(0),
76 <                                sman_(NULL), fortranInitialized_(false), selectMan_(NULL) {
77 <
78 <            
79 <    std::vector<std::pair<MoleculeStamp*, int> >::iterator i;
64 > using namespace std;
65 > namespace OpenMD {
66 >  
67 >  SimInfo::SimInfo(ForceField* ff, Globals* simParams) :
68 >    forceField_(ff), simParams_(simParams),
69 >    ndf_(0), fdf_local(0), ndfRaw_(0), ndfTrans_(0), nZconstraint_(0),
70 >    nGlobalMols_(0), nGlobalAtoms_(0), nGlobalCutoffGroups_(0),
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      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
80 >    int nGroups = 0;       //total cutoff groups defined in meta-data file
81      CutoffGroupStamp* cgStamp;    
82      RigidBodyStamp* rbStamp;
83      int nRigidAtoms = 0;
84      
85 <    for (i = molStampPairs.begin(); i !=molStampPairs.end(); ++i) {
86 <        molStamp = i->first;
87 <        nMolWithSameStamp = i->second;
88 <        
89 <        addMoleculeStamp(molStamp, nMolWithSameStamp);
90 <
91 <        //calculate atoms in molecules
92 <        nGlobalAtoms_ += molStamp->getNAtoms() *nMolWithSameStamp;  
93 <
94 <
95 <        //calculate atoms in cutoff groups
96 <        int nAtomsInGroups = 0;
97 <        int nCutoffGroupsInStamp = molStamp->getNCutoffGroups();
98 <        
99 <        for (int j=0; j < nCutoffGroupsInStamp; j++) {
100 <            cgStamp = molStamp->getCutoffGroup(j);
101 <            nAtomsInGroups += cgStamp->getNMembers();
102 <        }
103 <
104 <        nGroups += nCutoffGroupsInStamp * nMolWithSameStamp;
105 <        nCutoffAtoms += nAtomsInGroups * nMolWithSameStamp;            
106 <
107 <        //calculate atoms in rigid bodies
108 <        int nAtomsInRigidBodies = 0;
109 <        int nRigidBodiesInStamp = molStamp->getNRigidBodies();
110 <        
111 <        for (int j=0; j < nRigidBodiesInStamp; j++) {
112 <            rbStamp = molStamp->getRigidBody(j);
113 <            nAtomsInRigidBodies += rbStamp->getNMembers();
114 <        }
115 <
116 <        nGlobalRigidBodies_ += nRigidBodiesInStamp * nMolWithSameStamp;
117 <        nRigidAtoms += nAtomsInRigidBodies * nMolWithSameStamp;            
118 <        
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 >      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 >      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  
124    //every free atom (atom does not belong to cutoff groups) is a cutoff group
125    //therefore the total number of cutoff groups in the system is equal to
126    //the total number of atoms minus number of atoms belong to cutoff group defined in meta-data
127    //file plus the number of cutoff groups defined in meta-data file
132      nGlobalCutoffGroups_ = nGlobalAtoms_ - nCutoffAtoms + nGroups;
133  
134 <    //every free atom (atom does not belong to rigid bodies) is an integrable object
135 <    //therefore the total number of  integrable objects in the system is equal to
136 <    //the total number of atoms minus number of atoms belong to  rigid body defined in meta-data
137 <    //file plus the number of  rigid bodies defined in meta-data file
138 <    nGlobalIntegrableObjects_ = nGlobalAtoms_ - nRigidAtoms + nGlobalRigidBodies_;
139 <
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();
137
138 #ifdef IS_MPI    
145      molToProcMap_.resize(nGlobalMols_);
146 < #endif
147 <
148 <    selectMan_ = new SelectionManager(this);
149 <    selectMan_->selectAll();
150 < }
151 <
152 < SimInfo::~SimInfo() {
153 <    //MemoryUtils::deleteVectorOfPointer(molecules_);
154 <
149 <    MemoryUtils::deleteVectorOfPointer(moleculeStamps_);
150 <    
146 >  }
147 >  
148 >  SimInfo::~SimInfo() {
149 >    map<int, Molecule*>::iterator i;
150 >    for (i = molecules_.begin(); i != molecules_.end(); ++i) {
151 >      delete i->second;
152 >    }
153 >    molecules_.clear();
154 >      
155      delete sman_;
156      delete simParams_;
157      delete forceField_;
158 <    delete selectMan_;
155 < }
158 >  }
159  
157 int SimInfo::getNGlobalConstraints() {
158    int nGlobalConstraints;
159 #ifdef IS_MPI
160    MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM,
161                  MPI_COMM_WORLD);    
162 #else
163    nGlobalConstraints =  nConstraints_;
164 #endif
165    return nGlobalConstraints;
166 }
160  
161 < bool SimInfo::addMolecule(Molecule* mol) {
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 <        
169 <        nAtoms_ += mol->getNAtoms();
170 <        nBonds_ += mol->getNBonds();
171 <        nBends_ += mol->getNBends();
172 <        nTorsions_ += mol->getNTorsions();
173 <        nRigidBodies_ += mol->getNRigidBodies();
174 <        nIntegrableObjects_ += mol->getNIntegrableObjects();
175 <        nCutoffGroups_ += mol->getNCutoffGroups();
176 <        nConstraints_ += mol->getNConstraintPairs();
177 <
178 <        addExcludePairs(mol);
179 <        
180 <        return true;
181 <    } else {
182 <        return false;
166 >      
167 >      molecules_.insert(make_pair(mol->getGlobalIndex(), mol));
168 >      
169 >      nAtoms_ += mol->getNAtoms();
170 >      nBonds_ += mol->getNBonds();
171 >      nBends_ += mol->getNBends();
172 >      nTorsions_ += mol->getNTorsions();
173 >      nInversions_ += mol->getNInversions();
174 >      nRigidBodies_ += mol->getNRigidBodies();
175 >      nIntegrableObjects_ += mol->getNIntegrableObjects();
176 >      nCutoffGroups_ += mol->getNCutoffGroups();
177 >      nConstraints_ += mol->getNConstraintPairs();
178 >      
179 >      addInteractionPairs(mol);
180 >      
181 >      return true;
182 >    } else {
183 >      return false;
184      }
185 < }
186 <
187 < bool SimInfo::removeMolecule(Molecule* mol) {
185 >  }
186 >  
187 >  bool SimInfo::removeMolecule(Molecule* mol) {
188      MoleculeIterator i;
189      i = molecules_.find(mol->getGlobalIndex());
190  
191      if (i != molecules_.end() ) {
192  
193 <        assert(mol == i->second);
193 >      assert(mol == i->second);
194          
195 <        nAtoms_ -= mol->getNAtoms();
196 <        nBonds_ -= mol->getNBonds();
197 <        nBends_ -= mol->getNBends();
198 <        nTorsions_ -= mol->getNTorsions();
199 <        nRigidBodies_ -= mol->getNRigidBodies();
200 <        nIntegrableObjects_ -= mol->getNIntegrableObjects();
201 <        nCutoffGroups_ -= mol->getNCutoffGroups();
202 <        nConstraints_ -= mol->getNConstraintPairs();
195 >      nAtoms_ -= mol->getNAtoms();
196 >      nBonds_ -= mol->getNBonds();
197 >      nBends_ -= mol->getNBends();
198 >      nTorsions_ -= mol->getNTorsions();
199 >      nInversions_ -= mol->getNInversions();
200 >      nRigidBodies_ -= mol->getNRigidBodies();
201 >      nIntegrableObjects_ -= mol->getNIntegrableObjects();
202 >      nCutoffGroups_ -= mol->getNCutoffGroups();
203 >      nConstraints_ -= mol->getNConstraintPairs();
204  
205 <        removeExcludePairs(mol);
206 <        molecules_.erase(mol->getGlobalIndex());
205 >      removeInteractionPairs(mol);
206 >      molecules_.erase(mol->getGlobalIndex());
207  
208 <        delete mol;
208 >      delete mol;
209          
210 <        return true;
210 >      return true;
211      } else {
212 <        return false;
212 >      return false;
213      }
214 +  }    
215  
220
221 }    
222
216          
217 < Molecule* SimInfo::beginMolecule(MoleculeIterator& i) {
217 >  Molecule* SimInfo::beginMolecule(MoleculeIterator& i) {
218      i = molecules_.begin();
219      return i == molecules_.end() ? NULL : i->second;
220 < }    
220 >  }    
221  
222 < Molecule* SimInfo::nextMolecule(MoleculeIterator& i) {
222 >  Molecule* SimInfo::nextMolecule(MoleculeIterator& i) {
223      ++i;
224      return i == molecules_.end() ? NULL : i->second;    
225 < }
225 >  }
226  
227  
228 < void SimInfo::calcNdf() {
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  
235      ndf_local = 0;
236      
237      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
238 <        for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
239 <               integrableObject = mol->nextIntegrableObject(j)) {
238 >      for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
239 >           integrableObject = mol->nextIntegrableObject(j)) {
240  
241 <            ndf_local += 3;
241 >        ndf_local += 3;
242  
243 <            if (integrableObject->isDirectional()) {
244 <                if (integrableObject->isLinear()) {
245 <                    ndf_local += 2;
246 <                } else {
247 <                    ndf_local += 3;
248 <                }
249 <            }
243 >        if (integrableObject->isDirectional()) {
244 >          if (integrableObject->isLinear()) {
245 >            ndf_local += 2;
246 >          } else {
247 >            ndf_local += 3;
248 >          }
249 >        }
250              
251 <        }//end for (integrableObject)
252 <    }// end for (mol)
251 >      }
252 >    }
253      
254      // n_constraints is local, so subtract them on each processor
255      ndf_local -= nConstraints_;
# Line 271 | Line 264 | void SimInfo::calcNdf() {
264      // entire system:
265      ndf_ = ndf_ - 3 - nZconstraint_;
266  
267 < }
267 >  }
268  
269 < void SimInfo::calcNdfRaw() {
269 >  int SimInfo::getFdf() {
270 > #ifdef IS_MPI
271 >    MPI_Allreduce(&fdf_local,&fdf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
272 > #else
273 >    fdf_ = fdf_local;
274 > #endif
275 >    return fdf_;
276 >  }
277 >    
278 >  void SimInfo::calcNdfRaw() {
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 285 | Line 287 | void SimInfo::calcNdfRaw() {
287      ndfRaw_local = 0;
288      
289      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
290 <        for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
291 <               integrableObject = mol->nextIntegrableObject(j)) {
290 >      for (integrableObject = mol->beginIntegrableObject(j); integrableObject != NULL;
291 >           integrableObject = mol->nextIntegrableObject(j)) {
292  
293 <            ndfRaw_local += 3;
293 >        ndfRaw_local += 3;
294  
295 <            if (integrableObject->isDirectional()) {
296 <                if (integrableObject->isLinear()) {
297 <                    ndfRaw_local += 2;
298 <                } else {
299 <                    ndfRaw_local += 3;
300 <                }
301 <            }
295 >        if (integrableObject->isDirectional()) {
296 >          if (integrableObject->isLinear()) {
297 >            ndfRaw_local += 2;
298 >          } else {
299 >            ndfRaw_local += 3;
300 >          }
301 >        }
302              
303 <        }
303 >      }
304      }
305      
306   #ifdef IS_MPI
# Line 306 | Line 308 | void SimInfo::calcNdfRaw() {
308   #else
309      ndfRaw_ = ndfRaw_local;
310   #endif
311 < }
311 >  }
312  
313 < void SimInfo::calcNdfTrans() {
313 >  void SimInfo::calcNdfTrans() {
314      int ndfTrans_local;
315  
316      ndfTrans_local = 3 * nIntegrableObjects_ - nConstraints_;
# Line 322 | Line 324 | void SimInfo::calcNdfTrans() {
324  
325      ndfTrans_ = ndfTrans_ - 3 - nZconstraint_;
326  
327 < }
327 >  }
328  
329 < void SimInfo::addExcludePairs(Molecule* mol) {
330 <    std::vector<Bond*>::iterator bondIter;
331 <    std::vector<Bend*>::iterator bendIter;
332 <    std::vector<Torsion*>::iterator torsionIter;
329 >  void SimInfo::addInteractionPairs(Molecule* mol) {
330 >    ForceFieldOptions& options_ = forceField_->getForceFieldOptions();
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;
338 +    Inversion* inversion;
339      int a;
340      int b;
341      int c;
342      int d;
338    
339    for (bond= mol->beginBond(bondIter); bond != NULL; bond = mol->nextBond(bondIter)) {
340        a = bond->getAtomA()->getGlobalIndex();
341        b = bond->getAtomB()->getGlobalIndex();        
342        exclude_.addPair(a, b);
343    }
343  
344 <    for (bend= mol->beginBend(bendIter); bend != NULL; bend = mol->nextBend(bendIter)) {
345 <        a = bend->getAtomA()->getGlobalIndex();
346 <        b = bend->getAtomB()->getGlobalIndex();        
347 <        c = bend->getAtomC()->getGlobalIndex();
344 >    // atomGroups can be used to add special interaction maps between
345 >    // groups of atoms that are in two separate rigid bodies.
346 >    // However, most site-site interactions between two rigid bodies
347 >    // are probably not special, just the ones between the physically
348 >    // bonded atoms.  Interactions *within* a single rigid body should
349 >    // always be excluded.  These are done at the bottom of this
350 >    // function.
351  
352 <        exclude_.addPair(a, b);
353 <        exclude_.addPair(a, c);
354 <        exclude_.addPair(b, c);        
355 <    }
352 >    map<int, set<int> > atomGroups;
353 >    Molecule::RigidBodyIterator rbIter;
354 >    RigidBody* rb;
355 >    Molecule::IntegrableObjectIterator ii;
356 >    StuntDouble* integrableObject;
357 >    
358 >    for (integrableObject = mol->beginIntegrableObject(ii);
359 >         integrableObject != NULL;
360 >         integrableObject = mol->nextIntegrableObject(ii)) {
361 >      
362 >      if (integrableObject->isRigidBody()) {
363 >        rb = static_cast<RigidBody*>(integrableObject);
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(map<int, set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms));
371 >        }      
372 >      } else {
373 >        set<int> oneAtomSet;
374 >        oneAtomSet.insert(integrableObject->getGlobalIndex());
375 >        atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
376 >      }
377 >    }  
378 >          
379 >    for (bond= mol->beginBond(bondIter); bond != NULL;
380 >         bond = mol->nextBond(bondIter)) {
381  
382 <    for (torsion= mol->beginTorsion(torsionIter); torsion != NULL; torsion = mol->nextTorsion(torsionIter)) {
383 <        a = torsion->getAtomA()->getGlobalIndex();
384 <        b = torsion->getAtomB()->getGlobalIndex();        
385 <        c = torsion->getAtomC()->getGlobalIndex();        
386 <        d = torsion->getAtomD()->getGlobalIndex();        
382 >      a = bond->getAtomA()->getGlobalIndex();
383 >      b = bond->getAtomB()->getGlobalIndex();  
384 >    
385 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
386 >        oneTwoInteractions_.addPair(a, b);
387 >      } else {
388 >        excludedInteractions_.addPair(a, b);
389 >      }
390 >    }
391  
392 <        exclude_.addPair(a, b);
393 <        exclude_.addPair(a, c);
394 <        exclude_.addPair(a, d);
395 <        exclude_.addPair(b, c);
396 <        exclude_.addPair(b, d);
397 <        exclude_.addPair(c, d);        
392 >    for (bend= mol->beginBend(bendIter); bend != NULL;
393 >         bend = mol->nextBend(bendIter)) {
394 >
395 >      a = bend->getAtomA()->getGlobalIndex();
396 >      b = bend->getAtomB()->getGlobalIndex();        
397 >      c = bend->getAtomC()->getGlobalIndex();
398 >      
399 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
400 >        oneTwoInteractions_.addPair(a, b);      
401 >        oneTwoInteractions_.addPair(b, c);
402 >      } else {
403 >        excludedInteractions_.addPair(a, b);
404 >        excludedInteractions_.addPair(b, c);
405 >      }
406 >
407 >      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
408 >        oneThreeInteractions_.addPair(a, c);      
409 >      } else {
410 >        excludedInteractions_.addPair(a, c);
411 >      }
412      }
413  
414 <    
415 < }
414 >    for (torsion= mol->beginTorsion(torsionIter); torsion != NULL;
415 >         torsion = mol->nextTorsion(torsionIter)) {
416  
417 < void SimInfo::removeExcludePairs(Molecule* mol) {
418 <    std::vector<Bond*>::iterator bondIter;
419 <    std::vector<Bend*>::iterator bendIter;
420 <    std::vector<Torsion*>::iterator torsionIter;
417 >      a = torsion->getAtomA()->getGlobalIndex();
418 >      b = torsion->getAtomB()->getGlobalIndex();        
419 >      c = torsion->getAtomC()->getGlobalIndex();        
420 >      d = torsion->getAtomD()->getGlobalIndex();      
421 >
422 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
423 >        oneTwoInteractions_.addPair(a, b);      
424 >        oneTwoInteractions_.addPair(b, c);
425 >        oneTwoInteractions_.addPair(c, d);
426 >      } else {
427 >        excludedInteractions_.addPair(a, b);
428 >        excludedInteractions_.addPair(b, c);
429 >        excludedInteractions_.addPair(c, d);
430 >      }
431 >
432 >      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
433 >        oneThreeInteractions_.addPair(a, c);      
434 >        oneThreeInteractions_.addPair(b, d);      
435 >      } else {
436 >        excludedInteractions_.addPair(a, c);
437 >        excludedInteractions_.addPair(b, d);
438 >      }
439 >
440 >      if (options_.havevdw14scale() || options_.haveelectrostatic14scale()) {
441 >        oneFourInteractions_.addPair(a, d);      
442 >      } else {
443 >        excludedInteractions_.addPair(a, d);
444 >      }
445 >    }
446 >
447 >    for (inversion= mol->beginInversion(inversionIter); inversion != NULL;
448 >         inversion = mol->nextInversion(inversionIter)) {
449 >
450 >      a = inversion->getAtomA()->getGlobalIndex();
451 >      b = inversion->getAtomB()->getGlobalIndex();        
452 >      c = inversion->getAtomC()->getGlobalIndex();        
453 >      d = inversion->getAtomD()->getGlobalIndex();        
454 >
455 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
456 >        oneTwoInteractions_.addPair(a, b);      
457 >        oneTwoInteractions_.addPair(a, c);
458 >        oneTwoInteractions_.addPair(a, d);
459 >      } else {
460 >        excludedInteractions_.addPair(a, b);
461 >        excludedInteractions_.addPair(a, c);
462 >        excludedInteractions_.addPair(a, d);
463 >      }
464 >
465 >      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
466 >        oneThreeInteractions_.addPair(b, c);    
467 >        oneThreeInteractions_.addPair(b, d);    
468 >        oneThreeInteractions_.addPair(c, d);      
469 >      } else {
470 >        excludedInteractions_.addPair(b, c);
471 >        excludedInteractions_.addPair(b, d);
472 >        excludedInteractions_.addPair(c, d);
473 >      }
474 >    }
475 >
476 >    for (rb = mol->beginRigidBody(rbIter); rb != NULL;
477 >         rb = mol->nextRigidBody(rbIter)) {
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();
482 >          b = atoms[j]->getGlobalIndex();
483 >          excludedInteractions_.addPair(a, b);
484 >        }
485 >      }
486 >    }        
487 >
488 >  }
489 >
490 >  void SimInfo::removeInteractionPairs(Molecule* mol) {
491 >    ForceFieldOptions& options_ = forceField_->getForceFieldOptions();
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;
499 +    Inversion* inversion;
500      int a;
501      int b;
502      int c;
503      int d;
504 +
505 +    map<int, set<int> > atomGroups;
506 +    Molecule::RigidBodyIterator rbIter;
507 +    RigidBody* rb;
508 +    Molecule::IntegrableObjectIterator ii;
509 +    StuntDouble* integrableObject;
510      
511 <    for (bond= mol->beginBond(bondIter); bond != NULL; bond = mol->nextBond(bondIter)) {
512 <        a = bond->getAtomA()->getGlobalIndex();
513 <        b = bond->getAtomB()->getGlobalIndex();        
514 <        exclude_.removePair(a, b);
511 >    for (integrableObject = mol->beginIntegrableObject(ii);
512 >         integrableObject != NULL;
513 >         integrableObject = mol->nextIntegrableObject(ii)) {
514 >      
515 >      if (integrableObject->isRigidBody()) {
516 >        rb = static_cast<RigidBody*>(integrableObject);
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(map<int, set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms));
524 >        }      
525 >      } else {
526 >        set<int> oneAtomSet;
527 >        oneAtomSet.insert(integrableObject->getGlobalIndex());
528 >        atomGroups.insert(map<int, set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
529 >      }
530 >    }  
531 >
532 >    for (bond= mol->beginBond(bondIter); bond != NULL;
533 >         bond = mol->nextBond(bondIter)) {
534 >      
535 >      a = bond->getAtomA()->getGlobalIndex();
536 >      b = bond->getAtomB()->getGlobalIndex();  
537 >    
538 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
539 >        oneTwoInteractions_.removePair(a, b);
540 >      } else {
541 >        excludedInteractions_.removePair(a, b);
542 >      }
543      }
544  
545 <    for (bend= mol->beginBend(bendIter); bend != NULL; bend = mol->nextBend(bendIter)) {
546 <        a = bend->getAtomA()->getGlobalIndex();
392 <        b = bend->getAtomB()->getGlobalIndex();        
393 <        c = bend->getAtomC()->getGlobalIndex();
545 >    for (bend= mol->beginBend(bendIter); bend != NULL;
546 >         bend = mol->nextBend(bendIter)) {
547  
548 <        exclude_.removePair(a, b);
549 <        exclude_.removePair(a, c);
550 <        exclude_.removePair(b, c);        
548 >      a = bend->getAtomA()->getGlobalIndex();
549 >      b = bend->getAtomB()->getGlobalIndex();        
550 >      c = bend->getAtomC()->getGlobalIndex();
551 >      
552 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
553 >        oneTwoInteractions_.removePair(a, b);      
554 >        oneTwoInteractions_.removePair(b, c);
555 >      } else {
556 >        excludedInteractions_.removePair(a, b);
557 >        excludedInteractions_.removePair(b, c);
558 >      }
559 >
560 >      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
561 >        oneThreeInteractions_.removePair(a, c);      
562 >      } else {
563 >        excludedInteractions_.removePair(a, c);
564 >      }
565      }
566  
567 <    for (torsion= mol->beginTorsion(torsionIter); torsion != NULL; torsion = mol->nextTorsion(torsionIter)) {
568 <        a = torsion->getAtomA()->getGlobalIndex();
402 <        b = torsion->getAtomB()->getGlobalIndex();        
403 <        c = torsion->getAtomC()->getGlobalIndex();        
404 <        d = torsion->getAtomD()->getGlobalIndex();        
567 >    for (torsion= mol->beginTorsion(torsionIter); torsion != NULL;
568 >         torsion = mol->nextTorsion(torsionIter)) {
569  
570 <        exclude_.removePair(a, b);
571 <        exclude_.removePair(a, c);
572 <        exclude_.removePair(a, d);
573 <        exclude_.removePair(b, c);
574 <        exclude_.removePair(b, d);
575 <        exclude_.removePair(c, d);        
570 >      a = torsion->getAtomA()->getGlobalIndex();
571 >      b = torsion->getAtomB()->getGlobalIndex();        
572 >      c = torsion->getAtomC()->getGlobalIndex();        
573 >      d = torsion->getAtomD()->getGlobalIndex();      
574 >  
575 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
576 >        oneTwoInteractions_.removePair(a, b);      
577 >        oneTwoInteractions_.removePair(b, c);
578 >        oneTwoInteractions_.removePair(c, d);
579 >      } else {
580 >        excludedInteractions_.removePair(a, b);
581 >        excludedInteractions_.removePair(b, c);
582 >        excludedInteractions_.removePair(c, d);
583 >      }
584 >
585 >      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
586 >        oneThreeInteractions_.removePair(a, c);      
587 >        oneThreeInteractions_.removePair(b, d);      
588 >      } else {
589 >        excludedInteractions_.removePair(a, c);
590 >        excludedInteractions_.removePair(b, d);
591 >      }
592 >
593 >      if (options_.havevdw14scale() || options_.haveelectrostatic14scale()) {
594 >        oneFourInteractions_.removePair(a, d);      
595 >      } else {
596 >        excludedInteractions_.removePair(a, d);
597 >      }
598      }
599  
600 < }
600 >    for (inversion= mol->beginInversion(inversionIter); inversion != NULL;
601 >         inversion = mol->nextInversion(inversionIter)) {
602  
603 +      a = inversion->getAtomA()->getGlobalIndex();
604 +      b = inversion->getAtomB()->getGlobalIndex();        
605 +      c = inversion->getAtomC()->getGlobalIndex();        
606 +      d = inversion->getAtomD()->getGlobalIndex();        
607  
608 < void SimInfo::addMoleculeStamp(MoleculeStamp* molStamp, int nmol) {
609 <    int curStampId;
608 >      if (options_.havevdw12scale() || options_.haveelectrostatic12scale()) {
609 >        oneTwoInteractions_.removePair(a, b);      
610 >        oneTwoInteractions_.removePair(a, c);
611 >        oneTwoInteractions_.removePair(a, d);
612 >      } else {
613 >        excludedInteractions_.removePair(a, b);
614 >        excludedInteractions_.removePair(a, c);
615 >        excludedInteractions_.removePair(a, d);
616 >      }
617  
618 +      if (options_.havevdw13scale() || options_.haveelectrostatic13scale()) {
619 +        oneThreeInteractions_.removePair(b, c);    
620 +        oneThreeInteractions_.removePair(b, d);    
621 +        oneThreeInteractions_.removePair(c, d);      
622 +      } else {
623 +        excludedInteractions_.removePair(b, c);
624 +        excludedInteractions_.removePair(b, d);
625 +        excludedInteractions_.removePair(c, d);
626 +      }
627 +    }
628 +
629 +    for (rb = mol->beginRigidBody(rbIter); rb != NULL;
630 +         rb = mol->nextRigidBody(rbIter)) {
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();
635 +          b = atoms[j]->getGlobalIndex();
636 +          excludedInteractions_.removePair(a, b);
637 +        }
638 +      }
639 +    }        
640 +    
641 +  }
642 +  
643 +  
644 +  void SimInfo::addMoleculeStamp(MoleculeStamp* molStamp, int nmol) {
645 +    int curStampId;
646 +    
647      //index from 0
648      curStampId = moleculeStamps_.size();
649  
650      moleculeStamps_.push_back(molStamp);
651      molStampIds_.insert(molStampIds_.end(), nmol, curStampId);
652 < }
652 >  }
653  
427 void SimInfo::update() {
654  
655 <    setupSimType();
656 <
657 < #ifdef IS_MPI
658 <    setupFortranParallel();
659 < #endif
660 <
661 <    setupFortranSim();
662 <
663 <    //setup fortran force field
438 <    /** @deprecate */    
439 <    int isError = 0;
440 <    initFortranFF( &fInfo_.SIM_uses_RF , &isError );
441 <    if(isError){
442 <        sprintf( painCave.errMsg,
443 <         "ForceField error: There was an error initializing the forceField in fortran.\n" );
444 <        painCave.isFatal = 1;
445 <        simError();
446 <    }
447 <  
448 <    
449 <    setupCutoff();
450 <
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();
667 <
668 <    fortranInitialized_ = true;
669 < }
670 <
671 < std::set<AtomType*> SimInfo::getUniqueAtomTypes() {
667 >  }
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;
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 >    }    
688  
689 <    for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
689 > #ifdef IS_MPI
690  
691 <        for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
692 <            atomTypes.insert(atom->getAtomType());
469 <        }
470 <        
471 <    }
691 >    // loop over the found atom types on this processor, and add their
692 >    // numerical idents to a vector:
693  
694 <    return atomTypes;        
695 < }
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 < void SimInfo::setupSimType() {
700 <    std::set<AtomType*>::iterator i;
701 <    std::set<AtomType*> atomTypes;
702 <    atomTypes = getUniqueAtomTypes();
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 >    // 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 <    int useLennardJones = 0;
720 <    int useElectrostatic = 0;
483 <    int useEAM = 0;
484 <    int useCharge = 0;
485 <    int useDirectional = 0;
486 <    int useDipole = 0;
487 <    int useGayBerne = 0;
488 <    int useSticky = 0;
489 <    int useShape = 0;
490 <    int useFLARB = 0; //it is not in AtomType yet
491 <    int useDirectionalAtom = 0;    
492 <    int useElectrostatics = 0;
493 <    //usePBC and useRF are from simParams
494 <    int usePBC = simParams_->getPBC();
495 <    int useRF = simParams_->getUseRF();
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();
502 <        useCharge |= (*i)->isCharge();
503 <        useDirectional |= (*i)->isDirectional();
504 <        useDipole |= (*i)->isDipole();
505 <        useGayBerne |= (*i)->isGayBerne();
506 <        useSticky |= (*i)->isSticky();
507 <        useShape |= (*i)->isShape();
757 >      usesElectrostatic |= (*i)->isElectrostatic();
758 >      usesMetallic |= (*i)->isMetal();
759 >      usesDirectional |= (*i)->isDirectional();
760      }
761  
510    if (useSticky || useDipole || useGayBerne || useShape) {
511        useDirectionalAtom = 1;
512    }
513
514    if (useCharge || useDipole) {
515        useElectrostatics = 1;
516    }
517
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 >    fInfo_.SIM_uses_PBC = usesPeriodicBoundaries_;    
774 >    fInfo_.SIM_uses_DirectionalAtoms = usesDirectionalAtoms_;
775 >    fInfo_.SIM_uses_MetallicAtoms = usesMetallicAtoms_;
776 >    fInfo_.SIM_requires_SkipCorrection = usesElectrostaticAtoms_;
777 >    fInfo_.SIM_requires_SelfCorrection = usesElectrostaticAtoms_;
778 >    fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_;
779 >  }
780  
527    temp = useLennardJones;
528    MPI_Allreduce(&temp, &useLennardJones, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
781  
782 <    temp = useElectrostatics;
783 <    MPI_Allreduce(&temp, &useElectrostatics, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
782 >  vector<int> SimInfo::getGlobalAtomIndices() {
783 >    SimInfo::MoleculeIterator mi;
784 >    Molecule* mol;
785 >    Molecule::AtomIterator ai;
786 >    Atom* atom;
787  
788 <    temp = useCharge;
534 <    MPI_Allreduce(&temp, &useCharge, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
535 <
536 <    temp = useDipole;
537 <    MPI_Allreduce(&temp, &useDipole, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
538 <
539 <    temp = useSticky;
540 <    MPI_Allreduce(&temp, &useSticky, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
541 <
542 <    temp = useGayBerne;
543 <    MPI_Allreduce(&temp, &useGayBerne, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
544 <
545 <    temp = useEAM;
546 <    MPI_Allreduce(&temp, &useEAM, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
547 <
548 <    temp = useShape;
549 <    MPI_Allreduce(&temp, &useShape, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);  
550 <
551 <    temp = useFLARB;
552 <    MPI_Allreduce(&temp, &useFLARB, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
553 <
554 <    temp = useRF;
555 <    MPI_Allreduce(&temp, &useRF, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
788 >    vector<int> GlobalAtomIndices(getNAtoms(), 0);
789      
790 < #endif
790 >    for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
791 >      
792 >      for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
793 >        GlobalAtomIndices[atom->getLocalIndex()] = atom->getGlobalIndex();
794 >      }
795 >    }
796 >    return GlobalAtomIndices;
797 >  }
798  
559    fInfo_.SIM_uses_PBC = usePBC;    
560    fInfo_.SIM_uses_DirectionalAtoms = useDirectionalAtom;
561    fInfo_.SIM_uses_LennardJones = useLennardJones;
562    fInfo_.SIM_uses_Electrostatics = useElectrostatics;    
563    fInfo_.SIM_uses_Charges = useCharge;
564    fInfo_.SIM_uses_Dipoles = useDipole;
565    fInfo_.SIM_uses_Sticky = useSticky;
566    fInfo_.SIM_uses_GayBerne = useGayBerne;
567    fInfo_.SIM_uses_EAM = useEAM;
568    fInfo_.SIM_uses_Shapes = useShape;
569    fInfo_.SIM_uses_FLARB = useFLARB;
570    fInfo_.SIM_uses_RF = useRF;
799  
800 <    if( fInfo_.SIM_uses_Dipoles && fInfo_.SIM_uses_RF) {
800 >  vector<int> SimInfo::getGlobalGroupIndices() {
801 >    SimInfo::MoleculeIterator mi;
802 >    Molecule* mol;
803 >    Molecule::CutoffGroupIterator ci;
804 >    CutoffGroup* cg;
805  
806 <        if (simParams_->haveDielectric()) {
807 <            fInfo_.dielect = simParams_->getDielectric();
808 <        } else {
809 <            sprintf(painCave.errMsg,
810 <                    "SimSetup Error: No Dielectric constant was set.\n"
811 <                    "\tYou are trying to use Reaction Field without"
812 <                    "\tsetting a dielectric constant!\n");
813 <            painCave.isFatal = 1;
814 <            simError();
815 <        }
584 <        
585 <    } else {
586 <        fInfo_.dielect = 0.0;
806 >    vector<int> GlobalGroupIndices;
807 >    
808 >    for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
809 >      
810 >      //local index of cutoff group is trivial, it only depends on the
811 >      //order of travesing
812 >      for (cg = mol->beginCutoffGroup(ci); cg != NULL;
813 >           cg = mol->nextCutoffGroup(ci)) {
814 >        GlobalGroupIndices.push_back(cg->getGlobalIndex());
815 >      }        
816      }
817 +    return GlobalGroupIndices;
818 +  }
819  
589 }
820  
821 < void SimInfo::setupFortranSim() {
821 >  void SimInfo::setupFortran() {
822      int isError;
823 <    int nExclude;
824 <    std::vector<int> fortranGlobalGroupMembership;
823 >    int nExclude, nOneTwo, nOneThree, nOneFour;
824 >    vector<int> fortranGlobalGroupMembership;
825      
596    nExclude = exclude_.getSize();
826      isError = 0;
827  
828      //globalGroupMembership_ is filled by SimCreator    
829      for (int i = 0; i < nGlobalAtoms_; i++) {
830 <        fortranGlobalGroupMembership.push_back(globalGroupMembership_[i] + 1);
830 >      fortranGlobalGroupMembership.push_back(globalGroupMembership_[i] + 1);
831      }
832  
833      //calculate mass ratio of cutoff group
834 <    std::vector<double> mfact;
834 >    vector<RealType> mfact;
835      SimInfo::MoleculeIterator mi;
836      Molecule* mol;
837      Molecule::CutoffGroupIterator ci;
838      CutoffGroup* cg;
839      Molecule::AtomIterator ai;
840      Atom* atom;
841 <    double totalMass;
841 >    RealType totalMass;
842  
843      //to avoid memory reallocation, reserve enough space for mfact
844      mfact.reserve(getNCutoffGroups());
845      
846      for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {        
847 <        for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) {
847 >      for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) {
848  
849 <            totalMass = cg->getMass();
850 <            for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) {
851 <                        mfact.push_back(atom->getMass()/totalMass);
852 <            }
853 <
854 <        }      
849 >        totalMass = cg->getMass();
850 >        for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) {
851 >          // Check for massless groups - set mfact to 1 if true
852 >          if (totalMass != 0)
853 >            mfact.push_back(atom->getMass()/totalMass);
854 >          else
855 >            mfact.push_back( 1.0 );
856 >        }
857 >      }      
858      }
859  
860 <    //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!)
629 <    std::vector<int> identArray;
860 >    // Build the identArray_
861  
862 <    //to avoid memory reallocation, reserve enough space identArray
863 <    identArray.reserve(getNAtoms());
633 <    
862 >    identArray_.clear();
863 >    identArray_.reserve(getNAtoms());    
864      for(mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {        
865 <        for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
866 <            identArray.push_back(atom->getIdent());
867 <        }
865 >      for(atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
866 >        identArray_.push_back(atom->getIdent());
867 >      }
868      }    
869  
870      //fill molMembershipArray
871      //molMembershipArray is filled by SimCreator    
872 <    std::vector<int> molMembershipArray(nGlobalAtoms_);
872 >    vector<int> molMembershipArray(nGlobalAtoms_);
873      for (int i = 0; i < nGlobalAtoms_; i++) {
874 <        molMembershipArray[i] = globalMolMembership_[i] + 1;
874 >      molMembershipArray[i] = globalMolMembership_[i] + 1;
875      }
876      
877      //setup fortran simulation
648    //gloalExcludes and molMembershipArray should go away (They are never used)
649    //why the hell fortran need to know molecule?
650    //OOPSE = Object-Obfuscated Parallel Simulation Engine
651    int nGlobalExcludes = 0;
652    int* globalExcludes = NULL;
653    int* excludeList = exclude_.getExcludeList();
654    setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray[0], &nExclude, excludeList ,
655                  &nGlobalExcludes, globalExcludes, &molMembershipArray[0],
656                  &mfact[0], &nCutoffGroups_, &fortranGlobalGroupMembership[0], &isError);
878  
879 <    if( isError ){
879 >    nExclude = excludedInteractions_.getSize();
880 >    nOneTwo = oneTwoInteractions_.getSize();
881 >    nOneThree = oneThreeInteractions_.getSize();
882 >    nOneFour = oneFourInteractions_.getSize();
883  
884 <        sprintf( painCave.errMsg,
885 <                 "There was an error setting the simulation information in fortran.\n" );
886 <        painCave.isFatal = 1;
887 <        painCave.severity = OOPSE_ERROR;
664 <        simError();
665 <    }
884 >    int* excludeList = excludedInteractions_.getPairList();
885 >    int* oneTwoList = oneTwoInteractions_.getPairList();
886 >    int* oneThreeList = oneThreeInteractions_.getPairList();
887 >    int* oneFourList = oneFourInteractions_.getPairList();
888  
889 < #ifdef IS_MPI
890 <    sprintf( checkPointMsg,
891 <       "succesfully sent the simulation information to fortran.\n");
892 <    MPIcheckPoint();
893 < #endif // is_mpi
894 < }
895 <
674 <
675 < #ifdef IS_MPI
676 < void SimInfo::setupFortranParallel() {
889 >    //setFortranSim( &fInfo_, &nGlobalAtoms_, &nAtoms_, &identArray_[0],
890 >    //               &nExclude, excludeList,
891 >    //               &nOneTwo, oneTwoList,
892 >    //               &nOneThree, oneThreeList,
893 >    //               &nOneFour, oneFourList,
894 >    //               &molMembershipArray[0], &mfact[0], &nCutoffGroups_,
895 >    //               &fortranGlobalGroupMembership[0], &isError);
896      
897 <    //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex
898 <    std::vector<int> localToGlobalAtomIndex(getNAtoms(), 0);
899 <    std::vector<int> localToGlobalCutoffGroupIndex;
900 <    SimInfo::MoleculeIterator mi;
901 <    Molecule::AtomIterator ai;
902 <    Molecule::CutoffGroupIterator ci;
903 <    Molecule* mol;
904 <    Atom* atom;
905 <    CutoffGroup* cg;
906 <    mpiSimData parallelData;
907 <    int isError;
897 >    // if( isError ){
898 >    //  
899 >    //  sprintf( painCave.errMsg,
900 >    //         "There was an error setting the simulation information in fortran.\n" );
901 >    //  painCave.isFatal = 1;
902 >    //  painCave.severity = OPENMD_ERROR;
903 >    //  simError();
904 >    //}
905 >    
906 >    
907 >    // sprintf( checkPointMsg,
908 >    //          "succesfully sent the simulation information to fortran.\n");
909 >    
910 >    // errorCheckPoint();
911 >    
912 >    // Setup number of neighbors in neighbor list if present
913 >    //if (simParams_->haveNeighborListNeighbors()) {
914 >    //  int nlistNeighbors = simParams_->getNeighborListNeighbors();
915 >    //  setNeighbors(&nlistNeighbors);
916 >    //}
917 >  
918 > #ifdef IS_MPI    
919 >    // mpiSimData parallelData;
920  
690    for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
691
692        //local index(index in DataStorge) of atom is important
693        for (atom = mol->beginAtom(ai); atom != NULL; atom = mol->nextAtom(ai)) {
694            localToGlobalAtomIndex[atom->getLocalIndex()] = atom->getGlobalIndex() + 1;
695        }
696
697        //local index of cutoff group is trivial, it only depends on the order of travesing
698        for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) {
699            localToGlobalCutoffGroupIndex.push_back(cg->getGlobalIndex() + 1);
700        }        
701        
702    }
703
921      //fill up mpiSimData struct
922 <    parallelData.nMolGlobal = getNGlobalMolecules();
923 <    parallelData.nMolLocal = getNMolecules();
924 <    parallelData.nAtomsGlobal = getNGlobalAtoms();
925 <    parallelData.nAtomsLocal = getNAtoms();
926 <    parallelData.nGroupsGlobal = getNGlobalCutoffGroups();
927 <    parallelData.nGroupsLocal = getNCutoffGroups();
928 <    parallelData.myNode = worldRank;
929 <    MPI_Comm_size(MPI_COMM_WORLD, &(parallelData.nProcessors));
922 >    // parallelData.nMolGlobal = getNGlobalMolecules();
923 >    // parallelData.nMolLocal = getNMolecules();
924 >    // parallelData.nAtomsGlobal = getNGlobalAtoms();
925 >    // parallelData.nAtomsLocal = getNAtoms();
926 >    // parallelData.nGroupsGlobal = getNGlobalCutoffGroups();
927 >    // parallelData.nGroupsLocal = getNCutoffGroups();
928 >    // parallelData.myNode = worldRank;
929 >    // MPI_Comm_size(MPI_COMM_WORLD, &(parallelData.nProcessors));
930  
931      //pass mpiSimData struct and index arrays to fortran
932 <    setFsimParallel(&parallelData, &(parallelData.nAtomsLocal),
933 <                    &localToGlobalAtomIndex[0],  &(parallelData.nGroupsLocal),
934 <                    &localToGlobalCutoffGroupIndex[0], &isError);
932 >    //setFsimParallel(&parallelData, &(parallelData.nAtomsLocal),
933 >    //                &localToGlobalAtomIndex[0],  &(parallelData.nGroupsLocal),
934 >    //                &localToGlobalCutoffGroupIndex[0], &isError);
935  
936 <    if (isError) {
937 <        sprintf(painCave.errMsg,
938 <                "mpiRefresh errror: fortran didn't like something we gave it.\n");
939 <        painCave.isFatal = 1;
940 <        simError();
941 <    }
936 >    // if (isError) {
937 >    //   sprintf(painCave.errMsg,
938 >    //           "mpiRefresh errror: fortran didn't like something we gave it.\n");
939 >    //   painCave.isFatal = 1;
940 >    //   simError();
941 >    // }
942  
943 <    sprintf(checkPointMsg, " mpiRefresh successful.\n");
944 <    MPIcheckPoint();
728 <
729 <
730 < }
731 <
943 >    // sprintf(checkPointMsg, " mpiRefresh successful.\n");
944 >    // errorCheckPoint();
945   #endif
946  
947 < double SimInfo::calcMaxCutoffRadius() {
947 >    // initFortranFF(&isError);
948 >    // if (isError) {
949 >    //   sprintf(painCave.errMsg,
950 >    //           "initFortranFF errror: fortran didn't like something we gave it.\n");
951 >    //   painCave.isFatal = 1;
952 >    //   simError();
953 >    // }
954 >    // fortranInitialized_ = true;
955 >  }
956  
957 +  void SimInfo::addProperty(GenericData* genData) {
958 +    properties_.addProperty(genData);  
959 +  }
960  
961 <    std::set<AtomType*> atomTypes;
962 <    std::set<AtomType*>::iterator i;
963 <    std::vector<double> cutoffRadius;
961 >  void SimInfo::removeProperty(const string& propName) {
962 >    properties_.removeProperty(propName);  
963 >  }
964  
965 <    //get the unique atom types
966 <    atomTypes = getUniqueAtomTypes();
965 >  void SimInfo::clearProperties() {
966 >    properties_.clearProperties();
967 >  }
968  
969 <    //query the max cutoff radius among these atom types
970 <    for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
971 <        cutoffRadius.push_back(forceField_->getRcutFromAtomType(*i));
972 <    }
969 >  vector<string> SimInfo::getPropertyNames() {
970 >    return properties_.getPropertyNames();  
971 >  }
972 >      
973 >  vector<GenericData*> SimInfo::getProperties() {
974 >    return properties_.getProperties();
975 >  }
976  
977 <    double maxCutoffRadius = *(std::max_element(cutoffRadius.begin(), cutoffRadius.end()));
978 < #ifdef IS_MPI
979 <    //pick the max cutoff radius among the processors
752 < #endif
977 >  GenericData* SimInfo::getPropertyByName(const string& propName) {
978 >    return properties_.getPropertyByName(propName);
979 >  }
980  
981 <    return maxCutoffRadius;
982 < }
983 <
984 < void SimInfo::getCutoff(double& rcut, double& rsw) {
985 <    
759 <    if (fInfo_.SIM_uses_Charges | fInfo_.SIM_uses_Dipoles | fInfo_.SIM_uses_RF) {
760 <        
761 <        if (!simParams_->haveRcut()){
762 <            sprintf(painCave.errMsg,
763 <                "SimCreator Warning: No value was set for the cutoffRadius.\n"
764 <                "\tOOPSE will use a default value of 15.0 angstroms"
765 <                "\tfor the cutoffRadius.\n");
766 <            painCave.isFatal = 0;
767 <            simError();
768 <            rcut = 15.0;
769 <        } else{
770 <            rcut = simParams_->getRcut();
771 <        }
772 <
773 <        if (!simParams_->haveRsw()){
774 <            sprintf(painCave.errMsg,
775 <                "SimCreator Warning: No value was set for switchingRadius.\n"
776 <                "\tOOPSE will use a default value of\n"
777 <                "\t0.95 * cutoffRadius for the switchingRadius\n");
778 <            painCave.isFatal = 0;
779 <            simError();
780 <            rsw = 0.95 * rcut;
781 <        } else{
782 <            rsw = simParams_->getRsw();
783 <        }
784 <
785 <    } else {
786 <        // if charge, dipole or reaction field is not used and the cutofff radius is not specified in
787 <        //meta-data file, the maximum cutoff radius calculated from forcefiled will be used
788 <        
789 <        if (simParams_->haveRcut()) {
790 <            rcut = simParams_->getRcut();
791 <        } else {
792 <            //set cutoff radius to the maximum cutoff radius based on atom types in the whole system
793 <            rcut = calcMaxCutoffRadius();
794 <        }
795 <
796 <        if (simParams_->haveRsw()) {
797 <            rsw  = simParams_->getRsw();
798 <        } else {
799 <            rsw = rcut;
800 <        }
801 <    
802 <    }
803 < }
804 <
805 < void SimInfo::setupCutoff() {
806 <    getCutoff(rcut_, rsw_);    
807 <    double rnblist = rcut_ + 1; // skin of neighbor list
808 <
809 <    //Pass these cutoff radius etc. to fortran. This function should be called once and only once
810 <    notifyFortranCutoffs(&rcut_, &rsw_, &rnblist);
811 < }
812 <
813 < void SimInfo::addProperty(GenericData* genData) {
814 <    properties_.addProperty(genData);  
815 < }
816 <
817 < void SimInfo::removeProperty(const std::string& propName) {
818 <    properties_.removeProperty(propName);  
819 < }
820 <
821 < void SimInfo::clearProperties() {
822 <    properties_.clearProperties();
823 < }
824 <
825 < std::vector<std::string> SimInfo::getPropertyNames() {
826 <    return properties_.getPropertyNames();  
827 < }
828 <      
829 < std::vector<GenericData*> SimInfo::getProperties() {
830 <    return properties_.getProperties();
831 < }
832 <
833 < GenericData* SimInfo::getPropertyByName(const std::string& propName) {
834 <    return properties_.getPropertyByName(propName);
835 < }
836 <
837 < void SimInfo::setSnapshotManager(SnapshotManager* sman) {
838 <    //if (sman_ == sman_) {
839 <    //    return;
840 <    //}
841 <    
842 <    //delete sman_;
981 >  void SimInfo::setSnapshotManager(SnapshotManager* sman) {
982 >    if (sman_ == sman) {
983 >      return;
984 >    }    
985 >    delete sman_;
986      sman_ = sman;
987  
988      Molecule* mol;
989      RigidBody* rb;
990      Atom* atom;
991 +    CutoffGroup* cg;
992      SimInfo::MoleculeIterator mi;
993      Molecule::RigidBodyIterator rbIter;
994 <    Molecule::AtomIterator atomIter;;
994 >    Molecule::AtomIterator atomIter;
995 >    Molecule::CutoffGroupIterator cgIter;
996  
997      for (mol = beginMolecule(mi); mol != NULL; mol = nextMolecule(mi)) {
998          
999 <        for (atom = mol->beginAtom(atomIter); atom != NULL; atom = mol->nextAtom(atomIter)) {
1000 <            atom->setSnapshotManager(sman_);
1001 <        }
999 >      for (atom = mol->beginAtom(atomIter); atom != NULL; atom = mol->nextAtom(atomIter)) {
1000 >        atom->setSnapshotManager(sman_);
1001 >      }
1002          
1003 <        for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
1004 <            rb->setSnapshotManager(sman_);
1005 <        }
1003 >      for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
1004 >        rb->setSnapshotManager(sman_);
1005 >      }
1006 >
1007 >      for (cg = mol->beginCutoffGroup(cgIter); cg != NULL; cg = mol->nextCutoffGroup(cgIter)) {
1008 >        cg->setSnapshotManager(sman_);
1009 >      }
1010      }    
1011      
1012 < }
1012 >  }
1013  
1014 < Vector3d SimInfo::getComVel(){
1014 >  Vector3d SimInfo::getComVel(){
1015      SimInfo::MoleculeIterator i;
1016      Molecule* mol;
1017  
1018      Vector3d comVel(0.0);
1019 <    double totalMass = 0.0;
1019 >    RealType totalMass = 0.0;
1020      
1021  
1022      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1023 <        double mass = mol->getMass();
1024 <        totalMass += mass;
1025 <        comVel += mass * mol->getComVel();
1023 >      RealType mass = mol->getMass();
1024 >      totalMass += mass;
1025 >      comVel += mass * mol->getComVel();
1026      }  
1027  
1028   #ifdef IS_MPI
1029 <    double tmpMass = totalMass;
1029 >    RealType tmpMass = totalMass;
1030      Vector3d tmpComVel(comVel);    
1031 <    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1032 <    MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1031 >    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1032 >    MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1033   #endif
1034  
1035      comVel /= totalMass;
1036  
1037      return comVel;
1038 < }
1038 >  }
1039  
1040 < Vector3d SimInfo::getCom(){
1040 >  Vector3d SimInfo::getCom(){
1041      SimInfo::MoleculeIterator i;
1042      Molecule* mol;
1043  
1044      Vector3d com(0.0);
1045 <    double totalMass = 0.0;
1045 >    RealType totalMass = 0.0;
1046      
1047      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1048 <        double mass = mol->getMass();
1049 <        totalMass += mass;
1050 <        com += mass * mol->getCom();
1048 >      RealType mass = mol->getMass();
1049 >      totalMass += mass;
1050 >      com += mass * mol->getCom();
1051      }  
1052  
1053   #ifdef IS_MPI
1054 <    double tmpMass = totalMass;
1054 >    RealType tmpMass = totalMass;
1055      Vector3d tmpCom(com);    
1056 <    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1057 <    MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1056 >    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1057 >    MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1058   #endif
1059  
1060      com /= totalMass;
1061  
1062      return com;
1063  
1064 < }        
1064 >  }        
1065  
1066 < std::ostream& operator <<(std::ostream& o, SimInfo& info) {
1066 >  ostream& operator <<(ostream& o, SimInfo& info) {
1067  
1068      return o;
1069 < }
1069 >  }
1070 >  
1071 >  
1072 >   /*
1073 >   Returns center of mass and center of mass velocity in one function call.
1074 >   */
1075 >  
1076 >   void SimInfo::getComAll(Vector3d &com, Vector3d &comVel){
1077 >      SimInfo::MoleculeIterator i;
1078 >      Molecule* mol;
1079 >      
1080 >    
1081 >      RealType totalMass = 0.0;
1082 >    
1083  
1084 < }//end namespace oopse
1084 >      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1085 >         RealType mass = mol->getMass();
1086 >         totalMass += mass;
1087 >         com += mass * mol->getCom();
1088 >         comVel += mass * mol->getComVel();          
1089 >      }  
1090 >      
1091 > #ifdef IS_MPI
1092 >      RealType tmpMass = totalMass;
1093 >      Vector3d tmpCom(com);  
1094 >      Vector3d tmpComVel(comVel);
1095 >      MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1096 >      MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1097 >      MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1098 > #endif
1099 >      
1100 >      com /= totalMass;
1101 >      comVel /= totalMass;
1102 >   }        
1103 >  
1104 >   /*
1105 >   Return intertia tensor for entire system and angular momentum Vector.
1106  
1107 +
1108 +       [  Ixx -Ixy  -Ixz ]
1109 +    J =| -Iyx  Iyy  -Iyz |
1110 +       [ -Izx -Iyz   Izz ]
1111 +    */
1112 +
1113 +   void SimInfo::getInertiaTensor(Mat3x3d &inertiaTensor, Vector3d &angularMomentum){
1114 +      
1115 +
1116 +      RealType xx = 0.0;
1117 +      RealType yy = 0.0;
1118 +      RealType zz = 0.0;
1119 +      RealType xy = 0.0;
1120 +      RealType xz = 0.0;
1121 +      RealType yz = 0.0;
1122 +      Vector3d com(0.0);
1123 +      Vector3d comVel(0.0);
1124 +      
1125 +      getComAll(com, comVel);
1126 +      
1127 +      SimInfo::MoleculeIterator i;
1128 +      Molecule* mol;
1129 +      
1130 +      Vector3d thisq(0.0);
1131 +      Vector3d thisv(0.0);
1132 +
1133 +      RealType thisMass = 0.0;
1134 +    
1135 +      
1136 +      
1137 +  
1138 +      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1139 +        
1140 +         thisq = mol->getCom()-com;
1141 +         thisv = mol->getComVel()-comVel;
1142 +         thisMass = mol->getMass();
1143 +         // Compute moment of intertia coefficients.
1144 +         xx += thisq[0]*thisq[0]*thisMass;
1145 +         yy += thisq[1]*thisq[1]*thisMass;
1146 +         zz += thisq[2]*thisq[2]*thisMass;
1147 +        
1148 +         // compute products of intertia
1149 +         xy += thisq[0]*thisq[1]*thisMass;
1150 +         xz += thisq[0]*thisq[2]*thisMass;
1151 +         yz += thisq[1]*thisq[2]*thisMass;
1152 +            
1153 +         angularMomentum += cross( thisq, thisv ) * thisMass;
1154 +            
1155 +      }  
1156 +      
1157 +      
1158 +      inertiaTensor(0,0) = yy + zz;
1159 +      inertiaTensor(0,1) = -xy;
1160 +      inertiaTensor(0,2) = -xz;
1161 +      inertiaTensor(1,0) = -xy;
1162 +      inertiaTensor(1,1) = xx + zz;
1163 +      inertiaTensor(1,2) = -yz;
1164 +      inertiaTensor(2,0) = -xz;
1165 +      inertiaTensor(2,1) = -yz;
1166 +      inertiaTensor(2,2) = xx + yy;
1167 +      
1168 + #ifdef IS_MPI
1169 +      Mat3x3d tmpI(inertiaTensor);
1170 +      Vector3d tmpAngMom;
1171 +      MPI_Allreduce(tmpI.getArrayPointer(), inertiaTensor.getArrayPointer(),9,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1172 +      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1173 + #endif
1174 +              
1175 +      return;
1176 +   }
1177 +
1178 +   //Returns the angular momentum of the system
1179 +   Vector3d SimInfo::getAngularMomentum(){
1180 +      
1181 +      Vector3d com(0.0);
1182 +      Vector3d comVel(0.0);
1183 +      Vector3d angularMomentum(0.0);
1184 +      
1185 +      getComAll(com,comVel);
1186 +      
1187 +      SimInfo::MoleculeIterator i;
1188 +      Molecule* mol;
1189 +      
1190 +      Vector3d thisr(0.0);
1191 +      Vector3d thisp(0.0);
1192 +      
1193 +      RealType thisMass;
1194 +      
1195 +      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {        
1196 +        thisMass = mol->getMass();
1197 +        thisr = mol->getCom()-com;
1198 +        thisp = (mol->getComVel()-comVel)*thisMass;
1199 +        
1200 +        angularMomentum += cross( thisr, thisp );
1201 +        
1202 +      }  
1203 +      
1204 + #ifdef IS_MPI
1205 +      Vector3d tmpAngMom;
1206 +      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1207 + #endif
1208 +      
1209 +      return angularMomentum;
1210 +   }
1211 +  
1212 +  StuntDouble* SimInfo::getIOIndexToIntegrableObject(int index) {
1213 +    return IOIndexToIntegrableObject.at(index);
1214 +  }
1215 +  
1216 +  void SimInfo::setIOIndexToIntegrableObject(const vector<StuntDouble*>& v) {
1217 +    IOIndexToIntegrableObject= v;
1218 +  }
1219 +
1220 +  /* Returns the Volume of the simulation based on a ellipsoid with semi-axes
1221 +     based on the radius of gyration V=4/3*Pi*R_1*R_2*R_3
1222 +     where R_i are related to the principle inertia moments R_i = sqrt(C*I_i/N), this reduces to
1223 +     V = 4/3*Pi*(C/N)^3/2*sqrt(det(I)). See S.E. Baltazar et. al. Comp. Mat. Sci. 37 (2006) 526-536.
1224 +  */
1225 +  void SimInfo::getGyrationalVolume(RealType &volume){
1226 +    Mat3x3d intTensor;
1227 +    RealType det;
1228 +    Vector3d dummyAngMom;
1229 +    RealType sysconstants;
1230 +    RealType geomCnst;
1231 +
1232 +    geomCnst = 3.0/2.0;
1233 +    /* Get the inertial tensor and angular momentum for free*/
1234 +    getInertiaTensor(intTensor,dummyAngMom);
1235 +    
1236 +    det = intTensor.determinant();
1237 +    sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1238 +    volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(det);
1239 +    return;
1240 +  }
1241 +
1242 +  void SimInfo::getGyrationalVolume(RealType &volume, RealType &detI){
1243 +    Mat3x3d intTensor;
1244 +    Vector3d dummyAngMom;
1245 +    RealType sysconstants;
1246 +    RealType geomCnst;
1247 +
1248 +    geomCnst = 3.0/2.0;
1249 +    /* Get the inertial tensor and angular momentum for free*/
1250 +    getInertiaTensor(intTensor,dummyAngMom);
1251 +    
1252 +    detI = intTensor.determinant();
1253 +    sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1254 +    volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(detI);
1255 +    return;
1256 +  }
1257 + /*
1258 +   void SimInfo::setStuntDoubleFromGlobalIndex(vector<StuntDouble*> v) {
1259 +      assert( v.size() == nAtoms_ + nRigidBodies_);
1260 +      sdByGlobalIndex_ = v;
1261 +    }
1262 +
1263 +    StuntDouble* SimInfo::getStuntDoubleFromGlobalIndex(int index) {
1264 +      //assert(index < nAtoms_ + nRigidBodies_);
1265 +      return sdByGlobalIndex_.at(index);
1266 +    }  
1267 + */  
1268 +  int SimInfo::getNGlobalConstraints() {
1269 +    int nGlobalConstraints;
1270 + #ifdef IS_MPI
1271 +    MPI_Allreduce(&nConstraints_, &nGlobalConstraints, 1, MPI_INT, MPI_SUM,
1272 +                  MPI_COMM_WORLD);    
1273 + #else
1274 +    nGlobalConstraints =  nConstraints_;
1275 + #endif
1276 +    return nGlobalConstraints;
1277 +  }
1278 +
1279 + }//end namespace OpenMD
1280 +

Comparing:
trunk/src/brains/SimInfo.cpp (property svn:keywords), Revision 334 by tim, Mon Feb 14 17:57:01 2005 UTC vs.
branches/development/src/brains/SimInfo.cpp (property svn:keywords), Revision 1550 by gezelter, Wed Apr 27 21:49:59 2011 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines