src/minimizers/Minimizer.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]  Vardeman & Gezelter, in progress (2009).                        
 */
 
#ifndef MINIMIZERS_MINIMIZER_HPP
#define MINIMIZERS_MINIMIZER_HPP

#include <iostream>

#include "io/DumpWriter.hpp"
#include "io/StatWriter.hpp"
#include "minimizers/MinimizerParameterSet.hpp"
#include "brains/ForceManager.hpp"

// base class of minimizer

namespace OpenMD {

  /** @todo need refactorying */
  const int MIN_LSERROR = -1;
  const int MIN_MAXITER = 0;
  const int MIN_CONVERGE = 1;

  const int CONVG_UNCONVG = 0;
  const int CONVG_FTOL = 1;
  const int CONVG_GTOL = 2;
  const int CONVG_ABSGTOL = 3;
  const int CONVG_STEPTOL = 4;

  const int LS_SUCCEED =1;
  const int LS_ERROR  = -1;

  /** @todo move to math module */
  RealType dotProduct(const std::vector<RealType>& v1, const std::vector<RealType>& v2);

  /**
   * @class Minimizer
   * base minimizer class
   */
  class Minimizer {
  public:

    Minimizer(SimInfo *rhs);

    virtual ~Minimizer();

    //
    virtual void init() {}

    //driver function of minimization method
    virtual void minimize();

    //
    virtual int step() = 0;

    //
    virtual void prepareStep() {};

    //line search algorithm, for the time being, we use back track algorithm
    virtual int doLineSearch(std::vector<RealType>& direction, RealType stepSize);

    virtual int checkConvg() = 0;

    //save the result when minimization method is done
    virtual void saveResult(){}

    //get the status of minimization
    int getMinStatus() {return minStatus;}

    // get the dimension of the model
    int getDim() {  return ndim;  }

    //get the name of minimizer method
    std::string getMinimizerName() {  return minimizerName;  }

    //return number of  current Iteration  
    int getCurIter() {  return curIter;  }

    // set the verbose mode of minimizer
    void setVerbose(bool verbose) {  bVerbose = verbose;}

    //get and set the coordinate
    std::vector<RealType> getX() {  return curX;  }
    void setX(std::vector<RealType>& x);

    //get and set the value of object function
    RealType getF() {  return curF;  }
    void setF(RealType f)  { curF = f;  }

    std::vector<RealType> getG() {  return curG;  }
    void setG(std::vector<RealType>& g);

    //get and set the gradient
    std::vector<RealType> getGrad() {  return curG;  }
    void setGrad(std::vector<RealType>& g) {  curG = g;  }

    //interal function to evaluate the energy and gradient in OpenMD
    void calcEnergyGradient(std::vector<RealType>& x,  std::vector<RealType>& grad, RealType&
                            energy, int& status);

    //calculate the value of object function
    virtual void calcF();
    virtual void calcF(std::vector<RealType>& x, RealType&f, int& status);

    //calculate the gradient
    virtual void calcG();
    virtual void calcG(std::vector<RealType>& x,  std::vector<RealType>& g, RealType& f, int& status);

    //calculate the hessian
    //virtual void calcH(int& status);
    //virtual void calcH(vector<RealType>& x,  std::vector<dobule>& g, SymMatrix& h, int& status);

    friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);

  protected:

    // transfrom cartesian and rotational coordinates into minimization coordinates 
    std::vector<RealType> getCoor();

    // transfrom minimization coordinates into cartesian and rotational coordinates  
    void setCoor(std::vector<RealType>& x);


    //constraint the bonds;
    int shakeR() { return 0;}

    //remove the force component along the bond direction
    int shakeF() { return 0;}

    RealType calcPotential();
        
    SimInfo* info;

    ForceManager* forceMan;
        
    //parameter set of minimization method
    MinimizerParameterSet* paramSet;

    //flag of turning on shake algorithm 
    bool usingShake;
        
    // dimension of the model
    int ndim;

    //name of the minimizer
    std::string minimizerName;

    // current iteration number
    int curIter;
    //status of minimization
    int minStatus;

    //flag of verbose mode
    bool bVerbose;

    //status of energy and gradient evaluation
    int egEvalStatus;

    //initial coordinates
    //vector<RealType> initX;

    //current value  of the function
    RealType curF;
        
    // current coordinates
    std::vector<RealType> curX;

    //gradient at curent coordinates
    std::vector<RealType> curG;

    //hessian at current coordinates
    //SymMatrix curH;

  private:

    //calculate the dimension od the model for minimization
    void calcDim();

  };

}
#endif

