semi_analytic_solver.hpp

Go to the documentation of this file.

// ====================================================================
// This file is part of FlexibleSUSY.
//
// FlexibleSUSY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// FlexibleSUSY is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FlexibleSUSY.  If not, see
// <http://www.gnu.org/licenses/>.
// ====================================================================
 
#ifndef SEMI_ANALYTIC_SOLVER_H
#define SEMI_ANALYTIC_SOLVER_H
 
#include "rg_flow.hpp"
 
#include <memory>
#include <vector>
 
namespace flexiblesusy {
 
class Convergence_tester;
class Initial_guesser;
class Model;
class Single_scale_constraint;
class Single_scale_matching;
 
class Semi_analytic;
class Two_scale;
class Two_scale_running_precision;
 
template<>
class RGFlow<Semi_analytic> {
public:
   RGFlow() = default;
   RGFlow(const RGFlow&) = delete;
   RGFlow(RGFlow&&) = delete;
   ~RGFlow() = default;
   RGFlow& operator=(const RGFlow&) = delete;
   RGFlow& operator=(RGFlow&&) = delete;
 
   void add_inner(Single_scale_constraint*, Model*);
   void add_inner(Single_scale_matching*, Model*, Model*);
   void add_outer(Single_scale_constraint*, Model*);
   void add_outer(Single_scale_matching*, Model*, Model*);
   Model* get_model() const;
   int number_of_iterations_done() const;
   void reset();
   void run_to(double);
   void set_inner_convergence_tester(Convergence_tester*);
   void set_outer_convergence_tester(Convergence_tester*);
   void set_running_precision(Two_scale_running_precision*);
   void set_initial_guesser(Initial_guesser*);
   void solve();
 
private:
   struct Slider {
   public:
      virtual ~Slider() = default;
      virtual void clear_problems() {}
      virtual Model* get_model() = 0;
      virtual void add_constraint_to_solver(RGFlow<Two_scale>&) = 0;
      virtual double get_scale() = 0;
      virtual void slide() {}
      virtual void set_precision(double) {}
   };
 
   struct Constraint_slider : public Slider {
   public:
      Constraint_slider(Model* m, Single_scale_constraint* c)
         : model(m), constraint(c) {}
      virtual ~Constraint_slider() = default;
      virtual void clear_problems() override;
      virtual Model* get_model() override;
      virtual void add_constraint_to_solver(RGFlow<Two_scale>&) override;
      virtual double get_scale() override;
      virtual void slide() override;
      virtual void set_precision(double) override;
   private:
      Model* model;
      Single_scale_constraint* constraint;
   };
 
   struct Matching_slider : public Slider {
   public:
      Matching_slider(Model* m1_, Model* m2_, Single_scale_matching* mc)
         : m1(m1_), m2(m2_), matching(mc) {}
      virtual ~Matching_slider() = default;
      virtual void clear_problems() override;
      virtual Model* get_model() override;
      virtual void add_constraint_to_solver(RGFlow<Two_scale>&) override;
      virtual double get_scale() override;
      virtual void slide() override;
      virtual void set_precision(double) override;
   private:
      Model *m1, *m2;
      Single_scale_matching* matching;
   };
 
   std::vector<std::shared_ptr<Slider> > inner_sliders{}; 
   std::vector<std::shared_ptr<Slider> > outer_sliders{}; 
   int iteration{0};             
   Convergence_tester* inner_convergence_tester{nullptr}; 
   Convergence_tester* outer_convergence_tester{nullptr}; 
   Initial_guesser* initial_guesser{nullptr};       
   Two_scale_running_precision* running_precision_calculator{nullptr}; 
   double running_precision{1.0e-3};           
   double scale{0.};                           
 
   bool accuracy_goal_reached() const; 
   void check_setup() const;           
   void clear_problems();              
   void prepare_inner_iteration(RGFlow<Two_scale>& solver) const; 
   int get_max_iterations() const; 
   Model* get_model(double) const;     
   void initial_guess();               
   double get_precision();             
   void update_running_precision();    
   std::vector<std::shared_ptr<Slider> > sort_sliders(
      const std::vector<std::shared_ptr<Slider> >&) const; 
 
   void run_outer_sliders();           
};
 
} // namespace flexiblesusy
 
#endif