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

Comparing trunk/src/brains/SimInfo.hpp (file contents):
Revision 598 by chrisfen, Thu Sep 15 00:14:35 2005 UTC vs.
Revision 1103 by chuckv, Fri Dec 29 20:21:53 2006 UTC

# Line 73 | Line 73 | namespace oopse{
73    class SnapshotManager;
74    class Molecule;
75    class SelectionManager;
76 +  class StuntDouble;
77    /**
78     * @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
79 <   * @brief As one of the heavy weight class of OOPSE, SimInfo
80 <   * One of the major changes in SimInfo class is the data struct. It only maintains a list of molecules.
81 <   * And the Molecule class will maintain all of the concrete objects (atoms, bond, bend, torsions, rigid bodies,
82 <   * cutoff groups, constrains).
83 <   * Another major change is the index. No matter single version or parallel version,  atoms and
84 <   * rigid bodies have both global index and local index. Local index is not important to molecule as well as
84 <   * cutoff group.
79 >   * @brief One of the heavy weight classes of OOPSE, SimInfo maintains a list of molecules.
80 >   * The Molecule class maintains all of the concrete objects
81 >   * (atoms, bond, bend, torsions, rigid bodies, cutoff groups, constrains).
82 >   * In both the  single and parallel versions,  atoms and
83 >   * rigid bodies have both global and local indices.  The local index is
84 >   * not relevant to molecules or cutoff groups.
85     */
86    class SimInfo {
87    public:
# Line 95 | Line 95 | namespace oopse{
95       * @param simParams
96       * @note
97       */
98 <    SimInfo(MakeStamps* stamps, std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* simParams);
98 >    SimInfo(ForceField* ff, Globals* simParams);
99      virtual ~SimInfo();
100  
101      /**
# Line 207 | Line 207 | namespace oopse{
207  
208      /** Returns the number of degrees of freedom */
209      int getNdf() {
210 <      return ndf_;
210 >      return ndf_ - getFdf();
211      }
212  
213      /** Returns the number of raw degrees of freedom */
# Line 220 | Line 220 | namespace oopse{
220        return ndfTrans_;
221      }
222  
223 +    /** sets the current number of frozen degrees of freedom */
224 +    void setFdf(int fdf) {
225 +      fdf_local = fdf;
226 +    }
227 +
228 +    int getFdf();
229 +    
230      //getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
231          
232      /** Returns the total number of z-constraint molecules in the system */
# Line 265 | Line 272 | namespace oopse{
272      /** Returns system angular momentum */
273      Vector3d getAngularMomentum();
274  
275 +    /** Returns volume of system as estimated by an ellipsoid defined by the radii of gyration*/
276 +    void getGyrationalVolume(RealType &vol);
277 +    /** Overloaded version of gyrational volume that also returns det(I) so dV/dr can be calculated*/
278 +    void getGyrationalVolume(RealType &vol, RealType &detI);
279      /** main driver function to interact with fortran during the initialization and molecule migration */
280      void update();
281  
# Line 299 | Line 310 | namespace oopse{
310        return i != molecules_.end() ? i->second : NULL;
311      }
312  
313 <    /** Calculate the maximum cutoff radius based on the atom types */
303 <    double calcMaxCutoffRadius();
304 <
305 <    double getRcut() {
313 >    RealType getRcut() {
314        return rcut_;
315      }
316  
317 <    double getRsw() {
317 >    RealType getRsw() {
318        return rsw_;
319      }
320 +
321 +    RealType getList() {
322 +      return rlist_;
323 +    }
324          
325      std::string getFinalConfigFileName() {
326        return finalConfigFileName_;
327      }
328 <        
328 >
329      void setFinalConfigFileName(const std::string& fileName) {
330        finalConfigFileName_ = fileName;
331      }
332  
333 +    std::string getRawMetaData() {
334 +      return rawMetaData_;
335 +    }
336 +    void setRawMetaData(const std::string& rawMetaData) {
337 +      rawMetaData_ = rawMetaData;
338 +    }
339 +        
340      std::string getDumpFileName() {
341        return dumpFileName_;
342      }
# Line 365 | Line 384 | namespace oopse{
384        return fortranInitialized_;
385      }
386          
387 +    bool getCalcBoxDipole() {
388 +      return calcBoxDipole_;
389 +    }
390 +
391      //below functions are just forward functions
392      //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
393      //the other hand, has-a relation need composing.
# Line 422 | Line 445 | namespace oopse{
445          
446      friend std::ostream& operator <<(std::ostream& o, SimInfo& info);
447  
448 <    void getCutoff(double& rcut, double& rsw);
448 >    void getCutoff(RealType& rcut, RealType& rsw);
449          
450    private:
451  
# Line 439 | Line 462 | namespace oopse{
462      void setupCutoff();
463  
464      /** Figure out which coulombic correction method to use and pass to fortran */
465 <    void setupCoulombicCorrection( int isError );
465 >    void setupElectrostaticSummationMethod( int isError );
466  
467 +    /** Figure out which polynomial type to use for the switching function */
468 +    void setupSwitchingFunction();
469 +
470 +    /** Determine if we need to accumulate the simulation box dipole */
471 +    void setupAccumulateBoxDipole();
472 +
473      /** Calculates the number of degress of freedom in the whole system */
474      void calcNdf();
475      void calcNdfRaw();
476      void calcNdfTrans();
477  
478 +    ForceField* forceField_;      
479 +    Globals* simParams_;
480 +
481 +    std::map<int, Molecule*>  molecules_; /**< Molecule array */
482 +
483      /**
484       * Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
485       * system.
486       */
487      void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
454 –
455 –    MakeStamps* stamps_;
456 –    ForceField* forceField_;      
457 –    Globals* simParams_;
458 –
459 –    std::map<int, Molecule*>  molecules_; /**< Molecule array */
488          
489      //degress of freedom
490      int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
491 +    int fdf_local;       /**< number of frozen degrees of freedom */
492 +    int fdf_;            /**< number of frozen degrees of freedom */
493      int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
494      int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
495      int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
# Line 511 | Line 541 | namespace oopse{
541       */        
542      LocalIndexManager localIndexMan_;
543  
544 +    // unparsed MetaData block for storing in Dump and EOR files:
545 +    std::string rawMetaData_;
546 +
547      //file names
548      std::string finalConfigFileName_;
549      std::string dumpFileName_;
550      std::string statFileName_;
551      std::string restFileName_;
552          
553 <    double rcut_;       /**< cutoff radius*/
554 <    double rsw_;        /**< radius of switching function*/
553 >    RealType rcut_;       /**< cutoff radius*/
554 >    RealType rsw_;        /**< radius of switching function*/
555 >    RealType rlist_;      /**< neighbor list radius */
556  
557      bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
558  
559 +    bool calcBoxDipole_; /**< flag to indicate whether or not we calculate the simulation box dipole moment */
560 +
561 +    public:
562 +     /**
563 +      * return an integral objects by its global index. In MPI version, if the StuntDouble with specified
564 +      * global index does not belong to local processor, a NULL will be return.
565 +      */
566 +      StuntDouble* getIOIndexToIntegrableObject(int index);
567 +      void setIOIndexToIntegrableObject(const std::vector<StuntDouble*>& v);
568 +    private:
569 +      std::vector<StuntDouble*> IOIndexToIntegrableObject;
570 +  //public:
571 +    //void setStuntDoubleFromGlobalIndex(std::vector<StuntDouble*> v);
572 +    /**
573 +     * return a StuntDouble by its global index. In MPI version, if the StuntDouble with specified
574 +     * global index does not belong to local processor, a NULL will be return.
575 +     */
576 +    //StuntDouble* getStuntDoubleFromGlobalIndex(int index);
577 +  //private:
578 +    //std::vector<StuntDouble*> sdByGlobalIndex_;
579 +    
580   #ifdef IS_MPI
581      //in Parallel version, we need MolToProc
582    public:
# Line 543 | Line 598 | namespace oopse{
598      void setMolToProcMap(const std::vector<int>& molToProcMap) {
599        molToProcMap_ = molToProcMap;
600      }
601 +
602 +    
603          
604    private:
605  

Diff Legend

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