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 1877 by gezelter, Thu Jun 6 15:43:35 2013 UTC

# Line 35 | Line 35
35   *                                                                      
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).                        
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
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 +  const static int ELECTROSTATIC_PAIR  = (1 << 0);  
64 +  const static int LJ_PAIR             = (1 << 1);
65 +  const static int EAM_PAIR            = (1 << 2);
66 +  const static int SC_PAIR             = (1 << 3);
67 +  const static int STICKY_PAIR         = (1 << 4);
68 +  const static int GB_PAIR             = (1 << 5);
69 +  const static int MORSE_PAIR          = (1 << 6);
70 +  const static int REPULSIVEPOWER_PAIR = (1 << 7);
71 +  const static int MAW_PAIR            = (1 << 8);
72 +
73    /**
74 <   * @class InteractionManager InteractionManager is responsible for
75 <   * keeping track of the non-bonded interactions (C++) and providing
76 <   * an interface to the low-level loop (Fortran).
74 >   * @class InteractionManager
75 >   * InteractionManager is responsible for
76 >   * keeping track of the non-bonded interactions (C++)
77     */
78    class InteractionManager {
79  
80    public:
81 <    static InteractionManager* Instance();
82 <    static void setForceField(ForceField *ff) {forceField_ = ff;};    
81 >    InteractionManager();
82 >    virtual ~InteractionManager();
83 >    void setSimInfo(SimInfo* info) {info_ = info;}
84 >    void initialize();
85  
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 –
86      // Fortran support routines
87  
88 <    static void do_prepair(int *atid1, int *atid2, RealType *rij, RealType *rho_i_at_j, RealType *rho_j_at_i);
89 <    static void do_preforce(int *atid, RealType *rho, RealType *frho, RealType *dfrhodrho);
90 <    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);    
91 <    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);
92 <    static void do_self_correction(int *atid, RealType *eFrame, RealType *skippedCharge, RealType *pot, RealType *t);
93 <  
88 >    void doPrePair(InteractionData idat);
89 >    void doPreForce(SelfData sdat);
90 >    void doPair(InteractionData idat);    
91 >    void doSkipCorrection(InteractionData idat);
92 >    void doSelfCorrection(SelfData sdat);
93 >    void setCutoffRadius(RealType rCut);
94 >    RealType getSuggestedCutoffRadius(int *atid1);  
95 >    RealType getSuggestedCutoffRadius(AtomType *atype);
96      
97    private:
98 <    virtual ~InteractionManager() { }
116 <    // singleton pattern, prevent reconstruction
117 <    InteractionManager() { }
118 <    InteractionManager(InteractionManager const&) {};
119 <    InteractionManager& operator=(InteractionManager const&) {};
120 <    static InteractionManager* _instance;
98 >    bool initialized_;
99  
100 <    static void initialize();
123 <    static bool initialized_;
100 >    void setupElectrostatics();
101  
102 <    static ForceField* forceField_;
103 <    static LJ* lj_;
104 <    static GB* gb_;
105 <    static Sticky* sticky_;
106 <    static EAM* eam_;
107 <    static SC* sc_;
108 <    static Morse* morse_;
109 <    static Electrostatic* electrostatic_;
110 <
111 <    static map<int, AtomType*> typeMap_;
102 >    SimInfo* info_;
103 >    LJ* lj_;
104 >    GB* gb_;
105 >    Sticky* sticky_;
106 >    EAM* eam_;
107 >    SC* sc_;
108 >    Morse* morse_;
109 >    Electrostatic* electrostatic_;
110 >    RepulsivePower* repulsivePower_;
111 >    MAW* maw_;
112 >    
113 >    map<int, AtomType*> typeMap_;
114      /**
115       * Each pair of atom types can have multiple interactions, so the
116       * natural data structures are a map between the pair, and a set
117       * of non-bonded interactions.
118       */
119 <    static map<pair<AtomType*, AtomType*>, set<NonBondedInteraction*> > interactions_;
120 <    
119 >    map<pair<AtomType*, AtomType*>, set<NonBondedInteraction*> > interactions_;
120 >    map<pair<AtomType*, AtomType*>, int> iHash_;
121  
122    };
123   }

Diff Legend

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