No OneTemporary
Actions

Size

40 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 425ad34..8f3ed56 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,280 +1,280 @@
	cmake_minimum_required(VERSION 3.1 FATAL_ERROR)

	set(CMAKE_LEGACY_CYGWIN_WIN32 0)
	set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

	-project("HEJ" VERSION 2.0.4 LANGUAGES C CXX)
	+project("HEJ" VERSION 2.0.5 LANGUAGES C CXX)

	# Set a default build type if none was specified
	set(default_build_type "RelWithDebInfo")

	if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
	message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
	set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
	STRING "Choose the type of build." FORCE)
	# Set the possible values of build type for cmake-gui
	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
	"Debug" "Release" "MinSizeRel" "RelWithDebInfo")
	endif()

	## Flags for the compiler. No warning allowed.
	if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
	elseif (MSVC)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /EHsc")
	endif()
	set(CMAKE_CXX_STANDARD_REQUIRED ON)
	set(CMAKE_CXX_STANDARD 14)

	## Create Version
	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")


	# Get the latest abbreviated commit hash of the working branch
	execute_process(
	COMMAND git rev-parse HEAD
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE PROJECT_GIT_REVISION
	OUTPUT_STRIP_TRAILING_WHITESPACE
	)
	# Get the current working branch
	execute_process(
	COMMAND git rev-parse --abbrev-ref HEAD
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE PROJECT_GIT_BRANCH
	OUTPUT_STRIP_TRAILING_WHITESPACE
	)

	## target directories for install
	set(INSTALL_INCLUDE_DIR_BASE include)
	set(INSTALL_INCLUDE_DIR ${INSTALL_INCLUDE_DIR_BASE}/HEJ)
	set(INSTALL_BIN_DIR bin)
	set(INSTALL_LIB_DIR lib)
	set(INSTALL_CONFIG_DIR lib/cmake/HEJ)

	## Template files
	configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Templates/Version.hh.in
	${PROJECT_BINARY_DIR}/include/HEJ/Version.hh @ONLY )

	configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Templates/HEJ-config.cc.in
	${PROJECT_BINARY_DIR}/src/bin/HEJ-config.cc @ONLY )

	# Generate CMake config file
	include(CMakePackageConfigHelpers)
	configure_package_config_file(
	cmake/Templates/hej-config.cmake.in
	${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_CONFIG_DIR}/hej-config.cmake
	INSTALL_DESTINATION ${INSTALL_CONFIG_DIR}
	PATH_VARS INSTALL_INCLUDE_DIR_BASE INSTALL_LIB_DIR
	)
	write_basic_package_version_file(
	${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_CONFIG_DIR}/hej-config-version.cmake
	COMPATIBILITY SameMajorVersion
	)
	install(
	FILES ${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_CONFIG_DIR}/hej-config.cmake
	${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_CONFIG_DIR}/hej-config-version.cmake
	DESTINATION ${INSTALL_CONFIG_DIR})

	## Add directories and find dependences
	include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include)

	find_package(fastjet REQUIRED)
	include_directories(${fastjet_INCLUDE_DIRS})
	find_package(CLHEP 2.3 REQUIRED)
	include_directories(${CLHEP_INCLUDE_DIRS})
	find_package(LHAPDF REQUIRED)
	include_directories(${LHAPDF_INCLUDE_DIRS})
	## Amend unintuitive behaviour of FindBoost.cmake
	## Priority of BOOST_ROOT over BOOSTROOT matches FindBoost.cmake
	## at least for cmake 3.12
	if(DEFINED BOOST_ROOT)
	message("BOOST_ROOT set - only looking for Boost in ${BOOST_ROOT}")
	set(Boost_NO_BOOST_CMAKE ON)
	elseif(DEFINED BOOSTROOT)
	message("BOOSTROOT set - only looking for Boost in ${BOOSTROOT}")
	set(Boost_NO_BOOST_CMAKE ON)
	endif()
	find_package(Boost REQUIRED COMPONENTS iostreams)
	include_directories(${Boost_INCLUDE_DIRS})
	find_package(yaml-cpp) # requiring yaml does not work with fedora
	include_directories(${YAML_CPP_INCLUDE_DIR})
	if(${EXCLUDE_HepMC})
	message(STATUS "Skipping HepMC")
	# avoid "unused variable" warning if EXCLUDE_rivet is set by user
	set(EXCLUDE_rivet TRUE)
	else()
	find_package(HepMC 2)
	endif()
	if(${HepMC_FOUND})
	set(
	CMAKE_CXX_FLAGS
	"${CMAKE_CXX_FLAGS} -DHEJ_BUILD_WITH_HepMC_VERSION=${HepMC_VERSION_MAJOR}"
	)
	include_directories(${HepMC_INCLUDE_DIRS})
	if(${EXCLUDE_rivet})
	message(STATUS "Skipping rivet")
	else()
	find_package(rivet)
	endif()
	if(${rivet_FOUND})
	include_directories(${rivet_INCLUDE_DIRS})
	set(
	CMAKE_CXX_FLAGS
	"${CMAKE_CXX_FLAGS} -DHEJ_BUILD_WITH_RIVET"
	)
	endif()
	endif()
	if(${EXCLUDE_QCDloop})
	message(STATUS "Skipping QCDloop")
	else()
	find_package(QCDloop 2)
	endif()
	if(${QCDloop_FOUND})
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHEJ_BUILD_WITH_QCDLOOP")
	include_directories(SYSTEM ${QCDloop_INCLUDE_DIRS})
	endif()

	add_subdirectory(src)

	## define executable
	add_executable(HEJ src/bin/HEJ.cc)

	## link libraries
	target_link_libraries(HEJ hejlib)

	add_executable(HEJ-config src/bin/HEJ-config.cc)

	file(GLOB hej_headers ${CMAKE_CURRENT_SOURCE_DIR}/include/HEJ/.hh ${PROJECT_BINARY_DIR}/include/HEJ/.hh)
	file(GLOB lhef_headers ${CMAKE_CURRENT_SOURCE_DIR}/include/LHEF/*.h)
	install(FILES ${hej_headers} DESTINATION ${INSTALL_INCLUDE_DIR})
	install(FILES ${lhef_headers} DESTINATION include/LHEF/)
	install(TARGETS HEJ HEJ-config DESTINATION ${INSTALL_BIN_DIR})

	## tests
	enable_testing()
	set(tst_dir "${CMAKE_CURRENT_SOURCE_DIR}/t")
	add_executable(test_classify ${tst_dir}/test_classify.cc)
	add_executable(test_psp ${tst_dir}/test_psp.cc)
	add_executable(test_ME_generic ${tst_dir}/test_ME_generic.cc)
	add_executable(check_res ${tst_dir}/check_res.cc)
	add_executable(check_lhe ${tst_dir}/check_lhe.cc)
	add_library(scales SHARED ${tst_dir}/scales.cc)
	add_executable(test_scale_import ${tst_dir}/test_scale_import)
	add_executable(test_descriptions ${tst_dir}/test_descriptions)
	add_executable(test_scale_arithmetics ${tst_dir}/test_scale_arithmetics)
	add_executable(test_parameters ${tst_dir}/test_parameters)
	add_executable(test_colours ${tst_dir}/test_colours)
	target_link_libraries(test_classify hejlib)
	target_link_libraries(test_psp hejlib)
	target_link_libraries(test_ME_generic hejlib)
	target_link_libraries(check_res hejlib)
	target_link_libraries(check_lhe hejlib)
	target_link_libraries(test_scale_import hejlib)
	target_link_libraries(test_descriptions hejlib)
	target_link_libraries(test_scale_arithmetics hejlib)
	target_link_libraries(test_parameters hejlib)
	target_link_libraries(test_colours hejlib)

	## add tests
	add_test(
	NAME t_classify
	COMMAND test_classify ${tst_dir}/classify.lhe.gz
	)
	add_test(
	NAME t_psp
	COMMAND test_psp ${tst_dir}/psp_gen.lhe.gz
	)
	set(tst_ME_data_dir "${tst_dir}/ME_data")
	add_test(
	NAME t_ME_j
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml ${tst_ME_data_dir}/ME_jets.dat ${tst_ME_data_dir}/PSP_jets.lhe.gz
	)
	add_test(
	NAME t_ME_h
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml ${tst_ME_data_dir}/ME_h_mtinf.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	if(${QCDloop_FOUND})
	add_test(
	NAME t_ME_h_mt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mt.yml ${tst_ME_data_dir}/ME_h_mt.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	add_test(
	NAME t_ME_h_mtmb
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtmb.yml ${tst_ME_data_dir}/ME_h_mtmb.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	endif()
	add_test(
	NAME t_2j
	COMMAND check_res ${tst_dir}/2j.lhe.gz 3.49391e+07 419684
	)
	add_test(
	NAME t_3j
	COMMAND check_res ${tst_dir}/3j.lhe.gz 2.37902e+06 25746.6
	)
	add_test(
	NAME t_4j
	COMMAND check_res ${tst_dir}/4j.lhe.gz 603713 72822.6
	)
	add_test(
	NAME t_h_3j
	COMMAND check_res ${tst_dir}/h_3j.lhe.gz 0.821622 0.0220334
	)
	add_test(
	NAME t_h_3j_uno
	COMMAND check_res ${tst_dir}/h_3j_uno.lhe.gz 0.0261968 0.000341549 uno
	)
	if(${HepMC_FOUND})
	file(READ "${tst_dir}/jet_config.yml" config)
	file(WRITE "${tst_dir}/jet_config_withHepMC.yml" "${config} - tst.hepmc")
	if(${rivet_FOUND})
	file(READ "${tst_dir}/jet_config_withHepMC.yml" config)
	file(WRITE "${tst_dir}/jet_config_withRivet.yml" "${config}\n\nanalysis:\n rivet: MC_XS\n output: tst")
	add_test(
	NAME t_main
	COMMAND HEJ ${tst_dir}/jet_config_withRivet.yml ${tst_dir}/2j.lhe.gz
	)
	else()
	add_test(
	NAME t_main
	COMMAND HEJ ${tst_dir}/jet_config_withHepMC.yml ${tst_dir}/2j.lhe.gz
	)
	endif()
	if(${HepMC_VERSION_MAJOR} GREATER 2)
	add_executable(check_hepmc ${tst_dir}/check_hepmc.cc)
	target_link_libraries(check_hepmc hejlib)
	add_test(
	NAME t_hepmc
	COMMAND check_hepmc tst.hepmc
	)
	endif()
	else()
	add_test(
	NAME t_main
	COMMAND HEJ ${tst_dir}/jet_config.yml ${tst_dir}/2j.lhe.gz
	)
	endif()
	add_test(
	NAME t_lhe
	COMMAND check_lhe tst.lhe
	)
	add_test(
	NAME t_scale_import
	COMMAND test_scale_import ${tst_dir}/jet_config_with_import.yml
	)
	add_test(
	NAME t_descriptions
	COMMAND test_descriptions
	)
	add_test(
	NAME t_scale_arithmetics
	COMMAND test_scale_arithmetics ${tst_dir}/jet_config.yml ${tst_dir}/2j.lhe.gz
	)
	add_test(
	NAME test_parameters
	COMMAND test_parameters
	)
	add_test(
	NAME t_colour_flow
	COMMAND test_colours
	)
	diff --git a/Changes.md b/Changes.md
	index 69b9081..1f210a0 100644
	--- a/Changes.md
	+++ b/Changes.md
	@@ -1,55 +1,59 @@
	# Version 2.0

	## 2.X.0

	* Made `MatrixElement.tree_kin(...)` and `MatrixElement.tree_param(...)` public
	* Allow multiplication and division of multiple scale functions e.g.
	`H_T/2*m_j1j2`
	* Follow HepMC convention for particle Status codes: incoming = 11,
	decaying = 2, outgoing = 1 (unchanged)
	* New class `CrossSectionAccumulator` to keep track of Cross Section of the
	different subproccess
	* New template struct `Parameters` similar to old `Weights`
	- `Weights` are now an alias for `Parameters<double>`. Calling `Weights` did
	not change
	- `Weights.hh` was replaced by `Parameters.hh`. The old `Weights.hh` header
	will be removed in HEJ Version 2.3.0
	* Function to multiplication and division of `EventParameters.weight` by double
	- This can be combined with `Parameters`, e.g.
	`Parameters<EventParameters>*Weights`, see also `Events.parameters()`
	- Moved `EventParameters` to `Parameters.hh` header
	* Restructured `Event` class
	- `Event` can now only be build from a (new) `Event::EventData` class
	- Removed default constructor for `Event`
	- `Event::EventData` replaces the old `UnclusteredEvent` struct.
	- `UnclusteredEvent` is now deprecated, and will be removed in HEJ Version
	2.3.0
	- Removed `Event.unclustered()` function
	- Added new member function `Events.parameters()`, to directly access
	(underlying) `Parameters<EventParameters>`
	* Added optional Colour charges to particles (`Particle.colour`)
	- Colours are read from and written to LHE files
	- Colour connection in the HEJ limit can be generated via
	`Event::generate_colours` (automatically done in the resummation)

	+## 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`
	* Correctly include rivet headers
	* New `EXCLUDE_package` variable in `cmake` to not interface to specific
	packages
	* Consistent search and include for side packages in `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/FixedOrderGen/CMakeLists.txt b/FixedOrderGen/CMakeLists.txt
	index 9a49b94..aec1fbb 100644
	--- a/FixedOrderGen/CMakeLists.txt
	+++ b/FixedOrderGen/CMakeLists.txt
	@@ -1,113 +1,113 @@
	cmake_minimum_required(VERSION 3.1 FATAL_ERROR)

	set(CMAKE_LEGACY_CYGWIN_WIN32 0)
	set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

	-project("HEJ Fixed Order Generation" VERSION 2.0.4 LANGUAGES C CXX)
	+project("HEJ Fixed Order Generation" VERSION 2.0.5 LANGUAGES C CXX)

	# Set a default build type if none was specified
	set(default_build_type "RelWithDebInfo")

	if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
	message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
	set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
	STRING "Choose the type of build." FORCE)
	# Set the possible values of build type for cmake-gui
	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
	"Debug" "Release" "MinSizeRel" "RelWithDebInfo")
	endif()

	## Flags for the compiler. No warning allowed.
	if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
	elseif (MSVC)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /EHsc")
	endif()
	set(CMAKE_CXX_STANDARD_REQUIRED ON)
	set(CMAKE_CXX_STANDARD 14)

	## Create Version
	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")


	# Get the latest abbreviated commit hash of the working branch
	execute_process(
	COMMAND git rev-parse HEAD
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE PROJECT_GIT_REVISION
	OUTPUT_STRIP_TRAILING_WHITESPACE
	)
	# Get the current working branch
	execute_process(
	COMMAND git rev-parse --abbrev-ref HEAD
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE PROJECT_GIT_BRANCH
	OUTPUT_STRIP_TRAILING_WHITESPACE
	)

	CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Templates/Version.hh.in
	${PROJECT_BINARY_DIR}/include/Version.hh @ONLY )

	## Add directories and find dependences
	include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include)
	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/../cmake/Modules/")

	find_package(HEJ 2 REQUIRED)
	include_directories(${HEJ_INCLUDE_DIR})
	find_package(fastjet REQUIRED)
	include_directories(${fastjet_INCLUDE_DIRS})
	find_package(CLHEP 2.3 REQUIRED)
	include_directories(${CLHEP_INCLUDE_DIRS})
	find_package(LHAPDF REQUIRED)
	include_directories(${LHAPDF_INCLUDE_DIRS})
	## Amend unintuitive behaviour of FindBoost.cmake
	## Priority of BOOST_ROOT over BOOSTROOT matches FindBoost.cmake
	## at least for cmake 3.12
	if(DEFINED BOOST_ROOT)
	message("BOOST_ROOT set - only looking for Boost in ${BOOST_ROOT}")
	set(Boost_NO_BOOST_CMAKE ON)
	elseif(DEFINED BOOSTROOT)
	message("BOOSTROOT set - only looking for Boost in ${BOOSTROOT}")
	set(Boost_NO_BOOST_CMAKE ON)
	endif()
	find_package(Boost REQUIRED COMPONENTS iostreams)
	include_directories(${Boost_INCLUDE_DIRS})
	find_package(yaml-cpp) # requiring yaml does not work with fedora
	include_directories(${YAML_CPP_INCLUDE_DIR})

	## define executable
	file(GLOB HEJFOG_source ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cc)
	list(REMOVE_ITEM HEJFOG_source ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cc)
	add_library(hejfog STATIC ${HEJFOG_source})
	add_executable(HEJFOG ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cc)

	## link libraries
	set(libraries ${CMAKE_DL_LIBS} ${LHAPDF_LIBRARIES} ${CLHEP_LIBRARIES}
	${fastjet_LIBRARIES} ${Boost_LIBRARIES} ${YAML_CPP_LIBRARIES} ${HEJ_LIBRARIES})

	target_link_libraries(hejfog ${libraries})
	target_link_libraries(HEJFOG hejfog)

	install(TARGETS HEJFOG DESTINATION bin)

	## tests

	enable_testing()
	set(tst_dir "${CMAKE_CURRENT_SOURCE_DIR}/t")
	foreach(tst h_2j h_3j h_5j h_3j_uno1 h_3j_uno2 h_2j_decay 2j 4j)
	add_executable(test_${tst} ${tst_dir}/${tst}.cc)
	target_link_libraries(test_${tst} hejfog)
	add_test(NAME t_${tst} COMMAND test_${tst} WORKING_DIRECTORY ${tst_dir})
	endforeach()
	add_test(
	NAME t_main_2j
	COMMAND HEJFOG ${tst_dir}/config_2j.yml
	)
	add_test(
	NAME t_main_h2j
	COMMAND HEJFOG ${tst_dir}/config_h_2j.yml
	)
	add_test(
	NAME t_main_h2j_decay
	COMMAND HEJFOG ${tst_dir}/config_h_2j_decay.yml
	)
	diff --git a/doc/sphinx/conf.py b/doc/sphinx/conf.py
	index a9d958d..12fdfff 100644
	--- a/doc/sphinx/conf.py
	+++ b/doc/sphinx/conf.py
	@@ -1,175 +1,175 @@
	# -- coding: utf-8 --
	#
	# HEJ 2 documentation build configuration file, created by
	# sphinx-quickstart on Fri Sep 15 16:13:57 2017.
	#
	# This file is execfile()d with the current directory set to its
	# containing dir.
	#
	# Note that not all possible configuration values are present in this
	# autogenerated file.
	#
	# All configuration values have a default; values that are commented out
	# serve to show the default.

	# If extensions (or modules to document with autodoc) are in another directory,
	# add these directories to sys.path here. If the directory is relative to the
	# documentation root, use os.path.abspath to make it absolute, like shown here.
	#
	# import os
	# import sys
	# sys.path.insert(0, os.path.abspath('.'))


	# -- General configuration ------------------------------------------------

	# If your documentation needs a minimal Sphinx version, state it here.
	#
	# needs_sphinx = '1.0'

	# Add any Sphinx extension module names here, as strings. They can be
	# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
	# ones.
	extensions = ['sphinx.ext.mathjax',
	'sphinx.ext.githubpages']

	# Add any paths that contain templates here, relative to this directory.
	templates_path = ['_templates']

	# The suffix(es) of source filenames.
	# You can specify multiple suffix as a list of string:
	#
	# source_suffix = ['.rst', '.md']
	source_suffix = '.rst'

	# The master toctree document.
	master_doc = 'index'

	# General information about the project.
	project = u'HEJ 2'
	copyright = u'2017, Jeppe Andersen, Tuomas Hapola, Marian Heil, Andreas Maier, Jennifer Smillie'
	author = u'Jeppe Andersen, Tuomas Hapola, Marian Heil, Andreas Maier, Jennifer Smillie'

	# The version info for the project you're documenting, acts as replacement for
	# \|version\| and \|release\|, also used in various other places throughout the
	# built documents.
	#
	# The short X.Y version.
	version = u'2.0'
	# The full version, including alpha/beta/rc tags.
	-release = u'2.0.4'
	+release = u'2.0.5'

	# The language for content autogenerated by Sphinx. Refer to documentation
	# for a list of supported languages.
	#
	# This is also used if you do content translation via gettext catalogs.
	# Usually you set "language" from the command line for these cases.
	language = None

	# List of patterns, relative to source directory, that match files and
	# directories to ignore when looking for source files.
	# This patterns also effect to html_static_path and html_extra_path
	exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']

	highlight_language = 'C++'

	# The name of the Pygments (syntax highlighting) style to use.
	pygments_style = 'sphinx'

	# If true, `todo` and `todoList` produce output, else they produce nothing.
	todo_include_todos = False


	# -- Options for HTML output ----------------------------------------------

	# The theme to use for HTML and HTML Help pages. See the documentation for
	# a list of builtin themes.
	html_theme = 'alabaster'

	# Theme options are theme-specific and customize the look and feel of a theme
	# further. For a list of options available for each theme, see the
	# documentation.
	html_theme_options = {
	'body_text': '#000000',
	'narrow_sidebar_fg': '#000000',
	'sidebar_header': '#000000',
	'sidebar_link': '#000000',
	'sidebar_text': '#000000'
	}

	# Add any paths that contain custom static files (such as style sheets) here,
	# relative to this directory. They are copied after the builtin static files,
	# so a file named "default.css" will overwrite the builtin "default.css".
	# html_static_path = ['_static']

	# Custom sidebar templates, must be a dictionary that maps document names
	# to template names.
	#
	# This is required for the alabaster theme
	# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
	html_sidebars = {
	'**': [
	'about.html',
	'navigation.html',
	'relations.html', # needs 'show_related': True theme option to display
	'searchbox.html',
	'donate.html',
	]
	}


	# -- Options for HTMLHelp output ------------------------------------------

	# Output file base name for HTML help builder.
	htmlhelp_basename = 'HEJ2doc'


	# -- Options for LaTeX output ---------------------------------------------

	latex_elements = {
	# The paper size ('letterpaper' or 'a4paper').
	#
	# 'papersize': 'letterpaper',

	# The font size ('10pt', '11pt' or '12pt').
	#
	# 'pointsize': '10pt',

	# Additional stuff for the LaTeX preamble.
	#
	# 'preamble': '',

	# Latex figure (float) alignment
	#
	# 'figure_align': 'htbp',
	}

	# Grouping the document tree into LaTeX files. List of tuples
	# (source start file, target name, title,
	# author, documentclass [howto, manual, or own class]).
	latex_documents = [
	(master_doc, 'HEJ2.tex', u'HEJ 2 Documentation',
	u'Jeppe Andersen, Tuomas Hapola, Marian Heil, Andreas Maier, Jennifer Smillie', 'manual'),
	]


	# -- Options for manual page output ---------------------------------------

	# One entry per manual page. List of tuples
	# (source start file, name, description, authors, manual section).
	man_pages = [
	(master_doc, 'hej2', u'HEJ 2 Documentation',
	[author], 1)
	]


	# -- Options for Texinfo output -------------------------------------------

	# Grouping the document tree into Texinfo files. List of tuples
	# (source start file, target name, title, author,
	# dir menu entry, description, category)
	texinfo_documents = [
	(master_doc, 'HEJ2', u'HEJ 2 Documentation',
	author, 'HEJ2', 'One line description of project.',
	'Miscellaneous'),
	]
	diff --git a/src/EventReweighter.cc b/src/EventReweighter.cc
	index e7efa51..fcda57c 100644
	--- a/src/EventReweighter.cc
	+++ b/src/EventReweighter.cc
	@@ -1,267 +1,268 @@
	/**
	* \authors Jeppe Andersen, Tuomas Hapola, Marian Heil, Andreas Maier, Jennifer Smillie
	* \date 2019
	* \copyright GPLv2 or later
	*/
	#include "HEJ/EventReweighter.hh"

	#include <algorithm>
	#include <assert.h>
	#include <limits>
	#include <math.h>
	#include <stddef.h>
	#include <string>
	#include <unordered_map>

	#include "fastjet/ClusterSequence.hh"

	#include "LHEF/LHEF.h"

	#include "HEJ/Event.hh"
	#include "HEJ/exceptions.hh"
	#include "HEJ/Particle.hh"
	#include "HEJ/PDG_codes.hh"
	#include "HEJ/PhaseSpacePoint.hh"

	namespace HEJ{
	using EventType = event_type::EventType;

	namespace {

	static_assert(
	std::numeric_limits<double>::has_quiet_NaN,
	"no quiet NaN for double"
	);
	constexpr double NaN = std::numeric_limits<double>::quiet_NaN();

	Event::EventData to_EventData(PhaseSpacePoint const & psp){
	Event::EventData result;
	result.incoming=psp.incoming();
	assert(result.incoming.size() == 2);
	result.outgoing=psp.outgoing();
	// technically Event::EventData doesn't have to be sorted,
	// but PhaseSpacePoint should be anyway
	assert(
	std::is_sorted(
	begin(result.outgoing), end(result.outgoing),
	rapidity_less{}
	)
	);
	assert(result.outgoing.size() >= 2);
	result.decays = psp.decays();
	result.parameters.central = {NaN, NaN, psp.weight()};
	return result;
	}

	} // namespace anonymous

	EventReweighter::EventReweighter(
	LHEF::HEPRUP const & heprup,
	ScaleGenerator scale_gen,
	EventReweighterConfig conf,
	HEJ::RNG & ran
	):
	EventReweighter{
	HEJ::Beam{
	heprup.EBMUP.first,
	{{
	static_cast<HEJ::ParticleID>(heprup.IDBMUP.first),
	static_cast<HEJ::ParticleID>(heprup.IDBMUP.second)
	}}
	},
	heprup.PDFSUP.first,
	std::move(scale_gen),
	std::move(conf),
	ran
	}
	{
	if(heprup.EBMUP.second != E_beam_){
	throw std::invalid_argument(
	"asymmetric beam: " + std::to_string(E_beam_)
	+ " ---> <--- " + std::to_string(heprup.EBMUP.second)
	);
	};
	if(heprup.PDFSUP.second != pdf_.id()){
	throw std::invalid_argument(
	"conflicting PDF ids: " + std::to_string(pdf_.id())
	+ " vs. " + std::to_string(heprup.PDFSUP.second)
	);
	}
	}

	EventReweighter::EventReweighter(
	Beam beam,
	int pdf_id,
	ScaleGenerator scale_gen,
	EventReweighterConfig conf,
	HEJ::RNG & ran
	):
	param_{std::move(conf)},
	E_beam_{beam.E},
	pdf_{pdf_id, beam.type.front(), beam.type.back()},
	MEt2_{
	[this](double mu){ return pdf_.Halphas(mu); },
	param_.ME_config
	},
	scale_gen_(std::move(scale_gen)),
	ran_{ran}
	{}

	PDF const & EventReweighter::pdf() const{
	return pdf_;
	}

	std::vector<Event> EventReweighter::reweight(
	Event const & input_ev, int num_events
	){
	auto res_events = gen_res_events(input_ev, num_events);
	if(res_events.empty()) return {};
	for(auto & event: res_events) event = scale_gen_(event);
	return rescale(input_ev, std::move(res_events));
	}

	std::vector<Event> EventReweighter::gen_res_events(
	Event const & ev,
	int phase_space_points
	){
	assert(ev.variations().empty());

	switch(param_.treat.at(ev.type())){
	case EventTreatment::discard: return {};
	case EventTreatment::keep:
	if(! jets_pass_resummation_cuts(ev)) return {};
	else return {ev};
	default:;
	}
	const double Born_shat = shat(ev);

	std::vector<Event> resummation_events;
	for(int psp_number = 0; psp_number < phase_space_points; ++psp_number){
	PhaseSpacePoint psp{ev, param_.psp_config, ran_};
	if(psp.weight() == 0.) continue;
	if(psp.incoming()[0].E() > E_beam_ \|\| psp.incoming()[1].E() > E_beam_) continue;

	resummation_events.emplace_back(
	to_EventData( std::move(psp) ).cluster(
	param_.jet_param.def, param_.jet_param.min_pt
	)
	);
	auto & new_event = resummation_events.back();
	+ assert(new_event.type() == ev.type());
	new_event.generate_colours(ran_);
	assert(new_event.variations().empty());
	new_event.central().mur = ev.central().mur;
	new_event.central().muf = ev.central().muf;
	const double resum_shat = shat(new_event);
	new_event.central().weight = ev.central().weightBorn_shat*Born_shat/
	(phase_space_pointsresum_shatresum_shat);
	}
	return resummation_events;
	}

	std::vector<Event> EventReweighter::rescale(
	Event const & Born_ev,
	std::vector<Event> events
	) const{
	const double Born_pdf = pdf_factors(Born_ev).central;
	const double Born_ME = tree_matrix_element(Born_ev);

	for(auto & cur_event: events){
	const auto pdf = pdf_factors(cur_event);
	assert(pdf.variations.size() == cur_event.variations().size());
	const auto ME = matrix_elements(cur_event);
	assert(ME.variations.size() == cur_event.variations().size());
	cur_event.parameters() = pdfME/(Born_pdf*Born_ME);
	}
	return events;
	};

	bool EventReweighter::jets_pass_resummation_cuts(
	Event const & ev
	) const{
	const auto out_as_PseudoJet = to_PseudoJet(filter_partons(ev.outgoing()));
	fastjet::ClusterSequence cs{out_as_PseudoJet, param_.jet_param.def};
	return cs.inclusive_jets(param_.jet_param.min_pt).size() == ev.jets().size();
	}

	Weights EventReweighter::pdf_factors(Event const & ev) const{
	auto const & a = ev.incoming().front();
	auto const & b = ev.incoming().back();
	const double xa = a.p.e()/E_beam_;
	const double xb = b.p.e()/E_beam_;

	Weights result;
	std::unordered_map<double, double> known_pdf;
	result.central =
	pdf_.pdfpt(0,xa,ev.central().muf,a.type)*
	pdf_.pdfpt(1,xb,ev.central().muf,b.type);
	known_pdf.emplace(ev.central().muf, result.central);

	result.variations.reserve(ev.variations().size());
	for(auto const & ev_param: ev.variations()){
	const double muf = ev_param.muf;
	auto cur_pdf = known_pdf.find(muf);
	if(cur_pdf == known_pdf.end()){
	cur_pdf = known_pdf.emplace(
	muf,
	pdf_.pdfpt(0,xa,muf,a.type)*pdf_.pdfpt(1,xb,muf,b.type)
	).first;
	}
	result.variations.emplace_back(cur_pdf->second);
	}
	assert(result.variations.size() == ev.variations().size());
	return result;
	}

	Weights
	EventReweighter::matrix_elements(Event const & ev) const{
	assert(param_.treat.count(ev.type()) > 0);
	if(param_.treat.find(ev.type())->second == EventTreatment::keep){
	return fixed_order_scale_ME(ev);
	}

	return MEt2_(ev);
	}

	double EventReweighter::tree_matrix_element(Event const & ev) const{
	assert(ev.variations().empty());
	assert(param_.treat.count(ev.type()) > 0);
	if(param_.treat.find(ev.type())->second == EventTreatment::keep){
	return fixed_order_scale_ME(ev).central;
	}
	return MEt2_.tree(ev).central;
	}

	Weights
	EventReweighter::fixed_order_scale_ME(Event const & ev) const{
	int alpha_s_power = 0;
	for(auto const & part: ev.outgoing()){
	if(is_parton(part))
	++alpha_s_power;
	else {
	switch(part.type){
	case pid::Higgs: {
	alpha_s_power += 2;
	break;
	}
	// TODO
	case pid::Wp:
	case pid::Wm:
	case pid::photon:
	case pid::Z:
	default:
	throw not_implemented("Emission of boson of unsupported type");
	}
	}
	}

	Weights result;
	result.central = pow(pdf_.Halphas(ev.central().mur), alpha_s_power);
	for(auto const & var: ev.variations()){
	result.variations.emplace_back(
	pow(pdf_.Halphas(var.mur), alpha_s_power)
	);
	}
	return result;
	}

	} // namespace HEJ
	diff --git a/t/test_ME_generic.cc b/t/test_ME_generic.cc
	index 2168702..02c4556 100644
	--- a/t/test_ME_generic.cc
	+++ b/t/test_ME_generic.cc
	@@ -1,108 +1,120 @@

	// Generic tester for the ME for a given set of PSP
	// reference weights and PSP (as LHE file) have to be given as _individual_ files

	#include <fstream>
	+#include <random>
	+#include <algorithm>

	#include "LHEF/LHEF.h"

	#include "HEJ/MatrixElement.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/YAMLreader.hh"
	#include "HEJ/stream.hh"

	constexpr double alpha_s = 0.118;
	constexpr double ep = 1e-6;

	+void shuffle_particles(HEJ::Event::EventData & ev) {
	+ static std::mt19937_64 ran{0};
	+ std::shuffle(begin(ev.incoming), end(ev.incoming), ran);
	+ std::shuffle(begin(ev.outgoing), end(ev.outgoing), ran);
	+}
	+
	void dump(HEJ::Event const & ev){
	{
	LHEF::Writer writer{std::cout};
	std::cout << std::setprecision(6);
	writer.hepeup = to_HEPEUP(std::move(ev), nullptr);
	writer.writeEvent();
	}
	std::cout << "Rapidity ordering:\n";
	for(const auto & part: ev.outgoing()){
	std::cout << std::setw(2) << part.type << ": "<< std::setw(7) << part.rapidity() << std::endl;
	}
	}

	int main(int argn, char** argv){
	if(argn != 4 && argn != 5){
	std::cerr << "\n# Usage:\n."<< argv[0] <<" config.yml ME_weights input_file.lhe\n\n";
	return EXIT_FAILURE;
	}
	bool OUTPUT_MODE = false;
	if(argn == 5 && std::string("OUTPUT")==std::string(argv[4]))
	OUTPUT_MODE = true;
	const HEJ::Config config = HEJ::load_config(argv[1]);

	std::fstream wgt_file;
	if ( OUTPUT_MODE ) {
	std::cout << "_______________________USING OUTPUT MODE!_______________________" << std::endl;
	wgt_file.open(argv[2], std::fstream::out);
	wgt_file.precision(10);
	} else {
	wgt_file.open(argv[2], std::fstream::in);
	}

	HEJ::istream in{argv[3]};
	LHEF::Reader reader{in};

	HEJ::MatrixElement ME{
	[](double){ return alpha_s; },
	HEJ::to_MatrixElementConfig(config)
	};
	double max_ratio = 0.;
	size_t idx_max_ratio = 0;
	+
	HEJ::Event ev_max_ratio(HEJ::Event::EventData{}.cluster(
	config.resummation_jets.def,0
	)
	);
	double av_ratio = 0;

	size_t i = 0;
	while(reader.readEvent()){
	++i;

	+ HEJ::Event::EventData data{reader.hepeup};
	+ shuffle_particles(data);
	+
	HEJ::Event event{
	- HEJ::Event::EventData{reader.hepeup}(
	+ data.cluster(
	config.resummation_jets.def,
	config.resummation_jets.min_pt
	)
	};
	const double our_ME = ME.tree(event).central;

	if ( OUTPUT_MODE ) {
	wgt_file << our_ME << std::endl;
	} else {
	std::string line;
	if(!std::getline(wgt_file,line)) break;
	const double ref_ME = std::stod(line);
	const double diff = std::abs(our_ME/ref_ME-1.);
	av_ratio+=diff;
	if( diff > max_ratio ) {
	max_ratio = diff;
	idx_max_ratio = i;
	ev_max_ratio = event;
	}
	if( diff > ep ){
	size_t precision(std::cout.precision());
	std::cout.precision(16);
	std::cout<< "Large difference in PSP " << i << "\nis: "<<our_ME << " should: " << ref_ME << " => difference: " << diff << std::endl;
	std::cout.precision(precision);
	dump(event);
	return EXIT_FAILURE;
	}
	}
	}
	wgt_file.close();
	if ( !OUTPUT_MODE ) {
	size_t precision(std::cout.precision());
	std::cout.precision(16);
	std::cout << "Avg ratio after " << i << " PSP: " << av_ratio/i << std::endl;
	std::cout << "maximal ratio at " << idx_max_ratio << ": " << max_ratio << std::endl;
	std::cout.precision(precision);
	}
	return EXIT_SUCCESS;
	}
	diff --git a/t/test_classify.cc b/t/test_classify.cc
	index aad756b..13081e3 100644
	--- a/t/test_classify.cc
	+++ b/t/test_classify.cc
	@@ -1,51 +1,62 @@
	+#include <random>
	+#include <algorithm>
	+
	#include "LHEF/LHEF.h"
	#include "HEJ/stream.hh"
	#include "HEJ/event_types.hh"
	#include "HEJ/Event.hh"

	namespace{
	constexpr double min_jet_pt = 30.;
	const fastjet::JetDefinition jet_def{fastjet::kt_algorithm, 0.4};
	using namespace HEJ::event_type;
	static const std::vector<EventType> results{
	unob,FKL,FKL,FKL,FKL,FKL,FKL,unob,FKL,unob,FKL,FKL,FKL,unof,FKL,unob,FKL,
	FKL,unob,unob,FKL,FKL,unob,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,unof,
	FKL,FKL,unof,FKL,FKL,FKL,FKL,FKL,unof,FKL,FKL,FKL,unof,FKL,FKL,unob,unof,
	FKL,unof,FKL,unob,FKL,FKL,unob,FKL,unob,unof,unob,unof,FKL,FKL,FKL,FKL,FKL,
	FKL,FKL,FKL,FKL,FKL,FKL,FKL,unob,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,unob,FKL,
	FKL,FKL,FKL,unof,FKL,unob,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,unob,FKL,
	FKL,FKL,FKL,FKL,unob,FKL,unob,unob,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,FKL,unof,unob,FKL
	};
	+
	+ void shuffle_particles(HEJ::Event::EventData & ev) {
	+ static std::mt19937_64 ran{0};
	+ std::shuffle(begin(ev.incoming), end(ev.incoming), ran);
	+ std::shuffle(begin(ev.outgoing), end(ev.outgoing), ran);
	+ }
	}

	int main(int argn, char** argv) {
	if(argn != 2){
	std::cerr << "Usage: test_classify eventfile";
	return EXIT_FAILURE;
	}

	HEJ::istream in{argv[1]};
	LHEF::Reader reader{in};
	LHEF::Writer writer{std::cerr};
	writer.heprup = reader.heprup;

	for(auto const & expected: results){
	reader.readEvent();
	+ HEJ::Event::EventData data{reader.hepeup};
	+ shuffle_particles(data);
	const HEJ::Event ev{
	- HEJ::Event::EventData{reader.hepeup}(
	+ data.cluster(
	jet_def, min_jet_pt
	)
	};

	if(ev.type() != expected){
	using HEJ::event_type::names;
	writer.hepeup = reader.hepeup;
	std::cerr << "wrong classification of event:\n";
	writer.writeEvent();
	std::cerr << "classified as " << names[ev.type()]
	<< ", is " << names[expected] << '\n';
	return EXIT_FAILURE;
	}
	}

	}
	diff --git a/t/test_parameters.cc b/t/test_parameters.cc
	index 518a89e..2261167 100644
	--- a/t/test_parameters.cc
	+++ b/t/test_parameters.cc
	@@ -1,71 +1,71 @@
	#include <iostream>
	#include <stdexcept>

	#include "HEJ/Parameters.hh"

	#define ASSERT(x) if(!(x)) { \
	throw std::logic_error("Assertion '" #x "' failed."); \
	}


	namespace {
	bool same_description(
	HEJ::EventParameters const & par1, HEJ::EventParameters const & par2
	){
	if( par1.mur!=par2.mur \|\| par1.muf!=par2.muf ) return false;
	auto const & des1 = par1.description;
	auto const & des2 = par2.description;
	if(bool(des1) != bool(des2)) return false; // only one set
	if(!des1) return true; // both not set
	return (des1->mur_factor == des2->mur_factor)
	&& (des1->muf_factor == des2->muf_factor)
	&& (des1->scale_name == des2->scale_name);
	}

	void same_description(
	HEJ::Parameters<HEJ::EventParameters> const & par1,
	HEJ::Parameters<HEJ::EventParameters> const & par2
	){
	ASSERT(same_description(par1.central, par2.central));
	ASSERT(par1.variations.size() == par2.variations.size());
	for(size_t i=0; i<par1.variations.size(); ++i)
	ASSERT( same_description(par1.variations[i], par2.variations[i]) );
	}
	}

	int main() {
	HEJ::Parameters<HEJ::EventParameters> ev_param;
	ev_param.central = HEJ::EventParameters{ 1,1,1.1,
	std::make_shared<HEJ::ParameterDescription>("a", 1.,1.) };
	ev_param.variations.emplace_back(
	HEJ::EventParameters{ 2,2,2.2,
	- std::make_shared<HEJ::ParameterDescription>("a", 2.,2.)
	+ std::make_shared<HEJ::ParameterDescription>("b", 2.,2.)
	});
	ev_param.variations.emplace_back(
	HEJ::EventParameters{ 3,3,3.3,
	- std::make_shared<HEJ::ParameterDescription>("b", 3.,3.)
	+ std::make_shared<HEJ::ParameterDescription>("c", 3.,3.)
	});

	HEJ::Weights weights;
	weights.central = 4.4;
	weights.variations.push_back(5.5);
	weights.variations.push_back(6.6);

	HEJ::Parameters<HEJ::EventParameters> mult_param;
	mult_param = ev_param*weights;
	same_description(ev_param, mult_param);
	ASSERT(mult_param.central.weight == ev_param.central.weight*weights.central);
	for(size_t i=0; i<weights.variations.size(); ++i)
	ASSERT(mult_param.variations[i].weight
	== ev_param.variations[i].weight*weights.variations[i]);

	HEJ::Parameters<HEJ::EventParameters> div_param;
	div_param = ev_param/weights;
	same_description(ev_param, div_param);
	ASSERT(div_param.central.weight == ev_param.central.weight/weights.central);
	for(size_t i=0; i<weights.variations.size(); ++i)
	ASSERT(div_param.variations[i].weight
	== ev_param.variations[i].weight/weights.variations[i]);

	return EXIT_SUCCESS;
	}
	diff --git a/t/test_scale_arithmetics.cc b/t/test_scale_arithmetics.cc
	index ca48b3a..b640726 100644
	--- a/t/test_scale_arithmetics.cc
	+++ b/t/test_scale_arithmetics.cc
	@@ -1,88 +1,99 @@

	// Generic tester for the ME for a given set of PSP
	// reference weights and PSP (as LHE file) have to be given as _individual_ files

	#include <fstream>
	+#include <random>
	+#include <algorithm>

	#include "LHEF/LHEF.h"

	#include "HEJ/EventReweighter.hh"
	#include "HEJ/make_RNG.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/YAMLreader.hh"
	#include "HEJ/stream.hh"

	constexpr double alpha_s = 0.118;
	constexpr double ep = 1e-13;

	void dump(HEJ::Event const & ev){
	{
	LHEF::Writer writer{std::cout};
	std::cout << std::setprecision(6);
	writer.hepeup = to_HEPEUP(std::move(ev), nullptr);
	writer.writeEvent();
	}
	std::cout << "Rapidity ordering:\n";
	for(const auto & part: ev.outgoing()){
	std::cout << std::setw(2) << part.type << ": "<< std::setw(7) << part.rapidity() << std::endl;
	}
	}

	+void shuffle_particles(HEJ::Event::EventData & ev) {
	+ static std::mt19937_64 ran{0};
	+ std::shuffle(begin(ev.incoming), end(ev.incoming), ran);
	+ std::shuffle(begin(ev.outgoing), end(ev.outgoing), ran);
	+}
	+
	int main(int argn, char** argv){
	if(argn != 3){
	std::cerr << "\n# Usage:\n."<< argv[0] <<" config.yml input_file.lhe\n\n";
	return EXIT_FAILURE;
	}
	HEJ::Config config = HEJ::load_config(argv[1]);
	config.scales = HEJ::to_ScaleConfig(
	YAML::Load("scales: [H_T, 1 * H_T, 2/2 * H_T, 2H_T/2, H_T/22, H_T/2/24, H_TH_T/H_T]")
	);

	HEJ::istream in{argv[2]};
	LHEF::Reader reader{in};

	auto ran = HEJ::make_RNG(config.rng.name, config.rng.seed);

	HEJ::ScaleGenerator scale_gen{
	config.scales.base,
	config.scales.factors,
	config.scales.max_ratio
	};

	HEJ::EventReweighter resum{
	reader.heprup,
	std::move(scale_gen),
	to_EventReweighterConfig(config),
	*ran
	};

	size_t i = 0;
	while(reader.readEvent()){
	++i;

	+ HEJ::Event::EventData data{reader.hepeup};
	+ shuffle_particles(data);
	+
	HEJ::Event event{
	- HEJ::Event::EventData{reader.hepeup}(
	+ data.cluster(
	config.resummation_jets.def,
	config.resummation_jets.min_pt
	)
	};

	auto resummed = resum.reweight(event, config.trials);
	for(auto && ev: resummed) {
	for(auto &&var: ev.variations()) {
	if(std::abs(var.muf - ev.central().muf) > ep) {
	std::cerr
	<< std::setprecision(15)
	<< "unequal scales: " << var.muf
	<< " != " << ev.central().muf << '\n'
	<< "in resummed event:\n";
	dump(ev);
	std::cerr << "\noriginal event:\n";
	dump(event);
	return EXIT_FAILURE;
	}
	}
	}
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jan 20, 11:31 PM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4242878
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions