File indexing completed on 2025-02-05 23:51:55
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
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
0026
0027 for _eraName, _postfix, _era in _cfg.allEras():
0028 _seedProd = ["initialStepSeedsPreSplitting"]
0029 _trackProd = ["initialStepTracksPreSplitting"]
0030 if _eraName in ["trackingLowPU", "trackingPhase2PU140"]:
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
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
0173 defaultTaskName = task+_eras[0][0]
0174 defaultTask = modDict[defaultTaskName]
0175 modDict[defaultTaskName[1:]] = defaultTask
0176
0177
0178 if modifyTask is not None:
0179 for eraName, postfix, _era in _eras:
0180 modifyTask(modDict[task+postfix])
0181
0182
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
0193 def _getSeedingLayers(seedProducers, config):
0194 def _findSeedingLayers(name):
0195 prod = getattr(config, name)
0196 if hasattr(prod, "triplets"):
0197 if hasattr(prod, "layerList"):
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"):
0213 seedingLayersName = seedProd.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel()
0214 elif hasattr(seedProd, "seedingHitSets"):
0215 seedingLayersName = _findSeedingLayers(seedProd.seedingHitSets.getModuleLabel())
0216 elif hasattr(seedProd, "layerList"):
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():
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
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
0254 _taskForEachEra(_addSelectorsByAlgo, args=["_algos"], names="_selectorsByAlgo", task="_tracksValidationSelectorsByAlgo", modDict=globals())
0255
0256
0257 _taskForEachEra(_addSelectorsByHp, args=["_algos"], names="_selectorsByAlgoHp", task="_tracksValidationSelectorsByAlgoHp", modDict=globals())
0258
0259
0260 for _eraName, _postfix, _era in _relevantEras:
0261 locals()["_selectorsByAlgoAndHp"+_postfix] = locals()["_selectorsByAlgo"+_postfix] + locals()["_selectorsByAlgoHp"+_postfix]
0262
0263 locals()["_selectorsByAlgoAndHpNoGenTk"+_postfix] = [n for n in locals()["_selectorsByAlgoAndHp"+_postfix] if n not in ["generalTracks", "cutsRecoTracksHp"]]
0264
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
0277 import PhysicsTools.RecoAlgos.btvTracks_cfi as btvTracks_cfi
0278 cutsRecoTracksBtvLike = btvTracks_cfi.btvTrackRefs.clone()
0279
0280
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
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
0305 trackingParticlesInTime = trackingParticlesSignal.clone(
0306 signalOnly = False,
0307 intimeOnly = True,
0308 )
0309
0310
0311 generalTracksPt09 = cutsRecoTracks_cfi.cutsRecoTracks.clone(ptMin=0.9)
0312
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
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,
0331 rhoVtx = 1e10,
0332 )
0333
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
0341 generalTracksFromPVPt09 = generalTracksPt09.clone(src="generalTracksFromPV")
0342
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
0350 trackingParticlesConversion = _trackingParticleConversionRefSelector.clone()
0351
0352
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
0364 highPtJets = cms.EDFilter("CandPtrSelector", src = cms.InputTag("ak4CaloJets"), cut = cms.string("pt()>1000"))
0365 highPtJetsForTrk = highPtJets.clone(src = "ak4CaloJetsForTrk")
0366
0367
0368 trackingParticlesBHadron = _trackingParticleBHadronRefSelector.clone()
0369
0370
0371 trackValidator = Validation.RecoTrack.MultiTrackValidator_cfi.multiTrackValidator.clone(
0372 useLogPt = cms.untracked.bool(True),
0373 dodEdxPlots = True,
0374 doPVAssociationPlots = True
0375
0376
0377
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
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,
0407 histoProducerAlgoBlock = dict(
0408 TpSelectorForEfficiencyVsEta = dict(ptMin=0.05),
0409 TpSelectorForEfficiencyVsPhi = dict(ptMin=0.05),
0410 TpSelectorForEfficiencyVsVTXR = dict(ptMin=0.05),
0411 TpSelectorForEfficiencyVsVTXZ = dict(ptMin=0.05),
0412 ),
0413 doSimPlots = False,
0414 doRecoTrackPlots = False,
0415 doResolutionPlotsForLabels = ["disabled"],
0416 )
0417
0418
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
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
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
0452 minRapidityTP = -2.7,
0453 maxRapidityTP = 2.7,
0454 invertRapidityCutTP = True,
0455
0456 histoProducerAlgoBlock = dict(
0457 TpSelectorForEfficiencyVsPt = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
0458 TpSelectorForEfficiencyVsEta = dict(ptMin=0.005,minRapidity=-2.7,maxRapidity=2.7,invertRapidityCut=True),
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
0464
0465
0466
0467 ),
0468 doSimPlots = True,
0469 doRecoTrackPlots = True,
0470 doResolutionPlotsForLabels = ["disabled"]
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
0480
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 = []
0496 )
0497
0498
0499
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"],
0509 )
0510
0511
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,
0517 doPVAssociationPlots = False,
0518 doResolutionPlotsForLabels = ["disabled"],
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
0530 tpClusterProducerPreSplitting = tpClusterProducer.clone(pixelClusterSrc = "siPixelClustersPreSplitting")
0531 quickTrackAssociatorByHitsPreSplitting = quickTrackAssociatorByHits.clone(cluster2TPSrc = "tpClusterProducerPreSplitting")
0532 _trackValidatorSeedingBuilding = trackValidator.clone(
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
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
0584
0585 if l.startswith("TEC"):
0586 ret.append("M"+l)
0587 return ret
0588
0589
0590
0591 trackValidatorConversion.histoProducerAlgoBlock.seedingLayerSets = _uniqueFirstLayers(_convLayerPairs.layerList.value())
0592
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
0599 trackValidatorGsfTracks = trackValidatorConversion.clone(
0600 dirName = "Tracking/TrackGsf/",
0601 label = ["electronGsfTracks"],
0602 label_tp_effic = "trackingParticlesElectron",
0603 )
0604
0605 for _eraName, _postfix, _era in _relevantEras:
0606 _setForEra(trackValidatorGsfTracks.histoProducerAlgoBlock, _eraName, _era, seedingLayerSets=trackValidator.histoProducerAlgoBlock.seedingLayerSets.value()+locals()["_seedingLayerSetsForElectrons"+_postfix])
0607
0608
0609 trackValidatorJetCore = trackValidator.clone(
0610 dirName = "Tracking/JetCore/",
0611 useLogPt = cms.untracked.bool(True),
0612 dodEdxPlots = False,
0613 associators= ["trackAssociatorByChi2"],
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
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,
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
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),
0656 TpSelectorForEfficiencyVsEta = dict(ptMin=0.005, signalOnly=True, tip=1e5, lip=1e5),
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
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
0686 _taskForEachEra(_addSelectorsByAlgo, modDict=globals(),
0687 args=["_algos"],
0688 names="_selectorsByAlgo", task="_tracksEtaGreater2p7ValidationSelectorsByAlgo"
0689 )
0690
0691
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
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
0725
0726
0727
0728
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
0824
0825
0826 _taskForEachEra(_addSelectorsByOriginalAlgoMask, modDict = globals(),
0827 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["ByAlgoMask", "algorithmMaskContains"],
0828 names = "_selectorsByAlgoMask", task = "_tracksValidationSelectorsByAlgoMaskStandalone")
0829
0830
0831
0832 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0833 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["Pt09", "generalTracksPt09"],
0834 names = "_selectorsPt09Standalone", task = "_tracksValidationSelectorsPt09Standalone")
0835
0836
0837
0838 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0839 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["FromPV", "generalTracksFromPV"],
0840 names = "_selectorsFromPVStandalone", task = "_tracksValidationSelectorsFromPVStandalone")
0841
0842
0843
0844 _taskForEachEra(_addSelectorsBySrc, modDict = globals(),
0845 args = ["_selectorsByAlgoAndHpNoGenTk"], plainArgs = ["FromPVPt09", "generalTracksFromPVPt09"],
0846 names = "_selectorsFromPVPt09Standalone", task = "_tracksValidationSelectorsFromPVPt09Standalone")
0847
0848
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
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
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
0904
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
0931
0932
0933 tracksValidationSelectorsTrackingOnly = tracksValidationSelectors.copyAndExclude([ak4JetTracksAssociatorExplicitAll,cutsRecoTracksAK4PFJets])
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
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
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([
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
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
1082
1083 pixelTracksFromPV = generalTracksFromPV.clone(quality = "highPurity", ptMin = 0.0, ptMax = 99999., ptErrorCut = 99999., **_pixelTracksCustom)
1084
1085 pixelTracksFromPVPt09 = pixelTracksFromPV.clone(ptMin = 0.9)
1086
1087 cutstring = "hitPattern.trackerLayersWithMeasurement >= 4"
1088
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,
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
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
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
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
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
1222 trackValidatorLite = trackValidator.clone(
1223 label = ["generalTracks", "cutsRecoTracksHp"]
1224 )
1225 tracksValidationLite = cms.Sequence(
1226 cutsRecoTracksHp +
1227 trackValidatorLite,
1228 tracksValidationTruth
1229 )
1230
1231
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') )