diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/lines.py b/Hlt/Hlt1Conf/python/Hlt1Conf/lines.py index 3e0161217875cd506f15caf35590dc4550356203..4d04043c6219eedaaf0f3c627c7b5ca65833ff59 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/lines.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/lines.py @@ -9,15 +9,11 @@ # or submit itself to any jurisdiction. # ############################################################################### from __future__ import absolute_import, division, print_function -from PyConf.smart import ( - configurable -) +from PyConf.smart import (configurable) from Configurables import ( LHCb__Converters__RecVertex__v2__fromVectorLHCbRecVertex, - LHCb__Converters__Track__v1__fromV2TrackV1Track, - PrFilter__Track_v1, - TrackCombiner -) + LHCb__Converters__Track__v1__fromV2TrackV1Track, PrFilter__Track_v1, + TrackCombiner) from Hlt1Conf.reconstruction import ( make_param_forward_fitted_tracks, @@ -27,8 +23,7 @@ from Hlt1Conf.reconstruction import ( ) from PyConf.core import ( - Algorithm, -) + Algorithm, ) def require_all(*cuts): @@ -54,17 +49,20 @@ def require_any(*cuts): @configurable # cant make this a make_algorithm because the input transform function neeeds the kwargs -def TrackV1FilterWithPVs(Preambulo=[], **kwargs): +def TrackV1FilterWithPVs(Preambulo=[], name="PrFilter__Track_v1", **kwargs): def __transform_inputs(InputVertices, Input): return { "Preambulo": [ # TODO define special case for this preambulo shit # Redefine the functor to include the PV location "TrMINIPCHI2 = TrMINIPCHI2('{}')".format(InputVertices) ] + Preambulo, - "Input": Input + "Input": + Input } + return Algorithm( PrFilter__Track_v1, + name=name, input_transform=__transform_inputs, **kwargs) @@ -77,9 +75,8 @@ def TrackCombinerWithPVs(Preamble=[], **kwargs): # Redefine the functor to include the PV location "TrMINIPCHI2 = TrMINIPCHI2('{}')".format(InputVertices) ] + Preamble, - "InputTracks": InputTracks + "InputTracks": + InputTracks } - return Algorithm( - TrackCombiner, - input_transform=transform_inputs, - **kwargs) + + return Algorithm(TrackCombiner, input_transform=transform_inputs, **kwargs) diff --git a/Hlt/Hlt1Conf/python/Hlt1Conf/reconstruction.py b/Hlt/Hlt1Conf/python/Hlt1Conf/reconstruction.py index 3ff4f9b477ae3e704b09db3d3d2d5d5f53056485..a962b0350b5293d9834984f61ac51ae49e860ce7 100644 --- a/Hlt/Hlt1Conf/python/Hlt1Conf/reconstruction.py +++ b/Hlt/Hlt1Conf/python/Hlt1Conf/reconstruction.py @@ -9,9 +9,7 @@ # or submit itself to any jurisdiction. # ############################################################################### from __future__ import absolute_import, division, print_function -from PyConf.smart import ( - configurable -) +from PyConf.smart import (configurable) from PyConf.core import ( make_algorithm, @@ -20,183 +18,225 @@ from PyConf.core import ( ) from Configurables import ( - VSPClus, - PrPixelTracking, - MakeSelection__Track_v2 as TrackSelection, - PrFilterIP__Track_v2__RecVertex_v2 as PrFilterIP, - PatPV3DFuture, - Gaudi__Hive__FetchDataFromFile, - LHCb__DetDesc__ReserveDetDescForEvent, - LHCb__Tests__FakeEventTimeProducer as DummyEventTime, - FTRawBankDecoder, - VSPClus, - PrGECFilter, - PrStoreUTHit, - PrStoreFTHit, - LoKi__VoidFilter, - PrVeloUT, - PrForwardTracking, - ParameterizedKalmanFit, + TracksVPMergerConverter, TracksVPConverter, TracksUTConverter, + TracksFTConverter, TracksFitConverter, VeloClusterTrackingSIMD, + MakeSelection__Track_v2 as TrackSelection, PrFilterIPSoA as PrFilterIP, + TrackBeamLineVertexFinderSoA, Gaudi__Hive__FetchDataFromFile, + LHCb__DetDesc__ReserveDetDescForEvent, LHCb__Tests__FakeEventTimeProducer + as DummyEventTime, FTRawBankDecoder, VSPClus, PrGECFilter, PrStoreUTHit, + SciFiTrackForwardingStoreHit, LoKi__VoidFilter, PrVeloUT, + SciFiTrackForwarding, ParameterizedKalmanFit, VeloKalman as VeloKalmanAlg, MakeSelection__Track_v1 as TrackV1Selection, LHCb__Converters__Track__v1__fromV2TrackV1Track as fromV2TrackV1Track, - LHCb__Converters__RecVertex__v2__fromVectorLHCbRecVertex as fromVectorLHCbRecVertex -) + LHCb__Converters__Track__v1__fromV2TrackV1TrackVector as + fromV2TrackV1TrackVector, + LHCb__Converters__RecVertex__v2__fromVectorLHCbRecVertex as + fromVectorLHCbRecVertex) from GaudiKernel.SystemOfUnits import mm, GeV, MeV + def __rawdata_transform_outputs(RawEvent): - return { "DataKeys" : [RawEvent] } + return {"DataKeys": [RawEvent]} + -RawData=make_algorithm(Gaudi__Hive__FetchDataFromFile, - outputs={'RawEvent': force_location('/Event/DAQ/RawEvent')}, - output_transform=__rawdata_transform_outputs, - require_IOVLock = False) +RawData = make_algorithm( + Gaudi__Hive__FetchDataFromFile, + outputs={'RawEvent': force_location('/Event/DAQ/RawEvent')}, + output_transform=__rawdata_transform_outputs, + require_IOVLock=False) -VeloClustering = make_algorithm(VSPClus) +VPMergerConverter = make_algorithm(TracksVPMergerConverter) +VPConverter = make_algorithm(TracksVPConverter) +UTConverter = make_algorithm(TracksUTConverter) +FTConverter = make_algorithm(TracksFTConverter) +FitConverter = make_algorithm(TracksFitConverter) SelTrackV1 = make_algorithm(TrackV1Selection) -VeloTracking = make_algorithm( - PrPixelTracking, - defaults=dict( - HardFlagging=True, SkipLoopSens=True, MaxMissedOnTrack=2, MaxMissedConsecutive=1, - PhiWindow=2.5, PhiWindowExtrapolation=2.5, ModulesToSkip=[], EarlyKill3HitTracks=True, - UsePhiPerRegionsForward=False, BoostPhysics=False, AlgoConfig="ForwardThenBackward" - ) - ) +VeloClusterTracking = make_algorithm(VeloClusterTrackingSIMD) -PVFinding = make_algorithm( - PatPV3DFuture, - defaults=dict( - UseBeamSpotRCut=True, - BeamSpotRCut=.6, - minClusterMult=4, - )) +PVFinding = make_algorithm(TrackBeamLineVertexFinderSoA) V2TrackConvV1 = make_algorithm(fromV2TrackV1Track) +V2TrackConvV1Vector = make_algorithm(fromV2TrackV1TrackVector) V2VertexConvV1 = make_algorithm(fromVectorLHCbRecVertex) - -UTDecoding = make_algorithm(PrStoreUTHit, defaults=dict(skipBanksWithErrors=True)) +UTDecoding = make_algorithm( + PrStoreUTHit, defaults=dict(skipBanksWithErrors=True)) FTDecoding = make_algorithm(FTRawBankDecoder) -StoreFT = make_algorithm(PrStoreFTHit) +StoreFT = make_algorithm(SciFiTrackForwardingStoreHit) -VeloUTTracking = make_algorithm(PrVeloUT, defaults=dict(minPT= 300 * MeV)) +VeloUTTracking = make_algorithm(PrVeloUT, defaults=dict(minPT=300 * MeV)) -ForwardTracking = make_algorithm( - PrForwardTracking, - defaults=dict( - MinPT=0.4 * GeV, - Preselection=True, - PreselectionPT=0.3 * GeV, - TolYCollectX=3.5, - TolYSlopeCollectX=0.001, - MaxXWindow=1., - MaxXGap=1., - SecondLoop=True)) +ForwardTracking = make_algorithm(SciFiTrackForwarding) -ParamForwardFit = make_algorithm(ParameterizedKalmanFit, defaults=dict(MaxNumOutlier=2)) +ParamForwardFit = make_algorithm( + ParameterizedKalmanFit, defaults=dict(MaxNumOutlier=2)) + +VeloKalman = make_algorithm(VeloKalmanAlg) SelFromVector = make_algorithm(TrackSelection) FilterIP = make_algorithm(PrFilterIP) + def __emptyfilter_input_transform(InputLocation): - return {"Code" : "SIZE('{}')>0".format(InputLocation)} + return {"Code": "SIZE('{}')>0".format(InputLocation)} + + +EmptyFilter = make_algorithm( + LoKi__VoidFilter, input_transform=__emptyfilter_input_transform) -EmptyFilter = make_algorithm(LoKi__VoidFilter, input_transform = __emptyfilter_input_transform) ### maker functions @configurable def gec(raw=RawData, FTDecodingVersion=None, **kwargs): # TODO use FTDecodingVersion=smart.REQUIRED above cut = 9750 if FTDecodingVersion == 4 else 11000 - props = dict(NumberFTUTClusters=cut, **kwargs) # kwargs take precedence - return Algorithm(PrGECFilter, RawEventLocations = raw().RawEvent, **props) + props = dict(NumberFTUTClusters=cut, **kwargs) # kwargs take precedence + return Algorithm(PrGECFilter, RawEventLocations=raw().RawEvent, **props) -@configurable -def make_velo_clusters(raw = RawData): - return VeloClustering(RawEventLocation=raw().RawEvent).ClusterLocation @configurable -def make_velo_cluster_offsets(raw = RawData): - return VeloClustering(RawEventLocation=raw().RawEvent).ClusterOffsets +def make_velo_hits(raw=RawData): + return VeloClusterTracking(RawEventLocation=raw().RawEvent).HitsLocation -@configurable -def make_velo_tracks(make_clusters=make_velo_clusters, - make_cluster_offsets=make_velo_cluster_offsets, - convertToSelection = True): - clusters = make_clusters() - offsets = make_cluster_offsets() - tracks = VeloTracking(ClusterLocation = clusters, - ClusterOffsets = offsets).OutputTracksName - if not convertToSelection: - return tracks - return SelFromVector(Input = tracks).Output @configurable -def make_keyed_velo_tracks(make_velo_tracks=make_velo_tracks): - return V2TrackConvV1(InputTracksName=make_velo_tracks(convertToSelection=False)).OutputTracksName +def make_velo_tracks(raw=RawData): + return VeloClusterTracking(RawEventLocation=raw().RawEvent).TracksLocation + @configurable -def make_pvs(make_velo_tracks=make_velo_tracks, needConvertedTracks = False): - tracks = make_velo_tracks(convertToSelection = needConvertedTracks) - return PVFinding(InputTracks = tracks, name = "WURST").OutputVerticesName +def make_velo_tracks_backward(raw=RawData): + return VeloClusterTracking( + RawEventLocation=raw().RawEvent).TracksBackwardLocation + @configurable -def make_V1_pvs(make_keyed_velo_tracks=make_keyed_velo_tracks, make_pvs=make_pvs): - return V2VertexConvV1(InputVerticesName=make_pvs(), - InputTracksName=make_keyed_velo_tracks()).OutputVerticesName +def make_pvs(make_velo_tracks=make_velo_tracks, + make_velo_tracks_backward=make_velo_tracks_backward): + forwards = make_velo_tracks() + backwards = make_velo_tracks_backward() + return PVFinding( + TracksLocation=forwards, + TracksBackwardLocation=backwards, + name="TBLVertexFinder").OutputVertices + @configurable def FilterEmptyPVs(make_pvs=make_pvs): return EmptyFilter(InputLocation=make_pvs()) + @configurable -def make_IPselectedTracks(make_tracks=make_velo_tracks, make_pvs=make_pvs, ip_cut=0.1*mm): - return FilterIP(IPcut=ip_cut, - Input=make_tracks(), - InputVertices=make_pvs()).Output +def make_IPselectedTracks(make_tracks=make_velo_tracks, + make_pvs=make_pvs, + ip_cut=0.1 * mm): + return FilterIP( + IPcut=ip_cut, Input=make_tracks(), InputVertices=make_pvs()).Output + @configurable -def make_UT_clusters(raw = RawData): +def make_UT_clusters(raw=RawData): return UTDecoding(RawEventLocations=raw().RawEvent).UTHitsLocation + @configurable def make_VeloUT_tracks(make_velo_tracks=make_IPselectedTracks, - make_ut_clusters=make_UT_clusters, - convertToSelection=True): - ut_tracks = VeloUTTracking(InputTracksName=make_velo_tracks(), - UTHits=make_ut_clusters()).OutputTracksName - if not convertToSelection: - return ut_tracks - return SelFromVector(Input = ut_tracks).Output + make_ut_clusters=make_UT_clusters): + ut_tracks = VeloUTTracking( + InputTracksName=make_velo_tracks(), + UTHits=make_ut_clusters()).OutputTracksName + return ut_tracks + @configurable def make_ft_clusters(raw=RawData): - return FTDecoding(RawEventLocations = raw().RawEvent).OutputLocation + return FTDecoding(RawEventLocations=raw().RawEvent).OutputLocation + @configurable def make_ft_hits(make_ft_clusters=make_ft_clusters): - return StoreFT(InputLocation = make_ft_clusters()).FTHitsLocation + return StoreFT(HitsLocation=make_ft_clusters()).Output + @configurable def make_forward_tracks(make_ft_hits=make_ft_hits, - make_tracks=make_VeloUT_tracks, - make_ut_hits=make_UT_clusters): + make_tracks=make_VeloUT_tracks): + + return ForwardTracking( + HitsLocation=make_ft_hits(), InputTracks=make_tracks()).Output + + +@configurable +def make_trackv2_VP(make_tracks=make_velo_tracks, + make_hits=make_velo_hits, + make_tracks_backward=make_velo_tracks_backward): + tracks = make_tracks() + hits = make_hits() + backwards = make_tracks_backward() + return VPMergerConverter( + TracksForwardLocation=tracks, + TracksBackwardLocation=backwards, + HitsLocation=hits).OutputTracksLocation + + +@configurable +def make_trackv2_VP_IPCut(make_tracks=make_IPselectedTracks, + make_hits=make_velo_hits): + tracks = make_tracks() + hits = make_hits() + return VPConverter( + TracksLocation=tracks, HitsLocation=hits).OutputTracksLocation + + +@configurable +def make_trackv2_UT(make_trackv2_VP=make_trackv2_VP_IPCut, + make_VeloUT_tracks=make_VeloUT_tracks): + tracks_vp = make_trackv2_VP() + ut_tracks = make_VeloUT_tracks() + return UTConverter( + TracksVPLocation=tracks_vp, + TracksUTLocation=ut_tracks).OutputTracksLocation + + +@configurable +def make_trackv2_FT(make_trackv2_UT=make_trackv2_UT, + make_forward_tracks=make_forward_tracks): + tracks_ut = make_trackv2_UT() + tracks_ft = make_forward_tracks() + return FTConverter( + TracksUTLocation=tracks_ut, + TracksFTLocation=tracks_ft).OutputTracksLocation - from PyConf.Tools import PrAddUTHitsTool - uthitstool = PrAddUTHitsTool(UTHitsLocation = make_UT_clusters()) - return ForwardTracking(FTHitsLocation = make_ft_hits(), - InputName = make_tracks(), - AddUTHitsToolName = uthitstool).OutputName - # ).OutputName - # tool is set into a private context here @configurable -def make_param_forward_fitted_tracks(make_tracks=make_forward_tracks, +def make_velokalman_fitted_tracks(make_hits=make_velo_hits, + make_velo_tracks=make_IPselectedTracks, + make_forward_tracks=make_forward_tracks): + return VeloKalman( + HitsLocation=make_hits(), + TracksVPLocation=make_velo_tracks(), + TracksFTLocation=make_forward_tracks()).OutputTracksLocation + + +@configurable +def make_trackv2_fitted( + make_trackv2_FT=make_trackv2_FT, + make_velokalman_fitted_tracks=make_velokalman_fitted_tracks): + tracks_ft = make_trackv2_FT() + tracks_fit = make_velokalman_fitted_tracks() + return FitConverter( + TracksFTLocation=tracks_ft, + TracksFitLocation=tracks_fit).OutputTracksLocation + + +"""@configurable +def make_param_forward_fitted_tracks(make_tracks=make_trackv2_FT, make_velo_clusters=make_velo_clusters, make_ut_clusters=make_UT_clusters, make_ft_clusters=make_ft_clusters, @@ -227,4 +267,11 @@ def make_param_forward_fitted_tracks(make_tracks=make_forward_tracks, # fitted_tracks = ParamForwardFit(InputName = make_tracks()).OutputName if not convertToSelection: return fitted_tracks - return SelTrackV1(Input = fitted_tracks).Output + return SelTrackV1(Input = fitted_tracks).Output""" + + +@configurable +def make_param_forward_fitted_tracks(make_tracks=make_trackv2_fitted): + track_v1 = V2TrackConvV1Vector( + InputTracksName=make_tracks()).OutputTracksName + return SelTrackV1(Input=track_v1).Output