No OneTemporary
Actions

Size

31 KB

Subscribers

None

View Options

	diff --git a/t/CMakeLists.txt b/t/CMakeLists.txt
	index 73c49e4..c47bd7c 100644
	--- a/t/CMakeLists.txt
	+++ b/t/CMakeLists.txt
	@@ -1,658 +1,707 @@
	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 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 classify_ref
	COMMAND test_classify_ref ${tst_dir}/classify_ref ${tst_dir}/classify.lhe.gz
	)
	add_test(
	NAME classify_ref_4j
	COMMAND test_classify_ref ${tst_dir}/classify_ref_4j ${tst_dir}/4j.lhe.gz
	)
	add_test(
	NAME classify_ref_W4j
	COMMAND test_classify_ref
	${tst_dir}/classify_ref_W4j
	${tst_dir}/MGemnubar4j_unweighted.lhe.gz
	)
	add_test(
	NAME t_classify_ref_Z4j
	COMMAND test_classify_ref
	${tst_dir}/classify_ref_Z4j
	${tst_dir}/Z_4j.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 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 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 PhaseSpace
	COMMAND test_psp ${tst_dir}/psp_gen.lhe.gz
	)

	# test importing analyses
	file(COPY "${tst_dir}/analysis_config.yml" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
	set(test_config "${CMAKE_CURRENT_BINARY_DIR}/analysis_config.yml")

	get_target_property(ANALYSIS_PATH AnalysisTemplate_lib BINARY_DIR)
	get_target_property(ANALYSIS_LIB AnalysisTemplate_lib OUTPUT_NAME)
	set(ANALYSIS_PARAMETERS "")
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - plugin: ${ANALYSIS_PATH}/lib${ANALYSIS_LIB}.so\n ${ANALYSIS_PARAMETERS}\n")
	configure_file( ${tst_dir}/analysis_config_single.yml.in
	analysis_config_simple.yml @ONLY )
	add_test(
	NAME analysis_simple
	COMMAND $<TARGET_FILE:HEJ_main>
	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")
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - plugin: ${ANALYSIS_PATH}/lib${ANALYSIS_LIB}.so\n ${ANALYSIS_PARAMETERS}\n")
	configure_file( ${tst_dir}/analysis_config_single.yml.in
	analysis_config_print.yml @ONLY )
	add_test(
	NAME analysis_print
	COMMAND $<TARGET_FILE:HEJ_main>
	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 "")
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - plugin: ${ANALYSIS_PATH}/lib${ANALYSIS_LIB}.so\n ${ANALYSIS_PARAMETERS}\n")
	configure_file( ${tst_dir}/analysis_config_single.yml.in
	analysis_config_root.yml @ONLY )
	add_test(
	NAME analysis_root
	COMMAND $<TARGET_FILE:HEJ_main>
	analysis_config_root.yml
	${tst_dir}/2j.lhe.gz
	)
	endif()
	if(RIVET_FOUND)
	file(READ ${test_config} config)
	file(WRITE ${test_config} "${config} - rivet: MC_XS\n output: ana_rivet\n")
	endif()

	add_test(
	NAME analysis_all
	COMMAND $<TARGET_FILE:HEJ_main>
	${test_config}
	${tst_dir}/2j.lhe.gz
	)

	# test importing scales (from examples/softestptScale)
	add_executable(test_scale_import ${tst_dir}/test_scale_import.cc)
	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
	jet_config_with_import.yml @ONLY )

	add_test(
	NAME scale_import
	COMMAND test_scale_import jet_config_with_import.yml
	)

	# test scale arithmetic (e.g. 2*H_T/4)
	add_executable(test_scale_arithmetics ${tst_dir}/test_scale_arithmetics.cc)
	target_link_libraries(test_scale_arithmetics HEJ hej_test)
	add_test(
	NAME 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.cc)
	target_link_libraries(test_descriptions HEJ hej_test)
	add_test(
	NAME descriptions
	COMMAND test_descriptions
	)

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

	# test Particle IDs
	add_executable(test_pid ${tst_dir}/test_pid.cc)
	target_link_libraries(test_pid HEJ hej_test)
	add_test(
	NAME pid
	COMMAND test_pid
	)

	# test EW constants
	add_executable(test_EWConstants ${tst_dir}/test_EWConstants.cc)
	target_link_libraries(test_EWConstants HEJ hej_test)
	add_test(
	NAME EWConstants
	COMMAND test_EWConstants
	)

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

	# test colour generation
	add_executable(test_colours ${tst_dir}/test_colours.cc)
	target_link_libraries(test_colours HEJ hej_test)
	add_test(
	NAME colour_flow
	COMMAND test_colours
	)
	add_executable(test_colours2 ${tst_dir}/test_colours2.cc)
	target_link_libraries(test_colours2 HEJ hej_test)
	add_test(
	NAME colour_flow2
	COMMAND test_colours2
	)

	# 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 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 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 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 ME_h_subl
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml
	${tst_ME_data_dir}/ME_h_subl_mtinf_tree.dat ${tst_ME_data_dir}/PSP_h_subl.lhe.gz
	)
	add_test(
	NAME ME_hj
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml
	${tst_ME_data_dir}/ME_hj_mtinf_tree.dat ${tst_ME_data_dir}/PSP_hj.lhe.gz
	)
	add_test(
	NAME 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
	)
	add_test(
	NAME ME_hj_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtinf.yml
	${tst_ME_data_dir}/ME_hj_mtinf_virt.dat ${tst_ME_data_dir}/PSP_hj.lhe.gz
	)
	if(QCDloop_FOUND)
	add_test(
	NAME 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 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
	)
	add_test(
	NAME ME_h_subl_mtmb
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtmb.yml
	${tst_ME_data_dir}/ME_h_subl_mtmb_tree.dat ${tst_ME_data_dir}/PSP_h_subl.lhe.gz
	)
	add_test(
	NAME ME_hj_mt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mt.yml
	${tst_ME_data_dir}/ME_hj_mt_tree.dat ${tst_ME_data_dir}/PSP_hj.lhe.gz
	)
	add_test(
	NAME ME_hj_mtmb
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_mtmb.yml
	${tst_ME_data_dir}/ME_hj_mtmb_tree.dat ${tst_ME_data_dir}/PSP_hj.lhe.gz
	)
	endif()
	add_test(
	NAME 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 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 ME_j_subl_4j
	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 ME_j_subl_4j_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 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 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 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 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 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 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
	)
	add_test(
	NAME ME_Z
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_Z_ME.yml
	${tst_ME_data_dir}/ME_Z.dat ${tst_ME_data_dir}/PSP_Z.lhe.gz
	)
	add_test(
	NAME ME_Z_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_Z_ME.yml
	${tst_ME_data_dir}/ME_Z_virt.dat ${tst_ME_data_dir}/PSP_Z.lhe.gz
	)
	add_test(
	NAME ME_Z_uno
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_Z_ME.yml
	${tst_ME_data_dir}/ME_Z_uno_tree.dat ${tst_ME_data_dir}/PSP_Z_uno.lhe.gz
	)
	add_test(
	NAME ME_Z_uno_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_Z_ME.yml
	${tst_ME_data_dir}/ME_Z_uno_virt.dat ${tst_ME_data_dir}/PSP_Z_uno.lhe.gz
	)
	add_test(
	NAME ME_WpWp
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
	${tst_ME_data_dir}/ME_WpWp.dat ${tst_ME_data_dir}/PSP_WpWp.lhe.gz
	)
	add_test(
	NAME ME_WpWp_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
	${tst_ME_data_dir}/ME_WpWp_virt.dat ${tst_ME_data_dir}/PSP_WpWp.lhe.gz
	)
	add_test(
	NAME ME_WmWm
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
	${tst_ME_data_dir}/ME_WmWm.dat ${tst_ME_data_dir}/PSP_WmWm.lhe.gz
	)
	add_test(
	NAME ME_WmWm_virt
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
	${tst_ME_data_dir}/ME_WmWm_virt.dat ${tst_ME_data_dir}/PSP_WmWm.lhe.gz
	)
	# HEJ@NLO Virtuals
	add_test(
	NAME ME_WmWm_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_WmWm_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_WmWm.lhe.gz
	)
	add_test(
	NAME ME_WpWp_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_WpWp_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_WpWp.lhe.gz
	)
	add_test(
	NAME ME_Wp_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_wzhpure_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_Wp_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_Wp.lhe.gz
	)
	add_test(
	NAME ME_Wm_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_wzhpure_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_Wm_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_Wm.lhe.gz
	)
	add_test(
	NAME ME_Z_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_wzhpure_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_Z_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_Z.lhe.gz
	)
	add_test(
	NAME ME_jets_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_wzhpure_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_jets_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_jets.lhe.gz
	)
	add_test(
	NAME ME_h_hejnlo
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_wzhpure_ME_hejnlo.yml
	${tst_ME_data_dir}/ME_h_virt_hejnlo.dat ${tst_ME_data_dir}/PSP_h.lhe.gz
	)
	add_test(
	NAME ME_j_log_corr
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_log_corr.yml
	${tst_ME_data_dir}/ME_jets_log_corr.dat ${tst_ME_data_dir}/PSP_jets.lhe.gz
	)
	add_test(
	NAME ME_j_lambda
	COMMAND test_ME_generic ${tst_ME_data_dir}/config_lambda.yml
	${tst_ME_data_dir}/ME_jets_lambda.dat ${tst_ME_data_dir}/PSP_jets.lhe.gz
	)
	# test main executable
	file(COPY "${tst_dir}/jet_config.yml" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
	set(test_config "${CMAKE_CURRENT_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()
	+if(HepMC_FOUND)
	+ add_executable(check_hepmc2 ${tst_dir}/check_hepmc2.cc)
	+ target_link_libraries(check_hepmc2 HEJ ${HepMC_LIBRARY})
	+ target_include_directories(check_hepmc2 PRIVATE ${HepMC_INCLUDE_DIR})
	+endif()
	+if(HighFive_FOUND)
	+ add_executable(check_highfive ${tst_dir}/check_highfive.cc)
	+ target_link_libraries(check_highfive HEJ HighFive)
	+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 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
	)
	add_test(
	NAME main_example
	COMMAND $<TARGET_FILE:HEJ_main> ${PROJECT_SOURCE_DIR}/config.yml ${tst_dir}/h_3j.lhe.gz
	)
	# 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 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 hdf5_read
	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 hej_test)
	add_test(
	NAME hdf5_write
	COMMAND test_hdf5_write ${tst_dir}/Wm9-g4-repack.hdf5 output.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 rivet
	COMMAND check_rivet
	)
	find_program (BASH_PROGRAM bash)
	if (BASH_PROGRAM)
	add_test(
	NAME fifo_test
	COMMAND ${BASH_PROGRAM} ${tst_dir}/fifotest.sh ${tst_dir}/2j.lhe.gz $<TARGET_FILE:HEJ_main>)
	endif (BASH_PROGRAM)
	endif()

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

	# test repairing slightly off-shell momenta
	add_executable(repair_off-shell ${tst_dir}/repair_off-shell.cc)
	target_link_libraries(repair_off-shell HEJ)
	add_test(
	NAME repair_off-shell
	COMMAND repair_off-shell ${tst_dir}/off-shell.lhe.gz
	)

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

	# Setup yaml files for check res tests
	set(CENTRALSCALE 91.188)
	set(LOWPT_OPTION true)
	configure_file( ${tst_dir}/config_check_res.yml.in
	config_lowpt.yml @ONLY )
	set(LOWPT_OPTION false)
	configure_file( ${tst_dir}/config_check_res.yml.in
	config_default.yml @ONLY )
	set(CENTRALSCALE 125.)
	configure_file( ${tst_dir}/config_check_res.yml.in
	config_higgs.yml @ONLY )

	-
	-
	-
	-
	+# Check first event of HEJ output
	+set(xstest_cmd_lhef "$<TARGET_FILE:HEJ_main>\\\;${test_config}\\\;${tst_dir}/h_1j.lhe.gz")
	+set(xstest_cmd_lhef_check "$<TARGET_FILE:check_lhe>\\\;tst.lhe\\\;28024.1")
	+add_test(
	+ NAME test_lhe_xs
	+ COMMAND ${CMAKE_COMMAND} -DCMDS=${xstest_cmd_lhef}\;${xstest_cmd_lhef_check}
	+ -P ${PROJECT_SOURCE_DIR}/cmake/run_multiple_tests.cmake
	+)
	+set_tests_properties(test_lhe_xs PROPERTIES DEPENDS "main")
	+if(HepMC3_FOUND)
	+ set(xstest_cmd_hepmc "$<TARGET_FILE:HEJ_main>\\\;${test_config}\\\;${tst_dir}/h_1j.lhe.gz")
	+ set(xstest_cmd_hepmc_check "$<TARGET_FILE:check_hepmc>\\\;tst.hepmc\\\;28024.1")
	+ add_test(
	+ NAME test_hepmc_xs
	+ COMMAND ${CMAKE_COMMAND} -DCMDS=${xstest_cmd_hepmc}\;${xstest_cmd_hepmc_check}
	+ -P ${PROJECT_SOURCE_DIR}/cmake/run_multiple_tests.cmake
	+ )
	+ set_tests_properties(test_hepmc_xs PROPERTIES DEPENDS "main")
	+ set_tests_properties(test_hepmc_xs PROPERTIES RESOURCE_LOCK xstests)
	+endif()
	+if(HepMC_FOUND)
	+ set(xstest_cmd_hepmc2 "$<TARGET_FILE:HEJ_main>\\\;${test_config}\\\;${tst_dir}/h_1j.lhe.gz")
	+ set(xstest_cmd_hepmc2_check "$<TARGET_FILE:check_hepmc2>\\\;tst.hepmc2\\\;28024.1")
	+ add_test(
	+ NAME test_hepmc2_xs
	+ COMMAND ${CMAKE_COMMAND} -DCMDS=${xstest_cmd_hepmc2}\;${xstest_cmd_hepmc2_check}
	+ -P ${PROJECT_SOURCE_DIR}/cmake/run_multiple_tests.cmake
	+ )
	+ set_tests_properties(test_hepmc2_xs PROPERTIES DEPENDS "main")
	+ set_tests_properties(test_hepmc2_xs PROPERTIES RESOURCE_LOCK xstests)
	+endif()
	+if(HighFive_FOUND)
	+ set(xstest_cmd_highfive "$<TARGET_FILE:HEJ_main>\\\;${test_config}\\\;${tst_dir}/h_1j.lhe.gz")
	+ set(xstest_cmd_highfive_check "$<TARGET_FILE:check_highfive>\\\;tst.hdf5\\\;28024.1")
	+ add_test(
	+ NAME xstest_highfive
	+ COMMAND ${CMAKE_COMMAND} -DCMDS=${xstest_cmd_highfive}\;${xstest_cmd_highfive_check}
	+ -P ${PROJECT_SOURCE_DIR}/cmake/run_multiple_tests.cmake
	+ )
	+ set_tests_properties(xstest_highfive PROPERTIES DEPENDS "main;test_lhe_xs;")
	+ set_tests_properties(xstest_highfive PROPERTIES RESOURCE_LOCK xstests)
	+endif()
	+set_tests_properties(main test_lhe_xs
	+ PROPERTIES RESOURCE_LOCK xstests
	+)
	add_test(
	NAME xs_h_1j
	COMMAND check_res config_higgs.yml ${tst_dir}/h_1j.lhe.gz 4.97087 0.0302519
	)
	add_test(
	NAME xs_2j
	COMMAND check_res config_default.yml ${tst_dir}/2j.lhe.gz 3.49391e+07 419684
	)
	add_test(
	NAME xs_3j
	COMMAND check_res config_default.yml ${tst_dir}/3j.lhe.gz 2.37902e+06 25746.6
	)
	add_test(
	NAME xs_3j_unof
	COMMAND check_res config_default.yml ${tst_dir}/3j.lhe.gz 133399 4688.83 unof
	)
	add_test(
	NAME xs_3j_unob
	COMMAND check_res config_default.yml ${tst_dir}/3j.lhe.gz 105247 3449.45 unob
	)
	add_test(
	NAME xs_3j_splitf
	COMMAND check_res config_default.yml ${tst_dir}/3j.lhe.gz 97659.9 2748.65 splitf
	)
	add_test(
	NAME xs_3j_splitb
	COMMAND check_res config_default.yml ${tst_dir}/3j.lhe.gz 107150 2799.8 splitb
	)
	add_test(
	NAME xs_4j
	COMMAND check_res config_default.yml ${tst_dir}/4j.lhe.gz 603713 72822.6
	)
	add_test(
	NAME xs_4j_qqbar_mid
	COMMAND check_res config_default.yml ${tst_dir}/4j.lhe.gz 21866.7 1716.96 qqbar_mid
	)
	add_test(
	NAME xs_h_3j
	COMMAND check_res config_higgs.yml ${tst_dir}/h_3j.lhe.gz 0.667678 0.0126859
	)
	add_test(
	NAME xs_h_3j_unof
	COMMAND check_res config_higgs.yml ${tst_dir}/h_3j_uno.lhe.gz 0.0110041 0.000274214 unof
	)
	add_test(
	NAME xs_h_3j_unob
	COMMAND check_res config_higgs.yml ${tst_dir}/h_3j_uno.lhe.gz 0.0116516 0.000376737 unob
	)
	add_test(
	NAME xs_epnu_3j
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted.lhe.gz 84394.7 3770.35
	)
	add_test(
	NAME xs_emnubar_3j
	COMMAND check_res config_default.yml ${tst_dir}/MGemnubar3j_unweighted.lhe.gz 53489.1 977.234
	)
	add_test(
	NAME xs_epnu_4j
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu4j_unweighted.lhe.gz 19616.2 774.336
	)
	add_test(
	NAME xs_emnubar_4j
	COMMAND check_res config_default.yml ${tst_dir}/MGemnubar4j_unweighted.lhe.gz 10169.6 248.741
	)
	add_test(
	NAME xs_2j_lowpt
	COMMAND check_res config_lowpt.yml ${tst_dir}/2j.lhe.gz 45890.2 5325.62
	)
	if(TEST_ALL) # deactivate long tests by default
	add_test(
	NAME xs_h_1j_long
	COMMAND check_res config_higgs.yml ${tst_dir}/h_1j_large.lhe.gz 4.70112 0.00415353
	)
	add_test(
	NAME xs_epnu_2j
	COMMAND check_res config_default.yml ${tst_dir}/epnu2jLOFKL_unweight.lhe.tar.gz 262.7 3
	)
	add_test(
	NAME xs_epnu_3j_long
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted_large.lhe.gz 38.9512 1
	)
	add_test(
	NAME xs_emnubar_3j_long
	COMMAND check_res config_default.yml ${tst_dir}/MGemnubar3j_unweighted_large.lhe.gz 24.1575 1
	)
	add_test(
	NAME xs_epnu_3j_unof
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted_large.lhe.gz 9.63702 0.128355 unof
	)
	add_test(
	NAME xs_epnu_3j_unob
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted_large.lhe.gz 9.70119 0.108436 unob
	)
	add_test(
	NAME xs_epnu_3j_splitf
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted_large.lhe.gz 2.91995 0.0463182 splitf
	)
	add_test(
	NAME xs_epnu_3j_splitb
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu3j_unweighted_large.lhe.gz 3.40708 0.0550975 splitb
	)
	add_test(
	NAME xs_epnu_4j_long
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu4j_unweighted_large.lhe.gz 10.2542 0.135106
	)
	add_test(
	NAME xs_emnubar_4j_long
	COMMAND check_res config_default.yml ${tst_dir}/MGemnubar4j_unweighted_large.lhe.gz 5.73282 0.0583738
	)
	add_test(
	NAME xs_epnu_4j_qqbar_mid
	COMMAND check_res config_default.yml ${tst_dir}/MGepnu4j_unweighted_large.lhe.gz 0.802603 0.0126908 qqbar_mid
	)
	endif()
	diff --git a/t/check_hepmc.cc b/t/check_hepmc.cc
	index 367815a..3e60a35 100644
	--- a/t/check_hepmc.cc
	+++ b/t/check_hepmc.cc
	@@ -1,28 +1,44 @@
	/**
	* \authors The HEJ collaboration (see AUTHORS for details)
	- * \date 2019-2020
	+ * \date 2019-2023
	* \copyright GPLv2 or later
	*/
	#include <cstdlib>
	#include <iostream>

	#include "HepMC3/GenEvent.h"
	#include "HepMC3/ReaderAscii.h"
	+#include "HepMC3/Print.h"

	#include "HEJ/exceptions.hh"

	int main(int argn, char** argv) {
	- if(argn != 2){
	- std::cerr << "Usage: check_hepmc hepmc_file\n";
	+ constexpr double EP = 1e-3;
	+
	+ if(argn != 2 && argn != 3){
	+ std::cerr << "Usage: check_hepmc hepmc_file [XS test value]\n";
	return EXIT_FAILURE;
	}

	HepMC3::ReaderAscii input{argv[1]};
	if(input.failed()) throw std::runtime_error{"failed to open HepMC file"};
	+ HepMC3::GenEvent ev{};
	+ std::shared_ptr<HepMC3::GenCrossSection> cs;
	while(true){
	- HepMC3::GenEvent ev{};
	if ( !input.read_event(ev) \|\| ev.event_number() == 0 ) break;
	if(input.failed()) throw std::runtime_error{"failed to read HepMC event"};
	+ cs = ev.attribute<HepMC3::GenCrossSection>("GenCrossSection");
	+ }
	+ const double xs = cs->xsec();
	+
	+ if (argn == 3){
	+ const double xstest = std::stod(argv[2]);
	+ if(std::abs(xs-xstest) > EP*xs){
	+ std::cerr << "Total XS deviates substantially from ref value: "
	+ << xs << " vs " << xstest << "\n";
	+ return EXIT_FAILURE;
	+ }
	}
	+
	return EXIT_SUCCESS;
	}
	diff --git a/t/check_hepmc2.cc b/t/check_hepmc2.cc
	new file mode 100644
	index 0000000..0de5129
	--- /dev/null
	+++ b/t/check_hepmc2.cc
	@@ -0,0 +1,41 @@
	+/**
	+ * \authors The HEJ collaboration (see AUTHORS for details)
	+ * \date 2019-2023
	+ * \copyright GPLv2 or later
	+ */
	+#include <cstdlib>
	+#include <iostream>
	+#include <fstream>
	+
	+#include <boost/algorithm/string.hpp>
	+
	+int main(int argn, char** argv) {
	+ constexpr double EP = 1e-3;
	+
	+ if(argn != 3){
	+ std::cerr << "Usage: check_hepmc2 hepmc2_file XS_test_value\n";
	+ return EXIT_FAILURE;
	+ }
	+ const double xstest = std::stod(argv[2]);
	+ double xs = 0;
	+
	+ //Doing it manually as that is basically what hepmc2 does anyway!
	+ //https://gitlab.cern.ch/hepmc/HepMC/-/blob/master/src/GenCrossSection.cc
	+ std::ifstream istr( argv[1] );
	+
	+ std::string line;
	+ std::vector<std::string> vals;
	+
	+ while (std::getline(istr, line)) {
	+ if (line.find("C ") == std::string::npos)
	+ continue;
	+ boost::algorithm::split(vals, line, boost::is_any_of(" "));
	+ xs = std::stod(vals[1]);
	+ }
	+ if(std::abs(xs-xstest) > EP*xs){
	+ std::cerr << "Total XS deviates substantially from ref value: "
	+ << xs << " vs " << xstest << "\n";
	+ return EXIT_FAILURE;
	+ }
	+ return EXIT_SUCCESS;
	+}
	diff --git a/t/check_highfive.cc b/t/check_highfive.cc
	new file mode 100644
	index 0000000..b58a79b
	--- /dev/null
	+++ b/t/check_highfive.cc
	@@ -0,0 +1,39 @@
	+/**
	+ * \authors The HEJ collaboration (see AUTHORS for details)
	+ * \date 2019-2023
	+ * \copyright GPLv2 or later
	+ */
	+#include <cstdlib>
	+#include <iostream>
	+
	+#include <highfive/H5File.hpp>
	+
	+#include "HEJ/exceptions.hh"
	+
	+using namespace HighFive;
	+
	+int main(int argn, char** argv) {
	+ constexpr double EP = 1e-3;
	+
	+ if(argn != 3){
	+ std::cerr << "Usage: check_highfive hdf5_file XS_test_value\n";
	+ return EXIT_FAILURE;
	+ }
	+ const double xstest = std::stod(argv[2]);
	+ File file(argv[1], File::ReadOnly);
	+ auto dataset = file.getDataSet("procInfo/xSection");
	+ std::vector<double> result;
	+ // hdf data in form
	+ // { 0, 1, 2, 3,...}
	+ // {fkl, uno, qqbar, non-resummable,...}
	+ dataset.select({0}).read(result);
	+ double xs = result[0];
	+ dataset.select({3}).read(result);
	+ xs += result[0];
	+ if(std::abs(xs-xstest) > EP*xs){
	+ std::cerr << "Total XS deviates substantially from ref value: "
	+ << xs << " vs " << xstest << "\n";
	+ return EXIT_FAILURE;
	+ }
	+ return EXIT_SUCCESS;
	+}
	diff --git a/t/check_lhe.cc b/t/check_lhe.cc
	index 1c073f4..b7a79a8 100644
	--- a/t/check_lhe.cc
	+++ b/t/check_lhe.cc
	@@ -1,74 +1,86 @@
	/**
	* \authors The HEJ collaboration (see AUTHORS for details)
	- * \date 2019-2020
	+ * \date 2019-2023
	* \copyright GPLv2 or later
	*/
	#include "hej_test.hh"

	#include <cstdlib>
	#include <iostream>
	#include <unordered_map>

	#include "LHEF/LHEF.h"

	#include "fastjet/JetDefinition.hh"

	#include "HEJ/Event.hh"
	#include "HEJ/event_types.hh"
	#include "HEJ/EventReader.hh"

	namespace {
	constexpr double EP = 1e-3;
	const fastjet::JetDefinition JET_DEF{fastjet::kt_algorithm, 0.4};
	constexpr double MIN_JET_PT = 30;
	}


	int main(int argn, char** argv) {
	- if(argn != 2){
	- std::cerr << "Usage: " << argv[0] << " lhe_file\n";
	+ if(argn != 2 && argn != 3){
	+ std::cerr << "Usage: " << argv[0] << " lhe_file [XS test value]\n";
	return EXIT_FAILURE;
	}

	auto reader{ HEJ::make_reader(argv[1]) };

	// version should be overwritten
	ASSERT(reader->heprup().version==LHEF::HEPRUP().version);

	std::unordered_map<int, double> xsec_ref;
	for(int i=0; i < reader->heprup().NPRUP; ++i)
	xsec_ref[reader->heprup().LPRUP[i]] = 0.;

	while(reader->read_event()){
	auto const & hepeup = reader->hepeup();
	ASSERT(hepeup.NUP > 2); // at least 3 particles (2 in + 1 out)
	// first incoming has positive pz
	ASSERT(hepeup.PUP[0][2] > hepeup.PUP[1][2]);
	// test that we can trasform IDPRUP to event type
	(void) name(static_cast<HEJ::event_type::EventType>(hepeup.IDPRUP));
	xsec_ref[hepeup.IDPRUP] += hepeup.weight();
	// test that a HEJ event can be transformed back to the original HEPEUP
	auto hej_event = HEJ::Event::EventData(hepeup).cluster(JET_DEF, MIN_JET_PT);
	// there are two different weight infos, which should be the same
	ASSERT(hej_event.central().weight == hepeup.weight());
	ASSERT(hej_event.central().weight == hepeup.XWGTUP);
	// reader->heprup() is const, we can't use it to create a hepeup
	auto cp_heprup = reader->heprup();
	auto new_event = HEJ::to_HEPEUP(hej_event, &cp_heprup);
	ASSERT_PROPERTY(new_event, hepeup, weight());
	ASSERT_PROPERTY(new_event, hepeup, XWGTUP);
	ASSERT_PROPERTY(new_event, hepeup, SCALUP);
	ASSERT_PROPERTY(new_event, hepeup, NUP);
	}
	-
	+ double xstotal = 0;
	for(std::size_t i = 0; i < xsec_ref.size(); ++i){
	+ std::cout << "[+]" << xsec_ref.size() << std::endl;
	double const ref = xsec_ref[reader->heprup().LPRUP[i]];
	double const calc = reader->heprup().XSECUP[i];
	+ xstotal += calc;
	std::cout << ref << '\t' << calc << '\n';
	if(std::abs(calc-ref) > EP*calc){
	std::cerr << "Cross sections deviate substantially";
	return EXIT_FAILURE;
	}
	}
	+ if (argn == 3){
	+ const double xstest = std::stod(argv[2]);
	+ if(std::abs(xstotal-xstest) > EP*xstotal){
	+ std::cerr << "Total XS deviates substantially from ref value: "
	+ << xstotal << " vs " << xstest << "\n";
	+ return EXIT_FAILURE;
	+ }
	+ }
	+
	+
	return EXIT_SUCCESS;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 23, 2:46 PM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4486700
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions