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 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
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).                        
40   */
41  
42   /**
# Line 53 | Line 53
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 + #include "types/InversionType.hpp"
67 + #include "types/NonBondedInteractionType.hpp"
68   #include "UseTheForce/fForceOptions.h"
69 < namespace oopse {
69 > namespace OpenMD {
70  
71    /**
72     * @class ForceField ForceField.hpp ''UseTheForce/ForceField.hpp"
# Line 76 | Line 80 | namespace oopse {
80      typedef TypeContainer<BondType, 2> BondTypeContainer;
81      typedef TypeContainer<BendType, 3> BendTypeContainer;
82      typedef TypeContainer<TorsionType, 4> TorsionTypeContainer;
83 <        
83 >    typedef TypeContainer<InversionType, 4> InversionTypeContainer;
84 >    typedef TypeContainer<NonBondedInteractionType, 2> NonBondedInteractionTypeContainer;
85 >    
86      ForceField();
87 <
87 >    
88      virtual ~ForceField();
89  
90      std::string getForceFieldFileName() {
# Line 97 | Line 103 | namespace oopse {
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 <
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);
# Line 105 | Line 116 | namespace oopse {
116                                       const std::string &at2,
117                                       const std::string &at3,
118                                       const std::string &at4);
119 <
120 <
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 <
129 >    
130      std::string getWildCard() {
131        return wildCardAtomTypeName_;
132      }
133 <
133 >    
134      void setWildCard(const std::string& wildCard) {
135        wildCardAtomTypeName_ = wildCard;
136      }
137 <
122 <
137 >    
138      unsigned int getNAtomType() {
139        return atomTypeCont_.size();
140      }
141          
142      bool addAtomType(const std::string &at, AtomType* atomType);
143  
144 +    bool replaceAtomType(const std::string &at, AtomType* atomType);
145 +
146      bool addBondType(const std::string &at1, const std::string &at2,
147                       BondType* bondType);
148  
# Line 133 | Line 150 | namespace oopse {
150                       const std::string &at3, BendType* bendType);
151  
152      bool addTorsionType(const std::string &at1, const std::string &at2,
153 <                        const std::string &at3, const std::string &at4, TorsionType* torsionType);
153 >                        const std::string &at3, const std::string &at4,
154 >                        TorsionType* torsionType);
155  
156 +    bool addInversionType(const std::string &at1, const std::string &at2,
157 +                          const std::string &at3, const std::string &at4,
158 +                          InversionType* inversionType);
159 +    
160 +    bool addNonBondedInteractionType(const std::string &at1,
161 +                                     const std::string &at2,
162 +                                     NonBondedInteractionType* nbiType);
163 +    
164      ifstrstream* openForceFieldFile(const std::string& filename);
165 <
165 >    
166      ForceFieldOptions& getForceFieldOptions() {return forceFieldOptions_;}
167  
168      void setFortranForceOptions(void);
169 +
170 +
171    protected:
172  
173      AtomTypeContainer atomTypeCont_;    
174      BondTypeContainer bondTypeCont_;
175      BendTypeContainer bendTypeCont_;
176      TorsionTypeContainer torsionTypeCont_;
177 +    InversionTypeContainer inversionTypeCont_;
178 +    NonBondedInteractionTypeContainer nonBondedInteractionTypeCont_;
179      ForceFieldOptions forceFieldOptions_;
180      
181    private:  
182      std::string ffPath_;
183 <
183 >    
184      std::string wildCardAtomTypeName_;
185 <
186 <    std::string forceFieldFileName_;
185 >    
186 >    std::string forceFieldFileName_;    
187 >    
188    };
189 <
159 <
160 < }//end namespace oopse
189 > }//end namespace OpenMD
190   #endif
191  

Diff Legend

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