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]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */
 
#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 {
  
  /** minimizer stop codes */
  enum{MIN_MAXITER,
       MIN_MAXEVAL,
       MIN_ETOL,
       MIN_FTOL,
       MIN_DOWNHILL,
       MIN_ZEROALPHA,
       MIN_ZEROFORCE,
       MIN_ZEROQUAD};
  
  typedef int (*FnPtr)(std::vector<RealType> &, std::vector<RealType> &, RealType &);    

  /**
   * @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 a back track
    //algorithm
    virtual int doLineSearch(std::vector<RealType>& direction, RealType stepSize);
    virtual int checkConvergence() = 0;

    //save the result when minimization method is done
    virtual void saveResult(){}
    
    //get the status of minimization
    int getMinimizerStatus() {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 the current Iteration  
    int getCurrentIteration() {  return curIter;  }

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

    //get and set the coordinates
    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;  }

    void setGradientFunction(FnPtr efunc) { calcEnergyGradient = efunc; }

    //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:

    typedef int (*FnPtr)(std::vector<RealType> &, std::vector<RealType> &, RealType &);    
    FnPtr calcEnergyGradient;

    // 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 of the model for minimization
    void calcDim();
  };

}
#endif

Revision:	1744
Committed:	Tue Jun 5 18:07:08 2012 UTC (12 years, 11 months ago) by gezelter
File size:	6477 byte(s)
Log Message:	Fixes for minimization
#	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	1390	#ifndef MINIMIZERS_MINIMIZER_HPP
44			#define MINIMIZERS_MINIMIZER_HPP
45	gezelter	246
46			#include <iostream>
47
48			#include "io/DumpWriter.hpp"
49			#include "io/StatWriter.hpp"
50			#include "minimizers/MinimizerParameterSet.hpp"
51			#include "brains/ForceManager.hpp"
52
53			// base class of minimizer
54
55	gezelter	1390	namespace OpenMD {
56	gezelter	1744
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	gezelter	246
69	gezelter	507	/**
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	gezelter	246
83	gezelter	1744	//line search algorithm, for the time being, we use a back track
84			//algorithm
85	tim	963	virtual int doLineSearch(std::vector<RealType>& direction, RealType stepSize);
86	gezelter	1744	virtual int checkConvergence() = 0;
87	gezelter	246
88	gezelter	507	//save the result when minimization method is done
89			virtual void saveResult(){}
90	gezelter	1744
91	gezelter	507	//get the status of minimization
92	gezelter	1744	int getMinimizerStatus() {return minStatus;}
93	gezelter	246
94	gezelter	507	// get the dimension of the model
95			int getDim() { return ndim; }
96	gezelter	246
97	gezelter	507	//get the name of minimizer method
98			std::string getMinimizerName() { return minimizerName; }
99	gezelter	246
100	gezelter	1744	//return number of the current Iteration
101			int getCurrentIteration() { return curIter; }
102	gezelter	246
103	gezelter	507	// set the verbose mode of minimizer
104			void setVerbose(bool verbose) { bVerbose = verbose;}
105	gezelter	246
106	gezelter	1744	//get and set the coordinates
107	tim	963	std::vector<RealType> getX() { return curX; }
108			void setX(std::vector<RealType>& x);
109	gezelter	246
110	gezelter	507	//get and set the value of object function
111	tim	963	RealType getF() { return curF; }
112			void setF(RealType f) { curF = f; }
113	gezelter	246
114	tim	963	std::vector<RealType> getG() { return curG; }
115			void setG(std::vector<RealType>& g);
116	gezelter	246
117	gezelter	507	//get and set the gradient
118	tim	963	std::vector<RealType> getGrad() { return curG; }
119			void setGrad(std::vector<RealType>& g) { curG = g; }
120	gezelter	246
121	gezelter	1744	void setGradientFunction(FnPtr efunc) { calcEnergyGradient = efunc; }
122	gezelter	246
123	gezelter	507	//calculate the value of object function
124			virtual void calcF();
125	tim	963	virtual void calcF(std::vector<RealType>& x, RealType&f, int& status);
126	gezelter	246
127	gezelter	507	//calculate the gradient
128			virtual void calcG();
129	tim	963	virtual void calcG(std::vector<RealType>& x, std::vector<RealType>& g, RealType& f, int& status);
130	gezelter	246
131	gezelter	507	//calculate the hessian
132			//virtual void calcH(int& status);
133	tim	963	//virtual void calcH(vector<RealType>& x, std::vector<dobule>& g, SymMatrix& h, int& status);
134	gezelter	246
135	gezelter	507	friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);
136	gezelter	246
137	gezelter	507	protected:
138	gezelter	246
139	gezelter	1744	typedef int (*FnPtr)(std::vector<RealType> &, std::vector<RealType> &, RealType &);
140			FnPtr calcEnergyGradient;
141
142	gezelter	507	// transfrom cartesian and rotational coordinates into minimization coordinates
143	tim	963	std::vector<RealType> getCoor();
144	gezelter	246
145	gezelter	507	// transfrom minimization coordinates into cartesian and rotational coordinates
146	tim	963	void setCoor(std::vector<RealType>& x);
147	gezelter	246
148	gezelter	507	//constraint the bonds;
149			int shakeR() { return 0;}
150	gezelter	246
151	gezelter	507	//remove the force component along the bond direction
152			int shakeF() { return 0;}
153	tim	963	RealType calcPotential();
154	gezelter	246
155	gezelter	507	SimInfo* info;
156	gezelter	1744	ForceManager* forceMan;
157	gezelter	507	//parameter set of minimization method
158			MinimizerParameterSet* paramSet;
159	gezelter	246
160	gezelter	507	//flag of turning on shake algorithm
161			bool usingShake;
162	gezelter	246
163	gezelter	507	// dimension of the model
164			int ndim;
165	gezelter	246
166	gezelter	507	//name of the minimizer
167			std::string minimizerName;
168	gezelter	246
169	gezelter	507	// current iteration number
170			int curIter;
171			//status of minimization
172			int minStatus;
173	gezelter	246
174	gezelter	507	//flag of verbose mode
175			bool bVerbose;
176	gezelter	246
177	gezelter	507	//status of energy and gradient evaluation
178			int egEvalStatus;
179	gezelter	246
180	gezelter	507	//initial coordinates
181	tim	963	//vector<RealType> initX;
182	gezelter	246
183	gezelter	507	//current value of the function
184	tim	963	RealType curF;
185	gezelter	246
186	gezelter	507	// current coordinates
187	tim	963	std::vector<RealType> curX;
188	gezelter	246
189	gezelter	507	//gradient at curent coordinates
190	tim	963	std::vector<RealType> curG;
191	gezelter	246
192	gezelter	507	//hessian at current coordinates
193			//SymMatrix curH;
194	gezelter	246
195	gezelter	507	private:
196	gezelter	1744	//calculate the dimension of the model for minimization
197	gezelter	507	void calcDim();
198			};
199	gezelter	246
200			}
201			#endif
202