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. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. 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.
 */
 
 #ifndef MINIMIZERS_OOPSEMINIMIZER_HPP
#define MINIMIZERS_OOPSEMINIMIZER_HPP

#include <iostream>

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

// base class of minimizer

namespace oopse {

/** @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 */
double dotProduct(const std::vector<double>& v1, const std::vector<double>& 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<double>& direction, double 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<double> getX() {  return curX;  }
        void setX(std::vector<double>& x);

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

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

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

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

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

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

        //calculate the hessian
        //virtual void calcH(int& status);
        //virtual void calcH(vector<double>& 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<double> getCoor();

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


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

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

        double 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<double> initX;

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

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

        //hessian at current coordinates
        //SymMatrix curH;

    private:

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

};

}
#endif

Revision:	1930
Committed:	Wed Jan 12 22:41:40 2005 UTC (19 years, 5 months ago) by gezelter
File size:	6878 byte(s)
Log Message:	merging new_design branch into OOPSE-2.0
#	User	Rev	Content
1	gezelter	1930	/*
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. 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
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 3. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in the
23			* documentation and/or other materials provided with the
24			* distribution.
25			*
26			* This software is provided "AS IS," without a warranty of any
27			* kind. All express or implied conditions, representations and
28			* warranties, including any implied warranty of merchantability,
29			* fitness for a particular purpose or non-infringement, are hereby
30			* excluded. The University of Notre Dame and its licensors shall not
31			* be liable for any damages suffered by licensee as a result of
32			* using, modifying or distributing the software or its
33			* derivatives. In no event will the University of Notre Dame or its
34			* licensors be liable for any lost revenue, profit or data, or for
35			* direct, indirect, special, consequential, incidental or punitive
36			* damages, however caused and regardless of the theory of liability,
37			* arising out of the use of or inability to use software, even if the
38			* University of Notre Dame has been advised of the possibility of
39			* such damages.
40			*/
41
42			#ifndef MINIMIZERS_OOPSEMINIMIZER_HPP
43			#define MINIMIZERS_OOPSEMINIMIZER_HPP
44
45			#include <iostream>
46
47			#include "integrators/Integrator.hpp"
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			namespace oopse {
56
57			/** @todo need refactorying */
58			const int MIN_LSERROR = -1;
59			const int MIN_MAXITER = 0;
60			const int MIN_CONVERGE = 1;
61
62			const int CONVG_UNCONVG = 0;
63			const int CONVG_FTOL = 1;
64			const int CONVG_GTOL = 2;
65			const int CONVG_ABSGTOL = 3;
66			const int CONVG_STEPTOL = 4;
67
68			const int LS_SUCCEED =1;
69			const int LS_ERROR = -1;
70
71			/** @todo move to math module */
72			double dotProduct(const std::vector<double>& v1, const std::vector<double>& v2);
73
74			/**
75			* @class Minimizer
76			* base minimizer class
77			*/
78			class Minimizer {
79			public:
80
81			Minimizer(SimInfo *rhs);
82
83			virtual ~Minimizer();
84
85			//
86			virtual void init() {}
87
88			//driver function of minimization method
89			virtual void minimize();
90
91			//
92			virtual int step() = 0;
93
94			//
95			virtual void prepareStep() {};
96
97			//line search algorithm, for the time being, we use back track algorithm
98			virtual int doLineSearch(std::vector<double>& direction, double stepSize);
99
100			virtual int checkConvg() = 0;
101
102			//save the result when minimization method is done
103			virtual void saveResult(){}
104
105			//get the status of minimization
106			int getMinStatus() {return minStatus;}
107
108			// get the dimension of the model
109			int getDim() { return ndim; }
110
111			//get the name of minimizer method
112			std::string getMinimizerName() { return minimizerName; }
113
114			//return number of current Iteration
115			int getCurIter() { return curIter; }
116
117			// set the verbose mode of minimizer
118			void setVerbose(bool verbose) { bVerbose = verbose;}
119
120			//get and set the coordinate
121			std::vector<double> getX() { return curX; }
122			void setX(std::vector<double>& x);
123
124			//get and set the value of object function
125			double getF() { return curF; }
126			void setF(double f) { curF = f; }
127
128			std::vector<double> getG() { return curG; }
129			void setG(std::vector<double>& g);
130
131			//get and set the gradient
132			std::vector<double> getGrad() { return curG; }
133			void setGrad(std::vector<double>& g) { curG = g; }
134
135			//interal function to evaluate the energy and gradient in OOPSE
136			void calcEnergyGradient(std::vector<double>& x, std::vector<double>& grad, double&
137			energy, int& status);
138
139			//calculate the value of object function
140			virtual void calcF();
141			virtual void calcF(std::vector<double>& x, double&f, int& status);
142
143			//calculate the gradient
144			virtual void calcG();
145			virtual void calcG(std::vector<double>& x, std::vector<double>& g, double& f, int& status);
146
147			//calculate the hessian
148			//virtual void calcH(int& status);
149			//virtual void calcH(vector<double>& x, std::vector<dobule>& g, SymMatrix& h, int& status);
150
151			friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);
152
153			protected:
154
155			// transfrom cartesian and rotational coordinates into minimization coordinates
156			std::vector<double> getCoor();
157
158			// transfrom minimization coordinates into cartesian and rotational coordinates
159			void setCoor(std::vector<double>& x);
160
161
162
163			//constraint the bonds;
164			int shakeR() { return 0;}
165
166			//remove the force component along the bond direction
167			int shakeF() { return 0;}
168
169			double calcPotential();
170
171			SimInfo* info;
172
173			ForceManager* forceMan;
174
175			//parameter set of minimization method
176			MinimizerParameterSet* paramSet;
177
178			//flag of turning on shake algorithm
179			bool usingShake;
180
181			// dimension of the model
182			int ndim;
183
184			//name of the minimizer
185			std::string minimizerName;
186
187			// current iteration number
188			int curIter;
189			//status of minimization
190			int minStatus;
191
192			//flag of verbose mode
193			bool bVerbose;
194
195			//status of energy and gradient evaluation
196			int egEvalStatus;
197
198			//initial coordinates
199			//vector<double> initX;
200
201			//current value of the function
202			double curF;
203
204			// current coordinates
205			std::vector<double> curX;
206
207			//gradient at curent coordinates
208			std::vector<double> curG;
209
210			//hessian at current coordinates
211			//SymMatrix curH;
212
213			private:
214
215			//calculate the dimension od the model for minimization
216			void calcDim();
217
218			};
219
220			}
221			#endif
222