slha_io.hpp.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@

#ifndef @ModelName@_SLHA_IO_H
#define @ModelName@_SLHA_IO_H

#include "@ModelName@_mass_eigenstates.hpp"
#include "@ModelName@_model_slha.hpp"
#include "@ModelName@_info.hpp"
#include "@ModelName@_observables.hpp"
#include "@ModelName@_physical.hpp"
#include "standard_model_two_scale_model.hpp"
#include "slha_io.hpp"
#include "ckm.hpp"
#include "ew_input.hpp"
#include "lowe.h"

#include <Eigen/Core>
#include <string>
#include <tuple>
#include <utility>

#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>

#define Pole(p) physical.p
#define PHYSICAL(p) model.get_physical().p
#define PHYSICAL_SLHA(p) model.get_physical_slha().p
#define LOCALPHYSICAL(p) physical.p
#define MODEL model
#define MODELPARAMETER(p) model.get_##p()
#define EXTRAPARAMETER(p) model.get_##p()
#define OBSERVABLES observables
#define LowEnergyConstant(p) Electroweak_constants::p
#define SCALES(p) scales.p

namespace flexiblesusy {

struct @ModelName@_input_parameters;
class Spectrum_generator_settings;

template <class T>
class @ModelName@;

struct @ModelName@_scales {
   @ModelName@_scales() : HighScale(0.), SUSYScale(0.), LowScale(0.) {}
   double HighScale, SUSYScale, LowScale;
};

class @ModelName@_slha_io {
public:
   @ModelName@_slha_io();

   void clear();

   void fill(softsusy::QedQcd& qedqcd) const { slha_io.fill(qedqcd); }
   void fill(@ModelName@_input_parameters&) const;
   void fill(@ModelName@_mass_eigenstates&) const;
   template <class Model> void fill(@ModelName@_slha<Model>&) const;
   void fill(Physical_input&) const;
   void fill(Spectrum_generator_settings&) const;
   double get_parameter_output_scale() const;
   const SLHA_io& get_slha_io() const { return slha_io; }
   void read_from_file(const std::string&);
   void read_from_source(const std::string&);
   void read_from_stream(std::istream&);
   void set_block(const std::string& str, SLHA_io::Position position = SLHA_io::back) { slha_io.set_block(str, position); }
   void set_blocks(const std::vector<std::string>& vec, SLHA_io::Position position = SLHA_io::back) { slha_io.set_blocks(vec, position); }
   template <class Model> void set_extra(const @ModelName@_slha<Model>&, const @ModelName@_scales&, const @ModelName@_observables&);
   void set_input(const @ModelName@_input_parameters&);
   void set_modsel(const SLHA_io::Modsel&);
   void set_physical_input(const Physical_input&);
   void set_settings(const Spectrum_generator_settings&);
   void set_sminputs(const softsusy::QedQcd&);
   template <class... Ts> void set_spectrum(const std::tuple<Ts...>&);
   template <class Model> void set_spectrum(const @ModelName@_slha<Model>&);
   template <class T> void set_spectrum(const @ModelName@<T>&);
   void set_spectrum(const standard_model::Standard_model& m) { slha_io.set_spectrum(m); }
   void set_spinfo(const Problems<@ModelName@_info::NUMBER_OF_PARTICLES, @ModelName@_info::NUMBER_OF_PARAMETERS>&);
   void set_spinfo(const std::vector<std::string>&, const std::vector<std::string>&);
   void set_print_imaginary_parts_of_majorana_mixings(bool);
   void write_to(const std::string&) const;
   void write_to_file(const std::string& file_name) const { slha_io.write_to_file(file_name); }
   void write_to_stream(std::ostream& ostr = std::cout) const { slha_io.write_to_stream(ostr); }

   static void fill_minpar_tuple(@ModelName@_input_parameters&, int, double);
   static void fill_extpar_tuple(@ModelName@_input_parameters&, int, double);
   static void fill_imminpar_tuple(@ModelName@_input_parameters&, int, double);
   static void fill_imextpar_tuple(@ModelName@_input_parameters&, int, double);

   template <class Model>
   static void fill_slhaea(SLHAea::Coll&, const @ModelName@_slha<Model>&, const softsusy::QedQcd&, const @ModelName@_scales&, const @ModelName@_observables&);

   template <class Model>
   static SLHAea::Coll fill_slhaea(const @ModelName@_slha<Model>&, const softsusy::QedQcd&, const @ModelName@_scales&, const @ModelName@_observables&);

private:
   SLHA_io slha_io; ///< SLHA io class
   bool print_imaginary_parts_of_majorana_mixings;

