From 9338fc0b35611d9da40b3744eaa2515285c12509 Mon Sep 17 00:00:00 2001 From: abaty Date: Mon, 8 May 2017 19:21:29 +0200 Subject: [PATCH 01/10] First Round of Phase 1 Tracking changes for Heavy Ions --- .../python/Reconstruction_HI_cff.py | 5 + .../HiRegitMuonDetachedTripletStep_cff.py | 15 + .../python/HIPixel3PrimTracks_cfi.py | 72 +++++ RecoHI/HiTracking/python/HiTracking_cff.py | 22 ++ .../python/MergeTrackCollectionsHI_cff.py | 63 ++++- .../python/hiDetachedQuadStep_cff.py | 261 ++++++++++++++++++ .../python/hiDetachedTripletStep_cff.py | 38 ++- .../python/hiHighPtTripletStep_cff.py | 228 +++++++++++++++ .../python/hiJetCoreRegionalStep_cff.py | 23 ++ .../HiTracking/python/hiLowPtQuadStep_cff.py | 261 ++++++++++++++++++ .../python/hiLowPtTripletStep_cff.py | 31 ++- 11 files changed, 1007 insertions(+), 12 deletions(-) create mode 100644 RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py create mode 100644 RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py create mode 100644 RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py diff --git a/RecoHI/Configuration/python/Reconstruction_HI_cff.py b/RecoHI/Configuration/python/Reconstruction_HI_cff.py index 93fc913544eec..b92a991557f5a 100644 --- a/RecoHI/Configuration/python/Reconstruction_HI_cff.py +++ b/RecoHI/Configuration/python/Reconstruction_HI_cff.py @@ -49,6 +49,11 @@ * hcalnoise * muonRecoHighLevelPbPb ) +globalRecoPbPb_wPhase1 = globalRecoPbPb.copy() +globalRecoPbPb_wPhase1.replace(hiTracking_wSplitting, hiTracking_wSplitting_Phase1) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toReplaceWith(globalRecoPbPb, globalRecoPbPb_wPhase1) + globalRecoPbPb_wConformalPixel = cms.Sequence(hiTracking_wConformalPixel * hiParticleFlowLocalReco diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py index 7d37f0ecbc87b..adc79949547e1 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py @@ -29,12 +29,27 @@ from RecoTracker.IterativeTracking.DetachedTripletStep_cff import * # NEW CLUSTERS (remove previously used clusters) +""" +#Problem with this setup is because in pp, the iteration before detachedTriplet is detachedQuadruplets. hiRegitMuDetachedTripletStepClusters = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepClusters.clone( trajectories = cms.InputTag("hiRegitMuPixelLessStepTracks"), overrideTrkQuals = cms.InputTag('hiRegitMuPixelLessStepSelector','hiRegitMuPixelLessStep'), trackClassifier = cms.InputTag(''), TrackQuality = cms.string('tight') ) +""" +from RecoLocalTracker.SubCollectionProducers.trackClusterRemover_cfi import trackClusterRemover as _trackClusterRemover +hiRegitMuDetachedTripletStepClusters = _trackClusterRemover.clone( + maxChi2 = 9.0, + pixelClusters = "siPixelClusters", + stripClusters = "siStripClusters", + trajectories = cms.InputTag("hiRegitMuPixelLessStepTracks"), + overrideTrkQuals = cms.InputTag('hiRegitMuPixelLessStepSelector','hiRegitMuPixelLessStep'), + TrackQuality = 'tight', + trackClassifier = cms.InputTag(''), + minNumberOfLayersWithMeasBeforeFiltering = 0 +) + # SEEDING LAYERS hiRegitMuDetachedTripletStepSeedLayers = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeedLayers.clone() diff --git a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py index 21f0d78aafefe..2ec6c9255c8db 100644 --- a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py +++ b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py @@ -2,6 +2,8 @@ from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * from RecoPixelVertexing.PixelLowPtUtilities.trackCleaner_cfi import * from RecoPixelVertexing.PixelTrackFitting.pixelFitterByHelixProjections_cfi import * @@ -9,6 +11,11 @@ from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * from RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi import * +#from RecoTracker.TkSeedingLayers.seedingLayersEDProducer_cfi import * + +hiPixelLayerQuadruplets = PixelLayerTriplets.clone() +hiPixelLayerQuadruplets.layerList = PixelSeedMergerQuadruplets.layerList + # Hit ntuplets hiPixel3PrimTracksHitDoublets = _hitPairEDProducer.clone( clusterCheck = "", @@ -17,12 +24,67 @@ maxElement = 0, produceIntermediateHitDoublets = True, ) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toModify(hiPixel3PrimTracksHitDoublets, + seedingLayers = "hiPixelLayerQuadruplets" +) + hiPixel3PrimTracksHitTriplets = _pixelTripletHLTEDProducer.clone( doublets = "hiPixel3PrimTracksHitDoublets", maxElement = 1000000, # increase threshold for triplets in generation step (default: 100000) produceSeedingHitSets = True, + produceIntermediateHitTriplets = True, +) + + +# pixelQuadrupletMerger is not in use here. pp use it for trackingPhase1PU70 +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +_hiPixel3PrimTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( + triplets = "hiPixel3PrimTracksHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) +#### + +hiPixel3PrimTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( + triplets = "hiPixel3PrimTracksHitTriplets", + extraHitRZtolerance = hiPixel3PrimTracksHitTriplets.extraHitRZtolerance, + extraHitRPhitolerance = hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 200, value2 = 100, + enabled = True, + ), + extraPhiTolerance = dict( + pt1 = 0.6, pt2 = 1, + value1 = 0.15, value2 = 0.1, + enabled = True, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet +) + +from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer +hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone() +hiPixel3PrimTracksHitDoubletsCA.layerPairs = [0,1,2] + +hiPixel3PrimTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( + doublets = "hiPixel3PrimTracksHitDoubletsCA", + extraHitRPhitolerance = hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, + SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet, + maxChi2 = dict( + pt1 = 0.7, pt2 = 2, + value1 = 200, value2 = 50, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + CAThetaCut = 0.0012, + CAPhiCut = 0.2, +) # Pixel tracks hiPixel3PrimTracks = cms.EDProducer("PixelTrackProducer", @@ -31,6 +93,7 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitTriplets"), + #SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitQuadruplets"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -41,6 +104,9 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) +trackingPhase1QuadProp.toModify(hiPixel3PrimTracks, + SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitQuadrupletsCA"), +) hiPixel3PrimTracksSequence = cms.Sequence( hiTrackingRegionWithVertex + @@ -50,3 +116,9 @@ hiFilter + hiPixel3PrimTracks ) + +#phase 1 changes +hiPixel3PrimTracksSequence_Phase1 = hiPixel3PrimTracksSequence.copy() +hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitDoublets,hiPixelLayerQuadruplets+hiPixel3PrimTracksHitDoubletsCA)#can remove 'CA' to get regular seeds +hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitTriplets,hiPixel3PrimTracksHitTriplets+hiPixel3PrimTracksHitQuadrupletsCA)#can remove 'CA' to get regular seeds +trackingPhase1QuadProp.toReplaceWith(hiPixel3PrimTracksSequence,hiPixel3PrimTracksSequence_Phase1) diff --git a/RecoHI/HiTracking/python/HiTracking_cff.py b/RecoHI/HiTracking/python/HiTracking_cff.py index fec6e3699a422..dccf5328a9e96 100644 --- a/RecoHI/HiTracking/python/HiTracking_cff.py +++ b/RecoHI/HiTracking/python/HiTracking_cff.py @@ -7,6 +7,10 @@ from RecoHI.HiTracking.hiDetachedTripletStep_cff import * from RecoHI.HiTracking.hiJetCoreRegionalStep_cff import * from RecoHI.HiTracking.MergeTrackCollectionsHI_cff import * +from RecoHI.HiTracking.hiLowPtQuadStep_cff import * +from RecoHI.HiTracking.hiHighPtTripletStep_cff import * +from RecoHI.HiTracking.hiDetachedQuadStep_cff import * + from RecoHI.HiMuonAlgos.hiMuonIterativeTk_cff import * @@ -31,6 +35,17 @@ *hiPixelPairStep ) +hiTracking_noRegitMu_wSplitting_Phase1 = cms.Sequence( + hiInitialJetCoreClusterSplitting + *hiBasicTracking + *hiLowPtQuadStep#New iteration + *hiHighPtTripletStep#New iteration + *hiDetachedQuadStep#New iteration + *hiDetachedTripletStep + *hiLowPtTripletStep + *hiPixelPairStep #no CA seeding implemented + ) + hiTracking = cms.Sequence( hiTracking_noRegitMu *hiRegitMuTrackingAndSta @@ -44,6 +59,13 @@ *hiGeneralTracks ) +hiTracking_wSplitting_Phase1 = cms.Sequence( + hiTracking_noRegitMu_wSplitting_Phase1 + *hiJetCoreRegionalStep + *hiRegitMuTrackingAndSta + *hiGeneralTracks + ) + hiTracking_wConformalPixel = cms.Sequence( hiTracking *hiMergedConformalPixelTracking diff --git a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py index d1aecf846f551..14ccbc79a4402 100644 --- a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py +++ b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py @@ -1,6 +1,5 @@ import FWCore.ParameterSet.Config as cms -from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiGeneralTracksNoRegitMu = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), @@ -21,6 +20,29 @@ copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) ) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toModify(hiGeneralTracksNoRegitMu, + TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), + cms.InputTag('hiLowPtQuadStepTracks'), + cms.InputTag('hiHighPtTripletStepTracks'), + cms.InputTag('hiDetachedQuadStepTracks'), + cms.InputTag('hiDetachedTripletStepTracks'), + cms.InputTag('hiLowPtTripletStepTracks'), + cms.InputTag('hiPixelPairGlobalPrimTracks'), + cms.InputTag('hiJetCoreRegionalStepTracks') + ), + hasSelector=cms.vint32(1,1,1,1,1,1,1,1), + setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5,6), pQual=cms.bool(True))), + selectedTrackQuals = cms.VInputTag( + cms.InputTag("hiInitialStepSelector","hiInitialStep"), + cms.InputTag("hiLowPtQuadStepSelector","hiLowPtQuadStep"), + cms.InputTag("hiHighPtTripletStepSelector","hiHighPtTripletStep"), + cms.InputTag("hiDetachedQuadStepSelector","hiDetachedQuadStep"), + cms.InputTag("hiDetachedTripletStepSelector","hiDetachedTripletStep"), + cms.InputTag("hiLowPtTripletStepSelector","hiLowPtTripletStep"), + cms.InputTag("hiPixelPairStepSelector","hiPixelPairStep"), + ) +) hiGeneralTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), @@ -55,4 +77,41 @@ ), copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) - ) +) +trackingPhase1QuadProp.toModify(hiGeneralTracks, + TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), + cms.InputTag('hiLowPtQuadStepTracks'), + cms.InputTag('hiHighPtTripletStepTracks'), + cms.InputTag('hiDetachedQuadStepTracks'), + cms.InputTag('hiDetachedTripletStepTracks'), + cms.InputTag('hiLowPtTripletStepTracks'), + cms.InputTag('hiPixelPairGlobalPrimTracks'), + cms.InputTag('hiJetCoreRegionalStepTracks'), + cms.InputTag('hiRegitMuInitialStepTracks'), + cms.InputTag('hiRegitMuPixelPairStepTracks'), + cms.InputTag('hiRegitMuMixedTripletStepTracks'), + cms.InputTag('hiRegitMuPixelLessStepTracks'), + cms.InputTag('hiRegitMuDetachedTripletStepTracks'), + cms.InputTag('hiRegitMuonSeededTracksOutIn'), + cms.InputTag('hiRegitMuonSeededTracksInOut') + ), + hasSelector=cms.vint32(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), + setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14), pQual=cms.bool(True))), # should this be False? + selectedTrackQuals = cms.VInputTag( + cms.InputTag("hiInitialStepSelector","hiInitialStep"), + cms.InputTag("hiLowPtQuadStepSelector","hiLowPtQuadStep"), + cms.InputTag("hiHighPtTripletStepSelector","hiHighPtTripletStep"), + cms.InputTag("hiDetachedQuadStepSelector","hiDetachedQuadStep"), + cms.InputTag("hiDetachedTripletStepSelector","hiDetachedTripletStep"), + cms.InputTag("hiLowPtTripletStepSelector","hiLowPtTripletStep"), + cms.InputTag("hiPixelPairStepSelector","hiPixelPairStep"), + cms.InputTag("hiJetCoreRegionalStepSelector","hiJetCoreRegionalStep"), + cms.InputTag("hiRegitMuInitialStepSelector","hiRegitMuInitialStepLoose"), + cms.InputTag("hiRegitMuPixelPairStepSelector","hiRegitMuPixelPairStep"), + cms.InputTag("hiRegitMuMixedTripletStepSelector","hiRegitMuMixedTripletStep"), + cms.InputTag("hiRegitMuPixelLessStepSelector","hiRegitMuPixelLessStep"), + cms.InputTag("hiRegitMuDetachedTripletStepSelector","hiRegitMuDetachedTripletStep"), + cms.InputTag("hiRegitMuonSeededTracksOutInSelector","hiRegitMuonSeededTracksOutInHighPurity"), + cms.InputTag("hiRegitMuonSeededTracksInOutSelector","hiRegitMuonSeededTracksInOutHighPurity") + ) +) diff --git a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py new file mode 100644 index 0000000000000..d210e7bf1cf99 --- /dev/null +++ b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py @@ -0,0 +1,261 @@ +from RecoTracker.IterativeTracking.DetachedQuadStep_cff import * +from HIPixelTripletSeeds_cff import * +from HIPixel3PrimTracks_cfi import * + +hiDetachedQuadStepClusters = cms.EDProducer("HITrackClusterRemover", + clusterLessSolution = cms.bool(True), + trajectories = cms.InputTag("hiHighPtTripletStepTracks"), + overrideTrkQuals = cms.InputTag("hiHighPtTripletStepSelector","hiHighPtTripletStep"), + TrackQuality = cms.string('highPurity'), + minNumberOfLayersWithMeasBeforeFiltering = cms.int32(0), + pixelClusters = cms.InputTag("siPixelClusters"), + stripClusters = cms.InputTag("siStripClusters"), + Common = cms.PSet( + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2), + maxChi2 = cms.double(9.0) + ) +) + +# SEEDING LAYERS +# Using 4 layers layerlist +hiDetachedQuadStepSeedLayers = hiPixelLayerQuadruplets.clone() +hiDetachedQuadStepSeedLayers.BPix.skipClusters = cms.InputTag('hiDetachedQuadStepClusters') +hiDetachedQuadStepSeedLayers.FPix.skipClusters = cms.InputTag('hiDetachedQuadStepClusters') + +# SEEDS +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +from RecoPixelVertexing.PixelLowPtUtilities.trackCleaner_cfi import * +from RecoPixelVertexing.PixelTrackFitting.pixelFitterByHelixProjections_cfi import * +from RecoHI.HiTracking.HIPixelTrackFilter_cff import * +from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * + +hiDetachedQuadStepTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet=dict( + precise = True, + useMultipleScattering = False, + useFakeVertices = False, + beamSpot = "offlineBeamSpot", + useFixedError = True, + nSigmaZ = 4.0, + sigmaZVertex = 4.0, + fixedError = 0.5, + VertexCollection = "hiSelectedVertex", + ptMin = 0.9,# 0.3 for pp + useFoundVertices = True, + #originHalfLength = 15.0, # 15 for pp, useTrackingRegionWithVertices, does not have this parameter. Only with BeamSpot + originRadius = 1.5 # 1.5 for pp + +)) +hiDetachedQuadStepTracksHitDoublets = _hitPairEDProducer.clone( + clusterCheck = "", + seedingLayers = "hiDetachedQuadStepSeedLayers", + trackingRegions = "hiDetachedQuadStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi +hiDetachedQuadStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "hiDetachedQuadStepTracksHitDoublets", + extraHitRPhitolerance = 0.0, + extraHitRZtolerance = 0.0, + maxElement = 1000000, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), + produceSeedingHitSets = True, + produceIntermediateHitTriplets = True, +) + +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +_hiDetachedQuadStepTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( + triplets = "hiDetachedQuadStepTracksHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), +) + +hiDetachedQuadStepTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( + triplets = "hiDetachedQuadStepTracksHitTriplets", + extraHitRZtolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRZtolerance, + extraHitRPhitolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 500, value2 = 100, + enabled = True, + ), + extraPhiTolerance = dict( + pt1 = 0.4, pt2 = 1, + value1 = 0.2, value2 = 0.05, + enabled = True, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + SeedComparitorPSet = hiDetachedQuadStepTracksHitTriplets.SeedComparitorPSet +) + +from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer +hiDetachedQuadStepTracksHitDoubletsCA = hiDetachedQuadStepTracksHitDoublets.clone() +hiDetachedQuadStepTracksHitDoubletsCA.layerPairs = [0,1,2] + +hiDetachedQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( + doublets = "hiDetachedQuadStepTracksHitDoubletsCA", + extraHitRPhitolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 500, value2 = 100, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + CAThetaCut = 0.0011, + CAPhiCut = 0, +) + +hiDetachedQuadStepPixelTracksFilter = hiFilter.clone( + nSigmaTipMaxTolerance = 0, + lipMax = 1.0, + tipMax = 1.0, + ptMin = 0.95, #seeding region is 0.3 +) +hiDetachedQuadStepPixelTracks = cms.EDProducer("PixelTrackProducer", + + passLabel = cms.string('Pixel detached tracks with vertex constraint'), + + # Ordered Hits + #SeedingHitSets = cms.InputTag("hiDetachedQuadStepTracksHitQuadruplets"), + SeedingHitSets = cms.InputTag("hiDetachedQuadStepTracksHitQuadrupletsCA"), + + # Fitter + Fitter = cms.InputTag("pixelFitterByHelixProjections"), + + # Filter + Filter = cms.InputTag("hiDetachedQuadStepPixelTracksFilter"), + + # Cleaner + Cleaner = cms.string("trackCleaner") +) + + +import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi +hiDetachedQuadStepSeeds = RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi.pixelTrackSeeds.clone( + InputCollection = 'hiDetachedQuadStepPixelTracks' + ) + +# QUALITY CUTS DURING TRACK BUILDING +import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff +hiDetachedQuadStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( + #maxLostHits = 1, + minimumNumberOfHits = 3,#3 for pp + minPt = cms.double(0.075),# 0.075 for pp + #constantValueForLostHitsFractionFilter = cms.double(0.701) + ) + +import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi +hiDetachedQuadStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( + ComponentName = cms.string('hiDetachedQuadStepChi2Est'), + nSigma = cms.double(3.0), + MaxChi2 = cms.double(9.0) + ) + + +# TRACK BUILDING +import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi +hiDetachedQuadStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( + MeasurementTrackerName = '', + trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiDetachedQuadStepTrajectoryFilter')), + maxCand = 4,#4 for pp + estimator = cms.string('hiDetachedQuadStepChi2Est'), + maxDPhiForLooperReconstruction = cms.double(2.0),#2.0 for pp + # 0.63 GeV is the maximum pT for a charged particle to loop within the 1.1m radius + # of the outermost Tracker barrel layer (B=3.8T) + maxPtForLooperReconstruction = cms.double(0.7),# 0.7 for pp + alwaysUseInvalidHits = cms.bool(False) + ) + +# MAKING OF TRACK CANDIDATES + +# Trajectory cleaner in default + +import RecoTracker.CkfPattern.CkfTrackCandidates_cfi +hiDetachedQuadStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( + src = cms.InputTag('hiDetachedQuadStepSeeds'), + ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput + numHitsForSeedCleaner = cms.int32(50), + onlyPixelHitsForSeedCleaner = cms.bool(True), + TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiDetachedQuadStepTrajectoryBuilder')), + TrajectoryBuilder = cms.string('hiDetachedQuadStepTrajectoryBuilder'), + clustersToSkip = cms.InputTag('hiDetachedQuadStepClusters'), + doSeedingRegionRebuilding = True, + useHitsSplitting = True + ) + + +# TRACK FITTING +import RecoTracker.TrackProducer.TrackProducer_cfi +hiDetachedQuadStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( + src = 'hiDetachedQuadStepTrackCandidates', + AlgorithmName = cms.string('detachedQuadStep'), + Fitter=cms.string('FlexibleKFFittingSmoother') + ) + +# Final selection +import RecoHI.HiTracking.hiMultiTrackSelector_cfi +hiDetachedQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( + src='hiDetachedQuadStepTracks', + useAnyMVA = cms.bool(True), + GBRForestLabel = cms.string('HIMVASelectorIter10'),#FIXME MVA for new iteration + GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), + trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiDetachedQuadStepTight', + preFilterName = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiDetachedQuadStep', + preFilterName = 'hiDetachedQuadStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone + +import RecoTracker.FinalTrackSelectors.trackListMerger_cfi +hiDetachedQuadStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( + TrackProducers=cms.VInputTag(cms.InputTag('hiDetachedQuadStepTracks')), + hasSelector=cms.vint32(1), + selectedTrackQuals = cms.VInputTag(cms.InputTag("hiDetachedQuadStepSelector","hiDetachedQuadStep")), + copyExtras = True, + makeReKeyedSeeds = cms.untracked.bool(False), + ) + + +hiDetachedQuadStep = cms.Sequence(hiDetachedQuadStepClusters* + hiDetachedQuadStepSeedLayers* + hiDetachedQuadStepTrackingRegions* + hiDetachedQuadStepTracksHitDoubletsCA* # 'CA' can be removed + hiDetachedQuadStepTracksHitTriplets* + hiDetachedQuadStepTracksHitQuadrupletsCA* # 'CA' can be removed + pixelFitterByHelixProjections* + hiDetachedQuadStepPixelTracksFilter* + hiDetachedQuadStepPixelTracks* + hiDetachedQuadStepSeeds* + hiDetachedQuadStepTrackCandidates* + hiDetachedQuadStepTracks* + hiDetachedQuadStepSelector* + hiDetachedQuadStepQual) + + diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index 99c7872945e96..4a0053a781978 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -60,14 +60,29 @@ maxElement = 0, produceIntermediateHitDoublets = True, ) +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * hiDetachedTripletStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( doublets = "hiDetachedTripletStepTracksHitDoublets", - extraHitRPhitolerance = 0.0, - extraHitRZtolerance = 0.0, - maxElement = 1000000, - SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), produceSeedingHitSets = True, ) + +from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer +hiDetachedTripletStepTracksHitDoubletsCA = hiDetachedTripletStepTracksHitDoublets.clone() +hiDetachedTripletStepTracksHitDoubletsCA.layerPairs = [0,1] + +hiDetachedTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( + doublets = "hiDetachedTripletStepTracksHitDoubletsCA", + extraHitRPhitolerance = hiDetachedTripletStepTracksHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 300 , value2 = 10, + ), + useBendingCorrection = True, + CAThetaCut = 0.001, + CAPhiCut = 0, + CAHardPtCut = 0.2, +) + hiDetachedTripletStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance = 0, lipMax = 1.0, @@ -80,6 +95,7 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTriplets"), + #SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTripletsCA"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -90,6 +106,10 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toModify(hiDetachedTripletStepPixelTracks, + SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTripletsCA") +) import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi @@ -179,7 +199,6 @@ ) #end of vpset ) #end of clone -from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiDetachedTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers=cms.VInputTag(cms.InputTag('hiDetachedTripletStepTracks')), @@ -193,8 +212,8 @@ hiDetachedTripletStep = cms.Sequence(hiDetachedTripletStepClusters* hiDetachedTripletStepSeedLayers* hiDetachedTripletStepTrackingRegions* - hiDetachedTripletStepTracksHitDoublets* - hiDetachedTripletStepTracksHitTriplets* + hiDetachedTripletStepTracksHitDoublets* + hiDetachedTripletStepTracksHitTriplets* pixelFitterByHelixProjections* hiDetachedTripletStepPixelTracksFilter* hiDetachedTripletStepPixelTracks* @@ -203,5 +222,8 @@ hiDetachedTripletStepTracks* hiDetachedTripletStepSelector* hiDetachedTripletStepQual) - +hiDetachedTripletStep_Phase1 = hiDetachedTripletStep.copy() +hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitDoublets, hiDetachedTripletStepTracksHitDoubletsCA)# 'CA' can be removed +hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitTriplets, hiDetachedTripletStepTracksHitTripletsCA)# 'CA' can be removed +trackingPhase1QuadProp.toReplaceWith(hiDetachedTripletStep, hiDetachedTripletStep_Phase1) diff --git a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py new file mode 100644 index 0000000000000..ad0917fbd8d72 --- /dev/null +++ b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py @@ -0,0 +1,228 @@ +from RecoTracker.IterativeTracking.HighPtTripletStep_cff import * +from HIPixelTripletSeeds_cff import * +from HIPixel3PrimTracks_cfi import * + +hiHighPtTripletStepClusters = cms.EDProducer("HITrackClusterRemover", + clusterLessSolution = cms.bool(True), + trajectories = cms.InputTag("hiLowPtQuadStepTracks"), + overrideTrkQuals = cms.InputTag("hiLowPtQuadStepSelector","hiLowPtQuadStep"), + TrackQuality = cms.string('highPurity'), + minNumberOfLayersWithMeasBeforeFiltering = cms.int32(0), + pixelClusters = cms.InputTag("siPixelClusters"), + stripClusters = cms.InputTag("siStripClusters"), + Common = cms.PSet( + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2), + maxChi2 = cms.double(9.0) + ) +) + +# SEEDING LAYERS +# Using 3 layers layerlist +hiHighPtTripletStepSeedLayers = highPtTripletStepSeedLayers.clone() +hiHighPtTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiHighPtTripletStepClusters') +hiHighPtTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiHighPtTripletStepClusters') + +# SEEDS +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +from RecoPixelVertexing.PixelLowPtUtilities.trackCleaner_cfi import * +from RecoPixelVertexing.PixelTrackFitting.pixelFitterByHelixProjections_cfi import * +from RecoHI.HiTracking.HIPixelTrackFilter_cff import * +from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * + +hiHighPtTripletStepTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet=dict( + precise = True, + useMultipleScattering = False, + useFakeVertices = False, + beamSpot = "offlineBeamSpot", + useFixedError = True, + nSigmaZ = 4.0, + sigmaZVertex = 4.0, + fixedError = 0.5, + VertexCollection = "hiSelectedVertex", + ptMin = 0.8,#0.6 for pp + useFoundVertices = True, + originRadius = 0.02 #0.02 for pp +)) +hiHighPtTripletStepTracksHitDoublets = _hitPairEDProducer.clone( + clusterCheck = "", + seedingLayers = "hiHighPtTripletStepSeedLayers", + trackingRegions = "hiHighPtTripletStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +hiHighPtTripletStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "hiHighPtTripletStepTracksHitDoublets", + extraHitRPhitolerance = 0.0, + extraHitRZtolerance = 0.0, + maxElement = 1000000, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), + produceSeedingHitSets = True, +) + +from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer +hiHighPtTripletStepTracksHitDoubletsCA = hiHighPtTripletStepTracksHitDoublets.clone() +hiHighPtTripletStepTracksHitDoubletsCA.layerPairs = [0,1] + +hiHighPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( + doublets = "hiHighPtTripletStepTracksHitDoubletsCA", + extraHitRPhitolerance = hiHighPtTripletStepTracksHitTriplets.extraHitRPhitolerance, + SeedComparitorPSet = hiHighPtTripletStepTracksHitTriplets.SeedComparitorPSet, + maxChi2 = dict( + pt1 = 0.8, pt2 = 8, + value1 = 100, value2 = 6, + ), + useBendingCorrection = True, + CAThetaCut = 0.004, + CAPhiCut = 0.07, + CAHardPtCut = 0.3, +) + +hiHighPtTripletStepPixelTracksFilter = hiFilter.clone( + nSigmaTipMaxTolerance = 0, + lipMax = 1.0, + tipMax = 1.0, + ptMin = 1.0, #seeding region is 0.6 +) +hiHighPtTripletStepPixelTracks = cms.EDProducer("PixelTrackProducer", + + passLabel = cms.string('Pixel detached tracks with vertex constraint'), + + # Ordered Hits + #SeedingHitSets = cms.InputTag("hiHighPtTripletStepTracksHitTriplets"), + SeedingHitSets = cms.InputTag("hiHighPtTripletStepTracksHitTripletsCA"), + + # Fitter + Fitter = cms.InputTag("pixelFitterByHelixProjections"), + + # Filter + Filter = cms.InputTag("hiHighPtTripletStepPixelTracksFilter"), + + # Cleaner + Cleaner = cms.string("trackCleaner") +) + + +import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi +hiHighPtTripletStepSeeds = RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi.pixelTrackSeeds.clone( + InputCollection = 'hiHighPtTripletStepPixelTracks' + ) + +# QUALITY CUTS DURING TRACK BUILDING +import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff +hiHighPtTripletStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( + #maxLostHits = 1, + minimumNumberOfHits = 3,#3 for pp + minPt = cms.double(0.2),# 0.2 for pp + #constantValueForLostHitsFractionFilter = cms.double(0.701) + ) + +import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi +hiHighPtTripletStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( + ComponentName = cms.string('hiHighPtTripletStepChi2Est'), + nSigma = cms.double(3.0), + MaxChi2 = cms.double(9.0)# 30 for pp + ) + + +# TRACK BUILDING +import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi +hiHighPtTripletStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( + MeasurementTrackerName = '', + trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiHighPtTripletStepTrajectoryFilter')), + maxCand = 3,#3 for pp + estimator = cms.string('hiHighPtTripletStepChi2Est'), + maxDPhiForLooperReconstruction = cms.double(2.0),#2.0 for pp + # 0.63 GeV is the maximum pT for a charged particle to loop within the 1.1m radius + # of the outermost Tracker barrel layer (B=3.8T) + maxPtForLooperReconstruction = cms.double(0.7),# 0.7 for pp + alwaysUseInvalidHits = cms.bool(False) + ) + +# MAKING OF TRACK CANDIDATES + +# Trajectory cleaner in default + +import RecoTracker.CkfPattern.CkfTrackCandidates_cfi +hiHighPtTripletStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( + src = cms.InputTag('hiHighPtTripletStepSeeds'), + ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput + numHitsForSeedCleaner = cms.int32(50), + onlyPixelHitsForSeedCleaner = cms.bool(True), + TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiHighPtTripletStepTrajectoryBuilder')), + TrajectoryBuilder = cms.string('hiHighPtTripletStepTrajectoryBuilder'), + clustersToSkip = cms.InputTag('hiHighPtTripletStepClusters'), + doSeedingRegionRebuilding = True, + useHitsSplitting = True + ) + + +# TRACK FITTING +import RecoTracker.TrackProducer.TrackProducer_cfi +hiHighPtTripletStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( + src = 'hiHighPtTripletStepTrackCandidates', + AlgorithmName = cms.string('highPtTripletStep'), + Fitter=cms.string('FlexibleKFFittingSmoother') + ) + +# Final selection +import RecoHI.HiTracking.hiMultiTrackSelector_cfi +hiHighPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( + src='hiHighPtTripletStepTracks', + useAnyMVA = cms.bool(True), + GBRForestLabel = cms.string('HIMVASelectorIter9'),#FIXME MVA for new iteration + GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), + trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiHighPtTripletStepTight', + preFilterName = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiHighPtTripletStep', + preFilterName = 'hiHighPtTripletStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone + +import RecoTracker.FinalTrackSelectors.trackListMerger_cfi +hiHighPtTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( + TrackProducers=cms.VInputTag(cms.InputTag('hiHighPtTripletStepTracks')), + hasSelector=cms.vint32(1), + selectedTrackQuals = cms.VInputTag(cms.InputTag("hiHighPtTripletStepSelector","hiHighPtTripletStep")), + copyExtras = True, + makeReKeyedSeeds = cms.untracked.bool(False), + ) + + +hiHighPtTripletStep = cms.Sequence(hiHighPtTripletStepClusters* + hiHighPtTripletStepSeedLayers* + hiHighPtTripletStepTrackingRegions* + hiHighPtTripletStepTracksHitDoubletsCA* # 'CA' can be removed + hiHighPtTripletStepTracksHitTripletsCA* # 'CA' can be removed + pixelFitterByHelixProjections* + hiHighPtTripletStepPixelTracksFilter* + hiHighPtTripletStepPixelTracks* + hiHighPtTripletStepSeeds* + hiHighPtTripletStepTrackCandidates* + hiHighPtTripletStepTracks* + hiHighPtTripletStepSelector* + hiHighPtTripletStepQual) + + diff --git a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py index 3df760c936cd9..a42ba8f0d99a4 100644 --- a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py +++ b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py @@ -51,6 +51,29 @@ HitProducer = cms.string('siPixelRecHits'), ) ) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toModify(hiJetCoreRegionalStepSeedLayers, layerList = cms.vstring('BPix1+BPix2+BPix3', + 'BPix2+BPix3+BPix4', + 'BPix1+BPix3+BPix4', + 'BPix1+BPix2+BPix4', + 'BPix2+BPix3+FPix1_pos', + 'BPix2+BPix3+FPix1_neg', + 'BPix1+BPix2+FPix1_pos', + 'BPix1+BPix2+FPix1_neg', + 'BPix2+FPix1_pos+FPix2_pos', + 'BPix2+FPix1_neg+FPix2_neg', + 'BPix1+FPix1_pos+FPix2_pos', + 'BPix1+FPix1_neg+FPix2_neg', + 'FPix1_pos+FPix2_pos+FPix3_pos', + 'FPix1_neg+FPix2_neg+FPix3_neg',#up to here, same as what is in RecoTracker/TkSeedingLayers/python/PixelLayerTriplets_cfi.py for phase 1 + 'BPix1+BPix2+TIB1',#use TIB1 to try to recover tracks w/ 2 hits missing in pix barrel + 'BPix1+BPix3+TIB1', + 'BPix1+BPix4+TIB1', + 'BPix2+BPix3+TIB1', + 'BPix2+BPix4+TIB1', + 'BPix3+BPix4+TIB1', + ) +) # SEEDS import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py new file mode 100644 index 0000000000000..b2595c1ba5a66 --- /dev/null +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -0,0 +1,261 @@ +from RecoTracker.IterativeTracking.LowPtQuadStep_cff import * +from HIPixelTripletSeeds_cff import * +from HIPixel3PrimTracks_cfi import * + +hiLowPtQuadStepClusters = cms.EDProducer("HITrackClusterRemover", + clusterLessSolution = cms.bool(True), + trajectories = cms.InputTag("hiGlobalPrimTracks"), + overrideTrkQuals = cms.InputTag('hiInitialStepSelector','hiInitialStep'), + TrackQuality = cms.string('highPurity'), + minNumberOfLayersWithMeasBeforeFiltering = cms.int32(0), + pixelClusters = cms.InputTag("siPixelClusters"), + stripClusters = cms.InputTag("siStripClusters"), + Common = cms.PSet( + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2), + maxChi2 = cms.double(9.0) + ) +) + +# SEEDING LAYERS +# Using 4 layers layerlist +hiLowPtQuadStepSeedLayers = hiPixelLayerQuadruplets.clone() +hiLowPtQuadStepSeedLayers.BPix.skipClusters = cms.InputTag('hiLowPtQuadStepClusters') +hiLowPtQuadStepSeedLayers.FPix.skipClusters = cms.InputTag('hiLowPtQuadStepClusters') + +# SEEDS +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +from RecoPixelVertexing.PixelLowPtUtilities.trackCleaner_cfi import * +from RecoPixelVertexing.PixelTrackFitting.pixelFitterByHelixProjections_cfi import * +from RecoHI.HiTracking.HIPixelTrackFilter_cff import * +from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * + +hiLowPtQuadStepTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet=dict( + precise = True, + useMultipleScattering = False, + useFakeVertices = False, + beamSpot = "offlineBeamSpot", + useFixedError = True, + nSigmaZ = 4.0, + sigmaZVertex = 4.0, + fixedError = 0.5, + VertexCollection = "hiSelectedVertex", + ptMin = 0.3,#0.2 for pp + useFoundVertices = True, + originRadius = 0.02 #0.02 for pp +)) +hiLowPtQuadStepTracksHitDoublets = _hitPairEDProducer.clone( + clusterCheck = "", + seedingLayers = "hiLowPtQuadStepSeedLayers", + trackingRegions = "hiLowPtQuadStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi +hiLowPtQuadStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "hiLowPtQuadStepTracksHitDoublets", + extraHitRPhitolerance = 0.0, + extraHitRZtolerance = 0.0, + maxElement = 1000000, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), + produceSeedingHitSets = True, + produceIntermediateHitTriplets = True, +) + +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +_hiLowPtQuadStepTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( + triplets = "hiLowPtQuadStepTracksHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), +) + +hiLowPtQuadStepTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( + triplets = "hiLowPtQuadStepTracksHitTriplets", + extraHitRZtolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRZtolerance, + extraHitRPhitolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 2000, value2 = 100, + enabled = True, + ), + extraPhiTolerance = dict( + pt1 = 0.3, pt2 = 1, + value1 = 0.4, value2 = 0.05, + enabled = True, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + SeedComparitorPSet = hiLowPtQuadStepTracksHitTriplets.SeedComparitorPSet +) + +from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer +hiLowPtQuadStepTracksHitDoubletsCA = hiLowPtQuadStepTracksHitDoublets.clone() +hiLowPtQuadStepTracksHitDoubletsCA.layerPairs = [0,1,2] + +hiLowPtQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( + doublets = "hiLowPtQuadStepTracksHitDoubletsCA", + extraHitRPhitolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRPhitolerance, + SeedComparitorPSet = hiLowPtQuadStepTracksHitTriplets.SeedComparitorPSet, + maxChi2 = dict( + pt1 = 0.7, pt2 = 2, + value1 = 1000, value2 = 150, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + CAThetaCut = 0.0017, + CAPhiCut = 0.3, +) + + +hiLowPtQuadStepPixelTracksFilter = hiFilter.clone( + nSigmaTipMaxTolerance = 0, + lipMax = 1.0, + tipMax = 1.0, + ptMin = 0.4, #seeding region is 0.3 +) +hiLowPtQuadStepPixelTracks = cms.EDProducer("PixelTrackProducer", + + passLabel = cms.string('Pixel detached tracks with vertex constraint'), + + # Ordered Hits + #SeedingHitSets = cms.InputTag("hiLowPtQuadStepTracksHitQuadruplets"), + SeedingHitSets = cms.InputTag("hiLowPtQuadStepTracksHitQuadrupletsCA"), + + # Fitter + Fitter = cms.InputTag("pixelFitterByHelixProjections"), + + # Filter + Filter = cms.InputTag("hiLowPtQuadStepPixelTracksFilter"), + + # Cleaner + Cleaner = cms.string("trackCleaner") +) + + +import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi +hiLowPtQuadStepSeeds = RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi.pixelTrackSeeds.clone( + InputCollection = 'hiLowPtQuadStepPixelTracks' + ) + +# QUALITY CUTS DURING TRACK BUILDING +import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff +hiLowPtQuadStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( + #maxLostHits = 1, + minimumNumberOfHits = 3,#3 for pp + minPt = cms.double(0.075),# 0.075 for pp + #constantValueForLostHitsFractionFilter = cms.double(0.701) + ) + +import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi +hiLowPtQuadStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( + ComponentName = cms.string('hiLowPtQuadStepChi2Est'), + nSigma = cms.double(3.0), + MaxChi2 = cms.double(9.0) + ) + + +# TRACK BUILDING +import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi +hiLowPtQuadStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( + MeasurementTrackerName = '', + trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiLowPtQuadStepTrajectoryFilter')), + maxCand = 4,#4 for pp + estimator = cms.string('hiLowPtQuadStepChi2Est'), + maxDPhiForLooperReconstruction = cms.double(2.0),#2.0 for pp + # 0.63 GeV is the maximum pT for a charged particle to loop within the 1.1m radius + # of the outermost Tracker barrel layer (B=3.8T) + maxPtForLooperReconstruction = cms.double(0.7),# 0.7 for pp + alwaysUseInvalidHits = cms.bool(False) + ) + +# MAKING OF TRACK CANDIDATES + +# Trajectory cleaner in default + +import RecoTracker.CkfPattern.CkfTrackCandidates_cfi +hiLowPtQuadStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( + src = cms.InputTag('hiLowPtQuadStepSeeds'), + ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput + numHitsForSeedCleaner = cms.int32(50), + onlyPixelHitsForSeedCleaner = cms.bool(True), + TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiLowPtQuadStepTrajectoryBuilder')), + TrajectoryBuilder = cms.string('hiLowPtQuadStepTrajectoryBuilder'), + clustersToSkip = cms.InputTag('hiLowPtQuadStepClusters'), + doSeedingRegionRebuilding = True, + useHitsSplitting = True + ) + + +# TRACK FITTING +import RecoTracker.TrackProducer.TrackProducer_cfi +hiLowPtQuadStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( + src = 'hiLowPtQuadStepTrackCandidates', + AlgorithmName = cms.string('lowPtQuadStep'), + Fitter=cms.string('FlexibleKFFittingSmoother') + ) + +# Final selection +import RecoHI.HiTracking.hiMultiTrackSelector_cfi +hiLowPtQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( + src='hiLowPtQuadStepTracks', + useAnyMVA = cms.bool(True), + GBRForestLabel = cms.string('HIMVASelectorIter8'),#FIXME MVA for new iteration + GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), + trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiLowPtQuadStepTight', + preFilterName = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiLowPtQuadStep', + preFilterName = 'hiLowPtQuadStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone + +import RecoTracker.FinalTrackSelectors.trackListMerger_cfi +hiLowPtQuadStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( + TrackProducers=cms.VInputTag(cms.InputTag('hiLowPtQuadStepTracks')), + hasSelector=cms.vint32(1), + selectedTrackQuals = cms.VInputTag(cms.InputTag("hiLowPtQuadStepSelector","hiLowPtQuadStep")), + copyExtras = True, + makeReKeyedSeeds = cms.untracked.bool(False), + ) + + +hiLowPtQuadStep = cms.Sequence(hiLowPtQuadStepClusters* + hiLowPtQuadStepSeedLayers* + hiLowPtQuadStepTrackingRegions* + hiLowPtQuadStepTracksHitDoubletsCA* # 'CA' can be removed + hiLowPtQuadStepTracksHitTriplets* + hiLowPtQuadStepTracksHitQuadrupletsCA* # 'CA' can be removed + pixelFitterByHelixProjections* + hiLowPtQuadStepPixelTracksFilter* + hiLowPtQuadStepPixelTracks* + hiLowPtQuadStepSeeds* + hiLowPtQuadStepTrackCandidates* + hiLowPtQuadStepTracks* + hiLowPtQuadStepSelector* + hiLowPtQuadStepQual) + + diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index 8fa7555255401..6e66292b3d20e 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -60,12 +60,31 @@ maxElement = 0, produceIntermediateHitDoublets = True, ) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi hiLowPtTripletStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( doublets = "hiLowPtTripletStepTracksHitDoublets", - maxElement = 5000000, + #maxElement = 5000000, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), produceSeedingHitSets = True, ) + +from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer +hiLowPtTripletStepTracksHitDoubletsCA = hiLowPtTripletStepTracksHitDoublets.clone() +hiLowPtTripletStepTracksHitDoubletsCA.layerPairs = [0,1] + +hiLowPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( + doublets = "hiLowPtTripletStepTracksHitDoubletsCA", + extraHitRPhitolerance = hiLowPtTripletStepTracksHitTriplets.extraHitRPhitolerance, + SeedComparitorPSet = hiLowPtTripletStepTracksHitTriplets.SeedComparitorPSet, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 70 , value2 = 8, + ), + useBendingCorrection = True, + CAThetaCut = 0.002, + CAPhiCut = 0.05, +) + hiLowPtTripletStepPixelTracksFilter = hiFilter.clone( nSigmaLipMaxTolerance = 4.0, nSigmaTipMaxTolerance = 4.0, @@ -78,6 +97,7 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTriplets"), + #SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTripletsCA"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -88,6 +108,10 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) +from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp +trackingPhase1QuadProp.toModify(hiLowPtTripletStepPixelTracks, + SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTripletsCA") +) import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi @@ -175,7 +199,6 @@ ) #end of clone -from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiLowPtTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers = cms.VInputTag(cms.InputTag('hiLowPtTripletStepTracks')), @@ -201,3 +224,7 @@ hiLowPtTripletStepSelector* hiLowPtTripletStepQual ) +hiLowPtTripletStep_Phase1 = hiLowPtTripletStep.copy() +hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitDoublets, hiLowPtTripletStepTracksHitDoubletsCA)# 'CA' can be removed +hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitTriplets, hiLowPtTripletStepTracksHitTripletsCA)# 'CA' can be removed +trackingPhase1QuadProp.toReplaceWith(hiLowPtTripletStep, hiLowPtTripletStep_Phase1) From d2b96ca2cbddf9c6f31a4f1a66aeb1c9a61ef84a Mon Sep 17 00:00:00 2001 From: abaty Date: Wed, 10 May 2017 18:50:07 +0200 Subject: [PATCH 02/10] turning off all MVA selectors until new ones are trained --- .../python/HiRegitMuonDetachedTripletStep_cff.py | 6 +++--- .../HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py | 8 ++++---- .../python/HiRegitMuonMixedTripletStep_cff.py | 6 +++--- .../python/HiRegitMuonPixelLessStep_cff.py | 6 +++--- .../python/HiRegitMuonPixelPairStep_cff.py | 6 +++--- .../HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py | 12 ++++++------ RecoHI/HiTracking/python/HISelectedTracks_cfi.py | 6 +++--- RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py | 6 +++--- .../HiTracking/python/hiDetachedTripletStep_cff.py | 6 +++--- RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py | 6 +++--- RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py | 6 +++--- RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py | 6 +++--- RecoHI/HiTracking/python/hiPixelPairStep_cff.py | 6 +++--- 13 files changed, 43 insertions(+), 43 deletions(-) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py index adc79949547e1..b50c849f52b0e 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py @@ -102,7 +102,7 @@ hiRegitMuDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuDetachedTripletStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -114,14 +114,14 @@ name = 'hiRegitMuDetachedTripletStepTight', preFilterName = 'hiRegitMuDetachedTripletStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuDetachedTripletStep', preFilterName = 'hiRegitMuDetachedTripletStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ) ) #end of vpset diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py index 1a4d8e8d3a24e..4419cd13c98b4 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py @@ -33,7 +33,7 @@ hiRegitMuInitialStepHitDoublets = RecoTracker.IterativeTracking.InitialStep_cff.initialStepHitDoublets.clone( seedingLayers = "hiRegitMuInitialStepSeedLayers", trackingRegions = "hiRegitMuInitialStepTrackingRegions", - clusterCheck = "hiRegitMuClusterCheck", + clusterCheck = "hiRegitMuClusterCheck" ) hiRegitMuInitialStepHitTriplets = RecoTracker.IterativeTracking.InitialStep_cff.initialStepHitTriplets.clone( doublets = "hiRegitMuInitialStepHitDoublets" @@ -80,7 +80,7 @@ hiRegitMuInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuInitialStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter4'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -92,14 +92,14 @@ name = 'hiRegitMuInitialStepTight', preFilterName = 'hiRegitMuInitialStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.38) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuInitialStep', preFilterName = 'hiRegitMuInitialStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.77) ), ) #end of vpset diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py index 23109439cd5ea..825f2f1a66715 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py @@ -125,7 +125,7 @@ hiRegitMuMixedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src = 'hiRegitMuMixedTripletStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -137,14 +137,14 @@ name = 'hiRegitMuMixedTripletStepTight', preFilterName = 'hiRegitMuMixedTripletStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuMixedTripletStep', preFilterName = 'hiRegitMuMixedTripletStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ) ) #end of vpset diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py index 70a3721581a63..bbb7db5bf0af3 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py @@ -93,7 +93,7 @@ hiRegitMuPixelLessStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuPixelLessStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors = cms.VPSet( @@ -105,14 +105,14 @@ name = 'hiRegitMuPixelLessStepTight', preFilterName = 'hiRegitMuPixelLessStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuPixelLessStep', preFilterName = 'hiRegitMuPixelLessStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py index 6e36b580d5430..92d3a5729af37 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py @@ -96,7 +96,7 @@ hiRegitMuPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuPixelPairStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter6'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -108,14 +108,14 @@ name = 'hiRegitMuPixelPairStepTight', preFilterName = 'hiRegitMuPixelPairStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.58) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuPixelPairStep', preFilterName = 'hiRegitMuPixelPairStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(0.77) ), ) #end of vpset diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py index 1e6b79f77dac8..498b0ba9c1f99 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py @@ -70,7 +70,7 @@ hiRegitMuonSeededTracksInOutSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiRegitMuonSeededTracksInOut', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -82,14 +82,14 @@ name = 'hiRegitMuonSeededTracksInOutTight', preFilterName = 'hiRegitMuonSeededTracksInOutLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuonSeededTracksInOutHighPurity', preFilterName = 'hiRegitMuonSeededTracksInOutTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset @@ -98,7 +98,7 @@ hiRegitMuonSeededTracksOutInSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiRegitMuonSeededTracksOutIn', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -110,14 +110,14 @@ name = 'hiRegitMuonSeededTracksOutInTight', preFilterName = 'hiRegitMuonSeededTracksOutInLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuonSeededTracksOutInHighPurity', preFilterName = 'hiRegitMuonSeededTracksOutInTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py index bd5a325a38ae7..2d3f31e329e4d 100644 --- a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py +++ b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py @@ -6,7 +6,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiGlobalPrimTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter4'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -17,13 +17,13 @@ RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( name = 'hiInitialStepTight', preFilterName = 'hiInitialStepLoose', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.77) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiInitialStep', preFilterName = 'hiInitialStepTight', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.77) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py index d210e7bf1cf99..db98b85590f1b 100644 --- a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py @@ -207,7 +207,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiDetachedQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiDetachedQuadStepTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter10'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -220,14 +220,14 @@ name = 'hiDetachedQuadStepTight', preFilterName = 'hiDetachedQuadStepLoose', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiDetachedQuadStep', preFilterName = 'hiDetachedQuadStepTight', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index 4a0053a781978..a6b7a19d1c61d 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -173,7 +173,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiDetachedTripletStepTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -186,14 +186,14 @@ name = 'hiDetachedTripletStepTight', preFilterName = 'hiDetachedTripletStepLoose', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiDetachedTripletStep', preFilterName = 'hiDetachedTripletStepTight', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py index ad0917fbd8d72..ccb36db4e441b 100644 --- a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py @@ -175,7 +175,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiHighPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiHighPtTripletStepTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter9'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -188,14 +188,14 @@ name = 'hiHighPtTripletStepTight', preFilterName = 'hiHighPtTripletStepLoose', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiHighPtTripletStep', preFilterName = 'hiHighPtTripletStepTight', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py index b2595c1ba5a66..e81a7cfaf3074 100644 --- a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -207,7 +207,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiLowPtQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiLowPtQuadStepTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter8'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -220,14 +220,14 @@ name = 'hiLowPtQuadStepTight', preFilterName = 'hiLowPtQuadStepLoose', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiLowPtQuadStep', preFilterName = 'hiLowPtQuadStepTight', applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.09) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index 6e66292b3d20e..647b4e541cf98 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -175,7 +175,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiLowPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiLowPtTripletStepTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter5'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'relpterr', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -186,13 +186,13 @@ RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( name = 'hiLowPtTripletStepTight', preFilterName = 'hiLowPtTripletStepLoose', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.58) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiLowPtTripletStep', preFilterName = 'hiLowPtTripletStepTight', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(0.35) ), ) #end of vpset diff --git a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py index 73cef00272e54..e1d92f7e41d86 100644 --- a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py +++ b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py @@ -121,7 +121,7 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiPixelPairGlobalPrimTracks', - useAnyMVA = cms.bool(True), + useAnyMVA = cms.bool(False), GBRForestLabel = cms.string('HIMVASelectorIter6'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -132,13 +132,13 @@ RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( name = 'hiPixelPairStepTight', preFilterName = 'hiPixelPairStepLoose', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(-0.58) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiPixelPairStep', preFilterName = 'hiPixelPairStepTight', - useMVA = cms.bool(True), + useMVA = cms.bool(False), minMVA = cms.double(0.77) ), ) #end of vpset From 4a1ce30f6487dfe749d44a397389d0ecd50eeeef Mon Sep 17 00:00:00 2001 From: abaty Date: Mon, 22 May 2017 19:38:42 +0200 Subject: [PATCH 03/10] some cleanup of temporary non-CA quad seeding modules --- .../HiRegitMuonDetachedTripletStep_cff.py | 9 ---- .../python/HIPixel3PrimTracks_cfi.py | 35 +----------- .../python/hiDetachedQuadStep_cff.py | 51 ++---------------- .../python/hiDetachedTripletStep_cff.py | 5 +- .../python/hiHighPtTripletStep_cff.py | 23 +++----- .../HiTracking/python/hiLowPtQuadStep_cff.py | 54 +++---------------- .../python/hiLowPtTripletStep_cff.py | 5 +- 7 files changed, 24 insertions(+), 158 deletions(-) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py index b50c849f52b0e..cca669cbb5a86 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py @@ -29,15 +29,6 @@ from RecoTracker.IterativeTracking.DetachedTripletStep_cff import * # NEW CLUSTERS (remove previously used clusters) -""" -#Problem with this setup is because in pp, the iteration before detachedTriplet is detachedQuadruplets. -hiRegitMuDetachedTripletStepClusters = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepClusters.clone( - trajectories = cms.InputTag("hiRegitMuPixelLessStepTracks"), - overrideTrkQuals = cms.InputTag('hiRegitMuPixelLessStepSelector','hiRegitMuPixelLessStep'), - trackClassifier = cms.InputTag(''), - TrackQuality = cms.string('tight') -) -""" from RecoLocalTracker.SubCollectionProducers.trackClusterRemover_cfi import trackClusterRemover as _trackClusterRemover hiRegitMuDetachedTripletStepClusters = _trackClusterRemover.clone( maxChi2 = 9.0, diff --git a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py index 2ec6c9255c8db..7c1f66eb2d821 100644 --- a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py +++ b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py @@ -37,36 +37,6 @@ produceIntermediateHitTriplets = True, ) - -# pixelQuadrupletMerger is not in use here. pp use it for trackingPhase1PU70 -from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer -from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * -_hiPixel3PrimTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( - triplets = "hiPixel3PrimTracksHitTriplets", - layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), -) -#### - -hiPixel3PrimTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( - triplets = "hiPixel3PrimTracksHitTriplets", - extraHitRZtolerance = hiPixel3PrimTracksHitTriplets.extraHitRZtolerance, - extraHitRPhitolerance = hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 200, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.6, pt2 = 1, - value1 = 0.15, value2 = 0.1, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet -) - from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone() hiPixel3PrimTracksHitDoubletsCA.layerPairs = [0,1,2] @@ -93,7 +63,6 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitTriplets"), - #SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitQuadruplets"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -119,6 +88,6 @@ #phase 1 changes hiPixel3PrimTracksSequence_Phase1 = hiPixel3PrimTracksSequence.copy() -hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitDoublets,hiPixelLayerQuadruplets+hiPixel3PrimTracksHitDoubletsCA)#can remove 'CA' to get regular seeds -hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitTriplets,hiPixel3PrimTracksHitTriplets+hiPixel3PrimTracksHitQuadrupletsCA)#can remove 'CA' to get regular seeds +hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitDoublets,hiPixelLayerQuadruplets+hiPixel3PrimTracksHitDoubletsCA) +hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitTriplets,hiPixel3PrimTracksHitQuadrupletsCA) trackingPhase1QuadProp.toReplaceWith(hiPixel3PrimTracksSequence,hiPixel3PrimTracksSequence_Phase1) diff --git a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py index db98b85590f1b..57672e21bb5f1 100644 --- a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py @@ -53,58 +53,19 @@ originRadius = 1.5 # 1.5 for pp )) -hiDetachedQuadStepTracksHitDoublets = _hitPairEDProducer.clone( +hiDetachedQuadStepTracksHitDoubletsCA = _hitPairEDProducer.clone( clusterCheck = "", seedingLayers = "hiDetachedQuadStepSeedLayers", trackingRegions = "hiDetachedQuadStepTrackingRegions", maxElement = 0, produceIntermediateHitDoublets = True, -) -import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -hiDetachedQuadStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( - doublets = "hiDetachedQuadStepTracksHitDoublets", - extraHitRPhitolerance = 0.0, - extraHitRZtolerance = 0.0, - maxElement = 1000000, - SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), - produceSeedingHitSets = True, - produceIntermediateHitTriplets = True, -) - -from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer -from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * -_hiDetachedQuadStepTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( - triplets = "hiDetachedQuadStepTracksHitTriplets", - layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), -) - -hiDetachedQuadStepTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( - triplets = "hiDetachedQuadStepTracksHitTriplets", - extraHitRZtolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRZtolerance, - extraHitRPhitolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 500, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.4, pt2 = 1, - value1 = 0.2, value2 = 0.05, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - SeedComparitorPSet = hiDetachedQuadStepTracksHitTriplets.SeedComparitorPSet + layerPairs = [0,1,2] ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer -hiDetachedQuadStepTracksHitDoubletsCA = hiDetachedQuadStepTracksHitDoublets.clone() -hiDetachedQuadStepTracksHitDoubletsCA.layerPairs = [0,1,2] - hiDetachedQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiDetachedQuadStepTracksHitDoubletsCA", - extraHitRPhitolerance = hiDetachedQuadStepTracksHitTriplets.extraHitRPhitolerance, + extraHitRPhitolerance = 0.0, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 500, value2 = 100, @@ -127,7 +88,6 @@ passLabel = cms.string('Pixel detached tracks with vertex constraint'), # Ordered Hits - #SeedingHitSets = cms.InputTag("hiDetachedQuadStepTracksHitQuadruplets"), SeedingHitSets = cms.InputTag("hiDetachedQuadStepTracksHitQuadrupletsCA"), # Fitter @@ -246,9 +206,8 @@ hiDetachedQuadStep = cms.Sequence(hiDetachedQuadStepClusters* hiDetachedQuadStepSeedLayers* hiDetachedQuadStepTrackingRegions* - hiDetachedQuadStepTracksHitDoubletsCA* # 'CA' can be removed - hiDetachedQuadStepTracksHitTriplets* - hiDetachedQuadStepTracksHitQuadrupletsCA* # 'CA' can be removed + hiDetachedQuadStepTracksHitDoubletsCA* + hiDetachedQuadStepTracksHitQuadrupletsCA* pixelFitterByHelixProjections* hiDetachedQuadStepPixelTracksFilter* hiDetachedQuadStepPixelTracks* diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index a6b7a19d1c61d..426cb250c7dd4 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -95,7 +95,6 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTriplets"), - #SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTripletsCA"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -223,7 +222,7 @@ hiDetachedTripletStepSelector* hiDetachedTripletStepQual) hiDetachedTripletStep_Phase1 = hiDetachedTripletStep.copy() -hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitDoublets, hiDetachedTripletStepTracksHitDoubletsCA)# 'CA' can be removed -hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitTriplets, hiDetachedTripletStepTracksHitTripletsCA)# 'CA' can be removed +hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitDoublets, hiDetachedTripletStepTracksHitDoubletsCA) +hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitTriplets, hiDetachedTripletStepTracksHitTripletsCA) trackingPhase1QuadProp.toReplaceWith(hiDetachedTripletStep, hiDetachedTripletStep_Phase1) diff --git a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py index ccb36db4e441b..7accc6e578024 100644 --- a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py @@ -50,30 +50,20 @@ useFoundVertices = True, originRadius = 0.02 #0.02 for pp )) -hiHighPtTripletStepTracksHitDoublets = _hitPairEDProducer.clone( +hiHighPtTripletStepTracksHitDoubletsCA = _hitPairEDProducer.clone( clusterCheck = "", seedingLayers = "hiHighPtTripletStepSeedLayers", trackingRegions = "hiHighPtTripletStepTrackingRegions", maxElement = 0, produceIntermediateHitDoublets = True, -) -hiHighPtTripletStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( - doublets = "hiHighPtTripletStepTracksHitDoublets", - extraHitRPhitolerance = 0.0, - extraHitRZtolerance = 0.0, - maxElement = 1000000, - SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), - produceSeedingHitSets = True, + layerPairs = [0,1] ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer -hiHighPtTripletStepTracksHitDoubletsCA = hiHighPtTripletStepTracksHitDoublets.clone() -hiHighPtTripletStepTracksHitDoubletsCA.layerPairs = [0,1] - hiHighPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiHighPtTripletStepTracksHitDoubletsCA", - extraHitRPhitolerance = hiHighPtTripletStepTracksHitTriplets.extraHitRPhitolerance, - SeedComparitorPSet = hiHighPtTripletStepTracksHitTriplets.SeedComparitorPSet, + extraHitRPhitolerance = 0.0, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), maxChi2 = dict( pt1 = 0.8, pt2 = 8, value1 = 100, value2 = 6, @@ -95,7 +85,6 @@ passLabel = cms.string('Pixel detached tracks with vertex constraint'), # Ordered Hits - #SeedingHitSets = cms.InputTag("hiHighPtTripletStepTracksHitTriplets"), SeedingHitSets = cms.InputTag("hiHighPtTripletStepTracksHitTripletsCA"), # Fitter @@ -214,8 +203,8 @@ hiHighPtTripletStep = cms.Sequence(hiHighPtTripletStepClusters* hiHighPtTripletStepSeedLayers* hiHighPtTripletStepTrackingRegions* - hiHighPtTripletStepTracksHitDoubletsCA* # 'CA' can be removed - hiHighPtTripletStepTracksHitTripletsCA* # 'CA' can be removed + hiHighPtTripletStepTracksHitDoubletsCA* + hiHighPtTripletStepTracksHitTripletsCA* pixelFitterByHelixProjections* hiHighPtTripletStepPixelTracksFilter* hiHighPtTripletStepPixelTracks* diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py index e81a7cfaf3074..113dbfbd2ecc4 100644 --- a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -51,59 +51,21 @@ useFoundVertices = True, originRadius = 0.02 #0.02 for pp )) -hiLowPtQuadStepTracksHitDoublets = _hitPairEDProducer.clone( +hiLowPtQuadStepTracksHitDoubletsCA = _hitPairEDProducer.clone( clusterCheck = "", seedingLayers = "hiLowPtQuadStepSeedLayers", trackingRegions = "hiLowPtQuadStepTrackingRegions", maxElement = 0, produceIntermediateHitDoublets = True, -) -import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -hiLowPtQuadStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( - doublets = "hiLowPtQuadStepTracksHitDoublets", - extraHitRPhitolerance = 0.0, - extraHitRZtolerance = 0.0, - maxElement = 1000000, - SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), - produceSeedingHitSets = True, - produceIntermediateHitTriplets = True, -) - -from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer -from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * -_hiLowPtQuadStepTracksHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( - triplets = "hiLowPtQuadStepTracksHitTriplets", - layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), -) - -hiLowPtQuadStepTracksHitQuadruplets = _pixelQuadrupletEDProducer.clone( - triplets = "hiLowPtQuadStepTracksHitTriplets", - extraHitRZtolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRZtolerance, - extraHitRPhitolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 2000, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.3, pt2 = 1, - value1 = 0.4, value2 = 0.05, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - SeedComparitorPSet = hiLowPtQuadStepTracksHitTriplets.SeedComparitorPSet + layerPairs = [0,1,2] ) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer -hiLowPtQuadStepTracksHitDoubletsCA = hiLowPtQuadStepTracksHitDoublets.clone() -hiLowPtQuadStepTracksHitDoubletsCA.layerPairs = [0,1,2] - hiLowPtQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiLowPtQuadStepTracksHitDoubletsCA", - extraHitRPhitolerance = hiLowPtQuadStepTracksHitTriplets.extraHitRPhitolerance, - SeedComparitorPSet = hiLowPtQuadStepTracksHitTriplets.SeedComparitorPSet, + extraHitRPhitolerance = 0.0, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 1000, value2 = 150, @@ -127,7 +89,6 @@ passLabel = cms.string('Pixel detached tracks with vertex constraint'), # Ordered Hits - #SeedingHitSets = cms.InputTag("hiLowPtQuadStepTracksHitQuadruplets"), SeedingHitSets = cms.InputTag("hiLowPtQuadStepTracksHitQuadrupletsCA"), # Fitter @@ -246,9 +207,8 @@ hiLowPtQuadStep = cms.Sequence(hiLowPtQuadStepClusters* hiLowPtQuadStepSeedLayers* hiLowPtQuadStepTrackingRegions* - hiLowPtQuadStepTracksHitDoubletsCA* # 'CA' can be removed - hiLowPtQuadStepTracksHitTriplets* - hiLowPtQuadStepTracksHitQuadrupletsCA* # 'CA' can be removed + hiLowPtQuadStepTracksHitDoubletsCA* + hiLowPtQuadStepTracksHitQuadrupletsCA* pixelFitterByHelixProjections* hiLowPtQuadStepPixelTracksFilter* hiLowPtQuadStepPixelTracks* diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index 647b4e541cf98..4ee7937002403 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -97,7 +97,6 @@ # Ordered Hits SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTriplets"), - #SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTripletsCA"), # Fitter Fitter = cms.InputTag("pixelFitterByHelixProjections"), @@ -225,6 +224,6 @@ hiLowPtTripletStepQual ) hiLowPtTripletStep_Phase1 = hiLowPtTripletStep.copy() -hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitDoublets, hiLowPtTripletStepTracksHitDoubletsCA)# 'CA' can be removed -hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitTriplets, hiLowPtTripletStepTracksHitTripletsCA)# 'CA' can be removed +hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitDoublets, hiLowPtTripletStepTracksHitDoubletsCA) +hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitTriplets, hiLowPtTripletStepTracksHitTripletsCA) trackingPhase1QuadProp.toReplaceWith(hiLowPtTripletStep, hiLowPtTripletStep_Phase1) From d4142f7f8ded6b9c8faf522c1075876e00ee5fed Mon Sep 17 00:00:00 2001 From: abaty Date: Mon, 22 May 2017 20:03:41 +0200 Subject: [PATCH 04/10] missing parenthesis --- RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py index 113dbfbd2ecc4..7049f8b1f2370 100644 --- a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -65,7 +65,7 @@ hiLowPtQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiLowPtQuadStepTracksHitDoubletsCA", extraHitRPhitolerance = 0.0, - SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 1000, value2 = 150, From 174e033d73333c0622aeb2cac9e99a1f2640ed6e Mon Sep 17 00:00:00 2001 From: abaty Date: Tue, 23 May 2017 17:29:01 +0200 Subject: [PATCH 05/10] changed modifier in Reconstruction_HI --- RecoHI/Configuration/python/Reconstruction_HI_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoHI/Configuration/python/Reconstruction_HI_cff.py b/RecoHI/Configuration/python/Reconstruction_HI_cff.py index b92a991557f5a..5a9252709aa05 100644 --- a/RecoHI/Configuration/python/Reconstruction_HI_cff.py +++ b/RecoHI/Configuration/python/Reconstruction_HI_cff.py @@ -51,8 +51,8 @@ ) globalRecoPbPb_wPhase1 = globalRecoPbPb.copy() globalRecoPbPb_wPhase1.replace(hiTracking_wSplitting, hiTracking_wSplitting_Phase1) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toReplaceWith(globalRecoPbPb, globalRecoPbPb_wPhase1) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toReplaceWith(globalRecoPbPb, globalRecoPbPb_wPhase1) globalRecoPbPb_wConformalPixel = cms.Sequence(hiTracking_wConformalPixel From ecb6d209b605afb57f5fb4d4fff49f6d8ca8dca5 Mon Sep 17 00:00:00 2001 From: abaty Date: Tue, 23 May 2017 17:36:32 +0200 Subject: [PATCH 06/10] changed era modifier from trackingPhase1QuadProp to trackingPhase1 --- RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py | 8 ++++---- RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py | 6 +++--- RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py | 6 +++--- RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py | 4 ++-- RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py | 6 +++--- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py index 7c1f66eb2d821..a86aad884a719 100644 --- a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py +++ b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py @@ -24,8 +24,8 @@ maxElement = 0, produceIntermediateHitDoublets = True, ) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toModify(hiPixel3PrimTracksHitDoublets, +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiPixel3PrimTracksHitDoublets, seedingLayers = "hiPixelLayerQuadruplets" ) @@ -73,7 +73,7 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) -trackingPhase1QuadProp.toModify(hiPixel3PrimTracks, +trackingPhase1.toModify(hiPixel3PrimTracks, SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitQuadrupletsCA"), ) @@ -90,4 +90,4 @@ hiPixel3PrimTracksSequence_Phase1 = hiPixel3PrimTracksSequence.copy() hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitDoublets,hiPixelLayerQuadruplets+hiPixel3PrimTracksHitDoubletsCA) hiPixel3PrimTracksSequence_Phase1.replace(hiPixel3PrimTracksHitTriplets,hiPixel3PrimTracksHitQuadrupletsCA) -trackingPhase1QuadProp.toReplaceWith(hiPixel3PrimTracksSequence,hiPixel3PrimTracksSequence_Phase1) +trackingPhase1.toReplaceWith(hiPixel3PrimTracksSequence,hiPixel3PrimTracksSequence_Phase1) diff --git a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py index 14ccbc79a4402..aa89dbfb51ca1 100644 --- a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py +++ b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py @@ -20,8 +20,8 @@ copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) ) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toModify(hiGeneralTracksNoRegitMu, +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiGeneralTracksNoRegitMu, TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), cms.InputTag('hiLowPtQuadStepTracks'), cms.InputTag('hiHighPtTripletStepTracks'), @@ -78,7 +78,7 @@ copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) ) -trackingPhase1QuadProp.toModify(hiGeneralTracks, +trackingPhase1.toModify(hiGeneralTracks, TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), cms.InputTag('hiLowPtQuadStepTracks'), cms.InputTag('hiHighPtTripletStepTracks'), diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index 426cb250c7dd4..3ecd74fa63106 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -105,8 +105,8 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toModify(hiDetachedTripletStepPixelTracks, +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiDetachedTripletStepPixelTracks, SeedingHitSets = cms.InputTag("hiDetachedTripletStepTracksHitTripletsCA") ) @@ -224,5 +224,5 @@ hiDetachedTripletStep_Phase1 = hiDetachedTripletStep.copy() hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitDoublets, hiDetachedTripletStepTracksHitDoubletsCA) hiDetachedTripletStep_Phase1.replace(hiDetachedTripletStepTracksHitTriplets, hiDetachedTripletStepTracksHitTripletsCA) -trackingPhase1QuadProp.toReplaceWith(hiDetachedTripletStep, hiDetachedTripletStep_Phase1) +trackingPhase1.toReplaceWith(hiDetachedTripletStep, hiDetachedTripletStep_Phase1) diff --git a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py index a42ba8f0d99a4..acccfc52531f8 100644 --- a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py +++ b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py @@ -51,8 +51,8 @@ HitProducer = cms.string('siPixelRecHits'), ) ) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toModify(hiJetCoreRegionalStepSeedLayers, layerList = cms.vstring('BPix1+BPix2+BPix3', +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiJetCoreRegionalStepSeedLayers, layerList = cms.vstring('BPix1+BPix2+BPix3', 'BPix2+BPix3+BPix4', 'BPix1+BPix3+BPix4', 'BPix1+BPix2+BPix4', diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index 4ee7937002403..4898fa1327fe8 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -107,8 +107,8 @@ # Cleaner Cleaner = cms.string("trackCleaner") ) -from Configuration.Eras.Modifier_trackingPhase1QuadProp_cff import trackingPhase1QuadProp -trackingPhase1QuadProp.toModify(hiLowPtTripletStepPixelTracks, +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiLowPtTripletStepPixelTracks, SeedingHitSets = cms.InputTag("hiLowPtTripletStepTracksHitTripletsCA") ) @@ -226,4 +226,4 @@ hiLowPtTripletStep_Phase1 = hiLowPtTripletStep.copy() hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitDoublets, hiLowPtTripletStepTracksHitDoubletsCA) hiLowPtTripletStep_Phase1.replace(hiLowPtTripletStepTracksHitTriplets, hiLowPtTripletStepTracksHitTripletsCA) -trackingPhase1QuadProp.toReplaceWith(hiLowPtTripletStep, hiLowPtTripletStep_Phase1) +trackingPhase1.toReplaceWith(hiLowPtTripletStep, hiLowPtTripletStep_Phase1) From 4296c69fb040782137010a61361c55cba16a6d1c Mon Sep 17 00:00:00 2001 From: abaty Date: Wed, 24 May 2017 17:44:48 +0200 Subject: [PATCH 07/10] changed MVA selectors to be off for only Phase-1 --- .../HiRegitMuonDetachedTripletStep_cff.py | 30 +++++++++-- .../python/HiRegitMuonInitialStep_cff.py | 29 ++++++++-- .../python/HiRegitMuonMixedTripletStep_cff.py | 27 +++++++++- .../python/HiRegitMuonPixelLessStep_cff.py | 25 ++++++++- .../python/HiRegitMuonPixelPairStep_cff.py | 25 ++++++++- .../python/HiRegitMuonSeededStep_cff.py | 54 +++++++++++++++++-- 6 files changed, 175 insertions(+), 15 deletions(-) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py index cca669cbb5a86..8e47be187b049 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py @@ -93,7 +93,7 @@ hiRegitMuDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuDetachedTripletStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -105,19 +105,41 @@ name = 'hiRegitMuDetachedTripletStepTight', preFilterName = 'hiRegitMuDetachedTripletStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(False), + useMVA = cms.bool(True), minMVA = cms.double(-0.2) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuDetachedTripletStep', preFilterName = 'hiRegitMuDetachedTripletStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(False), + useMVA = cms.bool(True), minMVA = cms.double(-0.09) ) ) #end of vpset ) - +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuDetachedTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuDetachedTripletStepSelector, trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuDetachedTripletStepLoose', + min_nhits = cms.uint32(8) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuDetachedTripletStepTight', + preFilterName = 'hiRegitMuDetachedTripletStepLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(False), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuDetachedTripletStep', + preFilterName = 'hiRegitMuDetachedTripletStepTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(False), + minMVA = cms.double(-0.09) + ) + ) +) hiRegitMuonDetachedTripletStep = cms.Sequence(hiRegitMuDetachedTripletStepClusters* hiRegitMuDetachedTripletStepSeedLayers* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py index 4419cd13c98b4..91d94e8ac5ebe 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py @@ -80,7 +80,7 @@ hiRegitMuInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuInitialStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter4'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( @@ -92,18 +92,41 @@ name = 'hiRegitMuInitialStepTight', preFilterName = 'hiRegitMuInitialStepLoose', min_nhits = cms.uint32(8), - useMVA = cms.bool(False), + useMVA = cms.bool(True), minMVA = cms.double(-0.38) ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( name = 'hiRegitMuInitialStep', preFilterName = 'hiRegitMuInitialStepTight', min_nhits = cms.uint32(8), - useMVA = cms.bool(False), + useMVA = cms.bool(True), minMVA = cms.double(-0.77) ), ) #end of vpset ) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuInitialStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuInitialStepSelector, trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuInitialStepLoose', + min_nhits = cms.uint32(8) + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuInitialStepTight', + preFilterName = 'hiRegitMuInitialStepLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(False), + minMVA = cms.double(-0.38) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuInitialStep', + preFilterName = 'hiRegitMuInitialStepTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(False), + minMVA = cms.double(-0.77) + ), + ) +) hiRegitMuonInitialStep = cms.Sequence(hiRegitMuInitialStepSeedLayers* hiRegitMuInitialStepTrackingRegions* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py index 825f2f1a66715..2df1738dfef14 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py @@ -125,10 +125,33 @@ hiRegitMuMixedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src = 'hiRegitMuMixedTripletStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuMixedTripletStepLoose', + min_nhits = cms.uint32(8) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuMixedTripletStepTight', + preFilterName = 'hiRegitMuMixedTripletStepLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuMixedTripletStep', + preFilterName = 'hiRegitMuMixedTripletStepTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ) + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuMixedTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuMixedTripletStepSelector, trackSelectors= cms.VPSet( RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( name = 'hiRegitMuMixedTripletStepLoose', min_nhits = cms.uint32(8) @@ -148,7 +171,7 @@ minMVA = cms.double(-0.09) ) ) #end of vpset - ) #end of clone +) hiRegitMuonMixedTripletStep = cms.Sequence(hiRegitMuMixedTripletStepClusters* hiRegitMuMixedTripletStepSeedLayersA* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py index bbb7db5bf0af3..0bf3085345edd 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py @@ -93,10 +93,33 @@ hiRegitMuPixelLessStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuPixelLessStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors = cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuPixelLessStepLoose', + min_nhits = cms.uint32(8) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuPixelLessStepTight', + preFilterName = 'hiRegitMuPixelLessStepLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuPixelLessStep', + preFilterName = 'hiRegitMuPixelLessStepTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset +) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuPixelLessStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuPixelLessStepSelector, trackSelectors= cms.VPSet( RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( name = 'hiRegitMuPixelLessStepLoose', min_nhits = cms.uint32(8) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py index 92d3a5729af37..186bfc3567073 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py @@ -96,10 +96,33 @@ hiRegitMuPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src ='hiRegitMuPixelPairStepTracks', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter6'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuPixelPairStepLoose', + min_nhits = cms.uint32(8) + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuPixelPairStepTight', + preFilterName = 'hiRegitMuPixelPairStepLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.58) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuPixelPairStep', + preFilterName = 'hiRegitMuPixelPairStepTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(0.77) + ), + ) #end of vpset +) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuPixelPairStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuPixelPairStepSelector, trackSelectors= cms.VPSet( RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( name = 'hiRegitMuPixelPairStepLoose', min_nhits = cms.uint32(8) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py index 498b0ba9c1f99..1e30171069f10 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonSeededStep_cff.py @@ -70,10 +70,33 @@ hiRegitMuonSeededTracksInOutSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiRegitMuonSeededTracksInOut', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuonSeededTracksInOutLoose', + min_nhits = cms.uint32(8) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuonSeededTracksInOutTight', + preFilterName = 'hiRegitMuonSeededTracksInOutLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuonSeededTracksInOutHighPurity', + preFilterName = 'hiRegitMuonSeededTracksInOutTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuonSeededTracksInOutSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuonSeededTracksInOutSelector, trackSelectors= cms.VPSet( RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( name = 'hiRegitMuonSeededTracksInOutLoose', min_nhits = cms.uint32(8) @@ -93,15 +116,38 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) hiRegitMuonSeededTracksOutInSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiRegitMuonSeededTracksOutIn', vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'hiRegitMuonSeededTracksOutInLoose', + min_nhits = cms.uint32(8) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMuonSeededTracksOutInTight', + preFilterName = 'hiRegitMuonSeededTracksOutInLoose', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMuonSeededTracksOutInHighPurity', + preFilterName = 'hiRegitMuonSeededTracksOutInTight', + min_nhits = cms.uint32(8), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuonSeededTracksOutInSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiRegitMuonSeededTracksOutInSelector, trackSelectors= cms.VPSet( RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( name = 'hiRegitMuonSeededTracksOutInLoose', min_nhits = cms.uint32(8) @@ -121,7 +167,7 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) hiRegitMuonSeededStepCore = cms.Sequence( hiRegitMuonSeededSeedsInOut + hiRegitMuonSeededTrackCandidatesInOut + hiRegitMuonSeededTracksInOut + From 9fbc21c1b387eea7b5d9c738b05bbe47fda11c28 Mon Sep 17 00:00:00 2001 From: abaty Date: Wed, 24 May 2017 18:02:50 +0200 Subject: [PATCH 08/10] changed MVA selectors to be off for only Phase-1; part II --- .../HiTracking/python/HISelectedTracks_cfi.py | 25 +++++++++++++++-- .../python/hiDetachedQuadStep_cff.py | 28 +++++++++++++++++-- .../python/hiDetachedTripletStep_cff.py | 28 +++++++++++++++++-- .../python/hiHighPtTripletStep_cff.py | 28 +++++++++++++++++-- .../HiTracking/python/hiLowPtQuadStep_cff.py | 28 +++++++++++++++++-- .../python/hiLowPtTripletStep_cff.py | 25 +++++++++++++++-- .../HiTracking/python/hiPixelPairStep_cff.py | 25 +++++++++++++++-- 7 files changed, 173 insertions(+), 14 deletions(-) diff --git a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py index 2d3f31e329e4d..caa49ecf559c1 100644 --- a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py +++ b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py @@ -6,10 +6,31 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiGlobalPrimTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter4'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiInitialStepLoose', + useMVA = cms.bool(False) + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiInitialStepTight', + preFilterName = 'hiInitialStepLoose', + useMVA = cms.bool(True), + minMVA = cms.double(-0.77) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiInitialStep', + preFilterName = 'hiInitialStepTight', + useMVA = cms.bool(True), + minMVA = cms.double(-0.77) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiInitialStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiInitialStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiInitialStepLoose', useMVA = cms.bool(False) @@ -27,7 +48,7 @@ minMVA = cms.double(-0.77) ), ) #end of vpset - ) #end of clone +) diff --git a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py index 57672e21bb5f1..02391c860ef04 100644 --- a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py @@ -167,10 +167,34 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiDetachedQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiDetachedQuadStepTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter10'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiDetachedQuadStepTight', + preFilterName = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = cms.bool(True), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiDetachedQuadStep', + preFilterName = 'hiDetachedQuadStepTight', + applyAdaptedPVCuts = cms.bool(True), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiDetachedQuadStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiDetachedQuadStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiDetachedQuadStepLoose', applyAdaptedPVCuts = cms.bool(False), @@ -191,7 +215,7 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiDetachedQuadStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index 3ecd74fa63106..ad22f4bd631d1 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -172,10 +172,34 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiDetachedTripletStepTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter7'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiDetachedTripletStepTight', + preFilterName = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiDetachedTripletStep', + preFilterName = 'hiDetachedTripletStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiDetachedTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiDetachedTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiDetachedTripletStepLoose', applyAdaptedPVCuts = cms.bool(False), @@ -196,7 +220,7 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiDetachedTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( diff --git a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py index 7accc6e578024..c5fc47e3dc112 100644 --- a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py @@ -164,10 +164,34 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiHighPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiHighPtTripletStepTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter9'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiHighPtTripletStepTight', + preFilterName = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiHighPtTripletStep', + preFilterName = 'hiHighPtTripletStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiHighPtTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiHighPtTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiHighPtTripletStepLoose', applyAdaptedPVCuts = cms.bool(False), @@ -188,7 +212,7 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiHighPtTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py index 7049f8b1f2370..9df4a5810c9d5 100644 --- a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -168,10 +168,34 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiLowPtQuadStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiLowPtQuadStepTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter8'),#FIXME MVA for new iteration GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(False), + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiLowPtQuadStepTight', + preFilterName = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.2) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiLowPtQuadStep', + preFilterName = 'hiLowPtQuadStepTight', + applyAdaptedPVCuts = cms.bool(False), + useMVA = cms.bool(True), + minMVA = cms.double(-0.09) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiLowPtQuadStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiLowPtQuadStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiLowPtQuadStepLoose', applyAdaptedPVCuts = cms.bool(False), @@ -192,7 +216,7 @@ minMVA = cms.double(-0.09) ), ) #end of vpset - ) #end of clone +) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiLowPtQuadStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index 4898fa1327fe8..a843ca615a7c4 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -174,10 +174,31 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiLowPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiLowPtTripletStepTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter5'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'relpterr', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiLowPtTripletStepLoose', + useMVA = cms.bool(False) + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiLowPtTripletStepTight', + preFilterName = 'hiLowPtTripletStepLoose', + useMVA = cms.bool(True), + minMVA = cms.double(-0.58) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiLowPtTripletStep', + preFilterName = 'hiLowPtTripletStepTight', + useMVA = cms.bool(True), + minMVA = cms.double(0.35) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiLowPtTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiLowPtTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiLowPtTripletStepLoose', useMVA = cms.bool(False) @@ -195,7 +216,7 @@ minMVA = cms.double(0.35) ), ) #end of vpset - ) #end of clone +) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi diff --git a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py index e1d92f7e41d86..e1894308c8f71 100644 --- a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py +++ b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py @@ -121,10 +121,31 @@ import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( src='hiPixelPairGlobalPrimTracks', - useAnyMVA = cms.bool(False), + useAnyMVA = cms.bool(True), GBRForestLabel = cms.string('HIMVASelectorIter6'), GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), trackSelectors= cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiPixelPairStepLoose', + useMVA = cms.bool(False) + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiPixelPairStepTight', + preFilterName = 'hiPixelPairStepLoose', + useMVA = cms.bool(True), + minMVA = cms.double(-0.58) + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiPixelPairStep', + preFilterName = 'hiPixelPairStepTight', + useMVA = cms.bool(True), + minMVA = cms.double(0.77) + ), + ) #end of vpset + ) #end of clone +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiPixelPairStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiPixelPairStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiPixelPairStepLoose', useMVA = cms.bool(False) @@ -142,7 +163,7 @@ minMVA = cms.double(0.77) ), ) #end of vpset - ) #end of clone +) From bb70f2d64e8eafce5bf65ddc9a7629ee46d280ff Mon Sep 17 00:00:00 2001 From: abaty Date: Wed, 24 May 2017 20:26:59 +0200 Subject: [PATCH 09/10] small change to Detached Triplets for phase1 --- RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index ad22f4bd631d1..dda400da7480d 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -63,6 +63,10 @@ from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * hiDetachedTripletStepTracksHitTriplets = _pixelTripletHLTEDProducer.clone( doublets = "hiDetachedTripletStepTracksHitDoublets", + extraHitRPhitolerance = 0.0, + extraHitRZtolerance = 0.0, + maxElement = 1000000, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), produceSeedingHitSets = True, ) From 193f14ec7db2ae85c442f57b2be91152dbee5bb6 Mon Sep 17 00:00:00 2001 From: abaty Date: Mon, 29 May 2017 16:13:33 +0200 Subject: [PATCH 10/10] fix phase 1 HIMuon Initial step confusion between CA and non-CA doublet list (currently non-CA) --- RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py index 91d94e8ac5ebe..cf3497c0078f6 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py @@ -35,6 +35,9 @@ trackingRegions = "hiRegitMuInitialStepTrackingRegions", clusterCheck = "hiRegitMuClusterCheck" ) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toModify(hiRegitMuInitialStepHitDoublets, layerPairs = [0]) + hiRegitMuInitialStepHitTriplets = RecoTracker.IterativeTracking.InitialStep_cff.initialStepHitTriplets.clone( doublets = "hiRegitMuInitialStepHitDoublets" )