ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/minimizers/Minimizer.hpp

Comparing:
trunk/src/minimizers/Minimizer.hpp (file contents), Revision 258 by tim, Fri Jan 14 01:04:57 2005 UTC vs.
branches/development/src/minimizers/Minimizer.hpp (file contents), Revision 1744 by gezelter, Tue Jun 5 18:07:08 2012 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 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]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43	<	#ifndef MINIMIZERS_OOPSEMINIMIZER_HPP
44	<	#define MINIMIZERS_OOPSEMINIMIZER_HPP
43	>	#ifndef MINIMIZERS_MINIMIZER_HPP
44	>	#define MINIMIZERS_MINIMIZER_HPP
45
46		#include <iostream>
47
#	Line 51 | Line 52
52
53		// base class of minimizer
54
55	<	namespace oopse {
55	>	namespace OpenMD {
56	>
57	>	/** minimizer stop codes */
58	>	enum{MIN_MAXITER,
59	>	MIN_MAXEVAL,
60	>	MIN_ETOL,
61	>	MIN_FTOL,
62	>	MIN_DOWNHILL,
63	>	MIN_ZEROALPHA,
64	>	MIN_ZEROFORCE,
65	>	MIN_ZEROQUAD};
66	>
67	>	typedef int (*FnPtr)(std::vector<RealType> &, std::vector<RealType> &, RealType &);
68
69	<	/** @todo need refactorying */
70	<	const int MIN_LSERROR = -1;
71	<	const int MIN_MAXITER = 0;
72	<	const int MIN_CONVERGE = 1;
69	>	/**
70	>	* @class Minimizer
71	>	* base minimizer class
72	>	*/
73	>	class Minimizer {
74	>	public:
75	>	Minimizer(SimInfo *rhs);
76	>	virtual ~Minimizer();
77	>	virtual void init() {}
78	>	//driver function of minimization method
79	>	virtual void minimize();
80	>	virtual int step() = 0;
81	>	virtual void prepareStep() {};
82
83	<	const int CONVG_UNCONVG = 0;
84	<	const int CONVG_FTOL = 1;
85	<	const int CONVG_GTOL = 2;
86	<	const int CONVG_ABSGTOL = 3;
65	<	const int CONVG_STEPTOL = 4;
83	>	//line search algorithm, for the time being, we use a back track
84	>	//algorithm
85	>	virtual int doLineSearch(std::vector<RealType>& direction, RealType stepSize);
86	>	virtual int checkConvergence() = 0;
87
88	<	const int LS_SUCCEED =1;
89	<	const int LS_ERROR  = -1;
88	>	//save the result when minimization method is done
89	>	virtual void saveResult(){}
90	>
91	>	//get the status of minimization
92	>	int getMinimizerStatus() {return minStatus;}
93
94	<	/** @todo move to math module */
95	<	double dotProduct(const std::vector<double>& v1, const std::vector<double>& v2);
94	>	// get the dimension of the model
95	>	int getDim() {  return ndim;  }
96
97	<	/**
98	<	* @class Minimizer
75	<	* base minimizer class
76	<	*/
77	<	class Minimizer {
78	<	public:
97	>	//get the name of minimizer method
98	>	std::string getMinimizerName() {  return minimizerName;  }
99
100	<	Minimizer(SimInfo *rhs);
100	>	//return number of the current Iteration
101	>	int getCurrentIteration() {  return curIter;  }
102
103	<	virtual ~Minimizer();
103	>	// set the verbose mode of minimizer
104	>	void setVerbose(bool verbose) {  bVerbose = verbose;}
105
106	<	//
107	<	virtual void init() {}
106	>	//get and set the coordinates
107	>	std::vector<RealType> getX() {  return curX;  }
108	>	void setX(std::vector<RealType>& x);
109
110	<	//driver function of minimization method
111	<	virtual void minimize();
110	>	//get and set the value of object function
111	>	RealType getF() {  return curF;  }
112	>	void setF(RealType f)  { curF = f;  }
113
114	<	//
115	<	virtual int step() = 0;
114	>	std::vector<RealType> getG() {  return curG;  }
115	>	void setG(std::vector<RealType>& g);
116
117	<	//
118	<	virtual void prepareStep() {};
117	>	//get and set the gradient
118	>	std::vector<RealType> getGrad() {  return curG;  }
119	>	void setGrad(std::vector<RealType>& g) {  curG = g;  }
120
121	<	//line search algorithm, for the time being, we use back track algorithm
97	<	virtual int doLineSearch(std::vector<double>& direction, double stepSize);
121	>	void setGradientFunction(FnPtr efunc) { calcEnergyGradient = efunc; }
122
123	<	virtual int checkConvg() = 0;
123	>	//calculate the value of object function
124	>	virtual void calcF();
125	>	virtual void calcF(std::vector<RealType>& x, RealType&f, int& status);
126
127	<	//save the result when minimization method is done
128	<	virtual void saveResult(){}
127	>	//calculate the gradient
128	>	virtual void calcG();
129	>	virtual void calcG(std::vector<RealType>& x,  std::vector<RealType>& g, RealType& f, int& status);
130
131	<	//get the status of minimization
132	<	int getMinStatus() {return minStatus;}
131	>	//calculate the hessian
132	>	//virtual void calcH(int& status);
133	>	//virtual void calcH(vector<RealType>& x,  std::vector<dobule>& g, SymMatrix& h, int& status);
134
135	<	// get the dimension of the model
108	<	int getDim() {  return ndim;  }
135	>	friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);
136
137	<	//get the name of minimizer method
111	<	std::string getMinimizerName() {  return minimizerName;  }
137	>	protected:
138
139	<	//return number of  current Iteration
140	<	int getCurIter() {  return curIter;  }
139	>	typedef int (*FnPtr)(std::vector<RealType> &, std::vector<RealType> &, RealType &);
140	>	FnPtr calcEnergyGradient;
141
142	<	// set the verbose mode of minimizer
143	<	void setVerbose(bool verbose) {  bVerbose = verbose;}
142	>	// transfrom cartesian and rotational coordinates into minimization coordinates
143	>	std::vector<RealType> getCoor();
144
145	<	//get and set the coordinate
146	<	std::vector<double> getX() {  return curX;  }
121	<	void setX(std::vector<double>& x);
145	>	// transfrom minimization coordinates into cartesian and rotational coordinates
146	>	void setCoor(std::vector<RealType>& x);
147
148	<	//get and set the value of object function
149	<	double getF() {  return curF;  }
125	<	void setF(double f)  { curF = f;  }
148	>	//constraint the bonds;
149	>	int shakeR() { return 0;}
150
151	<	std::vector<double> getG() {  return curG;  }
152	<	void setG(std::vector<double>& g);
153	<
130	<	//get and set the gradient
131	<	std::vector<double> getGrad() {  return curG;  }
132	<	void setGrad(std::vector<double>& g) {  curG = g;  }
133	<
134	<	//interal function to evaluate the energy and gradient in OOPSE
135	<	void calcEnergyGradient(std::vector<double>& x,  std::vector<double>& grad, double&
136	<	energy, int& status);
137	<
138	<	//calculate the value of object function
139	<	virtual void calcF();
140	<	virtual void calcF(std::vector<double>& x, double&f, int& status);
141	<
142	<	//calculate the gradient
143	<	virtual void calcG();
144	<	virtual void calcG(std::vector<double>& x,  std::vector<double>& g, double& f, int& status);
145	<
146	<	//calculate the hessian
147	<	//virtual void calcH(int& status);
148	<	//virtual void calcH(vector<double>& x,  std::vector<dobule>& g, SymMatrix& h, int& status);
149	<
150	<	friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);
151	<
152	<	protected:
153	<
154	<	// transfrom cartesian and rotational coordinates into minimization coordinates
155	<	std::vector<double> getCoor();
156	<
157	<	// transfrom minimization coordinates into cartesian and rotational coordinates
158	<	void setCoor(std::vector<double>& x);
159	<
160	<
161	<
162	<	//constraint the bonds;
163	<	int shakeR() { return 0;}
164	<
165	<	//remove the force component along the bond direction
166	<	int shakeF() { return 0;}
167	<
168	<	double calcPotential();
151	>	//remove the force component along the bond direction
152	>	int shakeF() { return 0;}
153	>	RealType calcPotential();
154
155	<	SimInfo* info;
155	>	SimInfo* info;
156	>	ForceManager* forceMan;
157	>	//parameter set of minimization method
158	>	MinimizerParameterSet* paramSet;
159
160	<	ForceManager* forceMan;
160	>	//flag of turning on shake algorithm
161	>	bool usingShake;
162
163	<	//parameter set of minimization method
164	<	MinimizerParameterSet* paramSet;
163	>	// dimension of the model
164	>	int ndim;
165
166	<	//flag of turning on shake algorithm
167	<	bool usingShake;
179	<
180	<	// dimension of the model
181	<	int ndim;
166	>	//name of the minimizer
167	>	std::string minimizerName;
168
169	<	//name of the minimizer
170	<	std::string minimizerName;
169	>	// current iteration number
170	>	int curIter;
171	>	//status of minimization
172	>	int minStatus;
173
174	<	// current iteration number
175	<	int curIter;
188	<	//status of minimization
189	<	int minStatus;
174	>	//flag of verbose mode
175	>	bool bVerbose;
176
177	<	//flag of verbose mode
178	<	bool bVerbose;
177	>	//status of energy and gradient evaluation
178	>	int egEvalStatus;
179
180	<	//status of energy and gradient evaluation
181	<	int egEvalStatus;
180	>	//initial coordinates
181	>	//vector<RealType> initX;
182
183	<	//initial coordinates
184	<	//vector<double> initX;
199	<
200	<	//current value  of the function
201	<	double curF;
183	>	//current value  of the function
184	>	RealType curF;
185
186	<	// current coordinates
187	<	std::vector<double> curX;
186	>	// current coordinates
187	>	std::vector<RealType> curX;
188
189	<	//gradient at curent coordinates
190	<	std::vector<double> curG;
189	>	//gradient at curent coordinates
190	>	std::vector<RealType> curG;
191
192	<	//hessian at current coordinates
193	<	//SymMatrix curH;
192	>	//hessian at current coordinates
193	>	//SymMatrix curH;
194
195	<	private:
195	>	private:
196	>	//calculate the dimension of the model for minimization
197	>	void calcDim();
198	>	};
199
214	–	//calculate the dimension od the model for minimization
215	–	void calcDim();
216	–
217	–	};
218	–
200		}
201		#endif
202

Comparing:
trunk/src/minimizers/Minimizer.hpp (property svn:keywords), Revision 258 by tim, Fri Jan 14 01:04:57 2005 UTC vs.
branches/development/src/minimizers/Minimizer.hpp (property svn:keywords), Revision 1744 by gezelter, Tue Jun 5 18:07:08 2012 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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