diff --git a/Fit/CMakeLists.txt b/Fit/CMakeLists.txt
index f93f95aa12ea8363c17cf6232a59c24217473704..1a645f659a45f1ff0c8232b352ba9939e9655d28 100644
--- a/Fit/CMakeLists.txt
+++ b/Fit/CMakeLists.txt
@@ -22,6 +22,8 @@ file(GLOB include_files
if(NOT ROOT_FOUND)
list(REMOVE_ITEM source_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/src/ROOTGeneticMinimizer.cpp")
list(REMOVE_ITEM include_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/inc/ROOTGeneticMinimizer.h")
+ list(REMOVE_ITEM source_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/src/GeneticMinimizer.cxx")
+ list(REMOVE_ITEM include_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/inc/GeneticMinimizer.h")
endif()
if(BORNAGAIN_PYTHON)
@@ -71,13 +73,18 @@ target_link_libraries(
${GSL_LIBRARIES}
)
+
if(ROOT_FOUND)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_GENETIC_MINIMIZER")
include_directories(
${ROOT_INCLUDE_DIR}
)
+# target_link_libraries(${library_name}
+# ${ROOT_LIBRARIES} -lGenetic -lTMVA
+# )
target_link_libraries(${library_name}
- ${ROOT_LIBRARIES} -lGenetic -lTMVA
+ ${ROOT_LIBRARIES} -lTMVA
+# -L${ROOT_LIBRARY_DIR} -lTMVA
)
endif()
diff --git a/Fit/FitKernel/inc/FitSuite.h b/Fit/FitKernel/inc/FitSuite.h
index 2723416547fe9d8fd96d899d3c0aa9436de202a1..7dbe7d488f852875ed516d7ff13311b90dccc348 100644
--- a/Fit/FitKernel/inc/FitSuite.h
+++ b/Fit/FitKernel/inc/FitSuite.h
@@ -58,7 +58,7 @@ class BA_CORE_API_ FitSuite : public IObservable
void addFitStrategy(const IFitStrategy &strategy);
//! Sets minimizer
- void setMinimizer(IMinimizer *minimizer) { delete m_minimizer; m_minimizer = minimizer; }
+ void setMinimizer(IMinimizer *minimizer);
//! Returns minimizer
IMinimizer *getMinimizer() { return m_minimizer; }
diff --git a/Fit/FitKernel/inc/GeneticMinimizer.h b/Fit/FitKernel/inc/GeneticMinimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..46e3a0f4e5e0644c81cc43fadc380ecf695e4c1d
--- /dev/null
+++ b/Fit/FitKernel/inc/GeneticMinimizer.h
@@ -0,0 +1,112 @@
+// @(#)root/mathcore:$Id
+
+/**********************************************************************
+ * *
+ * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
+ * *
+ * *
+ **********************************************************************/
+
+// Header file for class GeneticMinimizer
+
+#ifndef ROOT_Math_GeneticMinimizer
+#define ROOT_Math_GeneticMinimizer
+
+#include <vector>
+
+#include "Math/Minimizer.h"
+
+#include "TMVA/IFitterTarget.h"
+#include "TMVA/Interval.h"
+
+namespace ROOT {
+ namespace Math {
+
+
+//_______________________________________________________________________________
+/*
+ structure containing the parameters of the genetic minimizer
+ */
+struct GeneticMinimizerParameters {
+
+ Int_t fPopSize;
+ Int_t fNsteps;
+ Int_t fCycles;
+ Int_t fSC_steps;
+ Int_t fSC_rate;
+ Double_t fSC_factor;
+ Double_t fConvCrit;
+ Int_t fSeed;
+
+
+ // constructor with default value
+ GeneticMinimizerParameters();
+};
+
+
+
+//_______________________________________________________________________________
+/**
+ GeneticMinimizer
+
+ @ingroup MultiMin
+*/
+class GeneticMinimizer: public ROOT::Math::Minimizer {
+
+public:
+
+ //GeneticMinimizer (int = 0);
+ GeneticMinimizer (int i = 0);
+ virtual ~GeneticMinimizer ();
+
+ virtual void Clear();
+ using ROOT::Math::Minimizer::SetFunction;
+ virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func);
+
+ virtual bool SetLimitedVariable(unsigned int , const std::string& , double , double , double, double);
+ virtual bool SetVariable(unsigned int ivar, const std::string & name, double val, double step);
+ virtual bool SetFixedVariable(unsigned int ivar , const std::string & name , double val);
+
+ virtual bool Minimize();
+ virtual double MinValue() const;
+ virtual double Edm() const;
+ virtual const double * X() const;
+ virtual const double * MinGradient() const;
+ virtual unsigned int NCalls() const;
+
+ virtual unsigned int NDim() const;
+ virtual unsigned int NFree() const;
+
+ virtual bool ProvidesError() const;
+ virtual const double * Errors() const;
+
+ virtual double CovMatrix(unsigned int i, unsigned int j) const;
+
+ void SetParameters(const GeneticMinimizerParameters & params );
+
+ void SetRandomSeed(int seed) { fParameters.fSeed = seed; }
+
+ const GeneticMinimizerParameters & MinimizerParameters() const { return fParameters; }
+
+ virtual ROOT::Math::MinimizerOptions Options() const;
+
+ virtual void SetOptions(const ROOT::Math::MinimizerOptions & opt);
+
+protected:
+
+ void GetGeneticOptions(ROOT::Math::MinimizerOptions & opt) const;
+
+ std::vector<TMVA::Interval*> fRanges;
+ TMVA::IFitterTarget* fFitness;
+ double fMinValue;
+ std::vector<double> fResult;
+
+ GeneticMinimizerParameters fParameters;
+
+};
+
+
+ } // end namespace Math
+} // end namespace ROOT
+
+#endif /* ROOT_Math_GeneticMinimizer */
diff --git a/Fit/FitKernel/src/FitSuite.cpp b/Fit/FitKernel/src/FitSuite.cpp
index f71c2699517563651df9658388b00351f7f178e3..f0654eb8b696eb79345cb296730fc052767e8bda 100644
--- a/Fit/FitKernel/src/FitSuite.cpp
+++ b/Fit/FitKernel/src/FitSuite.cpp
@@ -76,6 +76,14 @@ void FitSuite::addFitStrategy(const IFitStrategy &strategy)
addFitStrategy(strategy.clone());
}
+void FitSuite::setMinimizer(IMinimizer *minimizer)
+{
+ delete m_minimizer;
+ m_minimizer = minimizer;
+ if(!m_minimizer) {
+ msglog(MSG::WARNING) << "FitSuite::setMinimizer() -> Warning. Attempt to set NULL minimizer.";
+ }
+}
//! link FitMultiParameters with simulation parameters
void FitSuite::link_fit_parameters()
diff --git a/Fit/FitKernel/src/GeneticMinimizer.cxx b/Fit/FitKernel/src/GeneticMinimizer.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b454194f9ddb596be685409fbe77c28f0a70e753
--- /dev/null
+++ b/Fit/FitKernel/src/GeneticMinimizer.cxx
@@ -0,0 +1,372 @@
+#include "Math/GeneticMinimizer.h"
+
+#include "TMVA/GeneticAlgorithm.h"
+#include "TMVA/IFitterTarget.h"
+
+#include "Math/IFunction.h"
+#include "Math/GenAlgoOptions.h"
+
+#include "TError.h"
+
+#include <cassert>
+
+namespace ROOT {
+namespace Math {
+
+
+// wrapper class for TMVA interface to evaluate objective function
+class MultiGenFunctionFitness : public TMVA::IFitterTarget {
+private:
+ unsigned int fNCalls;
+ unsigned int fNFree;
+ const ROOT::Math::IMultiGenFunction& fFunc;
+ std::vector<int> fFixedParFlag;
+ mutable std::vector<double> fValues;
+
+public:
+ MultiGenFunctionFitness(const ROOT::Math::IMultiGenFunction& function) : fNCalls(0),
+ fFunc(function)
+ { fNFree = fFunc.NDim(); }
+
+ unsigned int NCalls() const { return fNCalls; }
+ unsigned int NDims() const { return fNFree; }
+
+ unsigned int NTotal() const { return fFunc.NDim(); }
+
+ void FixParameter(unsigned int ipar, double value, bool fix = true) {
+
+ if (fValues.size() != fFunc.NDim() ) {
+ fValues.resize(fFunc.NDim() );
+ fFixedParFlag.resize(fFunc.NDim());
+ }
+
+ if (ipar >= fValues.size() ) return;
+
+ // first find if it has been already fixed
+ fFixedParFlag[ipar] = fix;
+ fValues[ipar] = value;
+ // count number of fixed params
+ for (unsigned int i = 0; i < fFixedParFlag.size(); ++i)
+ if (!fFixedParFlag[i] ) fNFree++;
+
+ }
+
+ // transfrom from internal parameters (not fixed to external vector which include the fixed ones)
+ const std::vector<double> & Transform( const std::vector<double> & factors) const {
+ unsigned int n = fValues.size();
+ if (n == 0 || fNFree == n )
+ return factors;
+
+ // in case of fixed parameters
+ for (unsigned int i = 0, j = 0; i < n ; ++i) {
+ if (!fFixedParFlag[i] ) {
+ assert (j < fNFree);
+ fValues[i] = factors[j];
+ j++;
+ }
+ }
+ return fValues;
+ }
+
+ Double_t Evaluate(const std::vector<double> & factors ) const {
+ const std::vector<double> & x = Transform( factors);
+ return fFunc(&x[0]);
+ }
+
+ Double_t EstimatorFunction(std::vector<double> & factors ){
+ fNCalls += 1;
+ return Evaluate( factors);
+ }
+};
+
+GeneticMinimizerParameters::GeneticMinimizerParameters()
+{
+ // constructor of parameters with default values (use 100 is max iterations is not defined)
+ int defmaxiter = ROOT::Math::MinimizerOptions::DefaultMaxIterations();
+ fNsteps = (defmaxiter > 0) ? defmaxiter : 100;
+ fPopSize =300;
+ fCycles = 3;
+ fSC_steps =10;
+ fSC_rate =5;
+ fSC_factor=0.95;
+ fConvCrit =10.0 * ROOT::Math::MinimizerOptions::DefaultTolerance(); // default is 0.001
+ if (fConvCrit <=0 ) fConvCrit = 0.001;
+ fSeed=0; // random seed
+}
+
+// genetic minimizer class
+
+GeneticMinimizer::GeneticMinimizer(int ):
+ fFitness(0),
+ fMinValue(0),
+ fParameters(GeneticMinimizerParameters() )
+{
+
+ // check with default minimizer options
+ ROOT::Math::IOptions * geneticOpt = ROOT::Math::MinimizerOptions::FindDefault("Genetic");
+ if (geneticOpt) {
+ ROOT::Math::MinimizerOptions opt; // create using default options
+ opt.SetExtraOptions(*geneticOpt);
+ this->SetOptions(opt);
+ }
+
+ // set the parameters
+ SetTolerance(0.1 * fParameters.fConvCrit);
+ SetMaxIterations( fParameters.fNsteps);
+ }
+
+GeneticMinimizer::~GeneticMinimizer()
+{
+ if ( fFitness )
+ {
+ delete fFitness;
+ fFitness = 0;
+ }
+}
+
+void GeneticMinimizer::Clear()
+{
+ fRanges.clear();
+ fResult.clear();
+ if ( fFitness )
+ {
+ delete fFitness;
+ fFitness = 0;
+ }
+}
+
+void GeneticMinimizer::SetFunction(const ROOT::Math::IMultiGenFunction & func)
+{
+ Clear();
+
+ fFitness = new MultiGenFunctionFitness(func);
+ fResult = std::vector<double>(func.NDim() );
+ assert(fResult.size() == NDim() );
+}
+
+bool GeneticMinimizer::SetLimitedVariable(unsigned int , const std::string & , double , double , double lower , double upper )
+{
+ fRanges.push_back( new TMVA::Interval(lower,upper) );
+
+ return true;
+}
+
+bool GeneticMinimizer::SetVariable(unsigned int, const std::string& name, double value, double step)
+{
+ //It does nothing! As there is no variable if it has no limits!
+ double lower = value - (50 * step);
+ double upper = value + (50 * step);
+ Info("GeneticMinimizer::SetVariable", "Variables should be limited - set automatic range to 50 times step size for %s : [%f, %f]",
+ name.c_str(),lower,upper);
+ fRanges.push_back( new TMVA::Interval(lower, upper ) );
+
+ return true;
+}
+
+bool GeneticMinimizer::SetFixedVariable(unsigned int par, const std::string& name, double value) {
+ // set a fixed variable
+ if (!fFitness) {
+ Error("GeneticMinimizer::SetFixedVariable", "Function has not been set - cannot set fixed variables %s",name.c_str());
+ return false;
+ }
+
+ static_cast<MultiGenFunctionFitness*>(fFitness)->FixParameter(par, value);
+ return true;
+}
+
+
+void GeneticMinimizer::SetParameters(const GeneticMinimizerParameters & params )
+{
+ fParameters = params;
+ // set also the one defined in Minimizer
+ SetTolerance( 0.1 * fParameters.fConvCrit);
+ SetMaxIterations( fParameters.fNsteps );
+}
+
+ROOT::Math::MinimizerOptions GeneticMinimizer::Options() const {
+ ROOT::Math::MinimizerOptions opt;
+ GetGeneticOptions(opt);
+ return opt;
+}
+
+void GeneticMinimizer::GetGeneticOptions(ROOT::Math::MinimizerOptions & opt) const {
+ // get the genetic options of the class and return them in the MinimizerOptions class
+ opt.SetTolerance(fParameters.fConvCrit/10); // use a factor of 10 to have default as Minuit
+ opt.SetPrintLevel(PrintLevel() );
+ opt.SetMaxIterations(fParameters.fNsteps);
+ // use fixed or dammy value for the other options
+ opt.SetMinimizerType("Genetic");
+ opt.SetMaxFunctionCalls(0);
+ opt.SetStrategy(-1);
+ opt.SetErrorDef(0);
+ opt.SetPrecision(0);
+ opt.SetMinimizerAlgorithm("");
+
+ ROOT::Math::GenAlgoOptions geneticOpt;
+ geneticOpt.SetValue("PopSize",fParameters.fPopSize);
+ geneticOpt.SetValue("Steps",fParameters.fNsteps);
+ geneticOpt.SetValue("Cycles",fParameters.fCycles);
+ geneticOpt.SetValue("SC_steps",fParameters.fSC_steps);
+ geneticOpt.SetValue("SC_rate",fParameters.fSC_rate);
+ geneticOpt.SetValue("SC_factor",fParameters.fSC_factor);
+ geneticOpt.SetValue("ConvCrit",fParameters.fConvCrit);
+ geneticOpt.SetValue("RandomSeed",fParameters.fSeed);
+
+ opt.SetExtraOptions(geneticOpt);
+}
+
+void GeneticMinimizer::SetOptions(const ROOT::Math::MinimizerOptions & opt)
+{
+ SetTolerance(opt.Tolerance() );
+ SetPrintLevel(opt.PrintLevel() );
+ //SetMaxFunctionCalls(opt.MaxFunctionCalls() );
+ SetMaxIterations(opt.MaxIterations() );
+
+ fParameters.fConvCrit = 10.*opt.Tolerance(); // use a factor of 10 to have default as Minuit
+
+ // set genetic parameter from minimizer options
+ const ROOT::Math::IOptions * geneticOpt = opt.ExtraOptions();
+ if (!geneticOpt) {
+ Warning("GeneticMinimizer::SetOptions", "No specific genetic minimizer options have been set");
+ return;
+ }
+
+ // if options are not existing values will not be set
+ geneticOpt->GetValue("PopSize",fParameters.fPopSize);
+ geneticOpt->GetValue("Steps",fParameters.fNsteps);
+ geneticOpt->GetValue("Cycles",fParameters.fCycles);
+ geneticOpt->GetValue("SC_steps",fParameters.fSC_steps);
+ geneticOpt->GetValue("SC_rate",fParameters.fSC_rate);
+ geneticOpt->GetValue("SC_factor",fParameters.fSC_factor);
+ geneticOpt->GetValue("ConvCrit",fParameters.fConvCrit);
+ geneticOpt->GetValue("RandomSeed",fParameters.fSeed);
+
+ // use same of options in base class
+ int maxiter = opt.MaxIterations();
+ if (maxiter > 0 && fParameters.fNsteps > 0 && maxiter != fParameters.fNsteps ) {
+ Warning("GeneticMinimizer::SetOptions", "max iterations value given different than than Steps - set equal to Steps %d",fParameters.fNsteps);
+ }
+ if (fParameters.fNsteps > 0) SetMaxIterations(fParameters.fNsteps);
+
+}
+
+bool GeneticMinimizer::Minimize()
+{
+
+ if (!fFitness) {
+ Error("GeneticMinimizer::Minimize","Fitness function has not been set");
+ return false;
+ }
+
+ // sync parameters
+ if (MaxIterations() > 0) fParameters.fNsteps = MaxIterations();
+ if (Tolerance() > 0) fParameters.fConvCrit = 10* Tolerance();
+
+ TMVA::GeneticAlgorithm mg( *fFitness, fParameters.fPopSize, fRanges, fParameters.fSeed );
+
+ if (PrintLevel() > 0) {
+ std::cout << "GeneticMinimizer::Minimize - Start iterating - max iterations = " << MaxIterations()
+ << " conv criteria (tolerance) = " << fParameters.fConvCrit << std::endl;
+ }
+
+ fStatus = 0;
+ unsigned int niter = 0;
+ do {
+ mg.Init();
+
+ mg.CalculateFitness();
+
+ // Just for debugging options
+ //mg.GetGeneticPopulation().Print(0);
+
+ mg.GetGeneticPopulation().TrimPopulation();
+
+ mg.SpreadControl( fParameters.fSC_steps, fParameters.fSC_rate, fParameters.fSC_factor );
+
+ if (PrintLevel() > 2) {
+ std::cout << "New Iteration " << niter << " with parameter values :" << std::endl;
+ TMVA::GeneticGenes* genes = mg.GetGeneticPopulation().GetGenes( 0 );
+ if (genes) {
+ std::vector<Double_t> gvec;
+ gvec = genes->GetFactors();
+ for (unsigned int i = 0; i < gvec.size(); ++i) {
+ std::cout << gvec[i] << " ";
+ }
+ std::cout << std::endl;
+ std::cout << "\tFitness function value = " << static_cast<MultiGenFunctionFitness*>(fFitness)->Evaluate(gvec) << std::endl;
+ }
+ }
+ niter++;
+ if ( niter > MaxIterations() && MaxIterations() > 0) {
+ if (PrintLevel() > 0) {
+ Info("GeneticMinimizer::Minimize","Max number of iterations %d reached - stop iterating",MaxIterations());
+ }
+ fStatus = 1;
+ break;
+ }
+
+ } while (!mg.HasConverged( fParameters.fNsteps, fParameters.fConvCrit )); // converged if: fitness-improvement < CONVCRIT within the last CONVSTEPS loops
+
+ TMVA::GeneticGenes* genes = mg.GetGeneticPopulation().GetGenes( 0 );
+ std::vector<Double_t> gvec;
+ gvec = genes->GetFactors();
+
+
+ // transform correctly gvec on fresult in case there are fixed parameters
+ const std::vector<double> & transVec = static_cast<MultiGenFunctionFitness*>(fFitness)->Transform(gvec);
+ std::copy(transVec.begin(), transVec.end(), fResult.begin() );
+ fMinValue = static_cast<MultiGenFunctionFitness*>(fFitness)->Evaluate(gvec);
+
+
+ if (PrintLevel() > 0) {
+ if (PrintLevel() > 2) std::cout << std::endl;
+ std::cout << "Finished Iteration (niter = " << niter << " with fitness function value = " << MinValue() << std::endl;
+ for (unsigned int i = 0; i < fResult.size(); ++i) {
+ std::cout << " Parameter-" << i << "\t=\t" << fResult[i] << std::endl;
+ }
+ }
+
+ return true;
+}
+
+double GeneticMinimizer::MinValue() const
+{
+ return (fFitness) ? fMinValue : 0;
+}
+
+const double * GeneticMinimizer::X() const {
+ return (fFitness) ? &fResult[0] : 0;
+}
+
+unsigned int GeneticMinimizer::NCalls() const
+{
+ if ( fFitness )
+ return static_cast<MultiGenFunctionFitness*>(fFitness)->NCalls();
+ else
+ return 0;
+}
+
+unsigned int GeneticMinimizer::NDim() const
+{
+ if ( fFitness )
+ return static_cast<MultiGenFunctionFitness*>(fFitness)->NTotal();
+ else
+ return 0;
+}
+unsigned int GeneticMinimizer::NFree() const
+{
+ if ( fFitness )
+ return static_cast<MultiGenFunctionFitness*>(fFitness)->NDims();
+ else
+ return 0;
+}
+
+// Functions we don't need...
+const double * GeneticMinimizer::MinGradient() const { return 0; }
+bool GeneticMinimizer::ProvidesError() const { return false; }
+const double * GeneticMinimizer::Errors() const { return 0; }
+double GeneticMinimizer::Edm() const { return 0; }
+double GeneticMinimizer::CovMatrix(unsigned int, unsigned int) const { return 0; }
+
+}
+}
diff --git a/Fit/FitKernel/src/MinimizerFactory.cpp b/Fit/FitKernel/src/MinimizerFactory.cpp
index 576c004b160365c26f333a02dbf4610924ac72fd..5a3fab62a1e7e8af30674ca2ee61e377efc3f3b9 100644
--- a/Fit/FitKernel/src/MinimizerFactory.cpp
+++ b/Fit/FitKernel/src/MinimizerFactory.cpp
@@ -110,6 +110,10 @@ IMinimizer *MinimizerFactory::createMinimizer(const std::string& minimizer, cons
#ifdef HAS_GENETIC_MINIMIZER
} else if( minimizer == "Genetic" ) {
result = new ROOTGeneticMinimizer(minimizer, algorithm);
+#else
+ } else if( minimizer == "Genetic" ) {
+ std::cout << "MinimizerFactory::createMinimizer() -> Error! Genetic minimizer doesn't exists (compiled without ROOT support)." << std::endl;
+ result = 0;
#endif
}
diff --git a/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp b/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
index 815c76ef852c76b031c4fd8961e9707ede2853a5..7f41e0135edd43cd353cb204c957f70d878196b5 100644
--- a/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
+++ b/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
@@ -59,12 +59,6 @@ void ROOTGeneticMinimizer::propagateOptions()
{
ROOTMinimizer::propagateOptions();
-// if( m_options.getMaxIterations() > 0 && m_options.getMaxIterations() < m_options.getIntValue("Steps")) {
-// msglog(MSG::WARNING) << "ROOTGeneticMinimizer::propagateOptions() -> Max iterations smaller than Steps. ";
-// msglog(MSG::WARNING) << "Setting equal to steps " << m_options.getIntValue("Steps") << ".";
-// m_options.setMaxIterations(m_options.getIntValue("Steps"));
-// }
-
// setting minimizer parameters
ROOT::Math::GeneticMinimizerParameters pars;
pars.fPopSize = m_options.getIntValue("PopSize");
diff --git a/Tests/FunctionalTests/TestFit/TestFit01/TestFit01.cpp b/Tests/FunctionalTests/TestFit/TestFit01/TestFit01.cpp
index e2c7d32d68fb307bb5203893c611a0b4aaea3b8e..d43c3ee82c1c19d4204a7b10f0c06f302832e482 100644
--- a/Tests/FunctionalTests/TestFit/TestFit01/TestFit01.cpp
+++ b/Tests/FunctionalTests/TestFit/TestFit01/TestFit01.cpp
@@ -26,8 +26,8 @@ TestFit01::TestFit01()
{
m_minimizers.push_back( Minimizer("Minuit2","Migrad") );
m_minimizers.push_back( Minimizer("Minuit2","Fumili") );
- m_minimizers.push_back( Minimizer("GSLMultiMin","BFGS") );
- m_minimizers.push_back( Minimizer("GSLMultiMin","SteepestDescent") );
+// m_minimizers.push_back( Minimizer("GSLMultiMin","BFGS") );
+// m_minimizers.push_back( Minimizer("GSLMultiMin","SteepestDescent") );
m_minimizers.push_back( Minimizer("GSLLMA","") ); // this is Levenberg-Marquard
// m_minimizers.push_back( Minimizer("GSLSimAn","") );
// m_minimizers.push_back( Minimizer("Genetic","") );
diff --git a/ThirdParty/RootMinimizers/CMakeLists.txt b/ThirdParty/RootMinimizers/CMakeLists.txt
index d98a6e037212f404621ab277c7c0557ef7799afd..51e4c009647b85495c5980d03aa9312878d27d0a 100644
--- a/ThirdParty/RootMinimizers/CMakeLists.txt
+++ b/ThirdParty/RootMinimizers/CMakeLists.txt
@@ -23,6 +23,11 @@ file(GLOB include_files
"src/Math/*.h"
)
+#if(NOT ROOT_FOUND)
+# list(REMOVE_ITEM include_files GeneticMinimizer.h)
+# list(REMOVE_ITEM source_files GeneticMinimizer.cxx)
+#endif()
+
add_definitions(-DWARNINGMSG)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMATH_NO_PLUGIN_MANAGER -DHAS_MINUIT2 -DR__HAS_MATHMORE")
diff --git a/cmake/modules/FindROOT.cmake b/cmake/modules/FindROOT.cmake
index fcd453c2b768d5c954cc8c8029855ef4563a846e..7a0b262802e7ee880bfab6bac25e6f5890ce23d6 100644
--- a/cmake/modules/FindROOT.cmake
+++ b/cmake/modules/FindROOT.cmake
@@ -55,11 +55,11 @@ else()
endif()
# check if ROOT installation is complete
-if(NOT EXISTS "${ROOT_INCLUDE_DIR}/Math/GeneticMinimizer.h")
- message("--> ROOT installation is not complete. Can't find file ${ROOT_INCLUDE_DIR}/include/Math/GeneticMinimizer.h")
- message("--> Switching ROOT OFF")
- set(ROOT_FOUND FALSE)
-endif()
+#if(NOT EXISTS "${ROOT_INCLUDE_DIR}/Math/GeneticMinimizer.h")
+# message("--> ROOT installation is not complete. Can't find file ${ROOT_INCLUDE_DIR}/include/Math/GeneticMinimizer.h")
+# message("--> Switching ROOT OFF")
+# set(ROOT_FOUND FALSE)
+#endif()
#include(CMakeMacroParseArguments)
find_program(ROOTCINT_EXECUTABLE rootcint PATHS $ENV{ROOTSYS}/bin)
diff --git a/cmake/modules/SearchInstalledSoftware.cmake b/cmake/modules/SearchInstalledSoftware.cmake
index 5ef35cf1d79d0c5207d9aaf1b24b70fe1b051108..cff04a6c0d31e5e76c3e3b8b4942caabdc011b21 100644
--- a/cmake/modules/SearchInstalledSoftware.cmake
+++ b/cmake/modules/SearchInstalledSoftware.cmake
@@ -99,8 +99,7 @@ if(BORNAGAIN_PYTHON OR BORNAGAIN_GUI)
endif()
-
# --- ROOT ---
if(ROOT_SUPPORT)
-find_package(ROOT)
+ find_package(ROOT)
endif()