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

Comparing trunk/src/brains/SimInfo.hpp (file contents):
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 1241 by gezelter, Fri Apr 25 15:14:47 2008 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 One of the heavy weight classes of OOPSE, SimInfo maintains a list of molecules.
# Line 271 | 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 320 | Line 325 | namespace oopse{
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 372 | Line 384 | namespace oopse{
384        return fortranInitialized_;
385      }
386          
387 +    bool getCalcBoxDipole() {
388 +      return calcBoxDipole_;
389 +    }
390 +
391 +    bool getUseAtomicVirial() {
392 +      return useAtomicVirial_;
393 +    }
394 +
395      //below functions are just forward functions
396      //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
397      //the other hand, has-a relation need composing.
# Line 451 | Line 471 | namespace oopse{
471      /** Figure out which polynomial type to use for the switching function */
472      void setupSwitchingFunction();
473  
474 +    /** Determine if we need to accumulate the simulation box dipole */
475 +    void setupAccumulateBoxDipole();
476 +
477      /** Calculates the number of degress of freedom in the whole system */
478      void calcNdf();
479      void calcNdfRaw();
# Line 522 | Line 545 | namespace oopse{
545       */        
546      LocalIndexManager localIndexMan_;
547  
548 +    // unparsed MetaData block for storing in Dump and EOR files:
549 +    std::string rawMetaData_;
550 +
551      //file names
552      std::string finalConfigFileName_;
553      std::string dumpFileName_;
# Line 532 | Line 558 | namespace oopse{
558      RealType rsw_;        /**< radius of switching function*/
559      RealType rlist_;      /**< neighbor list radius */
560  
561 <    bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
561 >    bool ljsp_; /**< use shifted potential for LJ*/
562 >    bool ljsf_; /**< use shifted force for LJ*/
563  
564 < #ifdef IS_MPI
564 >    bool fortranInitialized_; /**< flag indicate whether fortran side
565 >                                 is initialized */
566 >    
567 >    bool calcBoxDipole_; /**< flag to indicate whether or not we calculate
568 >                            the simulation box dipole moment */
569 >    
570 >    bool useAtomicVirial_; /**< flag to indicate whether or not we use
571 >                              Atomic Virials to calculate the pressure */
572 >
573 >    public:
574 >     /**
575 >      * return an integral objects by its global index. In MPI version, if the StuntDouble with specified
576 >      * global index does not belong to local processor, a NULL will be return.
577 >      */
578 >      StuntDouble* getIOIndexToIntegrableObject(int index);
579 >      void setIOIndexToIntegrableObject(const std::vector<StuntDouble*>& v);
580 >    private:
581 >      std::vector<StuntDouble*> IOIndexToIntegrableObject;
582 >  //public:
583 >    //void setStuntDoubleFromGlobalIndex(std::vector<StuntDouble*> v);
584 >    /**
585 >     * return a StuntDouble by its global index. In MPI version, if the StuntDouble with specified
586 >     * global index does not belong to local processor, a NULL will be return.
587 >     */
588 >    //StuntDouble* getStuntDoubleFromGlobalIndex(int index);
589 >  //private:
590 >    //std::vector<StuntDouble*> sdByGlobalIndex_;
591 >    
592      //in Parallel version, we need MolToProc
593    public:
594                  
# Line 561 | Line 615 | namespace oopse{
615      void setupFortranParallel();
616          
617      /**
618 <     * The size of molToProcMap_ is equal to total number of molecules in the system.
619 <     *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
620 <     * once.
618 >     * The size of molToProcMap_ is equal to total number of molecules
619 >     * in the system.  It maps a molecule to the processor on which it
620 >     * resides. it is filled by SimCreator once and only once.
621       */        
622      std::vector<int> molToProcMap_;
623  
570 – #endif
624  
625    };
626  

Diff Legend

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