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

Comparing branches/new_design/OOPSE-3.0/src/brains/SimInfo.hpp (file contents):
Revision 1712 by tim, Thu Nov 4 20:55:01 2004 UTC vs.
Revision 1738 by tim, Sat Nov 13 05:08:12 2004 UTC

# Line 32 | Line 32
32  
33   #ifndef BRAINS_SIMMODEL_HPP
34   #define BRAINS_SIMMODEL_HPP
35 < #include <vector>
35 >
36   #include <iostream>
37 + #include <vector>
38 + #include <utility>
39  
40   #include "brains/fSimulation.h"
41   #include "primitives/Molecule.hpp"
42 + #include "types/MoleculeStamp.hpp"
43   #include "utils/PropertyMap.hpp"
44 + #include "io/Globals.hpp"
45  
46   namespace oopse{
47  
48   /**
49   * @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
50 < * @brief
50 > * @brief As one of the heavy weight class of OOPSE, SimInfo
51 > * One of the major changes in SimInfo class is the data struct. It only maintains a list of molecules.
52 > * And the Molecule class will maintain all of the concrete objects (atoms, bond, bend, torsions, rigid bodies,
53 > * cutoff groups, constrains).
54 > * Another major change is the index. No matter single version or parallel version,  atoms and
55 > * rigid bodies have both global index and local index. Local index is not important to molecule as well as
56 > * cutoff group.
57   */
58   class SimInfo {
59      public:
60 <        SimInfo();
60 >        typedef std::map<int, Molecule*>::iterator  MoleculeIterator;
61 >
62 >        /**
63 >         * Constructor of SimInfo
64 >         * @param molStampPairs MoleculeStamp Array. The first element of the pair is molecule stamp, the
65 >         * second element is the total number of molecules with the same molecule stamp in the system
66 >         * @param ff pointer of a concrete ForceField instance
67 >         * @param globals
68 >         * @note
69 >         */
70 >        SimInfo(const std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* globals);
71          virtual ~SimInfo();
72  
73          /**
# Line 63 | Line 83 | class SimInfo {
83           */
84          bool removeMolecule(Molecule* mol);
85  
86 +        /** Returns the total number of molecules in the system. */
87 +        int getNGlobalMolecules() {
88 +            return nGlobalMols_;
89 +        }
90 +
91 +        /** Returns the total number of atoms in the system. */
92 +        int getNGlobalAtoms() {
93 +            return nGlobalAtoms_;
94 +        }
95 +
96 +        /** Returns the total number of cutoff groups in the system. */
97 +        int getNGlobalCutoffGroups() {
98 +            return nGlobalCutoffGroups_;
99 +        }
100 +        
101          /**
102 <         * Returns the number of molecules.
103 <         * @return the number of molecules in this SimInfo
102 >         * Returns the number of local molecules.
103 >         * @return the number of local molecules
104           */
105          int getNMolecules() {
106              return molecules_.size();
107          }
108  
109 <        /** Returns the total number of atoms in this SimInfo */
109 >        /** Returns the number of local atoms */
110          unsigned int getNAtoms() {
111              return nAtoms_;
112          }
113  
114 <        /** Returns the total number of bonds in this SimInfo */        
114 >        /** Returns the number of local bonds */        
115          unsigned int getNBonds(){
116              return nBonds_;
117          }
118  
119 <        /** Returns the total number of bends in this SimInfo */        
119 >        /** Returns the number of local bends */        
120          unsigned int getNBends() {
121              return nBends_;
122          }
123  
124 <        /** Returns the total number of torsions in this SimInfo */        
124 >        /** Returns the number of local torsions */        
125          unsigned int getNTorsions() {
126              return nTorsions_;
127          }
128  
129 <        /** Returns the total number of rigid bodies in this SimInfo */        
129 >        /** Returns the number of local rigid bodies */        
130          unsigned int getNRigidBodies() {
131              return nRigidBodies_;
132          }
133  
134 <        /** Returns the total number of integrable objects in this SimInfo */
134 >        /** Returns the number of local integrable objects */
135          unsigned int getNIntegrableObjects() {
136              return nIntegrableObjects_;
137          }
138  
139 <        /** Returns the total number of cutoff groups in this SimInfo */
139 >        /** Returns the number of local cutoff groups */
140          unsigned int getNCutoffGroups() {
141              return nCutoffGroups_;
142          }
# Line 116 | Line 151 | class SimInfo {
151           * @return the first molecule, return NULL if there is not molecule in this SimInfo
152           * @param i the iterator of molecule array (user shouldn't change it)
153           */
154 <        Molecule* beginMolecule(std::vector<Molecule*>::iterator& i);
154 >        Molecule* beginMolecule(MoleculeIterator& i);
155  
156          /**
157            * Returns the next avaliable Molecule based on the iterator.
158            * @return the next avaliable molecule, return NULL if reaching the end of the array
159            * @param i the iterator of molecule array
160            */
161 <        Molecule* nextMolecule(std::vector<Molecule*>::iterator& i);
161 >        Molecule* nextMolecule(MoleculeIterator& i);
162  
163          /** Returns the number of degrees of freedom */
164 <        int getNDF() {
164 >        int getNdf() {
165              return ndf_;
166          }
167  
168          /** Returns the number of raw degrees of freedom */
169 <        int getNDFRaw() {
169 >        int getNdfRaw() {
170              return ndfRaw_;
171          }
172  
173          /** Returns the number of translational degrees of freedom */
174 <        int getNDFTrans() {
174 >        int getNdfTrans() {
175              return ndfTrans_;
176          }
177  
178 +        //getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
179 +        
180 +        /** Returns the total number of z-constraint molecules in the system */
181 +        int getNZconstraint() {
182 +            return nZconstraint_;
183 +        }
184 +
185 +        /**
186 +         * Sets the number of z-constraint molecules in the system.
187 +         */
188 +        int setNZconstraint(int nZconstraint) {
189 +            nZconstraint_ = nZconstraint;
190 +        }
191 +        
192          /** Returns the snapshot manager. */
193          SnapshotManager* getSnapshotManager() {
194              return sman_;
# Line 150 | Line 199 | class SimInfo {
199              sman_ = sman;
200          }
201  
202 +        /** Returns the force field */
203          ForceField* getForceField() {
204              return forceField_;
205          }
206 +
207 +        Globals* getGlobals() {
208 +            return globals_;
209 +        }
210 +
211 +        /** Returns the velocity of center of mass of the whole system.*/
212 +        Vector3d getComVel();
213 +
214 +        /** Returns the center of the mass of the whole system.*/
215 +        Vector3d getCom();
216 +
217 +        /** Returns the seed (used for random number generator) */
218 +        int getSeed() {
219 +            return seed_;
220 +        }
221 +
222 +        /** Sets the seed*/
223 +        void setSeed(int seed) {
224 +            seed_ = seed;
225 +        }
226 +
227 +        /** main driver function to interact with fortran during the initialization and molecule migration */
228 +        void update();
229 +
230 +        /** Returns the local index manager */
231 +        LocalIndexManager* getLocalIndexManager() {
232 +            return &localIndexMan_;
233 +        }
234 +
235 +        int getMoleculeStampId(int globalIndex) {
236 +            //assert(globalIndex < molStampIds_.size())
237 +            return molStampIds_[globalIndex];
238 +        }
239 +
240 +        /** Returns the molecule stamp */
241 +        MoleculeStamp* getMoleculeStamp(int id) {
242 +            return moleculeStamps_[id];
243 +        }
244          
245 <        void setForceField(ForceField* ff) {
246 <            forceField_ = ff;
245 >        /**
246 >         * Finds a molecule with a specified global index
247 >         * @return a pointer point to found molecule
248 >         * @param index
249 >         */
250 >        Molecule* getMoleculeByGlobalIndex(int index) {
251 >            std::map<int, Molecule*> i;
252 >            i = molecules_.find(index);
253 >
254 >            return i != molecules_.end() ? i->second : NULL;
255          }
160 –    private:
256  
257 <        void calcNDF();
258 <        void calcNDFRaw();
164 <        void calcNDFTrans();
257 >        /** Calculate the maximum cutoff radius based on the atom types */
258 >        double calcMaxCutoffRadius();
259  
260 <        int ndf_;
261 <        int ndfRaw_;
262 <        int ndfTrans_;
260 >        double getRcut() {
261 >            return rcut_;
262 >        }
263 >
264 >        double getRsw() {
265 >            return rsw_;
266 >        }
267          
268 <        int nAtoms_;
269 <        int nBonds_;
270 <        int nBends_;
271 <        int nTorsions_;
272 <        int nRigidBodies_;
273 <        int nIntegrableObjects_;
274 <        int nCutoffGroups_;
177 <        int nConstraints_;
268 >        std::string getFinalConfigFileName() {
269 >            return finalConfigFileName_;
270 >        }
271 >        
272 >        void setFinalConfigFileName(const std::string& fileName) {
273 >            finalConfigFileName_ = fileName;
274 >        }
275  
276 <        simtype fInfo;
277 <        Exclude excludeList;
278 <        ForceField* forceField_;
276 >        std::string getDumpFileName() {
277 >            return dumpFileName_;
278 >        }
279          
280 <        std::vector<Molecule*> molecules_; /**< Molecule array */
281 <        PropertyMap properties_;                  /** Generic Property */
282 <        SnapshotManager* sman_;               /** SnapshotManager */
280 >        void setDumpFileName(const std::string& fileName) {
281 >            dumpFileName_ = fileName;
282 >        }
283  
284 +        std::string getStatFileName() {
285 +            return statFileName_;
286 +        }
287 +        
288 +        void setStatFileName(const std::string& fileName) {
289 +            statFileName_ = fileName;
290 +        }
291 +
292 +        /**
293 +         * Returns the pointer of internal globalGroupMembership_ array. This array will be filled by SimCreator class
294 +         * @see #SimCreator::setGlobalIndex
295 +         */  
296 +        int* getGlobalGroupMembershipPointer() {
297 +            return globalGroupMembership_[0];
298 +        }
299 +
300 +        /**
301 +         * Returns the pointer of internal globalMolMembership_ array. This array will be filled by SimCreator class
302 +         * @see #SimCreator::setGlobalIndex
303 +         */        
304 +        int* getGlobalMolMembershipPointer() {
305 +            return globalMolMembership_[0];
306 +        }
307 +
308 +
309 +        bool isFortranInitialized() {
310 +            return fortranInitialized_;
311 +        }
312 +        
313 +        //below functions are just forward functions
314 +        //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
315 +        //the other hand, has-a relation need composing.
316 +        /**
317 +         * Adds property into property map
318 +         * @param genData GenericData to be added into PropertyMap
319 +         */
320 +        void addProperty(GenericData* genData);
321 +
322 +        /**
323 +         * Removes property from PropertyMap by name
324 +         * @param propName the name of property to be removed
325 +         */
326 +        void removeProperty(const std::string& propName);
327 +
328 +        /**
329 +         * clear all of the properties
330 +         */
331 +        void clearProperties();
332 +
333 +        /**
334 +         * Returns all names of properties
335 +         * @return all names of properties
336 +         */
337 +        std::vector<std::string> getPropertyNames();
338 +
339 +        /**
340 +         * Returns all of the properties in PropertyMap
341 +         * @return all of the properties in PropertyMap
342 +         */      
343 +        std::vector<GenericData*> getProperties();
344 +
345 +        /**
346 +         * Returns property
347 +         * @param propName name of property
348 +         * @return a pointer point to property with propName. If no property named propName
349 +         * exists, return NULL
350 +         */      
351 +        GenericData* getPropertyByName(const std::string& propName);
352 +                
353 +        friend std::ostream& operator <<(ostream& o, SimInfo& info);
354 +        
355 +    private:
356 +
357 +        
358 +        /** Returns the unique atom types of local processor in an array */
359 +        std::set<AtomType*> SimInfo::getUniqueAtomTypes();
360 +
361 +        /** fill up the simtype struct*/
362 +        void setupSimType();
363 +
364 +        /**
365 +         * Setup Fortran Simulation
366 +         * @see #setupFortranParallel
367 +         */
368 +        void setupFortranSim();
369 +
370 +        /** Figure out the radius of cutoff, radius of switching function and pass them to fortran */
371 +        void setupCutoff();
372 +
373 +        /** Calculates the number of degress of freedom in the whole system */
374 +        void calcNdf();
375 +        void calcNdfRaw();
376 +        void calcNdfTrans();
377 +
378 +        void addExcludePairs(Molecule* mol);
379 +        void removeExcludePairs(Molecule* mol);
380 +
381 +        /**
382 +         * Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
383 +         * system.
384 +         */
385 +        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
386 +
387 +        std::map<int, Molecule*>  molecules_; /**< Molecule array */
388 +        
389 +        //degress of freedom
390 +        int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
391 +        int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
392 +        int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
393 +        int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
394 +        
395 +        //number of global objects
396 +        int nGlobalMols_;       /**< number of molecules in the system */
397 +        int nGlobalAtoms_;   /**< number of atoms in the system */
398 +        int nGlobalCutoffGroups_; /**< number of cutoff groups in this system */
399 +
400 +        /**
401 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
402 +         * corresponding content is the global index of cutoff group this atom belong to.
403 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
404 +         */
405 +        std::vector<int> globalGroupMembership_;
406 +
407 +        /**
408 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
409 +         * corresponding content is the global index of molecule this atom belong to.
410 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
411 +         */
412 +        std::vector<int> globalMolMembership_;        
413 +
414 +        
415 +        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
416 +        std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */        
417 +        
418 +        //number of local objects
419 +        int nAtoms_;                        /**< number of atoms in local processor */
420 +        int nBonds_;                        /**< number of bonds in local processor */
421 +        int nBends_;                        /**< number of bends in local processor */
422 +        int nTorsions_;                    /**< number of torsions in local processor */
423 +        int nRigidBodies_;              /**< number of rigid bodies in local processor */
424 +        int nIntegrableObjects_;    /**< number of integrable objects in local processor */
425 +        int nCutoffGroups_;             /**< number of cutoff groups in local processor */
426 +        int nConstraints_;              /**< number of constraints in local processors */
427 +
428 +        simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
429 +        Exclude exclude_;
430 +        ForceField* forceField_;            
431 +        PropertyMap properties_;                  /**< Generic Property */
432 +        SnapshotManager* sman_;               /**< SnapshotManager */
433 +        Globals* globals_;
434 +        int seed_; /**< seed for random number generator */
435 +
436 +        /**
437 +         * The reason to have a local index manager is that when molecule is migrating to other processors,
438 +         * the atoms and the rigid-bodies will release their local indices to LocalIndexManager. Combining the
439 +         * information of molecule migrating to current processor, Migrator class can query  the LocalIndexManager
440 +         * to make a efficient data moving plan.
441 +         */        
442 +        LocalIndexManager localIndexMan_;
443 +
444 +        //file names
445 +        std::string finalConfigFileName_;
446 +        std::string dumpFileName_;
447 +        std::string statFileName_;
448 +
449 +        double rcut_;       /**< cutoff radius*/
450 +        double rsw_;        /**< radius of switching function*/
451 +
452 +        bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
453 +        
454 + #ifdef IS_MPI
455 +    //in Parallel version, we need MolToProc
456 +    public:
457 +                
458 +        /**
459 +         * Finds the processor where a molecule resides
460 +         * @return the id of the processor which contains the molecule
461 +         * @param globalIndex global Index of the molecule
462 +         */
463 +        int getMolToProc(int globalIndex) {
464 +            //assert(globalIndex < molToProcMap_.size());
465 +            return molToProcMap_[globalIndex];
466 +        }
467 +
468 +        /**
469 +         * Returns the pointer of internal molToProcMap array. This array will be filled by SimCreator class
470 +         * @see #SimCreator::divideMolecules
471 +         */
472 +        int* getMolToProcMapPointer() {
473 +            return &molToProcMap_[0];
474 +        }
475 +        
476 +    private:
477 +
478 +        void setupFortranParallel();
479 +        
480 +        /**
481 +         * The size of molToProcMap_ is equal to total number of molecules in the system.
482 +         *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
483 +         * once.
484 +         */        
485 +        std::vector<int> molToProcMap_;
486 + #endif
487 +
488   };
489  
490   } //namespace oopse

Diff Legend

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