Revision:	1465
Committed:	Fri Jul 9 23:08:25 2010 UTC (14 years, 9 months ago) by chuckv
File size:	6571 byte(s)
Log Message:	Creating busticated version of OpenMD
#	Content
1	/*
2	* 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	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	*
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.
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	*
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	#ifndef MINIMIZERS_MINIMIZER_HPP
43	#define MINIMIZERS_MINIMIZER_HPP
44
45	#include <iostream>
46
47	#include "io/DumpWriter.hpp"
48	#include "io/StatWriter.hpp"
49	#include "minimizers/MinimizerParameterSet.hpp"
50	#include "brains/ForceManager.hpp"
51
52	// base class of minimizer
53
54	namespace OpenMD {
55
56	/** @todo need refactorying */
57	const int MIN_LSERROR = -1;
58	const int MIN_MAXITER = 0;
59	const int MIN_CONVERGE = 1;
60
61	const int CONVG_UNCONVG = 0;
62	const int CONVG_FTOL = 1;
63	const int CONVG_GTOL = 2;
64	const int CONVG_ABSGTOL = 3;
65	const int CONVG_STEPTOL = 4;
66
67	const int LS_SUCCEED =1;
68	const int LS_ERROR = -1;
69
70	/** @todo move to math module */
71	RealType dotProduct(const std::vector<RealType>& v1, const std::vector<RealType>& v2);
72
73	/**
74	* @class Minimizer
75	* base minimizer class
76	*/
77	class Minimizer {
78	public:
79
80	Minimizer(SimInfo *rhs);
81
82	virtual ~Minimizer();
83
84	//
85	virtual void init() {}
86
87	//driver function of minimization method
88	virtual void minimize();
89
90	//
91	virtual int step() = 0;
92
93	//
94	virtual void prepareStep() {};
95
96	//line search algorithm, for the time being, we use back track algorithm
97	virtual int doLineSearch(std::vector<RealType>& direction, RealType stepSize);
98
99	virtual int checkConvg() = 0;
100
101	//save the result when minimization method is done
102	virtual void saveResult(){}
103
104	//get the status of minimization
105	int getMinStatus() {return minStatus;}
106
107	// get the dimension of the model
108	int getDim() { return ndim; }
109
110	//get the name of minimizer method
111	std::string getMinimizerName() { return minimizerName; }
112
113	//return number of current Iteration
114	int getCurIter() { return curIter; }
115
116	// set the verbose mode of minimizer
117	void setVerbose(bool verbose) { bVerbose = verbose;}
118
119	//get and set the coordinate
120	std::vector<RealType> getX() { return curX; }
121	void setX(std::vector<RealType>& x);
122
123	//get and set the value of object function
124	RealType getF() { return curF; }
125	void setF(RealType f) { curF = f; }
126
127	std::vector<RealType> getG() { return curG; }
128	void setG(std::vector<RealType>& g);
129
130	//get and set the gradient
131	std::vector<RealType> getGrad() { return curG; }
132	void setGrad(std::vector<RealType>& g) { curG = g; }
133
134	//interal function to evaluate the energy and gradient in OpenMD
135	void calcEnergyGradient(std::vector<RealType>& x, std::vector<RealType>& grad, RealType&
136	energy, int& status);
137
138	//calculate the value of object function
139	virtual void calcF();
140	virtual void calcF(std::vector<RealType>& x, RealType&f, int& status);
141
142	//calculate the gradient
143	virtual void calcG();
144	virtual void calcG(std::vector<RealType>& x, std::vector<RealType>& g, RealType& f, int& status);
145
146	//calculate the hessian
147	//virtual void calcH(int& status);
148	//virtual void calcH(vector<RealType>& 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<RealType> getCoor();
156
157	// transfrom minimization coordinates into cartesian and rotational coordinates
158	void setCoor(std::vector<RealType>& 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	RealType calcPotential();
169
170	SimInfo* info;
171
172	ForceManager* forceMan;
173
174	//parameter set of minimization method
175	MinimizerParameterSet* paramSet;
176
177	//flag of turning on shake algorithm
178	bool usingShake;
179
180	// dimension of the model
181	int ndim;
182
183	//name of the minimizer
184	std::string minimizerName;
185
186	// current iteration number
187	int curIter;
188	//status of minimization
189	int minStatus;
190
191	//flag of verbose mode
192	bool bVerbose;
193
194	//status of energy and gradient evaluation
195	int egEvalStatus;
196
197	//initial coordinates
198	//vector<RealType> initX;
199
200	//current value of the function
201	RealType curF;
202
203	// current coordinates
204	std::vector<RealType> curX;
205
206	//gradient at curent coordinates
207	std::vector<RealType> curG;
208
209	//hessian at current coordinates
210	//SymMatrix curH;
211
212	private:
213
214	//calculate the dimension od the model for minimization
215	void calcDim();
216
217	};
218
219	}
220	#endif
221