diff --git a/config.yml b/config.yml index d26d29c..4859c3f 100644 --- a/config.yml +++ b/config.yml @@ -1,142 +1,140 @@ ## Number of attempted resummation phase space points for each input event trials: 10 resummation jets: # resummation jet properties min pt: 30 # minimum jet transverse momentum algorithm: antikt # jet clustering algorithm R: 0.4 # jet R parameter fixed order jets: # properties of input jets min pt: 20 # by default, algorithm and R are like for resummation jets ## Treatment of he various event classes ## the supported settings are: reweight, keep, discard, abort ## non-resummable, unknown, and invalid events cannot be reweighted event treatment: FKL: reweight unordered: keep extremal qqbar: keep central qqbar: keep non-resummable: keep - unknown: abort - invalid: abort ## Central scale choice or choices # ## multiple scales are allowed, e.g. # scales: [125, max jet pperp, H_T/2, 2*jet invariant mass, m_j1j2] scales: 91.188 ## Factors by which the central scales should be multiplied ## renormalisation and factorisation scales are varied independently # # scale factors: [0.5, 0.7071, 1, 1.41421, 2] ## Maximum ratio between renormalisation and factorisation scale # # max scale ratio: 2.0001 ## Import scale setting functions # # import scales: # lib_my_scales.so: [scale0,scale1] ## Unweighting setting ## remove to obtain weighted events # unweight: # # type of unweighting (one of 'weighted', 'resummation', 'partial') # type: partial # trials: 10000 # max deviation: 0 ## Event output files # # the supported formats are # - Les Houches (suffix .lhe) # - HepMC2 (suffix .hepmc2) # - HepMC3 (suffix .hepmc3 or .hepmc) # - HDF5 (suffix .hdf5) # ## An output file's format is deduced either automatically from the suffix ## or from an explicit specification, e.g. ## - Les Houches: outfile # event output: - HEJ.lhe # - HEJ_events.hepmc ## Analyses # # analyses: ## Rivet analysis # - rivet: MC_XS # rivet analysis name # output: HEJ # name of the yoda files, ".yoda" and scale suffix will be added ## Custom analysis # - plugin: /path/to/libmyanalysis.so # my analysis parameter: some value ## Selection of random number generator and seed ## The choices are ## - mixmax (seed is an integer) ## - ranlux64 (seed is a filename containing parameters) random generator: name: mixmax # seed: 1 ## Whether or not to include higher order logs log correction: false ## Truncate higher-order corrections at NLO NLO truncation: enabled: false # nlo order: 2 ## Only keep low pt contributions # require low pt jet: false ## Vacuum expectation value vev: 246.2196508 ## Properties of the weak gauge bosons particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 ## Parameters for Higgs-gluon couplings ## This requires compilation with QCDloop # # Higgs coupling: # use impact factors: false # mt: 174 # include bottom: true # mb: 4.7 # # Tolerance towards numerical inaccuracies in input momenta # off-shell tolerance: 0.01 ## ---------------------------------------------------------------------- ## ## The following settings are only intended for advanced users. ## ## Please DO NOT SET them unless you know exactly what you are doing! ## ## ---------------------------------------------------------------------- ## # ## Maximum soft transverse momentum fraction in any tagging jets, e.g. ## extremal or qqbar jet # soft pt regulator: 0.1 # ## Minimum transverse momentum of extremal partons ## deprecated: use "soft pt regulator" instead # min extparton pt: 30 # ## deprecated: this cot directly replaced by "soft pt regulator" # max ext soft pt fraction: 0.1 # # max events: -1 # Maximal number of fixed order Events to process # regulator parameter: 0.2 # The regulator lambda for the subtraction terms diff --git a/src/YAMLreader.cc b/src/YAMLreader.cc index 99f99b3..39a24c4 100644 --- a/src/YAMLreader.cc +++ b/src/YAMLreader.cc @@ -1,606 +1,606 @@ /** * \authors The HEJ collaboration (see AUTHORS for details) * \date 2019-2020 * \copyright GPLv2 or later */ #include "HEJ/YAMLreader.hh" #include #include #include #include #include #include #include #include #include "HEJ/ConfigFlags.hh" #include "HEJ/Constants.hh" #include "HEJ/ScaleFunction.hh" #include "HEJ/event_types.hh" #include "HEJ/output_formats.hh" namespace HEJ { class Event; namespace { //! Get YAML tree of supported options /** * The configuration file is checked against this tree of options * in assert_all_options_known. */ YAML::Node const & get_supported_options(){ const static YAML::Node supported = [](){ YAML::Node supported; static const auto opts = { "trials", "min extparton pt", "max ext soft pt fraction", "soft pt regulator", "scales", "scale factors", "max scale ratio", "import scales", "log correction", "event output", "analysis", "analyses", "vev", "regulator parameter", "max events", "off-shell tolerance", "require low pt jet" }; // add subnodes to "supported" - the assigned value is irrelevant for(auto && opt: opts) supported[opt] = ""; for(auto && jet_opt: {"min pt", "algorithm", "R"}){ supported["resummation jets"][jet_opt] = ""; supported["fixed order jets"][jet_opt] = ""; } for(auto && opt: {"mt", "use impact factors", "include bottom", "mb"}){ supported["Higgs coupling"][opt] = ""; } for(auto && opt: {"name", "seed"}){ supported["random generator"][opt] = ""; } for(auto && opt: {"enabled", "nlo order"}){ supported["NLO truncation"][opt] = ""; } for( auto && opt: { "FKL", "unordered", "extremal qqbar", "central qqbar", "non-resummable", "unknown", "invalid" }){ supported["event treatment"][opt] = ""; } for(auto && particle_type: {"Higgs", "W", "Z"}){ for(auto && particle_opt: {"mass", "width"}){ supported["particle properties"][particle_type][particle_opt] = ""; } } for(auto && opt: {"type", "trials", "max deviation"}){ supported["unweight"][opt] = ""; } return supported; }(); return supported; } fastjet::JetAlgorithm to_JetAlgorithm(std::string const & algo){ using namespace fastjet; static const std::map known = { {"kt", kt_algorithm}, {"cambridge", cambridge_algorithm}, {"antikt", antikt_algorithm}, {"cambridge for passive", cambridge_for_passive_algorithm}, {"plugin", plugin_algorithm} }; const auto res = known.find(algo); if(res == known.end()){ throw std::invalid_argument("Unknown jet algorithm \"" + algo + "\""); } return res->second; } EventTreatment to_EventTreatment(std::string const & name){ static const std::map known = { {"reweight", EventTreatment::reweight}, {"keep", EventTreatment::keep}, {"discard", EventTreatment::discard}, {"abort", EventTreatment::abort} }; const auto res = known.find(name); if(res == known.end()){ throw std::invalid_argument("Unknown event treatment \"" + name + "\""); } return res->second; } WeightType to_weight_type(std::string const & setting){ if(setting == "weighted") return WeightType::weighted; if(setting =="resummation") return WeightType::unweighted_resum; if(setting =="partial") return WeightType::partially_unweighted; throw std::invalid_argument{"Unknown weight type \"" + setting + "\""}; } } // namespace namespace detail{ void set_from_yaml(fastjet::JetAlgorithm & setting, YAML::Node const & yaml){ setting = to_JetAlgorithm(yaml.as()); } void set_from_yaml(EventTreatment & setting, YAML::Node const & yaml){ setting = to_EventTreatment(yaml.as()); } void set_from_yaml(ParticleID & setting, YAML::Node const & yaml){ setting = to_ParticleID(yaml.as()); } void set_from_yaml(WeightType & setting, YAML::Node const & yaml){ setting = to_weight_type(yaml.as()); } } // namespace detail JetParameters get_jet_parameters( YAML::Node const & node, std::string const & entry ){ assert(node); JetParameters result; fastjet::JetAlgorithm jet_algo = fastjet::antikt_algorithm; double R = NAN; set_from_yaml_if_defined(jet_algo, node, entry, "algorithm"); set_from_yaml(R, node, entry, "R"); result.def = fastjet::JetDefinition{jet_algo, R}; set_from_yaml(result.min_pt, node, entry, "min pt"); return result; } RNGConfig to_RNGConfig( YAML::Node const & node, std::string const & entry ){ assert(node); RNGConfig result; set_from_yaml(result.name, node, entry, "name"); set_from_yaml_if_defined(result.seed, node, entry, "seed"); return result; } NLOConfig to_NLOConfig( YAML::Node const & node, std::string const & entry ){ assert(node); NLOConfig result; set_from_yaml_if_defined(result.enabled, node, entry, "enabled"); set_from_yaml_if_defined(result.nj, node, entry, "nlo order"); return result; } ParticleProperties get_particle_properties( YAML::Node const & node, std::string const & entry, std::string const & boson ){ ParticleProperties result{}; set_from_yaml(result.mass, node, entry, boson, "mass"); set_from_yaml(result.width, node, entry, boson, "width"); return result; } EWConstants get_ew_parameters(YAML::Node const & node){ EWConstants result; double vev = NAN; set_from_yaml(vev, node, "vev"); result.set_vevWZH(vev, get_particle_properties(node, "particle properties", "W"), get_particle_properties(node, "particle properties", "Z"), get_particle_properties(node, "particle properties", "Higgs") ); return result; } HiggsCouplingSettings get_Higgs_coupling( YAML::Node const & node, std::string const & entry ){ assert(node); static constexpr double mt_max = 2e4; #ifndef HEJ_BUILD_WITH_QCDLOOP if(node[entry].IsDefined()){ throw std::invalid_argument{ "Higgs coupling settings require building HEJ 2 " "with QCDloop support" }; } #endif HiggsCouplingSettings settings; set_from_yaml_if_defined(settings.mt, node, entry, "mt"); set_from_yaml_if_defined(settings.mb, node, entry, "mb"); set_from_yaml_if_defined(settings.include_bottom, node, entry, "include bottom"); set_from_yaml_if_defined(settings.use_impact_factors, node, entry, "use impact factors"); if(settings.use_impact_factors){ if(settings.mt != std::numeric_limits::infinity()){ throw std::invalid_argument{ "Conflicting settings: " "impact factors may only be used in the infinite top mass limit" }; } } else{ // huge values of the top mass are numerically unstable settings.mt = std::min(settings.mt, mt_max); } return settings; } FileFormat to_FileFormat(std::string const & name){ static const std::map known = { {"Les Houches", FileFormat::Les_Houches}, {"HepMC", FileFormat::HepMC}, {"HepMC2", FileFormat::HepMC2}, {"HepMC3", FileFormat::HepMC3}, {"HDF5", FileFormat::HDF5} }; const auto res = known.find(name); if(res == known.end()){ throw std::invalid_argument("Unknown file format \"" + name + "\""); } return res->second; } std::string extract_suffix(std::string const & filename){ size_t separator = filename.rfind('.'); if(separator == std::string::npos) return {}; return filename.substr(separator + 1); } FileFormat format_from_suffix(std::string const & filename){ const std::string suffix = extract_suffix(filename); if(suffix == "lhe") return FileFormat::Les_Houches; if(suffix == "hepmc") return FileFormat::HepMC; if(suffix == "hepmc3") return FileFormat::HepMC3; if(suffix == "hepmc2") return FileFormat::HepMC2; if(suffix == "hdf5") return FileFormat::HDF5; throw std::invalid_argument{ "Can't determine format for output file \"" + filename + "\"" }; } void assert_all_options_known( YAML::Node const & conf, YAML::Node const & supported ){ if(!conf.IsMap()) return; if(!supported.IsMap()) throw invalid_type{"must not have sub-entries"}; for(auto const & entry: conf){ const auto name = entry.first.as(); if(! supported[name]) throw unknown_option{name}; /* check sub-options, e.g. 'resummation jets: min pt' * we don't check analyses sub-options * those depend on the analysis being used and should be checked there * similar for "import scales" */ if(name != "analyses" && name != "analysis" && name != "import scales"){ try{ assert_all_options_known(conf[name], supported[name]); } catch(unknown_option const & ex){ throw unknown_option{name + ": " + ex.what()}; } catch(invalid_type const & ex){ throw invalid_type{name + ": " + ex.what()}; } } } } } // namespace HEJ namespace YAML { Node convert::encode(HEJ::OutputFile const & outfile) { Node node; node[to_string(outfile.format)] = outfile.name; return node; } bool convert::decode(Node const & node, HEJ::OutputFile & out) { switch(node.Type()){ case NodeType::Map: { YAML::const_iterator it = node.begin(); out.format = HEJ::to_FileFormat(it->first.as()); out.name = it->second.as(); return true; } case NodeType::Scalar: out.name = node.as(); out.format = HEJ::format_from_suffix(out.name); return true; default: return false; } } } // namespace YAML namespace HEJ { namespace detail{ void set_from_yaml(OutputFile & setting, YAML::Node const & yaml){ setting = yaml.as(); } } namespace { void update_fixed_order_jet_parameters( JetParameters & fixed_order_jets, YAML::Node const & yaml ){ if(!yaml["fixed order jets"]) return; set_from_yaml_if_defined( fixed_order_jets.min_pt, yaml, "fixed order jets", "min pt" ); fastjet::JetAlgorithm algo = fixed_order_jets.def.jet_algorithm(); set_from_yaml_if_defined(algo, yaml, "fixed order jets", "algorithm"); double R = fixed_order_jets.def.R(); set_from_yaml_if_defined(R, yaml, "fixed order jets", "R"); fixed_order_jets.def = fastjet::JetDefinition{algo, R}; } // like std::stod, but throw if not the whole string can be converted double to_double(std::string const & str){ std::size_t pos = 0; const double result = std::stod(str, &pos); if(pos < str.size()){ throw std::invalid_argument(str + " is not a valid double value"); } return result; } using EventScale = double (*)(Event const &); void import_scale_functions( std::string const & file, std::vector const & scale_names, std::unordered_map & known ) { void * handle = dlopen(file.c_str(), RTLD_NOW); char * error = dlerror(); if(error != nullptr) throw std::runtime_error{error}; for(auto const & scale: scale_names) { void * sym = dlsym(handle, scale.c_str()); error = dlerror(); if(error != nullptr) throw std::runtime_error{error}; known.emplace(scale, reinterpret_cast(sym)); // NOLINT } } auto get_scale_map( YAML::Node const & yaml ) { std::unordered_map scale_map; scale_map.emplace("H_T", H_T); scale_map.emplace("max jet pperp", max_jet_pt); scale_map.emplace("jet invariant mass", jet_invariant_mass); scale_map.emplace("m_j1j2", m_j1j2); if(yaml["import scales"].IsDefined()) { if(! yaml["import scales"].IsMap()) { throw invalid_type{"Entry 'import scales' is not a map"}; } for(auto const & import: yaml["import scales"]) { const auto file = import.first.as(); const auto scale_names = import.second.IsSequence() ?import.second.as>() :std::vector{import.second.as()}; import_scale_functions(file, scale_names, scale_map); } } return scale_map; } // simple (as in non-composite) scale functions /** * An example for a simple scale function would be H_T, * H_T/2 is then composite (take H_T and then divide by 2) */ ScaleFunction parse_simple_ScaleFunction( std::string const & scale_fun, std::unordered_map const & known ) { assert( scale_fun.empty() || (!std::isspace(scale_fun.front()) && !std::isspace(scale_fun.back())) ); const auto it = known.find(scale_fun); if(it != end(known)) return {it->first, it->second}; try{ const double scale = to_double(scale_fun); return {scale_fun, FixedScale{scale}}; } catch(std::invalid_argument const &){} throw std::invalid_argument{"Unknown scale choice: \"" + scale_fun + "\""}; } std::string trim_front(std::string const & str){ const auto new_begin = std::find_if( begin(str), end(str), [](char c){ return std::isspace(c) == 0; } ); return std::string(new_begin, end(str)); } std::string trim_back(std::string str){ size_t pos = str.size() - 1; // use guaranteed wrap-around behaviour to check whether we have // traversed the whole string for(; pos < str.size() && std::isspace(str[pos]); --pos) {} str.resize(pos + 1); // note that pos + 1 can be 0 return str; } ScaleFunction parse_ScaleFunction( std::string const & scale_fun, std::unordered_map const & known ){ assert( scale_fun.empty() || (!std::isspace(scale_fun.front()) && !std::isspace(scale_fun.back())) ); // parse from right to left => a/b/c gives (a/b)/c const size_t delim = scale_fun.find_last_of("*/"); if(delim == std::string::npos){ return parse_simple_ScaleFunction(scale_fun, known); } const std::string first = trim_back(std::string{scale_fun, 0, delim}); const std::string second = trim_front(std::string{scale_fun, delim+1}); if(scale_fun[delim] == '/'){ return parse_ScaleFunction(first, known) / parse_ScaleFunction(second, known); } assert(scale_fun[delim] == '*'); return parse_ScaleFunction(first, known) * parse_ScaleFunction(second, known); } EventTreatMap get_event_treatment( YAML::Node const & node, std::string const & entry ){ using namespace event_type; EventTreatMap treat { {FKL, EventTreatment::discard}, {unob, EventTreatment::discard}, {unof, EventTreatment::discard}, {qqbar_exb, EventTreatment::discard}, {qqbar_exf, EventTreatment::discard}, {qqbar_mid, EventTreatment::discard}, {non_resummable, EventTreatment::discard}, {unknown, EventTreatment::abort}, {invalid, EventTreatment::abort} }; set_from_yaml(treat.at(FKL), node, entry, "FKL"); set_from_yaml(treat.at(unob), node, entry, "unordered"); treat.at(unof) = treat.at(unob); set_from_yaml(treat.at(qqbar_exb), node, entry, "extremal qqbar"); treat.at(qqbar_exf) = treat.at(qqbar_exb); set_from_yaml(treat.at(qqbar_mid), node, entry, "central qqbar"); set_from_yaml(treat.at(non_resummable), node, entry, "non-resummable"); - set_from_yaml(treat.at(unknown), node, entry, "unknown"); - set_from_yaml(treat.at(invalid), node, entry, "invalid"); if(treat[non_resummable] == EventTreatment::reweight){ throw std::invalid_argument{"Cannot reweight non-resummable events"}; } + set_from_yaml_if_defined(treat.at(unknown), node, entry, "unknown"); + set_from_yaml_if_defined(treat.at(invalid), node, entry, "invalid"); return treat; } Config to_Config(YAML::Node const & yaml){ try{ assert_all_options_known(yaml, get_supported_options()); } catch(unknown_option const & ex){ throw unknown_option{std::string{"Unknown option '"} + ex.what() + "'"}; } Config config; config.resummation_jets = get_jet_parameters(yaml, "resummation jets"); config.fixed_order_jets = config.resummation_jets; update_fixed_order_jet_parameters(config.fixed_order_jets, yaml); set_from_yaml_if_defined(config.min_extparton_pt, yaml, "min extparton pt"); if(config.min_extparton_pt!=0) std::cerr << "WARNING: \"min extparton pt\" is deprecated." << " Please remove this entry or set \"soft pt regulator\" instead.\n"; set_from_yaml_if_defined( config.max_ext_soft_pt_fraction, yaml, "max ext soft pt fraction" ); if(config.max_ext_soft_pt_fraction){ std::cerr << "WARNING: \"max ext soft pt fraction\" is deprecated." << " Please remove this entry or set \"soft pt regulator\" instead.\n"; config.soft_pt_regulator = *config.max_ext_soft_pt_fraction; } else { set_from_yaml_if_defined( config.soft_pt_regulator, yaml, "soft pt regulator" ); } // Sets the standard value, then changes this if defined config.regulator_lambda=CLAMBDA; set_from_yaml_if_defined(config.regulator_lambda, yaml, "regulator parameter"); set_from_yaml_if_defined(config.max_events, yaml, "max events"); set_from_yaml(config.trials, yaml, "trials"); config.weight_type = WeightType::weighted; set_from_yaml_if_defined(config.weight_type, yaml, "unweight", "type"); if(config.weight_type == WeightType::partially_unweighted) { config.unweight_config = PartialUnweightConfig{}; set_from_yaml( config.unweight_config->trials, yaml, "unweight", "trials" ); set_from_yaml( config.unweight_config->max_dev, yaml, "unweight", "max deviation" ); } else if(yaml["unweight"].IsDefined()) { for(auto && opt: {"trials", "max deviation"}) { if(yaml["unweight"][opt].IsDefined()) { throw std::invalid_argument{ "'unweight: " + std::string{opt} + "' " "is only supported if 'unweight: type' is set to 'partial'" }; } } } set_from_yaml(config.log_correction, yaml, "log correction"); config.treat = get_event_treatment(yaml, "event treatment"); set_from_yaml_if_defined(config.output, yaml, "event output"); config.rng = to_RNGConfig(yaml, "random generator"); set_from_yaml_if_defined(config.lowpt, yaml, "require low pt jet"); set_from_yaml_if_defined(config.analyses_parameters, yaml, "analyses"); if(yaml["analysis"].IsDefined()){ std::cerr << "WARNING: Configuration entry 'analysis' is deprecated. " " Use 'analyses' instead.\n"; set_from_yaml(config.analysis_parameters, yaml, "analysis"); if(!config.analysis_parameters.IsNull()){ config.analyses_parameters.push_back(config.analysis_parameters); } } config.scales = to_ScaleConfig(yaml); config.ew_parameters = get_ew_parameters(yaml); config.Higgs_coupling = get_Higgs_coupling(yaml, "Higgs coupling"); //HEJ@NLO Truncation config.nlo = to_NLOConfig(yaml, "NLO truncation"); set_from_yaml_if_defined( config.off_shell_tolerance, yaml, "off-shell tolerance" ); return config; } } // namespace ScaleConfig to_ScaleConfig(YAML::Node const & yaml){ ScaleConfig config; auto scale_funs = get_scale_map(yaml); std::vector scales; set_from_yaml(scales, yaml, "scales"); config.base.reserve(scales.size()); std::transform( begin(scales), end(scales), std::back_inserter(config.base), [scale_funs](auto const & entry){ return parse_ScaleFunction(entry, scale_funs); } ); set_from_yaml_if_defined(config.factors, yaml, "scale factors"); config.max_ratio = std::numeric_limits::infinity(); set_from_yaml_if_defined(config.max_ratio, yaml, "max scale ratio"); return config; } Config load_config(std::string const & config_file){ try{ return to_Config(YAML::LoadFile(config_file)); } catch(...){ std::cerr << "Error reading " << config_file << ":\n "; throw; } } } // namespace HEJ diff --git a/t/ME_data/config_Z_ME.yml b/t/ME_data/config_Z_ME.yml index 31c16a3..14c3f03 100644 --- a/t/ME_data/config_Z_ME.yml +++ b/t/ME_data/config_Z_ME.yml @@ -1,41 +1,39 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: reweight non-resummable: discard - unknown: abort - invalid: abort scales: 91.188 soft pt regulator: 1 log correction: false vev: 246.219650794137 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.1876 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_lambda.yml b/t/ME_data/config_lambda.yml index 38d3589..2ab6b3b 100644 --- a/t/ME_data/config_lambda.yml +++ b/t/ME_data/config_lambda.yml @@ -1,43 +1,41 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 regulator parameter: 3 diff --git a/t/ME_data/config_log_corr.yml b/t/ME_data/config_log_corr.yml index f76217b..1fdaa54 100644 --- a/t/ME_data/config_log_corr.yml +++ b/t/ME_data/config_log_corr.yml @@ -1,41 +1,39 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: true vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_mt.yml b/t/ME_data/config_mt.yml index 2aacb2f..d1a0f39 100644 --- a/t/ME_data/config_mt.yml +++ b/t/ME_data/config_mt.yml @@ -1,46 +1,44 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false random generator: name: mixmax seed: 1 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 Higgs coupling: use impact factors: false mt: 174 include bottom: false diff --git a/t/ME_data/config_mtinf.yml b/t/ME_data/config_mtinf.yml index 5db8117..d7a67b9 100644 --- a/t/ME_data/config_mtinf.yml +++ b/t/ME_data/config_mtinf.yml @@ -1,41 +1,39 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_mtmb.yml b/t/ME_data/config_mtmb.yml index fd39b61..6aa5b1d 100644 --- a/t/ME_data/config_mtmb.yml +++ b/t/ME_data/config_mtmb.yml @@ -1,47 +1,45 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false random generator: name: mixmax seed: 1 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 Higgs coupling: use impact factors: false mt: 174 include bottom: true mb: 4.7 diff --git a/t/ME_data/config_pure.yml b/t/ME_data/config_pure.yml index f0e9ef1..1bdb9b2 100644 --- a/t/ME_data/config_pure.yml +++ b/t/ME_data/config_pure.yml @@ -1,41 +1,39 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_w_ME.yml b/t/ME_data/config_w_ME.yml index de6c531..7a24eb4 100644 --- a/t/ME_data/config_w_ME.yml +++ b/t/ME_data/config_w_ME.yml @@ -1,41 +1,39 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: reweight non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_ww_ME.yml b/t/ME_data/config_ww_ME.yml index a57407d..151050b 100644 --- a/t/ME_data/config_ww_ME.yml +++ b/t/ME_data/config_ww_ME.yml @@ -1,39 +1,37 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 91.187 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_ww_ME_hejnlo.yml b/t/ME_data/config_ww_ME_hejnlo.yml index 1aadd76..e8650b1 100644 --- a/t/ME_data/config_ww_ME_hejnlo.yml +++ b/t/ME_data/config_ww_ME_hejnlo.yml @@ -1,42 +1,40 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort scales: 91.187 log correction: false NLO truncation: enabled: true vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_wzhpure_ME_hejnlo.yml b/t/ME_data/config_wzhpure_ME_hejnlo.yml index 4d34688..8cc2373 100644 --- a/t/ME_data/config_wzhpure_ME_hejnlo.yml +++ b/t/ME_data/config_wzhpure_ME_hejnlo.yml @@ -1,44 +1,42 @@ trials: 1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: reweight non-resummable: discard - unknown: abort - invalid: abort scales: 125 soft pt regulator: 1 log correction: false NLO truncation: enabled: true vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/analysis_config.yml b/t/analysis_config.yml index 8aedd71..ac8e282 100644 --- a/t/analysis_config.yml +++ b/t/analysis_config.yml @@ -1,43 +1,41 @@ trials: 10 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqbar: reweight central qqbar: discard non-resummable: keep - unknown: abort - invalid: abort log correction: false scales: 125 random generator: name: mixmax seed: 11 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 max events: 100 analyses: diff --git a/t/analysis_config_single.yml.in b/t/analysis_config_single.yml.in index 735d177..0c34b58 100644 --- a/t/analysis_config_single.yml.in +++ b/t/analysis_config_single.yml.in @@ -1,45 +1,43 @@ trials: 10 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqbar: reweight central qqbar: discard non-resummable: keep - unknown: abort - invalid: abort log correction: false scales: 125 random generator: name: mixmax seed: 11 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 analysis: plugin: @ANALYSIS_PATH@/lib@ANALYSIS_LIB@.so @ANALYSIS_PARAMETERS@ max events: 100 diff --git a/t/config_check_res.yml.in b/t/config_check_res.yml.in index 906176a..0c10520 100644 --- a/t/config_check_res.yml.in +++ b/t/config_check_res.yml.in @@ -1,44 +1,42 @@ trials: 100 resummation jets: min pt: 35 algorithm: kt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqbar: reweight central qqbar: reweight non-resummable: discard - unknown: abort - invalid: abort log correction: false scales: @CENTRALSCALE@ random generator: name: mixmax seed: 2 vev: 246.2196508 require low pt jet: @LOWPT_OPTION@ particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 max events: 100 diff --git a/t/jet_config.yml b/t/jet_config.yml index a11fed9..d2920d2 100644 --- a/t/jet_config.yml +++ b/t/jet_config.yml @@ -1,51 +1,49 @@ trials: 10 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: keep extremal qqbar: discard central qqbar: keep non-resummable: keep - unknown: abort - invalid: abort log correction: false scales: [125, 91.188] scale factors: [0.5, 1, 2] max scale ratio: 2.0001 random generator: name: mixmax seed: 1024 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 max events: 500 unweight: type: partial trials: 100 max deviation: -1 event output: - tst.lhe diff --git a/t/jet_config_with_import.yml.in b/t/jet_config_with_import.yml.in index c818456..f0cf167 100644 --- a/t/jet_config_with_import.yml.in +++ b/t/jet_config_with_import.yml.in @@ -1,44 +1,42 @@ trials: 10 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqbar: discard central qqbar: discard non-resummable: discard - unknown: abort - invalid: abort log correction: false scales: @SCALE_NAME@ event output: - tst.lhe random generator: name: ranlux64 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 import scales: @SCALE_PATH@/lib@SCALE_LIB@.so: @SCALE_NAME@