ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/minimizers/MinimizerParameterSet.hpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/minimizers/MinimizerParameterSet.hpp (file contents):
Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC

# Line 1 | Line 1
1 < #ifndef _MININIZERPARAMETERSET_H_
2 < #define _MININIZERPARAMETERSET_H_
3 <
4 < const double DEFAULTTOLERANCE = 1.0e-8;
5 <
6 < // base class of minimizer's parameter set
7 < class MinimizerParameterSet{
8 <  public:
9 <
10 <    MinimizerParameterSet() {setDefaultParameter();}
11 <    MinimizerParameterSet(MinimizerParameterSet& param) {*this = param;}
12 <    
13 <    void operator= (MinimizerParameterSet& param) {
14 <
15 <      maxIteration = param.maxIteration;
16 <      stepSize = param.stepSize;
17 <      stepTol = param.stepTol;
18 <      fTol = param.fTol;
19 <      gTol = param.gTol;
20 <
21 <      writeFrq = param.writeFrq;
22 <
23 <      lsMaxIteration = param.lsMaxIteration;
24 <      lsTol = param.lsTol;
25 <
26 < }
27 <    
28 <    virtual void setDefaultParameter(){
29 <      maxIteration = 200;
30 <      stepSize = 0.01;
31 <      stepTol = DEFAULTTOLERANCE;
32 <      fTol = DEFAULTTOLERANCE;
33 <      gTol = DEFAULTTOLERANCE;
34 <
35 <      writeFrq = maxIteration;
36 <      
37 <      lsMaxIteration = 50;
38 <      lsTol = DEFAULTTOLERANCE;
39 <    }
40 <      
41 <    void setStepTol(double tol) { stepTol = tol;}
42 <    double getStepTol() { return stepTol;}
43 <
44 <    void setStepSize(double size) {  stepSize = size;}
45 <    double getStepSize() { return stepSize;}
46 <
47 <    void setMaxIteration(int iter) { maxIteration = iter;}
48 <    int getMaxIteration() {return maxIteration;}
49 <
50 <    void setFTol(double tol) {fTol = tol;}
51 <    double getFTol() {return fTol;}
52 <
53 <    void setGTol(double tol) {gTol = tol;}
54 <    double getGTol() {return gTol;}
55 <
56 <    void setLineSearchTol(double tol) {lsTol = tol;}
57 <    double getLineSearchTol() {return lsTol;}
58 <
59 <    void setLineSearchMaxIteration(int iter) {lsMaxIteration = iter;}
60 <    int getLineSearchMaxIteration() {return lsMaxIteration;}
61 <
62 <    void setWriteFrq(int frq) {writeFrq = frq;}
63 <    int getWriteFrq() {return writeFrq;}
64 <
65 <  protected:    
66 <
67 <    int maxIteration;
68 <    double stepTol;
69 <    double fTol;
70 <    double gTol;
71 <    double stepSize;
72 <
73 <    int lsMaxIteration;
74 <    double lsTol;
75 <
76 <    int writeFrq;
77 <    //int resetFrq;
78 < /*
79 <    // Absolute tolerance
80 <    vector<double> absTol;
81 <
82 <    // Relative tolerance
83 <    vector<double> relTol;
84 <
85 <    // Total specified tolerance at convergence
86 <    vector<double> totTol;
87 <
88 <    // Tolerance achieved at convergence.
89 <    vector<double> achTol;
90 < */
91 < };
92 <
93 <
94 < #endif
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. 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_MININIZERPARAMETERSET_HPP
43 > #define MINIMIZERS_MININIZERPARAMETERSET_HPP
44 > #include "brains/SimInfo.hpp"
45 > namespace oopse {
46 >
47 > // base class of minimizer's parameter set
48 >
49 > class MinimizerParameterSet {
50 >    public:
51 >
52 >        MinimizerParameterSet(SimInfo* info);
53 >
54 >        void setDefaultParameter();
55 >
56 >        void setStepTol(double tol) {
57 >            stepTol = tol;
58 >        }
59 >
60 >        double getStepTol() {
61 >            return stepTol;
62 >        }
63 >
64 >        void setStepSize(double size) {
65 >            stepSize = size;
66 >        }
67 >
68 >        double getStepSize() {
69 >            return stepSize;
70 >        }
71 >
72 >        void setMaxIteration(int iter) {
73 >            maxIteration = iter;
74 >        }
75 >
76 >        int getMaxIteration() {
77 >            return maxIteration;
78 >        }
79 >
80 >        void setFTol(double tol) {
81 >            fTol = tol;
82 >        }
83 >
84 >        double getFTol() {
85 >            return fTol;
86 >        }
87 >
88 >        void setGTol(double tol) {
89 >            gTol = tol;
90 >        }
91 >
92 >        double getGTol() {
93 >            return gTol;
94 >        }
95 >
96 >        void setLineSearchTol(double tol) {
97 >            lsTol = tol;
98 >        }
99 >
100 >        double getLineSearchTol() {
101 >            return lsTol;
102 >        }
103 >
104 >        void setLineSearchMaxIteration(int iter) {
105 >            lsMaxIteration = iter;
106 >        }
107 >
108 >        int getLineSearchMaxIteration() {
109 >            return lsMaxIteration;
110 >        }
111 >
112 >        void setWriteFrq(int frq) {
113 >            writeFrq = frq;
114 >        }
115 >
116 >        int getWriteFrq() {
117 >            return writeFrq;
118 >        }
119 >
120 >    protected:
121 >
122 >        int maxIteration;
123 >
124 >        double stepTol;
125 >
126 >        double fTol;
127 >
128 >        double gTol;
129 >
130 >        double stepSize;
131 >
132 >        int lsMaxIteration;
133 >
134 >        double lsTol;
135 >
136 >        int writeFrq;
137 >
138 >        const double  defaultTolerance;
139 >
140 > };
141 >
142 > }
143 > #endif

Diff Legend

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