diff --git a/Hlt/Hlt2Conf/options/hlt2_pp_commissioning_data_production_options.yaml b/Hlt/Hlt2Conf/options/hlt2_pp_commissioning_data_production_options.yaml index f5a87dc8b0b730eb2efc7ea5ab4089f8ffd0aa27..6f65b2928ffc5a6a48ce38ab559ef0d531c82f1a 100644 --- a/Hlt/Hlt2Conf/options/hlt2_pp_commissioning_data_production_options.yaml +++ b/Hlt/Hlt2Conf/options/hlt2_pp_commissioning_data_production_options.yaml @@ -8,7 +8,7 @@ conditions_version: master input_files: - LFN:/lhcb/data/2022/RAW/FULL/LHCb/COLLISION22/253597/253597_00090004_0456.part.raw input_type: RAW -evt_max: -1 +evt_max: 120 xml_summary_file: hlt2_pp_commissioning_data_summary.xml xml_file_catalog: hlt2_data_pool_xml_catalog.xml diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_pp_commissioning.py b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_pp_commissioning.py index 66e8457a334ce81a585561446f12a29e35cd05d5..96121206879ccf8e8549aeb6c23c909860161b73 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_pp_commissioning.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_pp_commissioning.py @@ -48,6 +48,14 @@ def _hlt2_lumi_line(name='Hlt2Lumi', prescale=1): prescale=prescale) +def _hlt2_lumi_calibration_line(name='Hlt2LumiCalibration', prescale=1): + return Hlt2Line( + name=name, + algs=[], + hlt1_filter_code="Hlt1ODIN1kHzLumiDecision", + prescale=prescale) + + def _hlt2_no_bias_line(name="Hlt2NoBias", prescale=0.1): return Hlt2Line( name=name, @@ -56,14 +64,14 @@ def _hlt2_no_bias_line(name="Hlt2NoBias", prescale=0.1): prescale=prescale) -def _hlt2_hlt1passthrough_line(name="Hlt2Hlt1PassThrough", prescale=1): +def _hlt2_hlt1passthrough_line(name="Hlt2Hlt1PassThrough", prescale=0.01): ''' Anything else than the nobias line ''' return Hlt2Line( name=name, algs=[], - hlt1_filter_code=r"^Hlt1(?!ODINNoBias|ODINLumi).*Decision", + hlt1_filter_code=r"^Hlt1(?!ODINNoBias|ODINLumi|ODIN1kHzLumi).*Decision", prescale=prescale) @@ -388,7 +396,7 @@ def _make_lines(lines): return [builder() for builder in trunc_lines.values()] -def make_streams(): +def _make_streams(): full_lines = _make_lines(topological_b_lines) + _make_lines( inclusive_detached_dilepton_trigger_lines) + _make_lines( charmonium_to_dimuon_detached_lines) + _make_lines( @@ -416,10 +424,44 @@ def make_streams(): ] nobias_lines = [_hlt2_no_bias_line(), _hlt2_lumi_line()] passthrough_lines = [_hlt2_hlt1passthrough_line(), _hlt2_lumi_line()] + lumi_lines = [_hlt2_lumi_line(), _hlt2_lumi_calibration_line()] return dict( full=full_lines, turboraw=turbo_lines, turbo=turbo_lines, turcal=turcal_lines, no_bias=nobias_lines, - passthrough=passthrough_lines) + passthrough=passthrough_lines, + lumi=lumi_lines, + ) + + +def make_streams(real_make_streams=_make_streams): + + from RecoConf.hlt1_tracking import ( + make_VeloClusterTrackingSIMD, make_RetinaClusters, make_reco_pvs, + make_PatPV3DFuture_pvs, get_global_measurement_provider) + from RecoConf.hlt1_muonid import make_muon_hits + from RecoConf.calorimeter_reconstruction import make_digits + from RecoConf.hlt2_tracking import ( + make_PrKalmanFilter_noUT_tracks, make_PrKalmanFilter_Seed_tracks, + make_PrKalmanFilter_Velo_tracks, make_TrackBestTrackCreator_tracks, + get_UpgradeGhostId_tool_no_UT) + from PyConf.Algorithms import VeloRetinaClusterTrackingSIMD + # Workaround to enable running of Tracking efficiency lines using special muon reconstruction + from PyConf.Tools import TrackMasterFitter + + make_muon_hits.global_bind(geometry_version=3) + + with make_TrackBestTrackCreator_tracks.bind(max_chi2ndof=4.),\ + make_PrKalmanFilter_Velo_tracks.bind(max_chi2ndof=6.),\ + make_PrKalmanFilter_noUT_tracks.bind(max_chi2ndof=8.),\ + make_PrKalmanFilter_Seed_tracks.bind(max_chi2ndof=5.),\ + make_VeloClusterTrackingSIMD.bind(algorithm=VeloRetinaClusterTrackingSIMD, SkipForward=4),\ + get_UpgradeGhostId_tool_no_UT.bind(velo_hits=make_RetinaClusters),\ + make_reco_pvs.bind(make_pvs_from_velo_tracks=make_PatPV3DFuture_pvs),\ + get_global_measurement_provider.bind(velo_hits=make_RetinaClusters),\ + make_digits.bind(calo_raw_bank=True),\ + TrackMasterFitter.bind(FastMaterialApproximation=True): + + return real_make_streams() diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py new file mode 100644 index 0000000000000000000000000000000000000000..5f4e10de6b22a6fc8407729feebafa1caf9b5c94 --- /dev/null +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py @@ -0,0 +1,214 @@ +############################################################################### +# (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### +"""Options for testing the first data with HLT2. +""" +from GaudiKernel.SystemOfUnits import (GeV, MeV, mm) + +from Moore.lines import Hlt2Line +import Moore.streams_hlt2 +from RecoConf.reconstruction_objects import upfront_reconstruction +from Hlt2Conf.lines.topological_b import threebody_line, twobody_line +from Hlt2Conf.standard_particles import (make_long_pions, make_long_protons, + make_photons) +from Hlt2Conf.algorithms_thor import ParticleCombiner, ParticleFilter +import Functors as F + + +def hlt2_track_mva_line(name='Hlt2Commissioning_TrackMVAPassThrough', + prescale=1): + return Hlt2Line( + name=name, + algs=[], + hlt1_filter_code="Hlt1TrackMVADecision", + persistreco=True, + prescale=prescale) + + +def hlt2_lumi_line(name='Hlt2Lumi', prescale=1): + return Hlt2Line( + name=name, + algs=[], + hlt1_filter_code="Hlt1ODINLumiDecision", + persistreco=True, + prescale=prescale) + + +def hlt2_no_bias_line(name="Hlt2NoBias", prescale=1): + return Hlt2Line( + name=name, + algs=[], + hlt1_filter_code="Hlt1.*NoBiasDecision", + persistreco=True, + prescale=prescale) + + +def _filter_long_pions(): + return ParticleFilter(make_long_pions(), + F.FILTER(F.require_all(F.PT > 100 * MeV))) + + +def _filter_long_protons(): + return ParticleFilter( + make_long_protons(), + F.FILTER(F.require_all(F.PT > 400 * MeV, F.P > 9 * GeV))) + + +def _filter_photons(): + return ParticleFilter( + make_photons(), + F.FILTER( + F.require_all(F.PT > 200 * MeV, + F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > 0.85, + F.IS_PHOTON > 0.7, F.IS_NOT_H > 0.4))) + + +def diphoton_line(name='Hlt2Commissioning_DiPhoton', prescale=1): + diphoton = ParticleCombiner( + name="Commissioning_DiPhoton_Combiner", + Inputs=[_filter_photons(), _filter_photons()], + ParticleCombiner="ParticleAdder", + DecayDescriptor="eta -> gamma gamma", + CombinationCut=F.require_all( + F.math.in_range(0 * MeV, F.MASS, 1200 * MeV), F.PT > 2 * GeV), + CompositeCut=F.ALL, + ) + return Hlt2Line( + name=name, algs=[diphoton], persistreco=True, prescale=prescale) + + +def kshort_ll_line(name="Hlt2Commissioning_KsToPimPip_LL"): + kshorts = ParticleCombiner( + [_filter_long_pions(), _filter_long_pions()], + DecayDescriptor="KS0 -> pi+ pi-", + name="Ks_LL", + CombinationCut=F.require_all( + F.math.in_range(405 * MeV, F.MASS, 590 * MeV), + F.MAXDOCACUT(1 * mm), + F.PT > 300 * MeV, + F.P > 3.5 * GeV, + ), + CompositeCut=F.require_all( + F.math.in_range(435 * MeV, F.MASS, 560 * MeV), + F.PT > 350 * MeV, + F.P > 4 * GeV, + F.END_VZ < 700 * mm, + ), + ) + return Hlt2Line( + name=name, algs=upfront_reconstruction() + [kshorts], persistreco=True) + + +def lambda_ll_line(name="Hlt2Commissioning_L0ToPimPip_LL"): + lambdas = ParticleCombiner( + [_filter_long_protons(), _filter_long_pions()], + DecayDescriptor="[Lambda0 -> p+ pi-]cc", + name="Lambda_LL", + CombinationCut=F.require_all( + F.MASS < 1230 * MeV, + F.MAXDOCACUT(1 * mm), + (F.CHILD(1, F.P) - F.CHILD(2, F.P)) > 1 * GeV, + F.PT > 500 * MeV, + ), + CompositeCut=F.require_all( + F.math.in_range(1080 * MeV, F.MASS, 1200 * MeV), + F.PT > 600 * MeV, + F.END_VZ < 700 * mm, + ), + ) + return Hlt2Line( + name=name, algs=upfront_reconstruction() + [lambdas], persistreco=True) + + +def sigmap_line(name='Hlt2Commissioning_SpToPPi0', prescale=1): + protons = ParticleFilter(_filter_long_protons(), F.FILTER(F.PT > 1. * GeV)) + pi0 = ParticleCombiner( + name="Commissioning_Pi0_Combiner", + Inputs=[_filter_photons(), _filter_photons()], + ParticleCombiner="ParticleAdder", + DecayDescriptor="pi0 -> gamma gamma", + CombinationCut=F.require_all( + F.math.in_range(110 * MeV, F.MASS, 165 * MeV), F.PT > 800 * MeV), + CompositeCut=F.ALL, + ) + sigmas = ParticleCombiner( + name="Commissioning_Sigmap_Combiner", + Inputs=[protons, pi0], + ParticleCombiner="ParticleAdder", + DecayDescriptor="[Sigma+ -> p+ pi0]cc", + CombinationCut=F.require_all( + F.math.in_range(1100 * MeV, F.MASS, 1400 * MeV), + F.PT > 2000 * MeV, + (F.CHILD(1, F.P) - F.CHILD(2, F.P)) > 1 * GeV, + ), + CompositeCut=F.ALL, + ) + return Hlt2Line( + name=name, algs=[protons, sigmas], persistreco=True, prescale=prescale) + + +def _make_streams(): + linedict = dict( + stream_A=[ + hlt2_track_mva_line(), + threebody_line(), + twobody_line(), + hlt2_lumi_line() + ], + stream_B=[ + diphoton_line(), + sigmap_line(), + hlt2_no_bias_line(), + kshort_ll_line(), + lambda_ll_line(), + hlt2_lumi_line() + ]) + return linedict + + +def make_streams(): + + from RecoConf.hlt1_tracking import ( + make_VeloClusterTrackingSIMD, make_RetinaClusters, make_reco_pvs, + make_PatPV3DFuture_pvs, get_global_measurement_provider) + from RecoConf.hlt1_muonid import make_muon_hits + from RecoConf.calorimeter_reconstruction import make_digits + from RecoConf.hlt2_tracking import ( + make_PrKalmanFilter_noUT_tracks, make_PrKalmanFilter_Seed_tracks, + make_PrKalmanFilter_Velo_tracks, make_TrackBestTrackCreator_tracks, + get_UpgradeGhostId_tool_no_UT) + from PyConf.Algorithms import VeloRetinaClusterTrackingSIMD + # Workaround to enable running of Tracking efficiency lines using special muon reconstruction + from PyConf.Tools import TrackMasterFitter + + with make_TrackBestTrackCreator_tracks.bind(max_chi2ndof=4.),\ + make_PrKalmanFilter_Velo_tracks.bind(max_chi2ndof=6.),\ + make_PrKalmanFilter_noUT_tracks.bind(max_chi2ndof=8.),\ + make_PrKalmanFilter_Seed_tracks.bind(max_chi2ndof=5.),\ + make_VeloClusterTrackingSIMD.bind(algorithm=VeloRetinaClusterTrackingSIMD, SkipForward=4),\ + get_UpgradeGhostId_tool_no_UT.bind(velo_hits=make_RetinaClusters),\ + make_muon_hits.bind(geometry_version=3),\ + make_reco_pvs.bind(make_pvs_from_velo_tracks=make_PatPV3DFuture_pvs),\ + get_global_measurement_provider.bind(velo_hits=make_RetinaClusters),\ + make_digits.bind(calo_raw_bank=True),\ + TrackMasterFitter.bind(FastMaterialApproximation=True): + + return _make_streams() + + +# Modify stream dictionaries for testing purposes +Moore.streams_hlt2.DETECTOR_RAW_BANK_TYPES_PER_STREAM = { + "stream_A": [ + 'ODIN', 'VPRetinaCluster', 'UT', 'Rich', 'FTCluster', 'Calo', 'Muon', + 'Plume' + ], + "stream_B": ['ODIN'] +} +Moore.streams_hlt2.stream_bits = dict(stream_A=87, stream_B=88) diff --git a/Hlt/Moore/python/Moore/config.py b/Hlt/Moore/python/Moore/config.py index e9435a6fb0a631da6a45ee589651af8e17b1e93c..1b83b1d063a38f6fb6a31ec1954736cd04139fea 100644 --- a/Hlt/Moore/python/Moore/config.py +++ b/Hlt/Moore/python/Moore/config.py @@ -570,7 +570,8 @@ def moore_control_flow(options, streams, process, analytics=False): stream_writers_setup += pre_algs streamFilter = VoidFilter( - name=f'Stream{stream}_filter', + # no explicit name to allow sharing of instances between TURBO and TURBORAW + # name=f'Stream{stream}_filter', Cut=F.DECREPORTS_FILTER( Lines=list(line.decision_name for line in stream_lines), DecReports=dec_reports.DecReportsLocation)) diff --git a/Hlt/Moore/python/Moore/persistence/__init__.py b/Hlt/Moore/python/Moore/persistence/__init__.py index 6bfc764ffded4a8c48d191ad39f907b49c282192..88dc15eacb85624a93d9d8404724561bb6d35caf 100644 --- a/Hlt/Moore/python/Moore/persistence/__init__.py +++ b/Hlt/Moore/python/Moore/persistence/__init__.py @@ -279,9 +279,10 @@ def persist_line_outputs( # must thus be explicitly scheduled in the control flow and classified as a barrier to # explicitly _not_ trigger the creation of any data dependencies. packer = SelectivePacker( - name='{}_{}_Packer'.format( - stream_name, - stream.removeprefix('/Event/').replace('/', '_')), + # no explicit name to allow sharing of instances between TURBO and TURBORAW + # name='{}_{}_Packer'.format( + # stream_name, + # stream.removeprefix('/Event/').replace('/', '_')), is_barrier=True, AddTagParticles=[ l.decision_name for l in stream_lines if l.tagging_particles @@ -306,9 +307,10 @@ def persist_line_outputs( for t, n in type_map().items()}) bank_writers[stream_name] = HltPackedBufferWriter( - name='{}_{}_PackedBufferWriter'.format( - stream_name, - stream.removeprefix('/Event/').replace('/', '_')), + # no explicit name to allow sharing of instances between TURBO and TURBORAW + # name='{}_{}_PackedBufferWriter'.format( + # stream_name, + # stream.removeprefix('/Event/').replace('/', '_')), PackedContainers=[packer.outputs['outputLocation']], SourceID=source_id) diff --git a/Hlt/Moore/python/Moore/production.py b/Hlt/Moore/python/Moore/production.py index b56f1579c2321befc1bac6b67d0a99eaa6436f14..60767fc00c73a5ff14ea9b188888a71250138ba1 100644 --- a/Hlt/Moore/python/Moore/production.py +++ b/Hlt/Moore/python/Moore/production.py @@ -59,17 +59,7 @@ def _hlt2(options, make_lines, lines_regex, from DDDB.CheckDD4Hep import UseDD4Hep from Moore import run_moore from RecoConf.reconstruction_objects import reconstruction - from RecoConf.hlt2_tracking import ( - make_PrKalmanFilter_noUT_tracks, make_PrKalmanFilter_Seed_tracks, - make_PrKalmanFilter_Velo_tracks, make_TrackBestTrackCreator_tracks, - get_UpgradeGhostId_tool_no_UT) - from PyConf.Algorithms import VeloRetinaClusterTrackingSIMD from RecoConf import mc_checking - from RecoConf.hlt1_tracking import ( - make_VeloClusterTrackingSIMD, make_RetinaClusters, make_reco_pvs, - make_PatPV3DFuture_pvs, get_global_measurement_provider) - from RecoConf.hlt1_muonid import make_muon_hits - from RecoConf.calorimeter_reconstruction import make_digits from Moore.lines import Hlt2Line from PyConf.application import metainfo_repos, retrieve_encoding_dictionary if require_deployed_trigger_key: @@ -92,19 +82,26 @@ def _hlt2(options, make_lines, lines_regex, # Do not configure simplified geometry as it does not exist for DD4HEP public_tools = [] - # Workaround to enable running of Tracking efficiency lines using special muon reconstruction - from PyConf.Tools import TrackMasterFitter def _line_maker(): lines = make_lines() + if options.simulation: print(f"Adding {MC_PASSTHROUGH_LINE_NAME} for simulation") - lines.append( - Hlt2Line( - name=MC_PASSTHROUGH_LINE_NAME, - algs=[], - prescale=1, - persistreco=True)) + + # FIXME this is a poor way of implementing flagging mode + # persistreco=True emulates Brunel... + def _make_passthrough_line(): + return [ + Hlt2Line( + name=MC_PASSTHROUGH_LINE_NAME, + algs=[], + prescale=1, + persistreco=True) + ] + + lines.extend(make_lines(_make_passthrough_line)) + if lines_regex: n_before = len(lines) lines = [ @@ -115,31 +112,30 @@ def _hlt2(options, make_lines, lines_regex, ) return lines - with reconstruction.bind(from_file=False),\ - make_TrackBestTrackCreator_tracks.bind(max_chi2ndof=4.2),\ - make_PrKalmanFilter_Velo_tracks.bind(max_chi2ndof=4.2),\ - make_PrKalmanFilter_noUT_tracks.bind(max_chi2ndof=4.2),\ - make_PrKalmanFilter_Seed_tracks.bind(max_chi2ndof=4.2),\ - make_VeloClusterTrackingSIMD.bind(algorithm=VeloRetinaClusterTrackingSIMD, SkipForward=4),\ - get_UpgradeGhostId_tool_no_UT.bind(velo_hits=make_RetinaClusters),\ - make_muon_hits.bind(geometry_version=3),\ - make_reco_pvs.bind(make_pvs_from_velo_tracks=make_PatPV3DFuture_pvs),\ - get_global_measurement_provider.bind(velo_hits=make_RetinaClusters),\ - make_digits.bind(calo_raw_bank=True),\ - TrackMasterFitter.bind(FastMaterialApproximation=True): + with reconstruction.bind(from_file=False): config = run_moore(options, _line_maker, public_tools) return config -def _make_all_lines(): +def _make_all_lines(maker=None): from Hlt2Conf.lines import all_lines - lines = [builder() for builder in all_lines.values()] - return lines + from RecoConf.hlt1_muonid import make_muon_hits + make_muon_hits.global_bind(geometry_version=3) + if maker is None: + return [builder() for builder in all_lines.values()] + else: + return maker() -def _make_pp_commissioning_lines(): +def _make_pp_commissioning_lines(*args): from Hlt2Conf.settings.hlt2_pp_commissioning import make_streams - streams = make_streams() + streams = make_streams(*args) # Use a set comprehension to deduplicate lines - return list({line for lines in streams.values() for line in lines}) + # FIXME why do we have duplicate lines? + if isinstance(streams, dict): + return sorted({line + for lines in streams.values() for line in lines}, + key=lambda x: x.name) + else: + return streams diff --git a/Hlt/Moore/python/Moore/streams_hlt2.py b/Hlt/Moore/python/Moore/streams_hlt2.py index f2a2ba935fc2a413cdd03779c85ccc5c2c4b1e90..4264eaf6fdbe21829dd9317005fb04c7716150ec 100644 --- a/Hlt/Moore/python/Moore/streams_hlt2.py +++ b/Hlt/Moore/python/Moore/streams_hlt2.py @@ -24,8 +24,17 @@ PHYSICS = r"^Hlt2(?!Lumi).*Decision$" LUMI = r"^Hlt2LumiDecision$" DETECTOR_RAW_BANK_TYPES = { - 'ODIN', 'VP', 'UT', 'FTCluster', 'Rich', 'EcalPacked', 'HcalPacked', - 'Muon', 'VPRetinaCluster', 'Calo', 'Plume' + 'ODIN', + 'VPRetinaCluster', + 'VP', # compatibility with data without VP clusters + 'UT', + 'FTCluster', + 'Rich', + 'Muon', + 'Plume', + 'Calo', + 'EcalPacked', # compatibility with old data, now under "Calo" + 'HcalPacked', # compatibility with old data, now under "Calo" } # HltRoutingBits banj is not in the list as it is rewritten by HLT2. @@ -41,13 +50,14 @@ HLT2_REPORT_RAW_BANK_TYPES = { # For now passing all RawBanks to all streams, to be modified based on the streaming development # list ODIN explicitly just here DETECTOR_RAW_BANK_TYPES_PER_STREAM = { + "default": DETECTOR_RAW_BANK_TYPES, "turboraw": DETECTOR_RAW_BANK_TYPES, "full": DETECTOR_RAW_BANK_TYPES, "turbo": {'ODIN'}, "turcal": DETECTOR_RAW_BANK_TYPES, "no_bias": DETECTOR_RAW_BANK_TYPES, "passthrough": DETECTOR_RAW_BANK_TYPES, - "default": DETECTOR_RAW_BANK_TYPES + "lumi": DETECTOR_RAW_BANK_TYPES, } stream_bits = dict( @@ -57,7 +67,9 @@ stream_bits = dict( turcal=90, no_bias=91, passthrough=92, - default=64) + lumi=93, + default=64, +) def stream_bank_types(stream): diff --git a/Hlt/Moore/tests/qmtest/test_lbexec_hlt2_pp_commissioning_data.qmt b/Hlt/Moore/tests/qmtest/test_lbexec_hlt2_pp_commissioning_data.qmt index 3a716a7a7453bc965b8b967e0c2b5a8d1a114e4c..d620603db027ebf9397a0f45faa256c5b6b8b856 100644 --- a/Hlt/Moore/tests/qmtest/test_lbexec_hlt2_pp_commissioning_data.qmt +++ b/Hlt/Moore/tests/qmtest/test_lbexec_hlt2_pp_commissioning_data.qmt @@ -22,9 +22,10 @@ Test that HLT2 can run from LHCbDirac and that it produces the expected outputs $HLT2CONFROOT/options/hlt2_pp_commissioning_data_production_options.yaml true +2000 -countErrorLines({"FATAL": 0, "ERROR": 10}) +countErrorLines({"FATAL": 0, "ERROR": 0}) import xml.etree.ElementTree as ET from pathlib import Path @@ -32,16 +33,24 @@ from pathlib import Path # Ensure the summary XML is as expected tree = ET.parse(Path.cwd() / "hlt2_pp_commissioning_data_summary.xml") out_files = tree.findall("./output/file") -assert len(out_files) == 1, out_files +if len(out_files) != 1: + causes.append(f"expected exactly one output file, got {out_files}") out_file = out_files[0] -assert int(out_file.text) > 10 -assert int(out_file.text) < 1234 -assert out_file.attrib["name"] == "PFN:hlt2_pp_commissioning_data_output.dst" + +if not (int(out_file.text) > 5): + causes.append(f"Expected more than 5 events in the output, XML summary gives {out_file.text}") + +if not (int(out_file.text) < 60): + causes.append(f"Expected less than 60 events in the output, XML summary gives {out_file.text}") + +if out_file.attrib["name"] != "PFN:hlt2_pp_commissioning_data_output.dst": + causes.append("wrong output file name") # Ensure the pool XML was updated to contain the new output file tree = ET.parse(Path.cwd() / "hlt2_data_pool_xml_catalog.xml") catalog_output = tree.findall(f'./File/physical/pfn[@name="hlt2_pp_commissioning_data_output.dst"]') -assert len(catalog_output) == 1, catalog_output +if len(catalog_output) != 1: + causes.append(f"Expected exactly one output with the right name, got {catalog_output}")