No OneTemporary
Actions

Size

25 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 86552fd..d38add3 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,226 +1,243 @@
	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.6 LANGUAGES C CXX)

	## User settings
	include(CMakeDependentOption)
	option(EXCLUDE_QCDloop "Do not include QCDloop" FALSE)
	option(EXCLUDE_HighFive "Do not include HighFive" FALSE)
	option(EXCLUDE_HepMC "Do not include HepMC version 2" FALSE)
	option(EXCLUDE_HepMC3 "Do not include HepMC version 3" FALSE)
	+option(EXCLUDE_ROOT "Do not include ROOT" TRUE)
	# Only skip rivet if we both HepMC 2 & 3 are excluded, since we don't know which
	# HepMC version rivet needs
	CMAKE_DEPENDENT_OPTION(EXCLUDE_rivet "Do not include rivet" FALSE
	"NOT EXCLUDE_HepMC OR NOT EXCLUDE_HepMC3" TRUE)

	option(BUILD_EXAMPLES "Build examples" FALSE)

	option(TEST_ALL "Run additional (longer) tests" FALSE)
	option(TEST_COVERAGE "Generate test coverage with \"gcovr\"" FALSE)

	# 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()

	## Global flags for the compiler (all warnings)
	if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
	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})

	## find dependencies
	find_package(fastjet REQUIRED)
	find_package(CLHEP 2.3 REQUIRED)
	find_package(LHAPDF REQUIRED)
	## 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)
	find_package(yaml-cpp) # requiring yaml does not work with fedora

	if(EXCLUDE_HepMC)
	message(STATUS "Skipping HepMC")
	else()
	find_package(HepMC 2 EXACT)
	endif()
	if(EXCLUDE_HepMC3)
	message(STATUS "Skipping HepMC3")
	else()
	## version 3.1: Finding version not possible in 3.1.1, see HepMC3 git 29e7a6c3
	find_package(HepMC3 QUIET) # suppress CMake warning if HepMC3 not available
	## print standard message
	find_package_handle_standard_args( HepMC3
	FOUND_VAR
	HepMC3_FOUND
	REQUIRED_VARS
	HEPMC3_INCLUDE_DIR
	HEPMC3_LIBRARIES
	# VERSION_VAR
	# HEPMC3_VERSION
	)
	endif()
	if(EXCLUDE_rivet)
	message(STATUS "Skipping rivet")
	else()
	find_package(rivet)
	if(rivet_FOUND)
	if(rivet_USE_HEPMC3 AND NOT HepMC3_FOUND)
	message(FATAL_ERROR "Rivet was compiled with HepMC version 3, "
	"but HepMC3 was not found!")
	elseif(NOT rivet_USE_HEPMC3 AND NOT HepMC_FOUND)
	message(FATAL_ERROR "Rivet was compiled with HepMC version 2, "
	"but HepMC2 was not found!")
	endif()
	endif()
	endif()

	if(EXCLUDE_QCDloop)
	message(STATUS "Skipping QCDloop")
	else()
	find_package(QCDloop 2)
	endif()
	+if(NOT EXCLUDE_ROOT)
	+ # Don't print "Skipping ROOT" for default option (EXCLUDE_ROOT=TRUE)
	+ find_package(ROOT 6.14) # root targets are broken before 6.14
	+ find_package_handle_standard_args( ROOT
	+ FOUND_VAR
	+ ROOT_FOUND
	+ REQUIRED_VARS
	+ ROOT_INCLUDE_DIRS
	+ ROOT_LIBRARIES
	+ VERSION_VAR
	+ ROOT_VERSION
	+ )
	+endif()
	if(EXCLUDE_HighFive)
	message(STATUS "Skipping HighFive")
	else()
	find_package(HighFive QUIET)
	find_package_handle_standard_args( HighFive CONFIG_MODE )
	endif()
	+
	include(RepairTargets) # more reliable cmake targets

	## shortcut for HEJ specific includes
	set(HEJ_INCLUDE_DIR
	$<INSTALL_INTERFACE:include>
	$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
	)


	if (TEST_COVERAGE AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) )
	include(CodeCoverage)
	APPEND_COVERAGE_COMPILER_FLAGS()
	set(COVERAGE_GCOVR_EXCLUDES "${PROJECT_SOURCE_DIR}/include/LHEF/*"
	"${PROJECT_SOURCE_DIR}/include/cxxopts.hpp"
	"${PROJECT_SOURCE_DIR}/t/*")
	SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML(
	NAME ctest_coverage
	EXECUTABLE ctest
	)
	endif()

	add_subdirectory(current_generator)
	## create main HEJ library
	add_subdirectory(src)

	## define executable
	add_executable(HEJ_main src/bin/HEJ.cc)
	set_target_properties(HEJ_main PROPERTIES OUTPUT_NAME "HEJ")

	## link libraries
	target_link_libraries(HEJ_main HEJ)

	add_executable(HEJ-config src/bin/HEJ-config.cc)
	target_include_directories(HEJ-config PRIVATE ${HEJ_INCLUDE_DIR})

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

	## tests (prevent testing if current project is a subproject)
	if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
	## advanced version of enable_testing()
	## adds "BUILD_TESTING" option to deactivate testing
	include(CTest)
	if(BUILD_TESTING)
	set(BUILD_EXAMPLES TRUE) # examples needed for testing
	set(include_tests TRUE)
	endif()
	endif()

	## build examples
	if(BUILD_EXAMPLES)
	+ message(STATUS "Adding examples")
	add_subdirectory(examples)
	endif()

	## build tests
	if(include_tests)
	+ message(STATUS "Adding tests")
	add_subdirectory(t)
	endif()

	add_subdirectory(doc)
	diff --git a/examples/AnalysisROOT.cc b/examples/AnalysisROOT.cc
	new file mode 100644
	index 0000000..b5c97a4
	--- /dev/null
	+++ b/examples/AnalysisROOT.cc
	@@ -0,0 +1,84 @@
	+//! Simple HEJ analysis to plot Delta y_{fb} with ROOT
	+
	+#include <memory> // for std::unique_ptr
	+#include <iostream> // for std::cout
	+
	+#include "TFile.h"
	+#include "TH1.h"
	+
	+#include "HEJ/Analysis.hh"
	+#include "HEJ/Event.hh"
	+#include "HEJ/Version.hh"
	+
	+namespace YAML {
	+ class Node;
	+}
	+
	+namespace LHEF {
	+ class HEPRUP;
	+}
	+
	+void Fill2DHistogram(TH1D & h,double x,double wt)
	+{
	+ const int binnumber=h.GetXaxis()->FindBin(x);
	+ const double binwidth=h.GetXaxis()->GetBinWidth(binnumber);
	+ h.Fill(x,wt/binwidth);
	+}
	+
	+class AnalysisROOT: public HEJ::Analysis {
	+private:
	+ TFile hfile_;
	+ TH1D htotal_,hydif_,hyf_,hyb_;
	+public:
	+ AnalysisROOT(
	+ YAML::Node const & /* config /, LHEF::HEPRUP const & / heprup */
	+ ):hfile_{"HEJ.root","RECREATE",
	+ ("Output from "+HEJ::Version::package_name_full()).c_str()},
	+ htotal_{"total","total",1,-0.5,.5},
	+ hydif_{"ydif","ydif",40,0.,10.},
	+ hyf_{"yf","yf",40,-5.,5.},
	+ hyb_{"yb","yb",40,-5.,5.}
	+ {
	+ // Setup histograms
	+ htotal_.Sumw2();
	+ hydif_.Sumw2();
	+ hyf_.Sumw2();
	+ hyb_.Sumw2();
	+ }
	+
	+ void fill(
	+ HEJ::Event const & event,
	+ HEJ::Event const & /* FO_event */
	+ ) override {
	+ const double weight=event.central().weight;
	+ htotal_.Fill(0.0,weight);
	+ auto const & jets=event.jets(); // jets are sorted in rapidity
	+ Fill2DHistogram(hydif_,
	+ fabs(jets.back().rapidity()-jets.front().rapidity()), weight);
	+ Fill2DHistogram(hyf_, jets.front().rapidity(), weight);
	+ Fill2DHistogram(hyb_, jets.back().rapidity(), weight);
	+ }
	+
	+ bool pass_cuts(
	+ HEJ::Event const & event,
	+ HEJ::Event const & /* FO_event */
	+ ) override {
	+ if (event.jets().size()<2)
	+ return false;
	+ return true;
	+ }
	+
	+ void finalise() override {
	+ hfile_.Write();
	+ hfile_.Close();
	+ std::cout << "AnalysisROOT bids you farewell " << std::endl; // be polite
	+ }
	+
	+};
	+
	+extern "C"
	+std::unique_ptr<HEJ::Analysis> make_analysis(
	+ YAML::Node const & config, LHEF::HEPRUP const & heprup
	+){
	+ return std::make_unique<AnalysisROOT>(config, heprup);
	+}
	diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
	index b6481fd..f64e195 100644
	--- a/examples/CMakeLists.txt
	+++ b/examples/CMakeLists.txt
	@@ -1,17 +1,25 @@
	set(example_dir "${CMAKE_CURRENT_SOURCE_DIR}")

	file(GLOB source_files ${example_dir}/*.cc)
	+
	+if(NOT ROOT_FOUND)
	+ list(REMOVE_ITEM source_files "${example_dir}/AnalysisROOT.cc")
	+endif()
	+
	foreach(source ${source_files})
	get_filename_component(name ${source} NAME_WE)
	add_library(${name}_lib SHARED ${source})
	set_target_properties(${name}_lib PROPERTIES OUTPUT_NAME "${name}")
	if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
	# Clang warns about `std::unique_ptr` in C linked (`extern "C"`) function
	# `make_analysis`. However this call is save from C++, and we don't care
	# about pure C. We can ignore the warning.
	target_compile_options(${name}_lib PRIVATE "-Wno-return-type-c-linkage")
	endif()
	-
	## link library
	target_link_libraries(${name}_lib HEJ)
	endforeach(source)
	+
	+if(ROOT_FOUND)
	+ target_link_libraries(AnalysisROOT_lib ROOT::Core ROOT::Hist ROOT::RIO)
	+endif()
	diff --git a/t/CMakeLists.txt b/t/CMakeLists.txt
	index ddabd4f..a2253de 100644
	--- a/t/CMakeLists.txt
	+++ b/t/CMakeLists.txt
	@@ -1,401 +1,415 @@
	set(tst_dir "${CMAKE_CURRENT_SOURCE_DIR}")
	set(tst_ME_data_dir "${tst_dir}/ME_data")

	# small library for common test functions
	add_library(hej_test SHARED hej_test.cc)
	target_include_directories(hej_test PUBLIC ${tst_dir})
	target_link_libraries(hej_test HEJ)
	# test event classification
	# test explicit configurations
	add_executable(test_classify ${tst_dir}/test_classify.cc)
	target_compile_options(test_classify PRIVATE "-O0") # avoid compiler optimisation
	target_link_libraries(test_classify HEJ hej_test)
	add_test(
	NAME t_classify
	COMMAND test_classify
	)
	# test against reference data
	add_executable(test_classify_ref ${tst_dir}/test_classify_ref.cc)
	target_link_libraries(test_classify_ref HEJ hej_test)
	add_test(
	NAME t_classify_ref
	COMMAND test_classify_ref ${tst_dir}/classify_ref ${tst_dir}/classify.lhe.gz
	)
	add_test(
	NAME t_classify_ref_4j
	COMMAND test_classify_ref ${tst_dir}/classify_ref_4j ${tst_dir}/4j.lhe.gz
	)
	add_test(
	NAME t_classify_ref_W4j
	COMMAND test_classify_ref ${tst_dir}/classify_ref_W4j ${tst_dir}/MGemnubar4j_unweighted.lhe.gz
	)

	# test for valid W decays
	add_executable(test_decay ${tst_dir}/test_decay.cc)
	target_link_libraries(test_decay HEJ hej_test)
	add_test(
	NAME t_valid_decay
	COMMAND test_decay
	)

	# test valid jet cuts on tagging jets
	add_executable(test_jet_cuts ${tst_dir}/test_jet_cuts.cc)
	target_link_libraries(test_jet_cuts HEJ hej_test)
	add_test(
	NAME t_jet_cuts
	COMMAND test_jet_cuts
	)

	# test phase space point
	add_executable(test_psp ${tst_dir}/test_psp.cc)
	target_link_libraries(test_psp HEJ hej_test)
	add_test(
	NAME t_psp
	COMMAND test_psp ${tst_dir}/psp_gen.lhe.gz
	)

	# test importing analyses

	get_target_property(ANALYSIS_PATH AnalysisTemplate_lib BINARY_DIR)
	get_target_property(ANALYSIS_LIB AnalysisTemplate_lib OUTPUT_NAME)
	set(ANALYSIS_PARAMETERS "")
	configure_file( ${tst_dir}/analysis_config.yml.in
	${PROJECT_BINARY_DIR}/t/analysis_config_simple.yml @ONLY )
	add_test(
	NAME t_analysis_simple
	COMMAND $<TARGET_FILE:HEJ_main>
	${PROJECT_BINARY_DIR}/t/analysis_config_simple.yml
	${tst_dir}/2j.lhe.gz
	)

	get_target_property(ANALYSIS_PATH AnalysisPrint_lib BINARY_DIR)
	get_target_property(ANALYSIS_LIB AnalysisPrint_lib OUTPUT_NAME)
	set(ANALYSIS_PARAMETERS " output: ana_output")
	configure_file( ${tst_dir}/analysis_config.yml.in
	${PROJECT_BINARY_DIR}/t/analysis_config_print.yml @ONLY )
	add_test(
	NAME t_analysis_print
	COMMAND $<TARGET_FILE:HEJ_main>
	${PROJECT_BINARY_DIR}/t/analysis_config_print.yml
	${tst_dir}/2j.lhe.gz
	)

	+if(ROOT_FOUND)
	+ get_target_property(ANALYSIS_PATH AnalysisROOT_lib BINARY_DIR)
	+ get_target_property(ANALYSIS_LIB AnalysisROOT_lib OUTPUT_NAME)
	+ set(ANALYSIS_PARAMETERS "")
	+ configure_file( ${tst_dir}/analysis_config.yml.in
	+ ${PROJECT_BINARY_DIR}/t/analysis_config_root.yml @ONLY )
	+ add_test(
	+ NAME t_analysis_root
	+ COMMAND $<TARGET_FILE:HEJ_main>
	+ ${PROJECT_BINARY_DIR}/t/analysis_config_root.yml
	+ ${tst_dir}/2j.lhe.gz
	+ )
	+endif()
	+
	# test importing scales (from examples/softestptScale)
	add_executable(test_scale_import ${tst_dir}/test_scale_import)
	target_link_libraries(test_scale_import HEJ)

	get_target_property(SCALE_PATH softestptScale_lib BINARY_DIR)
	get_target_property(SCALE_LIB softestptScale_lib OUTPUT_NAME)
	set(SCALE_NAME "softest_jet_pt")
	configure_file( ${tst_dir}/jet_config_with_import.yml.in
	${PROJECT_BINARY_DIR}/t/jet_config_with_import.yml @ONLY )

	add_test(
	NAME t_scale_import
	COMMAND test_scale_import ${PROJECT_BINARY_DIR}/t/jet_config_with_import.yml
	)

	# test scale arithmetic (e.g. 2*H_T/4)
	add_executable(test_scale_arithmetics ${tst_dir}/test_scale_arithmetics)
	target_link_libraries(test_scale_arithmetics HEJ hej_test)
	add_test(
	NAME t_scale_arithmetics
	COMMAND test_scale_arithmetics ${tst_dir}/jet_config.yml ${tst_dir}/2j.lhe.gz
	)

	# test "ParameterDescription"
	add_executable(test_descriptions ${tst_dir}/test_descriptions)
	target_link_libraries(test_descriptions HEJ hej_test)
	add_test(
	NAME t_descriptions
	COMMAND test_descriptions
	)

	# test "EventParameters*Weight"
	add_executable(test_parameters ${tst_dir}/test_parameters)
	target_link_libraries(test_parameters HEJ hej_test)
	add_test(
	NAME test_parameters
	COMMAND test_parameters
	)

	# test unweighting
	add_executable(test_unweighter ${tst_dir}/test_unweighter)
	target_link_libraries(test_unweighter HEJ hej_test)
	add_test(
	NAME test_unweighter
	COMMAND test_unweighter ${tst_dir}/4j.lhe.gz
	)

	# test colour generation
	add_executable(test_colours ${tst_dir}/test_colours)
	target_link_libraries(test_colours HEJ hej_test)
	add_test(
	NAME t_colour_flow
	COMMAND test_colours
	)

	# test matrix elements
	add_executable(test_ME_generic ${tst_dir}/test_ME_generic.cc)
	target_link_libraries(test_ME_generic HEJ hej_test)
	add_test(
	NAME t_ME_j
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml ${tst_ME_data_dir}/ME_jets_tree.dat ${tst_ME_data_dir}/PSP_jets.lhe.gz
	)
	add_test(
	NAME t_ME_j_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml ${tst_ME_data_dir}/ME_jets_tree_virt.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_tree.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	add_test(
	NAME t_ME_h_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml ${tst_ME_data_dir}/ME_h_mtinf_virt.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_tree.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_tree.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	endif()
	add_test(
	NAME t_ME_j_subl
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_pure.yml ${tst_ME_data_dir}/ME_jets_subl_tree.dat ${tst_ME_data_dir}/PSP_jets_subl.lhe.gz
	)
	add_test(
	NAME t_ME_j_subl_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_pure.yml ${tst_ME_data_dir}/ME_jets_subl_tree_virt.dat ${tst_ME_data_dir}/PSP_jets_subl.lhe.gz
	)
	add_test(
	NAME t_ME_j_subl_new
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_pure.yml ${tst_ME_data_dir}/ME_jets_subl_tree_new.dat ${tst_dir}/4j.lhe.gz
	)
	add_test(
	NAME t_ME_j_subl_new_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_pure.yml ${tst_ME_data_dir}/ME_jets_subl_tree_new_virt.dat ${tst_dir}/4j.lhe.gz
	)
	add_test(
	NAME t_ME_w_FKL
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_w_FKL_tree.dat ${tst_ME_data_dir}/PSP_w_FKL.lhe.gz
	)
	add_test(
	NAME t_ME_w_FKL_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_w_FKL_virt.dat ${tst_ME_data_dir}/PSP_w_FKL.lhe.gz
	)
	add_test(
	NAME t_ME_Wp
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_Wp.dat ${tst_ME_data_dir}/PSP_Wp.lhe.gz
	)
	add_test(
	NAME t_ME_Wp_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_Wp_virt.dat ${tst_ME_data_dir}/PSP_Wp.lhe.gz
	)
	add_test(
	NAME t_ME_Wm
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_Wm.dat ${tst_ME_data_dir}/PSP_Wm.lhe.gz
	)
	add_test(
	NAME t_ME_Wm_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_w_ME.yml ${tst_ME_data_dir}/ME_Wm_virt.dat ${tst_ME_data_dir}/PSP_Wm.lhe.gz
	)

	# test main executable
	file(COPY "${tst_dir}/jet_config.yml" DESTINATION "${PROJECT_BINARY_DIR}")
	set(test_config "${PROJECT_BINARY_DIR}/jet_config.yml")
	if(HighFive_FOUND)
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - tst.hdf5\n")
	endif()
	if(HepMC3_FOUND)
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - tst.hepmc\n")
	endif()
	if(HepMC_FOUND)
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - tst.hepmc2\n")
	endif()
	if(rivet_FOUND)
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config}\nanalysis:\n rivet: MC_XS\n output: tst\n")
	endif()
	set(test_cmd_main "$<TARGET_FILE:HEJ_main>\\\;${test_config}\\\;${tst_dir}/2j.lhe.gz")
	# check that HepMC3 output is correct
	if(HepMC3_FOUND)
	add_executable(check_hepmc ${tst_dir}/check_hepmc.cc)
	target_link_libraries(check_hepmc HEJ ${HEPMC3_LIBRARIES})
	target_include_directories(check_hepmc PRIVATE ${HEPMC3_INCLUDE_DIR})
	set(test_cmd_hepmc "$<TARGET_FILE:check_hepmc>\\\;tst.hepmc")
	else()
	set(test_cmd_hepmc "")
	endif()
	# check that LHEF output is correct
	add_executable(check_lhe ${tst_dir}/check_lhe.cc)
	target_link_libraries(check_lhe HEJ hej_test)
	set(test_cmd_lhe "$<TARGET_FILE:check_lhe>\\\;tst.lhe")
	# check that rivet interface is consistent with naive rivet
	if(rivet_FOUND)
	# this assumes "rivet" and "yodadiff" are found in PATH
	if(rivet_USE_HEPMC3)
	set(hepmc_file "tst.hepmc")
	else()
	set(hepmc_file "tst.hepmc2")
	endif()
	if(rivet_USE_HEPMC3 OR (rivet_VERSION VERSION_LESS 3))
	set(histo_exclude "")
	else()
	# rivet 3 with HepMC 2 is inconsistent in order of weights
	# -> interface != direct call (by permutation)
	# REQUIRES Yoda 1.7.5
	set(histo_exclude "-M\\\;\\\\d")
	endif()
	set(test_cmd_rivet "rivet\\\;-a\\\;MC_XS\\\;${hepmc_file}\\\;-o\\\;tst_direct.yoda\
	\;yodadiff\\\;${histo_exclude}\\\;tst.yoda\\\;tst_direct.yoda")
	else()
	set(test_cmd_rivet "")
	endif()
	# Run dependent tests in one command to ensure correct execution order
	# Note: The commands are concatenated with "\;" to escape CMake lists.
	# Thus arguments have to be escaped twice "\\\;".
	# e.g. "cmd1\;cmd2\\\;arg1\\\;arg2" is executed like "cmd1 && cmd2 arg1 arg2"
	add_test(
	NAME t_main
	COMMAND ${CMAKE_COMMAND}
	-DCMDS=${test_cmd_main}\;${test_cmd_hepmc}\;${test_cmd_lhe}\;${test_cmd_rivet}
	-P ${PROJECT_SOURCE_DIR}/cmake/run_multiple_tests.cmake
	)
	# check that Sherpas LHE input can be read
	add_executable(check_lhe_sherpa ${tst_dir}/check_lhe_sherpa.cc)
	target_link_libraries(check_lhe_sherpa HEJ hej_test)
	add_test(
	NAME t_sherpa_reader
	COMMAND check_lhe_sherpa ${tst_dir}/SherpaLHE.lhe 1.62624e+08
	)
	# check HDF5 reader & writer
	if(HighFive_FOUND)
	add_executable(test_hdf5 ${tst_dir}/test_hdf5.cc)
	target_link_libraries(test_hdf5 HEJ)
	add_test(
	NAME t_hdf5
	COMMAND test_hdf5 ${tst_dir}/Wm9-g4-repack.hdf5
	)
	add_executable(test_hdf5_write ${tst_dir}/test_hdf5_write.cc)
	target_link_libraries(test_hdf5_write HEJ)
	add_test(
	NAME t_hdf5_write
	COMMAND test_hdf5_write ${tst_dir}/Wm9-g4-repack.hdf5
	)
	endif()
	# check rivet interface
	if(RIVET_FOUND)
	add_executable(check_rivet ${tst_dir}/check_rivet.cc)
	target_link_libraries(check_rivet HEJ rivet::rivet)
	add_test(
	NAME t_rivet
	COMMAND check_rivet
	)
	endif()

	# test boson reconstruction
	add_executable(cmp_events ${tst_dir}/cmp_events.cc)
	target_link_libraries(cmp_events HEJ)
	add_test(
	NAME t_epnu_2j_noW
	COMMAND cmp_events ${tst_dir}/epnu2jLOFKL_unweight.lhe.tar.gz ${tst_dir}/epnu2jLOFKL_unweight_noW.lhe.gz
	)

	# test resummed result
	add_executable(check_res ${tst_dir}/check_res.cc)
	target_link_libraries(check_res HEJ hej_test)

	if(TEST_ALL) # deactivate long tests by default
	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_3j_unof
	COMMAND check_res ${tst_dir}/3j.lhe.gz 133399 4688.83 unof
	)
	add_test(
	NAME t_3j_unob
	COMMAND check_res ${tst_dir}/3j.lhe.gz 105247 3449.45 unob
	)
	add_test(
	NAME t_3j_splitf
	COMMAND check_res ${tst_dir}/3j.lhe.gz 97659.9 2748.65 splitf
	)
	add_test(
	NAME t_3j_splitb
	COMMAND check_res ${tst_dir}/3j.lhe.gz 107150 2799.8 splitb
	)
	add_test(
	NAME t_4j
	COMMAND check_res ${tst_dir}/4j.lhe.gz 603713 72822.6
	)
	add_test(
	NAME t_4j_qqxmid
	COMMAND check_res ${tst_dir}/4j.lhe.gz 21866.7 1716.96 qqxmid
	)
	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_unof
	COMMAND check_res ${tst_dir}/h_3j_uno.lhe.gz 0.0127362 0.000271555 unof
	)
	add_test(
	NAME t_h_3j_unob
	COMMAND check_res ${tst_dir}/h_3j_uno.lhe.gz 0.0130615 0.000224793 unob
	)
	add_test(
	NAME t_epnu_2j
	COMMAND check_res ${tst_dir}/epnu2jLOFKL_unweight.lhe.tar.gz 262.7 3
	)
	add_test(
	NAME t_MGepnu_3j
	COMMAND check_res ${tst_dir}/MGepnu3j_unweighted.lhe.gz 38.9512 1
	)
	add_test(
	NAME t_MGemnubar_3j
	COMMAND check_res ${tst_dir}/MGemnubar3j_unweighted.lhe.gz 24.1575 1
	)
	add_test(
	NAME t_MGepnu_3j_unof
	COMMAND check_res ${tst_dir}/MGepnu3j_unweighted.lhe.gz 9.63702 0.128355 unof
	)
	add_test(
	NAME t_MGepnu_3j_unob
	COMMAND check_res ${tst_dir}/MGepnu3j_unweighted.lhe.gz 9.70119 0.108436 unob
	)
	add_test(
	NAME t_MGepnu_3j_splitf
	COMMAND check_res ${tst_dir}/MGepnu3j_unweighted.lhe.gz 2.91995 0.0463182 splitf
	)
	add_test(
	NAME t_MGepnu_3j_splitb
	COMMAND check_res ${tst_dir}/MGepnu3j_unweighted.lhe.gz 3.40708 0.0550975 splitb
	)
	add_test(
	NAME t_MGepnu_4j
	COMMAND check_res ${tst_dir}/MGepnu4j_unweighted.lhe.gz 10.2542 0.135106
	)
	add_test(
	NAME t_MGemnubar_4j
	COMMAND check_res ${tst_dir}/MGemnubar4j_unweighted.lhe.gz 5.57909 0.0300496
	)
	add_test(
	NAME t_MGepnu_4j_qqxmid
	COMMAND check_res ${tst_dir}/MGepnu4j_unweighted.lhe.gz 0.732084 0.005 qqxmid
	)
	endif()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 23, 2:59 PM (5 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4476220
Default Alt Text: (25 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions