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 1024 by tim, Wed Aug 30 18:42:29 2006 UTC vs.
Revision 1386 by gezelter, Fri Oct 23 18:41:09 2009 UTC

# Line 54 | Line 54
54   #include <utility>
55   #include <vector>
56  
57 < #include "brains/Exclude.hpp"
57 > #include "brains/PairList.hpp"
58   #include "io/Globals.hpp"
59   #include "math/Vector3.hpp"
60   #include "math/SquareMatrix3.hpp"
# Line 64 | Line 64
64   #include "utils/LocalIndexManager.hpp"
65  
66   //another nonsense macro declaration
67 < #define __C
67 > #define __OOPSE_C
68   #include "brains/fSimulation.h"
69  
70   namespace oopse{
# Line 77 | Line 77 | namespace oopse{
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.
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 <   */
80 >    * The Molecule class maintains all of the concrete objects
81 >    * (atoms, bond, bend, torsions, inversions, rigid bodies, cutoff groups,
82 >    * constraints). 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:
88      typedef std::map<int, Molecule*>::iterator  MoleculeIterator;
# Line 171 | Line 171 | namespace oopse{
171        return nTorsions_;
172      }
173  
174 +    /** Returns the number of local torsions */        
175 +    unsigned int getNInversions() {
176 +      return nInversions_;
177 +    }
178      /** Returns the number of local rigid bodies */        
179      unsigned int getNRigidBodies() {
180        return nRigidBodies_;
# Line 272 | Line 276 | namespace oopse{
276      /** Returns system angular momentum */
277      Vector3d getAngularMomentum();
278  
279 +    /** Returns volume of system as estimated by an ellipsoid defined by the radii of gyration*/
280 +    void getGyrationalVolume(RealType &vol);
281 +    /** Overloaded version of gyrational volume that also returns det(I) so dV/dr can be calculated*/
282 +    void getGyrationalVolume(RealType &vol, RealType &detI);
283      /** main driver function to interact with fortran during the initialization and molecule migration */
284      void update();
285  
# Line 306 | Line 314 | namespace oopse{
314        return i != molecules_.end() ? i->second : NULL;
315      }
316  
317 +    int getGlobalMolMembership(int id){
318 +      return globalMolMembership_[id];
319 +    }
320 +
321      RealType getRcut() {
322        return rcut_;
323      }
# Line 362 | Line 374 | namespace oopse{
374       * @see #SimCreator::setGlobalIndex
375       */  
376      void setGlobalGroupMembership(const std::vector<int>& globalGroupMembership) {
377 <      assert(globalGroupMembership.size() == nGlobalAtoms_);
377 >      assert(globalGroupMembership.size() == static_cast<size_t>(nGlobalAtoms_));
378        globalGroupMembership_ = globalGroupMembership;
379      }
380  
# Line 371 | Line 383 | namespace oopse{
383       * @see #SimCreator::setGlobalIndex
384       */        
385      void setGlobalMolMembership(const std::vector<int>& globalMolMembership) {
386 <      assert(globalMolMembership.size() == nGlobalAtoms_);
386 >      assert(globalMolMembership.size() == static_cast<size_t>(nGlobalAtoms_));
387        globalMolMembership_ = globalMolMembership;
388      }
389  
# Line 384 | Line 396 | namespace oopse{
396        return calcBoxDipole_;
397      }
398  
399 +    bool getUseAtomicVirial() {
400 +      return useAtomicVirial_;
401 +    }
402 +
403      //below functions are just forward functions
404      //To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
405      //the other hand, has-a relation need composing.
# Line 425 | Line 441 | namespace oopse{
441      GenericData* getPropertyByName(const std::string& propName);
442  
443      /**
444 <     * add all exclude pairs of a molecule into exclude list.
444 >     * add all special interaction pairs (including excluded
445 >     * interactions) in a molecule into the appropriate lists.
446       */
447 <    void addExcludePairs(Molecule* mol);
447 >    void addInteractionPairs(Molecule* mol);
448  
449      /**
450 <     * remove all exclude pairs which belong to a molecule from exclude list
450 >     * remove all special interaction pairs which belong to a molecule
451 >     * from the appropriate lists.
452       */
453 +    void removeInteractionPairs(Molecule* mol);
454  
436 –    void removeExcludePairs(Molecule* mol);
455  
438 –
456      /** Returns the unique atom types of local processor in an array */
457      std::set<AtomType*> getUniqueAtomTypes();
458          
# Line 504 | Line 521 | namespace oopse{
521      std::vector<int> globalGroupMembership_;
522  
523      /**
524 <     * the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
524 >     * the size of globalMolMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
525       * corresponding content is the global index of molecule this atom belong to.
526       * It is filled by SimCreator once and only once, since it is never changed during the simulation.
527       */
# Line 515 | Line 532 | namespace oopse{
532      std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */        
533          
534      //number of local objects
535 <    int nAtoms_;                        /**< number of atoms in local processor */
536 <    int nBonds_;                        /**< number of bonds in local processor */
537 <    int nBends_;                        /**< number of bends in local processor */
538 <    int nTorsions_;                    /**< number of torsions in local processor */
539 <    int nRigidBodies_;              /**< number of rigid bodies in local processor */
540 <    int nIntegrableObjects_;    /**< number of integrable objects in local processor */
541 <    int nCutoffGroups_;             /**< number of cutoff groups in local processor */
542 <    int nConstraints_;              /**< number of constraints in local processors */
535 >    int nAtoms_;              /**< number of atoms in local processor */
536 >    int nBonds_;              /**< number of bonds in local processor */
537 >    int nBends_;              /**< number of bends in local processor */
538 >    int nTorsions_;           /**< number of torsions in local processor */
539 >    int nInversions_;         /**< number of inversions in local processor */
540 >    int nRigidBodies_;        /**< number of rigid bodies in local processor */
541 >    int nIntegrableObjects_;  /**< number of integrable objects in local processor */
542 >    int nCutoffGroups_;       /**< number of cutoff groups in local processor */
543 >    int nConstraints_;        /**< number of constraints in local processors */
544  
545      simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
546 <    Exclude exclude_;      
546 >    PairList excludedInteractions_;      
547 >    PairList oneTwoInteractions_;      
548 >    PairList oneThreeInteractions_;      
549 >    PairList oneFourInteractions_;      
550      PropertyMap properties_;                  /**< Generic Property */
551      SnapshotManager* sman_;               /**< SnapshotManager */
552  
# Line 550 | Line 571 | namespace oopse{
571      RealType rsw_;        /**< radius of switching function*/
572      RealType rlist_;      /**< neighbor list radius */
573  
574 <    bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
574 >    int ljsp_; /**< use shifted potential for LJ*/
575 >    int ljsf_; /**< use shifted force for LJ*/
576  
577 <    bool calcBoxDipole_; /**< flag to indicate whether or not we calculate the simulation box dipole moment */
577 >    bool fortranInitialized_; /**< flag indicate whether fortran side
578 >                                 is initialized */
579 >    
580 >    bool calcBoxDipole_; /**< flag to indicate whether or not we calculate
581 >                            the simulation box dipole moment */
582 >    
583 >    bool useAtomicVirial_; /**< flag to indicate whether or not we use
584 >                              Atomic Virials to calculate the pressure */
585  
586      public:
587       /**
# Line 573 | Line 602 | namespace oopse{
602    //private:
603      //std::vector<StuntDouble*> sdByGlobalIndex_;
604      
576 – #ifdef IS_MPI
605      //in Parallel version, we need MolToProc
606    public:
607                  
# Line 594 | Line 622 | namespace oopse{
622      void setMolToProcMap(const std::vector<int>& molToProcMap) {
623        molToProcMap_ = molToProcMap;
624      }
597 –
598 –    
625          
626    private:
627  
628      void setupFortranParallel();
629          
630      /**
631 <     * The size of molToProcMap_ is equal to total number of molecules in the system.
632 <     *  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
633 <     * once.
631 >     * The size of molToProcMap_ is equal to total number of molecules
632 >     * in the system.  It maps a molecule to the processor on which it
633 >     * resides. it is filled by SimCreator once and only once.
634       */        
635      std::vector<int> molToProcMap_;
636  
611 – #endif
637  
638    };
639  

Diff Legend

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