Config.hh

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <string>
#include <utility>
#include <optional>
#include <vector>
 
#include "fastjet/JetDefinition.hh"
#include "yaml-cpp/yaml.h"
 
#include "HEJ/Constants.hh"
#include "HEJ/EWConstants.hh"
#include "HEJ/Fraction.hh"
#include "HEJ/HiggsCouplingSettings.hh"
#include "HEJ/ScaleFunction.hh"
#include "HEJ/event_types.hh"
#include "HEJ/output_formats.hh"
 
namespace HEJ {
 
  struct JetParameters{
    fastjet::JetDefinition def;          
    double min_pt{};                       
  };
 
  struct ScaleConfig{
    std::vector<ScaleFunction> base;
    std::vector<double> factors;
    double max_ratio{};
  };
 
  struct RNGConfig {
    std::string name;
    std::optional<std::string> seed;
  };
 
  struct PartialUnweightConfig {
    size_t trials;
    double max_dev;
  };
 
  struct NLOConfig {
    bool enabled = false;
    size_t nj = 2;
  };
 
  enum class EventTreatment{
    reweight,                                  
    keep,                                      
    discard,                                   
    abort,                                     
  };
 
  using EventTreatMap = std::map<event_type::EventType, EventTreatment>;
 
  enum class WeightType{
    weighted,             
    unweighted_resum,     
    partially_unweighted  
  };
 
  struct Config {
    ScaleConfig scales;
    JetParameters resummation_jets;
    JetParameters fixed_order_jets;
    Fraction<double> soft_pt_regulator{ DEFAULT_SOFT_PT_REGULATOR };
    double regulator_lambda = CLAMBDA;
    size_t trials{};
    std::optional<size_t> max_events;
    bool log_correction{};
    std::vector<OutputFile> output;
    RNGConfig rng;
    EventTreatMap treat;
    std::vector<YAML::Node> analyses_parameters;
    HiggsCouplingSettings Higgs_coupling;
    EWConstants ew_parameters;
    WeightType weight_type;
    std::optional<PartialUnweightConfig> unweight_config;
    NLOConfig nlo;
    bool lowpt = false;
    double off_shell_tolerance = 0.;
  };
 
  struct PhaseSpacePointConfig {
    PhaseSpacePointConfig() = default;
    PhaseSpacePointConfig(
        JetParameters jet_param,
        NLOConfig nlo,
        Fraction<double> soft_pt_regulator =
          Fraction<double>{DEFAULT_SOFT_PT_REGULATOR}
    ):
    jet_param{std::move(jet_param)},
    nlo{std::move(nlo)},
    soft_pt_regulator{std::move(soft_pt_regulator)}
    {}
    JetParameters jet_param;
    NLOConfig nlo;
    Fraction<double> soft_pt_regulator{ DEFAULT_SOFT_PT_REGULATOR };
  };
 
  struct MatrixElementConfig {
    MatrixElementConfig() = default;
    MatrixElementConfig(
        bool log_correction,
        HiggsCouplingSettings Higgs_coupling,
        EWConstants ew_parameters,
        NLOConfig nlo,
        Fraction<double> soft_pt_regulator = Fraction<double>{DEFAULT_SOFT_PT_REGULATOR},
        double regulator_lambda = CLAMBDA
    ):
    log_correction{log_correction},
    Higgs_coupling{std::move(Higgs_coupling)},
    ew_parameters{std::move(ew_parameters)},
    nlo{std::move(nlo)},
    soft_pt_regulator{soft_pt_regulator},
    regulator_lambda{regulator_lambda}
    {}
 
    bool log_correction{};
    HiggsCouplingSettings Higgs_coupling;
    EWConstants ew_parameters;
    NLOConfig nlo;
    Fraction<double> soft_pt_regulator{ DEFAULT_SOFT_PT_REGULATOR };
    double regulator_lambda = CLAMBDA;
  };
 
  struct EventReweighterConfig {
    PhaseSpacePointConfig psp_config;
    MatrixElementConfig ME_config;
    JetParameters & jet_param() {
      return psp_config.jet_param;}
    JetParameters const & jet_param() const {
      return psp_config.jet_param;}
    EventTreatMap treat;
    bool lowpt = false;
  };
 
  inline
  PhaseSpacePointConfig to_PhaseSpacePointConfig(Config const & conf) {
    return {
      conf.resummation_jets,
      conf.nlo,
      conf.soft_pt_regulator
    };
  }
 
  inline
  MatrixElementConfig to_MatrixElementConfig(Config const & conf) {
    return {
      conf.log_correction,
      conf.Higgs_coupling,
      conf.ew_parameters,
      conf.nlo,
      conf.soft_pt_regulator,
      conf.regulator_lambda
    };
  }
 
  inline
  EventReweighterConfig to_EventReweighterConfig(Config const & conf) {
    return {
      to_PhaseSpacePointConfig(conf),
      to_MatrixElementConfig(conf),
      conf.treat,
      conf.lowpt
    };
  }
 
} // namespace HEJ