No OneTemporary
Actions

Size

27 KB

Subscribers

None

View Options

	diff --git a/Changes.md b/Changes.md
	index d4d15a2..212bb7b 100644
	--- a/Changes.md
	+++ b/Changes.md
	@@ -1,47 +1,53 @@
	# Changelog

	This is the log for changes to the HEJ program. Further changes to the HEJ API
	are documented in `Changes-API.md`. If you are using HEJ as a library, please
	also read the changes there.

	## Version 2.X

	### 2.X.0

	+* Resummation for W bosons with jets
	+ - New subleading processes `extremal qqx` & `central qqx` for a quark and
	+ anti-quark in the final state, e.g. `g g => u d_bar Wm g` (the other
	+ subleading processes also work with W's)
	+ - `HEJFOG` can generate mutliple jets together with a (off-shell) W bosons
	+ decaying into lepton & neutrino
	* Allow multiplication and division of multiple scale functions e.g.
	`H_T/2*m_j1j2`
	* Print cross sections at end of run
	* Follow HepMC convention for particle Status codes: incoming = 11,
	decaying = 2, outgoing = 1 (unchanged)
	* Partons now have a Colour charge
	- Colours are read from and written to LHE files
	- For reweighted events the colours are created according to leading colour in
	the FKL limit
	* Allow changing the regulator lambda in input (`regulator parameter`, only for
	advanced users)
	* Use `git-lfs` for raw data in test (`make test` now requires `git-lfs`)
	* Added support to read `hdf5` event files suggested in
	[arXiv:1905.05120](https://arxiv.org/abs/1905.05120) (needs
	[HighFive](https://github.com/BlueBrain/HighFive))

	## 2.0.5

	* Fixed event classification for input not ordered in rapidity

	### 2.0.4

	* Fixed wrong path of `HEJ_INCLUDE_DIR` in `hej-config.cmake`

	### 2.0.3

	* Fixed parsing of (numerical factor) * (base scale) in configuration
	* Don't change scale names, but sanitise Rivet output file names instead

	### 2.0.2

	* Changed scale names to `"_over_"` and `"_times_"` for proper file names (was
	`"/"` and `"*"` before)

	### 2.0.1

	* Fixed name of fixed-order generator in error message.
	diff --git a/config.yml b/config.yml
	index bb93dad..f5db005 100644
	--- a/config.yml
	+++ b/config.yml
	@@ -1,97 +1,98 @@
	# number of attempted resummation phase space points for each input event
	trials: 10

	min extparton pt: 30 # minimum transverse momentum of extremal partons

	# maximum soft transverse momentum fraction in extremal jets
	#
	# max ext soft pt fraction: 0.1

	resummation jets: # resummation jet properties
	min pt: 35 # minimum jet transverse momentum
	algorithm: antikt # jet clustering algorithm
	R: 0.4 # jet R parameter

	fixed order jets: # properties of input jets
	min pt: 30
	# by default, algorithm and R are like for resummation jets

	# treatment of he various event classes
	# the supported settings are: reweight, keep, discard
	# non-HEJ events cannot be reweighted
	FKL: reweight
	unordered: keep
	-qqx: keep
	+extremal qqx: keep
	+central qqx: keep
	non-HEJ: keep

	# central scale choice or choices
	#
	# 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]

	log correction: false # whether or not to include higher order logs

	# event output files
	#
	# the supported formats are
	# - Les Houches (suffix .lhe)
	# - HepMC (suffix .hepmc3)
	# TODO: - ROOT ntuples (suffix .root)
	#
	# 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

	# to use a rivet analysis
	#
	# analysis:
	# rivet: MC_XS # rivet analysis name
	# output: HEJ # name of the yoda files, ".yoda" and scale suffix will be added
	#
	# to use a custom analysis
	#
	# 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

	# parameters for Higgs-gluon couplings
	# this requires compilation with qcdloop
	#
	# Higgs coupling:
	# use impact factors: false
	# mt: 174
	# include bottom: true
	# mb: 4.7

	## ---------------------------------------------------------------------- ##
	## The following settings are only intended for advances users. ##
	## Please DO NOT SET them unless you know exactly what you are doing! ##
	## ---------------------------------------------------------------------- ##
	#
	# regulator parameter: 0.2 # The regulator lambda for the subtraction terms
	diff --git a/include/HEJ/event_types.hh b/include/HEJ/event_types.hh
	index 783942d..7c88121 100644
	--- a/include/HEJ/event_types.hh
	+++ b/include/HEJ/event_types.hh
	@@ -1,81 +1,93 @@
	/** \file
	* \brief Define different types of events.
	*
	* \authors The HEJ collaboration (see AUTHORS for details)
	* \date 2019
	* \copyright GPLv2 or later
	*/
	#pragma once

	#include "HEJ/utility.hh"

	namespace HEJ{

	//! Namespace for event types
	namespace event_type{
	//! Possible event types
	enum EventType: size_t{
	FKL, /*< FKL-type event /
	unordered_backward, /*< event with unordered backward emission /
	unordered_forward, /*< event with unordered forward emission /
	extremal_qqxb, /*< event with a backward extremal qqbar /
	extremal_qqxf, /*< event with a forward extremal qqbar /
	central_qqx, /*< event with a central qqbar /
	nonHEJ, /*< event configuration not covered by HEJ /
	no_2_jets, /*< event with less than two jets /
	bad_final_state, /*< event with an unsupported final state /
	unob = unordered_backward,
	unof = unordered_forward,
	qqxexb = extremal_qqxb,
	qqxexf = extremal_qqxf,
	qqxmid = central_qqx,
	first_type = FKL,
	last_type = bad_final_state
	};

	//! Event type names
	/**
	* For example, names[FKL] is the string "FKL"
	*/
	static constexpr auto names = make_array(
	"FKL",
	"unordered backward",
	"unordered forward",
	"extremal qqbar backward",
	"extremal qqbar forward",
	"central qqbar",
	"nonHEJ",
	"no 2 jets",
	"bad final state"
	);

	//! Returns True for a HEJ \ref event_type::EventType "EventType"
	inline
	bool is_HEJ(EventType type) {
	switch(type) {
	case FKL:
	case unordered_backward:
	case unordered_forward:
	case extremal_qqxb:
	case extremal_qqxf:
	case central_qqx:
	return true;
	default:
	return false;
	}
	}

	//! Returns True for an unordered \ref event_type::EventType "EventType"
	inline
	bool is_uno(EventType type) {
	return type == unordered_backward \|\| type == unordered_forward;
	}

	+ //! Returns True for an extremal_qqx \ref event_type::EventType "EventType"
	inline
	- bool is_qqx(EventType type) {
	- return type == extremal_qqxb \|\| type == extremal_qqxf \|\| type == central_qqx;
	+ bool is_ex_qqx(EventType type) {
	+ return type == extremal_qqxb \|\| type == extremal_qqxf;
	+ }
	+
	+ //! Returns True for an central_qqx \ref event_type::EventType "EventType"
	+ inline
	+ bool is_mid_qqx(EventType type) {
	+ return type == central_qqx;
	}

	- }
	+ //! Returns True for any qqx event \ref event_type::EventType "EventType"
	+ inline
	+ bool is_qqx(EventType type) {
	+ return is_ex_qqx(type) \|\| is_mid_qqx(type);
	+ }

	-}
	+ } // namespace event_type
	+} // namespace HEJ
	diff --git a/src/YAMLreader.cc b/src/YAMLreader.cc
	index 1d02134..fe2ba20 100644
	--- a/src/YAMLreader.cc
	+++ b/src/YAMLreader.cc
	@@ -1,474 +1,474 @@
	/**
	* \authors The HEJ collaboration (see AUTHORS for details)
	* \date 2019
	* \copyright GPLv2 or later
	*/
	#include "HEJ/YAMLreader.hh"

	#include <algorithm>
	#include <iostream>
	#include <limits>
	#include <map>
	#include <string>
	#include <unordered_map>
	#include <vector>

	#include <dlfcn.h>

	#include "HEJ/ScaleFunction.hh"
	#include "HEJ/event_types.hh"
	#include "HEJ/output_formats.hh"
	#include "HEJ/Constants.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",
	- "FKL", "unordered", "qqx", "non-HEJ",
	+ "FKL", "unordered", "extremal qqx", "central qqx", "non-HEJ",
	"scales", "scale factors", "max scale ratio", "import scales",
	"log correction", "event output", "analysis", "regulator parameter"
	};
	// 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] = "";
	}
	return supported;
	}();
	return supported;
	}

	fastjet::JetAlgorithm to_JetAlgorithm(std::string const & algo){
	using namespace fastjet;
	static const std::map<std::string, fastjet::JetAlgorithm> 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<std::string, EventTreatment> known = {
	{"reweight", EventTreatment::reweight},
	{"keep", EventTreatment::keep},
	{"discard", EventTreatment::discard}
	};
	const auto res = known.find(name);
	if(res == known.end()){
	throw std::invalid_argument("Unknown event treatment " + name);
	}
	return res->second;
	}

	} // namespace anonymous

	namespace detail{
	void set_from_yaml(fastjet::JetAlgorithm & setting, YAML::Node const & yaml){
	setting = to_JetAlgorithm(yaml.as<std::string>());
	}

	void set_from_yaml(EventTreatment & setting, YAML::Node const & yaml){
	setting = to_EventTreatment(yaml.as<std::string>());
	}

	void set_from_yaml(ParticleID & setting, YAML::Node const & yaml){
	setting = to_ParticleID(yaml.as<std::string>());
	}
	} // 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;
	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;
	}

	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]){
	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<double>::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<std::string, FileFormat> known = {
	{"Les Houches", FileFormat::Les_Houches},
	{"HepMC", FileFormat::HepMC}
	};
	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 == filename.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;
	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<std::string>();
	if(! supported[name]) throw unknown_option{name};
	/* check sub-options, e.g. 'resummation jets: min pt'
	* we don't check analysis sub-options
	* those depend on the analysis being used and should be checked there
	* similar for "import scales"
	*/
	if(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<HEJ::OutputFile>::encode(HEJ::OutputFile const & outfile) {
	Node node;
	node[to_string(outfile.format)] = outfile.name;
	return node;
	};

	bool convert<HEJ::OutputFile>::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<std::string>());
	out.name = it->second.as<std::string>();
	return true;
	}
	case NodeType::Scalar:
	out.name = node.as<std::string>();
	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<OutputFile>();
	}
	}

	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;
	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<std::string> const & scale_names,
	std::unordered_map<std::string, EventScale> & known
	) {
	auto 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<EventScale>(sym));
	}
	}

	auto get_scale_map(
	YAML::Node const & yaml
	) {
	std::unordered_map<std::string, EventScale> 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"]) {
	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<std::string>();
	const auto scale_names =
	import.second.IsSequence()
	?import.second.as<std::vector<std::string>>()
	:std::vector<std::string>{import.second.as<std::string>()};
	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<std::string, EventScale> 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); }
	);
	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<std::string, EventScale> 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 == scale_fun.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);
	}
	else{
	assert(scale_fun[delim] == '*');
	return parse_ScaleFunction(first, known)
	* parse_ScaleFunction(second, known);
	}
	}

	EventTreatMap get_event_treatment(
	YAML::Node const & yaml
	){
	using namespace event_type;
	EventTreatMap treat {
	{no_2_jets, EventTreatment::discard},
	{bad_final_state, EventTreatment::discard},
	{FKL, EventTreatment::reweight},
	{unob, EventTreatment::keep},
	{unof, EventTreatment::keep},
	{qqxexb, EventTreatment::keep},
	{qqxexf, EventTreatment::keep},
	{qqxmid, EventTreatment::keep},
	{nonHEJ, EventTreatment::keep}
	};
	set_from_yaml(treat.at(FKL), yaml, "FKL");
	set_from_yaml(treat.at(unob), yaml, "unordered");
	treat.at(unof) = treat.at(unob);
	- set_from_yaml(treat.at(qqxexb), yaml, "qqx");
	- set_from_yaml(treat.at(qqxexf), yaml, "qqx");
	- set_from_yaml(treat.at(qqxmid), yaml, "qqx");
	+ set_from_yaml(treat.at(qqxexb), yaml, "extremal qqx");
	+ set_from_yaml(treat.at(qqxexf), yaml, "extremal qqx");
	+ set_from_yaml(treat.at(qqxmid), yaml, "central qqx");
	set_from_yaml(treat.at(nonHEJ), yaml, "non-HEJ");
	if(treat[nonHEJ] == EventTreatment::reweight){
	throw std::invalid_argument{"Cannot reweight non-HEJ events"};
	}
	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(config.min_extparton_pt, yaml, "min extparton pt");
	// Sets the standard value, then changes this if defined
	config.regulator_lambda=CLAMBDA;
	set_from_yaml_if_defined(config.regulator_lambda, yaml, "regulator parameter");
	config.max_ext_soft_pt_fraction = std::numeric_limits<double>::infinity();
	set_from_yaml_if_defined(
	config.max_ext_soft_pt_fraction, yaml, "max ext soft pt fraction"
	);
	set_from_yaml(config.trials, yaml, "trials");
	set_from_yaml(config.log_correction, yaml, "log correction");
	config.treat = get_event_treatment(yaml);
	set_from_yaml_if_defined(config.output, yaml, "event output");
	config.rng = to_RNGConfig(yaml, "random generator");
	set_from_yaml_if_defined(config.analysis_parameters, yaml, "analysis");
	config.scales = to_ScaleConfig(yaml);
	config.Higgs_coupling = get_Higgs_coupling(yaml, "Higgs coupling");
	return config;
	}

	} // namespace anonymous

	ScaleConfig to_ScaleConfig(YAML::Node const & yaml){
	ScaleConfig config;
	auto scale_funs = get_scale_map(yaml);
	std::vector<std::string> 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<double>::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_mt.yml b/t/ME_data/config_mt.yml
	index eae06e5..a88b482 100644
	--- a/t/ME_data/config_mt.yml
	+++ b/t/ME_data/config_mt.yml
	@@ -1,29 +1,30 @@
	trials: 1

	min extparton pt: 30

	resummation jets:
	min pt: 30
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: reweight
	-qqx: discard
	+extremal qqx: discard
	+central qqx: discard
	non-HEJ: discard

	scales: 125

	log correction: false

	random generator:
	name: mixmax
	seed: 1

	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 dbac6c1..e74df97 100644
	--- a/t/ME_data/config_mtinf.yml
	+++ b/t/ME_data/config_mtinf.yml
	@@ -1,24 +1,25 @@
	trials: 1

	min extparton pt: 30

	resummation jets:
	min pt: 30
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: reweight
	-qqx: discard
	+extremal qqx: discard
	+central qqx: discard
	non-HEJ: discard

	scales: 125

	log correction: false

	random generator:
	name: mixmax
	seed: 1
	diff --git a/t/ME_data/config_mtmb.yml b/t/ME_data/config_mtmb.yml
	index 5f965cd..8cd06b8 100644
	--- a/t/ME_data/config_mtmb.yml
	+++ b/t/ME_data/config_mtmb.yml
	@@ -1,30 +1,31 @@
	trials: 1

	min extparton pt: 30

	resummation jets:
	min pt: 30
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: reweight
	-qqx: discard
	+extremal qqx: discard
	+central qqx: discard
	non-HEJ: discard

	scales: 125

	log correction: false

	random generator:
	name: mixmax
	seed: 1

	Higgs coupling:
	use impact factors: false
	mt: 174
	include bottom: true
	mb: 4.7
	diff --git a/t/ME_data/config_w_ME.yml b/t/ME_data/config_w_ME.yml
	index 228fb7b..3a35832 100644
	--- a/t/ME_data/config_w_ME.yml
	+++ b/t/ME_data/config_w_ME.yml
	@@ -1,24 +1,25 @@
	trials: 1

	min extparton pt: 30

	resummation jets:
	min pt: 30
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: reweight
	-qqx: reweight
	+extremal qqx: reweight
	+central qqx: reweight
	non-HEJ: discard

	scales: 125

	log correction: false

	random generator:
	name: mixmax
	seed: 1
	diff --git a/t/jet_config.yml b/t/jet_config.yml
	index 510c3f0..2e68ed7 100644
	--- a/t/jet_config.yml
	+++ b/t/jet_config.yml
	@@ -1,26 +1,27 @@
	trials: 10

	min extparton pt: 30

	resummation jets:
	min pt: 35
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: discard
	-qqx: discard
	+extremal qqx: discard
	+central qqx: discard
	non-HEJ: discard

	log correction: false

	scales: 91.188

	random generator:
	name: ranlux64

	event output:
	- tst.lhe
	diff --git a/t/jet_config_with_import.yml b/t/jet_config_with_import.yml
	index aeb3566..b3d41c6 100644
	--- a/t/jet_config_with_import.yml
	+++ b/t/jet_config_with_import.yml
	@@ -1,29 +1,30 @@
	trials: 10

	min extparton pt: 30

	resummation jets:
	min pt: 35
	algorithm: antikt
	R: 0.4

	fixed order jets:
	min pt: 30

	FKL: reweight
	unordered: discard
	-qqx: discard
	+extremal qqx: discard
	+central qqx: discard
	non-HEJ: discard

	log correction: false

	scales: softest_jet_pt

	event output:
	- tst.lhe

	random generator:
	name: ranlux64

	import scales:
	./libscales.so: softest_jet_pt

File Metadata

Mime Type: text/x-diff
Expires: Tue, Nov 19, 3:34 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3799149
Default Alt Text: (27 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions