RecoTrack/python/TrackValidation_cff.py

0001 import FWCore.ParameterSet.Config as cms
0002
0003 from SimTracker.TrackAssociatorProducers.trackAssociatorByChi2_cfi import *
0004 from SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi import *
0005 from SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi import *
0006 import Validation.RecoTrack.MultiTrackValidator_cfi
0007 from Validation.RecoTrack.trajectorySeedTracks_cfi import trajectorySeedTracks as _trajectorySeedTracks
0008 from Validation.RecoTrack.PostProcessorTracker_cfi import *
0009 import Validation.RecoTrack.cutsRecoTracks_cfi as cutsRecoTracks_cfi
0010 #from . import cutsRecoTracks_cfi
0011
0012 from SimTracker.TrackerHitAssociation.tpClusterProducer_cfi import *
0013 from SimTracker.VertexAssociation.VertexAssociatorByPositionAndTracks_cfi import *
0014 from CommonTools.RecoAlgos.trackingParticleRefSelector_cfi import trackingParticleRefSelector as _trackingParticleRefSelector
0015 from CommonTools.RecoAlgos.trackingParticleConversionRefSelector_cfi import trackingParticleConversionRefSelector as _trackingParticleConversionRefSelector
0016 from SimTracker.TrackHistory.trackingParticleBHadronRefSelector_cfi import trackingParticleBHadronRefSelector as _trackingParticleBHadronRefSelector
0017 from SimGeneral.TrackingAnalysis.trackingParticleNumberOfLayersProducer_cff import *
0018 from CommonTools.RecoAlgos.recoChargedRefCandidateToTrackRefProducer_cfi import recoChargedRefCandidateToTrackRefProducer as _recoChargedRefCandidateToTrackRefProducer
0019
0020 import RecoTracker.IterativeTracking.iterativeTkConfig as _cfg
0021 import RecoTracker.IterativeTracking.iterativeTkUtils as _utils
0022 from Configuration.Eras.Modifier_fastSim_cff import fastSim
0023 from Configuration.ProcessModifiers.hltClusterSplitting_cff import hltClusterSplitting
0024
0025 ### First define the stuff for the standard validation sequence
0026 ## Track selectors
0027 for _eraName, _postfix, _era in _cfg.allEras():
0028     _seedProd = ["initialStepSeedsPreSplitting"]
0029     _trackProd = ["initialStepTracksPreSplitting"]
0030     if _eraName in ["trackingLowPU", "trackingPhase2PU140"]: # these don't have preSplitting
0031         _seedProd = []
0032         _trackProd = []
0033
0034     locals()["_algos"+_postfix] = ["generalTracks"] + _cfg.iterationAlgos(_postfix) + ["duplicateMerge"]
0035     locals()["_seedProducersPreSplitting"+_postfix] = _seedProd
0036     locals()["_trackProducersPreSplitting"+_postfix] = _trackProd
0037     locals()["_seedProducers"+_postfix] = _cfg.seedProducers(_postfix)
0038     locals()["_trackProducers"+_postfix] = _cfg.trackProducers(_postfix)
0039
0040     if _eraName != "trackingPhase2PU140":
0041         locals()["_electronSeedProducers"+_postfix] = ["tripletElectronSeeds", "pixelPairElectronSeeds", "stripPairElectronSeeds"]
0042     else:
0043         locals()["_electronSeedProducers"+_postfix] = ["tripletElectronSeeds"]
0044
0045 _removeForFastSimSeedProducers =["initialStepSeedsPreSplitting",
0046                                  "jetCoreRegionalStepSeeds",
0047                                  "jetCoreRegionalStepSeedsBarrel","jetCoreRegionalStepSeedsEndcap",
0048                                  "displacedRegionalStepSeeds",
0049                                  "muonSeededSeedsInOut",
0050                                  "muonSeededSeedsOutIn"]
0051 _seedProducers_fastSim = [ x for x in _seedProducers if x not in _removeForFastSimSeedProducers]
0052 _seedProducers_hltSplit = [ x for x in _seedProducers if x not in ["initialStepSeedsPreSplitting"]]
0053
0054 _removeForFastTrackProducers = ["initialStepTracksPreSplitting",
0055                                 "jetCoreRegionalStepTracks",
0056                                 "displacedRegionalStepTracks",
0057                                 "muonSeededTracksInOut",
0058                                 "muonSeededTracksOutIn"]
0059 _trackProducers_fastSim = [ x for x in _trackProducers if x not in _removeForFastTrackProducers]
0060 _trackProducers_hltSplit = [ x for x in _trackProducers if x not in ["initialStepTracksPreSplitting"]]
0061
0062 def _algoToSelector(algo):
0063     sel = ""
0064     if algo != "generalTracks":
0065         sel = algo[0].upper()+algo[1:]
0066     return "cutsRecoTracks"+sel
0067
0068 def _addSelectorsByAlgo(algos, modDict):
0069     names = []
0070     task = cms.Task()
0071     for algo in algos:
0072         if algo == "generalTracks":
0073             continue
0074         modName = _algoToSelector(algo)
0075         if modName not in modDict:
0076             mod = cutsRecoTracks_cfi.cutsRecoTracks.clone(
0077 #                src = [src],
0078                 algorithm=[algo]
0079             )
0080             modDict[modName] = mod
0081         else:
0082             mod = modDict[modName]
0083         names.append(modName)
0084         task.add(mod)
0085     return (names, task)
0086 def _addSelectorsByHp(algos, modDict):
0087     task = cms.Task()
0088     names = []
0089     for algo in algos:
0090         modName = _algoToSelector(algo)
0091         modNameHp = modName+"Hp"
0092         if modNameHp not in modDict:
0093             if algo == "generalTracks":
0094                 mod = cutsRecoTracks_cfi.cutsRecoTracks.clone(quality=["highPurity"])
0095             else:
0096                 mod = modDict[modName].clone(quality=["highPurity"])
0097             modDict[modNameHp] = mod
0098         else:
0099             mod = modDict[modNameHp]
0100         names.append(modNameHp)
0101         task.add(mod)
0102     return (names, task)
0103 def _addSelectorsBySrc(modules, midfix, src, modDict):
0104     task = cms.Task()
0105     names = []
0106     for modName in modules:
0107         modNameNew = modName.replace("cutsRecoTracks", "cutsRecoTracks"+midfix)
0108         if modNameNew not in modDict:
0109             mod = modDict[modName].clone(src=src)
0110             modDict[modNameNew] = mod
0111         else:
0112             mod = modDict[modNameNew]
0113         names.append(modNameNew)
0114         task.add(mod)
0115     return (names, task)
0116 def _addSelectorsByOriginalAlgoMask(modules, midfix, algoParam,modDict):
0117     task = cms.Task()
0118     names = []
0119     for modName in modules:
0120         if modName[-2:] == "Hp":
0121             modNameNew = modName[:-2] + midfix + "Hp"
0122         else:
0123             modNameNew = modName + midfix
0124         if modNameNew not in modDict:
0125             mod = modDict[modName].clone()
0126             setattr(mod, algoParam, mod.algorithm.value())
0127             mod.algorithm = []
0128             modDict[modNameNew] = mod
0129         else:
0130             mod = modDict[modNameNew]
0131         names.append(modNameNew)
0132         task.add(mod)
0133     return (names, task)
0134 def _addSeedToTrackProducers(seedProducers,modDict):
0135     names = []
0136     task = cms.Task()
0137     for seed in seedProducers:
0138         modName = "seedTracks"+seed
0139         if modName not in modDict:
0140             mod = _trajectorySeedTracks.clone(src=seed)
0141             modDict[modName] = mod
0142         else:
0143             mod = modDict[modName]
0144         names.append(modName)
0145         task.add(mod)
0146     return (names, task)
0147
0148 _relevantEras = _cfg.allEras()
0149 _relevantErasAndFastSim = _relevantEras + [("fastSim", "_fastSim", fastSim)]
0150 def _translateArgs(args, postfix, modDict):
0151     ret = []
0152     for arg in args:
0153         if isinstance(arg, list):
0154             ret.append(_translateArgs(arg, postfix, modDict))
0155         else:
0156             ret.append(modDict[arg+postfix])
0157     return ret
0158 def _taskForEachEra(function, args, names, task, modDict, plainArgs=[], modifyTask=None, includeFastSim=False):
0159     if task[0] != "_":
0160         raise Exception("Task name is expected to begin with _")
0161
0162     _eras = _relevantErasAndFastSim if includeFastSim else _relevantEras
0163     for eraName, postfix, _era in _eras:
0164         _args = _translateArgs(args, postfix, modDict)
0165         _args.extend(plainArgs)
0166         ret = function(*_args, modDict=modDict)
0167         if len(ret) != 2:
0168             raise Exception("_taskForEachEra is expected to return 2 values, but function returned %d" % len(ret))
0169         modDict[names+postfix] = ret[0]
0170         modDict[task+postfix] = ret[1]
0171
0172     # The task of the first era will be the default one
0173     defaultTaskName = task+_eras[0][0]
0174     defaultTask = modDict[defaultTaskName]
0175     modDict[defaultTaskName[1:]] = defaultTask # remove leading underscore
0176
0177     # Optionally modify task before applying the era
0178     if modifyTask is not None:
0179         for eraName, postfix, _era in _eras:
0180             modifyTask(modDict[task+postfix])
0181
0182     # Apply eras
0183     for _eraName, _postfix, _era in _eras[1:]:
0184         _era.toReplaceWith(defaultTask, modDict[task+_postfix])
0185 def _setForEra(module, eraName, era, **kwargs):
0186     if eraName == "":
0187         for key, value in kwargs.items():
0188             setattr(module, key, value)
0189     else:
0190         era.toModify(module, **kwargs)
0191
0192 # Seeding layer sets
0193 def _getSeedingLayers(seedProducers, config):
0194     def _findSeedingLayers(name):
0195         prod = getattr(config, name)
0196         if hasattr(prod, "triplets"):
0197             if hasattr(prod, "layerList"): # merger
0198                 return prod.layerList.refToPSet_.value()
0199             return _findSeedingLayers(prod.triplets.getModuleLabel())
0200         elif hasattr(prod, "doublets"):
0201             return _findSeedingLayers(prod.doublets.getModuleLabel())
0202         label = prod.trackingRegionsSeedingLayers.getModuleLabel()
0203         if label != "":
0204             return label
0205         return prod.seedingLayers.getModuleLabel()
0206
0207     seedingLayersMerged = []
0208     for seedName in seedProducers:
0209         seedProd = getattr(config, seedName)
0210         seedingLayersName = None
0211         seedingLayers = None
0212         if hasattr(seedProd, "OrderedHitsFactoryPSet"): # old seeding framework
0213             seedingLayersName = seedProd.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel()
0214         elif hasattr(seedProd, "seedingHitSets"): # new seeding framework
0215             seedingLayersName = _findSeedingLayers(seedProd.seedingHitSets.getModuleLabel())
0216         elif hasattr(seedProd, "layerList"): # FastSim:
0217             seedingLayers = seedProd.layerList.value()
0218         else:
0219             continue
0220
0221         if seedingLayersName is not None:
0222             seedingLayers = getattr(config, seedingLayersName).layerList.value()
0223         for layerSet in seedingLayers:
0224             if layerSet not in seedingLayersMerged:
0225                 seedingLayersMerged.append(layerSet)
0226
0227     return seedingLayersMerged
0228 import RecoTracker.IterativeTracking.iterativeTk_cff as _iterativeTk_cff
0229 import RecoTracker.IterativeTracking.ElectronSeeds_cff as _ElectronSeeds_cff
0230 for _eraName, _postfix, _era in _relevantErasAndFastSim:
0231     _stdLayers = _getSeedingLayers(locals()["_seedProducers"+_postfix], _iterativeTk_cff)
0232     _eleLayers = []
0233     if "_electronSeedProducers"+_postfix in locals(): # doesn't exist for FastSim
0234         for _layer in _getSeedingLayers(locals()["_electronSeedProducers"+_postfix], _ElectronSeeds_cff):
0235             if _layer not in _stdLayers:
0236                 _eleLayers.append(_layer)
0237
0238     locals()["_seedingLayerSets"+_postfix] = _stdLayers
0239     locals()["_seedingLayerSetsForElectrons"+_postfix] = _eleLayers
0240
0241
0242 # MVA selectors
0243 def _getMVASelectors(postfix):
0244     mvaSel = _utils.getMVASelectors(postfix)
0245
0246     pset = cms.untracked.PSet()
0247     for iteration, (trackProducer, classifiers) in mvaSel.items():
0248         setattr(pset, trackProducer, cms.untracked.vstring(classifiers))
0249     return pset
0250 for _eraName, _postfix, _era in _relevantEras:
0251     locals()["_mvaSelectors"+_postfix] = _getMVASelectors(_postfix)
0252
0253 # Validation iterative steps
0254 _taskForEachEra(_addSelectorsByAlgo, args=["_algos"], names="_selectorsByAlgo", task="_tracksValidationSelectorsByAlgo", modDict=globals())
0255
0256 # high purity
0257 _taskForEachEra(_addSelectorsByHp, args=["_algos"], names="_selectorsByAlgoHp", task="_tracksValidationSelectorsByAlgoHp", modDict=globals())
0258
0259 # by originalAlgo
0260 for _eraName, _postfix, _era in _relevantEras:
0261     locals()["_selectorsByAlgoAndHp"+_postfix] = locals()["_selectorsByAlgo"+_postfix] + locals()["_selectorsByAlgoHp"+_postfix]
0262     # For ByAlgoMask
0263     locals()["_selectorsByAlgoAndHpNoGenTk"+_postfix] = [n for n in locals()["_selectorsByAlgoAndHp"+_postfix] if n not in ["generalTracks", "cutsRecoTracksHp"]]
0264     # For ByOriginalAlgo
0265     locals()["_selectorsByAlgoAndHpNoGenTkDupMerge"+_postfix] = [n for n in locals()["_selectorsByAlgoAndHpNoGenTk"+_postfix] if n not in ["cutsRecoTracksDuplicateMerge", "cutsRecoTracksDuplicateMergeHp"]]
0266 _taskForEachEra(_addSelectorsByOriginalAlgoMask, modDict = globals(),
0267                     args = ["_selectorsByAlgoAndHpNoGenTkDupMerge"], plainArgs = ["ByOriginalAlgo", "originalAlgorithm"],
0268                     names = "_selectorsByOriginalAlgo", task = "_tracksValidationSelectorsByOriginalAlgo")
0269
0270
0271 for _eraName, _postfix, _era in _relevantEras:
0272     selectors = locals()["_selectorsByAlgoHp"+_postfix]
0273     locals()["_generalTracksHp"+_postfix] = selectors[0]
0274     locals()["_selectorsByAlgoHp"+_postfix] = selectors[1:]
0275
0276 # BTV-like selection
0277 import PhysicsTools.RecoAlgos.btvTracks_cfi as btvTracks_cfi
0278 cutsRecoTracksBtvLike = btvTracks_cfi.btvTrackRefs.clone()
0279
0280 # Select tracks associated to AK4 jets
0281 import RecoJets.JetAssociationProducers.ak4JTA_cff as ak4JTA_cff
0282 ak4JetTracksAssociatorExplicitAll = ak4JTA_cff.ak4JetTracksAssociatorExplicit.clone(
0283     jets = "ak4PFJets"
0284 )
0285 from JetMETCorrections.Configuration.JetCorrectors_cff import *
0286 import JetMETCorrections.JetCorrector.jetTracksAssociationToTrackRefs_cfi as jetTracksAssociationToTrackRefs_cfi
0287 cutsRecoTracksAK4PFJets = jetTracksAssociationToTrackRefs_cfi.jetTracksAssociationToTrackRefs.clone(
0288     association = "ak4JetTracksAssociatorExplicitAll",
0289     jets = "ak4PFJets",
0290     correctedPtMin = 10,
0291 )
0292
0293
0294 ## Select signal TrackingParticles, and do the corresponding associations
0295 trackingParticlesSignal = _trackingParticleRefSelector.clone(
0296     signalOnly = True,
0297     chargedOnly = False,
0298     tip = 1e5,
0299     lip = 1e5,
0300     minRapidity = -10,
0301     maxRapidity = 10,
0302     ptMin = 0,
0303 )
0304 ## Select in-time TrackingParticles, and do the corresponding associations
0305 trackingParticlesInTime = trackingParticlesSignal.clone(
0306     signalOnly = False,
0307     intimeOnly = True,
0308 )
0309
0310 # select tracks with pT > 0.9 GeV (for upgrade fake rates)
0311 generalTracksPt09 = cutsRecoTracks_cfi.cutsRecoTracks.clone(ptMin=0.9)
0312 # and then the selectors
0313 _taskForEachEra(_addSelectorsBySrc, modDict=globals(),
0314                 args=[["_generalTracksHp"]],
0315                 plainArgs=["Pt09", "generalTracksPt09"],
0316                 names="_selectorsPt09", task="_tracksValidationSelectorsPt09",
0317                 modifyTask=lambda task:task.add(generalTracksPt09))
0318
0319 # select tracks from the PV
0320 from CommonTools.RecoAlgos.TrackWithVertexRefSelector_cfi import trackWithVertexRefSelector as _trackWithVertexRefSelector
0321 generalTracksFromPV = _trackWithVertexRefSelector.clone(
0322     src = "generalTracks",
0323     ptMin = 0,
0324     ptMax = 1e10,
0325     ptErrorCut = 1e10,
0326     quality = "loose",
0327     vertexTag = "offlinePrimaryVertices",
0328     nVertices = 1,
0329     vtxFallback = False,
0330     zetaVtx = 0.1, # 1 mm
0331     rhoVtx = 1e10, # intentionally no dxy cut
0332 )
0333 # and then the selectors
0334 _taskForEachEra(_addSelectorsBySrc, modDict=globals(),
0335                     args=[["_generalTracksHp"]],
0336                     plainArgs=["FromPV", "generalTracksFromPV"],
0337                     names="_selectorsFromPV", task="_tracksValidationSelectorsFromPV",
0338                     modifyTask=lambda task: task.add(generalTracksFromPV))
0339
0340 # select tracks with pT > 0.9 GeV from the PV
0341 generalTracksFromPVPt09 = generalTracksPt09.clone(src="generalTracksFromPV")
0342 # and then the selectors
0343 _taskForEachEra(_addSelectorsBySrc, modDict=globals(),
0344                 args=[["_generalTracksHp"]],
0345                 plainArgs=["FromPVPt09", "generalTracksFromPVPt09"],
0346                 names="_selectorsFromPVPt09", task="_tracksValidationSelectorsFromPVPt09",
0347                 modifyTask=lambda task: task.add(generalTracksFromPVPt09))
0348
0349 ## Select conversion TrackingParticles, and define the corresponding associator
0350 trackingParticlesConversion = _trackingParticleConversionRefSelector.clone()
0351
0352 ## Select electron TPs
0353 trackingParticlesElectron = _trackingParticleRefSelector.clone(
0354     pdgId = [-11, 11],
0355     signalOnly = False,
0356     tip = 1e5,
0357     lip = 1e5,
0358     minRapidity = -10,
0359     maxRapidity = 10,
0360     ptMin = 0,
0361 )
0362
0363 # Select jets for JetCore tracking
0364 highPtJets = cms.EDFilter("CandPtrSelector", src = cms.InputTag("ak4CaloJets"), cut = cms.string("pt()>1000"))
0365 highPtJetsForTrk = highPtJets.clone(src = "ak4CaloJetsForTrk")
0366
0367 # Select B-hadron TPs
0368 trackingParticlesBHadron = _trackingParticleBHadronRefSelector.clone()
0369
0370 ## MTV instances
0371 trackValidator = Validation.RecoTrack.MultiTrackValidator_cfi.multiTrackValidator.clone(
0372     useLogPt = cms.untracked.bool(True),
0373     dodEdxPlots = True,
0374     doPVAssociationPlots = True
0375     #,minpT = cms.double(-1)
0376     #,maxpT = cms.double(3)
0377     #,nintpT = cms.int32(40)
0378 )
0379 fastSim.toModify(trackValidator,
0380                       dodEdxPlots = False)
0381
0382 for _eraName, _postfix, _era in _relevantEras:
0383     _setForEra(trackValidator, _eraName, _era,
0384                label = ["generalTracks", locals()["_generalTracksHp"+_postfix]] +
0385                        locals()["_selectorsByAlgo"+_postfix] + locals()["_selectorsByAlgoHp"+_postfix] +
0386                        locals()["_selectorsByOriginalAlgo"+_postfix] +
0387                        ["generalTracksPt09"] + locals()["_selectorsPt09"+_postfix] +
0388                [
0389                    "cutsRecoTracksBtvLike",
0390                    "cutsRecoTracksAK4PFJets"
0391                ],
0392                doResolutionPlotsForLabels = [
0393                    "generalTracks",
0394                    locals()["_generalTracksHp"+_postfix],
0395                    "generalTracksPt09",
0396                    "cutsRecoTracksBtvLike",
0397                    "cutsRecoTracksJetCoreRegionalStepByOriginalAlgo"
0398                ]
0399     )
0400     _setForEra(trackValidator.histoProducerAlgoBlock, _eraName, _era, seedingLayerSets=locals()["_seedingLayerSets"+_postfix])
0401
0402 # for low-pT
0403 trackValidatorTPPtLess09 = trackValidator.clone(
0404     dirName = "Tracking/TrackTPPtLess09/",
0405     label = [x for x in trackValidator.label.value() if ("Pt09" not in x) and ("BtvLike" not in x) and ("AK4PFJets" not in x)],
0406     ptMaxTP = 0.9, # set maximum pT globally
0407     histoProducerAlgoBlock = dict(
0408         TpSelectorForEfficiencyVsEta  = dict(ptMin=0.05), # enough to set min pT here
0409         TpSelectorForEfficiencyVsPhi  = dict(ptMin=0.05),
0410         TpSelectorForEfficiencyVsVTXR = dict(ptMin=0.05),
0411         TpSelectorForEfficiencyVsVTXZ = dict(ptMin=0.05),
0412     ),
0413     doSimPlots = False,       # same as in trackValidator, no need to repeat here
0414     doRecoTrackPlots = False, # fake rates are same as in trackValidator, no need to repeat here
0415     doResolutionPlotsForLabels = ["disabled"], # resolutions are same as in trackValidator, no need to repeat here
0416 )
0417
0418 ## Select signal TrackingParticles, and do the corresponding associations
0419 trackingParticlesEtaGreater2p7 = _trackingParticleRefSelector.clone(
0420     signalOnly = cms.bool(False),
0421     tip = 1e5,
0422     lip = 1e5,
0423     minRapidity = -2.7,
0424     maxRapidity =  2.7,
0425     invertRapidityCut = cms.bool(True),
0426     ptMin = 0,
0427 )
0428
0429
0430 # select tracks with |eta| > 2.7
0431 generalTracksEtaGreater2p7 = cutsRecoTracks_cfi.cutsRecoTracks.clone(
0432     minRapidity = cms.double(-2.7),
0433     maxRapidity = cms.double( 2.7),
0434     invertRapidityCut = cms.bool(True)
0435 )
0436
0437 _taskForEachEra(_addSelectorsBySrc, modDict=globals(),
0438                     args=[["_generalTracksHp"]],
0439                     plainArgs=["EtaGreater2p7", "generalTracksEtaGreater2p7"],
0440                     names="_selectorsEtaGreater2p7", task="_tracksValidationSelectorsEtaGreater2p7",
0441                     modifyTask=lambda task: task.add(generalTracksEtaGreater2p7))
0442
0443 # for high-eta (phase2 : |eta| > 2.7)
0444 trackValidatorTPEtaGreater2p7 = trackValidator.clone(
0445     dirName = "Tracking/TrackTPEtaGreater2p7/",
0446     label_tp_effic = "trackingParticlesEtaGreater2p7",
0447     label_tp_fake  = "trackingParticlesEtaGreater2p7",
0448     label_tp_effic_refvector = True,
0449     label_tp_fake_refvector  = True,
0450     dodEdxPlots = False,
0451 #    doPVAssociationPlots = False,
0452     minRapidityTP = -2.7,
0453     maxRapidityTP = 2.7,
0454     invertRapidityCutTP = True,
0455 #    ptMaxTP = 0.9, # set maximum pT globally
0456     histoProducerAlgoBlock = dict(
0457         TpSelectorForEfficiencyVsPt   = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True), # enough to set min pT here
0458         TpSelectorForEfficiencyVsEta  = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True), # enough to set min pT here
0459         TpSelectorForEfficiencyVsPhi  = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
0460         TpSelectorForEfficiencyVsVTXR = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
0461         TpSelectorForEfficiencyVsVTXZ = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
0462         generalTpSelector             = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
0463 #        minEta  = -4.5,
0464 #        maxEta  =  4.5,
0465 #        nintEta = 90,
0466         #    minPt  = 0.01,
0467     ),
0468     doSimPlots = True,       # ####same as in trackValidator, no need to repeat here
0469     doRecoTrackPlots = True, # ####fake rates are same as in trackValidator, no need to repeat here
0470     doResolutionPlotsForLabels = ["disabled"] # resolutions are same as in trackValidator, no need to repeat here
0471 )
0472 for _eraName, _postfix, _era in _relevantEras:
0473     _setForEra(trackValidatorTPEtaGreater2p7, _eraName, _era,
0474                label = ["generalTracksEtaGreater2p7"] + locals()["_selectorsEtaGreater2p7"+_postfix] +
0475                        locals()["_selectorsByAlgo"+_postfix] + locals()["_selectorsByAlgoHp"+_postfix],
0476                doResolutionPlotsForLabels = ["generalTracksEtaGreater2p7"] + locals()["_selectorsEtaGreater2p7"+_postfix]
0477     )
0478
0479 # For efficiency of signal TPs vs. signal tracks, and fake rate of
0480 # signal tracks vs. signal TPs
0481 trackValidatorFromPV = trackValidator.clone(
0482     dirName = "Tracking/TrackFromPV/",
0483     label_tp_effic = "trackingParticlesSignal",
0484     label_tp_fake = "trackingParticlesSignal",
0485     label_tp_effic_refvector = True,
0486     label_tp_fake_refvector = True,
0487     trackCollectionForDrCalculation = "generalTracksFromPV",
0488     doPlotsOnlyForTruePV = True,
0489     doPVAssociationPlots = False,
0490     doResolutionPlotsForLabels = ["disabled"],
0491 )
0492 for _eraName, _postfix, _era in _relevantEras:
0493     _setForEra(trackValidatorFromPV, _eraName, _era,
0494                label = ["generalTracksFromPV"] + locals()["_selectorsFromPV"+_postfix] + ["generalTracksFromPVPt09"] + locals()["_selectorsFromPVPt09"+_postfix],
0495                doResolutionPlotsForLabels = [] # for standard "FromPV" do resolution plots for all input collections as they are already limited
0496     )
0497
0498 # For fake rate of signal tracks vs. all TPs, and pileup rate of
0499 # signal tracks vs. non-signal TPs
0500 trackValidatorFromPVAllTP = trackValidatorFromPV.clone(
0501     dirName = "Tracking/TrackFromPVAllTP/",
0502     label_tp_effic = trackValidator.label_tp_effic.value(),
0503     label_tp_fake = trackValidator.label_tp_fake.value(),
0504     label_tp_effic_refvector = False,
0505     label_tp_fake_refvector = False,
0506     doSimPlots = False,
0507     doSimTrackPlots = False,
0508     doResolutionPlotsForLabels = ["disabled"], # resolution plots are the same as in "trackValidatorFromPV"
0509 )
0510
0511 # For efficiency of all TPs vs. all tracks
0512 trackValidatorAllTPEffic = trackValidator.clone(
0513     dirName = "Tracking/TrackAllTPEffic/",
0514     label = [x for x in trackValidator.label.value() if "Pt09" not in x],
0515     doSimPlots = False,
0516     doRecoTrackPlots = True, # Fake rate of all tracks vs. all TPs is already included in trackValidator, but we want the reco plots for other reasons
0517     doPVAssociationPlots = False,
0518     doResolutionPlotsForLabels = ["disabled"], # resolution plots are the same as in "trackValidator"
0519 )
0520 trackValidatorAllTPEffic.histoProducerAlgoBlock.generalTpSelector.signalOnly = False
0521 trackValidatorAllTPEffic.histoProducerAlgoBlock.TpSelectorForEfficiencyVsEta.signalOnly = False
0522 trackValidatorAllTPEffic.histoProducerAlgoBlock.TpSelectorForEfficiencyVsPhi.signalOnly = False
0523 trackValidatorAllTPEffic.histoProducerAlgoBlock.TpSelectorForEfficiencyVsPt.signalOnly = False
0524 trackValidatorAllTPEffic.histoProducerAlgoBlock.TpSelectorForEfficiencyVsVTXR.signalOnly = False
0525 trackValidatorAllTPEffic.histoProducerAlgoBlock.TpSelectorForEfficiencyVsVTXZ.signalOnly = False
0526 for _eraName, _postfix, _era in _relevantEras:
0527     _setForEra(trackValidatorAllTPEffic, _eraName, _era, label = ["generalTracks", locals()["_generalTracksHp"+_postfix]])
0528
0529 # Built tracks, in the standard sequence mainly for monitoring the track selection MVA
0530 tpClusterProducerPreSplitting = tpClusterProducer.clone(pixelClusterSrc = "siPixelClustersPreSplitting")
0531 quickTrackAssociatorByHitsPreSplitting = quickTrackAssociatorByHits.clone(cluster2TPSrc = "tpClusterProducerPreSplitting")
0532 _trackValidatorSeedingBuilding = trackValidator.clone( # common for built tracks and seeds (in trackingOnly)
0533     associators = ["quickTrackAssociatorByHits"],
0534     UseAssociators = True,
0535     dodEdxPlots = False,
0536     doPVAssociationPlots = False,
0537     doSimPlots = False,
0538     doResolutionPlotsForLabels = ["disabled"]
0539 )
0540 trackValidatorBuilding = _trackValidatorSeedingBuilding.clone(
0541     dirName = "Tracking/TrackBuilding/",
0542     doMVAPlots = True,
0543     doResolutionPlotsForLabels = ['jetCoreRegionalStepTracks']
0544 )
0545 trackValidatorBuildingPreSplitting = trackValidatorBuilding.clone(
0546     associators = ["quickTrackAssociatorByHitsPreSplitting"],
0547     doMVAPlots = False,
0548     doSummaryPlots = False,
0549 )
0550 for _eraName, _postfix, _era in _relevantErasAndFastSim:
0551     _setForEra(trackValidatorBuilding, _eraName, _era, label = locals()["_trackProducers"+_postfix])
0552 fastSim.toModify(trackValidatorBuilding, doMVAPlots=False)
0553 for _eraName, _postfix, _era in _relevantEras:
0554     _setForEra(trackValidatorBuilding, _eraName, _era, mvaLabels = locals()["_mvaSelectors"+_postfix])
0555     _setForEra(trackValidatorBuildingPreSplitting, _eraName, _era, label = locals()["_trackProducersPreSplitting"+_postfix])
0556
0557
0558 # For conversions
0559 trackValidatorConversion = trackValidator.clone(
0560     dirName = "Tracking/TrackConversion/",
0561     label = [
0562         "convStepTracks",
0563         "conversionStepTracks",
0564         "ckfInOutTracksFromConversions",
0565         "ckfOutInTracksFromConversions",
0566     ],
0567     label_tp_effic = "trackingParticlesConversion",
0568     label_tp_effic_refvector = True,
0569     associators = ["quickTrackAssociatorByHits"],
0570     UseAssociators = True,
0571     doSimPlots = True,
0572     dodEdxPlots = False,
0573     doPVAssociationPlots = False,
0574     calculateDrSingleCollection = False,
0575 )
0576 from RecoTracker.ConversionSeedGenerators.ConversionStep_cff import convLayerPairs as _convLayerPairs
0577 def _uniqueFirstLayers(layerList):
0578     firstLayers = [layerSet.split("+")[0] for layerSet in layerList]
0579     ret = []
0580     for l in firstLayers:
0581         if not l in ret:
0582             ret.append(l)
0583             # For conversions add also the mono-TEC to the list as 'TEC'
0584             # is used for both matched and unmatched rphi/stereo hits
0585             if l.startswith("TEC"):
0586                 ret.append("M"+l)
0587     return ret
0588 # PhotonConversionTrajectorySeedProducerFromSingleLeg keeps only the
0589 # first hit of the pairs in the seed, bookkeeping those is the best we
0590 # can do without major further development
0591 trackValidatorConversion.histoProducerAlgoBlock.seedingLayerSets = _uniqueFirstLayers(_convLayerPairs.layerList.value())
0592 # relax lip and tip
0593 for n in ["Eta", "Phi", "Pt", "VTXR", "VTXZ"]:
0594     pset = getattr(trackValidatorConversion.histoProducerAlgoBlock, "TpSelectorForEfficiencyVs"+n)
0595     pset.lip = trackValidatorConversion.lipTP.value()
0596     pset.tip = trackValidatorConversion.tipTP.value()
0597
0598 # For electrons
0599 trackValidatorGsfTracks = trackValidatorConversion.clone(
0600     dirName = "Tracking/TrackGsf/",
0601     label = ["electronGsfTracks"],
0602     label_tp_effic = "trackingParticlesElectron",
0603 )
0604 # add the additional seeding layers from ElectronSeeds
0605 for _eraName, _postfix, _era in _relevantEras:
0606     _setForEra(trackValidatorGsfTracks.histoProducerAlgoBlock, _eraName, _era, seedingLayerSets=trackValidator.histoProducerAlgoBlock.seedingLayerSets.value()+locals()["_seedingLayerSetsForElectrons"+_postfix])
0607
0608 # For jetCore tracks
0609 trackValidatorJetCore = trackValidator.clone(#equivalent to trackBuilding case
0610     dirName = "Tracking/JetCore/",
0611     useLogPt = cms.untracked.bool(True),
0612     dodEdxPlots = False,
0613     associators= ["trackAssociatorByChi2"],#cms.untracked.VInputTag('MTVTrackAssociationByChi2'),
0614     UseAssociators = True,
0615     doPVAssociationPlots = True,
0616     label_tp_effic = "trackingParticlesInTime",
0617     label_tp_fake = "trackingParticlesInTime",
0618     label_tp_effic_refvector = True,
0619     label_tp_fake_refvector = True,
0620 )
0621 for _eraName, _postfix, _era in _relevantEras:
0622     if 'jetCoreRegionalStep' in _cfg.iterationAlgos(_postfix) :
0623         _setForEra(trackValidatorJetCore, _eraName, _era,
0624             label = ["generalTracks", "jetCoreRegionalStepTracks",
0625                     "cutsRecoTracksJetCoreRegionalStepByOriginalAlgo","cutsRecoTracksJetCoreRegionalStepByOriginalAlgoHp",
0626                     "cutsRecoTracksJetCoreRegionalStep", "cutsRecoTracksJetCoreRegionalStepHp"],
0627             doResolutionPlotsForLabels =["generalTracks", "jetCoreRegionalStepTracks",
0628                     "cutsRecoTracksJetCoreRegionalStepByOriginalAlgo","cutsRecoTracksJetCoreRegionalStepByOriginalAlgoHp",
0629                     "cutsRecoTracksJetCoreRegionalStep", "cutsRecoTracksJetCoreRegionalStepHp"],
0630         )
0631
0632 # for B-hadrons
0633 trackValidatorBHadron = trackValidator.clone(
0634     dirName = "Tracking/TrackBHadron/",
0635     label_tp_effic = "trackingParticlesBHadron",
0636     label_tp_effic_refvector = True,
0637     doSimPlots = True,
0638     doRecoTrackPlots = False, # Fake rate is defined wrt. all TPs, and that is already included in trackValidator
0639     dodEdxPlots = False,
0640 )
0641 for _eraName, _postfix, _era in _relevantEras:
0642     _setForEra(trackValidatorBHadron, _eraName, _era,
0643                label = ["generalTracks", locals()["_generalTracksHp"+_postfix], "cutsRecoTracksBtvLike"]
0644     )
0645
0646
0647 # for displaced tracks
0648 trackValidatorDisplaced = trackValidator.clone(
0649     dirName = "Tracking/TrackDisplaced/",
0650     label = [x for x in trackValidator.label.value() if ("Pt09" not in x) and ("BtvLike" not in x) and ("AK4PFJets" not in x)],
0651     ptMaxTP = 1e5,
0652     dodEdxPlots = False,
0653     invertRapidityCutTP = False,
0654     histoProducerAlgoBlock = dict(
0655         TpSelectorForEfficiencyVsPt   = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5), # enough to set min pT here
0656         TpSelectorForEfficiencyVsEta  = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5), # enough to set min pT here
0657         TpSelectorForEfficiencyVsPhi  = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5),
0658         TpSelectorForEfficiencyVsVTXR = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5),
0659         TpSelectorForEfficiencyVsVTXZ = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5),
0660         generalTpSelector             = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5),
0661         minDxy = -60,
0662         maxDxy =  60,
0663         nintDxy = 120,
0664         minDz  = -30,
0665         maxDz  =  30,
0666         nintDz =  60,
0667     ),
0668     signalOnlyTP = True,
0669     lipTP = 1e5,
0670     tipTP = 1e5,
0671 )
0672
0673 # the track selectors
0674 tracksValidationSelectors = cms.Task(
0675     tracksValidationSelectorsByAlgo,
0676     tracksValidationSelectorsByAlgoHp,
0677     tracksValidationSelectorsByOriginalAlgo,
0678     cutsRecoTracksBtvLike,
0679     ak4JetTracksAssociatorExplicitAll,
0680     cutsRecoTracksAK4PFJets
0681 )
0682 phase2_tracker.toModify(tracksValidationSelectors, lambda x: x.add(generalTracksEtaGreater2p7))
0683 phase2_tracker.toModify(tracksValidationSelectors, lambda x: x.add(cutsRecoTracksEtaGreater2p7Hp))
0684
0685 # Validation iterative steps
0686 _taskForEachEra(_addSelectorsByAlgo, modDict=globals(),
0687                 args=["_algos"],
0688                 names="_selectorsByAlgo", task="_tracksEtaGreater2p7ValidationSelectorsByAlgo"
0689                )
0690
0691 # high purity
0692 _taskForEachEra(_addSelectorsByHp, modDict=globals(),
0693                 args=["_algos"],
0694                 names="_selectorsByAlgoHp", task="_tracksEtaGreater2p7ValidationSelectorsByAlgoHp"
0695                )
0696
0697 for _eraName, _postfix, _era in _relevantEras:
0698     selectors = locals()["_selectorsByAlgoHp"+_postfix]
0699     locals()["_generalTracksHp"+_postfix] = selectors[0]
0700     locals()["_selectorsByAlgoHp"+_postfix] = selectors[1:]
0701
0702 phase2_tracker.toModify(tracksValidationSelectors, lambda x: x.add(tracksEtaGreater2p7ValidationSelectorsByAlgo))
0703 phase2_tracker.toModify(tracksValidationSelectors, lambda x: x.add(tracksEtaGreater2p7ValidationSelectorsByAlgoHp))
0704
0705 tracksValidationTruth = cms.Task(
0706     tpClusterProducer,
0707     tpClusterProducerPreSplitting,
0708     trackAssociatorByChi2,
0709     quickTrackAssociatorByHits,
0710     quickTrackAssociatorByHitsPreSplitting,
0711     trackingParticleRecoTrackAsssociation,
0712     VertexAssociatorByPositionAndTracks,
0713     trackingParticleNumberOfLayersProducer
0714 )
0715
0716 # HIon modifiers
0717 from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
0718
0719 trackingParticleHIPixelTrackAssociation = trackingParticleRecoTrackAsssociation.clone(
0720     label_tr = "hiConformalPixelTracks",
0721     associator = "quickTrackAssociatorByHits",
0722 )
0723
0724 # For the moment we have no Alpaka version of the hiConformalPixelTracks
0725 # from Configuration.ProcessModifiers.pixelNtupletFit_cff import pixelNtupletFit
0726
0727 # pixelNtupletFit.toModify(trackingParticleHIPixelTrackAssociation,
0728 #         associator = "quickTrackAssociatorByHitsPreSplitting")
0729
0730 HIPixelVertexAssociatorByPositionAndTracks = VertexAssociatorByPositionAndTracks.clone(
0731     trackAssociation = "trackingParticleHIPixelTrackAssociation"
0732 )
0733
0734 pp_on_AA.toReplaceWith(tracksValidationTruth, cms.Task(
0735     tracksValidationTruth.copy(),
0736     trackingParticleHIPixelTrackAssociation,
0737     HIPixelVertexAssociatorByPositionAndTracks
0738 ))
0739 fastSim.toModify(tracksValidationTruth, lambda x: x.remove(tpClusterProducer))
0740
0741 tracksPreValidation = cms.Task(
0742     highPtJetsForTrk,
0743     tracksValidationSelectors,
0744     tracksValidationSelectorsPt09,
0745     tracksValidationSelectorsFromPV,
0746     tracksValidationSelectorsFromPVPt09,
0747     tracksValidationTruth,
0748     trackingParticlesSignal,
0749     trackingParticlesInTime,
0750     trackingParticlesElectron,
0751     trackingParticlesConversion
0752 )
0753 fastSim.toReplaceWith(tracksPreValidation, tracksPreValidation.copyAndExclude([
0754     trackingParticlesElectron,
0755     trackingParticlesConversion,
0756 ]))
0757
0758
0759
0760 tracksValidation = cms.Sequence(
0761     trackValidator +
0762     trackValidatorTPPtLess09 +
0763     trackValidatorFromPV +
0764     trackValidatorFromPVAllTP +
0765     trackValidatorAllTPEffic +
0766     trackValidatorBuilding +
0767     trackValidatorBuildingPreSplitting +
0768     trackValidatorConversion +
0769     trackValidatorGsfTracks,
0770     tracksPreValidation
0771 )
0772
0773 trackValidatorHILowPtConformalValidator = trackValidator.clone(
0774     dirName = "Tracking/HIPixelTrack/",
0775     label = [
0776         "hiConformalPixelTracks",
0777     ],
0778     doResolutionPlotsForLabels = ["hiConformalPixelTracks"],
0779     trackCollectionForDrCalculation = "hiConformalPixelTracks",
0780     associators = ["trackingParticleHIPixelTrackAssociation"],
0781     vertexAssociator = "HIPixelVertexAssociatorByPositionAndTracks",
0782     dodEdxPlots = False,
0783     cores = ""
0784 )
0785
0786 tracksValidationHIonTask = cms.Task(trackValidatorHILowPtConformalValidator)
0787
0788 tracksValidationHIon = cms.Sequence(
0789     tracksValidation.copy(),
0790     tracksValidationHIonTask
0791 )
0792
0793 pp_on_AA.toReplaceWith(tracksValidation,tracksValidationHIon)
0794
0795
0796 from Configuration.ProcessModifiers.seedingDeepCore_cff import seedingDeepCore
0797 seedingDeepCore.toReplaceWith(tracksValidation, cms.Sequence(tracksValidation.copy()+trackValidatorJetCore))
0798
0799 from Configuration.ProcessModifiers.displacedTrackValidation_cff import displacedTrackValidation
0800 displacedTrackValidation.toReplaceWith(tracksValidation, cms.Sequence(tracksValidation.copy()+trackValidatorDisplaced))
0801
0802 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
0803 tracksPreValidationPhase2 = tracksPreValidation.copy()
0804 tracksPreValidationPhase2.add(trackingParticlesEtaGreater2p7)
0805 phase2_tracker.toReplaceWith(tracksPreValidation, tracksPreValidationPhase2)
0806
0807 tracksValidationPhase2 = tracksValidation.copyAndExclude([
0808     trackValidatorJetCore
0809 ])
0810 tracksValidationPhase2+=trackValidatorTPEtaGreater2p7
0811 phase2_tracker.toReplaceWith(tracksValidation, tracksValidationPhase2)
0812
0813 fastSim.toReplaceWith(tracksValidation, tracksValidation.copyAndExclude([
0814     trackValidatorBuildingPreSplitting,
0815     trackValidatorConversion,
0816     trackValidatorGsfTracks,
0817 ]))
0818
0819 hltClusterSplitting.toReplaceWith(tracksValidation, tracksValidation.copyAndExclude([
0820     trackValidatorBuildingPreSplitting,
0821 ]))
0822
0823 ### Then define stuff for standalone mode (i.e. MTV with RECO+DIGI input)
0824
0825 # Select by originalAlgo and algoMask
0826 _taskForEachEra(_addSelectorsByOriginalAlgoMask, modDict = globals(),
0827                 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["ByAlgoMask", "algorithmMaskContains"],
0828                 names = "_selectorsByAlgoMask", task = "_tracksValidationSelectorsByAlgoMaskStandalone")
0829
0830 # Select pT>0.9 by iteration
0831 # Need to avoid generalTracks+HP because those are already included in the standard validator
0832 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0833                 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["Pt09", "generalTracksPt09"],
0834                 names = "_selectorsPt09Standalone", task = "_tracksValidationSelectorsPt09Standalone")
0835
0836 # Select fromPV by iteration
0837 # Need to avoid generalTracks+HP because those are already included in the standard validator
0838 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0839                 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["FromPV", "generalTracksFromPV"],
0840                 names = "_selectorsFromPVStandalone", task = "_tracksValidationSelectorsFromPVStandalone")
0841
0842 # Select pt>0.9 and fromPV by iteration
0843 # Need to avoid generalTracks+HP because those are already included in the standard validator
0844 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0845                 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["FromPVPt09", "generalTracksFromPVPt09"],
0846                 names = "_selectorsFromPVPt09Standalone", task = "_tracksValidationSelectorsFromPVPt09Standalone")
0847
0848 # MTV instances
0849 trackValidatorStandalone = trackValidator.clone(
0850     cores = "highPtJets"
0851 )
0852 trackValidatorTPPtLess09Standalone = trackValidatorTPPtLess09.clone(
0853     cores = "highPtJets"
0854 )
0855 for _eraName, _postfix, _era in _relevantEras:
0856     _setForEra(trackValidatorStandalone, _eraName, _era, label = trackValidator.label + locals()["_selectorsByAlgoMask"+_postfix] + locals()["_selectorsPt09Standalone"+_postfix])
0857     _setForEra(trackValidatorTPPtLess09Standalone, _eraName, _era, label = trackValidatorTPPtLess09.label + locals()["_selectorsByAlgoMask"+_postfix] + locals()["_selectorsPt09Standalone"+_postfix])
0858
0859 trackValidatorFromPVStandalone = trackValidatorFromPV.clone(
0860     cores = "highPtJets"
0861 )
0862 for _eraName, _postfix, _era in _relevantEras:
0863     _setForEra(trackValidatorFromPVStandalone, _eraName, _era, label = trackValidatorFromPV.label + locals()["_selectorsFromPVStandalone"+_postfix] + locals()["_selectorsFromPVPt09Standalone"+_postfix])
0864 # do resolutions as in the standard version
0865
0866 trackValidatorFromPVAllTPStandalone = trackValidatorFromPVAllTP.clone(
0867     label = trackValidatorFromPVStandalone.label.value(),
0868     cores = "highPtJets"
0869
0870 )
0871 trackValidatorAllTPEfficStandalone = trackValidatorAllTPEffic.clone(
0872     label = [ x for x in trackValidator.label.value() if x not in ["cutsRecoTracksBtvLike", "cutsRecoTracksAK4PFJets"] and "Pt09" not in x],
0873     cores = "highPtJets"
0874 )
0875
0876 trackValidatorConversionStandalone = trackValidatorConversion.clone(
0877     label = [x for x in trackValidatorConversion.label if x != "convStepTracks"],
0878     cores = "highPtJets"
0879 )
0880
0881 trackValidatorBHadronStandalone = trackValidatorBHadron.clone(
0882     label = [x for x in trackValidatorStandalone.label if "Pt09" not in x],
0883     cores = "highPtJets"
0884 )
0885
0886 trackValidatorGsfTracksStandalone = trackValidatorGsfTracks.clone(
0887     cores = "highPtJets"
0888 )
0889
0890 # sequences
0891 tracksPreValidationStandalone = tracksPreValidation.copy()
0892 tracksPreValidationStandalone.add(trackingParticlesBHadron)
0893 tracksPreValidationStandalone.replace(highPtJetsForTrk,highPtJets)
0894 fastSim.toReplaceWith(tracksPreValidationStandalone, tracksPreValidation)
0895
0896 tracksValidationSelectorsStandalone = cms.Task(
0897     tracksValidationSelectorsByAlgoMaskStandalone,
0898     tracksValidationSelectorsPt09Standalone,
0899     tracksValidationSelectorsFromPVStandalone,
0900     tracksValidationSelectorsFromPVPt09Standalone
0901 )
0902
0903 # we copy this for both Standalone and TrackingOnly
0904 #  and later make modifications from it which change based on era
0905 _trackValidatorsBase = cms.Sequence(
0906     trackValidatorStandalone +
0907     trackValidatorTPPtLess09Standalone +
0908     trackValidatorFromPVStandalone +
0909     trackValidatorFromPVAllTPStandalone +
0910     trackValidatorAllTPEfficStandalone +
0911     trackValidatorConversionStandalone +
0912     trackValidatorGsfTracksStandalone +
0913     trackValidatorBHadronStandalone
0914 )
0915
0916 _trackValidatorsBasePhase2 = _trackValidatorsBase.copy()
0917 _trackValidatorsBasePhase2+=trackValidatorTPEtaGreater2p7
0918 phase2_tracker.toReplaceWith(_trackValidatorsBase, _trackValidatorsBasePhase2)
0919
0920 trackValidatorsStandalone = _trackValidatorsBase.copy()
0921 fastSim.toModify(trackValidatorsStandalone, lambda x: x.remove(trackValidatorConversionStandalone) )
0922
0923 tracksValidationStandalone = cms.Sequence(
0924     ak4PFL1FastL2L3CorrectorChain +
0925     trackValidatorsStandalone,
0926     tracksPreValidationStandalone,
0927     tracksValidationSelectorsStandalone
0928 )
0929
0930 ### TrackingOnly mode (i.e. MTV with DIGI input + tracking-only reconstruction)
0931
0932 # selectors
0933 tracksValidationSelectorsTrackingOnly = tracksValidationSelectors.copyAndExclude([ak4JetTracksAssociatorExplicitAll,cutsRecoTracksAK4PFJets]) # selectors using track information only (i.e. no PF)
0934 _taskForEachEra(_addSeedToTrackProducers, args=["_seedProducers"], names="_seedSelectors", task="_tracksValidationSeedSelectorsTrackingOnly", includeFastSim=True, modDict=globals())
0935 _taskForEachEra(_addSeedToTrackProducers, args=["_seedProducersPreSplitting"], names="_seedSelectorsPreSplitting", task="_tracksValidationSeedSelectorsPreSplittingTrackingOnly", modDict=globals())
0936 tracksValidationSeedSelectorsTrackingOnly.add(tracksValidationSeedSelectorsPreSplittingTrackingOnly)
0937
0938 # MTV instances
0939 trackValidatorTrackingOnly = trackValidatorStandalone.clone(
0940     label = [ x for x in trackValidatorStandalone.label if x != "cutsRecoTracksAK4PFJets"],
0941     doResolutionPlotsForLabels = trackValidatorStandalone.doResolutionPlotsForLabels + locals()["_selectorsByOriginalAlgo"+_postfix],
0942     cores = "highPtJetsForTrk"
0943  )
0944
0945 trackValidatorSeedingTrackingOnly = _trackValidatorSeedingBuilding.clone(
0946     dirName = "Tracking/TrackSeeding/",
0947     label = _seedSelectors,
0948     doSeedPlots = True,
0949     doResolutionPlotsForLabels = [ "seedTracksjetCoreRegionalStepSeeds" ]
0950 )
0951 seedingDeepCore.toModify(trackValidatorSeedingTrackingOnly, doResolutionPlotsForLabels = ["seedTracksjetCoreRegionalStepSeedsBarrel","seedTracksjetCoreRegionalStepSeedsEndcap"] )
0952
0953 trackValidatorSeedingPreSplittingTrackingOnly = trackValidatorSeedingTrackingOnly.clone(
0954     associators = ["quickTrackAssociatorByHitsPreSplitting"],
0955     label = _seedSelectorsPreSplitting,
0956     doSummaryPlots = False,
0957
0958 )
0959
0960 trackValidatorJetCoreSeedingTrackingOnly = trackValidatorSeedingTrackingOnly.clone(
0961     dirName = "Tracking/JetCore/TrackSeeding/",
0962     associators = ["trackAssociatorByChi2"],
0963     UseAssociators = True,
0964     doSeedPlots = True,
0965 )
0966
0967 for _eraName, _postfix, _era in _relevantEras:
0968     if 'jetCoreRegionalStep' in _cfg.iterationAlgos(_postfix) :
0969       _setForEra(trackValidatorJetCoreSeedingTrackingOnly, _eraName, _era,
0970                  label = [ "seedTracksjetCoreRegionalStepSeedsBarrel","seedTracksjetCoreRegionalStepSeedsEndcap" ],
0971                  doResolutionPlotsForLabels = [ "seedTracksjetCoreRegionalStepSeedsBarrel","seedTracksjetCoreRegionalStepSeedsEndcap" ]
0972       )
0973
0974 for _eraName, _postfix, _era in _relevantErasAndFastSim:
0975     _setForEra(trackValidatorSeedingTrackingOnly, _eraName, _era, label = locals()["_seedSelectors"+_postfix])
0976 for _eraName, _postfix, _era in _relevantEras:
0977     _setForEra(trackValidatorSeedingPreSplittingTrackingOnly, _eraName, _era, label = locals()["_seedSelectorsPreSplitting"+_postfix])
0978
0979
0980 trackValidatorConversionTrackingOnly = trackValidatorConversion.clone(label = [x for x in trackValidatorConversion.label if x not in ["ckfInOutTracksFromConversions", "ckfOutInTracksFromConversions"]])
0981
0982 trackValidatorBHadronTrackingOnly = trackValidatorBHadron.clone(label = [x for x in trackValidatorTrackingOnly.label if "Pt09" not in x])
0983
0984 trackValidatorTPPtLess09TrackingOnly = trackValidatorTPPtLess09Standalone.clone(cores = "highPtJetsForTrk")
0985 trackValidatorFromPVTrackingOnly = trackValidatorFromPVStandalone.clone(cores = "highPtJetsForTrk")
0986 trackValidatorFromPVAllTPTrackingOnly = trackValidatorFromPVAllTPStandalone.clone(cores = "highPtJetsForTrk")
0987 trackValidatorAllTPEfficTrackingOnly = trackValidatorAllTPEfficStandalone.clone(cores = "highPtJetsForTrk")
0988 # sequences
0989 tracksPreValidationTrackingOnly = tracksPreValidationStandalone.copy()
0990 tracksPreValidationTrackingOnly.replace(tracksValidationSelectors, tracksValidationSelectorsTrackingOnly)
0991 tracksPreValidationTrackingOnly.replace(highPtJets,highPtJetsForTrk)
0992
0993 trackValidatorsTrackingOnly = _trackValidatorsBase.copy()
0994 trackValidatorsTrackingOnly.replace(trackValidatorStandalone, trackValidatorTrackingOnly)
0995 trackValidatorsTrackingOnly.replace(trackValidatorTPPtLess09Standalone,trackValidatorTPPtLess09TrackingOnly)
0996 trackValidatorsTrackingOnly.replace(trackValidatorFromPVStandalone,trackValidatorFromPVTrackingOnly)
0997 trackValidatorsTrackingOnly.replace(trackValidatorFromPVAllTPStandalone,trackValidatorFromPVAllTPTrackingOnly)
0998 trackValidatorsTrackingOnly.replace(trackValidatorAllTPEfficStandalone,trackValidatorAllTPEfficTrackingOnly)
0999 trackValidatorsTrackingOnly += trackValidatorSeedingTrackingOnly
1000 trackValidatorsTrackingOnly += trackValidatorSeedingPreSplittingTrackingOnly
1001 trackValidatorsTrackingOnly += trackValidatorBuilding
1002 trackValidatorsTrackingOnly += trackValidatorBuildingPreSplitting
1003 trackValidatorsTrackingOnly.replace(trackValidatorConversionStandalone, trackValidatorConversionTrackingOnly)
1004 trackValidatorsTrackingOnly.remove(trackValidatorGsfTracksStandalone)
1005 trackValidatorsTrackingOnly.replace(trackValidatorBHadronStandalone, trackValidatorBHadronTrackingOnly)
1006
1007 (seedingDeepCore & ~fastSim).toReplaceWith(trackValidatorsTrackingOnly, cms.Sequence(
1008             trackValidatorsTrackingOnly.copy()+
1009             trackValidatorJetCore+
1010             trackValidatorJetCoreSeedingTrackingOnly
1011             )
1012         )
1013 phase2_tracker.toReplaceWith(trackValidatorsTrackingOnly, trackValidatorsTrackingOnly.copyAndExclude([ #must be done for each era which does not have jetcore in the iteration
1014     trackValidatorJetCore,
1015     trackValidatorJetCoreSeedingTrackingOnly
1016 ]))
1017
1018 displacedTrackValidation.toReplaceWith(trackValidatorsTrackingOnly, cms.Sequence(trackValidatorsTrackingOnly.copy()+trackValidatorDisplaced))
1019
1020 fastSim.toReplaceWith(trackValidatorsTrackingOnly, trackValidatorsTrackingOnly.copyAndExclude([
1021     trackValidatorBuildingPreSplitting,
1022     trackValidatorSeedingPreSplittingTrackingOnly,
1023     trackValidatorConversionTrackingOnly,
1024     trackValidatorBHadronTrackingOnly
1025 ]))
1026
1027 hltClusterSplitting.toReplaceWith(trackValidatorsTrackingOnly, trackValidatorsTrackingOnly.copyAndExclude([
1028     trackValidatorBuildingPreSplitting,
1029     trackValidatorSeedingPreSplittingTrackingOnly,
1030 ]))
1031
1032 tracksValidationTrackingOnly = cms.Sequence(
1033     trackValidatorsTrackingOnly,
1034     tracksPreValidationTrackingOnly,
1035     tracksValidationSelectorsStandalone,
1036     tracksValidationSeedSelectorsTrackingOnly
1037 )
1038
1039
1040 tracksValidationHIonTrackingOnly = cms.Sequence(
1041     tracksValidation.copy(),
1042     tracksValidationHIonTask
1043 )
1044
1045 pp_on_AA.toReplaceWith(tracksValidationTrackingOnly,tracksValidationHIonTrackingOnly)
1046
1047
1048 ####################################################################################################
1049 ### Pixel tracking only mode (placeholder for now)
1050 trackingParticlePixelTrackAsssociation = trackingParticleRecoTrackAsssociation.clone(
1051     label_tr = "pixelTracks",
1052     associator = "quickTrackAssociatorByHitsPreSplitting",
1053 )
1054 PixelVertexAssociatorByPositionAndTracks = VertexAssociatorByPositionAndTracks.clone(
1055     trackAssociation = "trackingParticlePixelTrackAsssociation"
1056 )
1057
1058 _pixelTracksCustom = dict(
1059     src = "pixelTracks",
1060     vertexTag = "pixelVertices",
1061 )
1062
1063 trackRefSelector = cms.EDFilter('TrackRefSelector',
1064                                 src = cms.InputTag('pixelTracks'),
1065                                 cut = cms.string("")
1066 )
1067
1068 trackSelector = cms.EDFilter('TrackSelector',
1069                              src = cms.InputTag('pixelTracks'),
1070                              cut = cms.string("")
1071 )
1072
1073 cutstring = "hitPattern.trackerLayersWithMeasurement == 3"
1074 pixelTracks3hits = trackRefSelector.clone( cut = cutstring )
1075
1076 cutstring = "hitPattern.trackerLayersWithMeasurement >= 4"
1077 pixelTracks4hits = trackRefSelector.clone( cut = cutstring )
1078
1079 cutstring = "pt > 0.9"
1080 pixelTracksPt09 = trackRefSelector.clone( cut = cutstring )
1081 #pixelTracksPt09 = generalTracksPt09.clone(quality = ["undefQuality"], **_pixelTracksCustom)
1082
1083 pixelTracksFromPV = generalTracksFromPV.clone(quality = "highPurity", ptMin = 0.0, ptMax = 99999., ptErrorCut = 99999., **_pixelTracksCustom)
1084 #pixelTracksFromPVPt09 = generalTracksPt09.clone(quality = ["loose","tight","highPurity"], vertexTag = "pixelVertices", src = "pixelTracksFromPV")
1085 pixelTracksFromPVPt09 = pixelTracksFromPV.clone(ptMin = 0.9)
1086
1087 cutstring = "hitPattern.trackerLayersWithMeasurement >= 4"
1088 #pixelTracksFromPV4hits = trackRefSelector.clone( cut = cutstring, src = "pixelTracksFromPV" )
1089 pixelTracksFromPV4hits = pixelTracksFromPV.clone( numberOfValidPixelHits = 4 )
1090
1091
1092 trackValidatorPixelTrackingOnly = trackValidator.clone(
1093     dirName = "Tracking/PixelTrack/",
1094     label = [
1095         "pixelTracks", "pixelTracksPt09", "pixelTracks3hits", "pixelTracks4hits",
1096         "pixelTracksL", "pixelTracksPt09L", "pixelTracks3hitsL", "pixelTracks4hitsL",
1097         "pixelTracksT", "pixelTracksPt09T", "pixelTracks3hitsT", "pixelTracks4hitsT",
1098         "pixelTracksHP", "pixelTracksPt09HP", "pixelTracks3hitsHP", "pixelTracks4hitsHP",
1099     ],
1100     doResolutionPlotsForLabels = [],
1101     trackCollectionForDrCalculation = "pixelTracks",
1102     associators = ["trackingParticlePixelTrackAsssociation"],
1103     label_vertex = "pixelVertices",
1104     vertexAssociator = "PixelVertexAssociatorByPositionAndTracks",
1105     dodEdxPlots = False,
1106     cores = ""
1107 )
1108
1109 trackValidatorFromPVPixelTrackingOnly = trackValidatorPixelTrackingOnly.clone(
1110     dirName = "Tracking/PixelTrackFromPV/",
1111     label = [
1112         "pixelTracksFromPV", "pixelTracksFromPVPt09", "pixelTracksFromPV4hits",
1113         "pixelTracksFromPVL", "pixelTracksFromPVT", "pixelTracksFromPVHP",
1114         "pixelTracksFromPVPt09L", "pixelTracksFromPVPt09T", "pixelTracksFromPVPt09HP",
1115         "pixelTracksFromPV4hitsL", "pixelTracksFromPV4hitsT", "pixelTracksFromPV4hitsHP",
1116     ],
1117     label_tp_effic = "trackingParticlesSignal",
1118     label_tp_fake = "trackingParticlesSignal",
1119     label_tp_effic_refvector = True,
1120     label_tp_fake_refvector = True,
1121     trackCollectionForDrCalculation = "pixelTracksFromPV",
1122     doPlotsOnlyForTruePV = True,
1123     doPVAssociationPlots = False,
1124     doResolutionPlotsForLabels = ["disabled"],
1125 )
1126 trackValidatorFromPVAllTPPixelTrackingOnly = trackValidatorFromPVPixelTrackingOnly.clone(
1127     dirName = "Tracking/PixelTrackFromPVAllTP/",
1128     label_tp_effic = trackValidatorPixelTrackingOnly.label_tp_effic.value(),
1129     label_tp_fake = trackValidatorPixelTrackingOnly.label_tp_fake.value(),
1130     label_tp_effic_refvector = False,
1131     label_tp_fake_refvector = False,
1132     doSimPlots = False,
1133     doSimTrackPlots = False,
1134 )
1135 trackValidatorBHadronPixelTrackingOnly = trackValidatorPixelTrackingOnly.clone(
1136     dirName = "Tracking/PixelTrackBHadron/",
1137     label = [
1138         "pixelTracks", "pixelTracksPt09",
1139         "pixelTracksL", "pixelTracks3hitsL", "pixelTracks4hitsL",
1140         "pixelTracksT", "pixelTracks3hitsT", "pixelTracks4hitsT",
1141         "pixelTracksHP", "pixelTracks3hitsHP", "pixelTracks4hitsHP",
1142          ],
1143     label_tp_effic = "trackingParticlesBHadron",
1144     label_tp_effic_refvector = True,
1145     doSimPlots = True,
1146     doRecoTrackPlots = False, # Fake rate is defined wrt. all TPs, and that is already included in trackValidator
1147     dodEdxPlots = False,
1148 )
1149
1150 tracksValidationTruthPixelTrackingOnly = tracksValidationTruth.copy()
1151 tracksValidationTruthPixelTrackingOnly.replace(trackingParticleRecoTrackAsssociation, trackingParticlePixelTrackAsssociation)
1152 tracksValidationTruthPixelTrackingOnly.replace(VertexAssociatorByPositionAndTracks, PixelVertexAssociatorByPositionAndTracks)
1153 tracksValidationTruthPixelTrackingOnly.add(trackingParticlesBHadron)
1154 tracksValidationTruthPixelTrackingOnly.add( pixelTracks3hits )
1155 tracksValidationTruthPixelTrackingOnly.add( pixelTracks4hits )
1156 tracksValidationTruthPixelTrackingOnly.add( pixelTracksPt09 )
1157 tracksValidationTruthPixelTrackingOnly.add( pixelTracksFromPV )
1158 tracksValidationTruthPixelTrackingOnly.add( pixelTracksFromPVPt09 )
1159 tracksValidationTruthPixelTrackingOnly.add( pixelTracksFromPV4hits )
1160
1161 tracksPreValidationPixelTrackingOnly = cms.Task(
1162     tracksValidationTruthPixelTrackingOnly,
1163     trackingParticlesSignal)
1164
1165 ##https://cmssdt.cern.ch/lxr/source/DataFormats/TrackReco/interface/TrackBase.h#0150
1166 quality = {
1167     "L"  : (1,"loose",     ["loose","tight","highPurity"]),
1168     "T"  : (2,"tight",     ["tight","highPurity"]),
1169     "HP" : (4,"highPurity",["highPurity"]),
1170 }
1171
1172 for key,value in quality.items():
1173     qualityName = value[1]
1174     qualityBit  = value[0]
1175     qualityList = value[2]
1176
1177     label = "pixelTracks"+str(key)
1178     cutstring = "qualityMask <= 7 & qualityMask >= " + str(qualityBit)
1179     locals()[label] = trackRefSelector.clone( cut = cutstring )
1180     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1181
1182     label = "pixelTracksFromPV"+key
1183 #    locals()[label] = generalTracksPt09.clone( ptMin = 0.0, vertexTag = "pixelVertices", src = "pixelTracksFromPV", quality = qualityList )
1184     locals()[label] = pixelTracksFromPV.clone( quality = qualityName )
1185     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1186 #-----------
1187     cutstring = "pt > 0.9 & qualityMask <= 7 & qualityMask >= " + str(qualityBit)
1188     label = "pixelTracksPt09"+key
1189     locals()[label] = trackRefSelector.clone( cut = cutstring )
1190     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1191
1192     label = "pixelTracksFromPVPt09"+key
1193  #   locals()[label] = generalTracksPt09.clone( ptMin = 0.9, vertexTag = "pixelVertices", src = "pixelTracksFromPV", quality = qualityList )
1194     locals()[label] = pixelTracksFromPVPt09.clone( quality = qualityName )
1195     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1196 #-----------
1197     label = "pixelTracks4hits"+key
1198     cutstring = "hitPattern.trackerLayersWithMeasurement >= 4 & qualityMask <= 7 & qualityMask >= " + str(qualityBit)
1199     locals()[label] = trackRefSelector.clone( cut = cutstring )
1200     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1201
1202     label = "pixelTracksFromPV4hits"+key
1203 #    locals()[label] = generalTracksPt09.clone( ptMin = 0.0, minHit = 4, vertexTag = "pixelVertices", src = "pixelTracksFromPV", quality = qualityList )
1204     locals()[label] = pixelTracksFromPV4hits.clone( quality = qualityName )
1205     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1206 #--------
1207     label = "pixelTracks3hits"+key
1208     cutstring = "hitPattern.trackerLayersWithMeasurement == 3 & qualityMask <= 7 & qualityMask >= " + str(qualityBit)
1209     locals()[label] = trackRefSelector.clone( cut = cutstring )
1210     tracksPreValidationPixelTrackingOnly.add(locals()[label])
1211
1212 tracksValidationPixelTrackingOnly = cms.Sequence(
1213     trackValidatorPixelTrackingOnly +
1214     trackValidatorFromPVPixelTrackingOnly +
1215     trackValidatorFromPVAllTPPixelTrackingOnly +
1216     trackValidatorBHadronPixelTrackingOnly,
1217     tracksPreValidationPixelTrackingOnly
1218 )
1219 ####################################################################################################
1220
1221 ### Lite mode (only generalTracks and HP)
1222 trackValidatorLite = trackValidator.clone(
1223     label = ["generalTracks", "cutsRecoTracksHp"]
1224 )
1225 tracksValidationLite = cms.Sequence(
1226     cutsRecoTracksHp +
1227     trackValidatorLite,
1228     tracksValidationTruth
1229 )
1230
1231 ## customization for timing
1232 from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
1233 phase2_timing_layer.toModify( trackValidatorStandalone,
1234                               label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
1235 phase2_timing_layer.toModify( trackValidatorFromPVStandalone,
1236                               label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
1237 phase2_timing_layer.toModify( trackValidatorFromPVAllTPStandalone,
1238                               label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
1239 phase2_timing_layer.toModify( trackValidatorConversionStandalone,
1240                               label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
1241 phase2_timing_layer.toModify( trackValidatorGsfTracks,
1242                               label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )