two_scale_high_scale_constraint.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@_two_scale_high_scale_constraint.hpp"
#include "@ModelName@_two_scale_model.hpp"
#include "@ModelName@_info.hpp"
#include "wrappers.hpp"
#include "logger.hpp"
#include "ew_input.hpp"
#include "gsl_utils.hpp"
#include "minimizer.hpp"
#include "root_finder.hpp"
#include "threshold_loop_functions.hpp"
#include "numerics2.hpp"

#include <cassert>
#include <cmath>
#include <cerrno>
#include <cstring>

namespace flexiblesusy {

#define DERIVEDPARAMETER(p) model->p()
#define INPUTPARAMETER(p) model->get_input().p
#define MODELPARAMETER(p) model->get_##p()
#define PHASE(p) model->get_##p()
#define BETAPARAMETER(p) beta_functions.get_##p()
#define BETAPARAMETER1(l,p) beta_functions_##l##L.get_##p()
#define BETA(p) beta_##p
#define BETA1(l,p) beta_##l##L_##p
#define LowEnergyConstant(p) Electroweak_constants::p
#define MZPole Electroweak_constants::MZ
#define STANDARDDEVIATION(p) Electroweak_constants::Error_##p
#define Pole(p) model->get_physical().p
#define SCALE model->get_scale()
#define THRESHOLD static_cast<int>(model->get_thresholds())
#define MODEL model
#define MODELCLASSNAME @ModelName@<Two_scale>

@ModelName@_high_scale_constraint<Two_scale>::@ModelName@_high_scale_constraint(
   @ModelName@<Two_scale>* model_)
   : model(model_)
{
   initialize();
}

@ModelName@_high_scale_constraint<Two_scale>::~@ModelName@_high_scale_constraint()
{
}

void @ModelName@_high_scale_constraint<Two_scale>::apply()
{
   assert(model && "Error: @ModelName@_high_scale_constraint::apply():"
          " model pointer must not be zero");

@temporarySetting@

   update_scale();

@applyConstraint@

   check_non_perturbative();

@temporaryResetting@
}

bool @ModelName@_high_scale_constraint<Two_scale>::check_non_perturbative()
{
   bool problem = false;

@checkPerturbativityForDimensionlessParameters@

   return problem;
}

double @ModelName@_high_scale_constraint<Two_scale>::get_scale() const
{
   return scale;
}

double @ModelName@_high_scale_constraint<Two_scale>::get_initial_scale_guess() const
{
   return initial_scale_guess;
}

const @ModelName@_input_parameters& @ModelName@_high_scale_constraint<Two_scale>::get_input_parameters() const
{
   return model->get_input();
}

@ModelName@<Two_scale>* @ModelName@_high_scale_constraint<Two_scale>::get_model() const
{
   return model;
}

void @ModelName@_high_scale_constraint<Two_scale>::set_model(Model* model_)
{
   model = cast_model<@ModelName@<Two_scale>*>(model_);
}

void @ModelName@_high_scale_constraint<Two_scale>::set_scale(double s)
{
   scale = s;
}

void @ModelName@_high_scale_constraint<Two_scale>::clear()
{
   scale = 0.;
   initial_scale_guess = 0.;
   model = NULL;
}

void @ModelName@_high_scale_constraint<Two_scale>::initialize()
{
   assert(model && "@ModelName@_high_scale_constraint<Two_scale>::"
          "initialize(): model pointer is zero.");

@scaleGuess@
   scale = initial_scale_guess;
}

void @ModelName@_high_scale_constraint<Two_scale>::update_scale()
{
   assert(model && "@ModelName@_high_scale_constraint<Two_scale>::"
          "update_scale(): model pointer is zero.");

   const double currentScale = model->get_scale();
   const @ModelName@_soft_parameters beta_functions(model->calc_beta());

@calculateScale@

   if (errno == ERANGE) {
#ifdef ENABLE_VERBOSE
      ERROR("@ModelName@_high_scale_constraint<Two_scale>: Overflow error"
            " during calculation of high scale: " << strerror(errno) << '\n'
            << "   current scale = " << currentScale << '\n'
            << "   new scale = " << scale << '\n'
            << "   resetting scale to " << get_initial_scale_guess());
#endif
      scale = get_initial_scale_guess();
      errno = 0;
   }

@restrictScale@
}

} // namespace flexiblesusy