   void set_extpar(const @ModelName@_input_parameters&);
   void set_imminpar(const @ModelName@_input_parameters&);
   void set_imextpar(const @ModelName@_input_parameters&);
   void set_minpar(const @ModelName@_input_parameters&);
   void set_mass(const @ModelName@_physical&, bool);
   void set_mixing_matrices(const @ModelName@_physical&, bool);
   template <class Model> void set_model_parameters(const @ModelName@_slha<Model>&);
   void set_ckm(const Eigen::Matrix<std::complex<double>,3,3>&, double);
   void set_pmns(const Eigen::Matrix<std::complex<double>,3,3>&, double);
   double read_scale() const;
   void fill_drbar_parameters(@ModelName@_mass_eigenstates&) const;
   void fill_physical(@ModelName@_physical&) const;
};

/**
 * Reads DR-bar parameters, pole masses and mixing matrices from a
 * SLHA output file.
 */
template <class Model>
void @ModelName@_slha_io::fill(@ModelName@_slha<Model>& model) const
{
   fill(static_cast<@ModelName@_mass_eigenstates&>(model));
   fill_physical(model.get_physical_slha());
}

template <class Model>
void @ModelName@_slha_io::fill_slhaea(
   SLHAea::Coll& slhaea, const @ModelName@_slha<Model>& model,
   const softsusy::QedQcd& qedqcd, const @ModelName@_scales& scales,
   const @ModelName@_observables& observables)
{
   @ModelName@_slha_io slha_io;
   const @ModelName@_input_parameters& input = model.get_input();
   const auto& problems = model.get_problems();
   const bool error = problems.have_problem();

   slha_io.set_spinfo(problems);
   slha_io.set_sminputs(qedqcd);
   slha_io.set_input(input);
   if (!error) {
      slha_io.set_spectrum(model);
      slha_io.set_extra(model, scales, observables);
   }

   slhaea = slha_io.get_slha_io().get_data();
}

template <class Model>
SLHAea::Coll @ModelName@_slha_io::fill_slhaea(
   const @ModelName@_slha<Model>& model, const softsusy::QedQcd& qedqcd,
   const @ModelName@_scales& scales, const @ModelName@_observables& observables)
{
   SLHAea::Coll slhaea;
   @ModelName@_slha_io::fill_slhaea(slhaea, model, qedqcd, scales, observables);

   return slhaea;
}

/**
 * Stores the model (DR-bar) parameters in the SLHA object.
 *
 * @param model model class
 */
template <class Model>
void @ModelName@_slha_io::set_model_parameters(const @ModelName@_slha<Model>& model)
{
@writeSLHAModelParametersBlocks@
@writeSLHAPhasesBlocks@
}

/**
 * Writes extra SLHA blocks
 *
 * @param model model class
 * @param scales struct of boundary condition scales
 * @param observables struct of observables
 */
template <class Model>
void @ModelName@_slha_io::set_extra(
   const @ModelName@_slha<Model>& model, const @ModelName@_scales& scales,
   const @ModelName@_observables& observables)
{
   const @ModelName@_physical physical(model.get_physical_slha());

@writeExtraSLHAOutputBlock@
}

/**
 * Stores the model (DR-bar) parameters, masses and mixing matrices of
 * all given models in the SLHA object.
 *
 * @todo Use generic lambda instead of Set_spectrum in C++14
 *
 * @param models model classes
 */
template <class... Ts>
void @ModelName@_slha_io::set_spectrum(const std::tuple<Ts...>& models)
{
   Set_spectrum<@ModelName@_slha_io> ss(this);
   boost::fusion::for_each(models, ss);
}

/**
 * Stores the model (DR-bar) parameters, masses and mixing matrices in
 * the SLHA object.
 *
 * @param model model class in BPMZ convention
 */
template <class T>
void @ModelName@_slha_io::set_spectrum(const @ModelName@<T>& model)
{
   set_spectrum(@ModelName@_slha<@ModelName@<T> >(model));
}

/**
 * Stores the model (DR-bar) parameters, masses and mixing matrices in
 * the SLHA object.
 *
 * @param model model class in SLHA convention
 */
template <class Model>
void @ModelName@_slha_io::set_spectrum(const @ModelName@_slha<Model>& model)
{
   const @ModelName@_physical physical(model.get_physical_slha());
   const bool write_sm_masses = model.do_calculate_sm_pole_masses();

   set_model_parameters(model);
   set_mass(physical, write_sm_masses);
   set_mixing_matrices(physical, write_sm_masses);

   if (slha_io.get_modsel().quark_flavour_violated)
      set_ckm(model.get_ckm_matrix(), model.get_scale());

   if (slha_io.get_modsel().lepton_flavour_violated)
      set_pmns(model.get_pmns_matrix(), model.get_scale());
}

} // namespace flexiblesusy

#undef Pole
#undef PHYSICAL
#undef PHYSICAL_SLHA
#undef LOCALPHYSICAL
#undef MODEL
#undef MODELPARAMETER
#undef EXTRAPARAMETER
#undef OBSERVABLES
#undef LowEnergyConstant
#undef SCALES

#endif