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 1725 by tim, Wed Nov 10 22:01:06 2004 UTC vs.
Revision 1735 by tim, Fri Nov 12 17:40:03 2004 UTC

# Line 47 | Line 47 | 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 <        typedef std::vector<Molecule*>::iterator MoleculeIterator;
61 <        SimInfo();
60 >        typedef MoleculeIterator 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 >         * <p>
70 >         * The major change of SimInfo
71 >         * </p>
72 >         */
73 >        SimInfo(const std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* globals);
74          virtual ~SimInfo();
75  
76          /**
# Line 70 | Line 88 | class SimInfo {
88  
89          /** Returns the total number of molecules in the system. */
90          int getNGlobalMolecules() {
91 <
74 < #ifdef IS_MPI
75 <        int nmols;
76 <        int totNMols;
77 <
78 <        nmols = getNMolecules();
79 <        MPI_Allreduce(&nmols, &totNMols, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
80 <
81 <        return totNMols;
82 < #else
83 <            return getNMolecules();
84 < #endif
91 >            return nGlobalMols_;
92          }
93  
94          /** Returns the total number of atoms in the system. */
95          int getNGlobalAtoms() {
96 <
90 < #ifdef IS_MPI
91 <        int totNAtoms;
92 <        MPI_Allreduce(&nAtoms_, &totNAtoms, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
93 <        return totNAtoms;
94 < #else
95 <            return nAtoms_;
96 < #endif
96 >            return nGlobalAtoms_;
97          }
98  
99          /** Returns the total number of cutoff groups in the system. */
100          int getNGlobalCutoffGroups() {
101 < #ifdef IS_MPI
102 <        int totNGroups;
103 <        MPI_Allreduce(&nCutoffGroups_, &totNGroups, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
104 <        return totNGroups;
105 < #else
106 <            return nCutoffGroups_;
107 < #endif
101 >            return nGlobalCutoffGroups_;
102          }
103          
104          /**
# Line 160 | Line 154 | class SimInfo {
154           * @return the first molecule, return NULL if there is not molecule in this SimInfo
155           * @param i the iterator of molecule array (user shouldn't change it)
156           */
157 <        Molecule* beginMolecule(std::vector<Molecule*>::iterator& i);
157 >        Molecule* beginMolecule(MoleculeIterator& i);
158  
159          /**
160            * Returns the next avaliable Molecule based on the iterator.
161            * @return the next avaliable molecule, return NULL if reaching the end of the array
162            * @param i the iterator of molecule array
163            */
164 <        Molecule* nextMolecule(std::vector<Molecule*>::iterator& i);
164 >        Molecule* nextMolecule(MoleculeIterator& i);
165  
166          /** Returns the number of degrees of freedom */
167          int getNdf() {
# Line 184 | Line 178 | class SimInfo {
178              return ndfTrans_;
179          }
180  
181 +        //getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
182 +        
183 +        /** Returns the total number of z-constraint molecules in the system */
184 +        int getNZconstraint() {
185 +            return nZconstraint_;
186 +        }
187 +
188 +        /**
189 +         * Sets the number of z-constraint molecules in the system.
190 +         */
191 +        int setNZconstraint(int nZconstraint) {
192 +            nZconstraint_ = nZconstraint;
193 +        }
194 +        
195          /** Returns the snapshot manager. */
196          SnapshotManager* getSnapshotManager() {
197              return sman_;
# Line 199 | Line 207 | class SimInfo {
207              return forceField_;
208          }
209  
202 –        /** Sets the force field */
203 –        void setForceField(ForceField* ff) {
204 –            forceField_ = ff;
205 –        }
206 –
210          Globals* getGlobals() {
211              return globals_;
212          }
210 –        
211 –        void setGlobals(Globals* globals) {
212 –            globals_ = globals;
213 –        }
213  
214          /** Returns the velocity of center of mass of the whole system.*/
215          Vector3d getComVel();
# Line 228 | Line 227 | class SimInfo {
227              seed_ = seed;
228          }
229  
230 <        
230 >        /** main driver function to interact with fortran during the initialization and molecule migration */
231          void update();
232  
234 –
233          /** Returns the local index manager */
234          LocalIndexManager* getLocalIndexManager() {
235 <            return localIndexMan_;
235 >            return &localIndexMan_;
236          }
239 –
240 –
241 –        /**
242 –         *
243 –         */
244 –        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
237  
238          int getMoleculeStampId(int globalIndex) {
239              //assert(globalIndex < molStampIds_.size())
# Line 254 | Line 246 | class SimInfo {
246          }
247          
248          /**
257 –         * Finds the processor where a molecule resides
258 –         * @return the id of the processor which contains the molecule
259 –         * @param globalIndex global Index of the molecule
260 –         */
261 –        int getMolToProc(int globalIndex) {
262 –            //assert(globalIndex < molToProcMap_.size());
263 –            return molToProcMap_[globalIndex];
264 –        }
265 –
266 –        /**
249           * Finds a molecule with a specified global index
250           * @return a pointer point to found molecule
251           * @param index
252           */
253          Molecule* getMoleculeByGlobalIndex(int index) {
254              std::map<int, Molecule*> i;
255 <            i = globalIndexToMol_.find(index);
255 >            i = molecules_.find(index);
256  
257 <            return i != globalIndexToMol_.end() ? i->second : NULL;
257 >            return i != molecules_.end() ? i->second : NULL;
258          }
259 +
260 +        /** Calculate the maximum cutoff radius based on the atom types */
261 +        double calcMaxCutoffRadius();
262 +
263 +        double getRcut() {
264 +            return rcut_;
265 +        }
266 +        
267 +        void setRcut(double rcut) {
268 +            rcut_ = rcut;
269 +        }
270 +
271 +        double getRsw() {
272 +            return rsw_;
273 +        }
274 +        void setRsw(double rsw) {
275 +            rsw_ = rsw;
276 +        }
277 +        
278 +        std::string getFinalConfigFileName() {
279 +            return finalConfigFileName_;
280 +        }
281 +        
282 +        void setFinalConfigFileName(const std::string& fileName) {
283 +            finalConfigFileName_ = fileName;
284 +        }
285 +
286 +
287 +        std::string getDumpFileName() {
288 +            return dumpFileName_;
289 +        }
290 +        
291 +        void setDumpFileName(const std::string& fileName) {
292 +            dumpFileName_ = fileName;
293 +        }
294 +
295 +        std::string getStatFileName() {
296 +            return statFileName_;
297 +        }
298 +        
299 +        void setStatFileName(const std::string& fileName) {
300 +            statFileName_ = fileName;
301 +        }
302 +
303 +        /**
304 +         * Returns the pointer of internal globalGroupMembership_ array. This array will be filled by SimCreator class
305 +         * @see #SimCreator::setGlobalIndex
306 +         */  
307 +        int* getGlobalGroupMembershipPointer() {
308 +            return globalGroupMembership_[0];
309 +        }
310 +
311 +        /**
312 +         * Returns the pointer of internal globalMolMembership_ array. This array will be filled by SimCreator class
313 +         * @see #SimCreator::setGlobalIndex
314 +         */        
315 +        int* getGlobalMolMembershipPointer() {
316 +            return globalMolMembership_[0];
317 +        }
318 +        
319 +        //below functions are just forward functions
320 +        //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
321 +        //the other hand, has-a relation need composing.
322 +        /**
323 +         * Adds property into property map
324 +         * @param genData GenericData to be added into PropertyMap
325 +         */
326 +        void addProperty(GenericData* genData);
327  
328 +        /**
329 +         * Removes property from PropertyMap by name
330 +         * @param propName the name of property to be removed
331 +         */
332 +        void removeProperty(const std::string& propName);
333  
334 +        /**
335 +         * clear all of the properties
336 +         */
337 +        void clearProperties();
338 +
339 +        /**
340 +         * Returns all names of properties
341 +         * @return all names of properties
342 +         */
343 +        std::vector<std::string> getPropertyNames();
344 +
345 +        /**
346 +         * Returns all of the properties in PropertyMap
347 +         * @return all of the properties in PropertyMap
348 +         */      
349 +        std::vector<GenericData*> getProperties();
350 +
351 +        /**
352 +         * Returns property
353 +         * @param propName name of property
354 +         * @return a pointer point to property with propName. If no property named propName
355 +         * exists, return NULL
356 +         */      
357 +        GenericData* getPropertyByName(const std::string& propName);
358 +                
359          friend std::ostream& operator <<(ostream& o, SimInfo& info);
360          
361      private:
362  
363 +        
364 +        /** Returns the unique atom types of local processor in an array */
365 +        std::set<AtomType*> SimInfo::getUniqueAtomTypes();
366 +
367 +        /** fill up the simtype struct*/
368 +        void setupSimType();
369 +
370 +        /**
371 +         * Setup Fortran Simulation
372 +         * @see #setupFortranParallel
373 +         */
374 +        void setupFortranSim();
375 +
376 +        /** Calculates the number of degress of freedom in the whole system */
377          void calcNdf();
378          void calcNdfRaw();
379          void calcNdfTrans();
380  
287 –        int* getExcludeList() {
288 –            return exclude_.getExcludeList();
289 –        }
290 –
381          void addExcludePairs(Molecule* mol);
382          void removeExcludePairs(Molecule* mol);
383  
384 +        /**
385 +         * Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
386 +         * system.
387 +         */
388 +        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
389 +
390 +        std::map<int, Molecule*>  molecules_; /**< Molecule array */
391 +        
392          //degress of freedom
393 <        int ndf_;           /** number of degress of freedom */
394 <        int ndfRaw_;
395 <        int ndfTrans_; /**< number of translation degress of freedom */
393 >        int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
394 >        int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
395 >        int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
396 >        int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
397 >        
398 >        //number of global objects
399 >        int nGlobalMols_;       /**< number of molecules in the system */
400 >        int nGlobalAtoms_;   /**< number of atoms in the system */
401 >        int nGlobalCutoffGroups_; /**< number of cutoff groups in this system */
402  
403 +        /**
404 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
405 +         * corresponding content is the global index of cutoff group this atom belong to.
406 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
407 +         */
408 +        std::vector<int> globalGroupMembership_;
409 +
410 +        /**
411 +         * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
412 +         * corresponding content is the global index of molecule this atom belong to.
413 +         * It is filled by SimCreator once and only once, since it is never changed during the simulation.
414 +         */
415 +        std::vector<int> globalMolMembership_;        
416 +
417 +        
418 +        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
419 +        std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */        
420 +        
421          //number of local objects
422 <        int nAtoms_;
423 <        int nBonds_;
424 <        int nBends_;
425 <        int nTorsions_;
426 <        int nRigidBodies_;
427 <        int nIntegrableObjects_;
428 <        int nCutoffGroups_;
429 <        int nConstraints_;
422 >        int nAtoms_;                        /**< number of atoms in local processor */
423 >        int nBonds_;                        /**< number of bonds in local processor */
424 >        int nBends_;                        /**< number of bends in local processor */
425 >        int nTorsions_;                    /**< number of torsions in local processor */
426 >        int nRigidBodies_;              /**< number of rigid bodies in local processor */
427 >        int nIntegrableObjects_;    /**< number of integrable objects in local processor */
428 >        int nCutoffGroups_;             /**< number of cutoff groups in local processor */
429 >        int nConstraints_;              /**< number of constraints in local processors */
430  
431 <        simtype fInfo_;
431 >        simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
432          Exclude exclude_;
433 <        ForceField* forceField_;
312 <        
313 <        std::vector<Molecule*> molecules_; /**< Molecule array */
433 >        ForceField* forceField_;            
434          PropertyMap properties_;                  /**< Generic Property */
435          SnapshotManager* sman_;               /**< SnapshotManager */
316 –
436          Globals* globals_;
318 –
437          int seed_; /**< seed for random number generator */
438  
439 +        /**
440 +         * The reason to have a local index manager is that when molecule is migrating to other processors,
441 +         * the atoms and the rigid-bodies will release their local indices to LocalIndexManager. Combining the
442 +         * information of molecule migrating to current processor, Migrator class can query  the LocalIndexManager
443 +         * to make a efficient data moving plan.
444 +         */        
445          LocalIndexManager localIndexMan_;
446  
447 <        //
448 <        std::vector<int> molToProcMap_;
449 <        std::map<int, Molecule*> globalIndexToMol_;
450 <        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
327 <        std::vector<MoleculeStamp*> moleculeStamps_; /**< molecule stamps array */      
447 >        //file names
448 >        std::string finalConfigFileName_;
449 >        std::string dumpFileName_;
450 >        std::string statFileName_;
451  
452 +        double rcut_;       /**< cutoff radius*/
453 +        double rsw_;        /**< radius of switching function*/
454 +        
455 + #ifdef IS_MPI
456 +    //in Parallel version, we need MolToProc
457 +    public:
458 +                
459 +        /**
460 +         * Finds the processor where a molecule resides
461 +         * @return the id of the processor which contains the molecule
462 +         * @param globalIndex global Index of the molecule
463 +         */
464 +        int getMolToProc(int globalIndex) {
465 +            //assert(globalIndex < molToProcMap_.size());
466 +            return molToProcMap_[globalIndex];
467 +        }
468 +
469 +        /**
470 +         * Returns the pointer of internal molToProcMap array. This array will be filled by SimCreator class
471 +         * @see #SimCreator::divideMolecules
472 +         */
473 +        int* getMolToProcMapPointer() {
474 +            return &molToProcMap_[0];
475 +        }
476 +        
477 +    private:
478 +
479 +        void setupFortranParallel();
480 +        
481 +        /**
482 +         * The size of molToProcMap_ is equal to total number of molecules in the system.
483 +         *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
484 +         * once.
485 +         */        
486 +        std::vector<int> molToProcMap_;
487 + #endif
488 +
489   };
490  
491   } //namespace oopse

Diff Legend

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