1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// ************************************************************************************************
//
// BornAgain: simulate and fit reflection and scattering
//
//! @file Fit/Suite/GeneticMinimizer.cpp
//! @brief Implements class GeneticMinimizer.
//!
//! @homepage http://www.bornagainproject.org
//! @license GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
// ************************************************************************************************
#include "Fit/Suite/GeneticMinimizer.h"
#include <Math/GeneticMinimizer.h>
namespace {
std::map<int, std::string> statusDescription()
{
std::map<int, std::string> result;
result[0] = "OK, minimum found";
result[1] = "Maximum number of iterations reached";
return result;
}
} // namespace
GeneticMinimizer::GeneticMinimizer()
: MinimizerAdapter(MinimizerInfo::buildGeneticInfo())
, m_genetic_minimizer(new ROOT::Math::GeneticMinimizer())
{
addOption("Tolerance", 0.01, "Tolerance on the function value at the minimum");
addOption("PrintLevel", 0, "Minimizer internal print level");
addOption("MaxIterations", 3, "Maximum number of iterations");
addOption("PopSize", 300, "Population size");
addOption("RandomSeed", 0, "Random seed");
}
GeneticMinimizer::~GeneticMinimizer() = default;
void GeneticMinimizer::setTolerance(double value)
{
setOptionValue("Tolerance", value);
}
double GeneticMinimizer::tolerance() const
{
return optionValue<double>("Tolerance");
}
void GeneticMinimizer::setPrintLevel(int value)
{
setOptionValue("PrintLevel", value);
}
int GeneticMinimizer::printLevel() const
{
return optionValue<int>("PrintLevel");
}
void GeneticMinimizer::setMaxIterations(int value)
{
setOptionValue("MaxIterations", value);
}
int GeneticMinimizer::maxIterations() const
{
return optionValue<int>("MaxIterations");
}
void GeneticMinimizer::setPopulationSize(int value)
{
setOptionValue("PopSize", value);
}
int GeneticMinimizer::populationSize() const
{
return optionValue<int>("PopSize");
}
void GeneticMinimizer::setRandomSeed(int value)
{
setOptionValue("RandomSeed", value);
}
int GeneticMinimizer::randomSeed() const
{
return optionValue<int>("RandomSeed");
}
void GeneticMinimizer::setParameter(unsigned int index, const mumufit::Parameter& par)
{
if (!par.limits().isFixed() && !par.limits().isLimited()) {
std::ostringstream ostr;
ostr << "GeneticMinimizer::setParameter -> Error! "
<< "Genetic minimizer requires either fixed or "
<< "limited AttLimits::limited(left,right) parameter. "
<< " Parameter name '" << par.name() << "', limits:" << par.limits().toString();
throw std::runtime_error(ostr.str());
}
MinimizerAdapter::setParameter(index, par);
}
std::string GeneticMinimizer::statusToString() const
{
return statusDescription()[rootMinimizer()->Status()];
}
std::map<std::string, std::string> GeneticMinimizer::statusMap() const
{
auto result = MinimizerAdapter::statusMap();
result["functionCalls"] = std::to_string(rootMinimizer()->NCalls());
return result;
}
void GeneticMinimizer::propagateOptions()
{
ROOT::Math::GeneticMinimizerParameters pars;
pars.fPopSize = populationSize();
pars.fNsteps = maxIterations();
const double scale_as_in_root = 10.0;
pars.fConvCrit = scale_as_in_root * tolerance();
pars.fSeed = randomSeed();
m_genetic_minimizer->SetParameters(pars);
}
const MinimizerAdapter::root_minimizer_t* GeneticMinimizer::rootMinimizer() const
{
return m_genetic_minimizer.get();
}
|
