Page MenuHomeHEPForge
Files F8724524

No OneTemporary
Actions

View Options

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ca963fb..0873c4a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,255 +1,261 @@
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.3 LANGUAGES C CXX)
# Set a default build type if none was specified
set(default_build_type "Release")
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_PATH})
find_package(clhep 2.3 REQUIRED)
include_directories(${CLHEP_INCLUDE_PATH})
find_package(lhapdf REQUIRED)
include_directories(${lhapdf_INCLUDE_PATH})
## 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)
include_directories(${YAML_CPP_INCLUDE_DIR})
find_package(HepMC 2)
if(${HepMC_FOUND})
message (STATUS "HepMC installation found: ${HepMC_INCLUDE_DIRS}")
set(
CMAKE_CXX_FLAGS
"${CMAKE_CXX_FLAGS} -DHEJ_BUILD_WITH_HepMC_VERSION=${HepMC_VERSION_MAJOR}"
)
include_directories(${HepMC_INCLUDE_DIRS})
find_package(rivet)
if(${rivet_FOUND})
include_directories(${rivet_INCLUDE_PATH})
set(
CMAKE_CXX_FLAGS
"${CMAKE_CXX_FLAGS} -DHEJ_BUILD_WITH_RIVET"
)
endif()
endif()
find_package(QCDloop 2)
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_colour_flow ${tst_dir}/test_colour_flow)
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_colour_flow 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 t_colour_flow
+ COMMAND test_colour_flow
+ )
diff --git a/t/test_colour_flow.cc b/t/test_colour_flow.cc
new file mode 100644
index 0000000..e76cd1f
--- /dev/null
+++ b/t/test_colour_flow.cc
@@ -0,0 +1,205 @@
+#include <stdexcept>
+#include <utility>
+
+#include "HEJ/Event.hh"
+#include "HEJ/RNG.hh"
+
+/// biased RNG to connect always to colour
+class dum_rnd: public HEJ::DefaultRNG {
+public:
+ dum_rnd() = default;
+ double flat() override {
+ return 0.;
+ };
+};
+
+void dump_event(HEJ::UnclusteredEvent const & ev){
+ for(auto const & in: ev.incoming){
+ std::cerr << "in type=" << in.type
+ << ", colour={" << (*in.colour).first
+ << ", " << (*in.colour).second << "}\n";
+ }
+ for(auto const & out: ev.outgoing){
+ std::cerr << "out type=" << out.type << ", colour={";
+ if(out.colour)
+ std::cerr << (*out.colour).first << ", " << (*out.colour).second;
+ else
+ std::cerr << "non, non";
+ std::cerr << "}\n";
+ }
+}
+
+/// true if colour is allowed for particle
+bool correct_colour(HEJ::Particle const & part){
+ if(HEJ::is_AWZH_boson(part) && !part.colour) return true;
+ if(!part.colour) return false;
+ int const colour = part.colour->first;
+ int const anti_colour = part.colour->second;
+ if(part.type == HEJ::ParticleID::gluon)
+ return colour != anti_colour && colour > 0 && anti_colour > 0;
+ if(HEJ::is_quark(part))
+ return anti_colour == 0 && colour > 0;
+ return colour == 0 && anti_colour > 0;
+}
+
+bool correct_colour(HEJ::UnclusteredEvent const & ev){
+ for(auto const & part: ev.incoming){
+ if(!correct_colour(part))
+ return false;
+ }
+ for(auto const & part: ev.outgoing){
+ if(!correct_colour(part))
+ return false;
+ }
+ return true;
+}
+
+bool match_expected(
+ HEJ::UnclusteredEvent const & ev,
+ std::vector<HEJ::Colour> const & expected
+){
+ assert(ev.outgoing.size()+2==expected.size());
+ for(size_t i=0; i<ev.incoming.size(); ++i){
+ assert(ev.incoming[i].colour);
+ if( *ev.incoming[i].colour != expected[i])
+ return false;
+ }
+ for(size_t i=2; i<ev.outgoing.size()+2; ++i){
+ if( ev.outgoing[i-2].colour ){
+ if( *ev.outgoing[i-2].colour != expected[i] )
+ return false;
+ } else if( expected[i].first != 0 || expected[i].second != 0)
+ return false;
+ }
+ return true;
+}
+
+void check_event(
+ HEJ::UnclusteredEvent ev, std::vector<HEJ::Colour> const & expected_colours
+){
+ dum_rnd rng;
+ ev.generate_colour_flow(rng);
+ if(!correct_colour(ev)){
+ std::cerr << "Found illegal colours for event\n";
+ dump_event(ev);
+ throw std::invalid_argument("Illegal colour set");
+ }
+ if(!match_expected(ev, expected_colours)){
+ std::cerr << "Colours didn't match expectation. Found\n";
+ dump_event(ev);
+ std::cerr << "but expected\n";
+ for(auto const & col: expected_colours){
+ std::cerr << "colour={" << col.first << ", " << col.second << "}\n";
+ }
+ throw std::logic_error("Colours did not match expectation");
+ }
+}
+
+int main() {
+ HEJ::UnclusteredEvent ev;
+ std::vector<HEJ::Colour> expected_colours(7);
+
+ /// pure gluon
+ ev.incoming[0] = { HEJ::ParticleID::gluon, { 0, 0,-427, 427}, {}};
+ ev.incoming[1] = { HEJ::ParticleID::gluon, { 0, 0, 851, 851}, {}};
+ ev.outgoing.push_back({ HEJ::ParticleID::gluon, { 196, 124, -82, 246}, {}});
+ ev.outgoing.push_back({ HEJ::ParticleID::gluon, {-167,-184, 16, 249}, {}});
+ ev.outgoing.push_back({ HEJ::ParticleID::higgs, { 197, 180, 168, 339}, {}});
+ ev.outgoing.push_back({ HEJ::ParticleID::gluon, {-190, -57, 126, 235}, {}});
+ ev.outgoing.push_back({ HEJ::ParticleID::gluon, { -36, -63, 196, 209}, {}});
+
+ expected_colours[0] = {502, 501};
+ expected_colours[1] = {509, 502};
+ expected_colours[2] = {503, 501};
+ expected_colours[3] = {505, 503};
+ expected_colours[4] = { 0, 0};
+ expected_colours[5] = {507, 505};
+ expected_colours[6] = {509, 507};
+ check_event(ev, expected_colours);
+
+ /// last g to Qx (=> gQx -> g ... Qx)
+ ev.incoming[1].type = HEJ::ParticleID::d_bar;
+ ev.outgoing[4].type = HEJ::ParticleID::d_bar;
+ // => only end changes
+ expected_colours[1].first = 0;
+ expected_colours[6].first = 0;
+ check_event(ev, expected_colours);
+
+ {
+ // don't overwrite
+ auto new_expected = expected_colours;
+ auto new_ev = ev;
+ /// uno forward (=> gQx -> g ... Qx g)
+ std::swap(new_ev.outgoing[3].type, new_ev.outgoing[4].type);
+ // => uno quarks eats colour and gluon connects to anti-colour
+ new_expected[5] = {0, expected_colours[3].first};
+ new_expected[6] = {expected_colours[0].first, expected_colours[0].first+2};
+ new_expected[1].second += 2; // one more anti-colour in line
+ check_event(new_ev, new_expected);
+ }
+
+ /// swap Qx <-> Q (=> gQx -> g ... Qx)
+ ev.incoming[1].type = HEJ::ParticleID::d;
+ ev.outgoing[4].type = HEJ::ParticleID::d;
+ // => swap: colour<->anti && inital<->final
+ std::swap(expected_colours[1], expected_colours[6]);
+ std::swap(expected_colours[1].first, expected_colours[1].second);
+ std::swap(expected_colours[6].first, expected_colours[6].second);
+ check_event(ev, expected_colours);
+
+ /// first g to q (=> qxQ -> qx ... Q)
+ ev.incoming[0].type = HEJ::ParticleID::u_bar;
+ ev.outgoing[0].type = HEJ::ParticleID::u_bar;
+ expected_colours[0] = { 0, 501};
+ // => shift anti-colour index one up
+ expected_colours[1].first -= 2;
+ expected_colours[5] = expected_colours[3];
+ expected_colours[3] = expected_colours[2];
+ expected_colours[2] = { 0, 502};
+ check_event(ev, expected_colours);
+
+ {
+ // don't overwrite
+ auto new_expected = expected_colours;
+ auto new_ev = ev;
+ /// uno backward (=> qxQ -> g qx ... Q)
+ std::swap(new_ev.outgoing[0].type, new_ev.outgoing[1].type);
+ // => uno gluon connects to quark colour
+ new_expected[3] = expected_colours[2];
+ new_expected[2] = {expected_colours[0].second+2, expected_colours[0].second};
+ check_event(new_ev, new_expected);
+
+ /// swap qx <-> q (=> qQ -> g q ... Q)
+ new_ev.incoming[0].type = HEJ::ParticleID::u;
+ new_ev.outgoing[1].type = HEJ::ParticleID::u;
+ // => swap: colour<->anti && inital<->final
+ std::swap(new_expected[0], new_expected[3]);
+ std::swap(new_expected[0].first, new_expected[0].second);
+ std::swap(new_expected[3].first, new_expected[3].second);
+ // => & connect first gluon with remaining anti-colour
+ new_expected[2] = {new_expected[0].first, new_expected[0].first+2};
+ // shift colour line one down
+ new_expected[1].first-=2;
+ new_expected[5].first-=2;
+ new_expected[5].second-=2;
+ // shift anti-colour line one up
+ new_expected[6].first+=2;
+ check_event(new_ev, new_expected);
+ }
+
+ {
+ // don't overwrite
+ auto new_expected = expected_colours;
+ auto new_ev = ev;
+ /// uno forward (=> qxQ -> qx ... Q g)
+ std::swap(new_ev.outgoing[3].type, new_ev.outgoing[4].type);
+ // => uno gluon connects to remaining colour
+ new_expected[5] = expected_colours[6];
+ new_expected[6] = {expected_colours[3].first+2, expected_colours[3].first};
+ check_event(new_ev, new_expected);
+ }
+
+ /// @TODO add qqx test when implemented (it should work)
+
+ return EXIT_SUCCESS;
+}

File Metadata

Mime Type
text/x-diff
Expires
Mon, Jan 20, 11:35 PM (1 d, 6 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4242926
Default Alt Text
(15 KB)

Event Timeline