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

Comparing branches/development/src/nonbonded/InteractionManager.hpp (file contents):
Revision 1502 by gezelter, Sat Oct 2 19:53:32 2010 UTC vs.
Revision 1808 by gezelter, Mon Oct 22 20:42:10 2012 UTC

# Line 36 | Line 36
36   * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37   * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38   * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 < * [4]  Vardeman & Gezelter, in progress (2009).                        
39 > * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 > * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42  
43   #ifndef NONBONDED_INTERACTIONMANAGER_HPP
# Line 44 | Line 45
45  
46   #include "brains/SimInfo.hpp"
47   #include "types/AtomType.hpp"
47 – #include "UseTheForce/ForceField.hpp"
48   #include "nonbonded/LJ.hpp"
49   #include "nonbonded/GB.hpp"
50   #include "nonbonded/Sticky.hpp"
# Line 52 | Line 52
52   #include "nonbonded/SC.hpp"
53   #include "nonbonded/Morse.hpp"
54   #include "nonbonded/Electrostatic.hpp"
55 + #include "nonbonded/MAW.hpp"
56 + #include "nonbonded/RepulsivePower.hpp"
57 + #include "nonbonded/SwitchingFunction.hpp"
58  
59   using namespace std;
60  
61   namespace OpenMD {
62 +
63    /**
64 <   * @class InteractionManager InteractionManager is responsible for
65 <   * keeping track of the non-bonded interactions (C++) and providing
66 <   * an interface to the low-level loop (Fortran).
64 >   * @class InteractionManager
65 >   * InteractionManager is responsible for
66 >   * keeping track of the non-bonded interactions (C++)
67     */
68    class InteractionManager {
69  
70    public:
71 <    static InteractionManager* Instance();
72 <    static void setForceField(ForceField *ff) {forceField_ = ff;};    
71 >    InteractionManager();
72 >    ~InteractionManager();
73 >    void setSimInfo(SimInfo* info) {info_ = info;}
74 >    void initialize();
75  
70 –    static void doPrePair(AtomType* atype1,
71 –                          AtomType* atype2,
72 –                          RealType rij,
73 –                          RealType &rho_i_at_j,
74 –                          RealType &rho_j_at_i);
75 –
76 –    static void doPreForce(AtomType* atype,
77 –                           RealType rho,      
78 –                           RealType &frho,
79 –                           RealType &dfrhodrho);
80 –
81 –    static void doSkipCorrection(AtomType* atype1,      
82 –                                 AtomType* atype2,
83 –                                 Vector3d d,
84 –                                 RealType rij,
85 –                                 RealType &skippedCharge1,
86 –                                 RealType &skippedCharge2,
87 –                                 RealType sw,
88 –                                 RealType electroMult,
89 –                                 RealType &pot,
90 –                                 RealType &vpair,
91 –                                 Vector3d &f1,
92 –                                 Mat3x3d eFrame1,
93 –                                 Mat3x3d eFrame2,
94 –                                 Vector3d &t1,
95 –                                 Vector3d &t2);
96 –    
97 –    static void doSelfCorrection(AtomType* atype,
98 –                                 Mat3x3d eFrame,
99 –                                 RealType skippedCharge,
100 –                                 RealType &pot,
101 –                                 Vector3d &t);
102 –
103 –    static RealType getCutoff();
104 –
76      // Fortran support routines
77  
78 <    static void do_prepair(int *atid1, int *atid2, RealType *rij, RealType *rho_i_at_j, RealType *rho_j_at_i);
79 <    static void do_preforce(int *atid, RealType *rho, RealType *frho, RealType *dfrhodrho);
80 <    static void do_pair(int *atid1, int *atid2, RealType *d, RealType *r, RealType *r2, RealType *rcut, RealType *sw, RealType *vdwMult,RealType *electroMult, RealType *pot, RealType *vpair, RealType *f1, RealType *eFrame1, RealType *eFrame2, RealType *A1, RealType *A2, RealType *t1, RealType *t2, RealType *rho1, RealType *rho2, RealType *dfrho1, RealType *dfrho2, RealType *fshift1, RealType *fshift2);    
81 <    static void do_skip_correction(int *atid1, int *atid2, RealType *d, RealType *r, RealType *skippedCharge1, RealType *skippedCharge2, RealType *sw, RealType *electroMult, RealType *pot, RealType *vpair, RealType *f1, RealType *eFrame1, RealType *eFrame2, RealType *t1, RealType *t2);
82 <    static void do_self_correction(int *atid, RealType *eFrame, RealType *skippedCharge, RealType *pot, RealType *t);
83 <  
78 >    void doPrePair(InteractionData idat);
79 >    void doPreForce(SelfData sdat);
80 >    void doPair(InteractionData idat);    
81 >    void doSkipCorrection(InteractionData idat);
82 >    void doSelfCorrection(SelfData sdat);
83 >    void setCutoffRadius(RealType rCut);
84 >    RealType getSuggestedCutoffRadius(int *atid1);  
85 >    RealType getSuggestedCutoffRadius(AtomType *atype);
86      
87    private:
88 <    virtual ~InteractionManager() { }
116 <    // singleton pattern, prevent reconstruction
117 <    InteractionManager() { }
118 <    InteractionManager(InteractionManager const&) {};
119 <    InteractionManager& operator=(InteractionManager const&) {};
120 <    static InteractionManager* _instance;
88 >    bool initialized_;
89  
90 <    static void initialize();
123 <    static bool initialized_;
90 >    void setupElectrostatics();
91  
92 <    static ForceField* forceField_;
93 <    static LJ* lj_;
94 <    static GB* gb_;
95 <    static Sticky* sticky_;
96 <    static EAM* eam_;
97 <    static SC* sc_;
98 <    static Morse* morse_;
99 <    static Electrostatic* electrostatic_;
100 <
101 <    static map<int, AtomType*> typeMap_;
92 >    SimInfo* info_;
93 >    LJ* lj_;
94 >    GB* gb_;
95 >    Sticky* sticky_;
96 >    EAM* eam_;
97 >    SC* sc_;
98 >    Morse* morse_;
99 >    Electrostatic* electrostatic_;
100 >    RepulsivePower* repulsivePower_;
101 >    MAW* maw_;
102 >    
103 >    map<int, AtomType*> typeMap_;
104      /**
105       * Each pair of atom types can have multiple interactions, so the
106       * natural data structures are a map between the pair, and a set
107       * of non-bonded interactions.
108       */
109 <    static map<pair<AtomType*, AtomType*>, set<NonBondedInteraction*> > interactions_;
141 <    
142 <
109 >    map<pair<AtomType*, AtomType*>, set<NonBondedInteraction*> > interactions_;    
110    };
111   }
112   #endif

Diff Legend

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