src/brains/ForceField.hpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */
 
/**
 * @file ForceField.hpp
 * @author tlin
 * @date 11/04/2004
 * @time 22:51am
 * @version 1.0
 */
  
#ifndef USETHEFORCE_FORCEFIELD_HPP
#define USETHEFORCE_FORCEFIELD_HPP

#include "config.h"
#include <string>
#include <utility>
#include <vector>

#include "io/ifstrstream.hpp"
#include "io/ForceFieldOptions.hpp"
#include "io/SectionParserManager.hpp"
#include "utils/TypeContainer.hpp"
#include "utils/Tuple.hpp"
#include "types/AtomType.hpp"
#include "types/BondType.hpp"
#include "types/BendType.hpp"
#include "types/TorsionType.hpp"
#include "types/InversionType.hpp"
#include "types/NonBondedInteractionType.hpp"

namespace OpenMD {

  class ForceField{

  public:
    typedef TypeContainer<AtomType, 1> AtomTypeContainer;
    typedef TypeContainer<BondType, 2> BondTypeContainer;
    typedef TypeContainer<BendType, 3> BendTypeContainer;
    typedef TypeContainer<TorsionType, 4> TorsionTypeContainer;
    typedef TypeContainer<InversionType, 4> InversionTypeContainer;
    typedef TypeContainer<NonBondedInteractionType, 2> NonBondedInteractionTypeContainer;
    
    ForceField(std::string ffName);
    
    virtual ~ForceField() {};

    std::string getForceFieldFileName() {
      return forceFieldFileName_;
    }

    void setForceFieldFileName(const std::string& filename) {
      forceFieldFileName_ = filename;
    }
        
    virtual void parse(const std::string& filename);  

    AtomType* getAtomType(const std::string &at);
    AtomType* getAtomType(int ident);
    BondType* getBondType(const std::string &at1, const std::string &at2);
    BendType* getBendType(const std::string &at1, const std::string &at2,
                          const std::string &at3);
    TorsionType* getTorsionType(const std::string &at1, const std::string &at2,
                                const std::string &at3, const std::string &at4);
    InversionType* getInversionType(const std::string &at1, 
                                    const std::string &at2,
                                    const std::string &at3, 
                                    const std::string &at4);
    NonBondedInteractionType* getNonBondedInteractionType(const std::string &at1, const std::string &at2);
    
    BondType* getExactBondType(const std::string &at1, const std::string &at2);
    BendType* getExactBendType(const std::string &at1, const std::string &at2,
                               const std::string &at3);
    TorsionType* getExactTorsionType(const std::string &at1, 
                                     const std::string &at2,
                                     const std::string &at3, 
                                     const std::string &at4);
    InversionType* getExactInversionType(const std::string &at1, 
                                         const std::string &at2,
                                         const std::string &at3, 
                                         const std::string &at4);
    NonBondedInteractionType* getExactNonBondedInteractionType(const std::string &at1, const std::string &at2);
    
    
    //avoid make virtual function public
    //Herb Sutter and Andrei Alexandrescu, C++ coding Standards, Addision-Wesley
    virtual RealType getRcutFromAtomType(AtomType* at);
    
    std::string getWildCard() {
      return wildCardAtomTypeName_;
    }
    
    void setWildCard(const std::string& wildCard) {
      wildCardAtomTypeName_ = wildCard;
    }
    
    unsigned int getNAtomType() {
      return atomTypeCont_.size();
    }

    AtomTypeContainer* getAtomTypes() {
      return &atomTypeCont_;
    }
    
    NonBondedInteractionTypeContainer* getNonBondedInteractionTypes() {
      return &nonBondedInteractionTypeCont_;
    }
        
    bool addAtomType(const std::string &at, AtomType* atomType);

    bool replaceAtomType(const std::string &at, AtomType* atomType);

    bool addBondType(const std::string &at1, const std::string &at2, 
                     BondType* bondType);

    bool addBendType(const std::string &at1, const std::string &at2,
                     const std::string &at3, BendType* bendType);

    bool addTorsionType(const std::string &at1, const std::string &at2,
                        const std::string &at3, const std::string &at4, 
                        TorsionType* torsionType);

    bool addInversionType(const std::string &at1, const std::string &at2,
                          const std::string &at3, const std::string &at4,
                          InversionType* inversionType);
    
    bool addNonBondedInteractionType(const std::string &at1, 
                                     const std::string &at2, 
                                     NonBondedInteractionType* nbiType);
    
    ifstrstream* openForceFieldFile(const std::string& filename);
    
    ForceFieldOptions& getForceFieldOptions() {return forceFieldOptions_;}

  protected:

