diff --git a/t/CMakeLists.txt b/t/CMakeLists.txt
index 5f4f145..b6f329e 100644
--- a/t/CMakeLists.txt
+++ b/t/CMakeLists.txt
@@ -1,707 +1,722 @@
 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_full
+  COMMAND test_ME_generic ${tst_ME_data_dir}/config_Z_ME.yml
+          ${tst_ME_data_dir}/ME_Z_full.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_WpWp_full
+  COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
+          ${tst_ME_data_dir}/ME_WpWp_full.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
   )
+add_test(
+  NAME ME_WmWm_full
+  COMMAND test_ME_generic ${tst_ME_data_dir}/config_ww_ME.yml
+          ${tst_ME_data_dir}/ME_WmWm_full.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}\nanalyses:\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/ME_data/ME_WmWm_full.dat b/t/ME_data/ME_WmWm_full.dat
new file mode 100644
index 0000000..611f6f2
--- /dev/null
+++ b/t/ME_data/ME_WmWm_full.dat
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7be9486ddbf43ce2a9f516615cbacf171265a8de57aee166779aa249354feed1
+size 61376
diff --git a/t/ME_data/ME_WpWp_full.dat b/t/ME_data/ME_WpWp_full.dat
new file mode 100644
index 0000000..7943156
--- /dev/null
+++ b/t/ME_data/ME_WpWp_full.dat
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c1035bad2b851dd77723dc785281589c239fbbf012a831b76949dac0c7dbb72
+size 80000
diff --git a/t/ME_data/ME_Z_full.dat b/t/ME_data/ME_Z_full.dat
new file mode 100644
index 0000000..6a5c64b
--- /dev/null
+++ b/t/ME_data/ME_Z_full.dat
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0601df7419f6e3a7e74d1cf69b98b4b86a128af36aef69d71a3ab01131db965
+size 80000
diff --git a/t/test_ME_generic.cc b/t/test_ME_generic.cc
index 55f1c06..4c3171f 100644
--- a/t/test_ME_generic.cc
+++ b/t/test_ME_generic.cc
@@ -1,292 +1,304 @@
 /**
  *  \brief     Generic tester for the ME for a given set of PSP
  *
  *  \note      reference weights and PSP (as LHE file) have to be given as
  *             _individual_ files
  *
  *  \authors   The HEJ collaboration (see AUTHORS for details)
  *  \date      2019-2020
  *  \copyright GPLv2 or later
  */
 #include "hej_test.hh"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <string>
 
 #include "HEJ/Config.hh"
 #include "HEJ/Event.hh"
 #include "HEJ/EventReader.hh"
 #include "HEJ/exceptions.hh"
 #include "HEJ/MatrixElement.hh"
 #include "HEJ/stream.hh"
 #include "HEJ/YAMLreader.hh"
 
 namespace {
   constexpr double ALPHA_S = 0.118;
   constexpr double EP = 1e-9;
   constexpr double EP_MIRROR = 1e-3;
   constexpr std::size_t MIN_PSP = 100;
   constexpr std::size_t WRITE_PRECISION = 9;
   constexpr std::size_t PRINT_PRECISION = WRITE_PRECISION+1;
 
-  enum MEComponent {tree, virt};
+  enum MEComponent {tree, virt, full};
 
   MEComponent guess_component(std::string const & data_file) {
     if(data_file.find("virt") != std::string::npos) return MEComponent::virt;
+    if(data_file.find("full") != std::string::npos) return MEComponent::full;
     return MEComponent::tree;
   }
 
   //! p_z -> -p_z
   HEJ::Event::EventData mirror_event(HEJ::Event::EventData ev){
     for(auto & part: ev.incoming){
       auto & p{ part.p };
       p.reset(p.px(),p.py(),-p.pz(),p.E());
     }
     for(auto & part: ev.outgoing){
       auto & p{ part.p };
       p.reset(p.px(),p.py(),-p.pz(),p.E());
     }
     for(auto & decay: ev.decays){
       for(auto & part: decay.second){
         auto & p{ part.p };
         p.reset(p.px(),p.py(),-p.pz(),p.E());
       }
     }
     // If this is a Z event, we also have to change quarks and leptons to their antiparticle
     if(ev.decays.size() == 1){
       auto decay = ev.decays.begin();
       if(ev.outgoing[decay->first].type == HEJ::ParticleID::Z_photon_mix){
         for(auto & part: ev.incoming){
           if(is_anyquark(part)) part.type = static_cast<HEJ::ParticleID>(-part.type);
         }
         for(auto & part: ev.outgoing){
           if(is_anyquark(part)) part.type = static_cast<HEJ::ParticleID>(-part.type);
         }
         for(auto & decay: ev.decays){
           for(auto & part: decay.second){
             part.type = static_cast<HEJ::ParticleID>(-part.type);
           }
         }
       }
     }
     return ev;
   }
 
   void to_anti(HEJ::Particle & part){
     if(is_anyquark(part)
       || is_anylepton(part)
       || abs(part.type) == HEJ::ParticleID::Wp)
     part.type = static_cast<HEJ::ParticleID>(-part.type);
   }
 
   //! p -> -p
   HEJ::Event::EventData reverse_event(HEJ::Event::EventData ev){
     for(auto & part: ev.incoming){
       to_anti(part);
       auto & p{ part.p };
       p.reset(-p.px(),-p.py(),-p.pz(),p.E());
     }
     for(auto & part: ev.outgoing){
       to_anti(part);
       auto & p{ part.p };
       p.reset(-p.px(),-p.py(),-p.pz(),p.E());
     }
     for(auto & decay: ev.decays){
       for(auto & part: decay.second){
         to_anti(part);
         auto & p{ part.p };
         p.reset(-p.px(),-p.py(),-p.pz(),p.E());
       }
     }
     return ev;
   }
 } // namespace
 
 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(WRITE_PRECISION);
     wgt_file << std::scientific;
   } else {
     wgt_file.open(argv[2], std::fstream::in);
   }
 
   auto reader{ HEJ::make_reader(argv[3])};
 
   const auto component = guess_component(argv[2]);
 
   HEJ::MatrixElement ME{
     [](double /*unused*/){ return ALPHA_S; },
     HEJ::to_MatrixElementConfig(config)
   };
   HEJ::EWConstants ew_parameters;
   ew_parameters = config.ew_parameters;
 
   double max_ratio = 0.;
   std::size_t idx_max_ratio = 0;
 
   HEJ::Event ev_max_ratio(HEJ::Event::EventData{}.cluster(
       config.resummation_jets.def,0
     )
   );
   double av_ratio = 0;
 
   std::size_t i = 0;
   while(reader->read_event()){
     ++i;
 
     HEJ::Event::EventData data{reader->hepeup()};
     shuffle_particles(data);
     data.reconstruct_intermediate(ew_parameters);
 
     HEJ::Event::EventData data_mirror{mirror_event(data)};
     shuffle_particles(data_mirror);
 
     HEJ::Event::EventData data_reverse{reverse_event(data)};
     shuffle_particles(data_reverse);
 
     HEJ::Event event{
       data.cluster(
         config.resummation_jets.def,
         config.resummation_jets.min_pt
       )
     };
     HEJ::Event event_mirror{
       data_mirror.cluster(
         config.resummation_jets.def,
         config.resummation_jets.min_pt
       )
     };
     HEJ::Event event_reverse{
       data_reverse.cluster(
         config.resummation_jets.def,
         config.resummation_jets.min_pt
       )
     };
 
     // Check finite
     double our_ME = NAN;
     if(component == MEComponent::tree){
       our_ME = ME.tree(event).central;
-    }else{
+    }else if(component == MEComponent::virt){
       const auto partons = filter_partons(event.outgoing());
       if (config.nlo.enabled and config.nlo.nj != partons.size()){
-      continue;
+        continue;
       }
 
       double sum = 0.;
       for(size_t i=0; i<ME.virtual_corrections(event).size(); ++i) {
         sum += ME.virtual_corrections(event).at(i).central;
       }
       our_ME = sum;
+    }else{
+      const auto partons = filter_partons(event.outgoing());
+      if (config.nlo.enabled and config.nlo.nj != partons.size()){
+        continue;
+      }
+
+      our_ME = ME(event).central;
     }
     if(!std::isfinite(our_ME)){
       std::cerr << "Found non-finite ME ("<< our_ME <<")\n" << event << std::endl;
       return EXIT_FAILURE;
     }
 
     // Mirror Event
     double ME_mirror = NAN;
     if(component == MEComponent::tree){
       ME_mirror = ME.tree(event_mirror).central;
-    }else{
+    }else if(component == MEComponent::virt){
       double sum = 0.;
       for(size_t i=0; i<ME.virtual_corrections(event_mirror).size(); ++i) {
         sum += ME.virtual_corrections(event_mirror).at(i).central;
       }
       ME_mirror = sum;
+    }else{
+      ME_mirror = ME(event_mirror).central;
     }
     if(!std::isfinite(ME_mirror)){
       std::cerr << "Found non-finite ME ("<< ME_mirror <<")\n" << event_mirror << std::endl;
       return EXIT_FAILURE;
     }
 
     if(std::abs(our_ME/ME_mirror-1.)>EP_MIRROR){
       std::cerr.precision(PRINT_PRECISION);
       std::cerr <<std::scientific
         << "z-Mirrored ME gives different result in event number " << i << "\n"
         << our_ME << " vs " << ME_mirror << " => difference: "
         << std::abs(our_ME/ME_mirror-1.) << "\n" << event
         << "\nmirrored:\n" << event_mirror << std::endl;
       return EXIT_FAILURE;
     }
 
     // Reverse Event
     double ME_reverse = NAN;
     if(component == MEComponent::tree){
       ME_reverse = ME.tree(event_reverse).central;
-    }else{
+    }else if(component == MEComponent::virt){
       double sum = 0.;
       for(size_t i=0; i<ME.virtual_corrections(event_reverse).size(); ++i) {
         sum += ME.virtual_corrections(event_reverse).at(i).central;
       }
       ME_reverse = sum;
+    }else{
+      ME_reverse = ME(event_reverse).central;
     }
     if(!std::isfinite(ME_reverse)){
       std::cerr << "Found non-finite ME ("<< ME_reverse <<")\n" << event_reverse << std::endl;
       return EXIT_FAILURE;
     }
     if(std::abs(our_ME/ME_reverse-1.)>EP_MIRROR){
       std::cerr.precision(PRINT_PRECISION);
       std::cerr <<std::scientific
         << "p-reversed ME gives different result in event number " << i << "\n"
         << our_ME << " vs " << ME_reverse << " => difference: "
         << std::abs(our_ME/ME_reverse-1.) << "\n" << event
         << "\nreversed:\n" << event_reverse << std::endl;
       return EXIT_FAILURE;
     }
 
     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);
       double diff = NAN;
       if(ref_ME == 0.){
         diff = static_cast<double>(our_ME != 0.);
       } else {
         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 ){
         std::cerr.precision(PRINT_PRECISION);
         std::cerr<<std::scientific
           << "Large difference in PSP " << i << "\nis: "<< our_ME
           << " should: " << ref_ME << " => difference: " << diff << "\n"
           << event << std::endl;
         return EXIT_FAILURE;
       }
     }
   }
   wgt_file.close();
   if ( i<MIN_PSP )
     throw std::invalid_argument{"Not enough PSP tested"};
   if ( !OUTPUT_MODE ) {
     std::cout.precision(PRINT_PRECISION);
     std::cout << std::scientific
       << "Avg ratio after " << i << " PSP: " << av_ratio/i << "\n"
       << "maximal ratio at " << idx_max_ratio << ": " << max_ratio << std::endl;
   }
   return EXIT_SUCCESS;
 }