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 "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:	2204
Committed:	Fri Apr 15 22:04:00 2005 UTC (19 years, 2 months ago) by gezelter
File size:	6480 byte(s)
Log Message:	xemacs has been drafted to perform our indentation services
#	User	Rev	Content
1	gezelter	2204	/*
2	gezelter	1930	* 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	gezelter	2204	#ifndef MINIMIZERS_OOPSEMINIMIZER_HPP
43	gezelter	1930	#define MINIMIZERS_OOPSEMINIMIZER_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 oopse {
55
56	gezelter	2204	/** @todo need refactorying */
57			const int MIN_LSERROR = -1;
58			const int MIN_MAXITER = 0;
59			const int MIN_CONVERGE = 1;
60	gezelter	1930
61	gezelter	2204	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	gezelter	1930
67	gezelter	2204	const int LS_SUCCEED =1;
68			const int LS_ERROR = -1;
69	gezelter	1930
70	gezelter	2204	/** @todo move to math module */
71			double dotProduct(const std::vector<double>& v1, const std::vector<double>& v2);
72	gezelter	1930
73	gezelter	2204	/**
74			* @class Minimizer
75			* base minimizer class
76			*/
77			class Minimizer {
78			public:
79	gezelter	1930
80	gezelter	2204	Minimizer(SimInfo *rhs);
81	gezelter	1930
82	gezelter	2204	virtual ~Minimizer();
83	gezelter	1930
84	gezelter	2204	//
85			virtual void init() {}
86	gezelter	1930
87	gezelter	2204	//driver function of minimization method
88			virtual void minimize();
89	gezelter	1930
90	gezelter	2204	//
91			virtual int step() = 0;
92	gezelter	1930
93	gezelter	2204	//
94			virtual void prepareStep() {};
95	gezelter	1930
96	gezelter	2204	//line search algorithm, for the time being, we use back track algorithm
97			virtual int doLineSearch(std::vector<double>& direction, double stepSize);
98	gezelter	1930
99	gezelter	2204	virtual int checkConvg() = 0;
100	gezelter	1930
101	gezelter	2204	//save the result when minimization method is done
102			virtual void saveResult(){}
103	gezelter	1930
104	gezelter	2204	//get the status of minimization
105			int getMinStatus() {return minStatus;}
106	gezelter	1930
107	gezelter	2204	// get the dimension of the model
108			int getDim() { return ndim; }
109	gezelter	1930
110	gezelter	2204	//get the name of minimizer method
111			std::string getMinimizerName() { return minimizerName; }
112	gezelter	1930
113	gezelter	2204	//return number of current Iteration
114			int getCurIter() { return curIter; }
115	gezelter	1930
116	gezelter	2204	// set the verbose mode of minimizer
117			void setVerbose(bool verbose) { bVerbose = verbose;}
118	gezelter	1930
119	gezelter	2204	//get and set the coordinate
120			std::vector<double> getX() { return curX; }
121			void setX(std::vector<double>& x);
122	gezelter	1930
123	gezelter	2204	//get and set the value of object function
124			double getF() { return curF; }
125			void setF(double f) { curF = f; }
126	gezelter	1930
127	gezelter	2204	std::vector<double> getG() { return curG; }
128			void setG(std::vector<double>& g);
129	gezelter	1930
130	gezelter	2204	//get and set the gradient
131			std::vector<double> getGrad() { return curG; }
132			void setGrad(std::vector<double>& g) { curG = g; }
133	gezelter	1930
134	gezelter	2204	//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	gezelter	1930
138	gezelter	2204	//calculate the value of object function
139			virtual void calcF();
140			virtual void calcF(std::vector<double>& x, double&f, int& status);
141	gezelter	1930
142	gezelter	2204	//calculate the gradient
143			virtual void calcG();
144			virtual void calcG(std::vector<double>& x, std::vector<double>& g, double& f, int& status);
145	gezelter	1930
146	gezelter	2204	//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	gezelter	1930
150	gezelter	2204	friend std::ostream& operator<<(std::ostream& os, const Minimizer& minimizer);
151	gezelter	1930
152	gezelter	2204	protected:
153	gezelter	1930
154	gezelter	2204	// transfrom cartesian and rotational coordinates into minimization coordinates
155			std::vector<double> getCoor();
156	gezelter	1930
157	gezelter	2204	// transfrom minimization coordinates into cartesian and rotational coordinates
158			void setCoor(std::vector<double>& x);
159	gezelter	1930
160
161
162	gezelter	2204	//constraint the bonds;
163			int shakeR() { return 0;}
164	gezelter	1930
165	gezelter	2204	//remove the force component along the bond direction
166			int shakeF() { return 0;}
167	gezelter	1930
168	gezelter	2204	double calcPotential();
169	gezelter	1930
170	gezelter	2204	SimInfo* info;
171	gezelter	1930
172	gezelter	2204	ForceManager* forceMan;
173	gezelter	1930
174	gezelter	2204	//parameter set of minimization method
175			MinimizerParameterSet* paramSet;
176	gezelter	1930
177	gezelter	2204	//flag of turning on shake algorithm
178			bool usingShake;
179	gezelter	1930
180	gezelter	2204	// dimension of the model
181			int ndim;
182	gezelter	1930
183	gezelter	2204	//name of the minimizer
184			std::string minimizerName;
185	gezelter	1930
186	gezelter	2204	// current iteration number
187			int curIter;
188			//status of minimization
189			int minStatus;
190	gezelter	1930
191	gezelter	2204	//flag of verbose mode
192			bool bVerbose;
193	gezelter	1930
194	gezelter	2204	//status of energy and gradient evaluation
195			int egEvalStatus;
196	gezelter	1930
197	gezelter	2204	//initial coordinates
198			//vector<double> initX;
199	gezelter	1930
200	gezelter	2204	//current value of the function
201			double curF;
202	gezelter	1930
203	gezelter	2204	// current coordinates
204			std::vector<double> curX;
205	gezelter	1930
206	gezelter	2204	//gradient at curent coordinates
207			std::vector<double> curG;
208	gezelter	1930
209	gezelter	2204	//hessian at current coordinates
210			//SymMatrix curH;
211	gezelter	1930
212	gezelter	2204	private:
213	gezelter	1930
214	gezelter	2204	//calculate the dimension od the model for minimization
215			void calcDim();
216	gezelter	1930
217	gezelter	2204	};
218	gezelter	1930
219			}
220			#endif
221