From eba4f1ddea526307d65ad39c6a78c84079297d10 Mon Sep 17 00:00:00 2001 From: Jeongeun Lee Date: Wed, 18 Nov 2020 09:37:46 +0100 Subject: [PATCH] drop type specs in RecoHI{Configuration, HiTracking} --- .../python/Reconstruction_hiPF_cff.py | 62 +++--- .../python/Reconstruction_hiSignal_cff.py | 7 +- .../python/peripheralHLTFilter_cff.py | 35 +-- .../python/HIBestVertexSequences_cff.py | 26 +-- .../HIInitialJetCoreClusterSplitting_cff.py | 18 +- .../python/HILowPtConformalPixelTracks_cfi.py | 107 +++++----- .../python/HIPixel3PrimTracks_cfi.py | 22 +- .../python/HIPixelVerticesPreSplitting_cff.py | 48 +++-- .../HiTracking/python/HISelectedTracks_cfi.py | 78 +++---- .../python/HITrackingRegionProducer_cfi.py | 33 +-- .../MergeRegitTrackCollectionsHI_cff.py | 26 +-- .../python/MergeTrackCollectionsHI_cff.py | 200 +++++++++--------- .../python/hiDetachedQuadStep_cff.py | 132 ++++++------ .../python/hiDetachedTripletStep_cff.py | 143 ++++++------- .../python/hiHighPtTripletStep_cff.py | 133 ++++++------ .../python/hiJetCoreRegionalStep_cff.py | 82 ++++--- .../HiTracking/python/hiLowPtQuadStep_cff.py | 135 ++++++------ .../python/hiLowPtTripletStep_cff.py | 117 +++++----- .../hiMergedConformalPixelTracking_cff.py | 83 ++++---- .../python/hiMixedTripletStep_cff.py | 74 +++---- .../python/hiMultiTrackSelector_cfi.py | 47 ++-- .../HiTracking/python/hiPixelLessStep_cff.py | 78 +++---- .../HiTracking/python/hiPixelPairStep_cff.py | 179 ++++++++-------- .../python/hiRegitDetachedTripletStep_cff.py | 84 ++++---- .../python/hiRegitInitialStep_cff.py | 76 +++---- .../python/hiRegitLowPtTripletStep_cff.py | 97 +++++---- .../python/hiRegitMixedTripletStep_cff.py | 135 ++++++------ .../python/hiRegitPixelPairStep_cff.py | 88 ++++---- RecoHI/HiTracking/python/hiTobTecStep_cff.py | 78 +++---- 29 files changed, 1231 insertions(+), 1192 deletions(-) diff --git a/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py b/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py index 3f42f98b48b36..bbe268867a252 100644 --- a/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py +++ b/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py @@ -6,38 +6,38 @@ # run a trimmed down PF sequence with heavy-ion vertex, no conversions, nucl int, etc. from RecoParticleFlow.PFProducer.particleFlowEGamma_cff import * -particleFlowEGamma.vertexCollection = cms.InputTag("hiSelectedVertex") -gedGsfElectronCores.ctfTracks = cms.InputTag("hiGeneralTracks") -gedGsfElectronsTmp.ctfTracksTag = cms.InputTag("hiGeneralTracks") -gedGsfElectronsTmp.vtxTag = cms.InputTag("hiSelectedVertex") -gedGsfElectronsTmp.preselection.minSCEtBarrel = cms.double(15.0) -gedGsfElectronsTmp.preselection.minSCEtEndcaps = cms.double(15.0) -gedGsfElectronsTmp.fillConvVtxFitProb = cms.bool(False) - -gedPhotonsTmp.primaryVertexProducer = cms.InputTag("hiSelectedVertex") -gedPhotonsTmp.isolationSumsCalculatorSet.trackProducer = cms.InputTag("hiGeneralTracks") -gedPhotons.primaryVertexProducer = cms.InputTag("hiSelectedVertex") -gedPhotons.isolationSumsCalculatorSet.trackProducer = cms.InputTag("hiGeneralTracks") -photonIDValueMaps.vertices = cms.InputTag("hiSelectedVertex") +particleFlowEGamma.vertexCollection = "hiSelectedVertex" +gedGsfElectronCores.ctfTracks = "hiGeneralTracks" +gedGsfElectronsTmp.ctfTracksTag = "hiGeneralTracks" +gedGsfElectronsTmp.vtxTag = "hiSelectedVertex" +gedGsfElectronsTmp.preselection.minSCEtBarrel = 15.0 +gedGsfElectronsTmp.preselection.minSCEtEndcaps = 15.0 +gedGsfElectronsTmp.fillConvVtxFitProb = False + +gedPhotonsTmp.primaryVertexProducer = "hiSelectedVertex" +gedPhotonsTmp.isolationSumsCalculatorSet.trackProducer = "hiGeneralTracks" +gedPhotons.primaryVertexProducer = "hiSelectedVertex" +gedPhotons.isolationSumsCalculatorSet.trackProducer = "hiGeneralTracks" +photonIDValueMaps.vertices = "hiSelectedVertex" from RecoHI.HiEgammaAlgos.photonIsolationHIProducer_cfi import photonIsolationHIProducer -photonIsolationHIProducerGED = photonIsolationHIProducer.clone(photonProducer=cms.InputTag("gedPhotonsTmp")) +photonIsolationHIProducerGED = photonIsolationHIProducer.clone(photonProducer="gedPhotonsTmp") #These are set for consistency w/ HiElectronSequence, but these cuts need to be studied -gedGsfElectronsTmp.preselection.maxHOverEBarrelCone = cms.double(0.25) -gedGsfElectronsTmp.preselection.maxHOverEEndcapsCone = cms.double(0.25) -gedGsfElectronsTmp.preselection.maxHOverEBarrelTower = cms.double(0.0) -gedGsfElectronsTmp.preselection.maxHOverEEndcapsTower = cms.double(0.0) -gedGsfElectronsTmp.preselection.maxEOverPBarrel = cms.double(2.) -gedGsfElectronsTmp.preselection.maxEOverPEndcaps = cms.double(2.) - -ootPhotonsTmp.primaryVertexProducer = cms.InputTag("hiSelectedVertex") -ootPhotonsTmp.isolationSumsCalculatorSet.trackProducer = cms.InputTag("hiGeneralTracks") -ootPhotons.primaryVertexProducer = cms.InputTag("hiSelectedVertex") -ootPhotons.isolationSumsCalculatorSet.trackProducer = cms.InputTag("hiGeneralTracks") +gedGsfElectronsTmp.preselection.maxHOverEBarrelCone = 0.25 +gedGsfElectronsTmp.preselection.maxHOverEEndcapsCone = 0.25 +gedGsfElectronsTmp.preselection.maxHOverEBarrelTower = 0.0 +gedGsfElectronsTmp.preselection.maxHOverEEndcapsTower = 0.0 +gedGsfElectronsTmp.preselection.maxEOverPBarrel = 2. +gedGsfElectronsTmp.preselection.maxEOverPEndcaps = 2. + +ootPhotonsTmp.primaryVertexProducer = "hiSelectedVertex" +ootPhotonsTmp.isolationSumsCalculatorSet.trackProducer = "hiGeneralTracks" +ootPhotons.primaryVertexProducer = "hiSelectedVertex" +ootPhotons.isolationSumsCalculatorSet.trackProducer = "hiGeneralTracks" from RecoParticleFlow.Configuration.RecoParticleFlow_cff import * -mvaElectrons.vertexTag = cms.InputTag("hiSelectedVertex") +mvaElectrons.vertexTag = "hiSelectedVertex" particleFlowBlock.elementImporters = cms.VPSet( cms.PSet( importerName = cms.string("GSFTrackImporter"), @@ -79,16 +79,16 @@ source = cms.InputTag("particleFlowClusterPS") ) ) -particleFlowTmp.postMuonCleaning = cms.bool(False) -particleFlowTmp.vertexCollection = cms.InputTag("hiSelectedVertex") -particleFlowTmp.muons = cms.InputTag("hiMuons1stStep") -particleFlowTmp.usePFConversions = cms.bool(False) +particleFlowTmp.postMuonCleaning = False +particleFlowTmp.vertexCollection = "hiSelectedVertex" +particleFlowTmp.muons = "hiMuons1stStep" +particleFlowTmp.usePFConversions = False pfNoPileUpIso.enable = False pfPileUpIso.Enable = False pfNoPileUp.enable = False pfPileUp.Enable = False -particleFlow.Muons = cms.InputTag("muons","hiMuons1stStep2muonsMap") +particleFlow.Muons = "muons:hiMuons1stStep2muonsMap" # local reco must run before electrons (RecoHI/HiEgammaAlgos), due to PF integration diff --git a/RecoHI/Configuration/python/Reconstruction_hiSignal_cff.py b/RecoHI/Configuration/python/Reconstruction_hiSignal_cff.py index 67892270f1db3..6d0bfa0500645 100644 --- a/RecoHI/Configuration/python/Reconstruction_hiSignal_cff.py +++ b/RecoHI/Configuration/python/Reconstruction_hiSignal_cff.py @@ -12,7 +12,7 @@ #Tracks hiSignalGlobalPrimTracks = hiGlobalPrimTracks.clone() hiSignalSelectedTracks = hiSelectedTracks.clone() -hiSelectedTracks.src = cms.InputTag("hiSignalGlobalPrimTracks") +hiSelectedTracks.src = "hiSignalGlobalPrimTracks" heavyIonTrackingTask = cms.Task(hiPixelVerticesTask ,hiPrimSeedsTask ,hiPrimTrackCandidates @@ -38,8 +38,9 @@ runjets = cms.Sequence(runjetsTask) #Muons -hiSignalGlobalMuons = globalMuons.clone() -hiSignalGlobalMuons.TrackerCollectionLabel = 'hiSignalGlobalPrimTracks' +hiSignalGlobalMuons = globalMuons.clone( + TrackerCollectionLabel = 'hiSignalGlobalPrimTracks' +) muontrackingTask = cms.Task(standAloneMuonSeedsTask,standAloneMuons,hiSignalGlobalMuons) muontracking = cms.Sequence(muontrackingTask) diff --git a/RecoHI/Configuration/python/peripheralHLTFilter_cff.py b/RecoHI/Configuration/python/peripheralHLTFilter_cff.py index 9d6c0d2adc1c6..e7794cb7b389b 100644 --- a/RecoHI/Configuration/python/peripheralHLTFilter_cff.py +++ b/RecoHI/Configuration/python/peripheralHLTFilter_cff.py @@ -1,22 +1,23 @@ import FWCore.ParameterSet.Config as cms import HLTrigger.HLTfilters.hltHighLevel_cfi -hltPerhiphHI = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone() -hltPerhiphHI.HLTPaths = ["HLT_HISinglePhoton*_Eta*_Cent50_100_*", - "HLT_HISinglePhoton*_Eta*_Cent30_100_*", - "HLT_HIFullTrack*_L1Centrality30100_*", - "HLT_HIPuAK4CaloJet*_Eta5p1_Cent50_100_v*", - "HLT_HIPuAK4CaloJet*_Eta5p1_Cent30_100_v*", - "HLT_HIDmesonHITrackingGlobal_Dpt*_Cent50_100_v*", - "HLT_HIDmesonHITrackingGlobal_Dpt*_Cent30_100_v*", - "HLT_HIL1Centralityext30100MinimumumBiasHF*", - "HLT_HIL1Centralityext50100MinimumumBiasHF*", - "HLT_HIQ2*005_Centrality3050_v*", - "HLT_HIQ2*005_Centrality5070_v*", - "HLT_HICastor*", - "HLT_HIL1Castor*", - "HLT_HIUPC*"] -hltPerhiphHI.throw = False -hltPerhiphHI.andOr = True +hltPerhiphHI = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone( + HLTPaths = ["HLT_HISinglePhoton*_Eta*_Cent50_100_*", + "HLT_HISinglePhoton*_Eta*_Cent30_100_*", + "HLT_HIFullTrack*_L1Centrality30100_*", + "HLT_HIPuAK4CaloJet*_Eta5p1_Cent50_100_v*", + "HLT_HIPuAK4CaloJet*_Eta5p1_Cent30_100_v*", + "HLT_HIDmesonHITrackingGlobal_Dpt*_Cent50_100_v*", + "HLT_HIDmesonHITrackingGlobal_Dpt*_Cent30_100_v*", + "HLT_HIL1Centralityext30100MinimumumBiasHF*", + "HLT_HIL1Centralityext50100MinimumumBiasHF*", + "HLT_HIQ2*005_Centrality3050_v*", + "HLT_HIQ2*005_Centrality5070_v*", + "HLT_HICastor*", + "HLT_HIL1Castor*", + "HLT_HIUPC*"], + throw = False, + andOr = True +) peripheralHLTFilterSequence = cms.Sequence( hltPerhiphHI ) diff --git a/RecoHI/HiTracking/python/HIBestVertexSequences_cff.py b/RecoHI/HiTracking/python/HIBestVertexSequences_cff.py index 1692790dfef92..f7f6e2892853e 100644 --- a/RecoHI/HiTracking/python/HIBestVertexSequences_cff.py +++ b/RecoHI/HiTracking/python/HIBestVertexSequences_cff.py @@ -3,7 +3,7 @@ # sort by number of tracks and keep the best hiBestAdaptiveVertex = cms.EDFilter("HIBestVertexSelection", src = cms.InputTag("hiPixelAdaptiveVertex"), - maxNumber = cms.uint32(1) + maxNumber = cms.uint32(1) ) # select best of precise vertex, fast vertex, and beamspot @@ -19,18 +19,18 @@ from RecoHI.HiTracking.HIPixelAdaptiveVertex_cfi import * hiOfflinePrimaryVertices=hiPixelAdaptiveVertex.clone( # vertexing run AFTER tracking - TrackLabel = cms.InputTag("hiGeneralTracks"), + TrackLabel = "hiGeneralTracks", - TkFilterParameters = cms.PSet( - algorithm = cms.string('filterWithThreshold'), - maxNormalizedChi2 = cms.double(5.0), - minPixelLayersWithHits=cms.int32(3), #0 missing pix hit (Run 1 pixels) - minSiliconLayersWithHits = cms.int32(5),#at least 8 (3pix+5strip) hits total - maxD0Significance = cms.double(3.0), #default is 5.0 in pp; 3.0 here suppresses split vtxs - minPt = cms.double(0.0), - maxEta = cms.double(100.), - trackQuality = cms.string("any"), - numTracksThreshold = cms.int32(2) + TkFilterParameters = dict( + algorithm = 'filterWithThreshold', + maxNormalizedChi2 = 5.0, + minPixelLayersWithHits = 3, #0 missing pix hit (Run 1 pixels) + minSiliconLayersWithHits = 5, #at least 8 (3pix+5strip) hits total + maxD0Significance = 3.0, #default is 5.0 in pp; 3.0 here suppresses split vtxs + minPt = 0.0, + maxEta = 100., + trackQuality = "any", + numTracksThreshold = 2 ) ) from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 @@ -45,7 +45,7 @@ ) # select best of precise vertex, fast vertex, and beamspot hiSelectedVertex = hiSelectedPixelVertex.clone( - useFinalAdaptiveVertexCollection = cms.bool(True), + useFinalAdaptiveVertexCollection = True, finalAdaptiveVertexCollection = cms.InputTag("hiBestOfflinePrimaryVertex") ) bestFinalHiVertexTask = cms.Task(hiOfflinePrimaryVertices , hiBestOfflinePrimaryVertex , hiSelectedVertex ) diff --git a/RecoHI/HiTracking/python/HIInitialJetCoreClusterSplitting_cff.py b/RecoHI/HiTracking/python/HIInitialJetCoreClusterSplitting_cff.py index ee9297cf55aa6..d89861bd40799 100644 --- a/RecoHI/HiTracking/python/HIInitialJetCoreClusterSplitting_cff.py +++ b/RecoHI/HiTracking/python/HIInitialJetCoreClusterSplitting_cff.py @@ -10,22 +10,26 @@ hiCaloTowerForTrkPreSplitting = hiCaloTowerForTrk.clone() hiAkPu4CaloJetsForTrkPreSplitting = akPu4CaloJetsForTrk.clone( src = 'hiCaloTowerForTrkPreSplitting', - srcPVs = 'hiSelectedVertexPreSplitting') + srcPVs = 'hiSelectedVertexPreSplitting' +) hiAkPu4CaloJetsCorrectedPreSplitting = akPu4CaloJetsCorrected.clone( - src = 'hiAkPu4CaloJetsForTrkPreSplitting') + src = 'hiAkPu4CaloJetsForTrkPreSplitting' +) hiAkPu4CaloJetsSelectedPreSplitting = akPu4CaloJetsSelected.clone( - src = 'hiAkPu4CaloJetsCorrectedPreSplitting') + src = 'hiAkPu4CaloJetsCorrectedPreSplitting' +) hiJetsForCoreTrackingPreSplitting = hiJetsForCoreTracking.clone( - src = 'hiAkPu4CaloJetsSelectedPreSplitting') + src = 'hiAkPu4CaloJetsSelectedPreSplitting' +) from RecoLocalTracker.SubCollectionProducers.jetCoreClusterSplitter_cfi import jetCoreClusterSplitter siPixelClusters = jetCoreClusterSplitter.clone( - pixelClusters = cms.InputTag('siPixelClustersPreSplitting'), + pixelClusters = 'siPixelClustersPreSplitting', vertices = 'hiSelectedVertexPreSplitting', cores = 'hiJetsForCoreTrackingPreSplitting', - deltaRmax = cms.double(0.1), - ptMin = cms.double(50) + deltaRmax = 0.1, + ptMin = 50 ) from RecoLocalTracker.SiPixelRecHits.SiPixelRecHits_cfi import siPixelRecHits diff --git a/RecoHI/HiTracking/python/HILowPtConformalPixelTracks_cfi.py b/RecoHI/HiTracking/python/HILowPtConformalPixelTracks_cfi.py index 84ea46533d882..831cf4b8d0525 100644 --- a/RecoHI/HiTracking/python/HILowPtConformalPixelTracks_cfi.py +++ b/RecoHI/HiTracking/python/HILowPtConformalPixelTracks_cfi.py @@ -10,15 +10,15 @@ # Hit ntuplets hiConformalPixelTracksHitDoublets = _hitPairEDProducer.clone( - clusterCheck = "", - seedingLayers = "PixelLayerTriplets", + clusterCheck = "", + seedingLayers = "PixelLayerTriplets", trackingRegions = "hiTrackingRegionWithVertex", - maxElement = 50000000, + maxElement = 50000000, produceIntermediateHitDoublets = True, ) hiConformalPixelTracksHitTriplets = _pixelTripletHLTEDProducer.clone( - doublets = "hiConformalPixelTracksHitDoublets", + doublets = "hiConformalPixelTracksHitDoublets", maxElement = 5000000, # increase threshold for triplets in generation step (default: 100000) produceSeedingHitSets = True, ) @@ -49,78 +49,81 @@ #Tracking regions - use PV from pp tracking from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices -hiConformalPixelTracksPhase1TrackingRegions = globalTrackingRegionWithVertices.clone(RegionPSet=dict( - precise = True, - useMultipleScattering = False, - useFakeVertices = False, - beamSpot = "offlineBeamSpot", - useFixedError = True, - nSigmaZ = 3.0, - sigmaZVertex = 3.0, - fixedError = 0.2, - VertexCollection = "offlinePrimaryVertices", - ptMin = 0.3, - useFoundVertices = True, - originRadius = 0.2 -)) +hiConformalPixelTracksPhase1TrackingRegions = globalTrackingRegionWithVertices.clone( + RegionPSet = dict( + precise = True, + useMultipleScattering = False, + useFakeVertices = False, + beamSpot = "offlineBeamSpot", + useFixedError = True, + nSigmaZ = 3.0, + sigmaZVertex = 3.0, + fixedError = 0.2, + VertexCollection = "offlinePrimaryVertices", + ptMin = 0.3, + useFoundVertices = True, + originRadius = 0.2 + ) +) # SEEDING LAYERS # Using 4 layers layerlist from RecoTracker.IterativeTracking.LowPtQuadStep_cff import lowPtQuadStepSeedLayers -hiConformalPixelTracksPhase1SeedLayers = lowPtQuadStepSeedLayers.clone() -hiConformalPixelTracksPhase1SeedLayers.BPix = cms.PSet( - HitProducer = cms.string('siPixelRecHits'), - TTRHBuilder = cms.string('WithTrackAngle'), -) -hiConformalPixelTracksPhase1SeedLayers.FPix = cms.PSet( - HitProducer = cms.string('siPixelRecHits'), - TTRHBuilder = cms.string('WithTrackAngle'), +hiConformalPixelTracksPhase1SeedLayers = lowPtQuadStepSeedLayers.clone( + BPix = cms.PSet( + HitProducer = cms.string('siPixelRecHits'), + TTRHBuilder = cms.string('WithTrackAngle'), + ), + FPix = cms.PSet( + HitProducer = cms.string('siPixelRecHits'), + TTRHBuilder = cms.string('WithTrackAngle'), + ) ) # Hit ntuplets from RecoTracker.IterativeTracking.LowPtQuadStep_cff import lowPtQuadStepHitDoublets hiConformalPixelTracksPhase1HitDoubletsCA = lowPtQuadStepHitDoublets.clone( - seedingLayers = "hiConformalPixelTracksPhase1SeedLayers", - trackingRegions = "hiConformalPixelTracksPhase1TrackingRegions" + seedingLayers = "hiConformalPixelTracksPhase1SeedLayers", + trackingRegions = "hiConformalPixelTracksPhase1TrackingRegions" ) from RecoTracker.IterativeTracking.LowPtQuadStep_cff import lowPtQuadStepHitQuadruplets hiConformalPixelTracksPhase1HitQuadrupletsCA = lowPtQuadStepHitQuadruplets.clone( - doublets = "hiConformalPixelTracksPhase1HitDoubletsCA", - CAPhiCut = 0.2, - CAThetaCut = 0.0012, - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('none') - ), - extraHitRPhitolerance = 0.032, - maxChi2 = cms.PSet( - enabled = cms.bool(True), - pt1 = cms.double(0.7), - pt2 = cms.double(2), - value1 = cms.double(200), - value2 = cms.double(50) - ) + doublets = "hiConformalPixelTracksPhase1HitDoubletsCA", + CAPhiCut = 0.2, + CAThetaCut = 0.0012, + SeedComparitorPSet = cms.PSet( + ComponentName = cms.string('none') + ), + extraHitRPhitolerance = 0.032, + maxChi2 = cms.PSet( + enabled = cms.bool(True), + pt1 = cms.double(0.7), + pt2 = cms.double(2), + value1 = cms.double(200), + value2 = cms.double(50) + ) ) #Filter hiConformalPixelTracksPhase1Filter = hiConformalPixelFilter.clone( - VertexCollection = "offlinePrimaryVertices", - chi2 = 999.9, - lipMax = 999.0, - nSigmaLipMaxTolerance = 999.9, - nSigmaTipMaxTolerance = 999.0, - ptMax = 999999, - ptMin = 0.30, - tipMax = 999.0 + VertexCollection = "offlinePrimaryVertices", + chi2 = 999.9, + lipMax = 999.0, + nSigmaLipMaxTolerance = 999.9, + nSigmaTipMaxTolerance = 999.0, + ptMax = 999999, + ptMin = 0.30, + tipMax = 999.0 ) from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel phase1Pixel.toModify(hiConformalPixelTracks, Cleaner = 'pixelTrackCleanerBySharedHits', - Filter = "hiConformalPixelTracksPhase1Filter", - Fitter = "pixelFitterByConformalMappingAndLine", + Filter = "hiConformalPixelTracksPhase1Filter", + Fitter = "pixelFitterByConformalMappingAndLine", SeedingHitSets = "hiConformalPixelTracksPhase1HitQuadrupletsCA", ) diff --git a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py index dd270b9469fc0..bce23461ace34 100644 --- a/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py +++ b/RecoHI/HiTracking/python/HIPixel3PrimTracks_cfi.py @@ -15,10 +15,10 @@ # Hit ntuplets hiPixel3PrimTracksHitDoublets = _hitPairEDProducer.clone( - clusterCheck = "", - seedingLayers = "PixelLayerTriplets", + clusterCheck = "", + seedingLayers = "PixelLayerTriplets", trackingRegions = "hiTrackingRegionWithVertex", - maxElement = 50000000, + maxElement = 50000000, produceIntermediateHitDoublets = True, ) from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 @@ -28,29 +28,29 @@ hiPixel3PrimTracksHitTriplets = _pixelTripletHLTEDProducer.clone( - doublets = "hiPixel3PrimTracksHitDoublets", + doublets = "hiPixel3PrimTracksHitDoublets", maxElement = 1000000, # increase threshold for triplets in generation step (default: 100000) produceSeedingHitSets = True, produceIntermediateHitTriplets = True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer -hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone() -hiPixel3PrimTracksHitDoubletsCA.layerPairs = [0,1,2] - +hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone( + layerPairs = [0,1,2] +) hiPixel3PrimTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiPixel3PrimTracksHitDoubletsCA", extraHitRPhitolerance = hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, - SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet, + SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 200, value2 = 50, ), useBendingCorrection = True, - fitFastCircle = True, + fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0012, - CAPhiCut = 0.2, + CAPhiCut = 0.2, ) # Pixel tracks @@ -71,7 +71,7 @@ Cleaner = cms.string("trackCleaner") ) trackingPhase1.toModify(hiPixel3PrimTracks, - SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitQuadrupletsCA"), + SeedingHitSets = "hiPixel3PrimTracksHitQuadrupletsCA", ) hiPixel3PrimTracksTask = cms.Task( diff --git a/RecoHI/HiTracking/python/HIPixelVerticesPreSplitting_cff.py b/RecoHI/HiTracking/python/HIPixelVerticesPreSplitting_cff.py index cba3bf144b0a7..a169d1dc32171 100644 --- a/RecoHI/HiTracking/python/HIPixelVerticesPreSplitting_cff.py +++ b/RecoHI/HiTracking/python/HIPixelVerticesPreSplitting_cff.py @@ -2,48 +2,62 @@ from RecoHI.HiTracking.HIPixelVertices_cff import * -hiPixelClusterVertexPreSplitting = hiPixelClusterVertex.clone( pixelRecHits=cms.string("siPixelRecHitsPreSplitting") ) +hiPixelClusterVertexPreSplitting = hiPixelClusterVertex.clone( + pixelRecHits = "siPixelRecHitsPreSplitting" +) hiProtoTrackFilterPreSplitting = hiProtoTrackFilter.clone( siPixelRecHits = "siPixelRecHitsPreSplitting" ) -hiPixel3ProtoTracksTrackingRegionsPreSplitting = hiTrackingRegionFromClusterVtx.clone(RegionPSet=dict( - siPixelRecHits = "siPixelRecHitsPreSplitting", - VertexCollection = "hiPixelClusterVertexPreSplitting" -)) +hiPixel3ProtoTracksTrackingRegionsPreSplitting = hiTrackingRegionFromClusterVtx.clone( + RegionPSet = dict( + siPixelRecHits = "siPixelRecHitsPreSplitting", + VertexCollection = "hiPixelClusterVertexPreSplitting" + ) +) + hiPixel3PRotoTracksHitDoubletsPreSplitting = hiPixel3ProtoTracksHitDoublets.clone( seedingLayers = "PixelLayerTripletsPreSplitting", trackingRegions = "hiPixel3ProtoTracksTrackingRegionsPreSplitting", ) + hiPixel3ProtoTracksHitTripletsPreSplitting = hiPixel3ProtoTracksHitTriplets.clone( doublets = "hiPixel3PRotoTracksHitDoubletsPreSplitting" ) hiPixel3ProtoTracksPreSplitting = hiPixel3ProtoTracks.clone( SeedingHitSets = "hiPixel3ProtoTracksHitTripletsPreSplitting", - Filter = "hiProtoTrackFilterPreSplitting", + Filter = "hiProtoTrackFilterPreSplitting", +) + +hiPixelMedianVertexPreSplitting = hiPixelMedianVertex.clone( + TrackCollection = 'hiPixel3ProtoTracksPreSplitting' ) -hiPixelMedianVertexPreSplitting = hiPixelMedianVertex.clone( TrackCollection = cms.InputTag('hiPixel3ProtoTracksPreSplitting') ) hiSelectedProtoTracksPreSplitting = hiSelectedProtoTracks.clone( - src = cms.InputTag("hiPixel3ProtoTracksPreSplitting"), - VertexCollection = cms.InputTag("hiPixelMedianVertexPreSplitting") + src = "hiPixel3ProtoTracksPreSplitting", + VertexCollection = "hiPixelMedianVertexPreSplitting" ) + hiPixelAdaptiveVertexPreSplitting = hiPixelAdaptiveVertex.clone( - TrackLabel = cms.InputTag("hiSelectedProtoTracksPreSplitting") + TrackLabel = "hiSelectedProtoTracksPreSplitting" +) + +hiBestAdaptiveVertexPreSplitting = hiBestAdaptiveVertex.clone( + src = "hiPixelAdaptiveVertexPreSplitting" ) -hiBestAdaptiveVertexPreSplitting = hiBestAdaptiveVertex.clone( src = cms.InputTag("hiPixelAdaptiveVertexPreSplitting") ) + hiSelectedVertexPreSplitting = hiSelectedPixelVertex.clone( - adaptiveVertexCollection = cms.InputTag("hiBestAdaptiveVertexPreSplitting"), - medianVertexCollection = cms.InputTag("hiPixelMedianVertexPreSplitting") + adaptiveVertexCollection = "hiBestAdaptiveVertexPreSplitting", + medianVertexCollection = "hiPixelMedianVertexPreSplitting" ) bestHiVertexPreSplittingTask = cms.Task( hiBestAdaptiveVertexPreSplitting , hiSelectedVertexPreSplitting ) -PixelLayerTripletsPreSplitting = PixelLayerTriplets.clone() -PixelLayerTripletsPreSplitting.FPix.HitProducer = 'siPixelRecHitsPreSplitting' -PixelLayerTripletsPreSplitting.BPix.HitProducer = 'siPixelRecHitsPreSplitting' - +PixelLayerTripletsPreSplitting = PixelLayerTriplets.clone( + FPix = dict(HitProducer = cms.string('siPixelRecHitsPreSplitting')), + BPix = dict(HitProducer = cms.string('siPixelRecHitsPreSplitting')) +) hiPixelVerticesPreSplittingTask = cms.Task(hiPixelClusterVertexPreSplitting , PixelLayerTripletsPreSplitting , hiPixel3ProtoTracksTrackingRegionsPreSplitting diff --git a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py index d36776dbe3f49..6241b0f76cde0 100644 --- a/RecoHI/HiTracking/python/HISelectedTracks_cfi.py +++ b/RecoHI/HiTracking/python/HISelectedTracks_cfi.py @@ -5,48 +5,48 @@ # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiGlobalPrimTracks', - useAnyMVA = cms.bool(True), - GBRForestLabel = cms.string('HIMVASelectorIter4'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), - trackSelectors= cms.VPSet( + src = 'hiGlobalPrimTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter4', + GBRForestVars = ['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiInitialStepLoose', - useMVA = cms.bool(False) - ), #end of pset + name = 'hiInitialStepLoose', + useMVA = False + ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiInitialStepTight', - preFilterName = 'hiInitialStepLoose', - useMVA = cms.bool(True), - minMVA = cms.double(-0.77) - ), + name = 'hiInitialStepTight', + preFilterName = 'hiInitialStepLoose', + useMVA = True, + minMVA = -0.77 + ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiInitialStep', - preFilterName = 'hiInitialStepTight', - useMVA = cms.bool(True), - minMVA = cms.double(-0.77) - ), + name = 'hiInitialStep', + preFilterName = 'hiInitialStepTight', + useMVA = True, + minMVA = -0.77 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiInitialStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiInitialStepSelector, useAnyMVA = False) trackingPhase1.toModify(hiInitialStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiInitialStepLoose', - useMVA = cms.bool(False) - ), #end of pset + name = 'hiInitialStepLoose', + useMVA = False + ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiInitialStepTight', - preFilterName = 'hiInitialStepLoose', - useMVA = cms.bool(False), - minMVA = cms.double(-0.77) - ), + name = 'hiInitialStepTight', + preFilterName = 'hiInitialStepLoose', + useMVA = False, + minMVA = -0.77 + ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiInitialStep', - preFilterName = 'hiInitialStepTight', - useMVA = cms.bool(False), - minMVA = cms.double(-0.77) - ), + name = 'hiInitialStep', + preFilterName = 'hiInitialStepTight', + useMVA = False, + minMVA = -0.77 + ), ) #end of vpset ) @@ -56,13 +56,13 @@ from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiSelectedTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers = cms.VInputTag(cms.InputTag('hiGlobalPrimTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiInitialStepSelector","hiInitialStep")), - copyExtras = True, - copyMVA = cms.bool(True), + TrackProducers = ['hiGlobalPrimTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiInitialStepSelector:hiInitialStep"], + copyExtras = True, + copyMVA = True, makeReKeyedSeeds = cms.untracked.bool(False) - ) +) #complete sequence hiTracksWithQualityTask = cms.Task(hiInitialStepSelector diff --git a/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py b/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py index 77394580de01c..f05260aa9d5bd 100644 --- a/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py +++ b/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py @@ -3,18 +3,18 @@ # global tracking region for primary pixel tracks from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices hiTrackingRegionWithVertex = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( - ptMin = cms.double(1.5), - originRadius = cms.double(0.2), - nSigmaZ = cms.double(3.0), - beamSpot = cms.InputTag("offlineBeamSpot"), - precise = cms.bool(True), - useMultipleScattering = cms.bool(False), - useFakeVertices = cms.bool(False), - useFoundVertices = cms.bool(True), - VertexCollection = cms.InputTag("hiSelectedPixelVertex"), - useFixedError = cms.bool(True), - fixedError = cms.double(0.2), - sigmaZVertex = cms.double(3.0) + ptMin = 1.5, + originRadius = 0.2, + nSigmaZ = 3.0, + beamSpot = "offlineBeamSpot", + precise = True, + useMultipleScattering = False, + useFakeVertices = False, + useFoundVertices = True, + VertexCollection = "hiSelectedPixelVertex", + useFixedError = True, + fixedError = 0.2, + sigmaZVertex = 3.0 )) # global tracking region for low-pt pixel tracks @@ -55,10 +55,11 @@ # limited jet-seeded tracking region from RecoTauTag.HLTProducers.TauRegionalPixelSeedGenerator_cfi import tauRegionalPixelSeedGenerator -HiTrackingRegionFactoryFromJetsBlock = tauRegionalPixelSeedGenerator.RegionFactoryPSet -HiTrackingRegionFactoryFromJetsBlock.RegionPSet.JetSrc = cms.InputTag("iterativeConePu5CaloJets") -HiTrackingRegionFactoryFromJetsBlock.RegionPSet.vertexSrc = cms.InputTag("hiSelectedPixelVertex") - +HiTrackingRegionFactoryFromJetsBlock = tauRegionalPixelSeedGenerator.RegionFactoryPSet.clone( + RegionPSet = dict( + JetSrc = "iterativeConePu5CaloJets", + vertexSrc = "hiSelectedPixelVertex") +) # limited stand-alone muon-seeded tracking region from RecoMuon.TrackingTools.MuonServiceProxy_cff import MuonServiceProxy from RecoMuon.GlobalTrackingTools.MuonTrackingRegionCommon_cff import MuonTrackingRegionCommon diff --git a/RecoHI/HiTracking/python/MergeRegitTrackCollectionsHI_cff.py b/RecoHI/HiTracking/python/MergeRegitTrackCollectionsHI_cff.py index 61b9f0bd580ed..766ba040aee1d 100644 --- a/RecoHI/HiTracking/python/MergeRegitTrackCollectionsHI_cff.py +++ b/RecoHI/HiTracking/python/MergeRegitTrackCollectionsHI_cff.py @@ -3,19 +3,19 @@ from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiRegitTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers = (cms.InputTag('hiRegitInitialStepTracks'), - cms.InputTag('hiRegitLowPtTripletStepTracks'), - cms.InputTag('hiRegitPixelPairStepTracks'), - cms.InputTag('hiRegitDetachedTripletStepTracks'), - cms.InputTag('hiRegitMixedTripletStepTracks')), - hasSelector=cms.vint32(1,1,1,1,1), - selectedTrackQuals = cms.VInputTag( - cms.InputTag("hiRegitInitialStepSelector","hiRegitInitialStep"), - cms.InputTag("hiRegitLowPtTripletStepSelector","hiRegitLowPtTripletStep"), - cms.InputTag("hiRegitPixelPairStepSelector","hiRegitPixelPairStep"), - cms.InputTag("hiRegitDetachedTripletStepSelector","hiRegitDetachedTripletStep"), - cms.InputTag("hiRegitMixedTripletStepSelector","hiRegitMixedTripletStep"), - ), + TrackProducers = ['hiRegitInitialStepTracks', + 'hiRegitLowPtTripletStepTracks', + 'hiRegitPixelPairStepTracks', + 'hiRegitDetachedTripletStepTracks', + 'hiRegitMixedTripletStepTracks' + ], + hasSelector = [1,1,1,1,1], + selectedTrackQuals = ["hiRegitInitialStepSelector:hiRegitInitialStep", + "hiRegitLowPtTripletStepSelector:hiRegitLowPtTripletStep", + "hiRegitPixelPairStepSelector:hiRegitPixelPairStep", + "hiRegitDetachedTripletStepSelector:hiRegitDetachedTripletStep", + "hiRegitMixedTripletStepSelector:hiRegitMixedTripletStep" + ], setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5), pQual=cms.bool(True)), # should this be False? ), copyExtras = True, diff --git a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py index d30b20b3c54f2..728ec72ca1778 100644 --- a/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py +++ b/RecoHI/HiTracking/python/MergeTrackCollectionsHI_cff.py @@ -2,19 +2,18 @@ import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiGeneralTracksNoRegitMu = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), - cms.InputTag('hiDetachedTripletStepTracks'), - cms.InputTag('hiLowPtTripletStepTracks'), - cms.InputTag('hiPixelPairGlobalPrimTracks'), - cms.InputTag('hiJetCoreRegionalStepTracks') - ), - hasSelector=cms.vint32(1,1,1,1,1), - selectedTrackQuals = cms.VInputTag( - cms.InputTag("hiInitialStepSelector","hiInitialStep"), - cms.InputTag("hiDetachedTripletStepSelector","hiDetachedTripletStep"), - cms.InputTag("hiLowPtTripletStepSelector","hiLowPtTripletStep"), - cms.InputTag("hiPixelPairStepSelector","hiPixelPairStep"), - ), + TrackProducers = ['hiGlobalPrimTracks', + 'hiDetachedTripletStepTracks', + 'hiLowPtTripletStepTracks', + 'hiPixelPairGlobalPrimTracks', + 'hiJetCoreRegionalStepTracks' + ], + hasSelector = [1,1,1,1,1], + selectedTrackQuals = ["hiInitialStepSelector:hiInitialStep", + "hiDetachedTripletStepSelector:hiDetachedTripletStep", + "hiLowPtTripletStepSelector:hiLowPtTripletStep", + "hiPixelPairStepSelector:hiPixelPairStep" + ], setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3), pQual=cms.bool(True)), # should this be False? ), copyExtras = True, @@ -22,102 +21,99 @@ ) from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 trackingPhase1.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), + TrackProducers = ['hiGlobalPrimTracks', + 'hiLowPtQuadStepTracks', + 'hiHighPtTripletStepTracks', + 'hiDetachedQuadStepTracks', + 'hiDetachedTripletStepTracks', + 'hiLowPtTripletStepTracks', + 'hiPixelPairGlobalPrimTracks', + 'hiJetCoreRegionalStepTracks' + ], + hasSelector = [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"), - ) -) + selectedTrackQuals = ["hiInitialStepSelector:hiInitialStep", + "hiLowPtQuadStepSelector:hiLowPtQuadStep", + "hiHighPtTripletStepSelector:hiHighPtTripletStep", + "hiDetachedQuadStepSelector:hiDetachedQuadStep", + "hiDetachedTripletStepSelector:hiDetachedTripletStep", + "hiLowPtTripletStepSelector:hiLowPtTripletStep", + "hiPixelPairStepSelector:hiPixelPairStep" + ], +) hiGeneralTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers = (cms.InputTag('hiGlobalPrimTracks'), - 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), - selectedTrackQuals = cms.VInputTag( - cms.InputTag("hiInitialStepSelector","hiInitialStep"), - 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") - ), + TrackProducers = ['hiGlobalPrimTracks', + 'hiDetachedTripletStepTracks', + 'hiLowPtTripletStepTracks', + 'hiPixelPairGlobalPrimTracks', + 'hiJetCoreRegionalStepTracks', + 'hiRegitMuInitialStepTracks', + 'hiRegitMuPixelPairStepTracks', + 'hiRegitMuMixedTripletStepTracks', + 'hiRegitMuPixelLessStepTracks', + 'hiRegitMuDetachedTripletStepTracks', + 'hiRegitMuonSeededTracksOutIn', + 'hiRegitMuonSeededTracksInOut' + ], + hasSelector = [1,1,1,1,1,1,1,1,1,1,1,1], + selectedTrackQuals = ["hiInitialStepSelector:hiInitialStep", + "hiDetachedTripletStepSelector:hiDetachedTripletStep", + "hiLowPtTripletStepSelector:hiLowPtTripletStep", + "hiPixelPairStepSelector:hiPixelPairStep", + "hiJetCoreRegionalStepSelector:hiJetCoreRegionalStep", + "hiRegitMuInitialStepSelector:hiRegitMuInitialStepLoose", + "hiRegitMuPixelPairStepSelector:hiRegitMuPixelPairStep", + "hiRegitMuMixedTripletStepSelector:hiRegitMuMixedTripletStep", + "hiRegitMuPixelLessStepSelector:hiRegitMuPixelLessStep", + "hiRegitMuDetachedTripletStepSelector:hiRegitMuDetachedTripletStep", + "hiRegitMuonSeededTracksOutInSelector:hiRegitMuonSeededTracksOutInHighPurity", + "hiRegitMuonSeededTracksInOutSelector:hiRegitMuonSeededTracksInOutHighPurity" + ], setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5,6,7,8,9,10,11), pQual=cms.bool(True)), # should this be False? ), copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) ) trackingPhase1.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('hiMixedTripletStepTracks'), - cms.InputTag('hiPixelLessStepTracks'), - cms.InputTag('hiTobTecStepTracks'), - 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,1,1,1), + TrackProducers = ['hiGlobalPrimTracks', + 'hiLowPtQuadStepTracks', + 'hiHighPtTripletStepTracks', + 'hiDetachedQuadStepTracks', + 'hiDetachedTripletStepTracks', + 'hiLowPtTripletStepTracks', + 'hiPixelPairGlobalPrimTracks', + 'hiMixedTripletStepTracks', + 'hiPixelLessStepTracks', + 'hiTobTecStepTracks', + 'hiJetCoreRegionalStepTracks', + 'hiRegitMuInitialStepTracks', + 'hiRegitMuPixelPairStepTracks', + 'hiRegitMuMixedTripletStepTracks', + 'hiRegitMuPixelLessStepTracks', + 'hiRegitMuDetachedTripletStepTracks', + 'hiRegitMuonSeededTracksOutIn', + 'hiRegitMuonSeededTracksInOut' + ], + hasSelector = [1,1,1,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,15,16,17), 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("hiMixedTripletStepSelector","hiMixedTripletStep"), - cms.InputTag("hiPixelLessStepSelector","hiPixelLessStep"), - cms.InputTag("hiTobTecStepSelector","hiTobTecStep"), - 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") - ) -) + selectedTrackQuals = ["hiInitialStepSelector:hiInitialStep", + "hiLowPtQuadStepSelector:hiLowPtQuadStep", + "hiHighPtTripletStepSelector:hiHighPtTripletStep", + "hiDetachedQuadStepSelector:hiDetachedQuadStep", + "hiDetachedTripletStepSelector:hiDetachedTripletStep", + "hiLowPtTripletStepSelector:hiLowPtTripletStep", + "hiPixelPairStepSelector:hiPixelPairStep", + "hiMixedTripletStepSelector:hiMixedTripletStep", + "hiPixelLessStepSelector:hiPixelLessStep", + "hiTobTecStepSelector:hiTobTecStep", + "hiJetCoreRegionalStepSelector:hiJetCoreRegionalStep", + "hiRegitMuInitialStepSelector:hiRegitMuInitialStepLoose", + "hiRegitMuPixelPairStepSelector:hiRegitMuPixelPairStep", + "hiRegitMuMixedTripletStepSelector:hiRegitMuMixedTripletStep", + "hiRegitMuPixelLessStepSelector:hiRegitMuPixelLessStep", + "hiRegitMuDetachedTripletStepSelector:hiRegitMuDetachedTripletStep", + "hiRegitMuonSeededTracksOutInSelector:hiRegitMuonSeededTracksOutInHighPurity", + "hiRegitMuonSeededTracksInOutSelector:hiRegitMuonSeededTracksInOutHighPurity" + ], +) diff --git a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py index 1375e95e77986..8f5fa2c9add9c 100644 --- a/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedQuadStep_cff.py @@ -23,10 +23,10 @@ # SEEDING LAYERS # Using 4 layers layerlist -hiDetachedQuadStepSeedLayers = hiPixelLayerQuadruplets.clone() -hiDetachedQuadStepSeedLayers.BPix.skipClusters = cms.InputTag('hiDetachedQuadStepClusters') -hiDetachedQuadStepSeedLayers.FPix.skipClusters = cms.InputTag('hiDetachedQuadStepClusters') - +hiDetachedQuadStepSeedLayers = hiPixelLayerQuadruplets.clone( + BPix = dict(skipClusters = cms.InputTag('hiDetachedQuadStepClusters')), + FPix = dict(skipClusters = cms.InputTag('hiDetachedQuadStepClusters')) +) # SEEDS from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer @@ -104,38 +104,38 @@ 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) - ) + minPt = 0.075,# 0.075 for pp + #constantValueForLostHitsFractionFilter = 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) - ) + ComponentName = 'hiDetachedQuadStepChi2Est', + nSigma = 3.0, + MaxChi2 = 9.0 +) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiDetachedQuadStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiDetachedQuadStepTrajectoryFilter')), + trajectoryFilter = dict(refToPSet_ = 'hiDetachedQuadStepTrajectoryFilter'), maxCand = 4,#4 for pp - estimator = cms.string('hiDetachedQuadStepChi2Est'), + estimator = '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) - ) + alwaysUseInvalidHits = False +) # MAKING OF TRACK CANDIDATES @@ -143,88 +143,88 @@ import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiDetachedQuadStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiDetachedQuadStepSeeds'), + src = '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'), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiDetachedQuadStepTrajectoryBuilder'), + TrajectoryBuilder = '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') - ) + AlgorithmName = 'detachedQuadStep', + Fitter = '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']), + src = 'hiDetachedQuadStepTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter10',#FIXME MVA for new iteration + GBRForestVars = ['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) - ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiDetachedQuadStepTight', + preFilterName = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = True, + useMVA = True, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiDetachedQuadStep', + preFilterName = 'hiDetachedQuadStepTight', + applyAdaptedPVCuts = True, + useMVA = True, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiDetachedQuadStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiDetachedQuadStepSelector, useAnyMVA = False) trackingPhase1.toModify(hiDetachedQuadStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiDetachedQuadStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), + name = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiDetachedQuadStepTight', - preFilterName = 'hiDetachedQuadStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) + name = 'hiDetachedQuadStepTight', + preFilterName = 'hiDetachedQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiDetachedQuadStep', - preFilterName = 'hiDetachedQuadStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) + name = 'hiDetachedQuadStep', + preFilterName = 'hiDetachedQuadStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 ), - ) #end of vpset + ) #end of vpset ) 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")), + TrackProducers = ['hiDetachedQuadStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiDetachedQuadStepSelector:hiDetachedQuadStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiDetachedQuadStepTask = cms.Task(hiDetachedQuadStepClusters, diff --git a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py index 4ec1493a3a20c..a70c931a93e79 100644 --- a/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiDetachedTripletStep_cff.py @@ -24,16 +24,17 @@ from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 trackingPhase1.toModify(hiDetachedTripletStepClusters, - trajectories = cms.InputTag("hiDetachedQuadStepTracks"), - overrideTrkQuals = cms.InputTag("hiDetachedQuadStepSelector","hiDetachedQuadStep"), + trajectories = "hiDetachedQuadStepTracks", + overrideTrkQuals = "hiDetachedQuadStepSelector:hiDetachedQuadStep", ) # SEEDING LAYERS import RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi -hiDetachedTripletStepSeedLayers = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.clone() -hiDetachedTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiDetachedTripletStepClusters') -hiDetachedTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiDetachedTripletStepClusters') +hiDetachedTripletStepSeedLayers = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.clone( + BPix = dict(skipClusters = cms.InputTag('hiDetachedTripletStepClusters')), + FPix = dict(skipClusters = cms.InputTag('hiDetachedTripletStepClusters')) +) # SEEDS from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices @@ -77,9 +78,9 @@ ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer -hiDetachedTripletStepTracksHitDoubletsCA = hiDetachedTripletStepTracksHitDoublets.clone() -hiDetachedTripletStepTracksHitDoubletsCA.layerPairs = [0,1] - +hiDetachedTripletStepTracksHitDoubletsCA = hiDetachedTripletStepTracksHitDoublets.clone( + layerPairs = [0,1] +) hiDetachedTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiDetachedTripletStepTracksHitDoubletsCA", extraHitRPhitolerance = hiDetachedTripletStepTracksHitTriplets.extraHitRPhitolerance, @@ -130,115 +131,115 @@ hiDetachedTripletStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( maxLostHits = 1, minimumNumberOfHits = 6, - minPt = cms.double(0.3), - constantValueForLostHitsFractionFilter = cms.double(0.701) - ) + minPt = 0.3, + constantValueForLostHitsFractionFilter = 0.701 +) import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi hiDetachedTripletStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( - ComponentName = cms.string('hiDetachedTripletStepChi2Est'), - nSigma = cms.double(3.0), - MaxChi2 = cms.double(9.0) - ) + ComponentName = 'hiDetachedTripletStepChi2Est', + nSigma = 3.0, + MaxChi2 = 9.0 +) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiDetachedTripletStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiDetachedTripletStepTrajectoryFilter')), + trajectoryFilter = dict(refToPSet_ = 'hiDetachedTripletStepTrajectoryFilter'), maxCand = 2, - estimator = cms.string('hiDetachedTripletStepChi2Est'), + estimator = 'hiDetachedTripletStepChi2Est', maxDPhiForLooperReconstruction = cms.double(0), - maxPtForLooperReconstruction = cms.double(0), - alwaysUseInvalidHits = cms.bool(False) - ) + maxPtForLooperReconstruction = cms.double(0), + alwaysUseInvalidHits = False +) # MAKING OF TRACK CANDIDATES import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiDetachedTripletStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiDetachedTripletStepSeeds'), + src = 'hiDetachedTripletStepSeeds', ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput numHitsForSeedCleaner = cms.int32(50), onlyPixelHitsForSeedCleaner = cms.bool(True), - TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiDetachedTripletStepTrajectoryBuilder')), - TrajectoryBuilder = cms.string('hiDetachedTripletStepTrajectoryBuilder'), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiDetachedTripletStepTrajectoryBuilder'), + TrajectoryBuilder = 'hiDetachedTripletStepTrajectoryBuilder', clustersToSkip = cms.InputTag('hiDetachedTripletStepClusters'), doSeedingRegionRebuilding = True, useHitsSplitting = True - ) +) # TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi hiDetachedTripletStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( src = 'hiDetachedTripletStepTrackCandidates', - AlgorithmName = cms.string('detachedTripletStep'), - Fitter=cms.string('FlexibleKFFittingSmoother') - ) + AlgorithmName = 'detachedTripletStep', + Fitter = 'FlexibleKFFittingSmoother' +) # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiDetachedTripletStepTracks', - 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) - ), + src = 'hiDetachedTripletStepTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter7', + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiDetachedTripletStepTight', + preFilterName = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiDetachedTripletStep', + preFilterName = 'hiDetachedTripletStepTight', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiDetachedTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiDetachedTripletStepSelector, useAnyMVA = False) trackingPhase1.toModify(hiDetachedTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiDetachedTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), + name = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiDetachedTripletStepTight', - preFilterName = 'hiDetachedTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) + name = 'hiDetachedTripletStepTight', + preFilterName = 'hiDetachedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiDetachedTripletStep', - preFilterName = 'hiDetachedTripletStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) + name = 'hiDetachedTripletStep', + preFilterName = 'hiDetachedTripletStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 ), - ) #end of vpset + ) #end of vpset ) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiDetachedTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers=cms.VInputTag(cms.InputTag('hiDetachedTripletStepTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiDetachedTripletStepSelector","hiDetachedTripletStep")), + TrackProducers = ['hiDetachedTripletStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiDetachedTripletStepSelector:hiDetachedTripletStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiDetachedTripletStepTask = cms.Task(hiDetachedTripletStepClusters, diff --git a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py index da7478e8fbd6e..8b42b5bdc4fac 100644 --- a/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiHighPtTripletStep_cff.py @@ -23,9 +23,10 @@ # SEEDING LAYERS # Using 3 layers layerlist -hiHighPtTripletStepSeedLayers = highPtTripletStepSeedLayers.clone() -hiHighPtTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiHighPtTripletStepClusters') -hiHighPtTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiHighPtTripletStepClusters') +hiHighPtTripletStepSeedLayers = highPtTripletStepSeedLayers.clone( + BPix = dict(skipClusters = 'hiHighPtTripletStepClusters'), + FPix = dict(skipClusters = 'hiHighPtTripletStepClusters') +) # SEEDS from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices @@ -102,38 +103,38 @@ 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) - ) + minPt = 0.2,# 0.2 for pp + #constantValueForLostHitsFractionFilter = 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 - ) + ComponentName = 'hiHighPtTripletStepChi2Est', + nSigma = 3.0, + MaxChi2 = 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')), + trajectoryFilter = dict(refToPSet_ = 'hiHighPtTripletStepTrajectoryFilter'), maxCand = 3,#3 for pp - estimator = cms.string('hiHighPtTripletStepChi2Est'), + estimator = '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) - ) + alwaysUseInvalidHits = False +) # MAKING OF TRACK CANDIDATES @@ -141,88 +142,88 @@ import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiHighPtTripletStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiHighPtTripletStepSeeds'), + src = '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'), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiHighPtTripletStepTrajectoryBuilder'), + TrajectoryBuilder = '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') - ) + AlgorithmName = 'highPtTripletStep', + Fitter = '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) - ), + src = 'hiHighPtTripletStepTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter9',#FIXME MVA for new iteration + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiHighPtTripletStepTight', + preFilterName = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiHighPtTripletStep', + preFilterName = 'hiHighPtTripletStepTight', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiHighPtTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiHighPtTripletStepSelector, useAnyMVA = False) trackingPhase1.toModify(hiHighPtTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiHighPtTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), + name = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiHighPtTripletStepTight', - preFilterName = 'hiHighPtTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) + name = 'hiHighPtTripletStepTight', + preFilterName = 'hiHighPtTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiHighPtTripletStep', - preFilterName = 'hiHighPtTripletStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) + name = 'hiHighPtTripletStep', + preFilterName = 'hiHighPtTripletStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 ), - ) #end of vpset + ) #end of vpset ) 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")), + TrackProducers = ['hiHighPtTripletStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiHighPtTripletStepSelector:hiHighPtTripletStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiHighPtTripletStepTask = cms.Task(hiHighPtTripletStepClusters, diff --git a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py index b8a74c1e98393..ed9cc44756f93 100644 --- a/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py +++ b/RecoHI/HiTracking/python/hiJetCoreRegionalStep_cff.py @@ -4,7 +4,7 @@ # run only if there are high pT jets from RecoJets.JetProducers.TracksForJets_cff import trackRefsForJets -hiInitialStepTrackRefsForJets = trackRefsForJets.clone(src = cms.InputTag('hiGlobalPrimTracks')) +hiInitialStepTrackRefsForJets = trackRefsForJets.clone(src = 'hiGlobalPrimTracks') #change this to import Bkg substracted Heavy Ion jets: from RecoHI.HiJetAlgos.hiCaloJetsForTrk_cff import * @@ -52,7 +52,7 @@ ) ) from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiJetCoreRegionalStepSeedLayers, layerList = cms.vstring('BPix1+BPix2+BPix3', +trackingPhase1.toModify(hiJetCoreRegionalStepSeedLayers, layerList = ['BPix1+BPix2+BPix3', 'BPix2+BPix3+BPix4', 'BPix1+BPix3+BPix4', 'BPix1+BPix2+BPix4', @@ -72,36 +72,34 @@ 'BPix2+BPix3+TIB1', 'BPix2+BPix4+TIB1', 'BPix3+BPix4+TIB1', - ) + ] ) # SEEDS import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -hiJetCoreRegionalStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -hiJetCoreRegionalStepSeeds.RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "TauRegionalPixelSeedGenerator" ),#not so nice to depend on RecoTau... - RegionPSet = cms.PSet( - precise = cms.bool( True ), - useMultipleScattering = cms.bool(False), - useFakeVertices = cms.bool(False), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 15. ), - originHalfLength = cms.double( 0.2 ), - deltaPhiRegion = cms.double( 0.30 ), - deltaEtaRegion = cms.double( 0.30 ), - JetSrc = cms.InputTag( "hiJetsForCoreTracking" ), - vertexSrc = cms.InputTag( "hiFirstStepGoodPrimaryVertices" ), - measurementTrackerName = cms.InputTag( "MeasurementTrackerEvent" ), - howToUseMeasurementTracker = cms.string( "Never" ) - ) +hiJetCoreRegionalStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( + RegionFactoryPSet = cms.PSet( + ComponentName = cms.string( "TauRegionalPixelSeedGenerator" ),#not so nice to depend on RecoTau... + RegionPSet = cms.PSet( + precise = cms.bool( True ), + useMultipleScattering = cms.bool(False), + useFakeVertices = cms.bool(False), + originRadius = cms.double( 0.2 ), + ptMin = cms.double( 15. ), + originHalfLength = cms.double( 0.2 ), + deltaPhiRegion = cms.double( 0.30 ), + deltaEtaRegion = cms.double( 0.30 ), + JetSrc = cms.InputTag( "hiJetsForCoreTracking" ), + vertexSrc = cms.InputTag( "hiFirstStepGoodPrimaryVertices" ), + measurementTrackerName = cms.InputTag( "MeasurementTrackerEvent" ), + howToUseMeasurementTracker = cms.string( "Never" ) + ) + ), + OrderedHitsFactoryPSet = dict(SeedingLayers = 'hiJetCoreRegionalStepSeedLayers'), + SeedComparitorPSet = dict(ComponentName = 'none'), + SeedCreatorPSet = dict(forceKinematicWithRegionDirection = True), + ClusterCheckPSet = dict(doClusterCheck = False) ) -hiJetCoreRegionalStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiJetCoreRegionalStepSeedLayers' -hiJetCoreRegionalStepSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('none'), - ) -hiJetCoreRegionalStepSeeds.SeedCreatorPSet.forceKinematicWithRegionDirection = cms.bool( True ) -hiJetCoreRegionalStepSeeds.ClusterCheckPSet.doClusterCheck = cms.bool( False ) - # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff hiJetCoreRegionalStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( @@ -111,45 +109,45 @@ import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi hiJetCoreRegionalStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( - ComponentName = cms.string('hiJetCoreRegionalStepChi2Est'), - nSigma = cms.double(3.0), - MaxChi2 = cms.double(30.0) + ComponentName = 'hiJetCoreRegionalStepChi2Est', + nSigma = 3.0, + MaxChi2 = 30.0 ) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiJetCoreRegionalStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiJetCoreRegionalStepTrajectoryFilter')), + trajectoryFilter = dict(refToPSet_ = 'hiJetCoreRegionalStepTrajectoryFilter'), maxCand = 50, - estimator = cms.string('hiJetCoreRegionalStepChi2Est'), + estimator = 'hiJetCoreRegionalStepChi2Est', maxDPhiForLooperReconstruction = cms.double(2.0), maxPtForLooperReconstruction = cms.double(0.7) - ) +) # MAKING OF TRACK CANDIDATES import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiJetCoreRegionalStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiJetCoreRegionalStepSeeds'), - maxSeedsBeforeCleaning = cms.uint32(10000), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string('hiJetCoreRegionalStepTrajectoryBuilder')), - NavigationSchool = cms.string('SimpleNavigationSchool'), + src = 'hiJetCoreRegionalStepSeeds', + maxSeedsBeforeCleaning = 10000, + TrajectoryBuilderPSet = dict( refToPSet_ = 'hiJetCoreRegionalStepTrajectoryBuilder'), + NavigationSchool = 'SimpleNavigationSchool', ) # TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi hiJetCoreRegionalStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( - AlgorithmName = cms.string('jetCoreRegionalStep'), + AlgorithmName = 'jetCoreRegionalStep', src = 'hiJetCoreRegionalStepTrackCandidates', - Fitter = cms.string('FlexibleKFFittingSmoother') - ) + Fitter = 'FlexibleKFFittingSmoother' +) # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiJetCoreRegionalStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiJetCoreRegionalStepTracks', - vertices = cms.InputTag("hiFirstStepGoodPrimaryVertices"), + src = 'hiJetCoreRegionalStepTracks', + vertices = "hiFirstStepGoodPrimaryVertices", trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( name = 'hiJetCoreRegionalStepLoose', diff --git a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py index 83120b0e37812..1e8eca5efe0ee 100644 --- a/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtQuadStep_cff.py @@ -23,9 +23,10 @@ # SEEDING LAYERS # Using 4 layers layerlist -hiLowPtQuadStepSeedLayers = hiPixelLayerQuadruplets.clone() -hiLowPtQuadStepSeedLayers.BPix.skipClusters = cms.InputTag('hiLowPtQuadStepClusters') -hiLowPtQuadStepSeedLayers.FPix.skipClusters = cms.InputTag('hiLowPtQuadStepClusters') +hiLowPtQuadStepSeedLayers = hiPixelLayerQuadruplets.clone( + BPix = dict(skipClusters = cms.InputTag('hiLowPtQuadStepClusters')), + FPix = dict(skipClusters = cms.InputTag('hiLowPtQuadStepClusters')) +) # SEEDS from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices @@ -105,38 +106,38 @@ 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) - ) + minPt = 0.075,# 0.075 for pp + #constantValueForLostHitsFractionFilter = 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) - ) + ComponentName = 'hiLowPtQuadStepChi2Est', + nSigma = 3.0, + MaxChi2 = 9.0 +) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiLowPtQuadStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiLowPtQuadStepTrajectoryFilter')), + trajectoryFilter = dict(refToPSet_ = 'hiLowPtQuadStepTrajectoryFilter'), maxCand = 4,#4 for pp - estimator = cms.string('hiLowPtQuadStepChi2Est'), + estimator = '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) - ) + alwaysUseInvalidHits = False +) # MAKING OF TRACK CANDIDATES @@ -144,88 +145,88 @@ import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiLowPtQuadStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiLowPtQuadStepSeeds'), + src = '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'), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiLowPtQuadStepTrajectoryBuilder'), + TrajectoryBuilder = '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') - ) + AlgorithmName = 'lowPtQuadStep', + Fitter = '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) - ), + src ='hiLowPtQuadStepTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter8',#FIXME MVA for new iteration + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiLowPtQuadStepTight', + preFilterName = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiLowPtQuadStep', + preFilterName = 'hiLowPtQuadStepTight', + applyAdaptedPVCuts = False, + useMVA = True, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiLowPtQuadStepSelector, useAnyMVA = cms.bool(False)) -trackingPhase1.toModify(hiLowPtQuadStepSelector, trackSelectors= cms.VPSet( +trackingPhase1.toModify(hiLowPtQuadStepSelector, useAnyMVA = False) +trackingPhase1.toModify(hiLowPtQuadStepSelector, trackSelectors = cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiLowPtQuadStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), + name = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiLowPtQuadStepTight', - preFilterName = 'hiLowPtQuadStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) + name = 'hiLowPtQuadStepTight', + preFilterName = 'hiLowPtQuadStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiLowPtQuadStep', - preFilterName = 'hiLowPtQuadStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) + name = 'hiLowPtQuadStep', + preFilterName = 'hiLowPtQuadStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 ), - ) #end of vpset + ) #end of vpset ) 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")), + TrackProducers = ['hiLowPtQuadStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiLowPtQuadStepSelector:hiLowPtQuadStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiLowPtQuadStepTask = cms.Task(hiLowPtQuadStepClusters, diff --git a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py index c555270a99fe6..5ebecf0f3b4d9 100644 --- a/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiLowPtTripletStep_cff.py @@ -24,9 +24,10 @@ # SEEDING LAYERS import RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi -hiLowPtTripletStepSeedLayers = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.clone() -hiLowPtTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiLowPtTripletStepClusters') -hiLowPtTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiLowPtTripletStepClusters') +hiLowPtTripletStepSeedLayers = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.clone( + BPix = dict(skipClusters = cms.InputTag('hiLowPtTripletStepClusters')), + FPix = dict(skipClusters = cms.InputTag('hiLowPtTripletStepClusters')) +) # SEEDS from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices @@ -69,9 +70,9 @@ ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer -hiLowPtTripletStepTracksHitDoubletsCA = hiLowPtTripletStepTracksHitDoublets.clone() -hiLowPtTripletStepTracksHitDoubletsCA.layerPairs = [0,1] - +hiLowPtTripletStepTracksHitDoubletsCA = hiLowPtTripletStepTracksHitDoublets.clone( + layerPairs = [0,1] +) hiLowPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiLowPtTripletStepTracksHitDoubletsCA", extraHitRPhitolerance = hiLowPtTripletStepTracksHitTriplets.extraHitRPhitolerance, @@ -116,7 +117,7 @@ import RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi hiLowPtTripletStepSeeds = RecoPixelVertexing.PixelLowPtUtilities.TrackSeeds_cfi.pixelTrackSeeds.clone( InputCollection = 'hiLowPtTripletStepPixelTracks' - ) +) # QUALITY CUTS DURING TRACK BUILDING @@ -125,109 +126,109 @@ maxLostHits = 1, minimumNumberOfHits = 6, minPt = 0.4 - ) +) import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi hiLowPtTripletStepChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( - ComponentName = cms.string('hiLowPtTripletStepChi2Est'), - nSigma = cms.double(3.0), - MaxChi2 = cms.double(9.0) - ) + ComponentName = 'hiLowPtTripletStepChi2Est', + nSigma = 3.0, + MaxChi2 = 9.0 +) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiLowPtTripletStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiLowPtTripletStepTrajectoryFilter')), + trajectoryFilter = dict(refToPSet_ = 'hiLowPtTripletStepTrajectoryFilter'), maxCand = 3, - estimator = cms.string('hiLowPtTripletStepChi2Est'), + estimator = 'hiLowPtTripletStepChi2Est', maxDPhiForLooperReconstruction = cms.double(2.0), # 0.63 GeV is the maximum pT for a charged particle to loop within the 1.1m radius # of the outermost Tracker barrel layer (with B=3.8T) maxPtForLooperReconstruction = cms.double(0.7) - ) +) # MAKING OF TRACK CANDIDATES import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiLowPtTripletStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiLowPtTripletStepSeeds'), + src = 'hiLowPtTripletStepSeeds', ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput numHitsForSeedCleaner = cms.int32(50), onlyPixelHitsForSeedCleaner = cms.bool(True), - TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiLowPtTripletStepTrajectoryBuilder')), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiLowPtTripletStepTrajectoryBuilder'), clustersToSkip = cms.InputTag('hiLowPtTripletStepClusters'), doSeedingRegionRebuilding = True, useHitsSplitting = True - ) +) # TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi hiLowPtTripletStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( src = 'hiLowPtTripletStepTrackCandidates', - AlgorithmName = cms.string('lowPtTripletStep'), - Fitter=cms.string('FlexibleKFFittingSmoother') - ) + AlgorithmName = 'lowPtTripletStep', + Fitter='FlexibleKFFittingSmoother' +) # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiLowPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiLowPtTripletStepTracks', - useAnyMVA = cms.bool(True), - GBRForestLabel = cms.string('HIMVASelectorIter5'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'relpterr', 'nhits', 'nlayers', 'eta']), + src = 'hiLowPtTripletStepTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter5', + GBRForestVars = ['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) - ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiLowPtTripletStepLoose', + useMVA = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiLowPtTripletStepTight', + preFilterName = 'hiLowPtTripletStepLoose', + useMVA = True, + minMVA = -0.58 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiLowPtTripletStep', + preFilterName = 'hiLowPtTripletStepTight', + useMVA = True, + minMVA = 0.35 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiLowPtTripletStepSelector, useAnyMVA = cms.bool(False)) +trackingPhase1.toModify(hiLowPtTripletStepSelector, useAnyMVA = False) trackingPhase1.toModify(hiLowPtTripletStepSelector, trackSelectors= cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiLowPtTripletStepLoose', - useMVA = cms.bool(False) + name = 'hiLowPtTripletStepLoose', + useMVA = False ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiLowPtTripletStepTight', - preFilterName = 'hiLowPtTripletStepLoose', - useMVA = cms.bool(False), - minMVA = cms.double(-0.58) + name = 'hiLowPtTripletStepTight', + preFilterName = 'hiLowPtTripletStepLoose', + useMVA = False, + minMVA = -0.58 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiLowPtTripletStep', - preFilterName = 'hiLowPtTripletStepTight', - useMVA = cms.bool(False), - minMVA = cms.double(0.35) + name = 'hiLowPtTripletStep', + preFilterName = 'hiLowPtTripletStepTight', + useMVA = False, + minMVA = 0.35 ), - ) #end of vpset + ) #end of vpset ) import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiLowPtTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers = cms.VInputTag(cms.InputTag('hiLowPtTripletStepTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiLowPtTripletStepSelector","hiLowPtTripletStep")), + TrackProducers = ['hiLowPtTripletStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiLowPtTripletStepSelector:hiLowPtTripletStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), #writeOnlyTrkQuals = True - ) +) # Final sequence diff --git a/RecoHI/HiTracking/python/hiMergedConformalPixelTracking_cff.py b/RecoHI/HiTracking/python/hiMergedConformalPixelTracking_cff.py index d745bdcea2e26..20c80b63e26e9 100644 --- a/RecoHI/HiTracking/python/hiMergedConformalPixelTracking_cff.py +++ b/RecoHI/HiTracking/python/hiMergedConformalPixelTracking_cff.py @@ -9,84 +9,81 @@ #loose hiPixelOnlyStepLooseMTS = hiLooseMTS.clone( - name= cms.string('hiPixelOnlyTrkLoose'), - chi2n_no1Dmod_par = cms.double(25.0), - d0_par2 = cms.vdouble(9999.0, 0.0), # d0E from tk.d0Error - dz_par2 = cms.vdouble(14.0, 0.0), - max_relpterr = cms.double(9999.), - min_nhits = cms.uint32(0), + name = 'hiPixelOnlyTrkLoose', + chi2n_no1Dmod_par = 25.0, + d0_par2 = [9999.0, 0.0], # d0E from tk.d0Error + dz_par2 = [14.0, 0.0], + max_relpterr = 9999., + min_nhits = 0, pixel_pTMinCut = cms.vdouble(0.0001,0.000,9999,1.0), pixel_pTMaxCut = cms.vdouble(10,5,25,2.5) ) -hiPixelOnlyStepTightMTS=hiPixelOnlyStepLooseMTS.clone( - preFilterName='hiPixelOnlyTrkLoose', - chi2n_no1Dmod_par = cms.double(18.0), - dz_par2 = cms.vdouble(12.0, 0.0), - pixel_pTMaxCut = cms.vdouble(4,2,18,2.5), - name= cms.string('hiPixelOnlyTrkTight'), - qualityBit = cms.string('tight'), - keepAllTracks= cms.bool(True) - ) +hiPixelOnlyStepTightMTS = hiPixelOnlyStepLooseMTS.clone( + preFilterName ='hiPixelOnlyTrkLoose', + chi2n_no1Dmod_par = 18.0, + dz_par2 = [12.0, 0.0], + pixel_pTMaxCut = [4,2,18,2.5], + name = 'hiPixelOnlyTrkTight', + qualityBit = 'tight', + keepAllTracks = True +) hiPixelOnlyStepHighpurityMTS= hiPixelOnlyStepTightMTS.clone( - name= cms.string('hiPixelOnlyTrkHighPurity'), - preFilterName='hiPixelOnlyTrkTight', - chi2n_no1Dmod_par = cms.double(12.), - dz_par2 = cms.vdouble(10.0, 0.0), - pixel_pTMaxCut = cms.vdouble(2.4,1.6,12,2.5), - qualityBit = cms.string('highPurity') ## set to '' or comment out if you dont want to set the bit - ) + name = 'hiPixelOnlyTrkHighPurity', + preFilterName ='hiPixelOnlyTrkTight', + chi2n_no1Dmod_par = 12., + dz_par2 = [10.0, 0.0], + pixel_pTMaxCut = [2.4,1.6,12,2.5], + qualityBit = 'highPurity' ## set to '' or comment out if you dont want to set the bit +) hiPixelOnlyStepSelector = hiMultiTrackSelector.clone( applyPixelMergingCuts = cms.bool(True), - src='hiConformalPixelTracks', + src = 'hiConformalPixelTracks', trackSelectors= cms.VPSet( hiPixelOnlyStepLooseMTS, hiPixelOnlyStepTightMTS, hiPixelOnlyStepHighpurityMTS ) - ) +) # selector for tapered full tracks hiHighPtStepTruncMTS = hiLooseMTS.clone( - name= cms.string('hiHighPtTrkTrunc'), - chi2n_no1Dmod_par = cms.double(9999.0), - d0_par2 = cms.vdouble(9999.0, 0.0), # d0E from tk.d0Error - dz_par2 = cms.vdouble(9999.0, 0.0), - max_relpterr = cms.double(9999.), - minHitsToBypassChecks = cms.uint32(9999), - min_nhits = cms.uint32(12), + name = 'hiHighPtTrkTrunc', + chi2n_no1Dmod_par = 9999.0, + d0_par2 = [9999.0, 0.0], # d0E from tk.d0Error + dz_par2 = [9999.0, 0.0], + max_relpterr = 9999., + minHitsToBypassChecks = 9999, + min_nhits = 12, pixel_pTMinCut = cms.vdouble(1.0,1.8,0.15,2.5), pixel_pTMaxCut = cms.vdouble(9998,9999,9999,1.0), - qualityBit = cms.string('') + qualityBit = '' ) hiHighPtStepSelector = hiMultiTrackSelector.clone( applyPixelMergingCuts = cms.bool(True), - src='hiGeneralTracks', + src = 'hiGeneralTracks', trackSelectors= cms.VPSet( hiHighPtStepTruncMTS ) - ) +) hiGeneralAndPixelTracks = trackListMerger.clone( - TrackProducers = cms.VInputTag(cms.InputTag('hiConformalPixelTracks'), - cms.InputTag('hiGeneralTracks') - ), - hasSelector=cms.vint32(1,1), - selectedTrackQuals = cms.VInputTag( - cms.InputTag("hiPixelOnlyStepSelector","hiPixelOnlyTrkHighPurity"), - cms.InputTag("hiHighPtStepSelector","hiHighPtTrkTrunc") - ), + TrackProducers = ['hiConformalPixelTracks', + 'hiGeneralTracks'], + hasSelector = [1,1], + selectedTrackQuals = ["hiPixelOnlyStepSelector:hiPixelOnlyTrkHighPurity", + "hiHighPtStepSelector:hiHighPtTrkTrunc"], setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1), pQual=cms.bool(False)), ), copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) - ) +) hiMergedConformalPixelTrackingTask = cms.Task( hiConformalPixelTracksTask diff --git a/RecoHI/HiTracking/python/hiMixedTripletStep_cff.py b/RecoHI/HiTracking/python/hiMixedTripletStep_cff.py index 5b60ec75ebbd2..94cb720c63cef 100644 --- a/RecoHI/HiTracking/python/hiMixedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiMixedTripletStep_cff.py @@ -24,12 +24,12 @@ ) # SEEDING LAYERS -mixedTripletStepSeedLayersA.layerList = cms.vstring('BPix1+BPix2+BPix3', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', - 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg') -mixedTripletStepSeedLayersA.BPix.skipClusters = cms.InputTag('hiMixedTripletStepClusters') -mixedTripletStepSeedLayersA.FPix.skipClusters = cms.InputTag('hiMixedTripletStepClusters') -mixedTripletStepSeedLayersA.TEC.skipClusters = cms.InputTag('hiMixedTripletStepClusters') +mixedTripletStepSeedLayersA.layerList = ['BPix1+BPix2+BPix3', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', + 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', + 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg'] +mixedTripletStepSeedLayersA.BPix.skipClusters = 'hiMixedTripletStepClusters' +mixedTripletStepSeedLayersA.FPix.skipClusters = 'hiMixedTripletStepClusters' +mixedTripletStepSeedLayersA.TEC.skipClusters = 'hiMixedTripletStepClusters' # TrackingRegion from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices @@ -53,8 +53,8 @@ mixedTripletStepHitDoubletsA.trackingRegions = "hiMixedTripletStepTrackingRegionsA" # SEEDING LAYERS -mixedTripletStepSeedLayersB.BPix.skipClusters = cms.InputTag('hiMixedTripletStepClusters') -mixedTripletStepSeedLayersB.TIB.skipClusters = cms.InputTag('hiMixedTripletStepClusters') +mixedTripletStepSeedLayersB.BPix.skipClusters = 'hiMixedTripletStepClusters' +mixedTripletStepSeedLayersB.TIB.skipClusters = 'hiMixedTripletStepClusters' hiMixedTripletStepTrackingRegionsB = hiMixedTripletStepTrackingRegionsA.clone(RegionPSet=dict( originRadius = 1.0, @@ -81,41 +81,41 @@ # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiMixedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiMixedTripletStepTracks', - useAnyMVA = cms.bool(False), - GBRForestLabel = cms.string('HIMVASelectorIter11'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiMixedTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiMixedTripletStepTight', - preFilterName = 'hiMixedTripletStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiMixedTripletStep', - preFilterName = 'hiMixedTripletStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) - ), + src = 'hiMixedTripletStepTracks', + useAnyMVA = False, + GBRForestLabel = 'HIMVASelectorIter11', + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiMixedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiMixedTripletStepTight', + preFilterName = 'hiMixedTripletStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiMixedTripletStep', + preFilterName = 'hiMixedTripletStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiMixedTripletStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers=cms.VInputTag(cms.InputTag('hiMixedTripletStepTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiMixedTripletStepSelector","hiMixedTripletStep")), + TrackProducers = ['hiMixedTripletStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiMixedTripletStepSelector:hiMixedTripletStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiMixedTripletStepTask = cms.Task( hiMixedTripletStepClusters, diff --git a/RecoHI/HiTracking/python/hiMultiTrackSelector_cfi.py b/RecoHI/HiTracking/python/hiMultiTrackSelector_cfi.py index 2386b3b360730..bf1b93a5adcc7 100644 --- a/RecoHI/HiTracking/python/hiMultiTrackSelector_cfi.py +++ b/RecoHI/HiTracking/python/hiMultiTrackSelector_cfi.py @@ -12,14 +12,13 @@ #untracked bool copyTrajectories = true // when doing retracking before copyTrajectories = cms.untracked.bool(True), copyExtras = cms.untracked.bool(True), ## set to false on AOD - qualityBit = cms.string('loose'), ## set to '' or comment out if you dont want to set the - - chi2n_par = cms.double(0.3), # version with 1D hits modification - chi2n_no1Dmod_par = cms.double(9999.), # normalizedChi2 < nLayers * chi2n_par - res_par = cms.vdouble(99999., 99999.), # residual parameterization (re-check in HI) - d0_par1 = cms.vdouble(9999., 0.), # parameterized nomd0E + qualityBit = cms.string('loose'), ## set to '' or comment out if you dont want to set the + chi2n_par = cms.double(0.3), # version with 1D hits modification + chi2n_no1Dmod_par = cms.double(9999.), # normalizedChi2 < nLayers * chi2n_par + res_par = cms.vdouble(99999., 99999.), # residual parameterization (re-check in HI) + d0_par1 = cms.vdouble(9999., 0.), # parameterized nomd0E dz_par1 = cms.vdouble(9999., 0.), - d0_par2 = cms.vdouble(0.4, 4.0), # d0E from tk.d0Error + d0_par2 = cms.vdouble(0.4, 4.0), # d0E from tk.d0Error dz_par2 = cms.vdouble(0.4, 4.0), # Boolean indicating if adapted primary vertex compatibility cuts are to be applied. applyAdaptedPVCuts = cms.bool(True), @@ -52,27 +51,27 @@ ) hiTightMTS=hiLooseMTS.clone( - preFilterName='hiTrkLoose', - min_nhits = cms.uint32(8), - max_relpterr = cms.double(0.075), - d0_par2 = cms.vdouble(5.0, 0.0), - dz_par2 = cms.vdouble(5.0, 0.0), - chi2n_no1Dmod_par = cms.double(0.25), - name= cms.string('hiTrkTight'), - qualityBit = cms.string('tight'), ## set to '' or comment out if you dont want to set the bit - keepAllTracks= cms.bool(True) - ) + preFilterName ='hiTrkLoose', + min_nhits = 8, + max_relpterr = 0.075, + d0_par2 = [5.0, 0.0], + dz_par2 = [5.0, 0.0], + chi2n_no1Dmod_par = 0.25, + name = 'hiTrkTight', + qualityBit = 'tight', ## set to '' or comment out if you dont want to set the bit + keepAllTracks = True +) hiHighpurityMTS= hiTightMTS.clone( - name= cms.string('hiTrkHighPurity'), - preFilterName='hiTrkTight', - min_nhits = cms.uint32(8), - max_relpterr = cms.double(0.05), + name = 'hiTrkHighPurity', + preFilterName ='hiTrkTight', + min_nhits = 8, + max_relpterr = 0.05, d0_par2 = [3.0, 0.0], dz_par2 = [3.0, 0.0], - chi2n_no1Dmod_par = cms.double(0.15), - qualityBit = cms.string('highPurity') ## set to '' or comment out if you dont want to set the bit - ) + chi2n_no1Dmod_par = 0.15, + qualityBit = 'highPurity' ## set to '' or comment out if you dont want to set the bit +) #typical configuration is six selectors... something like this to #make cloning easier. diff --git a/RecoHI/HiTracking/python/hiPixelLessStep_cff.py b/RecoHI/HiTracking/python/hiPixelLessStep_cff.py index a78d930264339..6e8b438b45079 100644 --- a/RecoHI/HiTracking/python/hiPixelLessStep_cff.py +++ b/RecoHI/HiTracking/python/hiPixelLessStep_cff.py @@ -11,17 +11,17 @@ #HIClusterRemover from RecoHI.HiTracking.hiMixedTripletStep_cff import hiMixedTripletStepClusters -hiPixelLessStepClusters = hiMixedTripletStepClusters.clone() -hiPixelLessStepClusters.trajectories = cms.InputTag("hiMixedTripletStepTracks") -hiPixelLessStepClusters.overrideTrkQuals = cms.InputTag('hiMixedTripletStepSelector','hiMixedTripletStep') - +hiPixelLessStepClusters = hiMixedTripletStepClusters.clone( + trajectories = "hiMixedTripletStepTracks", + overrideTrkQuals = 'hiMixedTripletStepSelector:hiMixedTripletStep' +) # SEEDING LAYERS -pixelLessStepSeedLayers.TIB.skipClusters = cms.InputTag('hiPixelLessStepClusters') -pixelLessStepSeedLayers.MTIB.skipClusters = cms.InputTag('hiPixelLessStepClusters') -pixelLessStepSeedLayers.TID.skipClusters = cms.InputTag('hiPixelLessStepClusters') -pixelLessStepSeedLayers.MTID.skipClusters = cms.InputTag('hiPixelLessStepClusters') -pixelLessStepSeedLayers.TEC.skipClusters = cms.InputTag('hiPixelLessStepClusters') -pixelLessStepSeedLayers.MTEC.skipClusters = cms.InputTag('hiPixelLessStepClusters') +pixelLessStepSeedLayers.TIB.skipClusters = 'hiPixelLessStepClusters' +pixelLessStepSeedLayers.MTIB.skipClusters = 'hiPixelLessStepClusters' +pixelLessStepSeedLayers.TID.skipClusters = 'hiPixelLessStepClusters' +pixelLessStepSeedLayers.MTID.skipClusters = 'hiPixelLessStepClusters' +pixelLessStepSeedLayers.TEC.skipClusters = 'hiPixelLessStepClusters' +pixelLessStepSeedLayers.MTEC.skipClusters = 'hiPixelLessStepClusters' # TrackingRegion from RecoHI.HiTracking.hiMixedTripletStep_cff import hiMixedTripletStepTrackingRegionsA as _hiMixedTripletStepTrackingRegionsA @@ -42,7 +42,7 @@ pixelLessStepTrajectoryFilter.minPt = 0.7 # MAKING OF TRACK CANDIDATES -pixelLessStepTrackCandidates.clustersToSkip = cms.InputTag('hiPixelLessStepClusters') +pixelLessStepTrackCandidates.clustersToSkip = 'hiPixelLessStepClusters' # TRACK FITTING hiPixelLessStepTracks = pixelLessStepTracks.clone() @@ -50,41 +50,41 @@ # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiPixelLessStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiPixelLessStepTracks', - useAnyMVA = cms.bool(False), - GBRForestLabel = cms.string('HIMVASelectorIter12'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), + src = 'hiPixelLessStepTracks', + useAnyMVA = False, + GBRForestLabel = 'HIMVASelectorIter12', + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiPixelLessStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiPixelLessStepTight', - preFilterName = 'hiPixelLessStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiPixelLessStep', - preFilterName = 'hiPixelLessStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) - ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiPixelLessStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiPixelLessStepTight', + preFilterName = 'hiPixelLessStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiPixelLessStep', + preFilterName = 'hiPixelLessStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiPixelLessStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers=cms.VInputTag(cms.InputTag('hiPixelLessStepTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiPixelLessStepSelector","hiPixelLessStep")), + TrackProducers = ['hiPixelLessStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiPixelLessStepSelector:hiPixelLessStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiPixelLessStepTask = cms.Task(hiPixelLessStepClusters, pixelLessStepSeedLayers, diff --git a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py index f3c409f8aec9d..8d02751c2f999 100644 --- a/RecoHI/HiTracking/python/hiPixelPairStep_cff.py +++ b/RecoHI/HiTracking/python/hiPixelPairStep_cff.py @@ -26,52 +26,58 @@ # SEEDING LAYERS import RecoTracker.TkSeedingLayers.PixelLayerPairs_cfi hiPixelPairSeedLayers = RecoTracker.TkSeedingLayers.PixelLayerPairs_cfi.PixelLayerPairs.clone( - layerList = cms.vstring('BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3', - 'BPix1+FPix1_pos', 'BPix1+FPix1_neg', - 'BPix2+FPix1_pos', 'BPix2+FPix1_neg', - 'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg'), - BPix = cms.PSet( + layerList = ['BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3', + 'BPix1+FPix1_pos', 'BPix1+FPix1_neg', + 'BPix2+FPix1_pos', 'BPix2+FPix1_neg', + 'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg'], + BPix = cms.PSet( TTRHBuilder = cms.string('TTRHBuilderWithoutAngle4PixelPairs'), HitProducer = cms.string('siPixelRecHits'), skipClusters = cms.InputTag('hiPixelPairClusters') - ), - FPix = cms.PSet( + ), + FPix = cms.PSet( TTRHBuilder = cms.string('TTRHBuilderWithoutAngle4PixelPairs'), HitProducer = cms.string('siPixelRecHits'), skipClusters = cms.InputTag('hiPixelPairClusters') - ) + ) ) from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 trackingPhase1.toModify(hiPixelPairSeedLayers, - layerList = cms.vstring('BPix1+BPix4','BPix1+FPix1_pos','BPix1+FPix1_neg') #only use first and fourth barrel layers or first barrel and first forward layer around area where BPIX2+3 are inactive + layerList = ['BPix1+BPix4','BPix1+FPix1_pos','BPix1+FPix1_neg'] #only use first and fourth barrel layers or first barrel and first forward layer around area where BPIX2+3 are inactive ) # SEEDS import RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff -hiPixelPairSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff.globalSeedsFromPairsWithVertices.clone() -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.VertexCollection=cms.InputTag("hiSelectedPixelVertex") -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.0 -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.originRadius = 0.005 -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.nSigmaZ = 4.0 -# sigmaZVertex is only used when usedFixedError is True -Matt -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.sigmaZVertex = 4.0 -hiPixelPairSeeds.RegionFactoryPSet.RegionPSet.useFixedError = cms.bool(False) -hiPixelPairSeeds.OrderedHitsFactoryPSet.SeedingLayers = cms.InputTag('hiPixelPairSeedLayers') -hiPixelPairSeeds.OrderedHitsFactoryPSet.maxElement = 5000000 -hiPixelPairSeeds.ClusterCheckPSet.MaxNumberOfPixelClusters = 5000000 -hiPixelPairSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters = 50000000 -hiPixelPairSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters = 50000000 -del hiPixelPairSeeds.ClusterCheckPSet.cut - -hiPixelPairSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), - FilterAtHelixStage = cms.bool(True), - FilterPixelHits = cms.bool(True), - FilterStripHits = cms.bool(False), - ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), - ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") +hiPixelPairSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff.globalSeedsFromPairsWithVertices.clone( + RegionFactoryPSet = dict( + RegionPSet = dict( + VertexCollection = "hiSelectedPixelVertex", + ptMin = 1.0, + originRadius = 0.005, + nSigmaZ = 4.0, + # sigmaZVertex is only used when usedFixedError is True -Matt + sigmaZVertex = 4.0, + useFixedError = False + ) + ), + OrderedHitsFactoryPSet = dict( + SeedingLayers = 'hiPixelPairSeedLayers', + maxElement = 5000000 + ), + ClusterCheckPSet = dict( + MaxNumberOfPixelClusters = 5000000, + MaxNumberOfCosmicClusters = 50000000, + cut = "" + ), + SeedComparitorPSet = cms.PSet( + ComponentName = cms.string('PixelClusterShapeSeedComparitor'), + FilterAtHelixStage = cms.bool(True), + FilterPixelHits = cms.bool(True), + FilterStripHits = cms.bool(False), + ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), + ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") ) - +) #rectangular tracking region around area missing BPIX2/3 in Phase 1 from RecoTracker.TkTrackingRegions.pointSeededTrackingRegion_cfi import pointSeededTrackingRegion as _pointSeededTrackingRegion hiPixelPairStepTrackingRegionPhase1 = _pointSeededTrackingRegion.clone( @@ -97,7 +103,7 @@ seedingLayers = "hiPixelPairSeedLayers", trackingRegions = "hiPixelPairStepTrackingRegionPhase1", clusterCheck = "", - produceSeedingHitSets = cms.bool(True), + produceSeedingHitSets = True, ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer @@ -119,98 +125,97 @@ #maxLostHits = 0, minimumNumberOfHits = 6, minPt = 1.0 - ) +) import TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi hiPixelPairChi2Est = TrackingTools.KalmanUpdators.Chi2MeasurementEstimator_cfi.Chi2MeasurementEstimator.clone( - ComponentName = cms.string('hiPixelPairChi2Est'), - nSigma = cms.double(3.0), - MaxChi2 = cms.double(9.0) - ) + ComponentName = 'hiPixelPairChi2Est', + nSigma = 3.0, + MaxChi2 = 9.0 +) # TRACK BUILDING import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi hiPixelPairTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( - MeasurementTrackerName = '', - trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiPixelPairTrajectoryFilter')), - maxCand = 3, - estimator = cms.string('hiPixelPairChi2Est'), - maxDPhiForLooperReconstruction = cms.double(2.0), - maxPtForLooperReconstruction = cms.double(0.7) - ) + MeasurementTrackerName = '', + trajectoryFilter = dict(refToPSet_ = 'hiPixelPairTrajectoryFilter'), + maxCand = 3, + estimator = 'hiPixelPairChi2Est', + maxDPhiForLooperReconstruction = cms.double(2.0), + maxPtForLooperReconstruction = cms.double(0.7) +) # MAKING OF TRACK CANDIDATES import RecoTracker.CkfPattern.CkfTrackCandidates_cfi hiPixelPairTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( - src = cms.InputTag('hiPixelPairSeeds'), + src = 'hiPixelPairSeeds', clustersToSkip = cms.InputTag('hiPixelPairClusters'), - TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiPixelPairTrajectoryBuilder')), + TrajectoryBuilderPSet = dict(refToPSet_ = 'hiPixelPairTrajectoryBuilder'), ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput numHitsForSeedCleaner = cms.int32(50), onlyPixelHitsForSeedCleaner = cms.bool(True), - - ) +) trackingPhase1.toModify(hiPixelPairTrackCandidates, - src = cms.InputTag('hiPixelPairStepSeedsPhase1') + src = 'hiPixelPairStepSeedsPhase1' ) # TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi hiPixelPairGlobalPrimTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( - AlgorithmName = cms.string('pixelPairStep'), + AlgorithmName = 'pixelPairStep', src = 'hiPixelPairTrackCandidates', - Fitter = cms.string('FlexibleKFFittingSmoother') - ) + Fitter = 'FlexibleKFFittingSmoother' +) # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiPixelPairGlobalPrimTracks', - useAnyMVA = cms.bool(True), - GBRForestLabel = cms.string('HIMVASelectorIter6'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'nhits', 'nlayers', 'eta']), + src = 'hiPixelPairGlobalPrimTracks', + useAnyMVA = True, + GBRForestLabel = 'HIMVASelectorIter6', + GBRForestVars = ['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) - ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiPixelPairStepLoose', + useMVA = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiPixelPairStepTight', + preFilterName = 'hiPixelPairStepLoose', + useMVA = True, + minMVA = -0.58 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiPixelPairStep', + preFilterName = 'hiPixelPairStepTight', + useMVA = True, + minMVA = 0.77 + ), ) #end of vpset - ) #end of clone +) #end of clone from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(hiPixelPairStepSelector, useAnyMVA = cms.bool(False)) -trackingPhase1.toModify(hiPixelPairStepSelector, trackSelectors= cms.VPSet( +trackingPhase1.toModify(hiPixelPairStepSelector, useAnyMVA = False) +trackingPhase1.toModify(hiPixelPairStepSelector, trackSelectors = cms.VPSet( RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiPixelPairStepLoose', - useMVA = cms.bool(False) + name = 'hiPixelPairStepLoose', + useMVA = False ), #end of pset RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiPixelPairStepTight', - preFilterName = 'hiPixelPairStepLoose', - useMVA = cms.bool(False), - minMVA = cms.double(-0.58) + name = 'hiPixelPairStepTight', + preFilterName = 'hiPixelPairStepLoose', + useMVA = False, + minMVA = -0.58 ), RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiPixelPairStep', - preFilterName = 'hiPixelPairStepTight', - useMVA = cms.bool(False), - minMVA = cms.double(0.77) + name = 'hiPixelPairStep', + preFilterName = 'hiPixelPairStepTight', + useMVA = False, + minMVA = 0.77 ), - ) #end of vpset + ) #end of vpset ) diff --git a/RecoHI/HiTracking/python/hiRegitDetachedTripletStep_cff.py b/RecoHI/HiTracking/python/hiRegitDetachedTripletStep_cff.py index a09d38447110c..6f244d124bbc3 100644 --- a/RecoHI/HiTracking/python/hiRegitDetachedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiRegitDetachedTripletStep_cff.py @@ -31,69 +31,73 @@ # SEEDING LAYERS -hiRegitDetachedTripletStepSeedLayers = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeedLayers.clone() -hiRegitDetachedTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiRegitDetachedTripletStepClusters') -hiRegitDetachedTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiRegitDetachedTripletStepClusters') +hiRegitDetachedTripletStepSeedLayers = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeedLayers.clone( + BPix = dict(skipClusters = 'hiRegitDetachedTripletStepClusters'), + FPix = dict(skipClusters = 'hiRegitDetachedTripletStepClusters') +) -# seeding -hiRegitDetachedTripletStepSeeds = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeeds.clone() -hiRegitDetachedTripletStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitDetachedTripletStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitDetachedTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitDetachedTripletStepSeedLayers' from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * #import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -#hiRegitDetachedTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() -hiRegitDetachedTripletStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.2 - +# seeding +hiRegitDetachedTripletStepSeeds = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeeds.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + OrderedHitsFactoryPSet = dict( + SeedingLayers = 'hiRegitDetachedTripletStepSeedLayers' + #GeneratorPSet = dict(SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone()), + ), + RegionFactoryPSet = dict( + RegionPSet = dict(ptMin = 1.2) + ), +) # building: feed the new-named seeds hiRegitDetachedTripletStepTrajectoryFilter = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepTrajectoryFilterBase.clone() - hiRegitDetachedTripletStepTrajectoryBuilder = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepTrajectoryBuilder.clone( trajectoryFilter = cms.PSet(refToPSet_ = cms.string('hiRegitDetachedTripletStepTrajectoryFilter')), clustersToSkip = cms.InputTag('hiRegitDetachedTripletStepClusters') ) hiRegitDetachedTripletStepTrackCandidates = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepTrackCandidates.clone( - src = cms.InputTag('hiRegitDetachedTripletStepSeeds'), + src = 'hiRegitDetachedTripletStepSeeds', TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiRegitDetachedTripletStepTrajectoryBuilder')), maxNSeeds=100000 - ) +) # fitting: feed new-names hiRegitDetachedTripletStepTracks = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepTracks.clone( src = 'hiRegitDetachedTripletStepTrackCandidates', - #AlgorithmName = cms.string('jetCoreRegionalStep'), - AlgorithmName = cms.string('detachedTripletStep'), - ) + #AlgorithmName = 'jetCoreRegionalStep', + AlgorithmName = 'detachedTripletStep', +) # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiRegitDetachedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiRegitDetachedTripletStepTracks', - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitDetachedTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitDetachedTripletStepTight', - preFilterName = 'hiRegitDetachedTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitDetachedTripletStep', - preFilterName = 'hiRegitDetachedTripletStepTight', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False + src = 'hiRegitDetachedTripletStepTracks', + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiRegitDetachedTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitDetachedTripletStepTight', + preFilterName = 'hiRegitDetachedTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitDetachedTripletStep', + preFilterName = 'hiRegitDetachedTripletStepTight', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False ), - ) #end of vpset - ) #end of clone + ) #end of vpset +) #end of clone hiRegitDetachedTripletStepTask = cms.Task(hiRegitDetachedTripletStepClusters, diff --git a/RecoHI/HiTracking/python/hiRegitInitialStep_cff.py b/RecoHI/HiTracking/python/hiRegitInitialStep_cff.py index 945073bb7c8da..2d4b9ef2b6b70 100644 --- a/RecoHI/HiTracking/python/hiRegitInitialStep_cff.py +++ b/RecoHI/HiTracking/python/hiRegitInitialStep_cff.py @@ -23,22 +23,24 @@ pixelClusters = cms.InputTag("siPixelClusters"), stripClusters = cms.InputTag("siStripClusters"), Common = cms.PSet( - maxChi2 = cms.double(9.0), - ), - Strip = cms.PSet( - maxChi2 = cms.double(9.0), - ) + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + maxChi2 = cms.double(9.0), + ) ) # seeding -hiRegitInitialStepSeeds = RecoTracker.IterativeTracking.InitialStep_cff.initialStepSeeds.clone() -hiRegitInitialStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitInitialStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitInitialStepSeeds.skipClusters = cms.InputTag('hiRegitInitialStepClusters') -hiRegitInitialStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.2 - +hiRegitInitialStepSeeds = RecoTracker.IterativeTracking.InitialStep_cff.initialStepSeeds.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + skipClusters = cms.InputTag('hiRegitInitialStepClusters') + RegionFactoryPSet = dict( + RegionPSet = dict(ptMin = 1.2) + ), +) # building: feed the new-named seeds hiRegitInitialStepTrajectoryFilter = RecoTracker.IterativeTracking.InitialStep_cff.initialStepTrajectoryFilterBase.clone() @@ -50,45 +52,45 @@ # track candidates hiRegitInitialStepTrackCandidates = RecoTracker.IterativeTracking.InitialStep_cff.initialStepTrackCandidates.clone( - src = cms.InputTag('hiRegitInitialStepSeeds'), + src = 'hiRegitInitialStepSeeds', TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiRegitInitialStepTrajectoryBuilder')), maxNSeeds = 100000 - ) +) # fitting: feed new-names hiRegitInitialStepTracks = RecoTracker.IterativeTracking.InitialStep_cff.initialStepTracks.clone( src = 'hiRegitInitialStepTrackCandidates', - AlgorithmName = cms.string('initialStep') + AlgorithmName = 'initialStep' ) # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiRegitInitialStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiRegitInitialStepTracks', - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitInitialStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitInitialStepTight', - preFilterName = 'hiRegitInitialStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitInitialStep', - preFilterName = 'hiRegitInitialStepTight', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), + src = 'hiRegitInitialStepTracks', + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiRegitInitialStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitInitialStepTight', + preFilterName = 'hiRegitInitialStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitInitialStep', + preFilterName = 'hiRegitInitialStepTight', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), ) #end of vpset - ) #end of clone +) #end of clone hiRegitInitialStepTask = cms.Task(hiGeneralTrackFilter, diff --git a/RecoHI/HiTracking/python/hiRegitLowPtTripletStep_cff.py b/RecoHI/HiTracking/python/hiRegitLowPtTripletStep_cff.py index bbfce67da46ca..e69a7144e5744 100644 --- a/RecoHI/HiTracking/python/hiRegitLowPtTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiRegitLowPtTripletStep_cff.py @@ -19,31 +19,38 @@ pixelClusters = cms.InputTag("siPixelClusters"), stripClusters = cms.InputTag("siStripClusters"), Common = cms.PSet( - maxChi2 = cms.double(9.0), - ), - Strip = cms.PSet( - maxChi2 = cms.double(9.0), - #Yen-Jie's mod to preserve merged clusters - maxSize = cms.uint32(2) - ) + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + maxChi2 = cms.double(9.0), + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2) + ) ) # SEEDING LAYERS -hiRegitLowPtTripletStepSeedLayers = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeedLayers.clone() -hiRegitLowPtTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiRegitLowPtTripletStepClusters') -hiRegitLowPtTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiRegitLowPtTripletStepClusters') +hiRegitLowPtTripletStepSeedLayers = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeedLayers.clone( + BPix = dict(skipClusters = 'hiRegitLowPtTripletStepClusters'), + FPix = dict(skipClusters = 'hiRegitLowPtTripletStepClusters') +) -# seeds -hiRegitLowPtTripletStepSeeds = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeeds.clone() -hiRegitLowPtTripletStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitLowPtTripletStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitLowPtTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitLowPtTripletStepSeedLayers' from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -hiRegitLowPtTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() -hiRegitLowPtTripletStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 0.4 - +# seeds +hiRegitLowPtTripletStepSeeds = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeeds.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + OrderedHitsFactoryPSet = dict( + SeedingLayers = 'hiRegitLowPtTripletStepSeedLayers', + GeneratorPSet = dict ( + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() + ), + ), + RegionFactoryPSet = dict( + RegionPSet = dict(ptMin = 0.4) + ) +) # building: feed the new-named seeds hiRegitLowPtTripletStepTrajectoryFilter = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepStandardTrajectoryFilter.clone() @@ -56,46 +63,46 @@ # track candidates hiRegitLowPtTripletStepTrackCandidates = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepTrackCandidates.clone( - src = cms.InputTag('hiRegitLowPtTripletStepSeeds'), + src = 'hiRegitLowPtTripletStepSeeds', TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiRegitLowPtTripletStepTrajectoryBuilder')), maxNSeeds = 100000 - ) +) # fitting: feed new-names hiRegitLowPtTripletStepTracks = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepTracks.clone( src = 'hiRegitLowPtTripletStepTrackCandidates', - #AlgorithmName = cms.string('pixelLessStep') - AlgorithmName = cms.string('lowPtTripletStep') + #AlgorithmName = 'pixelLessStep' + AlgorithmName = 'lowPtTripletStep' ) # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiRegitLowPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiRegitLowPtTripletStepTracks', - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitLowPtTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitLowPtTripletStepTight', - preFilterName = 'hiRegitLowPtTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitLowPtTripletStep', - preFilterName = 'hiRegitLowPtTripletStepTight', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), + src = 'hiRegitLowPtTripletStepTracks', + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiRegitLowPtTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitLowPtTripletStepTight', + preFilterName = 'hiRegitLowPtTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitLowPtTripletStep', + preFilterName = 'hiRegitLowPtTripletStepTight', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), ) #end of vpset - ) #end of clone +) #end of clone hiRegitLowPtTripletStepTask = cms.Task(hiRegitLowPtTripletStepClusters, diff --git a/RecoHI/HiTracking/python/hiRegitMixedTripletStep_cff.py b/RecoHI/HiTracking/python/hiRegitMixedTripletStep_cff.py index d52ad3d204eca..403dc2573e749 100644 --- a/RecoHI/HiTracking/python/hiRegitMixedTripletStep_cff.py +++ b/RecoHI/HiTracking/python/hiRegitMixedTripletStep_cff.py @@ -19,54 +19,57 @@ pixelClusters = cms.InputTag("siPixelClusters"), stripClusters = cms.InputTag("siStripClusters"), Common = cms.PSet( - maxChi2 = cms.double(9.0), - ), - Strip = cms.PSet( - maxChi2 = cms.double(9.0), - #Yen-Jie's mod to preserve merged clusters - maxSize = cms.uint32(2) - ) + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + maxChi2 = cms.double(9.0), + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2) + ) ) # SEEDING LAYERS A -hiRegitMixedTripletStepSeedLayersA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedLayersA.clone() -hiRegitMixedTripletStepSeedLayersA.BPix.skipClusters = cms.InputTag('hiRegitMixedTripletStepClusters') -hiRegitMixedTripletStepSeedLayersA.FPix.skipClusters = cms.InputTag('hiRegitMixedTripletStepClusters') -hiRegitMixedTripletStepSeedLayersA.TEC.skipClusters = cms.InputTag('hiRegitMixedTripletStepClusters') -hiRegitMixedTripletStepSeedLayersA.layerList = cms.vstring('BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', - 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg', - 'FPix1_pos+FPix2_pos+TEC1_pos', 'FPix1_neg+FPix2_neg+TEC1_neg',) - +hiRegitMixedTripletStepSeedLayersA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedLayersA.clone( + BPix = dict(skipClusters = 'hiRegitMixedTripletStepClusters'), + FPix = dict(skipClusters = 'hiRegitMixedTripletStepClusters'), + TEC = dict(skipClusters = 'hiRegitMixedTripletStepClusters'), + layerList = ['BPix1+BPix2+BPix3', + 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', + 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', + 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg', + 'FPix1_pos+FPix2_pos+TEC1_pos', 'FPix1_neg+FPix2_neg+TEC1_neg'] +) # SEEDS A -hiRegitMixedTripletStepSeedsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsA.clone() -hiRegitMixedTripletStepSeedsA.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitMixedTripletStepSeedsA.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMixedTripletStepSeedsA.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMixedTripletStepSeedLayersA' -hiRegitMixedTripletStepSeedsA.RegionFactoryPSet.RegionPSet.ptMin = 1.0 - +hiRegitMixedTripletStepSeedsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsA.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + OrderedHitsFactoryPSet = dict(SeedingLayers = 'hiRegitMixedTripletStepSeedLayersA'), + RegionFactoryPSet = dict( + RegionPSet = dict(ptMin = 1.0) + ) +) # SEEDING LAYERS B -hiRegitMixedTripletStepSeedLayersB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedLayersB.clone() -hiRegitMixedTripletStepSeedLayersB.BPix.skipClusters = cms.InputTag('hiRegitMixedTripletStepClusters') -hiRegitMixedTripletStepSeedLayersB.TIB.skipClusters = cms.InputTag('hiRegitMixedTripletStepClusters') -hiRegitMixedTripletStepSeedLayersB.layerList = cms.vstring('BPix2+BPix3+TIB1','BPix2+BPix3+TIB2') - -hiRegitMixedTripletStepSeedsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsB.clone() -hiRegitMixedTripletStepSeedsB.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitMixedTripletStepSeedsB.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMixedTripletStepSeedsB.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMixedTripletStepSeedLayersB' -hiRegitMixedTripletStepSeedsB.RegionFactoryPSet.RegionPSet.ptMin = 1.0 - +hiRegitMixedTripletStepSeedLayersB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedLayersB.clone( + BPix = dict(skipClusters = 'hiRegitMixedTripletStepClusters'), + TIB = dict(skipClusters = 'hiRegitMixedTripletStepClusters'), + layerList = ['BPix2+BPix3+TIB1','BPix2+BPix3+TIB2'] +) +hiRegitMixedTripletStepSeedsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsB.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + OrderedHitsFactoryPSet = dict(SeedingLayers = 'hiRegitMixedTripletStepSeedLayersB'), + RegionFactoryPSet = dict( + RegionPSet = dict(ptMin = 1.0) + ) +) # combine seeds hiRegitMixedTripletStepSeeds = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeeds.clone( - seedCollections = cms.VInputTag( - cms.InputTag('hiRegitMixedTripletStepSeedsA'), - cms.InputTag('hiRegitMixedTripletStepSeedsB'), - ) - ) + seedCollections = ['hiRegitMixedTripletStepSeedsA', + 'hiRegitMixedTripletStepSeedsB' + ], +) # track building hiRegitMixedTripletStepTrajectoryFilter = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepTrajectoryFilter.clone() @@ -77,7 +80,7 @@ ) hiRegitMixedTripletStepTrackCandidates = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepTrackCandidates.clone( - src = cms.InputTag('hiRegitMixedTripletStepSeeds'), + src = 'hiRegitMixedTripletStepSeeds', TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiRegitMixedTripletStepTrajectoryBuilder')), maxNSeeds = 100000 ) @@ -85,37 +88,37 @@ # fitting: feed new-names hiRegitMixedTripletStepTracks = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepTracks.clone( src = 'hiRegitMixedTripletStepTrackCandidates', - #AlgorithmName = cms.string('conversionStep'), - AlgorithmName = cms.string('mixedTripletStep'), - ) + #AlgorithmName = 'conversionStep', + AlgorithmName = 'mixedTripletStep', +) # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiRegitMixedTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiRegitMixedTripletStepTracks', - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitMixedTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitMixedTripletStepTight', - preFilterName = 'hiRegitMixedTripletStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitMixedTripletStep', - preFilterName = 'hiRegitMixedTripletStepTight', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), + src = 'hiRegitMixedTripletStepTracks', + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiRegitMixedTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitMixedTripletStepTight', + preFilterName = 'hiRegitMixedTripletStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitMixedTripletStep', + preFilterName = 'hiRegitMixedTripletStepTight', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), ) #end of vpset - ) #end of clone +) #end of clone hiRegitMixedTripletStepTask = cms.Task(hiRegitMixedTripletStepClusters, hiRegitMixedTripletStepSeedLayersA, diff --git a/RecoHI/HiTracking/python/hiRegitPixelPairStep_cff.py b/RecoHI/HiTracking/python/hiRegitPixelPairStep_cff.py index c7777b29edfb6..9bd469ff15374 100644 --- a/RecoHI/HiTracking/python/hiRegitPixelPairStep_cff.py +++ b/RecoHI/HiTracking/python/hiRegitPixelPairStep_cff.py @@ -19,30 +19,30 @@ pixelClusters = cms.InputTag("siPixelClusters"), stripClusters = cms.InputTag("siStripClusters"), Common = cms.PSet( - maxChi2 = cms.double(9.0), - ), - Strip = cms.PSet( - maxChi2 = cms.double(9.0), - #Yen-Jie's mod to preserve merged clusters - maxSize = cms.uint32(2) - ) + maxChi2 = cms.double(9.0), + ), + Strip = cms.PSet( + maxChi2 = cms.double(9.0), + #Yen-Jie's mod to preserve merged clusters + maxSize = cms.uint32(2) + ) ) # SEEDING LAYERS -hiRegitPixelPairStepSeedLayers = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeedLayers.clone() -hiRegitPixelPairStepSeedLayers.BPix.skipClusters = cms.InputTag('hiRegitPixelPairStepClusters') -hiRegitPixelPairStepSeedLayers.FPix.skipClusters = cms.InputTag('hiRegitPixelPairStepClusters') - +hiRegitPixelPairStepSeedLayers = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeedLayers.clone( + BPix = dict(skipClusters = 'hiRegitPixelPairStepClusters'), + FPix = dict(skipClusters = 'hiRegitPixelPairStepClusters') +) # seeding -hiRegitPixelPairStepSeeds = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeeds.clone() -hiRegitPixelPairStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone() -hiRegitPixelPairStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitPixelPairStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitPixelPairStepSeedLayers' -hiRegitPixelPairStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.2 - +hiRegitPixelPairStepSeeds = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeeds.clone( + RegionFactoryPSet = HiTrackingRegionFactoryFromJetsBlock.clone(), + ClusterCheckPSet = dict(doClusterCheck = False), # do not check for max number of clusters pixel or strips + OrderedHitsFactoryPSet = dict(SeedingLayers = 'hiRegitPixelPairStepSeedLayers'), + RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 1.2)), +) # building: feed the new-named seeds hiRegitPixelPairStepTrajectoryFilter = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepTrajectoryFilterBase.clone() @@ -54,45 +54,45 @@ # trackign candidate hiRegitPixelPairStepTrackCandidates = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepTrackCandidates.clone( - src = cms.InputTag('hiRegitPixelPairStepSeeds'), + src = 'hiRegitPixelPairStepSeeds', TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('hiRegitPixelPairStepTrajectoryBuilder')), maxNSeeds = 100000 - ) +) # fitting: feed new-names hiRegitPixelPairStepTracks = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepTracks.clone( src = 'hiRegitPixelPairStepTrackCandidates', - AlgorithmName = cms.string('pixelPairStep'), - ) + AlgorithmName = 'pixelPairStep', +) # Track selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiRegitPixelPairStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiRegitPixelPairStepTracks', - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitPixelPairStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitPixelPairStepTight', - preFilterName = 'hiRegitPixelPairStepLoose', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitPixelPairStep', - preFilterName = 'hiRegitPixelPairStepTight', - d0_par2 = [9999.0, 0.0], - dz_par2 = [9999.0, 0.0], - applyAdaptedPVCuts = False - ), + src = 'hiRegitPixelPairStepTracks', + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiRegitPixelPairStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiRegitPixelPairStepTight', + preFilterName = 'hiRegitPixelPairStepLoose', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiRegitPixelPairStep', + preFilterName = 'hiRegitPixelPairStepTight', + d0_par2 = [9999.0, 0.0], + dz_par2 = [9999.0, 0.0], + applyAdaptedPVCuts = False + ), ) #end of vpset - ) #end of clone +) #end of clone hiRegitPixelPairStepTask = cms.Task(hiRegitPixelPairStepClusters, hiRegitPixelPairStepSeedLayers, diff --git a/RecoHI/HiTracking/python/hiTobTecStep_cff.py b/RecoHI/HiTracking/python/hiTobTecStep_cff.py index 524cb981b129d..52ba2973d0a61 100644 --- a/RecoHI/HiTracking/python/hiTobTecStep_cff.py +++ b/RecoHI/HiTracking/python/hiTobTecStep_cff.py @@ -9,14 +9,14 @@ # Very large impact parameter tracking using TOB + TEC ring 5 seeding # ####################################################################### from RecoHI.HiTracking.hiPixelLessStep_cff import hiPixelLessStepClusters -hiTobTecStepClusters = hiPixelLessStepClusters.clone() -hiTobTecStepClusters.trajectories = cms.InputTag("hiPixelLessStepTracks") -hiTobTecStepClusters.overrideTrkQuals = cms.InputTag('hiPixelLessStepSelector','hiPixelLessStep') - +hiTobTecStepClusters = hiPixelLessStepClusters.clone( + trajectories = "hiPixelLessStepTracks", + overrideTrkQuals = 'hiPixelLessStepSelector:hiPixelLessStep' +) # TRIPLET SEEDING LAYERS -tobTecStepSeedLayersTripl.TOB.skipClusters = cms.InputTag('hiTobTecStepClusters') -tobTecStepSeedLayersTripl.MTOB.skipClusters = cms.InputTag('hiTobTecStepClusters') -tobTecStepSeedLayersTripl.MTEC.skipClusters = cms.InputTag('hiTobTecStepClusters') +tobTecStepSeedLayersTripl.TOB.skipClusters = 'hiTobTecStepClusters' +tobTecStepSeedLayersTripl.MTOB.skipClusters = 'hiTobTecStepClusters' +tobTecStepSeedLayersTripl.MTEC.skipClusters = 'hiTobTecStepClusters' # Triplet TrackingRegion from RecoHI.HiTracking.hiMixedTripletStep_cff import hiMixedTripletStepTrackingRegionsA as _hiMixedTripletStepTrackingRegionsA @@ -31,8 +31,8 @@ tobTecStepHitDoubletsTripl.clusterCheck = "" tobTecStepHitDoubletsTripl.trackingRegions = "hiTobTecStepTrackingRegionsTripl" -tobTecStepSeedLayersPair.TOB.skipClusters = cms.InputTag('hiTobTecStepClusters') -tobTecStepSeedLayersPair.TEC.skipClusters = cms.InputTag('hiTobTecStepClusters') +tobTecStepSeedLayersPair.TOB.skipClusters = 'hiTobTecStepClusters' +tobTecStepSeedLayersPair.TEC.skipClusters = 'hiTobTecStepClusters' # Pair TrackingRegion hiTobTecStepTrackingRegionsPair = hiTobTecStepTrackingRegionsTripl.clone(RegionPSet=dict( @@ -52,7 +52,7 @@ tobTecStepTrajectoryFilter.minPt = 0.85 # MAKING OF TRACK CANDIDATES -tobTecStepTrackCandidates.clustersToSkip = cms.InputTag('hiTobTecStepClusters') +tobTecStepTrackCandidates.clustersToSkip = 'hiTobTecStepClusters' # TRACK FITTING hiTobTecStepTracks = tobTecStepTracks.clone() @@ -60,41 +60,41 @@ # Final selection import RecoHI.HiTracking.hiMultiTrackSelector_cfi hiTobTecStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src='hiTobTecStepTracks', - useAnyMVA = cms.bool(False), - GBRForestLabel = cms.string('HIMVASelectorIter13'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), - trackSelectors= cms.VPSet( - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiTobTecStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiTobTecStepTight', - preFilterName = 'hiTobTecStepLoose', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.2) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiTobTecStep', - preFilterName = 'hiTobTecStepTight', - applyAdaptedPVCuts = cms.bool(False), - useMVA = cms.bool(False), - minMVA = cms.double(-0.09) - ), + src = 'hiTobTecStepTracks', + useAnyMVA = False, + GBRForestLabel = 'HIMVASelectorIter13', + GBRForestVars = ['chi2perdofperlayer', 'nhits', 'nlayers', 'eta'], + trackSelectors = cms.VPSet( + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( + name = 'hiTobTecStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + ), #end of pset + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( + name = 'hiTobTecStepTight', + preFilterName = 'hiTobTecStepLoose', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.2 + ), + RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( + name = 'hiTobTecStep', + preFilterName = 'hiTobTecStepTight', + applyAdaptedPVCuts = False, + useMVA = False, + minMVA = -0.09 + ), ) #end of vpset - ) #end of clone +) #end of clone import RecoTracker.FinalTrackSelectors.trackListMerger_cfi hiTobTecStepQual = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( - TrackProducers=cms.VInputTag(cms.InputTag('hiTobTecStepTracks')), - hasSelector=cms.vint32(1), - selectedTrackQuals = cms.VInputTag(cms.InputTag("hiTobTecStepSelector","hiTobTecStep")), + TrackProducers = ['hiTobTecStepTracks'], + hasSelector = [1], + selectedTrackQuals = ["hiTobTecStepSelector:hiTobTecStep"], copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False), - ) +) hiTobTecStepTask = cms.Task(hiTobTecStepClusters,