From 5dd63a9145e039aac25d0db8df89fcb2eff54d87 Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Fri, 9 Aug 2019 15:21:24 +0200 Subject: [PATCH 01/14] Add muon id to reconstruction --- Hlt/RecoConf/options/hlt1_reco_baseline.py | 21 ++++++++-- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 45 +++++++++++++++++++++ 2 files changed, 63 insertions(+), 3 deletions(-) create mode 100644 Hlt/RecoConf/python/RecoConf/hlt1_muonid.py diff --git a/Hlt/RecoConf/options/hlt1_reco_baseline.py b/Hlt/RecoConf/options/hlt1_reco_baseline.py index 2f3c2d2be1e..deb7450d226 100644 --- a/Hlt/RecoConf/options/hlt1_reco_baseline.py +++ b/Hlt/RecoConf/options/hlt1_reco_baseline.py @@ -12,10 +12,18 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_hlt1_tracks, make_velokalman_fitted_tracks) +from RecoConf.hlt1_muonid import (make_muon_hits, + make_muon_id, + make_tracks_with_muon_id, + ) +from Hlt1Conf.algorithms import (SOAFilterTracksWithMuonID) from PyConf.Algorithms import FTRawBankDecoder from PyConf.environment import EverythingHandler, setupInputFromTestFileDB +from GaudiKernel.SystemOfUnits import mm, GeV + + ftdec_v = 4 @@ -23,9 +31,16 @@ def hlt1_full_track_reco_line(): with FTRawBankDecoder.bind(DecodingVersion=ftdec_v): gec = require_gec(FTDecodingVersion=ftdec_v) NoPVFilter = require_pvs(make_pvs()) - fitted_tracks = make_velokalman_fitted_tracks(make_hlt1_tracks())["Pr"] - - return [gec, NoPVFilter, fitted_tracks] + fitted_tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) + muon_id = make_muon_id(fitted_tracks) + tracks_with_muon_id = make_tracks_with_muon_id(fitted_tracks) + from Functors import ISMUON, PT + track_filter = SOAFilterTracksWithMuonID( + ISMUON & (PT > 0.75 * GeV ), + Input=tracks_with_muon_id, + InputSelection=fitted_tracks["v2ZipSel"] + ) + return [gec, NoPVFilter, tracks_with_muon_id, track_filter] env = EverythingHandler( diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py new file mode 100644 index 00000000000..df130e12429 --- /dev/null +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -0,0 +1,45 @@ +############################################################################### +# (c) Copyright 2019 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. # +############################################################################### +from PyConf import configurable + +# all trivial (not changing default) and fully datahandly imports can be done from here +from PyConf.Algorithms import ( + MuonRawToHits, + MuonIDHlt1Alg, + MakeView__Track_v2__MuonID, + SOAFilter__TrackWithMuonIDView, +) + +from hlt1_tracking import ( + RawData, +) + + + +@configurable +def make_muon_hits(raw=RawData): + return MuonRawToHits(RawEventLocation=raw().RawEvent).HitContainer + + +@configurable +def make_muon_id(tracks, + muon_hits=make_muon_hits): + return MuonIDHlt1Alg(InputTracks=tracks["v2Zip"], + InputMuonHits=muon_hits()).OutputMuonPID + +@configurable +def make_tracks_with_muon_id(tracks, + make_muon_id=make_muon_id): + muon_ids = make_muon_id(tracks) + return MakeView__Track_v2__MuonID( + InputTracks = tracks["v2Zip"], + InputMuonIDs = muon_ids).Output + -- GitLab From 3bc398112ec7e0ba5811294ec4af399f8c64f4fe Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Fri, 9 Aug 2019 15:21:55 +0200 Subject: [PATCH 02/14] Add muon line to hlt1 example --- Hlt/Hlt1Conf/options/hlt1_example.py | 2 + Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py | 10 +++ .../python/Hlt1Conf/lines/track_muon.py | 68 +++++++++++++++++++ 3 files changed, 80 insertions(+) create mode 100644 Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py diff --git a/Hlt/Hlt1Conf/options/hlt1_example.py b/Hlt/Hlt1Conf/options/hlt1_example.py index 4f2c4fa80d4..f1e065ffcb9 100644 --- a/Hlt/Hlt1Conf/options/hlt1_example.py +++ b/Hlt/Hlt1Conf/options/hlt1_example.py @@ -13,6 +13,7 @@ from PyConf.Algorithms import FTRawBankDecoder from RecoConf.hlt1_tracking import require_gec from Hlt1Conf.lines.track_mva import (one_track_mva_line, two_track_mva_line, debug_two_track_mva_line) +from Hlt1Conf.lines.track_muon import (one_track_muon_mva_line) ftdec_v = 4 env = EverythingHandler( @@ -25,6 +26,7 @@ with FTRawBankDecoder.bind(DecodingVersion=ftdec_v), \ 'Hlt1TrackMVALine': one_track_mva_line, 'Hlt1TwoTrackMVALine': two_track_mva_line, 'Hlt1DebugTwoTrackMVALine': debug_two_track_mva_line, + 'Hlt1TrackMuonMVALine': one_track_muon_mva_line, } for name, builder in builders.items(): env.registerLine(name, builder()) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py b/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py index 5322a13480e..8ce50d963e8 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py @@ -18,6 +18,7 @@ from Configurables import ( CombineTracks__2Body__Track_v2, CombineTracks__2Body__Track_v2__Dumper, CombineTracks__2Body__PrFittedForwardTracks, + SOAFilter__TrackWithMuonIDView, ) from PyConf.components import Algorithm @@ -85,6 +86,15 @@ def PrFilterV2Tracks(functor, **kwargs): Factory='FunctorFactory', **kwargs) +@configurable +def SOAFilterTracksWithMuonID(functor, **kwargs): + return Algorithm( + SOAFilter__TrackWithMuonIDView, + Code=functor.code(), + Headers=functor.headers(), + Factory='FunctorFactory', + **kwargs) + @configurable def FilterPrFittedForwardTracks(functor, **kwargs): diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py new file mode 100644 index 00000000000..e2859c4ae2d --- /dev/null +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py @@ -0,0 +1,68 @@ +############################################################################### +# (c) Copyright 2019 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. # +############################################################################### +from __future__ import absolute_import, division, print_function +import math +from GaudiKernel.SystemOfUnits import GeV +from PyConf import configurable +from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, + make_odin, make_hlt1_tracks, + make_velokalman_fitted_tracks, + ) +from RecoConf.hlt1_muonid import (make_tracks_with_muon_id, + ) +from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMuonID, + ) + +from PyConf.Algorithms import FTRawBankDecoder + + + +def make_fitted_tracks_with_muon_id(): + tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) + tracks_with_muon_id = make_tracks_with_muon_id(tracks) + return tracks, tracks_with_muon_id + +@configurable +def track_muon_prefilters(make_pvs=make_pvs): + return [require_gec(), require_pvs(make_pvs())] + + + +@configurable +def one_track_muon_mva_line( + make_input_tracks=make_fitted_tracks_with_muon_id, + make_pvs=make_pvs, + # TrackMuonLoose cuts from ZombieMoore to be done + max_chi2dof=2.5, + min_pt=2.0 * GeV, + max_pt=26 * GeV, + min_ipchi2=7.4, + param1=1.0, + param2=2.0, + param3=1.248): + pvs = make_pvs().location + #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON + from Functors import ISMUON, PT + from Functors.math import in_range, log + pre_sel = (ISMUON) & (PT > min_pt) + # hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) + # bulk_sel = in_range(min_pt, PT, max_pt) & ( + # log(MINIPCHI2(pvs)) > + # (param1 / ((PT / GeV - param2)**2) + + # (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) + full_sel = pre_sel + tracks, tracks_with_muon_id = make_input_tracks() + track_filter = SOAFilterTracksWithMuonID( + full_sel, + Input=tracks_with_muon_id, + InputSelection = tracks["v2ZipSel"] + ) + return track_muon_prefilters() + [track_filter] -- GitLab From 669a5f47460a751957e93af2ab88fb762ffba946 Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Fri, 9 Aug 2019 16:06:35 +0200 Subject: [PATCH 03/14] Forgotten file --- Hlt/RecoConf/python/RecoConf/hlt1_tracking.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py index a8241026d26..926f2d00e7f 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py @@ -32,6 +32,7 @@ from PyConf.Algorithms import ( LHCb__Converters__Track__v1__fromV2TrackV1TrackVector as FromV2TrackV1TrackVector, LHCb__Converters__Track__v1__fromV2TrackV1Track as FromV2TrackV1Track, + MakeZipContainer__Track_v2, FTRawBankDecoder, TracksVPMergerConverter, TracksVPConverter, @@ -222,10 +223,12 @@ def make_forward_tracks( TracksFTLocation=forward_tracks_pr).OutputTracksLocation forward_tracks_v1 = FromV2TrackV1Track( InputTracksName=forward_tracks_v2).OutputTracksName + forward_tracks_v2_zip = MakeZipContainer__Track_v2(Input=forward_tracks_v2).OutputSelection return { "Pr": forward_tracks_pr, "v2": forward_tracks_v2, - "v1": forward_tracks_v1 + "v1": forward_tracks_v1, + "v2Zip": forward_tracks_v2_zip, } @@ -246,12 +249,16 @@ def make_velokalman_fitted_tracks(tracks, make_hits=make_velo_hits): Input=FromV2TrackV1TrackVector( InputTracksName=fitted_tracks_v2).OutputTracksName) fitted_tracks_v2_sel = TrackV2Selection(Input=fitted_tracks_v2).Output + fitted_tracks_v2_zip_sel = MakeZipContainer__Track_v2(Input=fitted_tracks_v2).OutputSelection + fitted_tracks_v2_zip = MakeZipContainer__Track_v2(Input=fitted_tracks_v2).OutputData return { "Pr": fitted_tracks, "v2": fitted_tracks_v2, "v1": fitted_tracks_v1, "v1Sel": fitted_tracks_v1_sel, "v2Sel": fitted_tracks_v2_sel, + "v2Zip": fitted_tracks_v2_zip, + "v2ZipSel": fitted_tracks_v2_zip_sel, } -- GitLab From bb134101a8d6390e69062f738f7d9329b60929c1 Mon Sep 17 00:00:00 2001 From: "claire.prouve" Date: Fri, 9 Aug 2019 16:35:07 +0200 Subject: [PATCH 04/14] working towards muonmatch lines --- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 36 ++++++++++++++++++- Hlt/RecoConf/python/RecoConf/hlt1_tracking.py | 8 +++++ 2 files changed, 43 insertions(+), 1 deletion(-) diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index df130e12429..d15d93620d6 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -16,6 +16,7 @@ from PyConf.Algorithms import ( MuonIDHlt1Alg, MakeView__Track_v2__MuonID, SOAFilter__TrackWithMuonIDView, + MuonMatchVeloUTSoA ) from hlt1_tracking import ( @@ -31,7 +32,7 @@ def make_muon_hits(raw=RawData): @configurable def make_muon_id(tracks, - muon_hits=make_muon_hits): + make_muon_hits=make_muon_hits): return MuonIDHlt1Alg(InputTracks=tracks["v2Zip"], InputMuonHits=muon_hits()).OutputMuonPID @@ -43,3 +44,36 @@ def make_tracks_with_muon_id(tracks, InputTracks = tracks["v2Zip"], InputMuonIDs = muon_ids).Output + +@configurable +def make_muon_match_tracks(tracks, + make_muon_hits = make_muon_hits): + + muon_match_tracks= MuonMatchVeloUTSoA(InputTracks = tracks["Pr"], + InputMuonHits = make_muon_hits()) + return {"Pr":muon_match_tracks.OutputTracks} + + +def make_tracks_with_muonmatch(): + velo_tracks = make_velo_tracks() + velo_ut_tracks = make_upstream_tracks(velo_tracks) + muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + forward_tracks = make_forward_tracks(muon_match_tracks) + return { + "Velo": velo_tracks, + "Upstream": velo_ut_tracks, + "MuonMatch" : muon_match_tracks, + "Forward": forward_tracks, + } + +def make_tracks_with_muonmatch_ipcut(): + velo_tracks = make_IPselected_tracks() + velo_ut_tracks = make_upstream_tracks(velo_tracks) + muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + forward_tracks = make_forward_tracks(muon_match_tracks) + return { + "Velo": velo_tracks, + "Upstream": velo_ut_tracks, + "MuonMatch" : muon_match_tracks, + "Forward": forward_tracks, + } diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py index 926f2d00e7f..071219a4a0e 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py @@ -144,6 +144,14 @@ def make_velo_tracks(make_velo_pr_tracks=make_velo_tracks_simdly, } + +@configurable +def make_IPselected_tracks(make_tracks=make_velo_tracks, + make_pvs=make_pvs, + ip_cut=0.1 * mm): + ip_selected_tracks = PrFilterIP( IPcut=ip_cut, Input=make_tracks(), InputVertices=make_pvs()).Output + return {"Pr" : ip_selected_tracks} + @configurable def make_pvs_tblv(velo_tracks): return TrackBeamLineVertexFinderSoA( -- GitLab From 03951816cca1cb53519d0a8bf648216aa9fad9e7 Mon Sep 17 00:00:00 2001 From: "claire.prouve" Date: Mon, 12 Aug 2019 09:35:51 +0200 Subject: [PATCH 05/14] added code for the muonmatch reco sequence --- Hlt/RecoConf/options/hlt1_reco_baseline.py | 6 +- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 57 ++++++++++++++++--- Hlt/RecoConf/python/RecoConf/hlt1_tracking.py | 8 +-- 3 files changed, 54 insertions(+), 17 deletions(-) diff --git a/Hlt/RecoConf/options/hlt1_reco_baseline.py b/Hlt/RecoConf/options/hlt1_reco_baseline.py index deb7450d226..88b0b5ac791 100644 --- a/Hlt/RecoConf/options/hlt1_reco_baseline.py +++ b/Hlt/RecoConf/options/hlt1_reco_baseline.py @@ -15,6 +15,8 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, from RecoConf.hlt1_muonid import (make_muon_hits, make_muon_id, make_tracks_with_muon_id, + make_tracks_with_muonmatch, + make_tracks_with_muonmatch_ipcut, ) from Hlt1Conf.algorithms import (SOAFilterTracksWithMuonID) @@ -34,13 +36,15 @@ def hlt1_full_track_reco_line(): fitted_tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) muon_id = make_muon_id(fitted_tracks) tracks_with_muon_id = make_tracks_with_muon_id(fitted_tracks) + #tracks_with_muonmatch = make_tracks_with_muonmatch()["Forward"]["Pr"] + tracks_with_muonmatch_ipcut = make_tracks_with_muonmatch_ipcut(4*mm, 80.)["Forward"]["Pr"] from Functors import ISMUON, PT track_filter = SOAFilterTracksWithMuonID( ISMUON & (PT > 0.75 * GeV ), Input=tracks_with_muon_id, InputSelection=fitted_tracks["v2ZipSel"] ) - return [gec, NoPVFilter, tracks_with_muon_id, track_filter] + return [gec, NoPVFilter, tracks_with_muon_id, track_filter, tracks_with_muonmatch_ipcut] env = EverythingHandler( diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index d15d93620d6..cb6223c89e7 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -16,11 +16,22 @@ from PyConf.Algorithms import ( MuonIDHlt1Alg, MakeView__Track_v2__MuonID, SOAFilter__TrackWithMuonIDView, - MuonMatchVeloUTSoA + MuonMatchVeloUTSoA, + TracksVPConverter, + TracksUTConverter, + LHCb__Converters__Track__v1__fromV2TrackV1Track as FromV2TrackV1Track, + PrFilterIPSoA, + SciFiTrackForwarding, ) from hlt1_tracking import ( RawData, + make_velo_hits, + make_velo_tracks, + make_pvs, + make_upstream_tracks, + make_forward_tracks, + VeloUTTracking, ) @@ -34,7 +45,7 @@ def make_muon_hits(raw=RawData): def make_muon_id(tracks, make_muon_hits=make_muon_hits): return MuonIDHlt1Alg(InputTracks=tracks["v2Zip"], - InputMuonHits=muon_hits()).OutputMuonPID + InputMuonHits=make_muon_hits()).OutputMuonPID @configurable def make_tracks_with_muon_id(tracks, @@ -45,13 +56,36 @@ def make_tracks_with_muon_id(tracks, InputMuonIDs = muon_ids).Output +@configurable +def make_IPselected_tracks(tracks, + pvs, + ip_cut, + make_velo_hits = make_velo_hits): + output_tracks = PrFilterIPSoA(IPcut=ip_cut, Input=tracks["Pr"], InputVertices=pvs).Output + output_tracks_v2 = TracksVPConverter(TracksLocation=output_tracks, HitsLocation = make_velo_hits() ).OutputTracksLocation + output_tracks_v1 = FromV2TrackV1Track( + InputTracksName=output_tracks_v2).OutputTracksName + + return {"Pr" : output_tracks, + "v2" : output_tracks_v2, + "v1" : output_tracks_v1} + @configurable def make_muon_match_tracks(tracks, make_muon_hits = make_muon_hits): - muon_match_tracks= MuonMatchVeloUTSoA(InputTracks = tracks["Pr"], - InputMuonHits = make_muon_hits()) - return {"Pr":muon_match_tracks.OutputTracks} + muon_match_tracks= MuonMatchVeloUTSoA( InputTracks = tracks["Pr"], + InputMuonHits = make_muon_hits()).OutputTracks + muon_match_tracks_v2 = TracksUTConverter( TracksVPLocation = tracks["v2"], + TracksUTLocation = muon_match_tracks).OutputTracksLocation + + muon_match_tracks_v1 = FromV2TrackV1Track( InputTracksName=muon_match_tracks_v2).OutputTracksName + + return { + "Pr": muon_match_tracks, + "v2": muon_match_tracks_v2, + "v1": muon_match_tracks_v1 + } def make_tracks_with_muonmatch(): @@ -66,11 +100,16 @@ def make_tracks_with_muonmatch(): "Forward": forward_tracks, } -def make_tracks_with_muonmatch_ipcut(): - velo_tracks = make_IPselected_tracks() - velo_ut_tracks = make_upstream_tracks(velo_tracks) +def make_tracks_with_muonmatch_ipcut(IPcut, PTcut): + velo_tracks = make_velo_tracks() + pvs = make_pvs() #make_pvs make method better + ipselected_tracks = make_IPselected_tracks(velo_tracks, pvs, IPcut) + with VeloUTTracking.bind(minPT = PTcut, minPTFinal = PTcut ): + velo_ut_tracks = make_upstream_tracks(ipselected_tracks) muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) - forward_tracks = make_forward_tracks(muon_match_tracks) + + with SciFiTrackForwarding.bind(MinPt=PTcut, PreSelectionPT=0., PropertiesPrint = True ): + forward_tracks = make_forward_tracks(muon_match_tracks) return { "Velo": velo_tracks, "Upstream": velo_ut_tracks, diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py index 071219a4a0e..78ceaa99c66 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py @@ -44,6 +44,7 @@ from PyConf.Algorithms import ( TrackBeamLineVertexFinderSoA, SciFiTrackForwardingStoreHit, VeloKalman, + PrFilterIPSoA, createODIN, LHCb__MDF__IOAlg, ) @@ -145,13 +146,6 @@ def make_velo_tracks(make_velo_pr_tracks=make_velo_tracks_simdly, -@configurable -def make_IPselected_tracks(make_tracks=make_velo_tracks, - make_pvs=make_pvs, - ip_cut=0.1 * mm): - ip_selected_tracks = PrFilterIP( IPcut=ip_cut, Input=make_tracks(), InputVertices=make_pvs()).Output - return {"Pr" : ip_selected_tracks} - @configurable def make_pvs_tblv(velo_tracks): return TrackBeamLineVertexFinderSoA( -- GitLab From 6c16203d881db39e39a17a3a89db006dfc78cd7c Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Tue, 13 Aug 2019 00:06:39 +0200 Subject: [PATCH 06/14] Add low pt muon line --- .../python/Hlt1Conf/lines/low_pt_muon.py | 69 ++++++++++++++ Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 68 -------------- .../python/RecoConf/hlt1_muonmatch.py | 93 +++++++++++++++++++ 3 files changed, 162 insertions(+), 68 deletions(-) create mode 100644 Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py create mode 100644 Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py new file mode 100644 index 00000000000..304ac8be98c --- /dev/null +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -0,0 +1,69 @@ +############################################################################### +# (c) Copyright 2019 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. # +############################################################################### +from __future__ import absolute_import, division, print_function +import math +from GaudiKernel.SystemOfUnits import GeV, MeV, mm +from PyConf import configurable +from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, + make_odin, make_hlt1_tracks, + make_velokalman_fitted_tracks, + ) +from RecoConf.hlt1_muonid import (make_tracks_with_muon_id, + ) + +from RecoConf.hlt1_muonmatch import (make_tracks_with_muonmatch_ipcut, + ) +from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMuonID, + ) + +from PyConf.Algorithms import FTRawBankDecoder + + +def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): + make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt) + tracks = make_velokalman_fitted_tracks(make_tracks) + tracks_with_muon_id = make_tracks_with_muon_id(tracks) + return tracks, tracks_with_muon_id + +@configurable +def prefilters(make_pvs=make_pvs): + return [require_gec(), require_pvs(make_pvs())] + + + +@configurable +def detached_low_pt_muon_line( + make_input_tracks=make_fitted_tracks_with_muon_id, + make_pvs=make_pvs, + velo_track_min_ip = 4.*mm, + tracking_min_pt = 80.*MeV, + max_chi2dof=2.5, + min_pt=80.0 * MeV, + min_ipchi2=7.4, + ): + pvs = make_pvs().location + #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON + from Functors import ISMUON, PT + from Functors.math import in_range, log + pre_sel = (ISMUON) & (PT > min_pt) + # hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) + # bulk_sel = in_range(min_pt, PT, max_pt) & ( + # log(MINIPCHI2(pvs)) > + # (param1 / ((PT / GeV - param2)**2) + + # (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) + full_sel = pre_sel + tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, tracking_min_pt) + track_filter = SOAFilterTracksWithMuonID( + full_sel, + Input=tracks_with_muon_id, + InputSelection = tracks["v2ZipSel"] + ) + return prefilters() + [track_filter] diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index cb6223c89e7..f15764807d4 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -15,13 +15,6 @@ from PyConf.Algorithms import ( MuonRawToHits, MuonIDHlt1Alg, MakeView__Track_v2__MuonID, - SOAFilter__TrackWithMuonIDView, - MuonMatchVeloUTSoA, - TracksVPConverter, - TracksUTConverter, - LHCb__Converters__Track__v1__fromV2TrackV1Track as FromV2TrackV1Track, - PrFilterIPSoA, - SciFiTrackForwarding, ) from hlt1_tracking import ( @@ -55,64 +48,3 @@ def make_tracks_with_muon_id(tracks, InputTracks = tracks["v2Zip"], InputMuonIDs = muon_ids).Output - -@configurable -def make_IPselected_tracks(tracks, - pvs, - ip_cut, - make_velo_hits = make_velo_hits): - output_tracks = PrFilterIPSoA(IPcut=ip_cut, Input=tracks["Pr"], InputVertices=pvs).Output - output_tracks_v2 = TracksVPConverter(TracksLocation=output_tracks, HitsLocation = make_velo_hits() ).OutputTracksLocation - output_tracks_v1 = FromV2TrackV1Track( - InputTracksName=output_tracks_v2).OutputTracksName - - return {"Pr" : output_tracks, - "v2" : output_tracks_v2, - "v1" : output_tracks_v1} - -@configurable -def make_muon_match_tracks(tracks, - make_muon_hits = make_muon_hits): - - muon_match_tracks= MuonMatchVeloUTSoA( InputTracks = tracks["Pr"], - InputMuonHits = make_muon_hits()).OutputTracks - muon_match_tracks_v2 = TracksUTConverter( TracksVPLocation = tracks["v2"], - TracksUTLocation = muon_match_tracks).OutputTracksLocation - - muon_match_tracks_v1 = FromV2TrackV1Track( InputTracksName=muon_match_tracks_v2).OutputTracksName - - return { - "Pr": muon_match_tracks, - "v2": muon_match_tracks_v2, - "v1": muon_match_tracks_v1 - } - - -def make_tracks_with_muonmatch(): - velo_tracks = make_velo_tracks() - velo_ut_tracks = make_upstream_tracks(velo_tracks) - muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) - forward_tracks = make_forward_tracks(muon_match_tracks) - return { - "Velo": velo_tracks, - "Upstream": velo_ut_tracks, - "MuonMatch" : muon_match_tracks, - "Forward": forward_tracks, - } - -def make_tracks_with_muonmatch_ipcut(IPcut, PTcut): - velo_tracks = make_velo_tracks() - pvs = make_pvs() #make_pvs make method better - ipselected_tracks = make_IPselected_tracks(velo_tracks, pvs, IPcut) - with VeloUTTracking.bind(minPT = PTcut, minPTFinal = PTcut ): - velo_ut_tracks = make_upstream_tracks(ipselected_tracks) - muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) - - with SciFiTrackForwarding.bind(MinPt=PTcut, PreSelectionPT=0., PropertiesPrint = True ): - forward_tracks = make_forward_tracks(muon_match_tracks) - return { - "Velo": velo_tracks, - "Upstream": velo_ut_tracks, - "MuonMatch" : muon_match_tracks, - "Forward": forward_tracks, - } diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py new file mode 100644 index 00000000000..5a2feaddf97 --- /dev/null +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py @@ -0,0 +1,93 @@ +############################################################################### +# (c) Copyright 2019 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. # +############################################################################### +from PyConf import configurable + +# all trivial (not changing default) and fully datahandly imports can be done from here +from PyConf.Algorithms import ( + MuonMatchVeloUTSoA, + TracksVPConverter, + TracksUTConverter, + LHCb__Converters__Track__v1__fromV2TrackV1Track as FromV2TrackV1Track, + PrFilterIPSoA, + SciFiTrackForwarding, +) + +from hlt1_tracking import ( + make_velo_hits, + make_velo_tracks, + make_pvs, + make_upstream_tracks, + make_forward_tracks, + VeloUTTracking, +) + +from hlt1_muonid import ( + make_muon_hits, +) + +@configurable +def make_IPselected_tracks(tracks, + pvs, + ip_cut, + make_velo_hits = make_velo_hits): + output_tracks = PrFilterIPSoA(IPcut=ip_cut, Input=tracks["Pr"], InputVertices=pvs).Output + output_tracks_v2 = TracksVPConverter(TracksLocation=output_tracks, HitsLocation = make_velo_hits() ).OutputTracksLocation + output_tracks_v1 = FromV2TrackV1Track( + InputTracksName=output_tracks_v2).OutputTracksName + + return {"Pr" : output_tracks, + "v2" : output_tracks_v2, + "v1" : output_tracks_v1} + +@configurable +def make_muon_match_tracks(tracks, + make_muon_hits = make_muon_hits): + muon_match_tracks= MuonMatchVeloUTSoA( InputTracks = tracks["Pr"], + InputMuonHits = make_muon_hits()).OutputTracks + muon_match_tracks_v2 = TracksUTConverter( TracksVPLocation = tracks["v2"], + TracksUTLocation = muon_match_tracks).OutputTracksLocation + + muon_match_tracks_v1 = FromV2TrackV1Track( InputTracksName=muon_match_tracks_v2).OutputTracksName + + return { + "Pr": muon_match_tracks, + "v2": muon_match_tracks_v2, + "v1": muon_match_tracks_v1 + } + +def make_tracks_with_muonmatch(): + velo_tracks = make_velo_tracks() + velo_ut_tracks = make_upstream_tracks(velo_tracks) + muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + forward_tracks = make_forward_tracks(muon_match_tracks) + return { + "Velo": velo_tracks, + "Upstream": velo_ut_tracks, + "MuonMatch" : muon_match_tracks, + "Forward": forward_tracks, + } + +def make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt): + velo_tracks = make_velo_tracks() + pvs = make_pvs() #make_pvs make method better + ipselected_tracks = make_IPselected_tracks(velo_tracks, pvs, velo_track_min_ip) + with VeloUTTracking.bind(minPT = tracking_min_pt, minPTFinal = tracking_min_pt ): + velo_ut_tracks = make_upstream_tracks(ipselected_tracks) + muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + + with SciFiTrackForwarding.bind(MinPt=tracking_min_pt, PreSelectionPT=0.): + forward_tracks = make_forward_tracks(muon_match_tracks) + return { + "Velo": velo_tracks, + "Upstream": velo_ut_tracks, + "MuonMatch" : muon_match_tracks, + "Forward": forward_tracks, + } -- GitLab From d5914292c1b5ca4fbf5712ac13fb396ca63cbc7c Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Tue, 13 Aug 2019 08:42:28 +0200 Subject: [PATCH 07/14] Make low pt muon line run --- Hlt/Hlt1Conf/options/hlt1_example.py | 2 ++ .../python/Hlt1Conf/lines/low_pt_muon.py | 31 +++++++++---------- .../python/RecoConf/hlt1_muonmatch.py | 1 + 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/Hlt/Hlt1Conf/options/hlt1_example.py b/Hlt/Hlt1Conf/options/hlt1_example.py index f1e065ffcb9..5c395d03eb5 100644 --- a/Hlt/Hlt1Conf/options/hlt1_example.py +++ b/Hlt/Hlt1Conf/options/hlt1_example.py @@ -14,6 +14,7 @@ from RecoConf.hlt1_tracking import require_gec from Hlt1Conf.lines.track_mva import (one_track_mva_line, two_track_mva_line, debug_two_track_mva_line) from Hlt1Conf.lines.track_muon import (one_track_muon_mva_line) +from Hlt1Conf.lines.low_pt_muon import (detached_low_pt_muon_line) ftdec_v = 4 env = EverythingHandler( @@ -27,6 +28,7 @@ with FTRawBankDecoder.bind(DecodingVersion=ftdec_v), \ 'Hlt1TwoTrackMVALine': two_track_mva_line, 'Hlt1DebugTwoTrackMVALine': debug_two_track_mva_line, 'Hlt1TrackMuonMVALine': one_track_muon_mva_line, + 'Hlt1LowPtMuonLine': detached_low_pt_muon_line, } for name, builder in builders.items(): env.registerLine(name, builder()) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index 304ac8be98c..e303a7b1133 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -15,6 +15,7 @@ from PyConf import configurable from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_odin, make_hlt1_tracks, make_velokalman_fitted_tracks, + EmptyFilter, ) from RecoConf.hlt1_muonid import (make_tracks_with_muon_id, ) @@ -26,13 +27,15 @@ from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMu from PyConf.Algorithms import FTRawBankDecoder - def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt) tracks = make_velokalman_fitted_tracks(make_tracks) tracks_with_muon_id = make_tracks_with_muon_id(tracks) return tracks, tracks_with_muon_id +def require_forward_tracks(tracks): + return EmptyFilter(name='require_forward_tracks', InputLocation=tracks) + @configurable def prefilters(make_pvs=make_pvs): return [require_gec(), require_pvs(make_pvs())] @@ -41,29 +44,25 @@ def prefilters(make_pvs=make_pvs): @configurable def detached_low_pt_muon_line( - make_input_tracks=make_fitted_tracks_with_muon_id, - make_pvs=make_pvs, + make_input_tracks = make_fitted_tracks_with_muon_id, + make_pvs = make_pvs, velo_track_min_ip = 4.*mm, tracking_min_pt = 80.*MeV, - max_chi2dof=2.5, - min_pt=80.0 * MeV, - min_ipchi2=7.4, + max_chi2dof = 2.5, + min_pt = 80.0 * MeV, + min_ipchi2 = 7.4, ): pvs = make_pvs().location #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON - from Functors import ISMUON, PT - from Functors.math import in_range, log - pre_sel = (ISMUON) & (PT > min_pt) - # hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) - # bulk_sel = in_range(min_pt, PT, max_pt) & ( - # log(MINIPCHI2(pvs)) > - # (param1 / ((PT / GeV - param2)**2) + - # (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) + from Functors import ISMUON, PT, MINIPCHI2CUT + pre_sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) full_sel = pre_sel tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, tracking_min_pt) - track_filter = SOAFilterTracksWithMuonID( + # Filter avoids running converters + require_tracks = require_forward_tracks(tracks["Pr"]) + trackmuon_filter = SOAFilterTracksWithMuonID( full_sel, Input=tracks_with_muon_id, InputSelection = tracks["v2ZipSel"] ) - return prefilters() + [track_filter] + return prefilters() + [require_tracks, trackmuon_filter] diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py index 5a2feaddf97..cc01ddd0799 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py @@ -75,6 +75,7 @@ def make_tracks_with_muonmatch(): "Forward": forward_tracks, } + def make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt): velo_tracks = make_velo_tracks() pvs = make_pvs() #make_pvs make method better -- GitLab From c51c760f6afaf4158b53e744f391a8d71397dae6 Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Tue, 13 Aug 2019 21:53:38 +0200 Subject: [PATCH 08/14] Some clean-up --- .../python/Hlt1Conf/lines/low_pt_muon.py | 8 +++--- .../python/Hlt1Conf/lines/track_muon.py | 25 ++++++++++--------- Hlt/RecoConf/options/hlt1_reco_baseline.py | 19 ++++---------- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 4 +-- 4 files changed, 24 insertions(+), 32 deletions(-) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index e303a7b1133..0b2a466629a 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -17,8 +17,9 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_velokalman_fitted_tracks, EmptyFilter, ) -from RecoConf.hlt1_muonid import (make_tracks_with_muon_id, - ) +from RecoConf.hlt1_muonid import (make_muon_id, + make_tracks_with_muon_id, + ) from RecoConf.hlt1_muonmatch import (make_tracks_with_muonmatch_ipcut, ) @@ -30,7 +31,8 @@ from PyConf.Algorithms import FTRawBankDecoder def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt) tracks = make_velokalman_fitted_tracks(make_tracks) - tracks_with_muon_id = make_tracks_with_muon_id(tracks) + muon_ids = make_muon_id(tracks) + tracks_with_muon_id = make_tracks_with_muon_id(tracks, muon_ids) return tracks, tracks_with_muon_id def require_forward_tracks(tracks): diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py index e2859c4ae2d..a401019f8f0 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py @@ -16,8 +16,9 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_odin, make_hlt1_tracks, make_velokalman_fitted_tracks, ) -from RecoConf.hlt1_muonid import (make_tracks_with_muon_id, - ) +from RecoConf.hlt1_muonid import (make_muon_id, + make_tracks_with_muon_id, + ) from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMuonID, ) @@ -27,7 +28,8 @@ from PyConf.Algorithms import FTRawBankDecoder def make_fitted_tracks_with_muon_id(): tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) - tracks_with_muon_id = make_tracks_with_muon_id(tracks) + muon_ids = make_muon_id(tracks) + tracks_with_muon_id = make_tracks_with_muon_id(tracks, muon_ids) return tracks, tracks_with_muon_id @configurable @@ -49,16 +51,15 @@ def one_track_muon_mva_line( param2=2.0, param3=1.248): pvs = make_pvs().location - #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON - from Functors import ISMUON, PT + from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON from Functors.math import in_range, log - pre_sel = (ISMUON) & (PT > min_pt) - # hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) - # bulk_sel = in_range(min_pt, PT, max_pt) & ( - # log(MINIPCHI2(pvs)) > - # (param1 / ((PT / GeV - param2)**2) + - # (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) - full_sel = pre_sel + pre_sel = (ISMUON) & (PT > min_pt) & (CHI2DOF < max_chi2dof) + hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) + bulk_sel = in_range(min_pt, PT, max_pt) & ( + log(MINIPCHI2(pvs)) > + (param1 / ((PT / GeV - param2)**2) + + (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) + full_sel = pre_sel & (hard_sel | bulk_sel) tracks, tracks_with_muon_id = make_input_tracks() track_filter = SOAFilterTracksWithMuonID( full_sel, diff --git a/Hlt/RecoConf/options/hlt1_reco_baseline.py b/Hlt/RecoConf/options/hlt1_reco_baseline.py index 88b0b5ac791..dc388234876 100644 --- a/Hlt/RecoConf/options/hlt1_reco_baseline.py +++ b/Hlt/RecoConf/options/hlt1_reco_baseline.py @@ -15,9 +15,8 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, from RecoConf.hlt1_muonid import (make_muon_hits, make_muon_id, make_tracks_with_muon_id, - make_tracks_with_muonmatch, - make_tracks_with_muonmatch_ipcut, - ) + ) + from Hlt1Conf.algorithms import (SOAFilterTracksWithMuonID) from PyConf.Algorithms import FTRawBankDecoder @@ -34,17 +33,9 @@ def hlt1_full_track_reco_line(): gec = require_gec(FTDecodingVersion=ftdec_v) NoPVFilter = require_pvs(make_pvs()) fitted_tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) - muon_id = make_muon_id(fitted_tracks) - tracks_with_muon_id = make_tracks_with_muon_id(fitted_tracks) - #tracks_with_muonmatch = make_tracks_with_muonmatch()["Forward"]["Pr"] - tracks_with_muonmatch_ipcut = make_tracks_with_muonmatch_ipcut(4*mm, 80.)["Forward"]["Pr"] - from Functors import ISMUON, PT - track_filter = SOAFilterTracksWithMuonID( - ISMUON & (PT > 0.75 * GeV ), - Input=tracks_with_muon_id, - InputSelection=fitted_tracks["v2ZipSel"] - ) - return [gec, NoPVFilter, tracks_with_muon_id, track_filter, tracks_with_muonmatch_ipcut] + muon_ids = make_muon_id(fitted_tracks) + tracks_with_muon_id = make_tracks_with_muon_id(fitted_tracks, muon_ids) + return [gec, NoPVFilter, fitted_tracks["Pr"], tracks_with_muon_id] env = EverythingHandler( diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index f15764807d4..f9c93a8e823 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -40,10 +40,8 @@ def make_muon_id(tracks, return MuonIDHlt1Alg(InputTracks=tracks["v2Zip"], InputMuonHits=make_muon_hits()).OutputMuonPID -@configurable def make_tracks_with_muon_id(tracks, - make_muon_id=make_muon_id): - muon_ids = make_muon_id(tracks) + muon_ids): return MakeView__Track_v2__MuonID( InputTracks = tracks["v2Zip"], InputMuonIDs = muon_ids).Output -- GitLab From 3bc376f9157ec9e3f8949b0d6a83f7402bda6800 Mon Sep 17 00:00:00 2001 From: Gitlab CI Date: Tue, 13 Aug 2019 19:54:15 +0000 Subject: [PATCH 09/14] Fixed formatting patch generated by https://gitlab.cern.ch/lhcb/Moore/-/jobs/5154751 --- Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py | 1 + .../python/Hlt1Conf/lines/low_pt_muon.py | 66 +++++++++++-------- .../python/Hlt1Conf/lines/track_muon.py | 40 ++++++----- Hlt/RecoConf/options/hlt1_reco_baseline.py | 10 +-- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 17 ++--- .../python/RecoConf/hlt1_muonmatch.py | 57 +++++++++------- Hlt/RecoConf/python/RecoConf/hlt1_tracking.py | 10 +-- 7 files changed, 111 insertions(+), 90 deletions(-) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py b/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py index 8ce50d963e8..766f416e693 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/algorithms.py @@ -86,6 +86,7 @@ def PrFilterV2Tracks(functor, **kwargs): Factory='FunctorFactory', **kwargs) + @configurable def SOAFilterTracksWithMuonID(functor, **kwargs): return Algorithm( diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index 0b2a466629a..651ab31b3b6 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -12,59 +12,69 @@ from __future__ import absolute_import, division, print_function import math from GaudiKernel.SystemOfUnits import GeV, MeV, mm from PyConf import configurable -from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, - make_odin, make_hlt1_tracks, - make_velokalman_fitted_tracks, - EmptyFilter, - ) -from RecoConf.hlt1_muonid import (make_muon_id, - make_tracks_with_muon_id, - ) +from RecoConf.hlt1_tracking import ( + require_gec, + require_pvs, + make_pvs, + make_odin, + make_hlt1_tracks, + make_velokalman_fitted_tracks, + EmptyFilter, +) +from RecoConf.hlt1_muonid import ( + make_muon_id, + make_tracks_with_muon_id, +) -from RecoConf.hlt1_muonmatch import (make_tracks_with_muonmatch_ipcut, - ) -from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMuonID, - ) +from RecoConf.hlt1_muonmatch import ( + make_tracks_with_muonmatch_ipcut, ) +from ..algorithms import ( + CombineTracks, + PrFilterV2Tracks, + SOAFilterTracksWithMuonID, +) from PyConf.Algorithms import FTRawBankDecoder + def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): - make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt) + make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, + tracking_min_pt) tracks = make_velokalman_fitted_tracks(make_tracks) muon_ids = make_muon_id(tracks) tracks_with_muon_id = make_tracks_with_muon_id(tracks, muon_ids) return tracks, tracks_with_muon_id + def require_forward_tracks(tracks): return EmptyFilter(name='require_forward_tracks', InputLocation=tracks) + @configurable def prefilters(make_pvs=make_pvs): return [require_gec(), require_pvs(make_pvs())] - @configurable def detached_low_pt_muon_line( - make_input_tracks = make_fitted_tracks_with_muon_id, - make_pvs = make_pvs, - velo_track_min_ip = 4.*mm, - tracking_min_pt = 80.*MeV, - max_chi2dof = 2.5, - min_pt = 80.0 * MeV, - min_ipchi2 = 7.4, - ): + make_input_tracks=make_fitted_tracks_with_muon_id, + make_pvs=make_pvs, + velo_track_min_ip=4. * mm, + tracking_min_pt=80. * MeV, + max_chi2dof=2.5, + min_pt=80.0 * MeV, + min_ipchi2=7.4, +): pvs = make_pvs().location #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON from Functors import ISMUON, PT, MINIPCHI2CUT - pre_sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) + pre_sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT( + IPChi2Cut=min_ipchi2, Vertices=pvs) full_sel = pre_sel - tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, tracking_min_pt) + tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, + tracking_min_pt) # Filter avoids running converters require_tracks = require_forward_tracks(tracks["Pr"]) trackmuon_filter = SOAFilterTracksWithMuonID( - full_sel, - Input=tracks_with_muon_id, - InputSelection = tracks["v2ZipSel"] - ) + full_sel, Input=tracks_with_muon_id, InputSelection=tracks["v2ZipSel"]) return prefilters() + [require_tracks, trackmuon_filter] diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py index a401019f8f0..9bcdb5be040 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py @@ -12,32 +12,39 @@ from __future__ import absolute_import, division, print_function import math from GaudiKernel.SystemOfUnits import GeV from PyConf import configurable -from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, - make_odin, make_hlt1_tracks, - make_velokalman_fitted_tracks, - ) -from RecoConf.hlt1_muonid import (make_muon_id, - make_tracks_with_muon_id, - ) -from ..algorithms import (CombineTracks, PrFilterV2Tracks, SOAFilterTracksWithMuonID, - ) +from RecoConf.hlt1_tracking import ( + require_gec, + require_pvs, + make_pvs, + make_odin, + make_hlt1_tracks, + make_velokalman_fitted_tracks, +) +from RecoConf.hlt1_muonid import ( + make_muon_id, + make_tracks_with_muon_id, +) +from ..algorithms import ( + CombineTracks, + PrFilterV2Tracks, + SOAFilterTracksWithMuonID, +) from PyConf.Algorithms import FTRawBankDecoder - def make_fitted_tracks_with_muon_id(): tracks = make_velokalman_fitted_tracks(make_hlt1_tracks()) muon_ids = make_muon_id(tracks) tracks_with_muon_id = make_tracks_with_muon_id(tracks, muon_ids) return tracks, tracks_with_muon_id + @configurable def track_muon_prefilters(make_pvs=make_pvs): return [require_gec(), require_pvs(make_pvs())] - @configurable def one_track_muon_mva_line( make_input_tracks=make_fitted_tracks_with_muon_id, @@ -56,14 +63,11 @@ def one_track_muon_mva_line( pre_sel = (ISMUON) & (PT > min_pt) & (CHI2DOF < max_chi2dof) hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) bulk_sel = in_range(min_pt, PT, max_pt) & ( - log(MINIPCHI2(pvs)) > - (param1 / ((PT / GeV - param2)**2) + - (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) + log(MINIPCHI2(pvs)) > + (param1 / ((PT / GeV - param2)**2) + + (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) full_sel = pre_sel & (hard_sel | bulk_sel) tracks, tracks_with_muon_id = make_input_tracks() track_filter = SOAFilterTracksWithMuonID( - full_sel, - Input=tracks_with_muon_id, - InputSelection = tracks["v2ZipSel"] - ) + full_sel, Input=tracks_with_muon_id, InputSelection=tracks["v2ZipSel"]) return track_muon_prefilters() + [track_filter] diff --git a/Hlt/RecoConf/options/hlt1_reco_baseline.py b/Hlt/RecoConf/options/hlt1_reco_baseline.py index dc388234876..c22aee71ee2 100644 --- a/Hlt/RecoConf/options/hlt1_reco_baseline.py +++ b/Hlt/RecoConf/options/hlt1_reco_baseline.py @@ -12,10 +12,11 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_hlt1_tracks, make_velokalman_fitted_tracks) -from RecoConf.hlt1_muonid import (make_muon_hits, - make_muon_id, - make_tracks_with_muon_id, - ) +from RecoConf.hlt1_muonid import ( + make_muon_hits, + make_muon_id, + make_tracks_with_muon_id, +) from Hlt1Conf.algorithms import (SOAFilterTracksWithMuonID) @@ -24,7 +25,6 @@ from PyConf.environment import EverythingHandler, setupInputFromTestFileDB from GaudiKernel.SystemOfUnits import mm, GeV - ftdec_v = 4 diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index f9c93a8e823..ec642cb97b8 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -28,21 +28,18 @@ from hlt1_tracking import ( ) - @configurable def make_muon_hits(raw=RawData): return MuonRawToHits(RawEventLocation=raw().RawEvent).HitContainer @configurable -def make_muon_id(tracks, - make_muon_hits=make_muon_hits): - return MuonIDHlt1Alg(InputTracks=tracks["v2Zip"], - InputMuonHits=make_muon_hits()).OutputMuonPID +def make_muon_id(tracks, make_muon_hits=make_muon_hits): + return MuonIDHlt1Alg( + InputTracks=tracks["v2Zip"], + InputMuonHits=make_muon_hits()).OutputMuonPID -def make_tracks_with_muon_id(tracks, - muon_ids): - return MakeView__Track_v2__MuonID( - InputTracks = tracks["v2Zip"], - InputMuonIDs = muon_ids).Output +def make_tracks_with_muon_id(tracks, muon_ids): + return MakeView__Track_v2__MuonID( + InputTracks=tracks["v2Zip"], InputMuonIDs=muon_ids).Output diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py index cc01ddd0799..7cd00cdbdf9 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py @@ -30,32 +30,36 @@ from hlt1_tracking import ( ) from hlt1_muonid import ( - make_muon_hits, -) + make_muon_hits, ) + @configurable -def make_IPselected_tracks(tracks, - pvs, - ip_cut, - make_velo_hits = make_velo_hits): - output_tracks = PrFilterIPSoA(IPcut=ip_cut, Input=tracks["Pr"], InputVertices=pvs).Output - output_tracks_v2 = TracksVPConverter(TracksLocation=output_tracks, HitsLocation = make_velo_hits() ).OutputTracksLocation +def make_IPselected_tracks(tracks, pvs, ip_cut, make_velo_hits=make_velo_hits): + output_tracks = PrFilterIPSoA( + IPcut=ip_cut, Input=tracks["Pr"], InputVertices=pvs).Output + output_tracks_v2 = TracksVPConverter( + TracksLocation=output_tracks, + HitsLocation=make_velo_hits()).OutputTracksLocation output_tracks_v1 = FromV2TrackV1Track( InputTracksName=output_tracks_v2).OutputTracksName - return {"Pr" : output_tracks, - "v2" : output_tracks_v2, - "v1" : output_tracks_v1} + return { + "Pr": output_tracks, + "v2": output_tracks_v2, + "v1": output_tracks_v1 + } + @configurable -def make_muon_match_tracks(tracks, - make_muon_hits = make_muon_hits): - muon_match_tracks= MuonMatchVeloUTSoA( InputTracks = tracks["Pr"], - InputMuonHits = make_muon_hits()).OutputTracks - muon_match_tracks_v2 = TracksUTConverter( TracksVPLocation = tracks["v2"], - TracksUTLocation = muon_match_tracks).OutputTracksLocation +def make_muon_match_tracks(tracks, make_muon_hits=make_muon_hits): + muon_match_tracks = MuonMatchVeloUTSoA( + InputTracks=tracks["Pr"], InputMuonHits=make_muon_hits()).OutputTracks + muon_match_tracks_v2 = TracksUTConverter( + TracksVPLocation=tracks["v2"], + TracksUTLocation=muon_match_tracks).OutputTracksLocation - muon_match_tracks_v1 = FromV2TrackV1Track( InputTracksName=muon_match_tracks_v2).OutputTracksName + muon_match_tracks_v1 = FromV2TrackV1Track( + InputTracksName=muon_match_tracks_v2).OutputTracksName return { "Pr": muon_match_tracks, @@ -63,32 +67,35 @@ def make_muon_match_tracks(tracks, "v1": muon_match_tracks_v1 } + def make_tracks_with_muonmatch(): velo_tracks = make_velo_tracks() velo_ut_tracks = make_upstream_tracks(velo_tracks) - muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + muon_match_tracks = make_muon_match_tracks(velo_ut_tracks) forward_tracks = make_forward_tracks(muon_match_tracks) return { "Velo": velo_tracks, "Upstream": velo_ut_tracks, - "MuonMatch" : muon_match_tracks, + "MuonMatch": muon_match_tracks, "Forward": forward_tracks, } def make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt): velo_tracks = make_velo_tracks() - pvs = make_pvs() #make_pvs make method better - ipselected_tracks = make_IPselected_tracks(velo_tracks, pvs, velo_track_min_ip) - with VeloUTTracking.bind(minPT = tracking_min_pt, minPTFinal = tracking_min_pt ): + pvs = make_pvs() #make_pvs make method better + ipselected_tracks = make_IPselected_tracks(velo_tracks, pvs, + velo_track_min_ip) + with VeloUTTracking.bind( + minPT=tracking_min_pt, minPTFinal=tracking_min_pt): velo_ut_tracks = make_upstream_tracks(ipselected_tracks) - muon_match_tracks=make_muon_match_tracks(velo_ut_tracks) + muon_match_tracks = make_muon_match_tracks(velo_ut_tracks) with SciFiTrackForwarding.bind(MinPt=tracking_min_pt, PreSelectionPT=0.): forward_tracks = make_forward_tracks(muon_match_tracks) return { "Velo": velo_tracks, "Upstream": velo_ut_tracks, - "MuonMatch" : muon_match_tracks, + "MuonMatch": muon_match_tracks, "Forward": forward_tracks, } diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py index 78ceaa99c66..e885c5eb3cb 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py @@ -145,7 +145,6 @@ def make_velo_tracks(make_velo_pr_tracks=make_velo_tracks_simdly, } - @configurable def make_pvs_tblv(velo_tracks): return TrackBeamLineVertexFinderSoA( @@ -225,7 +224,8 @@ def make_forward_tracks( TracksFTLocation=forward_tracks_pr).OutputTracksLocation forward_tracks_v1 = FromV2TrackV1Track( InputTracksName=forward_tracks_v2).OutputTracksName - forward_tracks_v2_zip = MakeZipContainer__Track_v2(Input=forward_tracks_v2).OutputSelection + forward_tracks_v2_zip = MakeZipContainer__Track_v2( + Input=forward_tracks_v2).OutputSelection return { "Pr": forward_tracks_pr, "v2": forward_tracks_v2, @@ -251,8 +251,10 @@ def make_velokalman_fitted_tracks(tracks, make_hits=make_velo_hits): Input=FromV2TrackV1TrackVector( InputTracksName=fitted_tracks_v2).OutputTracksName) fitted_tracks_v2_sel = TrackV2Selection(Input=fitted_tracks_v2).Output - fitted_tracks_v2_zip_sel = MakeZipContainer__Track_v2(Input=fitted_tracks_v2).OutputSelection - fitted_tracks_v2_zip = MakeZipContainer__Track_v2(Input=fitted_tracks_v2).OutputData + fitted_tracks_v2_zip_sel = MakeZipContainer__Track_v2( + Input=fitted_tracks_v2).OutputSelection + fitted_tracks_v2_zip = MakeZipContainer__Track_v2( + Input=fitted_tracks_v2).OutputData return { "Pr": fitted_tracks, "v2": fitted_tracks_v2, -- GitLab From 608e2f6ee684f059f348661089fc481fe43e7807 Mon Sep 17 00:00:00 2001 From: Alex Pearce Date: Wed, 21 Aug 2019 15:30:25 +0200 Subject: [PATCH 10/14] Tidy up. Remove unused imports, move imports to top of module. --- .../python/Hlt1Conf/lines/low_pt_muon.py | 23 +++++-------------- .../python/Hlt1Conf/lines/track_muon.py | 16 ++++--------- .../python/Hlt1Conf/lines/track_mva.py | 2 +- Hlt/RecoConf/options/hlt1_reco_baseline.py | 5 ---- Hlt/RecoConf/python/RecoConf/hlt1_muonid.py | 11 +-------- .../python/RecoConf/hlt1_muonmatch.py | 1 - Hlt/RecoConf/python/RecoConf/hlt1_tracking.py | 9 +++----- 7 files changed, 16 insertions(+), 51 deletions(-) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index 651ab31b3b6..487e98b254b 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -9,15 +9,12 @@ # or submit itself to any jurisdiction. # ############################################################################### from __future__ import absolute_import, division, print_function -import math -from GaudiKernel.SystemOfUnits import GeV, MeV, mm +from GaudiKernel.SystemOfUnits import MeV, mm from PyConf import configurable from RecoConf.hlt1_tracking import ( require_gec, require_pvs, make_pvs, - make_odin, - make_hlt1_tracks, make_velokalman_fitted_tracks, EmptyFilter, ) @@ -26,15 +23,10 @@ from RecoConf.hlt1_muonid import ( make_tracks_with_muon_id, ) -from RecoConf.hlt1_muonmatch import ( - make_tracks_with_muonmatch_ipcut, ) -from ..algorithms import ( - CombineTracks, - PrFilterV2Tracks, - SOAFilterTracksWithMuonID, -) +from RecoConf.hlt1_muonmatch import make_tracks_with_muonmatch_ipcut +from ..algorithms import SOAFilterTracksWithMuonID -from PyConf.Algorithms import FTRawBankDecoder +from Functors import ISMUON, PT, MINIPCHI2CUT def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): @@ -66,15 +58,12 @@ def detached_low_pt_muon_line( min_ipchi2=7.4, ): pvs = make_pvs().location - #from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON - from Functors import ISMUON, PT, MINIPCHI2CUT - pre_sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT( + sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT( IPChi2Cut=min_ipchi2, Vertices=pvs) - full_sel = pre_sel tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, tracking_min_pt) # Filter avoids running converters require_tracks = require_forward_tracks(tracks["Pr"]) trackmuon_filter = SOAFilterTracksWithMuonID( - full_sel, Input=tracks_with_muon_id, InputSelection=tracks["v2ZipSel"]) + sel, Input=tracks_with_muon_id, InputSelection=tracks["v2ZipSel"]) return prefilters() + [require_tracks, trackmuon_filter] diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py index 9bcdb5be040..7fb1368ee58 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py @@ -16,7 +16,6 @@ from RecoConf.hlt1_tracking import ( require_gec, require_pvs, make_pvs, - make_odin, make_hlt1_tracks, make_velokalman_fitted_tracks, ) @@ -24,13 +23,10 @@ from RecoConf.hlt1_muonid import ( make_muon_id, make_tracks_with_muon_id, ) -from ..algorithms import ( - CombineTracks, - PrFilterV2Tracks, - SOAFilterTracksWithMuonID, -) +from ..algorithms import SOAFilterTracksWithMuonID -from PyConf.Algorithms import FTRawBankDecoder +from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON +import Functors.math as fmath def make_fitted_tracks_with_muon_id(): @@ -58,12 +54,10 @@ def one_track_muon_mva_line( param2=2.0, param3=1.248): pvs = make_pvs().location - from Functors import PT, CHI2DOF, MINIPCHI2, MINIPCHI2CUT, ISMUON - from Functors.math import in_range, log pre_sel = (ISMUON) & (PT > min_pt) & (CHI2DOF < max_chi2dof) hard_sel = (PT > max_pt) & MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs) - bulk_sel = in_range(min_pt, PT, max_pt) & ( - log(MINIPCHI2(pvs)) > + bulk_sel = fmath.in_range(min_pt, PT, max_pt) & ( + fmath.log(MINIPCHI2(pvs)) > (param1 / ((PT / GeV - param2)**2) + (param3 / max_pt) * (max_pt - PT) + math.log(min_ipchi2))) full_sel = pre_sel & (hard_sel | bulk_sel) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_mva.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_mva.py index fd7309266f4..52044aa3920 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_mva.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_mva.py @@ -17,7 +17,7 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_velokalman_fitted_tracks) from ..algorithms import (CombineTracks, PrFilterV2Tracks, FilterPrFittedForwardTracks) -from PyConf.Algorithms import (FTRawBankDecoder, MakeIterableTracks) +from PyConf.Algorithms import MakeIterableTracks def make_tracks_mva_tracks(): diff --git a/Hlt/RecoConf/options/hlt1_reco_baseline.py b/Hlt/RecoConf/options/hlt1_reco_baseline.py index c22aee71ee2..15958df815d 100644 --- a/Hlt/RecoConf/options/hlt1_reco_baseline.py +++ b/Hlt/RecoConf/options/hlt1_reco_baseline.py @@ -13,18 +13,13 @@ from RecoConf.hlt1_tracking import (require_gec, require_pvs, make_pvs, make_hlt1_tracks, make_velokalman_fitted_tracks) from RecoConf.hlt1_muonid import ( - make_muon_hits, make_muon_id, make_tracks_with_muon_id, ) -from Hlt1Conf.algorithms import (SOAFilterTracksWithMuonID) - from PyConf.Algorithms import FTRawBankDecoder from PyConf.environment import EverythingHandler, setupInputFromTestFileDB -from GaudiKernel.SystemOfUnits import mm, GeV - ftdec_v = 4 diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py index ec642cb97b8..020e950c797 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonid.py @@ -10,22 +10,13 @@ ############################################################################### from PyConf import configurable -# all trivial (not changing default) and fully datahandly imports can be done from here from PyConf.Algorithms import ( MuonRawToHits, MuonIDHlt1Alg, MakeView__Track_v2__MuonID, ) -from hlt1_tracking import ( - RawData, - make_velo_hits, - make_velo_tracks, - make_pvs, - make_upstream_tracks, - make_forward_tracks, - VeloUTTracking, -) +from hlt1_tracking import RawData @configurable diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py index 7cd00cdbdf9..dd4040abd86 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py @@ -10,7 +10,6 @@ ############################################################################### from PyConf import configurable -# all trivial (not changing default) and fully datahandly imports can be done from here from PyConf.Algorithms import ( MuonMatchVeloUTSoA, TracksVPConverter, diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py index e885c5eb3cb..8d1253f8df7 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_tracking.py @@ -22,10 +22,8 @@ from Configurables import ( PrStoreUTHit, VoidFilter, PrVeloUT, - ParameterizedKalmanFit, ) -# all trivial (not changing default) and fully datahandly imports can be done from here from PyConf.Algorithms import ( MakeSelection__Track_v1 as TrackV1Selection, MakeSelection__Track_v2 as TrackV2Selection, @@ -35,7 +33,6 @@ from PyConf.Algorithms import ( MakeZipContainer__Track_v2, FTRawBankDecoder, TracksVPMergerConverter, - TracksVPConverter, TracksUTConverter, TracksFTConverter, TracksFitConverter, @@ -44,12 +41,13 @@ from PyConf.Algorithms import ( TrackBeamLineVertexFinderSoA, SciFiTrackForwardingStoreHit, VeloKalman, - PrFilterIPSoA, createODIN, LHCb__MDF__IOAlg, ) -from GaudiKernel.SystemOfUnits import mm, MeV +from GaudiKernel.SystemOfUnits import MeV + +from Functors import SIZE def __rawdata_transform_outputs(RawEvent): @@ -69,7 +67,6 @@ VeloUTTracking = make_algorithm(PrVeloUT, defaults=dict(minPT=300 * MeV)) def __emptyfilter_input_transform(InputLocation): - from Functors import SIZE fun = SIZE(InputLocation) > 0 return {"Code": fun.code(), "Headers": fun.headers()} -- GitLab From aa21b7fa3fc9b7f01eb854b7ec917d27974f60cd Mon Sep 17 00:00:00 2001 From: Alex Pearce Date: Wed, 21 Aug 2019 15:42:54 +0200 Subject: [PATCH 11/14] Expect some warnings. --- Hlt/Hlt1Conf/tests/qmtest/test_hlt1_example.qmt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/Hlt/Hlt1Conf/tests/qmtest/test_hlt1_example.qmt b/Hlt/Hlt1Conf/tests/qmtest/test_hlt1_example.qmt index ba6e0f6a8de..db38cd71954 100644 --- a/Hlt/Hlt1Conf/tests/qmtest/test_hlt1_example.qmt +++ b/Hlt/Hlt1Conf/tests/qmtest/test_hlt1_example.qmt @@ -29,7 +29,11 @@ HiveDataBrokerSvc().OutputLevel = 5 true -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 0}) +# We expect 12 warnings, 6 of: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +# and 6 of +# MuonIDHlt1Alg#1 WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 12}) # test that at least one event fires import re -- GitLab From 8cefa8613d04a30a0872140e7d5e4aa43016b76b Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Wed, 21 Aug 2019 18:30:05 +0200 Subject: [PATCH 12/14] Fix converter configurationfor VeloUTMuon tracks --- .../python/Hlt1Conf/lines/low_pt_muon.py | 18 ++++++++++-------- Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py | 13 ++++++++----- 2 files changed, 18 insertions(+), 13 deletions(-) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index 487e98b254b..2035f3b4ea3 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -26,16 +26,18 @@ from RecoConf.hlt1_muonid import ( from RecoConf.hlt1_muonmatch import make_tracks_with_muonmatch_ipcut from ..algorithms import SOAFilterTracksWithMuonID -from Functors import ISMUON, PT, MINIPCHI2CUT +from Functors import ISMUON, PT, MINIPCHI2CUT, CHI2DOF def make_fitted_tracks_with_muon_id(velo_track_min_ip, tracking_min_pt): - make_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, - tracking_min_pt) - tracks = make_velokalman_fitted_tracks(make_tracks) - muon_ids = make_muon_id(tracks) - tracks_with_muon_id = make_tracks_with_muon_id(tracks, muon_ids) - return tracks, tracks_with_muon_id + make_all_tracks = make_tracks_with_muonmatch_ipcut(velo_track_min_ip, + tracking_min_pt) + fitted_forward_tracks = make_velokalman_fitted_tracks(make_all_tracks) + muon_ids = make_muon_id(fitted_forward_tracks) + tracks_with_muon_id = make_tracks_with_muon_id(fitted_forward_tracks, + muon_ids) + # The types needed by the Muon filter are a selection and a track container. + return fitted_forward_tracks, tracks_with_muon_id def require_forward_tracks(tracks): @@ -59,7 +61,7 @@ def detached_low_pt_muon_line( ): pvs = make_pvs().location sel = (ISMUON) & (PT > min_pt) & MINIPCHI2CUT( - IPChi2Cut=min_ipchi2, Vertices=pvs) + IPChi2Cut=min_ipchi2, Vertices=pvs) & (CHI2DOF < max_chi2dof) tracks, tracks_with_muon_id = make_input_tracks(velo_track_min_ip, tracking_min_pt) # Filter avoids running converters diff --git a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py index dd4040abd86..012c769e638 100644 --- a/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py +++ b/Hlt/RecoConf/python/RecoConf/hlt1_muonmatch.py @@ -50,11 +50,14 @@ def make_IPselected_tracks(tracks, pvs, ip_cut, make_velo_hits=make_velo_hits): @configurable -def make_muon_match_tracks(tracks, make_muon_hits=make_muon_hits): +def make_muon_match_tracks(velo_tracks, + upstream_tracks, + make_muon_hits=make_muon_hits): muon_match_tracks = MuonMatchVeloUTSoA( - InputTracks=tracks["Pr"], InputMuonHits=make_muon_hits()).OutputTracks + InputTracks=upstream_tracks["Pr"], + InputMuonHits=make_muon_hits()).OutputTracks muon_match_tracks_v2 = TracksUTConverter( - TracksVPLocation=tracks["v2"], + TracksVPLocation=velo_tracks["v2"], TracksUTLocation=muon_match_tracks).OutputTracksLocation muon_match_tracks_v1 = FromV2TrackV1Track( @@ -70,7 +73,7 @@ def make_muon_match_tracks(tracks, make_muon_hits=make_muon_hits): def make_tracks_with_muonmatch(): velo_tracks = make_velo_tracks() velo_ut_tracks = make_upstream_tracks(velo_tracks) - muon_match_tracks = make_muon_match_tracks(velo_ut_tracks) + muon_match_tracks = make_muon_match_tracks(velo_tracks, velo_ut_tracks) forward_tracks = make_forward_tracks(muon_match_tracks) return { "Velo": velo_tracks, @@ -88,7 +91,7 @@ def make_tracks_with_muonmatch_ipcut(velo_track_min_ip, tracking_min_pt): with VeloUTTracking.bind( minPT=tracking_min_pt, minPTFinal=tracking_min_pt): velo_ut_tracks = make_upstream_tracks(ipselected_tracks) - muon_match_tracks = make_muon_match_tracks(velo_ut_tracks) + muon_match_tracks = make_muon_match_tracks(velo_tracks, velo_ut_tracks) with SciFiTrackForwarding.bind(MinPt=tracking_min_pt, PreSelectionPT=0.): forward_tracks = make_forward_tracks(muon_match_tracks) -- GitLab From 671771bbc1fbab61543c9f762737c1d37404b023 Mon Sep 17 00:00:00 2001 From: Sascha Stahl Date: Wed, 21 Aug 2019 18:34:42 +0200 Subject: [PATCH 13/14] Increase chi2 cut value --- Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py | 2 +- Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py index 2035f3b4ea3..07a006480b6 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/low_pt_muon.py @@ -55,7 +55,7 @@ def detached_low_pt_muon_line( make_pvs=make_pvs, velo_track_min_ip=4. * mm, tracking_min_pt=80. * MeV, - max_chi2dof=2.5, + max_chi2dof=100.0, min_pt=80.0 * MeV, min_ipchi2=7.4, ): diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py index 7fb1368ee58..2cd6a3248c5 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines/track_muon.py @@ -46,7 +46,7 @@ def one_track_muon_mva_line( make_input_tracks=make_fitted_tracks_with_muon_id, make_pvs=make_pvs, # TrackMuonLoose cuts from ZombieMoore to be done - max_chi2dof=2.5, + max_chi2dof=100.0, min_pt=2.0 * GeV, max_pt=26 * GeV, min_ipchi2=7.4, -- GitLab From d947c34da95a8731a2d26ea832dd21622732d5be Mon Sep 17 00:00:00 2001 From: Alex Pearce Date: Wed, 28 Aug 2019 15:49:59 +0200 Subject: [PATCH 14/14] Expect additional warnings. Due to Rec#79. --- Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_read.qmt | 5 ++++- Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_write.qmt | 7 +++++-- Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_read.qmt | 5 ++++- Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_write.qmt | 9 ++++++--- Hlt/RecoConf/tests/qmtest/hlt1_reco_baseline.qmt | 4 +++- 5 files changed, 22 insertions(+), 8 deletions(-) diff --git a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_read.qmt b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_read.qmt index 9e0c830c7b7..e6473e75184 100644 --- a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_read.qmt +++ b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_read.qmt @@ -24,7 +24,10 @@ Run HLT1 on an HLT1-filtered DST file. true -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 0}) +# Expect 12 warnings due to Rec#79, 6 from each muon ID algorithm: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +# MuonIDHlt1Alg#1 WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 12}) import re diff --git a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_write.qmt b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_write.qmt index ae1ce57d241..7f65a384a35 100644 --- a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_write.qmt +++ b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/dst_write.qmt @@ -21,9 +21,12 @@ Run HLT1 and save an DST file. true -# Expect a single WARNING: +# Expect a single WARNING from the data broker: # HiveDataBrokerSvc WARNING non-reentrant algorithm: OutputStream -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 1}) +# and 12 due to Rec#79, 6 from each muon ID algorithm: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +# MuonIDHlt1Alg#1 WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 13}) import re diff --git a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_read.qmt b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_read.qmt index 4ec6eb0c5c0..6004ac1e872 100644 --- a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_read.qmt +++ b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_read.qmt @@ -24,7 +24,10 @@ Run HLT1 on an HLT1-filtered MDF file. true -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 0}) +# Expect 12 warnings due to Rec#79, 6 from each muon ID algorithm: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +# MuonIDHlt1Alg#1 WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 12}) import re diff --git a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_write.qmt b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_write.qmt index c0c7aef99da..89a6b09cbe8 100644 --- a/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_write.qmt +++ b/Hlt/Hlt1Conf/tests/qmtest/persistency.qms/mdf_write.qmt @@ -21,9 +21,12 @@ Run HLT1 and save an MDF file. true -# Expect a single WARNING: -# HiveDataBrokerSvc WARNING non-reentrant algorithm: LHCb::MDFWriter/LHCb__MDFWriter -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 1}) +# Expect a single WARNING from the data broker: +# HiveDataBrokerSvc WARNING non-reentrant algorithm: OutputStream +# and 12 due to Rec#79, 6 from each muon ID algorithm: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +# MuonIDHlt1Alg#1 WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 13}) import re diff --git a/Hlt/RecoConf/tests/qmtest/hlt1_reco_baseline.qmt b/Hlt/RecoConf/tests/qmtest/hlt1_reco_baseline.qmt index 47c35b1225f..241648133b4 100644 --- a/Hlt/RecoConf/tests/qmtest/hlt1_reco_baseline.qmt +++ b/Hlt/RecoConf/tests/qmtest/hlt1_reco_baseline.qmt @@ -26,7 +26,9 @@ HiveDataBrokerSvc().OutputLevel = 5 true -countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 0}) +# Expect 6 warnings due to Rec#79 from the muon ID algorithm: +# MuonIDHlt1Alg WARNING CondDB {X,Y}FOIParameters member size is 20, geometry expects 16 +countErrorLines({"FATAL": 0, "ERROR": 0, "WARNING": 6}) # test that at least one event fires import re -- GitLab