Minimizer.h

Go to the documentation of this file.

// Copyright (C) 2018  Philipp Basler and Margarete Mühlleitner
// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
// Müller
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef MINIMIZER_H_
#define MINIMIZER_H_
 
#include <BSMPT/config.h>
#include <BSMPT/models/IncludeAllModels.h>
#include <memory>
#include <thread>
#include <vector> // for vector
 
namespace BSMPT
{
class Class_Potential_Origin;
namespace Minimizer
{
 
// Here you can decide the default setting for the mnimizer
 
const bool UseGSLDefault = true;
 
#ifdef libcmaes_FOUND
const bool UseLibCMAESDefault = true;
#else
const bool UseLibCMAESDefault = false;
#endif
 
#ifdef NLopt_FOUND
const bool UseNLoptDefault = true;
#else
const bool UseNLoptDefault    = false;
#endif
 
const std::size_t Num_threads = std::thread::hardware_concurrency();
 
constexpr int CalcWhichMinimizer(bool UseGSL   = UseGSLDefault,
                                 bool UseCMAES = UseLibCMAESDefault,
                                 bool UseNLopt = UseNLoptDefault)
{
  return static_cast<int>(UseCMAES) + 2 * static_cast<int>(UseGSL) +
         4 * static_cast<int>(UseNLopt);
}
 
struct MinimizersToUse
{
  bool UseCMAES{UseLibCMAESDefault};
  bool UseGSL{UseGSLDefault};
  bool UseNLopt{UseNLoptDefault};
  MinimizersToUse(bool useCMAES, bool useGSL, bool useNLopt)
      : UseCMAES{useCMAES}
      , UseGSL{useGSL}
      , UseNLopt{useNLopt}
  {
  }
};
 
MinimizersToUse GetMinimizers(int WhichMinimizer);
 
constexpr int WhichMinimizerDefault = CalcWhichMinimizer();
 
std::vector<double>
Minimize_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
                 const double &Temp,
                 std::vector<double> &Check,
                 const std::vector<double> &start,
                 const int &WhichMinimizer = WhichMinimizerDefault,
                 bool UseMultithreading    = true);
 
enum class MinimizerStatus
{
  SUCCESS                 = 1,
  NOTVANISHINGATFINALTEMP = -1,
  NOTNLOSTABLE            = -2,
  NUMERICALLYUNSTABLE     = -3,
  BELOWTHRESHOLD          = -4,
  NLOVEVZEROORINF         = -5
 
};
 
struct EWPTReturnType
{
  MinimizerStatus StatusFlag;
  double vc;
  double Tc;
  std::vector<double> EWMinimum;
};
 
EWPTReturnType
PTFinder_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
                 const double &TempStart,
                 const double &TempEnd,
                 const int &WhichMinimizer = WhichMinimizerDefault,
                 bool UseMultithreading    = true);
 
[[deprecated("Will call Minimize_gen_all_tree_level with GetSMConstants(). "
             "Please use the "
             "detailed overload "
             "to ensure consistent SM constants through all "
             "routines.")]] std::vector<double>
Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model,
                            const std::vector<double> &par,
                            const std::vector<double> &parCT,
                            std::vector<double> &Check,
                            const std::vector<double> &start,
                            int WhichMinimizer     = WhichMinimizerDefault,
                            bool UseMultithreading = true);
 
std::vector<double>
Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model,
                            const std::vector<double> &par,
                            const std::vector<double> &parCT,
                            const ISMConstants &SMConstants,
                            std::vector<double> &Check,
                            const std::vector<double> &start,
                            int WhichMinimizer     = WhichMinimizerDefault,
                            bool UseMultithreading = true);
 
std::vector<std::vector<double>>
FindNextLocalMinima(const std::shared_ptr<Class_Potential_Origin> &model,
                    const std::vector<double> &StartingPoint,
                    const double &temperature,
                    int WhichMinimizer = WhichMinimizerDefault);
 
std::vector<std::vector<std::pair<double, std::vector<double>>>>
MinimaDevelopmentWithTemperature(
    const std::shared_ptr<Class_Potential_Origin> &model,
    const double &StartingTemperature,
    const double &FinalTemperature,
    const double &StepsizeTemperature,
    const std::vector<std::pair<double, double>> &RNGRanges,
    const std::size_t &seed,
    const std::size_t &NumberOfStartingPoints,
    const int &WhichMinimizer);
 
} // namespace Minimizer
} // namespace BSMPT
 
#endif /* MINIMIZER_H_ */