Rename base matching and composite convergence tester classes

to avoid having a dependence on the two-scale algorithm

examples/tower/MSSMD5O_MSSMRHN_spectrum_generator.hpp

@@ -34,12 +34,12 @@
 
 #include "MSSMD5O_MSSMRHN_two_scale_initial_guesser.hpp"
 
+#include "composite_convergence_tester.hpp"
 #include "coupling_monitor.hpp"
 #include "error.hpp"
 #include "numerics2.hpp"
 #include "two_scale_running_precision.hpp"
 #include "two_scale_solver.hpp"
-#include "two_scale_composite_convergence_tester.hpp"
 
 namespace flexiblesusy {
 
@@ -156,7 +156,7 @@ void MSSMD5O_MSSMRHN_spectrum_generator<T>::run
       convergence_tester_1.set_max_iterations(max_iterations);
       convergence_tester_2.set_max_iterations(max_iterations);
    }
-   Composite_convergence_tester<T> convergence_tester;
+   Composite_convergence_tester convergence_tester;
    convergence_tester.add_convergence_tester(&convergence_tester_1);
    convergence_tester.add_convergence_tester(&convergence_tester_2);
 

examples/tower/MSSMD5O_MSSMRHN_two_scale_matching.hpp

@@ -21,7 +21,7 @@
 
 #include "MSSMD5O_MSSMRHN_matching.hpp"
 #include "MSSMD5O_input_parameters.hpp"
