semi_analytic_high_scale_spectrum_generator.cpp.in

// ====================================================================
// 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/>.
// ====================================================================

// File generated at @DateAndTime@

#include "@ModelName@_semi_analytic_spectrum_generator.hpp"
#include "@ModelName@_semi_analytic_convergence_tester.hpp"
#include "@ModelName@_semi_analytic_initial_guesser.hpp"
#include "@ModelName@_semi_analytic_susy_convergence_tester.hpp"

#include "error.hpp"
#include "lowe.h"
#include "numerics2.hpp"
#include "two_scale_running_precision.hpp"
#include "semi_analytic_solver.hpp"

#include <limits>

namespace flexiblesusy {

double @ModelName@_spectrum_generator<Semi_analytic>::get_pole_mass_scale() const
{
   return
      this->settings.get(Spectrum_generator_settings::pole_mass_scale) != 0. ?
      this->settings.get(Spectrum_generator_settings::pole_mass_scale) : get_susy_scale();
}

/**
 * @brief Run's the RG solver with the given input parameters
 *
 * This function sets up the RG solver using a high-scale, susy-scale,
 * low-scale and soft parameters constraint.  Afterwards the solver 
 * is run until convergence is reached or an error occours.  Finally 
 * the particle spectrum (pole masses) is calculated.
 *
 * @param qedqcd Standard Model input parameters
 * @param input model input parameters
 */
void @ModelName@_spectrum_generator<Semi_analytic>::run_except(const softsusy::QedQcd& qedqcd,
                                const @ModelName@_input_parameters& input)
{
   @ModelName@<Semi_analytic>& model = this->model;
   model.clear();
   model.set_input_parameters(input);
   model.do_calculate_sm_pole_masses(this->settings.get(Spectrum_generator_settings::calculate_sm_masses));
   model.do_calculate_bsm_pole_masses(this->settings.get(Spectrum_generator_settings::calculate_bsm_masses));
   model.do_force_output(this->settings.get(Spectrum_generator_settings::force_output));
   model.set_loops(this->settings.get(Spectrum_generator_settings::beta_loop_order));
   model.set_thresholds(this->settings.get(Spectrum_generator_settings::threshold_corrections_loop_order));
   model.set_zero_threshold(this->settings.get(Spectrum_generator_settings::beta_zero_threshold));

   high_scale_constraint.clear();
   susy_scale_constraint.clear();
   low_scale_constraint .clear();
   soft_constraint.clear();

   // needed for constraint::initialize()
   high_scale_constraint.set_model(&model);
   susy_scale_constraint.set_model(&model);
   low_scale_constraint .set_model(&model);

   susy_scale_constraint.set_sm_parameters(qedqcd);
   low_scale_constraint .set_sm_parameters(qedqcd);

   high_scale_constraint.initialize();
   susy_scale_constraint.initialize();
   low_scale_constraint .initialize();

   @ModelName@_susy_convergence_tester<Semi_analytic> inner_ct(
      &model, this->settings.get(Spectrum_generator_settings::precision));
   @ModelName@_convergence_tester<Semi_analytic> outer_ct(
      &model, this->settings.get(Spectrum_generator_settings::precision));

   if (this->settings.get(Spectrum_generator_settings::pole_mass_scale) != 0.)
      outer_ct.set_scale_getter(
         [this](){ return settings.get(Spectrum_generator_settings::pole_mass_scale); });

   if (this->settings.get(Spectrum_generator_settings::max_iterations) > 0) {
      inner_ct.set_max_iterations(
         this->settings.get(Spectrum_generator_settings::max_iterations));
      outer_ct.set_max_iterations(
         this->settings.get(Spectrum_generator_settings::max_iterations));
   }

   @ModelName@_initial_guesser<Semi_analytic> initial_guesser(&model, qedqcd,
                                                              low_scale_constraint,
                                                              susy_scale_constraint,
                                                              high_scale_constraint);

   Two_scale_increasing_precision precision(
      10.0, this->settings.get(Spectrum_generator_settings::precision));

   RGFlow<Semi_analytic> solver;
   solver.set_inner_convergence_tester(&inner_ct);
   solver.set_outer_convergence_tester(&outer_ct);
   solver.set_running_precision(&precision);
   solver.set_initial_guesser(&initial_guesser);
   solver.add_inner(&low_scale_constraint, &model);
   solver.add_inner(&high_scale_constraint, &model);
   solver.add_inner(&susy_scale_constraint, &model);
   solver.add_outer(&soft_constraint, &model);

   this->reached_precision = std::numeric_limits<double>::infinity();

   solver.solve();

   // impose low-scale constraint one last time
   model.run_to(low_scale_constraint.get_scale());
   low_scale_constraint.apply();

   this->reached_precision = outer_ct.get_current_accuracy();

   calculate_spectrum();

   // copy calculated W pole mass
   model.get_physical().M@VectorW@
      = low_scale_constraint.get_sm_parameters().displayPoleMW();

   // run to output scale (if scale > 0)
   if (!is_zero(this->parameter_output_scale))
      model.run_to(this->parameter_output_scale);
}

/**
 * Create a text file which contains the values of all model
 * parameters at all scales between the low-scale and the high-scale.
 *
 * @param filename name of output file
 */
void @ModelName@_spectrum_generator<Semi_analytic>::write_running_couplings(
   const std::string& filename) const
{
   @ModelName@_spectrum_generator_interface<Semi_analytic>::write_running_couplings(
      filename, get_low_scale(), get_high_scale());
}

void @ModelName@_spectrum_generator<Semi_analytic>::calculate_spectrum()
{
   this->model.run_to(get_pole_mass_scale());
   this->model.calculate_semi_analytic_solutions(get_high_scale());
   this->model.solve_ewsb();
   this->model.calculate_spectrum();
}

} // namespace flexiblesusy