ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/brains/SimInfo.hpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/brains/SimInfo.hpp (file contents):
Revision 1772 by chrisfen, Tue Nov 23 22:48:31 2004 UTC vs.
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC

# Line 1 | Line 1
1 < #ifndef __SIMINFO_H__
2 < #define __SIMINFO_H__
1 > /*
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 > *
4 > * The University of Notre Dame grants you ("Licensee") a
5 > * non-exclusive, royalty free, license to use, modify and
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
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
40 > */
41 >
42 > /**
43 > * @file SimInfo.hpp
44 > * @author    tlin
45 > * @date  11/02/2004
46 > * @version 1.0
47 > */
48  
49 < #include <map>
50 < #include <string>
49 > #ifndef BRAINS_SIMMODEL_HPP
50 > #define BRAINS_SIMMODEL_HPP
51 >
52 > #include <iostream>
53 > #include <set>
54 > #include <utility>
55   #include <vector>
56  
8 – #include "primitives/Atom.hpp"
9 – #include "primitives/RigidBody.hpp"
10 – #include "primitives/Molecule.hpp"
57   #include "brains/Exclude.hpp"
58 < #include "brains/SkipList.hpp"
59 < #include "primitives/AbstractClasses.hpp"
60 < #include "types/MakeStamps.hpp"
61 < #include "brains/SimState.hpp"
62 < #include "restraints/Restraints.hpp"
58 > #include "io/Globals.hpp"
59 > #include "math/Vector3.hpp"
60 > #include "types/MoleculeStamp.hpp"
61 > #include "UseTheForce/ForceField.hpp"
62 > #include "utils/PropertyMap.hpp"
63 > #include "utils/LocalIndexManager.hpp"
64  
65 + //another nonsense macro declaration
66   #define __C
67   #include "brains/fSimulation.h"
20 – #include "utils/GenericData.hpp"
68  
69 + namespace oopse{
70  
71 < //#include "Minimizer.hpp"
72 < //#include "minimizers/OOPSEMinimizer.hpp"
71 > //forward decalration
72 > class SnapshotManager;
73 > class Molecule;
74  
75 + /**
76 + * @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
77 + * @brief As one of the heavy weight class of OOPSE, SimInfo
78 + * One of the major changes in SimInfo class is the data struct. It only maintains a list of molecules.
79 + * And the Molecule class will maintain all of the concrete objects (atoms, bond, bend, torsions, rigid bodies,
80 + * cutoff groups, constrains).
81 + * Another major change is the index. No matter single version or parallel version,  atoms and
82 + * rigid bodies have both global index and local index. Local index is not important to molecule as well as
83 + * cutoff group.
84 + */
85 + class SimInfo {
86 +    public:
87 +        typedef std::map<int, Molecule*>::iterator  MoleculeIterator;
88  
89 < double roundMe( double x );
90 < class OOPSEMinimizer;
91 < class SimInfo{
89 >        /**
90 >         * Constructor of SimInfo
91 >         * @param molStampPairs MoleculeStamp Array. The first element of the pair is molecule stamp, the
92 >         * second element is the total number of molecules with the same molecule stamp in the system
93 >         * @param ff pointer of a concrete ForceField instance
94 >         * @param simParams
95 >         * @note
96 >         */
97 >        SimInfo(std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* simParams);
98 >        virtual ~SimInfo();
99  
100 < public:
100 >        /**
101 >         * Adds a molecule
102 >         * @return return true if adding successfully, return false if the molecule is already in SimInfo
103 >         * @param mol molecule to be added
104 >         */
105 >        bool addMolecule(Molecule* mol);
106  
107 <  SimInfo();
108 <  ~SimInfo();
107 >        /**
108 >         * Removes a molecule from SimInfo
109 >         * @return true if removing successfully, return false if molecule is not in this SimInfo
110 >         */
111 >        bool removeMolecule(Molecule* mol);
112  
113 <  int n_atoms; // the number of atoms
114 <  Atom **atoms; // the array of atom objects
113 >        /** Returns the total number of molecules in the system. */
114 >        int getNGlobalMolecules() {
115 >            return nGlobalMols_;
116 >        }
117  
118 <  vector<RigidBody*> rigidBodies;  // A vector of rigid bodies
119 <  vector<StuntDouble*> integrableObjects;
120 <  
121 <  double tau[9]; // the stress tensor
118 >        /** Returns the total number of atoms in the system. */
119 >        int getNGlobalAtoms() {
120 >            return nGlobalAtoms_;
121 >        }
122  
123 <  int n_bonds;    // number of bends
124 <  int n_bends;    // number of bends
125 <  int n_torsions; // number of torsions
126 <  int n_oriented; // number of of atoms with orientation
48 <  int ndf;        // number of actual degrees of freedom
49 <  int ndfRaw;     // number of settable degrees of freedom
50 <  int ndfTrans;   // number of translational degrees of freedom
51 <  int nZconstraints; // the number of zConstraints
123 >        /** Returns the total number of cutoff groups in the system. */
124 >        int getNGlobalCutoffGroups() {
125 >            return nGlobalCutoffGroups_;
126 >        }
127  
128 <  int setTemp;   // boolean to set the temperature at each sampleTime
129 <  int resetIntegrator; // boolean to reset the integrator
128 >        /**
129 >         * Returns the total number of integrable objects (total number of rigid bodies plus the total number
130 >         * of atoms which do not belong to the rigid bodies) in the system
131 >         */
132 >        int getNGlobalIntegrableObjects() {
133 >            return nGlobalIntegrableObjects_;
134 >        }
135  
136 <  int n_dipoles; // number of dipoles
136 >        /**
137 >         * Returns the total number of integrable objects (total number of rigid bodies plus the total number
138 >         * of atoms which do not belong to the rigid bodies) in the system
139 >         */
140 >        int getNGlobalRigidBodies() {
141 >            return nGlobalRigidBodies_;
142 >        }
143  
144 <  int n_exclude;
145 <  Exclude* excludes;  // the exclude list for ignoring pairs in fortran
146 <  int nGlobalExcludes;
147 <  int* globalExcludes; // same as above, but these guys participate in
148 <                       // no long range forces.
144 >        int getNGlobalConstraints();
145 >        /**
146 >         * Returns the number of local molecules.
147 >         * @return the number of local molecules
148 >         */
149 >        int getNMolecules() {
150 >            return molecules_.size();
151 >        }
152  
153 <  int* identArray;     // array of unique identifiers for the atoms
154 <  int* molMembershipArray;  // map of atom numbers onto molecule numbers
153 >        /** Returns the number of local atoms */
154 >        unsigned int getNAtoms() {
155 >            return nAtoms_;
156 >        }
157  
158 <  int n_constraints; // the number of constraints on the system
158 >        /** Returns the number of local bonds */        
159 >        unsigned int getNBonds(){
160 >            return nBonds_;
161 >        }
162  
163 <  int n_SRI;   // the number of short range interactions
163 >        /** Returns the number of local bends */        
164 >        unsigned int getNBends() {
165 >            return nBends_;
166 >        }
167  
168 <  double lrPot; // the potential energy from the long range calculations.
168 >        /** Returns the number of local torsions */        
169 >        unsigned int getNTorsions() {
170 >            return nTorsions_;
171 >        }
172  
173 <  double Hmat[3][3];  // the periodic boundry conditions. The Hmat is the
174 <                      // column vectors of the x, y, and z box vectors.
175 <                      //   h1  h2  h3
176 <                      // [ Xx  Yx  Zx ]
77 <                      // [ Xy  Yy  Zy ]
78 <                      // [ Xz  Yz  Zz ]
79 <                      //  
80 <  double HmatInv[3][3];
173 >        /** Returns the number of local rigid bodies */        
174 >        unsigned int getNRigidBodies() {
175 >            return nRigidBodies_;
176 >        }
177  
178 <  double boxL[3]; // The Lengths of the 3 column vectors of Hmat
179 <  double boxVol;
180 <  int orthoRhombic;
181 <  
178 >        /** Returns the number of local integrable objects */
179 >        unsigned int getNIntegrableObjects() {
180 >            return nIntegrableObjects_;
181 >        }
182  
183 <  double dielectric;      // the dielectric of the medium for reaction field
183 >        /** Returns the number of local cutoff groups */
184 >        unsigned int getNCutoffGroups() {
185 >            return nCutoffGroups_;
186 >        }
187  
188 <  
189 <  int usePBC; // whether we use periodic boundry conditions.
190 <  int useDirectionalAtoms;
191 <  int useLennardJones;
192 <  int useElectrostatics;
193 <  int useCharges;
194 <  int useDipoles;
195 <  int useSticky;
196 <  int useGayBerne;
197 <  int useEAM;
198 <  int useShapes;
100 <  int useFLARB;
101 <  int useReactionField;
102 <  bool haveCutoffGroups;
103 <  bool useInitXSstate;
104 <  double orthoTolerance;
188 >        /** Returns the total number of constraints in this SimInfo */
189 >        unsigned int getNConstraints() {
190 >            return nConstraints_;
191 >        }
192 >        
193 >        /**
194 >         * Returns the first molecule in this SimInfo and intialize the iterator.
195 >         * @return the first molecule, return NULL if there is not molecule in this SimInfo
196 >         * @param i the iterator of molecule array (user shouldn't change it)
197 >         */
198 >        Molecule* beginMolecule(MoleculeIterator& i);
199  
200 <  double dt, run_time;           // the time step and total time
201 <  double sampleTime, statusTime; // the position and energy dump frequencies
202 <  double target_temp;            // the target temperature of the system
203 <  double thermalTime;            // the temp kick interval
204 <  double currentTime;            // Used primarily for correlation Functions
205 <  double resetTime;              // Use to reset the integrator periodically
112 <  short int have_target_temp;
200 >        /**
201 >          * Returns the next avaliable Molecule based on the iterator.
202 >          * @return the next avaliable molecule, return NULL if reaching the end of the array
203 >          * @param i the iterator of molecule array
204 >          */
205 >        Molecule* nextMolecule(MoleculeIterator& i);
206  
207 <  int n_mol;           // n_molecules;
208 <  Molecule* molecules; // the array of molecules
209 <  
210 <  int nComponents;           // the number of components in the system
118 <  int* componentsNmol;       // the number of molecules of each component
119 <  MoleculeStamp** compStamps;// the stamps matching the components
120 <  LinkedMolStamp* headStamp; // list of stamps used in the simulation
121 <  
122 <  
123 <  char ensemble[100]; // the enesemble of the simulation (NVT, NVE, etc. )
124 <  char mixingRule[100]; // the mixing rules for Lennard jones/van der walls
125 <  BaseIntegrator *the_integrator; // the integrator of the simulation
207 >        /** Returns the number of degrees of freedom */
208 >        int getNdf() {
209 >            return ndf_;
210 >        }
211  
212 <  OOPSEMinimizer* the_minimizer; // the energy minimizer
213 <  Restraints* restraint;
214 <  bool has_minimizer;
212 >        /** Returns the number of raw degrees of freedom */
213 >        int getNdfRaw() {
214 >            return ndfRaw_;
215 >        }
216  
217 <  string finalName;  // the name of the eor file to be written
218 <  string sampleName; // the name of the dump file to be written
219 <  string statusName; // the name of the stat file to be written
220 <  string zAngleName; // the name of the ang file to be written
217 >        /** Returns the number of translational degrees of freedom */
218 >        int getNdfTrans() {
219 >            return ndfTrans_;
220 >        }
221  
222 <  int seed;                    //seed for random number generator
222 >        //getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
223 >        
224 >        /** Returns the total number of z-constraint molecules in the system */
225 >        int getNZconstraint() {
226 >            return nZconstraint_;
227 >        }
228  
229 <  int useSolidThermInt;  // is solid-state thermodynamic integration being used
230 <  int useLiquidThermInt; // is liquid thermodynamic integration being used
231 <  double thermIntLambda; // lambda for TI
232 <  double thermIntK;      // power of lambda for TI
233 <  double vRaw;           // unperturbed potential for TI
234 <  double vHarm;          // harmonic potential for TI
235 <  int i;                 // just an int
229 >        /**
230 >         * Sets the number of z-constraint molecules in the system.
231 >         */
232 >        void setNZconstraint(int nZconstraint) {
233 >            nZconstraint_ = nZconstraint;
234 >        }
235 >        
236 >        /** Returns the snapshot manager. */
237 >        SnapshotManager* getSnapshotManager() {
238 >            return sman_;
239 >        }
240  
241 <  vector<double> mfact;
242 <  vector<int> FglobalGroupMembership;
243 <  int ngroup;
244 <  int* globalGroupMembership;
241 >        /** Sets the snapshot manager. */
242 >        void setSnapshotManager(SnapshotManager* sman);
243 >        
244 >        /** Returns the force field */
245 >        ForceField* getForceField() {
246 >            return forceField_;
247 >        }
248  
249 <  // refreshes the sim if things get changed (load balanceing, volume
250 <  // adjustment, etc.)
249 >        Globals* getSimParams() {
250 >            return simParams_;
251 >        }
252  
253 <  void refreshSim( void );
254 <  
253 >        /** Returns the velocity of center of mass of the whole system.*/
254 >        Vector3d getComVel();
255  
256 <  // sets the internal function pointer to fortran.
256 >        /** Returns the center of the mass of the whole system.*/
257 >        Vector3d getCom();
258  
259 +        /** Returns the seed (used for random number generator) */
260 +        int getSeed() {
261 +            return seed_;
262 +        }
263  
264 <  int getNDF();
265 <  int getNDFraw();
266 <  int getNDFtranslational();
267 <  int getTotIntegrableObjects();
164 <  void setBox( double newBox[3] );
165 <  void setBoxM( double newBox[3][3] );
166 <  void getBoxM( double theBox[3][3] );
167 <  void scaleBox( double scale );
168 <  
169 <  void setDefaultRcut( double theRcut );
170 <  void setDefaultRcut( double theRcut, double theRsw );
171 <  void checkCutOffs( void );
264 >        /** Sets the seed*/
265 >        void setSeed(int seed) {
266 >            seed_ = seed;
267 >        }
268  
269 <  double getRcut( void )  { return rCut; }
270 <  double getRlist( void ) { return rList; }
175 <  double getRsw( void )   { return rSw; }
176 <  double getMaxCutoff( void ) { return maxCutoff; }
177 <  
178 <  void setTime( double theTime ) { currentTime = theTime; }
179 <  void incrTime( double the_dt ) { currentTime += the_dt; }
180 <  void decrTime( double the_dt ) { currentTime -= the_dt; }
181 <  double getTime( void ) { return currentTime; }
269 >        /** main driver function to interact with fortran during the initialization and molecule migration */
270 >        void update();
271  
272 <  void wrapVector( double thePos[3] );
272 >        /** Returns the local index manager */
273 >        LocalIndexManager* getLocalIndexManager() {
274 >            return &localIndexMan_;
275 >        }
276  
277 <  SimState* getConfiguration( void ) { return myConfiguration; }
278 <  
279 <  void addProperty(GenericData* prop);
280 <  GenericData* getProperty(const string& propName);
189 <  //vector<GenericData*>& getProperties()  {return properties;}    
277 >        int getMoleculeStampId(int globalIndex) {
278 >            //assert(globalIndex < molStampIds_.size())
279 >            return molStampIds_[globalIndex];
280 >        }
281  
282 <  int getSeed(void) {  return seed; }
283 <  void setSeed(int theSeed) {  seed = theSeed;}
282 >        /** Returns the molecule stamp */
283 >        MoleculeStamp* getMoleculeStamp(int id) {
284 >            return moleculeStamps_[id];
285 >        }
286  
287 < private:
287 >        /** Return the total number of the molecule stamps */
288 >        int getNMoleculeStamp() {
289 >            return moleculeStamps_.size();
290 >        }
291 >        /**
292 >         * Finds a molecule with a specified global index
293 >         * @return a pointer point to found molecule
294 >         * @param index
295 >         */
296 >        Molecule* getMoleculeByGlobalIndex(int index) {
297 >            MoleculeIterator i;
298 >            i = molecules_.find(index);
299  
300 <  SimState* myConfiguration;
300 >            return i != molecules_.end() ? i->second : NULL;
301 >        }
302  
303 <  int boxIsInit, haveRcut, haveRsw;
303 >        /** Calculate the maximum cutoff radius based on the atom types */
304 >        double calcMaxCutoffRadius();
305  
306 <  double rList, rCut; // variables for the neighborlist
307 <  double rSw;         // the switching radius
306 >        double getRcut() {
307 >            return rcut_;
308 >        }
309  
310 <  double maxCutoff;
310 >        double getRsw() {
311 >            return rsw_;
312 >        }
313 >        
314 >        std::string getFinalConfigFileName() {
315 >            return finalConfigFileName_;
316 >        }
317 >        
318 >        void setFinalConfigFileName(const std::string& fileName) {
319 >            finalConfigFileName_ = fileName;
320 >        }
321  
322 <  double distXY;
323 <  double distYZ;
324 <  double distZX;
325 <  
326 <  void calcHmatInv( void );
327 <  void calcBoxL();
328 <  double calcMaxCutOff();
322 >        std::string getDumpFileName() {
323 >            return dumpFileName_;
324 >        }
325 >        
326 >        void setDumpFileName(const std::string& fileName) {
327 >            dumpFileName_ = fileName;
328 >        }
329  
330 <  
331 <  //Addtional Properties of SimInfo
332 <  map<string, GenericData*> properties;
333 <  void getFortranGroupArrays(SimInfo* info,
334 <                             vector<int>& FglobalGroupMembership,
335 <                             vector<double>& mfact);
330 >        std::string getStatFileName() {
331 >            return statFileName_;
332 >        }
333 >        
334 >        void setStatFileName(const std::string& fileName) {
335 >            statFileName_ = fileName;
336 >        }
337  
338 +        /**
339 +         * Sets GlobalGroupMembership
340 +         * @see #SimCreator::setGlobalIndex
341 +         */  
342 +        void setGlobalGroupMembership(const std::vector<int>& globalGroupMembership) {
343 +            assert(globalGroupMembership.size() == nGlobalAtoms_);
344 +            globalGroupMembership_ = globalGroupMembership;
345 +        }
346  
347 < };
347 >        /**
348 >         * Sets GlobalMolMembership
349 >         * @see #SimCreator::setGlobalIndex
350 >         */        
351 >        void setGlobalMolMembership(const std::vector<int>& globalMolMembership) {
352 >            assert(globalMolMembership.size() == nGlobalAtoms_);
353 >            globalMolMembership_ = globalMolMembership;
354 >        }
355  
356  
357 +        bool isFortranInitialized() {
358 +            return fortranInitialized_;
359 +        }
360 +        
361 +        //below functions are just forward functions
362 +        //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
363 +        //the other hand, has-a relation need composing.
364 +        /**
365 +         * Adds property into property map
366 +         * @param genData GenericData to be added into PropertyMap
367 +         */
368 +        void addProperty(GenericData* genData);
369 +
370 +        /**
371 +         * Removes property from PropertyMap by name
372 +         * @param propName the name of property to be removed
373 +         */
374 +        void removeProperty(const std::string& propName);
375 +
376 +        /**
377 +         * clear all of the properties
378 +         */
379 +        void clearProperties();
380 +
381 +        /**
382 +         * Returns all names of properties
383 +         * @return all names of properties
384 +         */
385 +        std::vector<std::string> getPropertyNames();
386 +
387 +        /**
388 +         * Returns all of the properties in PropertyMap
389 +         * @return all of the properties in PropertyMap
390 +         */      
391 +        std::vector<GenericData*> getProperties();
392 +
393 +        /**
394 +         * Returns property
395 +         * @param propName name of property
396 +         * @return a pointer point to property with propName. If no property named propName
397 +         * exists, return NULL
398 +         */      
399 +        GenericData* getPropertyByName(const std::string& propName);
400 +
401 +        /**
402 +         * add all exclude pairs of a molecule into exclude list.
403 +         */
404 +        void addExcludePairs(Molecule* mol);
405 +
406 +        /**
407 +         * remove all exclude pairs which belong to a molecule from exclude list
408 +         */
409 +
410 +        void removeExcludePairs(Molecule* mol);
411 +                
412 +        friend std::ostream& operator <<(std::ostream& o, SimInfo& info);
413 +        
414 +    private:
415 +
416 +        
417 +        /** Returns the unique atom types of local processor in an array */
418 +        std::set<AtomType*> getUniqueAtomTypes();
419 +
420 +        /** fill up the simtype struct*/
421 +        void setupSimType();
422 +
423 +        /**
424 +         * Setup Fortran Simulation
425 +         * @see #setupFortranParallel
426 +         */
427 +        void setupFortranSim();
428 +
429 +        /** Figure out the radius of cutoff, radius of switching function and pass them to fortran */
430 +        void setupCutoff();
431 +
432 +        /** Calculates the number of degress of freedom in the whole system */
433 +        void calcNdf();
434 +        void calcNdfRaw();
435 +        void calcNdfTrans();
436 +
437 +        /**
438 +         * Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
439 +         * system.
440 +         */
441 +        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
442 +
443 +        ForceField* forceField_;      
444 +        Globals* simParams_;
445 +
446 +        std::map<int, Molecule*>  molecules_; /**< Molecule array */
447 +        
448 +        //degress of freedom
449 +        int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
450 +        int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
451 +        int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
452 +        int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
453 +        
454 +        //number of global objects
455 +        int nGlobalMols_;       /**< number of molecules in the system */
456 +        int nGlobalAtoms_;   /**< number of atoms in the system */
457 +        int nGlobalCutoffGroups_; /**< number of cutoff groups in this system */
458 +        int nGlobalIntegrableObjects_; /**< number of integrable objects in this system */
459 +        int nGlobalRigidBodies_; /**< number of rigid bodies in this system */
460 +        /**
461 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
462 +         * corresponding content is the global index of cutoff group this atom belong to.
463 +         * It is filled by SimCreator once and only once, since it never changed during the simulation.
464 +         */
465 +        std::vector<int> globalGroupMembership_;
466 +
467 +        /**
468 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
469 +         * corresponding content is the global index of molecule this atom belong to.
470 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
471 +         */
472 +        std::vector<int> globalMolMembership_;        
473 +
474 +        
475 +        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
476 +        std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */        
477 +        
478 +        //number of local objects
479 +        int nAtoms_;                        /**< number of atoms in local processor */
480 +        int nBonds_;                        /**< number of bonds in local processor */
481 +        int nBends_;                        /**< number of bends in local processor */
482 +        int nTorsions_;                    /**< number of torsions in local processor */
483 +        int nRigidBodies_;              /**< number of rigid bodies in local processor */
484 +        int nIntegrableObjects_;    /**< number of integrable objects in local processor */
485 +        int nCutoffGroups_;             /**< number of cutoff groups in local processor */
486 +        int nConstraints_;              /**< number of constraints in local processors */
487 +
488 +        simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
489 +        Exclude exclude_;      
490 +        PropertyMap properties_;                  /**< Generic Property */
491 +        SnapshotManager* sman_;               /**< SnapshotManager */
492 +
493 +        int seed_; /**< seed for random number generator */
494 +
495 +        /**
496 +         * The reason to have a local index manager is that when molecule is migrating to other processors,
497 +         * the atoms and the rigid-bodies will release their local indices to LocalIndexManager. Combining the
498 +         * information of molecule migrating to current processor, Migrator class can query  the LocalIndexManager
499 +         * to make a efficient data moving plan.
500 +         */        
501 +        LocalIndexManager localIndexMan_;
502 +
503 +        //file names
504 +        std::string finalConfigFileName_;
505 +        std::string dumpFileName_;
506 +        std::string statFileName_;
507 +
508 +        double rcut_;       /**< cutoff radius*/
509 +        double rsw_;        /**< radius of switching function*/
510 +
511 +        bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
512 +        
513 + #ifdef IS_MPI
514 +    //in Parallel version, we need MolToProc
515 +    public:
516 +                
517 +        /**
518 +         * Finds the processor where a molecule resides
519 +         * @return the id of the processor which contains the molecule
520 +         * @param globalIndex global Index of the molecule
521 +         */
522 +        int getMolToProc(int globalIndex) {
523 +            //assert(globalIndex < molToProcMap_.size());
524 +            return molToProcMap_[globalIndex];
525 +        }
526 +
527 +        /**
528 +         * Set MolToProcMap array
529 +         * @see #SimCreator::divideMolecules
530 +         */
531 +        void setMolToProcMap(const std::vector<int>& molToProcMap) {
532 +            molToProcMap_ = molToProcMap;
533 +        }
534 +        
535 +    private:
536 +
537 +        void setupFortranParallel();
538 +        
539 +        /**
540 +         * The size of molToProcMap_ is equal to total number of molecules in the system.
541 +         *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
542 +         * once.
543 +         */        
544 +        std::vector<int> molToProcMap_;
545   #endif
546 +
547 + };
548 +
549 + } //namespace oopse
550 + #endif //BRAINS_SIMMODEL_HPP
551 +

Diff Legend

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