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

Comparing trunk/src/UseTheForce/ForceField.hpp (file contents):
Revision 475 by tim, Tue Apr 12 18:30:37 2005 UTC vs.
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 39 | Line 39
39   * such damages.
40   */
41  
42 < /**
43 <  * @file ForceField.hpp
44 <  * @author tlin
45 <  * @date 11/04/2004
46 <  * @time 22:51am
47 <  * @version 1.0
48 <  */
42 > /**
43 > * @file ForceField.hpp
44 > * @author tlin
45 > * @date 11/04/2004
46 > * @time 22:51am
47 > * @version 1.0
48 > */
49    
50   #ifndef USETHEFORCE_FORCEFIELD_HPP
51   #define USETHEFORCE_FORCEFIELD_HPP
52  
53 < #define MK_STR(s) # s
54 < #define STR_DEFINE(t, s) t = MK_STR(s)
55 <
53 > #include "config.h"
54   #include <string>
55   #include <utility>
56 + #include <vector>
57  
58   #include "io/basic_ifstrstream.hpp"
59 + #include "io/ForceFieldOptions.hpp"
60   #include "utils/TypeContainer.hpp"
61 + #include "utils/Tuple.hpp"
62   #include "types/AtomType.hpp"
63   #include "types/BondType.hpp"
64   #include "types/BendType.hpp"
65   #include "types/TorsionType.hpp"
66 <
66 > #include "types/InversionType.hpp"
67 > #include "types/NonBondedInteractionType.hpp"
68 > #include "UseTheForce/fForceOptions.h"
69   namespace oopse {
70  
71 < /**
72 < * @class ForceField ForceField.hpp ''UseTheForce/ForceField.hpp"
73 < * @brief
74 < */
75 < class ForceField{
71 >  /**
72 >   * @class ForceField ForceField.hpp ''UseTheForce/ForceField.hpp"
73 >   * @brief
74 >   */
75 >  class ForceField{
76  
77 <    public:
77 >  public:
78  
79 <        typedef TypeContainer<AtomType, 1> AtomTypeContainer;
80 <        typedef TypeContainer<BondType, 2> BondTypeContainer;
81 <        typedef TypeContainer<BendType, 3> BendTypeContainer;
82 <        typedef TypeContainer<TorsionType, 4> TorsionTypeContainer;
83 <        
84 <        ForceField();
79 >    typedef TypeContainer<AtomType, 1> AtomTypeContainer;
80 >    typedef TypeContainer<BondType, 2> BondTypeContainer;
81 >    typedef TypeContainer<BendType, 3> BendTypeContainer;
82 >    typedef TypeContainer<TorsionType, 4> TorsionTypeContainer;
83 >    typedef TypeContainer<InversionType, 4> InversionTypeContainer;
84 >    typedef TypeContainer<NonBondedInteractionType, 2> NonBondedInteractionTypeContainer;
85 >    
86 >    ForceField();
87 >    
88 >    virtual ~ForceField();
89  
90 <        virtual ~ForceField();
90 >    std::string getForceFieldFileName() {
91 >      return forceFieldFileName_;
92 >    }
93  
94 <        std::string getForceFieldFileName() {
95 <            return forceFieldFileName_;
96 <        }
88 <
89 <        void setForceFieldFileName(const std::string& filename) {
90 <            forceFieldFileName_ = filename;
91 <        }
94 >    void setForceFieldFileName(const std::string& filename) {
95 >      forceFieldFileName_ = filename;
96 >    }
97          
98 <        virtual void parse(const std::string& filename) = 0;  
98 >    virtual void parse(const std::string& filename) = 0;  
99  
100 <        AtomType* getAtomType(const std::string &at);
101 <        BondType* getBondType(const std::string &at1, const std::string &at2);
102 <        BendType* getBendType(const std::string &at1, const std::string &at2,
103 <                                    const std::string &at3);
104 <        TorsionType* getTorsionType(const std::string &at1, const std::string &at2,
105 <                                          const std::string &at3, const std::string &at4);
106 <
107 <        BondType* getExactBondType(const std::string &at1, const std::string &at2);
108 <        BendType* getExactBendType(const std::string &at1, const std::string &at2,
109 <                                    const std::string &at3);
110 <        TorsionType* getExactTorsionType(const std::string &at1, const std::string &at2,
111 <                                          const std::string &at3, const std::string &at4);
112 <
113 <
114 <        //avoid make virtual function public
115 <        //Herb Sutter and Andrei Alexandrescu, C++ coding Standards, Addision-Wesley
116 <        virtual double getRcutFromAtomType(AtomType* at);
117 <
118 <        std::string getWildCard() {
119 <            return wildCardAtomTypeName_;
120 <        }
121 <
122 <        void setWildCard(const std::string& wildCard) {
123 <            wildCardAtomTypeName_ = wildCard;
124 <        }
125 <
126 <
127 <        unsigned int getNAtomType() {
128 <            return atomTypeCont_.size();
129 <        }
100 >    AtomType* getAtomType(const std::string &at);
101 >    BondType* getBondType(const std::string &at1, const std::string &at2);
102 >    BendType* getBendType(const std::string &at1, const std::string &at2,
103 >                          const std::string &at3);
104 >    TorsionType* getTorsionType(const std::string &at1, const std::string &at2,
105 >                                const std::string &at3, const std::string &at4);
106 >    InversionType* getInversionType(const std::string &at1,
107 >                                    const std::string &at2,
108 >                                    const std::string &at3,
109 >                                    const std::string &at4);
110 >    NonBondedInteractionType* getNonBondedInteractionType(const std::string &at1, const std::string &at2);
111 >    
112 >    BondType* getExactBondType(const std::string &at1, const std::string &at2);
113 >    BendType* getExactBendType(const std::string &at1, const std::string &at2,
114 >                               const std::string &at3);
115 >    TorsionType* getExactTorsionType(const std::string &at1,
116 >                                     const std::string &at2,
117 >                                     const std::string &at3,
118 >                                     const std::string &at4);
119 >    InversionType* getExactInversionType(const std::string &at1,
120 >                                         const std::string &at2,
121 >                                         const std::string &at3,
122 >                                         const std::string &at4);
123 >    NonBondedInteractionType* getExactNonBondedInteractionType(const std::string &at1, const std::string &at2);
124 >    
125 >    
126 >    //avoid make virtual function public
127 >    //Herb Sutter and Andrei Alexandrescu, C++ coding Standards, Addision-Wesley
128 >    virtual RealType getRcutFromAtomType(AtomType* at);
129 >    
130 >    std::string getWildCard() {
131 >      return wildCardAtomTypeName_;
132 >    }
133 >    
134 >    void setWildCard(const std::string& wildCard) {
135 >      wildCardAtomTypeName_ = wildCard;
136 >    }
137 >    
138 >    unsigned int getNAtomType() {
139 >      return atomTypeCont_.size();
140 >    }
141          
142 <        bool addAtomType(const std::string &at, AtomType* atomType);
142 >    bool addAtomType(const std::string &at, AtomType* atomType);
143  
144 <        bool addBondType(const std::string &at1, const std::string &at2, BondType* bondType);
144 >    bool addBondType(const std::string &at1, const std::string &at2,
145 >                     BondType* bondType);
146  
147 <        bool addBendType(const std::string &at1, const std::string &at2,
148 <                                    const std::string &at3, BendType* bendType);
147 >    bool addBendType(const std::string &at1, const std::string &at2,
148 >                     const std::string &at3, BendType* bendType);
149  
150 <        bool addTorsionType(const std::string &at1, const std::string &at2,
151 <                                          const std::string &at3, const std::string &at4, TorsionType* torsionType);
150 >    bool addTorsionType(const std::string &at1, const std::string &at2,
151 >                        const std::string &at3, const std::string &at4,
152 >                        TorsionType* torsionType);
153  
154 <        ifstrstream* openForceFieldFile(const std::string& filename);
154 >    bool addInversionType(const std::string &at1, const std::string &at2,
155 >                          const std::string &at3, const std::string &at4,
156 >                          InversionType* inversionType);
157 >    
158 >    bool addNonBondedInteractionType(const std::string &at1,
159 >                                     const std::string &at2,
160 >                                     NonBondedInteractionType* nbiType);
161 >    
162 >    ifstrstream* openForceFieldFile(const std::string& filename);
163 >    
164 >    ForceFieldOptions& getForceFieldOptions() {return forceFieldOptions_;}
165  
166 <    protected:
166 >    void setFortranForceOptions(void);
167  
140 –        AtomTypeContainer atomTypeCont_;    
141 –        BondTypeContainer bondTypeCont_;
142 –        BendTypeContainer bendTypeCont_;
143 –        TorsionTypeContainer torsionTypeCont_;
144 –        
145 –    private:  
146 –        std::string ffPath_;
147 –
148 –        std::string wildCardAtomTypeName_;
149 –
150 –        std::string forceFieldFileName_;
151 – };
152 –
168  
169 +  protected:
170 +
171 +    AtomTypeContainer atomTypeCont_;    
172 +    BondTypeContainer bondTypeCont_;
173 +    BendTypeContainer bendTypeCont_;
174 +    TorsionTypeContainer torsionTypeCont_;
175 +    InversionTypeContainer inversionTypeCont_;
176 +    NonBondedInteractionTypeContainer nonBondedInteractionTypeCont_;
177 +    ForceFieldOptions forceFieldOptions_;
178 +    
179 +  private:  
180 +    std::string ffPath_;
181 +    
182 +    std::string wildCardAtomTypeName_;
183 +    
184 +    std::string forceFieldFileName_;    
185 +    
186 +  };
187   }//end namespace oopse
188   #endif
189  

Diff Legend

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