diff --git a/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.cpp b/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.cpp
index c9935ceb781a4e9736c54fbcef7a0e48a4f061b5..c54656bd3657fbec45a6942b15a19673b307f0ad 100644
--- a/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.cpp
+++ b/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.cpp
@@ -18,10 +18,10 @@
#include "StringUtils.h"
#ifdef _WIN32
-#pragma warning ( push )
-#pragma warning ( disable: 4267 )
+#pragma warning(push)
+#pragma warning(disable : 4267)
#include "Math/GSLNLSMinimizer.h"
-#pragma warning ( pop )
+#pragma warning(pop)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -29,29 +29,30 @@
#pragma GCC diagnostic pop
#endif
-namespace {
+namespace
+{
- std::map<int, std::string> covmatrixStatusDescription()
- {
- std::map<int, std::string> result;
- result[0] = "Covariance matrix was not computed";
- result[1] = "Covariance matrix approximate because minimum is not valid";
- result[3] = "Covariance matrix OK";
- return result;
- }
+std::map<int, std::string> covmatrixStatusDescription()
+{
+ std::map<int, std::string> result;
+ result[0] = "Covariance matrix was not computed";
+ result[1] = "Covariance matrix approximate because minimum is not valid";
+ result[3] = "Covariance matrix OK";
+ return result;
+}
} // namespace
GSLLevenbergMarquardtMinimizer::GSLLevenbergMarquardtMinimizer()
- : RootMinimizerAdapter(MinimizerInfo::buildGSLLMAInfo())
- , m_gsl_minimizer(new ROOT::Math::GSLNLSMinimizer(2))
+ : RootMinimizerAdapter(MinimizerInfo::buildGSLLMAInfo()),
+ m_gsl_minimizer(new ROOT::Math::GSLNLSMinimizer(2))
{
addOption(OptionNames::Tolerance, 0.01, "Tolerance on the function value at the minimum");
addOption(OptionNames::PrintLevel, 0, "Minimizer internal print level");
addOption(OptionNames::MaxIterations, 0, "Maximum number of iterations");
}
-GSLLevenbergMarquardtMinimizer::~GSLLevenbergMarquardtMinimizer() {}
+GSLLevenbergMarquardtMinimizer::~GSLLevenbergMarquardtMinimizer() = default;
void GSLLevenbergMarquardtMinimizer::setTolerance(double value)
{
@@ -103,7 +104,7 @@ void GSLLevenbergMarquardtMinimizer::propagateOptions()
{
m_gsl_minimizer->SetTolerance(tolerance());
m_gsl_minimizer->SetPrintLevel(printLevel());
- m_gsl_minimizer->SetMaxIterations(maxIterations());
+ m_gsl_minimizer->SetMaxIterations(static_cast<unsigned int>(maxIterations()));
}
const RootMinimizerAdapter::root_minimizer_t* GSLLevenbergMarquardtMinimizer::rootMinimizer() const
diff --git a/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.h b/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.h
index 689a5addd9fbb7ffc1364fa35673fec1a379685b..7b14c87a5c986d2ae0cf2d182fa3dad8d5620344 100644
--- a/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.h
+++ b/Fit/RootAdapter/GSLLevenbergMarquardtMinimizer.h
@@ -19,14 +19,13 @@
namespace ROOT { namespace Math { class GSLNLSMinimizer; } }
-//! Wrapper for CERN ROOT facade of the GSL Levenberg-Marquardt minimizer.
-//! It's a facade to ROOT::Math::GSLNLSMinimizer which adapts ROOT::Math::GSLMultiFit
-//! minimizers to some CERN ROOT generic minimizer interface. ROOT::Math::GSLMultiFit,
-//! in turn, is a facade to the actual GSL's gsl_multifit_fdfsolver_type
+//! It's a facade to ROOT::Math::GSLNLSMinimizer which, in turn, is a facade to the
+//! actual GSL's gsl_multifit_fdfsolver_type
//! (http://www.gnu.org/software/gsl/manual/html_node/Nonlinear-Least_002dSquares-Fitting.html).
//! @ingroup fitting_internal
-class BA_CORE_API_ GSLLevenbergMarquardtMinimizer : public RootMinimizerAdapter {
+class BA_CORE_API_ GSLLevenbergMarquardtMinimizer : public RootMinimizerAdapter
+{
public:
GSLLevenbergMarquardtMinimizer();
~GSLLevenbergMarquardtMinimizer();
diff --git a/Fit/RootAdapter/GSLMultiMinimizer.cpp b/Fit/RootAdapter/GSLMultiMinimizer.cpp
index 70727fc2bcb8b45871ce54f25b1cdb32aeebc08c..92de5b2826c93038c94736c85d9b89840e508bcc 100644
--- a/Fit/RootAdapter/GSLMultiMinimizer.cpp
+++ b/Fit/RootAdapter/GSLMultiMinimizer.cpp
@@ -37,10 +37,7 @@ GSLMultiMinimizer::GSLMultiMinimizer(const std::string &algorithmName)
addOption(OptionNames::MaxIterations, 0, "Maximum number of iterations");
}
-GSLMultiMinimizer::~GSLMultiMinimizer()
-{
-
-}
+GSLMultiMinimizer::~GSLMultiMinimizer() = default;
void GSLMultiMinimizer::setPrintLevel(int value)
{
@@ -70,7 +67,7 @@ std::string GSLMultiMinimizer::statusToString() const
void GSLMultiMinimizer::propagateOptions()
{
m_gsl_minimizer->SetPrintLevel(printLevel());
- m_gsl_minimizer->SetMaxIterations(maxIterations());
+ m_gsl_minimizer->SetMaxIterations(static_cast<unsigned int>(maxIterations()));
}
const RootMinimizerAdapter::root_minimizer_t *GSLMultiMinimizer::rootMinimizer() const
diff --git a/Fit/RootAdapter/GSLMultiMinimizer.h b/Fit/RootAdapter/GSLMultiMinimizer.h
index 350d6b52df7bcee959a313569ef2a1ae300ec6a3..939b76e6fa49223e8829f94b55e00816c689cf2a 100644
--- a/Fit/RootAdapter/GSLMultiMinimizer.h
+++ b/Fit/RootAdapter/GSLMultiMinimizer.h
@@ -15,17 +15,18 @@
#ifndef GSLMULTIMINIMIZER_H
#define GSLMULTIMINIMIZER_H
-#include "RootMinimizerAdapter.h"
#include "MinimizerConstants.h"
+#include "RootMinimizerAdapter.h"
namespace ROOT { namespace Math { class GSLMinimizer; } }
//! Wrapper for the CERN ROOT facade of the GSL multi minimizer family (gradient descent based).
//! @ingroup fitting_internal
-class BA_CORE_API_ GSLMultiMinimizer : public RootMinimizerAdapter {
+class BA_CORE_API_ GSLMultiMinimizer : public RootMinimizerAdapter
+{
public:
- explicit GSLMultiMinimizer(const std::string &algorithmName = AlgorithmNames::ConjugateFR);
+ explicit GSLMultiMinimizer(const std::string& algorithmName = AlgorithmNames::ConjugateFR);
~GSLMultiMinimizer();
//! Sets minimizer internal print level.
diff --git a/Fit/RootAdapter/GeneticMinimizer.cpp b/Fit/RootAdapter/GeneticMinimizer.cpp
index c42f04057c1ba95b634f78855479853eccf0ccb8..b7160f52a72298ef7ed521df45e7d5cbc620d4b2 100644
--- a/Fit/RootAdapter/GeneticMinimizer.cpp
+++ b/Fit/RootAdapter/GeneticMinimizer.cpp
@@ -13,11 +13,12 @@
// ************************************************************************** //
#include "GeneticMinimizer.h"
-#include "MinimizerConstants.h"
#include "Math/GeneticMinimizer.h"
+#include "MinimizerConstants.h"
#include "Parameter.h"
-namespace {
+namespace
+{
std::map<int, std::string> statusDescription()
{
@@ -26,12 +27,11 @@ std::map<int, std::string> statusDescription()
result[1] = std::string("Maximum number of iterations reached");
return result;
}
-
}
GeneticMinimizer::GeneticMinimizer()
- : RootMinimizerAdapter(MinimizerInfo::buildGeneticInfo())
- , m_genetic_minimizer(new ROOT::Math::GeneticMinimizer())
+ : RootMinimizerAdapter(MinimizerInfo::buildGeneticInfo()),
+ m_genetic_minimizer(new ROOT::Math::GeneticMinimizer())
{
addOption(OptionNames::Tolerance, 0.01, "Tolerance on the function value at the minimum");
addOption(OptionNames::PrintLevel, 0, "Minimizer internal print level");
@@ -40,20 +40,17 @@ GeneticMinimizer::GeneticMinimizer()
addOption(OptionNames::RandomSeed, 0, "Random seed");
// Seems it is not used inside Root, no need to expose
- //addOption("Cycles", 3, "Number of cycles");
+ // addOption("Cycles", 3, "Number of cycles");
// It's hard to understand (without going to much into genetics details), what parameters below
// are doing. So better to not to expose and rely on their internal ROOT's default values.
- //addOption("sc_steps", 10, "Spread control steps");
- //addOption("sc_rate", 5, "Spread control rate");
- //addOption("sc_factor", 0.95, "Spread control factor");
+ // addOption("sc_steps", 10, "Spread control steps");
+ // addOption("sc_rate", 5, "Spread control rate");
+ // addOption("sc_factor", 0.95, "Spread control factor");
}
-GeneticMinimizer::~GeneticMinimizer()
-{
-
-}
+GeneticMinimizer::~GeneticMinimizer() = default;
void GeneticMinimizer::setTolerance(double value)
{
@@ -107,7 +104,7 @@ int GeneticMinimizer::randomSeed() const
void GeneticMinimizer::setParameter(unsigned int index, const Fit::Parameter& par)
{
- if( !par.limits().isFixed() && !par.limits().isLimited()) {
+ if (!par.limits().isFixed() && !par.limits().isLimited()) {
std::ostringstream ostr;
ostr << "GeneticMinimizer::setParameter() -> Error! "
<< "Genetic minimizer requires either fixed or "
@@ -135,17 +132,17 @@ void GeneticMinimizer::propagateOptions()
ROOT::Math::GeneticMinimizerParameters pars;
pars.fPopSize = populationSize();
pars.fNsteps = maxIterations();
-// pars.fCycles = m_options.getIntValue("Cycles"); // seems it's not used inside ROOT
-// pars.fSC_steps = m_options.getIntValue("SC_steps"); // no idea what it is doing
-// pars.fSC_rate = m_options.getIntValue("SC_rate"); // no idea what it is doing
-// pars.fSC_factor = m_options.getRealValue("SC_factor"); // no idea what it is doing
+ // pars.fCycles = m_options.getIntValue("Cycles"); // seems it's not used inside ROOT
+ // pars.fSC_steps = m_options.getIntValue("SC_steps"); // no idea what it is doing
+ // pars.fSC_rate = m_options.getIntValue("SC_rate"); // no idea what it is doing
+ // pars.fSC_factor = m_options.getRealValue("SC_factor"); // no idea what it is doing
const double scale_as_in_root = 10.0;
- pars.fConvCrit = scale_as_in_root*tolerance();
+ pars.fConvCrit = scale_as_in_root * tolerance();
pars.fSeed = randomSeed();
m_genetic_minimizer->SetParameters(pars);
}
-const RootMinimizerAdapter::root_minimizer_t *GeneticMinimizer::rootMinimizer() const
+const RootMinimizerAdapter::root_minimizer_t* GeneticMinimizer::rootMinimizer() const
{
return m_genetic_minimizer.get();
}
diff --git a/Fit/RootAdapter/GeneticMinimizer.h b/Fit/RootAdapter/GeneticMinimizer.h
index 7f2c1892d623fb0ff4bbc13aa4b2762cd6938390..564b6c6fca007917c304735e6fdc40c31cdad376 100644
--- a/Fit/RootAdapter/GeneticMinimizer.h
+++ b/Fit/RootAdapter/GeneticMinimizer.h
@@ -22,7 +22,8 @@ namespace ROOT { namespace Math { class GeneticMinimizer; } }
//! Wrapper for the CERN ROOT Genetic minimizer.
//! @ingroup fitting_internal
-class BA_CORE_API_ GeneticMinimizer : public RootMinimizerAdapter {
+class BA_CORE_API_ GeneticMinimizer : public RootMinimizerAdapter
+{
public:
GeneticMinimizer();
~GeneticMinimizer();
diff --git a/Fit/RootAdapter/Minuit2Minimizer.cpp b/Fit/RootAdapter/Minuit2Minimizer.cpp
index 5a558caaa15fe4a32f06da530f6799178ca425a6..852a7d4fef4831e8505dcfa5dec880b7e3143c1d 100644
--- a/Fit/RootAdapter/Minuit2Minimizer.cpp
+++ b/Fit/RootAdapter/Minuit2Minimizer.cpp
@@ -16,55 +16,48 @@
#include "Minuit2/Minuit2Minimizer.h"
#include "StringUtils.h"
-namespace {
-
- std::map<int, std::string> statusDescription()
- {
- std::map<int, std::string> result;
- result[0] = "OK, valid minimum";
- result[1] = "Didn't converge, covariance was made pos defined";
- result[2] = "Didn't converge, Hessian is invalid";
- result[3] = "Didn't converge, Edm is above max";
- result[4] = "Didn't converge, reached call limit";
- result[5] = "Didn't converge, unknown failure";
- return result;
- }
-
- std::map<int, std::string> covmatrixStatusDescription()
- {
- std::map<int, std::string> result;
- result[-1] = "Not available (inversion failed or Hessian failed)";
- result[ 0] = "Available but not positive defined";
- result[ 1] = "Covariance only approximate";
- result[ 2] = "Full matrix but forced pos def";
- result[ 3] = "Full accurate";
- return result;
- }
+namespace
+{
+
+std::map<int, std::string> statusDescription()
+{
+ std::map<int, std::string> result;
+ result[0] = "OK, valid minimum";
+ result[1] = "Didn't converge, covariance was made pos defined";
+ result[2] = "Didn't converge, Hessian is invalid";
+ result[3] = "Didn't converge, Edm is above max";
+ result[4] = "Didn't converge, reached call limit";
+ result[5] = "Didn't converge, unknown failure";
+ return result;
+}
+
+std::map<int, std::string> covmatrixStatusDescription()
+{
+ std::map<int, std::string> result;
+ result[-1] = "Not available (inversion failed or Hessian failed)";
+ result[0] = "Available but not positive defined";
+ result[1] = "Covariance only approximate";
+ result[2] = "Full matrix but forced pos def";
+ result[3] = "Full accurate";
+ return result;
+}
} // namespace
-Minuit2Minimizer::Minuit2Minimizer(const std::string &algorithmName)
- : RootMinimizerAdapter(MinimizerInfo::buildMinuit2Info(algorithmName))
- , m_minuit2_minimizer(new ROOT::Minuit2::Minuit2Minimizer(algorithmName.c_str()))
+Minuit2Minimizer::Minuit2Minimizer(const std::string& algorithmName)
+ : RootMinimizerAdapter(MinimizerInfo::buildMinuit2Info(algorithmName)),
+ m_minuit2_minimizer(new ROOT::Minuit2::Minuit2Minimizer(algorithmName.c_str()))
{
- addOption(OptionNames::Strategy, 1,
- "Minimization strategy (0-low, 1-medium, 2-high quality)");
+ addOption(OptionNames::Strategy, 1, "Minimization strategy (0-low, 1-medium, 2-high quality)");
addOption(OptionNames::ErrorDef, 1.0,
"Error definition factor for parameter error calculation");
- addOption(OptionNames::Tolerance, 0.01,
- "Tolerance on the function value at the minimum");
- addOption(OptionNames::Precision, -1.0,
- "Relative floating point arithmetic precision");
- addOption(OptionNames::PrintLevel, 0,
- "Minimizer internal print level");
- addOption(OptionNames::MaxFunctionCalls, 0,
- "Maximum number of function calls");
+ addOption(OptionNames::Tolerance, 0.01, "Tolerance on the function value at the minimum");
+ addOption(OptionNames::Precision, -1.0, "Relative floating point arithmetic precision");
+ addOption(OptionNames::PrintLevel, 0, "Minimizer internal print level");
+ addOption(OptionNames::MaxFunctionCalls, 0, "Maximum number of function calls");
}
-Minuit2Minimizer::~Minuit2Minimizer()
-{
-
-}
+Minuit2Minimizer::~Minuit2Minimizer() = default;
void Minuit2Minimizer::setStrategy(int value)
{
@@ -145,7 +138,7 @@ std::map<std::string, std::string> Minuit2Minimizer::statusMap() const
// simplified approach: if not Fumili, then chi2 only. Think of refactoring TODO.
bool Minuit2Minimizer::isGradientBasedAgorithm()
{
- if(algorithmName() == AlgorithmNames::Fumili)
+ if (algorithmName() == AlgorithmNames::Fumili)
return true;
return false;
@@ -160,10 +153,10 @@ void Minuit2Minimizer::propagateOptions()
m_minuit2_minimizer->SetTolerance(tolerance());
m_minuit2_minimizer->SetPrecision(precision());
m_minuit2_minimizer->SetPrintLevel(printLevel());
- m_minuit2_minimizer->SetMaxFunctionCalls(maxFunctionCalls());
+ m_minuit2_minimizer->SetMaxFunctionCalls(static_cast<unsigned int>(maxFunctionCalls()));
}
-const RootMinimizerAdapter::root_minimizer_t *Minuit2Minimizer::rootMinimizer() const
+const RootMinimizerAdapter::root_minimizer_t* Minuit2Minimizer::rootMinimizer() const
{
return m_minuit2_minimizer.get();
}
diff --git a/Fit/RootAdapter/Minuit2Minimizer.h b/Fit/RootAdapter/Minuit2Minimizer.h
index f525a808b7602f520bbd328d8814fbdbb93e73d3..6595430c539cc755a6fdea79b45d252898dd5904 100644
--- a/Fit/RootAdapter/Minuit2Minimizer.h
+++ b/Fit/RootAdapter/Minuit2Minimizer.h
@@ -15,8 +15,8 @@
#ifndef MINUIT2MINIMIZER_H
#define MINUIT2MINIMIZER_H
-#include "RootMinimizerAdapter.h"
#include "MinimizerConstants.h"
+#include "RootMinimizerAdapter.h"
#include <memory>
namespace ROOT { namespace Minuit2 { class Minuit2Minimizer; } }
diff --git a/Fit/RootAdapter/RootMinimizerAdapter.cpp b/Fit/RootAdapter/RootMinimizerAdapter.cpp
index a0f5f93d447d6bbf69a8bf25bfb2f48e3baf48d8..8303708604554702cae63a80ac963794375c7e90 100644
--- a/Fit/RootAdapter/RootMinimizerAdapter.cpp
+++ b/Fit/RootAdapter/RootMinimizerAdapter.cpp
@@ -15,25 +15,25 @@
#include "RootMinimizerAdapter.h"
#include "Math/Minimizer.h"
#include "MinimizerResultsHelper.h"
-#include "RootScalarFunction.h"
-#include "StringUtils.h"
+#include "ObjectiveFunctionAdapter.h"
#include "Parameter.h"
#include "Parameters.h"
-#include "ObjectiveFunctionAdapter.h"
#include "RootResidualFunction.h"
+#include "RootScalarFunction.h"
+#include "StringUtils.h"
using namespace Fit;
-RootMinimizerAdapter::RootMinimizerAdapter(const MinimizerInfo &minimizerInfo)
- : m_minimizerInfo(minimizerInfo)
+RootMinimizerAdapter::RootMinimizerAdapter(const MinimizerInfo& minimizerInfo)
+ : m_minimizerInfo(minimizerInfo)
, m_adapter(new Fit::ObjectiveFunctionAdapter)
, m_status(false)
-{}
+{
+}
-RootMinimizerAdapter::~RootMinimizerAdapter() {}
+RootMinimizerAdapter::~RootMinimizerAdapter() = default;
-MinimizerResult RootMinimizerAdapter::minimize_scalar(fcn_scalar_t fcn,
- Parameters parameters)
+MinimizerResult RootMinimizerAdapter::minimize_scalar(fcn_scalar_t fcn, Parameters parameters)
{
// Genetic minimizer requires SetFunction before setParameters, others don't care
rootMinimizer()->SetFunction(*m_adapter->rootObjectiveFunction(fcn, parameters));
@@ -46,7 +46,7 @@ MinimizerResult RootMinimizerAdapter::minimize_scalar(fcn_scalar_t fcn,
MinimizerResult result;
result.setParameters(parameters);
result.setMinValue(minValue());
- result.setReport( MinimizerResultsHelper().reportOutcome(this));
+ result.setReport(MinimizerResultsHelper().reportOutcome(this));
result.setNumberOfCalls(m_adapter->numberOfCalls());
return result;
@@ -86,13 +86,10 @@ void RootMinimizerAdapter::setParameters(const Fit::Parameters& parameters)
{
unsigned int index(0);
for (const auto& par : parameters)
- setParameter(index++, par );
+ setParameter(index++, par);
}
-double RootMinimizerAdapter::minValue() const
-{
- return rootMinimizer()->MinValue();
-}
+double RootMinimizerAdapter::minValue() const { return rootMinimizer()->MinValue(); }
std::string RootMinimizerAdapter::statusToString() const
{
@@ -109,7 +106,7 @@ std::map<std::string, std::string> RootMinimizerAdapter::statusMap() const
std::map<std::string, std::string> result;
result["Status"] = statusToString();
- if(providesError())
+ if (providesError())
result["ProvidesError"] = "Provides parameters error and error matrix";
else
result["ProvidesError"] = "Doesn't provide error calculation";
@@ -119,7 +116,7 @@ std::map<std::string, std::string> RootMinimizerAdapter::statusMap() const
return result;
}
-void RootMinimizerAdapter::setOptions(const std::string &optionString)
+void RootMinimizerAdapter::setOptions(const std::string& optionString)
{
options().setOptionString(optionString);
}
@@ -131,14 +128,15 @@ void RootMinimizerAdapter::propagateResults(Fit::Parameters& parameters)
parameters.setValues(parValuesAtMinimum());
parameters.setErrors(parErrorsAtMinimum());
// sets correlation matrix
- if(providesError()) {
+ if (providesError()) {
Fit::Parameters::corr_matrix_t matrix;
matrix.resize(fitDimension());
- for(unsigned i=0; i<(size_t)fitDimension(); ++i) {
+ for (size_t i = 0; i < fitDimension(); ++i) {
matrix[i].resize(fitDimension(), 0.0);
- for(unsigned j=0; j<(size_t)fitDimension(); ++j)
- matrix[i][j] = rootMinimizer()->Correlation(i,j);
+ for (size_t j = 0; j < fitDimension(); ++j)
+ matrix[i][j] = rootMinimizer()->Correlation(static_cast<unsigned int>(i),
+ static_cast<unsigned int>(j));
}
parameters.setCorrelationMatrix(matrix);
}
@@ -148,46 +146,40 @@ void RootMinimizerAdapter::setParameter(unsigned int index, const Fit::Parameter
{
bool success;
if (par.limits().isFixed()) {
- success = rootMinimizer()->SetFixedVariable(index, par.name().c_str(),
- par.value());
+ success = rootMinimizer()->SetFixedVariable(index, par.name().c_str(), par.value());
}
else if (par.limits().isLimited()) {
- success = rootMinimizer()->SetLimitedVariable(index, par.name().c_str(),
- par.value(), par.step(),
- par.limits().lowerLimit(),
+ success = rootMinimizer()->SetLimitedVariable(index, par.name().c_str(), par.value(),
+ par.step(), par.limits().lowerLimit(),
par.limits().upperLimit());
}
else if (par.limits().isLowerLimited()) {
- success = rootMinimizer()->SetLowerLimitedVariable(index, par.name().c_str(),
- par.value(), par.step(),
- par.limits().lowerLimit());
+ success = rootMinimizer()->SetLowerLimitedVariable(index, par.name().c_str(), par.value(),
+ par.step(), par.limits().lowerLimit());
}
else if (par.limits().isUpperLimited()) {
- success = rootMinimizer()->SetUpperLimitedVariable(index, par.name().c_str(),
- par.value(), par.step(),
- par.limits().upperLimit());
+ success = rootMinimizer()->SetUpperLimitedVariable(index, par.name().c_str(), par.value(),
+ par.step(), par.limits().upperLimit());
}
else if (par.limits().isLimitless()) {
- success = rootMinimizer()->SetVariable(index, par.name().c_str(), par.value(),
- par.step());
+ success = rootMinimizer()->SetVariable(index, par.name().c_str(), par.value(), par.step());
}
else {
throw std::runtime_error("BasicMinimizer::setParameter() -> Error! Unexpected parameter.");
}
- if( !success ) {
+ if (!success) {
std::ostringstream ostr;
ostr << "BasicMinimizer::setParameter() -> Error! Can't set minimizer's fit parameter";
ostr << "Index:" << index << " name '" << par.name() << "'";
throw std::runtime_error(ostr.str());
}
-
}
//! Returns number of fit parameters defined (i.e. dimension of the function to be minimized).
@@ -201,9 +193,9 @@ size_t RootMinimizerAdapter::fitDimension() const
std::vector<double> RootMinimizerAdapter::parValuesAtMinimum() const
{
- std::vector<double > result;
+ std::vector<double> result;
result.resize(fitDimension(), 0.0);
- std::copy(rootMinimizer()->X(), rootMinimizer()->X()+fitDimension(), result.begin());
+ std::copy(rootMinimizer()->X(), rootMinimizer()->X() + fitDimension(), result.begin());
return result;
}
@@ -211,16 +203,17 @@ std::vector<double> RootMinimizerAdapter::parValuesAtMinimum() const
std::vector<double> RootMinimizerAdapter::parErrorsAtMinimum() const
{
- std::vector<double > result;
+ std::vector<double> result;
result.resize(fitDimension(), 0.0);
- if(rootMinimizer()->Errors() != 0 ) {
- std::copy(rootMinimizer()->Errors(), rootMinimizer()->Errors()+fitDimension(),
+ if (rootMinimizer()->Errors() != 0) {
+ std::copy(rootMinimizer()->Errors(), rootMinimizer()->Errors() + fitDimension(),
result.begin());
}
return result;
}
-RootMinimizerAdapter::root_minimizer_t *RootMinimizerAdapter::rootMinimizer() {
- return const_cast<root_minimizer_t *>(
- static_cast<const RootMinimizerAdapter *>(this)->rootMinimizer());
+RootMinimizerAdapter::root_minimizer_t* RootMinimizerAdapter::rootMinimizer()
+{
+ return const_cast<root_minimizer_t*>(
+ static_cast<const RootMinimizerAdapter*>(this)->rootMinimizer());
}
diff --git a/Fit/RootAdapter/RootMinimizerAdapter.h b/Fit/RootAdapter/RootMinimizerAdapter.h
index 209b36ad64c60ebb16eb7e0b546c65a9f5f0756e..ff39d74cf94cc74f63983db4796673ef1d6061f4 100644
--- a/Fit/RootAdapter/RootMinimizerAdapter.h
+++ b/Fit/RootAdapter/RootMinimizerAdapter.h
@@ -16,14 +16,15 @@
#define ROOTMINIMIZERADAPTER_H
#include "IMinimizer.h"
-#include "MinimizerOptions.h"
#include "MinimizerInfo.h"
-#include <string>
+#include "MinimizerOptions.h"
#include <memory>
+#include <string>
namespace Fit {
class Parameters; class Parameter; class ObjectiveFunctionAdapter; class MinimizerResult;
}
+
namespace ROOT { namespace Math { class Minimizer; } }
//! Pure virtual interface that adapts the CERN ROOT minimizer to our IMinimizer.
@@ -69,7 +70,7 @@ protected:
void propagateResults(Fit::Parameters& parameters);
- virtual bool isGradientBasedAgorithm() { return false;}
+ virtual bool isGradientBasedAgorithm() { return false; }
virtual void setParameter(unsigned int index, const Fit::Parameter& par);
size_t fitDimension() const;
std::vector<double> parValuesAtMinimum() const;
@@ -79,15 +80,13 @@ protected:
virtual const root_minimizer_t* rootMinimizer() const = 0;
root_minimizer_t* rootMinimizer();
- template<class T>
- OptionContainer::option_t addOption(
- const std::string& optionName, T value, const std::string& description="");
+ template <class T>
+ OptionContainer::option_t addOption(const std::string& optionName, T value,
+ const std::string& description = "");
- template<class T>
- void setOptionValue(const std::string& optionName, T value);
+ template <class T> void setOptionValue(const std::string& optionName, T value);
- template<class T>
- T optionValue(const std::string& optionName) const;
+ template <class T> T optionValue(const std::string& optionName) const;
private:
MinimizerOptions m_options;
@@ -96,21 +95,19 @@ private:
bool m_status;
};
-template<class T>
-OptionContainer::option_t RootMinimizerAdapter::addOption(
- const std::string& optionName, T value, const std::string& description)
+template <class T>
+OptionContainer::option_t RootMinimizerAdapter::addOption(const std::string& optionName, T value,
+ const std::string& description)
{
return m_options.addOption(optionName, value, description);
}
-template<class T>
-void RootMinimizerAdapter::setOptionValue(const std::string& optionName, T value)
+template <class T> void RootMinimizerAdapter::setOptionValue(const std::string& optionName, T value)
{
m_options.setOptionValue(optionName, value);
}
-template<class T>
-T RootMinimizerAdapter::optionValue(const std::string& optionName) const
+template <class T> T RootMinimizerAdapter::optionValue(const std::string& optionName) const
{
return m_options.optionValue<T>(optionName);
}
diff --git a/Fit/RootAdapter/RootResidualFunction.cpp b/Fit/RootAdapter/RootResidualFunction.cpp
index 377ef831e13b80eb1f39853fc68266089a5531b9..d592f617953e309b1a3ba0dc6f28989cc46d6380 100644
--- a/Fit/RootAdapter/RootResidualFunction.cpp
+++ b/Fit/RootAdapter/RootResidualFunction.cpp
@@ -15,12 +15,11 @@
#include "RootResidualFunction.h"
RootResidualFunction::RootResidualFunction(objective_function_t objective_fun,
- gradient_function_t gradient_fun, size_t npars, size_t ndatasize)
- : ROOT::Math::FitMethodFunction(static_cast<int>(npars), static_cast<int>(ndatasize))
- , m_objective_fun(objective_fun)
- , m_gradient_fun(gradient_fun)
- , m_npars(npars)
- , m_datasize(ndatasize)
+ gradient_function_t gradient_fun, size_t npars,
+ size_t ndatasize)
+ : ROOT::Math::FitMethodFunction(static_cast<int>(npars), static_cast<int>(ndatasize)),
+ m_objective_fun(objective_fun), m_gradient_fun(gradient_fun), m_npars(npars),
+ m_datasize(ndatasize)
{
}
diff --git a/Fit/RootAdapter/RootResidualFunction.h b/Fit/RootAdapter/RootResidualFunction.h
index dbe39628563368deadd13c9d8dbe2b815a34f366..16d4fd0803bc25509acb9d5868956f3ace446023 100644
--- a/Fit/RootAdapter/RootResidualFunction.h
+++ b/Fit/RootAdapter/RootResidualFunction.h
@@ -54,7 +54,7 @@ private:
double DoEval(const double* pars) const override;
objective_function_t m_objective_fun; //!< User function to get value to minimizer.
- gradient_function_t m_gradient_fun; //!< User function to get residual and gradients.
+ gradient_function_t m_gradient_fun; //!< User function to get residual and gradients.
size_t m_npars;
size_t m_datasize;
};
diff --git a/Fit/RootAdapter/RootScalarFunction.cpp b/Fit/RootAdapter/RootScalarFunction.cpp
index 303ffd6d27830309d96a4f9f2d9b41e21140df46..29fb23318fda8d9e70f08c2634498f294f098760 100644
--- a/Fit/RootAdapter/RootScalarFunction.cpp
+++ b/Fit/RootAdapter/RootScalarFunction.cpp
@@ -15,4 +15,4 @@
#include "RootScalarFunction.h"
RootScalarFunction::RootScalarFunction(root_objective_t fcn, int ndims)
- : ROOT::Math::Functor(fcn, ndims) {}
+ : ROOT::Math::Functor(fcn, static_cast<unsigned int>(ndims)) {}
diff --git a/Fit/RootAdapter/SimAnMinimizer.cpp b/Fit/RootAdapter/SimAnMinimizer.cpp
index 029d88322377715e07fbb0ac975cb0ccbbeb40c2..f1dd4f31b7f00879ae2ac1ba167ab5b376af47e0 100644
--- a/Fit/RootAdapter/SimAnMinimizer.cpp
+++ b/Fit/RootAdapter/SimAnMinimizer.cpp
@@ -17,10 +17,10 @@
#include "MinimizerConstants.h"
#ifdef _WIN32
-#pragma warning ( push )
-#pragma warning ( disable: 4267 )
+#pragma warning(push)
+#pragma warning(disable : 4267)
#include "Math/GSLSimAnMinimizer.h"
-#pragma warning ( pop )
+#pragma warning(pop)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -29,8 +29,8 @@
#endif
SimAnMinimizer::SimAnMinimizer()
- : RootMinimizerAdapter(MinimizerInfo::buildGSLSimAnInfo())
- , m_siman_minimizer(new ROOT::Math::GSLSimAnMinimizer())
+ : RootMinimizerAdapter(MinimizerInfo::buildGSLSimAnInfo()),
+ m_siman_minimizer(new ROOT::Math::GSLSimAnMinimizer())
{
addOption(OptionNames::PrintLevel, 0, "Minimizer internal print level");
addOption(OptionNames::MaxIterations, 100, "Number of points to try for each step");
@@ -42,7 +42,7 @@ SimAnMinimizer::SimAnMinimizer()
addOption(OptionNames::BoltzmannTmin, 0.1, "Boltzmann minimal temperature");
}
-SimAnMinimizer::~SimAnMinimizer() {}
+SimAnMinimizer::~SimAnMinimizer() = default;
void SimAnMinimizer::setPrintLevel(int value)
{
@@ -131,7 +131,10 @@ std::map<std::string, std::string> SimAnMinimizer::statusMap() const
return result;
}
-bool SimAnMinimizer::isGradientBasedAgorithm() { return false; }
+bool SimAnMinimizer::isGradientBasedAgorithm()
+{
+ return false;
+}
void SimAnMinimizer::propagateOptions()
{
diff --git a/Fit/RootAdapter/SimAnMinimizer.h b/Fit/RootAdapter/SimAnMinimizer.h
index 070775a43120676beef4be8112738be71737eb78..d556d0fb7a6a5ece63f111cc1c530dc9a2525855 100644
--- a/Fit/RootAdapter/SimAnMinimizer.h
+++ b/Fit/RootAdapter/SimAnMinimizer.h
@@ -22,7 +22,8 @@ namespace ROOT { namespace Math { class GSLSimAnMinimizer; } }
//! Wrapper for the CERN ROOT facade of the GSL simmulated annealing minimizer.
//! @ingroup fitting_internal
-class BA_CORE_API_ SimAnMinimizer : public RootMinimizerAdapter {
+class BA_CORE_API_ SimAnMinimizer : public RootMinimizerAdapter
+{
public:
SimAnMinimizer();
~SimAnMinimizer();
@@ -61,7 +62,7 @@ public:
double boltzmannMinTemp() const;
std::map<std::string, std::string> statusMap() const override;
- virtual bool isGradientBasedAgorithm() override;
+ virtual bool isGradientBasedAgorithm() override;
protected:
void propagateOptions() override;