    AtomTypeContainer atomTypeCont_;    
    BondTypeContainer bondTypeCont_;
    BendTypeContainer bendTypeCont_;
    TorsionTypeContainer torsionTypeCont_;
    InversionTypeContainer inversionTypeCont_;
    NonBondedInteractionTypeContainer nonBondedInteractionTypeCont_;
    ForceFieldOptions forceFieldOptions_;
    std::map<int, std::string> atypeIdentToName;
    SectionParserManager spMan_;

    
  private:  
    std::string ffPath_;    
    std::string wildCardAtomTypeName_;    
    std::string forceFieldFileName_;    
    
  };
}//end namespace OpenMD
#endif

Revision:	1725
Committed:	Sat May 26 18:13:43 2012 UTC (12 years, 11 months ago) by gezelter
File size:	7272 byte(s)
Log Message:	Individual ForceField classes have been removed (they were essentially all duplicates anyway). ForceField has moved to brains, and since only one force field is in play at any time, the ForceFieldFactory and Register methods have been removed.
#	User	Rev	Content
1	gezelter	507	/*
2	gezelter	246	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9	gezelter	1390	* 1. Redistributions of source code must retain the above copyright
10	gezelter	246	* notice, this list of conditions and the following disclaimer.
11			*
12	gezelter	1390	* 2. Redistributions in binary form must reproduce the above copyright
13	gezelter	246	* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the
15			* distribution.
16			*
17			* This software is provided "AS IS," without a warranty of any
18			* kind. All express or implied conditions, representations and
19			* warranties, including any implied warranty of merchantability,
20			* fitness for a particular purpose or non-infringement, are hereby
21			* excluded. The University of Notre Dame and its licensors shall not
22			* be liable for any damages suffered by licensee as a result of
23			* using, modifying or distributing the software or its
24			* derivatives. In no event will the University of Notre Dame or its
25			* licensors be liable for any lost revenue, profit or data, or for
26			* direct, indirect, special, consequential, incidental or punitive
27			* damages, however caused and regardless of the theory of liability,
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	gezelter	1390	*
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	gezelter	1665	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	gezelter	246	*/
42
43	gezelter	507	/**
44			* @file ForceField.hpp
45			* @author tlin
46			* @date 11/04/2004
47			* @time 22:51am
48			* @version 1.0
49			*/
50	gezelter	246
51	gezelter	206	#ifndef USETHEFORCE_FORCEFIELD_HPP
52			#define USETHEFORCE_FORCEFIELD_HPP
53
54	gezelter	762	#include "config.h"
55	gezelter	246	#include <string>
56			#include <utility>
57	gezelter	1269	#include <vector>
58	gezelter	206
59	gezelter	1627	#include "io/ifstrstream.hpp"
60	tim	749	#include "io/ForceFieldOptions.hpp"
61	gezelter	1725	#include "io/SectionParserManager.hpp"
62	gezelter	246	#include "utils/TypeContainer.hpp"
63	gezelter	1269	#include "utils/Tuple.hpp"
64	gezelter	246	#include "types/AtomType.hpp"
65			#include "types/BondType.hpp"
66			#include "types/BendType.hpp"
67			#include "types/TorsionType.hpp"
68	cli2	1275	#include "types/InversionType.hpp"
69	chuckv	1151	#include "types/NonBondedInteractionType.hpp"
70	gezelter	1725
71	gezelter	1390	namespace OpenMD {
72	gezelter	206
73	gezelter	507	class ForceField{
74	gezelter	206
75	gezelter	507	public:
76			typedef TypeContainer<AtomType, 1> AtomTypeContainer;
77			typedef TypeContainer<BondType, 2> BondTypeContainer;
78			typedef TypeContainer<BendType, 3> BendTypeContainer;
79			typedef TypeContainer<TorsionType, 4> TorsionTypeContainer;
80	cli2	1275	typedef TypeContainer<InversionType, 4> InversionTypeContainer;
81			typedef TypeContainer<NonBondedInteractionType, 2> NonBondedInteractionTypeContainer;
82
83	gezelter	1725	ForceField(std::string ffName);
84	cli2	1275
85	gezelter	1535	virtual ~ForceField() {};
86	gezelter	206
87	gezelter	507	std::string getForceFieldFileName() {
88			return forceFieldFileName_;
89			}
90	gezelter	206
91	gezelter	507	void setForceFieldFileName(const std::string& filename) {
92			forceFieldFileName_ = filename;
93			}
94	gezelter	246
95	gezelter	1725	virtual void parse(const std::string& filename);
96	gezelter	206
97	gezelter	507	AtomType* getAtomType(const std::string &at);
98	gezelter	1535	AtomType* getAtomType(int ident);
99	gezelter	507	BondType* getBondType(const std::string &at1, const std::string &at2);
100			BendType* getBendType(const std::string &at1, const std::string &at2,
101	chrisfen	514	const std::string &at3);
102	gezelter	507	TorsionType* getTorsionType(const std::string &at1, const std::string &at2,
103	chrisfen	514	const std::string &at3, const std::string &at4);
104	cli2	1275	InversionType* getInversionType(const std::string &at1,
105			const std::string &at2,
106			const std::string &at3,
107			const std::string &at4);
108			NonBondedInteractionType* getNonBondedInteractionType(const std::string &at1, const std::string &at2);
109
110	gezelter	507	BondType* getExactBondType(const std::string &at1, const std::string &at2);
111			BendType* getExactBendType(const std::string &at1, const std::string &at2,
112	chrisfen	514	const std::string &at3);
113			TorsionType* getExactTorsionType(const std::string &at1,
114			const std::string &at2,
115			const std::string &at3,
116			const std::string &at4);
117	cli2	1275	InversionType* getExactInversionType(const std::string &at1,
118			const std::string &at2,
119			const std::string &at3,
120			const std::string &at4);
121			NonBondedInteractionType* getExactNonBondedInteractionType(const std::string &at1, const std::string &at2);
122
123
124	gezelter	507	//avoid make virtual function public
125			//Herb Sutter and Andrei Alexandrescu, C++ coding Standards, Addision-Wesley
126	tim	963	virtual RealType getRcutFromAtomType(AtomType* at);
127	cli2	1275
128	gezelter	507	std::string getWildCard() {
129			return wildCardAtomTypeName_;
130			}
131	cli2	1275
132	gezelter	507	void setWildCard(const std::string& wildCard) {
133			wildCardAtomTypeName_ = wildCard;
134			}
135	cli2	1275
136	gezelter	507	unsigned int getNAtomType() {
137			return atomTypeCont_.size();
138			}
139	gezelter	1467
140	gezelter	1476	AtomTypeContainer* getAtomTypes() {
141			return &atomTypeCont_;
142	gezelter	1467	}
143
144	gezelter	1476	NonBondedInteractionTypeContainer* getNonBondedInteractionTypes() {
145			return &nonBondedInteractionTypeCont_;
146	gezelter	1467	}
147	gezelter	246
148	gezelter	507	bool addAtomType(const std::string &at, AtomType* atomType);
149	gezelter	246
150	gezelter	1282	bool replaceAtomType(const std::string &at, AtomType* atomType);
151
152	chrisfen	514	bool addBondType(const std::string &at1, const std::string &at2,
153			BondType* bondType);
154	gezelter	246
155	gezelter	507	bool addBendType(const std::string &at1, const std::string &at2,
156			const std::string &at3, BendType* bendType);
157	gezelter	246
158	gezelter	507	bool addTorsionType(const std::string &at1, const std::string &at2,
159	cli2	1275	const std::string &at3, const std::string &at4,
160			TorsionType* torsionType);
161	gezelter	246
162	cli2	1275	bool addInversionType(const std::string &at1, const std::string &at2,
163			const std::string &at3, const std::string &at4,
164			InversionType* inversionType);
165
166			bool addNonBondedInteractionType(const std::string &at1,
167			const std::string &at2,
168			NonBondedInteractionType* nbiType);
169
170	gezelter	507	ifstrstream* openForceFieldFile(const std::string& filename);
171	cli2	1275
172	tim	749	ForceFieldOptions& getForceFieldOptions() {return forceFieldOptions_;}
173	chuckv	821
174	gezelter	507	protected:
175	gezelter	246
176	gezelter	507	AtomTypeContainer atomTypeCont_;
177			BondTypeContainer bondTypeCont_;
178			BendTypeContainer bendTypeCont_;
179			TorsionTypeContainer torsionTypeCont_;
180	cli2	1275	InversionTypeContainer inversionTypeCont_;
181	chuckv	1151	NonBondedInteractionTypeContainer nonBondedInteractionTypeCont_;
182	tim	749	ForceFieldOptions forceFieldOptions_;
183	gezelter	1535	std::map<int, std::string> atypeIdentToName;
184	gezelter	1725	SectionParserManager spMan_;
185
186	tim	749
187	gezelter	507	private:
188	gezelter	1535	std::string ffPath_;
189			std::string wildCardAtomTypeName_;
190	cli2	1275	std::string forceFieldFileName_;
191
192	gezelter	507	};
193	gezelter	1390	}//end namespace OpenMD
194	gezelter	206	#endif
195