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 1733 by tim, Fri Nov 12 06:19:04 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  
# Line 47 | Line 51 | class SimInfo {
51   */
52   class SimInfo {
53      public:
54 <        SimInfo();
54 >        typedef MoleculeIterator MoleculeIterator;
55 >
56 >        /**
57 >         * Constructor of SimInfo
58 >         * @param molStampPairs MoleculeStamp Array. The first element of the pair is molecule stamp, the
59 >         * second element is the total number of molecules with the same molecule stamp in the system
60 >         * @param ff pointer of a concrete ForceField instance
61 >         * @param globals
62 >         * @note
63 >         * <p>
64 >         * The major change of SimInfo
65 >         * </p>
66 >         */
67 >        SimInfo(const std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* globals);
68          virtual ~SimInfo();
69  
70          /**
# Line 63 | Line 80 | class SimInfo {
80           */
81          bool removeMolecule(Molecule* mol);
82  
83 +        /** Returns the total number of molecules in the system. */
84 +        int getNGlobalMolecules() {
85 +            return nGlobalMols_;
86 +        }
87 +
88 +        /** Returns the total number of atoms in the system. */
89 +        int getNGlobalAtoms() {
90 +            return nGlobalAtoms_;
91 +        }
92 +
93 +        /** Returns the total number of cutoff groups in the system. */
94 +        int getNGlobalCutoffGroups() {
95 +            return nGlobalCutoffGroups_;
96 +        }
97 +        
98          /**
99 <         * Returns the number of molecules.
100 <         * @return the number of molecules in this SimInfo
99 >         * Returns the number of local molecules.
100 >         * @return the number of local molecules
101           */
102          int getNMolecules() {
103              return molecules_.size();
104          }
105  
106 <        /** Returns the total number of atoms in this SimInfo */
106 >        /** Returns the number of local atoms */
107          unsigned int getNAtoms() {
108              return nAtoms_;
109          }
110  
111 <        /** Returns the total number of bonds in this SimInfo */        
111 >        /** Returns the number of local bonds */        
112          unsigned int getNBonds(){
113              return nBonds_;
114          }
115  
116 <        /** Returns the total number of bends in this SimInfo */        
116 >        /** Returns the number of local bends */        
117          unsigned int getNBends() {
118              return nBends_;
119          }
120  
121 <        /** Returns the total number of torsions in this SimInfo */        
121 >        /** Returns the number of local torsions */        
122          unsigned int getNTorsions() {
123              return nTorsions_;
124          }
125  
126 <        /** Returns the total number of rigid bodies in this SimInfo */        
126 >        /** Returns the number of local rigid bodies */        
127          unsigned int getNRigidBodies() {
128              return nRigidBodies_;
129          }
130  
131 <        /** Returns the total number of integrable objects in this SimInfo */
131 >        /** Returns the number of local integrable objects */
132          unsigned int getNIntegrableObjects() {
133              return nIntegrableObjects_;
134          }
135  
136 <        /** Returns the total number of cutoff groups in this SimInfo */
136 >        /** Returns the number of local cutoff groups */
137          unsigned int getNCutoffGroups() {
138              return nCutoffGroups_;
139          }
# Line 116 | Line 148 | class SimInfo {
148           * @return the first molecule, return NULL if there is not molecule in this SimInfo
149           * @param i the iterator of molecule array (user shouldn't change it)
150           */
151 <        Molecule* beginMolecule(std::vector<Molecule*>::iterator& i);
151 >        Molecule* beginMolecule(MoleculeIterator& i);
152  
153          /**
154            * Returns the next avaliable Molecule based on the iterator.
155            * @return the next avaliable molecule, return NULL if reaching the end of the array
156            * @param i the iterator of molecule array
157            */
158 <        Molecule* nextMolecule(std::vector<Molecule*>::iterator& i);
158 >        Molecule* nextMolecule(MoleculeIterator& i);
159  
160          /** Returns the number of degrees of freedom */
161 <        int getNDF() {
161 >        int getNdf() {
162              return ndf_;
163          }
164  
165          /** Returns the number of raw degrees of freedom */
166 <        int getNDFRaw() {
166 >        int getNdfRaw() {
167              return ndfRaw_;
168          }
169  
170          /** Returns the number of translational degrees of freedom */
171 <        int getNDFTrans() {
171 >        int getNdfTrans() {
172              return ndfTrans_;
173          }
174  
175 +        //getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
176 +        
177 +        /** Returns the total number of z-constraint molecules in the system */
178 +        int getNZconstraint() {
179 +            return nZconstraint_;
180 +        }
181 +
182 +        /**
183 +         * Sets the number of z-constraint molecules in the system.
184 +         */
185 +        int setNZconstraint(int nZconstraint) {
186 +            nZconstraint_ = nZconstraint;
187 +        }
188 +        
189          /** Returns the snapshot manager. */
190          SnapshotManager* getSnapshotManager() {
191              return sman_;
# Line 150 | Line 196 | class SimInfo {
196              sman_ = sman;
197          }
198  
199 +        /** Returns the force field */
200          ForceField* getForceField() {
201              return forceField_;
202          }
203 +
204 +        Globals* getGlobals() {
205 +            return globals_;
206 +        }
207 +
208 +        /** Returns the velocity of center of mass of the whole system.*/
209 +        Vector3d getComVel();
210 +
211 +        /** Returns the center of the mass of the whole system.*/
212 +        Vector3d getCom();
213 +
214 +        /** Returns the seed (used for random number generator) */
215 +        int getSeed() {
216 +            return seed_;
217 +        }
218 +
219 +        /** Sets the seed*/
220 +        void setSeed(int seed) {
221 +            seed_ = seed;
222 +        }
223 +
224 +        /** main driver function to interact with fortran during the initialization and molecule migration */
225 +        void update();
226 +
227 +        /** Returns the local index manager */
228 +        LocalIndexManager* getLocalIndexManager() {
229 +            return localIndexMan_;
230 +        }
231 +
232 +        int getMoleculeStampId(int globalIndex) {
233 +            //assert(globalIndex < molStampIds_.size())
234 +            return molStampIds_[globalIndex];
235 +        }
236 +
237 +        /** Returns the molecule stamp */
238 +        MoleculeStamp* getMoleculeStamp(int id) {
239 +            return moleculeStamps_[id];
240 +        }
241          
242 <        void setForceField(ForceField* ff) {
243 <            forceField_ = ff;
242 >        /**
243 >         * Finds a molecule with a specified global index
244 >         * @return a pointer point to found molecule
245 >         * @param index
246 >         */
247 >        Molecule* getMoleculeByGlobalIndex(int index) {
248 >            std::map<int, Molecule*> i;
249 >            i = molecules_.find(index);
250 >
251 >            return i != molecules_.end() ? i->second : NULL;
252          }
160 –    private:
253  
254 <        void calcNDF();
255 <        void calcNDFRaw();
164 <        void calcNDFTrans();
254 >        /** Returns the unique atom types of local processor in an array */
255 >        std::set<AtomType*> SimInfo::getUniqueAtomTypes();
256  
257 <        int ndf_;
258 <        int ndfRaw_;
259 <        int ndfTrans_;
257 >        std::string getFinalConfigFileName() {
258 >            return finalConfigFileName_;
259 >        }
260          
261 <        int nAtoms_;
262 <        int nBonds_;
263 <        int nBends_;
173 <        int nTorsions_;
174 <        int nRigidBodies_;
175 <        int nIntegrableObjects_;
176 <        int nCutoffGroups_;
177 <        int nConstraints_;
261 >        void setFinalConfigFileName(const std::string& fileName) {
262 >            finalConfigFileName_ = fileName;
263 >        }
264  
265 <        simtype fInfo;
266 <        Exclude excludeList;
267 <        ForceField* forceField_;
265 >
266 >        std::string getDumpFileName() {
267 >            return dumpFileName_;
268 >        }
269          
270 <        std::vector<Molecule*> molecules_; /**< Molecule array */
271 <        PropertyMap properties_;                  /** Generic Property */
272 <        SnapshotManager* sman_;               /** SnapshotManager */
270 >        void setDumpFileName(const std::string& fileName) {
271 >            dumpFileName_ = fileName;
272 >        }
273  
274 +        std::string getStatFileName() {
275 +            return statFileName_;
276 +        }
277 +        
278 +        void setStatFileName(const std::string& fileName) {
279 +            statFileName_ = fileName;
280 +        }
281 +
282 +        int* getGlobalGroupMembershipPointer() {
283 +            return globalGroupMembership_[0];
284 +        }
285 +
286 +        //below functions are just forward functions
287 +        //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
288 +        //the other hand, has-a relation need composing.
289 +        /**
290 +         * Adds property into property map
291 +         * @param genData GenericData to be added into PropertyMap
292 +         */
293 +        void addProperty(GenericData* genData);
294 +
295 +        /**
296 +         * Removes property from PropertyMap by name
297 +         * @param propName the name of property to be removed
298 +         */
299 +        void removeProperty(const std::string& propName);
300 +
301 +        /**
302 +         * clear all of the properties
303 +         */
304 +        void clearProperties();
305 +
306 +        /**
307 +         * Returns all names of properties
308 +         * @return all names of properties
309 +         */
310 +        std::vector<std::string> getPropertyNames();
311 +
312 +        /**
313 +         * Returns all of the properties in PropertyMap
314 +         * @return all of the properties in PropertyMap
315 +         */      
316 +        std::vector<GenericData*> getProperties();
317 +
318 +        /**
319 +         * Returns property
320 +         * @param propName name of property
321 +         * @return a pointer point to property with propName. If no property named propName
322 +         * exists, return NULL
323 +         */      
324 +        GenericData* getPropertyByName(const std::string& propName);
325 +                
326 +        friend std::ostream& operator <<(ostream& o, SimInfo& info);
327 +        
328 +    private:
329 +
330 +        void setupSimType();
331 +
332 +        /**
333 +         * Setup Fortran Simulation
334 +         * @see #setupFortranParallel
335 +         */
336 +        void setupFortranSim();
337 +
338 +        /** Calculates the number of degress of freedom in the whole system */
339 +        void calcNdf();
340 +        void calcNdfRaw();
341 +        void calcNdfTrans();
342 +
343 +        void addExcludePairs(Molecule* mol);
344 +        void removeExcludePairs(Molecule* mol);
345 +
346 +        /**
347 +         * Adds molecule stamps into
348 +         */
349 +        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
350 +
351 +        std::map<int, Molecule*>  molecules_; /**< Molecule array */
352 +        
353 +        //degress of freedom
354 +        int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
355 +        int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
356 +        int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
357 +        int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
358 +        
359 +        //number of global objects
360 +        int nGlobalMols_;       /**< number of molecules in the system */
361 +        int nGlobalAtoms_;   /**< number of atoms in the system */
362 +        int nGlobalCutoffGroups_; /**< number of cutoff groups in this system */
363 +
364 +        /**
365 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
366 +         * corresponding content is the global index of cutoff group this atom belong to.
367 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
368 +         */
369 +        std::vector<int> globalGroupMembership_;
370 +        
371 +        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
372 +        std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */        
373 +        
374 +        //number of local objects
375 +        int nAtoms_;                        /**< number of atoms in local processor */
376 +        int nBonds_;                        /**< number of bonds in local processor */
377 +        int nBends_;                        /**< number of bends in local processor */
378 +        int nTorsions_;                    /**< number of torsions in local processor */
379 +        int nRigidBodies_;              /**< number of rigid bodies in local processor */
380 +        int nIntegrableObjects_;    /**< number of integrable objects in local processor */
381 +        int nCutoffGroups_;             /**< number of cutoff groups in local processor */
382 +        int nConstraints_;              /**< number of constraints in local processors */
383 +
384 +        simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
385 +        Exclude exclude_;
386 +        ForceField* forceField_;            
387 +        PropertyMap properties_;                  /**< Generic Property */
388 +        SnapshotManager* sman_;               /**< SnapshotManager */
389 +        Globals* globals_;
390 +        int seed_; /**< seed for random number generator */
391 +
392 +        LocalIndexManager localIndexMan_;
393 +
394 +        std::string finalConfigFileName_;
395 +        std::string dumpFileName_;
396 +        std::string statFileName_;
397 +        
398 + #ifdef IS_MPI
399 +    //in Parallel version, we need MolToProc
400 +    public:
401 +                
402 +        /**
403 +         * Finds the processor where a molecule resides
404 +         * @return the id of the processor which contains the molecule
405 +         * @param globalIndex global Index of the molecule
406 +         */
407 +        int getMolToProc(int globalIndex) {
408 +            //assert(globalIndex < molToProcMap_.size());
409 +            return molToProcMap_[globalIndex];
410 +        }
411 +
412 +        int* getMolToProcMapPointer() {
413 +            return &molToProcMap_[0];
414 +        }
415 +        
416 +    private:
417 +
418 +        void setupFortranParallel();
419 +        
420 +        /**
421 +         * The size of molToProcMap_ is equal to total number of molecules in the system.
422 +         *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
423 +         * once.
424 +         */        
425 +        std::vector<int> molToProcMap_;
426 + #endif
427 +
428   };
429  
430   } //namespace oopse

Diff Legend

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