-#include "two_scale_matching.hpp"
+#include "single_scale_matching.hpp"
 
 namespace flexiblesusy {
 
@@ -62,7 +62,7 @@ class MSSMD5O_MSSMRHN_matching {
 };
 
 template<>
-class MSSMD5O_MSSMRHN_matching_up<Two_scale> : public Matching<Two_scale> {
+class MSSMD5O_MSSMRHN_matching_up<Two_scale> : public Single_scale_matching {
 public:
     MSSMD5O_MSSMRHN_matching_up();
     MSSMD5O_MSSMRHN_matching_up(const MSSMD5O_input_parameters&);
@@ -79,7 +79,7 @@ class MSSMD5O_MSSMRHN_matching_up<Two_scale> : public Matching<Two_scale> {
 };
 
 template<>
-class MSSMD5O_MSSMRHN_matching_down<Two_scale> : public Matching<Two_scale> {
+class MSSMD5O_MSSMRHN_matching_down<Two_scale> : public Single_scale_matching {
 public:
     MSSMD5O_MSSMRHN_matching_down();
     MSSMD5O_MSSMRHN_matching_down(const MSSMD5O_input_parameters&);

src/two_scale_composite_convergence_tester.cpp → src/composite_convergence_tester.cpp

@@ -16,18 +16,12 @@
 // <http://www.gnu.org/licenses/>.
 // ====================================================================
 
-#include "two_scale_composite_convergence_tester.hpp"
+#include "composite_convergence_tester.hpp"
 #include <algorithm>
 
 namespace flexiblesusy {
 
-Composite_convergence_tester<Two_scale>::Composite_convergence_tester()
-   : Convergence_tester()
-   , testers()
-{
-}
-
-Composite_convergence_tester<Two_scale>::~Composite_convergence_tester()
+Composite_convergence_tester::~Composite_convergence_tester()
 {
 }
 
@@ -49,7 +43,7 @@ Composite_convergence_tester<Two_scale>::~Composite_convergence_tester()
  * calls of all convergence testers return true.  Otherewise false is
  * returned.
  */
-bool Composite_convergence_tester<Two_scale>::accuracy_goal_reached()
+bool Composite_convergence_tester::accuracy_goal_reached()
 {
    bool precision_reached = true;
 
@@ -61,7 +55,7 @@ bool Composite_convergence_tester<Two_scale>::accuracy_goal_reached()
    return precision_reached;
 }
 
-unsigned int Composite_convergence_tester<Two_scale>::max_iterations() const
+unsigned int Composite_convergence_tester::max_iterations() const
 {
    if (testers.empty())
       return 0;
@@ -73,13 +67,13 @@ unsigned int Composite_convergence_tester<Two_scale>::max_iterations() const
                              }))->max_iterations();
 }
 
-void Composite_convergence_tester<Two_scale>::restart()
+void Composite_convergence_tester::restart()
 {
    for (auto ct: testers)
       ct->restart();
 }
 
-void Composite_convergence_tester<Two_scale>::add_convergence_tester(Convergence_tester* t)
+void Composite_convergence_tester::add_convergence_tester(Convergence_tester* t)
 {
    if (t)
       testers.push_back(t);

src/composite_convergence_tester.hpp

@@ -19,10 +19,32 @@
 #ifndef COMPOSITE_CONVERGENCE_TESTER_H
 #define COMPOSITE_CONVERGENCE_TESTER_H
 
+#include "convergence_tester.hpp"
+#include <vector>
+
 namespace flexiblesusy {
 
-template <class T>
-class Composite_convergence_tester;
+/**
+ * @class Composite_convergence_tester
+ * @brief A composite convergence tester
+ *
+ * This class collects convergence testers that will be checked when
+ * Composite_convergence_tester::accuracy_goal_reached() is called.
+ */
+
+class Composite_convergence_tester : public Convergence_tester {
+public:
+   Composite_convergence_tester() = default;
+   virtual ~Composite_convergence_tester();
+
+   virtual bool accuracy_goal_reached() override;
+   virtual unsigned int max_iterations() const override;
+   virtual void restart() override;
+   void add_convergence_tester(Convergence_tester*);
+
+private:
+   std::vector<Convergence_tester*> testers{};
+};
 
 }
 

src/module.mk

@@ -10,6 +10,7 @@ LIBFLEXI_SRC := \
 		$(DIR)/build_info.cpp \
 		$(DIR)/ckm.cpp \
 		$(DIR)/command_line_options.cpp \
+		$(DIR)/composite_convergence_tester.cpp \
 		$(DIR)/convergence_tester.cpp \
 		$(DIR)/database.cpp \
 		$(DIR)/dilog.cpp \
@@ -83,7 +84,6 @@ LIBFLEXI_HDR := \
 		$(DIR)/linalg2.hpp \
 		$(DIR)/logger.hpp \
 		$(DIR)/lowe.h \
-		$(DIR)/matching.hpp \
 		$(DIR)/mathlink_utils.hpp \
 		$(DIR)/minimizer.hpp \
 		$(DIR)/model.hpp \
@@ -106,6 +106,7 @@ LIBFLEXI_HDR := \
 		$(DIR)/scan.hpp \
 		$(DIR)/sfermions.hpp \
 		$(DIR)/single_scale_constraint.hpp \
+		$(DIR)/single_scale_matching.hpp \
 		$(DIR)/slha_io.hpp \
 		$(DIR)/sm_twoloophiggs.hpp \
 		$(DIR)/split_threeloophiggs.hpp \
@@ -128,28 +129,22 @@ LIBFLEXI_HDR := \
 
 ifneq ($(findstring two_scale,$(SOLVERS)),)
 LIBFLEXI_SRC += \
-		$(DIR)/two_scale_composite_convergence_tester.cpp \
 		$(DIR)/two_scale_running_precision.cpp \
 		$(DIR)/two_scale_solver.cpp
 
 LIBFLEXI_HDR += \
-		$(DIR)/two_scale_composite_convergence_tester.hpp \
-		$(DIR)/two_scale_matching.hpp \
 		$(DIR)/two_scale_running_precision.hpp \
 		$(DIR)/two_scale_solver.hpp
 endif
 
 ifneq ($(findstring semi_analytic,$(SOLVERS)),)
 LIBFLEXI_SRC += \
 		$(DIR)/semi_analytic_solver.cpp \
-		$(DIR)/two_scale_composite_convergence_tester.cpp \
 		$(DIR)/two_scale_running_precision.cpp \
 		$(DIR)/two_scale_solver.cpp
 
 LIBFLEXI_HDR += \
 		$(DIR)/semi_analytic_solver.hpp \
-		$(DIR)/two_scale_composite_convergence_tester.hpp \
-		$(DIR)/two_scale_matching.hpp \
 		$(DIR)/two_scale_running_precision.hpp \
 		$(DIR)/two_scale_solver.hpp
 endif

src/two_scale_composite_convergence_tester.hpp → src/single_scale_matching.hpp

@@ -16,38 +16,19 @@
 // <http://www.gnu.org/licenses/>.
 // ====================================================================
 
-#ifndef TWO_SCALE_COMPOSITE_CONVERGENCE_TESTER_H
-#define TWO_SCALE_COMPOSITE_CONVERGENCE_TESTER_H
-
-#include "composite_convergence_tester.hpp"
-#include "convergence_tester.hpp"
-#include <vector>
+#ifndef SINGLE_SCALE_MATCHING_H
+#define SINGLE_SCALE_MATCHING_H
 
 namespace flexiblesusy {
 
-class Two_scale;
-
-/**
- * @class Composite_convergence_tester
- * @brief A composite convergence tester
- *
- * This class collects convergence testers that will be checked when
- * Composite_convergence_tester::accuracy_goal_reached() is called.
- */
+class Model;
 
-template<>
-class Composite_convergence_tester<Two_scale> : public Convergence_tester {
+class Single_scale_matching {
 public:
-   Composite_convergence_tester();
-   virtual ~Composite_convergence_tester();
-
-   virtual bool accuracy_goal_reached() override;
-   virtual unsigned int max_iterations() const override;
-   virtual void restart() override;
-   void add_convergence_tester(Convergence_tester*);
-
-private:
-   std::vector<Convergence_tester*> testers;
+   virtual ~Single_scale_matching() {}
+   virtual void match() = 0;
+   virtual double get_scale() const = 0;
+   virtual void set_models(Model*, Model*) = 0;
 };
 
 }

src/two_scale_solver.cpp

@@ -25,7 +25,7 @@
 #include "logger.hpp"
 #include "model.hpp"
 #include "single_scale_constraint.hpp"
-#include "two_scale_matching.hpp"
+#include "single_scale_matching.hpp"
 #include "two_scale_running_precision.hpp"
 
 #include <cmath>
@@ -64,7 +64,7 @@ void RGFlow<Two_scale>::add(Single_scale_constraint* c, Model* m)
  * @param m1 model 1
  * @param m2 model 2
  */
-void RGFlow<Two_scale>::add(Matching<Two_scale>* mc, Model* m1, Model* m2)
+void RGFlow<Two_scale>::add(Single_scale_matching* mc, Model* m1, Model* m2)
 {
    if (!mc) throw SetupError("matching condition pointer is NULL");
    if (!m1) throw SetupError("model pointer 1 is NULL");

src/two_scale_solver.hpp

@@ -32,11 +32,11 @@
 
 namespace flexiblesusy {
 
-template <class T> class Matching;
 class Convergence_tester;
 class Initial_guesser;
 class Model;
 class Single_scale_constraint;
+class Single_scale_matching;
 
 class Two_scale;
 class Two_scale_running_precision;
@@ -71,7 +71,7 @@ class RGFlow<Two_scale> {
    /// add constraint
    void add(Single_scale_constraint*, Model*);
    /// add matching condition
-   void add(Matching<Two_scale>*, Model*, Model*);
+   void add(Single_scale_matching*, Model*, Model*);
    /// get model at current scale
    Model* get_model() const;
    /// get number of used iterations
@@ -117,7 +117,7 @@ class RGFlow<Two_scale> {
 
    struct Matching_slider : public Slider {
    public:
-      Matching_slider(Model* m1_, Model* m2_, Matching<Two_scale>* mc)
+      Matching_slider(Model* m1_, Model* m2_, Single_scale_matching* mc)
          : m1(m1_), m2(m2_), matching(mc) {}
       virtual ~Matching_slider() {}
       virtual void clear_problems() override;
@@ -127,7 +127,7 @@ class RGFlow<Two_scale> {
       virtual void set_precision(double) override;
    private:
       Model *m1, *m2;
-      Matching<Two_scale>* matching;
+      Single_scale_matching* matching;
    };
 
    std::vector<std::shared_ptr<Slider> > sliders{}; ///< sliders to be run up and down

templates/standard_model_matching.cpp.in

@@ -20,7 +20,7 @@
 
 #include "@ModelName@_standard_model_matching.hpp"
 #include "wrappers.hpp"
-#include "two_scale_matching.hpp"
+#include "single_scale_matching.hpp"
 #include "two_loop_corrections.hpp"
 #include "standard_model.hpp"
 #include "@ModelName@_mass_eigenstates.hpp"

templates/standard_model_two_scale_high_scale_spectrum_generator.cpp.in

@@ -23,8 +23,8 @@
 #include "@ModelName@_two_scale_ewsb_solver.hpp"
 #include "@ModelName@_two_scale_initial_guesser.hpp"
 #include "standard_model_two_scale_convergence_tester.hpp"
-#include "two_scale_composite_convergence_tester.hpp"
 
+#include "composite_convergence_tester.hpp"
 #include "error.hpp"
 #include "lowe.h"
 #include "numerics2.hpp"
@@ -138,7 +138,7 @@ void @ModelName@_spectrum_generator<Two_scale>::run_except(const softsusy::QedQc
          this->settings.get(Spectrum_generator_settings::max_iterations));
    }
 
-   Composite_convergence_tester<Two_scale> cct;
+   Composite_convergence_tester cct;
    cct.add_convergence_tester(&model_ct);
    cct.add_convergence_tester(&eft_ct);
 

templates/standard_model_two_scale_low_scale_spectrum_generator.cpp.in

@@ -23,8 +23,8 @@
 #include "@ModelName@_two_scale_ewsb_solver.hpp"
 #include "@ModelName@_two_scale_initial_guesser.hpp"
 #include "standard_model_two_scale_convergence_tester.hpp"
-#include "two_scale_composite_convergence_tester.hpp"
 
+#include "composite_convergence_tester.hpp"
 #include "error.hpp"
 #include "lowe.h"
 #include "numerics2.hpp"
@@ -135,7 +135,7 @@ void @ModelName@_spectrum_generator<Two_scale>::run_except(const softsusy::QedQc
          this->settings.get(Spectrum_generator_settings::max_iterations));
    }
 
-   Composite_convergence_tester<Two_scale> cct;
+   Composite_convergence_tester cct;
    cct.add_convergence_tester(&model_ct);
    cct.add_convergence_tester(&eft_ct);