diff --git a/Configuration/ProcessModifiers/python/jetCoreInPhase2_cff.py b/Configuration/ProcessModifiers/python/jetCoreInPhase2_cff.py new file mode 100644 index 0000000000000..7544943c5bb36 --- /dev/null +++ b/Configuration/ProcessModifiers/python/jetCoreInPhase2_cff.py @@ -0,0 +1,3 @@ +import FWCore.ParameterSet.Config as cms + +jetCoreInPhase2 = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/splitClustersInPhase2Pixel_cff.py b/Configuration/ProcessModifiers/python/splitClustersInPhase2Pixel_cff.py new file mode 100644 index 0000000000000..da825d3c7584d --- /dev/null +++ b/Configuration/ProcessModifiers/python/splitClustersInPhase2Pixel_cff.py @@ -0,0 +1,3 @@ +import FWCore.ParameterSet.Config as cms + +splitClustersInPhase2Pixel = cms.Modifier() diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 426c97f6e57c8..672c4eaa6f377 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -2444,6 +2444,52 @@ def condition(self, fragment, stepList, key, hasHarvest): upgradeWFs['Aging3000'].offset = 0.103 upgradeWFs['Aging3000'].lumi = '3000' +class UpgradeWorkflow_PixelClusterSplitting(UpgradeWorkflow): + def setup_(self, step, stepName, stepDict, k, properties): + stepDict[stepName][k] = merge([{'--procModifiers': 'splitClustersInPhase2Pixel'}, stepDict[step][k]]) + def condition(self, fragment, stepList, key, hasHarvest): + return '2026' in key + +upgradeWFs['PixelClusterSplitting'] = UpgradeWorkflow_PixelClusterSplitting( + steps = [ + 'RecoLocal', + 'Reco', + 'RecoFakeHLT', + 'RecoGlobal', + ], + PU = [ + 'RecoLocal', + 'Reco', + 'RecoFakeHLT', + 'RecoGlobal', + ], + suffix = '_ClusterSplittingInPixel', + offset = 0.19001, +) + +class UpgradeWorkflow_JetCore(UpgradeWorkflow): + def setup_(self, step, stepName, stepDict, k, properties): + stepDict[stepName][k] = merge([{'--procModifiers': 'splitClustersInPhase2Pixel,jetCoreInPhase2'}, stepDict[step][k]]) + def condition(self, fragment, stepList, key, hasHarvest): + return '2026' in key + +upgradeWFs['JetCore'] = UpgradeWorkflow_JetCore( + steps = [ + 'RecoLocal', + 'Reco', + 'RecoFakeHLT', + 'RecoGlobal', + ], + PU = [ + 'RecoLocal', + 'Reco', + 'RecoFakeHLT', + 'RecoGlobal', + ], + suffix = '_JetCore', + offset = 0.19002, +) + # # Simulates Bias Rail in Phase-2 OT PS modules and X% random bad Strips # in PS-s and SS sensors diff --git a/RecoLocalTracker/SubCollectionProducers/python/jetCoreClusterSplitter_cfi.py b/RecoLocalTracker/SubCollectionProducers/python/jetCoreClusterSplitter_cfi.py index 40cd6423e287b..43cae67f5f2e0 100644 --- a/RecoLocalTracker/SubCollectionProducers/python/jetCoreClusterSplitter_cfi.py +++ b/RecoLocalTracker/SubCollectionProducers/python/jetCoreClusterSplitter_cfi.py @@ -14,6 +14,11 @@ fractionalWidth = cms.double(0.4), chargePerUnit = cms.double(2000), centralMIPCharge = cms.double(26000), + expSizeXAtLorentzAngleIncidence = cms.double(1.5), + expSizeXDeltaPerTanAlpha = cms.double(0.0), + expSizeYAtNormalIncidence = cms.double(1.3), + tanLorentzAngle = cms.double(0.0), # doesn't really matter if expSizeXDeltaPerTanAlpha == 0 + tanLorentzAngleBarrelLayer1 = cms.double(0.0), ) diff --git a/RecoLocalTracker/SubCollectionProducers/src/JetCoreClusterSplitter.cc b/RecoLocalTracker/SubCollectionProducers/src/JetCoreClusterSplitter.cc index 258f57e3cdee3..6730c8946c49e 100644 --- a/RecoLocalTracker/SubCollectionProducers/src/JetCoreClusterSplitter.cc +++ b/RecoLocalTracker/SubCollectionProducers/src/JetCoreClusterSplitter.cc @@ -1,7 +1,9 @@ #include "FWCore/Framework/interface/stream/EDProducer.h" #include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/Utilities/interface/InputTag.h" #include "DataFormats/Common/interface/Handle.h" #include "FWCore/Framework/interface/ESHandle.h" @@ -12,9 +14,12 @@ #include "RecoLocalTracker/Records/interface/TkPixelCPERecord.h" #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h" +#include "Geometry/CommonTopologies/interface/PixelTopology.h" #include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h" #include "DataFormats/GeometryVector/interface/VectorUtil.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" + #include "DataFormats/VertexReco/interface/Vertex.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" #include "DataFormats/JetReco/interface/Jet.h" @@ -25,6 +30,7 @@ class JetCoreClusterSplitter : public edm::stream::EDProducer<> { public: + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); JetCoreClusterSplitter(const edm::ParameterSet& iConfig); ~JetCoreClusterSplitter() override; void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; @@ -49,11 +55,17 @@ class JetCoreClusterSplitter : public edm::stream::EDProducer<> { edm::ESGetToken const tTrackingGeom_; edm::ESGetToken const tCPE_; + edm::ESGetToken const tTrackerTopo_; bool verbose; double ptMin_; double deltaR_; double chargeFracMin_; + float expSizeXAtLorentzAngleIncidence_; + float expSizeXDeltaPerTanAlpha_; + float expSizeYAtNormalIncidence_; + float tanLorentzAngle_; + float tanLorentzAngleBarrelLayer1_; edm::EDGetTokenT> pixelClusters_; edm::EDGetTokenT vertices_; edm::EDGetTokenT> cores_; @@ -64,13 +76,45 @@ class JetCoreClusterSplitter : public edm::stream::EDProducer<> { double centralMIPCharge_; }; +void JetCoreClusterSplitter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("pixelCPE", "PixelCPEGeneric"); + desc.add("verbose", false); + desc.add("ptMin", 200.0); + desc.add("deltaRmax", 0.05); + desc.add("chargeFractionMin", 2.0); + desc.add("pixelClusters", edm::InputTag("siPixelCluster")); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("cores", edm::InputTag("ak5CaloJets")); + desc.add("forceXError", 100.0); + desc.add("forceYError", 150.0); + desc.add("fractionalWidth", 0.4); + desc.add("chargePerUnit", 2000.0); + desc.add("centralMIPCharge", 26e3); + + desc.add("expSizeXAtLorentzAngleIncidence", 1.5); + desc.add("expSizeXDeltaPerTanAlpha", 0.0); + desc.add("expSizeYAtNormalIncidence", 1.3); + desc.add("tanLorentzAngle", 0.0); + desc.add("tanLorentzAngleBarrelLayer1", 0.0); + + descriptions.addWithDefaultLabel(desc); +} + JetCoreClusterSplitter::JetCoreClusterSplitter(const edm::ParameterSet& iConfig) : tTrackingGeom_(esConsumes()), tCPE_(esConsumes(edm::ESInputTag("", iConfig.getParameter("pixelCPE")))), + tTrackerTopo_(esConsumes()), verbose(iConfig.getParameter("verbose")), ptMin_(iConfig.getParameter("ptMin")), deltaR_(iConfig.getParameter("deltaRmax")), chargeFracMin_(iConfig.getParameter("chargeFractionMin")), + expSizeXAtLorentzAngleIncidence_(iConfig.getParameter("expSizeXAtLorentzAngleIncidence")), + expSizeXDeltaPerTanAlpha_(iConfig.getParameter("expSizeXDeltaPerTanAlpha")), + expSizeYAtNormalIncidence_(iConfig.getParameter("expSizeYAtNormalIncidence")), + tanLorentzAngle_(iConfig.getParameter("tanLorentzAngle")), + tanLorentzAngleBarrelLayer1_(iConfig.getParameter("tanLorentzAngleBarrelLayer1")), pixelClusters_( consumes>(iConfig.getParameter("pixelClusters"))), vertices_(consumes(iConfig.getParameter("vertices"))), @@ -92,6 +136,7 @@ bool SortPixels(const SiPixelCluster::Pixel& i, const SiPixelCluster::Pixel& j) void JetCoreClusterSplitter::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { using namespace edm; const auto& geometry = &iSetup.getData(tTrackingGeom_); + const auto& topology = &iSetup.getData(tTrackerTopo_); Handle> inputPixelClusters; iEvent.getByToken(pixelClusters_, inputPixelClusters); @@ -111,6 +156,13 @@ void JetCoreClusterSplitter::produce(edm::Event& iEvent, const edm::EventSetup& edmNew::DetSetVector::FastFiller filler(*output, detIt->id()); const edmNew::DetSet& detset = *detIt; const GeomDet* det = geometry->idToDet(detset.id()); + float pitchX, pitchY; + std::tie(pitchX, pitchY) = static_cast(det->topology()).pitch(); + float thickness = det->surface().bounds().thickness(); + float tanLorentzAngle = tanLorentzAngle_; + if (DetId(detset.id()).subdetId() == 1 /* px barrel */ && topology->pxbLayer(detset.id()) == 1) { + tanLorentzAngle = tanLorentzAngleBarrelLayer1_; + } for (auto cluster = detset.begin(); cluster != detset.end(); cluster++) { const SiPixelCluster& aCluster = *cluster; bool hasBeenSplit = false; @@ -126,18 +178,18 @@ void JetCoreClusterSplitter::produce(edm::Event& iEvent, const edm::EventSetup& if (Geom::deltaR(jetDir, clusterDir) < deltaR_) { // check if the cluster has to be splitted - bool isEndCap = (std::abs(cPos.z()) > 30.f); // FIXME: check detID instead! - float jetZOverRho = jet.momentum().Z() / jet.momentum().Rho(); - if (isEndCap) - jetZOverRho = jet.momentum().Rho() / jet.momentum().Z(); - float expSizeY = std::sqrt((1.3f * 1.3f) + (1.9f * 1.9f) * jetZOverRho * jetZOverRho); + LocalVector jetDirLocal = det->surface().toLocal(jetDir); + float jetTanAlpha = jetDirLocal.x() / jetDirLocal.z(); + float jetTanBeta = jetDirLocal.y() / jetDirLocal.z(); + float jetZOverRho = std::sqrt(jetTanAlpha * jetTanAlpha + jetTanBeta * jetTanBeta); + float expSizeX = expSizeXAtLorentzAngleIncidence_ + + std::abs(expSizeXDeltaPerTanAlpha_ * (jetTanAlpha - tanLorentzAngle)); + float expSizeY = std::sqrt((expSizeYAtNormalIncidence_ * expSizeYAtNormalIncidence_) + + thickness * thickness / (pitchY * pitchY) * jetTanBeta * jetTanBeta); + if (expSizeX < 1.f) + expSizeX = 1.f; if (expSizeY < 1.f) expSizeY = 1.f; - float expSizeX = 1.5f; - if (isEndCap) { - expSizeX = expSizeY; - expSizeY = 1.5f; - } // in endcap col/rows are switched float expCharge = std::sqrt(1.08f + jetZOverRho * jetZOverRho) * centralMIPCharge_; if (aCluster.charge() > expCharge * chargeFracMin_ && @@ -163,8 +215,10 @@ void JetCoreClusterSplitter::produce(edm::Event& iEvent, const edm::EventSetup& if (shouldBeSplit) { // blowup the error if we failed to split a splittable cluster (does // it ever happen) - c.setSplitClusterErrorX(c.sizeX() * (100.f / 3.f)); // this is not really blowing up .. TODO: tune - c.setSplitClusterErrorY(c.sizeY() * (150.f / 3.f)); + const float fromCentiToMicro = 1e4; + c.setSplitClusterErrorX(c.sizeX() * + (pitchX * fromCentiToMicro / 3.f)); // this is not really blowing up .. TODO: tune + c.setSplitClusterErrorY(c.sizeY() * (pitchY * fromCentiToMicro / 3.f)); } filler.push_back(c); std::push_heap(filler.begin(), filler.end(), [](SiPixelCluster const& cl1, SiPixelCluster const& cl2) { diff --git a/RecoTracker/FinalTrackSelectors/python/earlyGeneralTracks_cfi.py b/RecoTracker/FinalTrackSelectors/python/earlyGeneralTracks_cfi.py index c33f6cbfd71a9..525640861f3ea 100644 --- a/RecoTracker/FinalTrackSelectors/python/earlyGeneralTracks_cfi.py +++ b/RecoTracker/FinalTrackSelectors/python/earlyGeneralTracks_cfi.py @@ -87,21 +87,23 @@ def _extend_displacedGeneral(x): trackingPhase2PU140.toReplaceWith(earlyGeneralTracks, _trackListMerger.clone( TrackProducers =['initialStepTracks', 'highPtTripletStepTracks', + 'jetCoreRegionalStepTracks', 'lowPtQuadStepTracks', 'lowPtTripletStepTracks', 'detachedQuadStepTracks', 'pixelPairStepTracks', ], - hasSelector = [1,1,1,1,1,1], - indivShareFrac = [1.0,0.16,0.095,0.09,0.09,0.09], + hasSelector = [1,1,1,1,1,1,1], + indivShareFrac = [1.0,0.16,1.0,0.095,0.09,0.09,0.09], selectedTrackQuals = ['initialStepSelector:initialStep', 'highPtTripletStepSelector:highPtTripletStep', + 'jetCoreRegionalStepSelector:jetCoreRegionalStep', 'lowPtQuadStepSelector:lowPtQuadStep', 'lowPtTripletStepSelector:lowPtTripletStep', 'detachedQuadStep', 'pixelPairStepSelector:pixelPairStep', ], - setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5), pQual=cms.bool(True) ) + setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3,4,5,6), pQual=cms.bool(True) ) ), copyExtras = True, makeReKeyedSeeds = cms.untracked.bool(False) diff --git a/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py b/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py index ced05c9ca46eb..a28f1a80d4389 100644 --- a/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py @@ -23,6 +23,10 @@ trackingPhase1.toModify(initialStepSeedLayersPreSplitting, layerList = RecoTracker.TkSeedingLayers.PixelLayerQuadruplets_cfi.PixelLayerQuadruplets.layerList.value() ) +from Configuration.ProcessModifiers.splitClustersInPhase2Pixel_cff import splitClustersInPhase2Pixel +splitClustersInPhase2Pixel.toModify(initialStepSeedLayersPreSplitting, + layerList = RecoTracker.TkSeedingLayers.PixelLayerQuadruplets_cfi.PixelLayerQuadruplets.layerList.value() +) # TrackingRegion from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot @@ -32,6 +36,7 @@ nSigmaZ = 4.0 )) trackingPhase1.toModify(initialStepTrackingRegionsPreSplitting, RegionPSet = dict(ptMin = 0.5)) +splitClustersInPhase2Pixel.toModify(initialStepTrackingRegionsPreSplitting, RegionPSet = dict(ptMin = 0.6,originRadius = 0.03)) # seeding from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer @@ -54,6 +59,7 @@ ) from RecoTracker.PixelSeeding.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toModify(initialStepHitDoubletsPreSplitting, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) +splitClustersInPhase2Pixel.toModify(initialStepHitDoubletsPreSplitting, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) initialStepHitQuadrupletsPreSplitting = _caHitQuadrupletEDProducer.clone( doublets = 'initialStepHitDoubletsPreSplitting', extraHitRPhitolerance = initialStepHitTripletsPreSplitting.extraHitRPhitolerance, @@ -68,21 +74,29 @@ CAThetaCut = 0.0012, CAPhiCut = 0.2, ) +splitClustersInPhase2Pixel.toModify(initialStepHitQuadrupletsPreSplitting, + CAThetaCut = 0.0010, + CAPhiCut = 0.175, +) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer initialStepSeedsPreSplitting = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = 'initialStepHitTripletsPreSplitting', ) trackingPhase1.toModify(initialStepSeedsPreSplitting, seedingHitSets = 'initialStepHitQuadrupletsPreSplitting') +splitClustersInPhase2Pixel.toModify(initialStepSeedsPreSplitting, seedingHitSets = 'initialStepHitQuadrupletsPreSplitting') # building import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff -initialStepTrajectoryFilterBasePreSplitting = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( +_initialStepTrajectoryFilterBasePreSplitting = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 4, minPt = 0.2, +) +initialStepTrajectoryFilterBasePreSplitting = _initialStepTrajectoryFilterBasePreSplitting.clone( maxCCCLostHits = 0, minGoodStripCharge = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) ) +splitClustersInPhase2Pixel.toReplaceWith(initialStepTrajectoryFilterBasePreSplitting, _initialStepTrajectoryFilterBasePreSplitting) from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016 _tracker_apv_vfp30_2016.toModify(initialStepTrajectoryFilterBasePreSplitting, maxCCCLostHits = 2) import RecoTracker.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi @@ -93,6 +107,10 @@ cms.PSet( refToPSet_ = cms.string('initialStepTrajectoryFilterBasePreSplitting')), cms.PSet( refToPSet_ = cms.string('initialStepTrajectoryFilterShapePreSplitting'))), ) +splitClustersInPhase2Pixel.toReplaceWith(initialStepTrajectoryFilterPreSplitting, TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( + minimumNumberOfHits = 3, + minPt = 0.2 +)) import RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi initialStepChi2EstPreSplitting = RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi.Chi2ChargeMeasurementEstimator.clone( @@ -104,6 +122,9 @@ _tracker_apv_vfp30_2016.toModify(initialStepChi2EstPreSplitting, clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTiny') ) +splitClustersInPhase2Pixel.toModify(initialStepChi2EstPreSplitting, + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutNone'), +) import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi initialStepTrajectoryBuilderPreSplitting = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilderIterativeDefault.clone( @@ -237,6 +258,9 @@ _InitialStepPreSplittingTask_trackingPhase1 = InitialStepPreSplittingTask.copy() _InitialStepPreSplittingTask_trackingPhase1.replace(initialStepHitTripletsPreSplitting, cms.Task(initialStepHitTripletsPreSplitting,initialStepHitQuadrupletsPreSplitting)) trackingPhase1.toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_trackingPhase1.copyAndExclude([initialStepHitTripletsPreSplitting])) +_InitialStepPreSplittingTask_trackingPhase2PU140 = InitialStepPreSplittingTask.copy() +_InitialStepPreSplittingTask_trackingPhase2PU140.replace(initialStepHitTripletsPreSplitting, cms.Task(initialStepHitTripletsPreSplitting,initialStepHitQuadrupletsPreSplitting)) +splitClustersInPhase2Pixel.toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_trackingPhase2PU140.copyAndExclude([initialStepHitTripletsPreSplitting])) from Configuration.ProcessModifiers.trackingMkFitCommon_cff import trackingMkFitCommon _InitialStepPreSplittingTask_trackingMkFitCommon = InitialStepPreSplittingTask.copy() @@ -265,12 +289,23 @@ from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU trackingLowPU.toReplaceWith(siPixelClusters, _siPixelClusters) from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 -trackingPhase2PU140.toReplaceWith(siPixelClusters, _siPixelClusters) -_InitialStepPreSplittingTask_LowPU_Phase2PU140 = cms.Task( +(trackingPhase2PU140 & ~splitClustersInPhase2Pixel).toReplaceWith(siPixelClusters, _siPixelClusters) +_InitialStepPreSplittingTask_LowPU = cms.Task( siPixelClusters , siPixelRecHits , MeasurementTrackerEvent , siPixelClusterShapeCache ) -trackingLowPU.toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_LowPU_Phase2PU140) -trackingPhase2PU140.toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_LowPU_Phase2PU140) +trackingLowPU.toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_LowPU) +(trackingPhase2PU140 & ~splitClustersInPhase2Pixel).toReplaceWith(InitialStepPreSplittingTask, _InitialStepPreSplittingTask_LowPU) +splitClustersInPhase2Pixel.toModify(siPixelClusters, + centralMIPCharge = cms.double(12000), + expSizeXAtLorentzAngleIncidence = cms.double(1.5), + expSizeXDeltaPerTanAlpha = cms.double(5.2), + expSizeYAtNormalIncidence = cms.double(2.3), + tanLorentzAngle = cms.double(-0.21), + tanLorentzAngleBarrelLayer1 = cms.double(0.0), + chargeFractionMin = cms.double(2.0), + forceXError = cms.double(25.0), + forceYError = cms.double(100.0), +) diff --git a/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py index aa2ed52be9cf5..a3f6e6e7a0308 100644 --- a/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py @@ -71,6 +71,20 @@ 'BPix4+TIB1','BPix4+TIB2' ] trackingPhase1.toModify(jetCoreRegionalStepSeedLayers, layerList = _layerListForPhase1) +from Configuration.ProcessModifiers.jetCoreInPhase2_cff import jetCoreInPhase2 +_layerListForPhase2 = [ + 'BPix1+BPix2', 'BPix1+BPix3', 'BPix1+BPix4', + 'BPix2+BPix3', 'BPix2+BPix4', + 'BPix3+BPix4', + 'BPix1+FPix1_pos', 'BPix1+FPix1_neg', + 'BPix2+FPix1_pos', 'BPix2+FPix1_neg', + 'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg', + 'FPix1_pos+FPix3_pos', 'FPix1_neg+FPix3_neg', + 'FPix2_pos+FPix3_pos', 'FPix2_neg+FPix3_neg', + #'BPix3+TIB1','BPix3+TIB2' + #'BPix4+TIB1','BPix4+TIB2' + ] +jetCoreInPhase2.toModify(jetCoreRegionalStepSeedLayers, layerList = _layerListForPhase2) # TrackingRegion from RecoTauTag.HLTProducers.tauRegionalPixelSeedTrackingRegions_cfi import tauRegionalPixelSeedTrackingRegions as _tauRegionalPixelSeedTrackingRegions @@ -83,6 +97,12 @@ vertexSrc = 'firstStepGoodPrimaryVertices', howToUseMeasurementTracker = 'Never') ) +jetCoreInPhase2.toModify(jetCoreRegionalStepTrackingRegions, + RegionPSet=dict( + deltaPhiRegion = 0.10, + deltaEtaRegion = 0.10, + ), +) jetCoreRegionalStepEndcapTrackingRegions = jetCoreRegionalStepTrackingRegions.clone( RegionPSet=dict( JetSrc = 'jetsForCoreTrackingEndcap') @@ -337,6 +357,58 @@ jetCoreRegionalStepEndcap) +import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi +jetCoreRegionalStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone( + src = 'jetCoreRegionalStepTracks', + trackSelectors= cms.VPSet( + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( + name = 'jetCoreRegionalStepLoose', + chi2n_par = 2.0, + res_par = ( 0.003, 0.002 ), + minNumberLayers = 3, + maxNumberLostLayers = 3, + minNumber3DLayers = 3, + d0_par1 = ( 0.8, 4.0 ), + dz_par1 = ( 0.9, 4.0 ), + d0_par2 = ( 0.6, 4.0 ), + dz_par2 = ( 0.8, 4.0 ) + ), #end of pset + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.tightMTS.clone( + name = 'jetCoreRegionalStepTight', + preFilterName = 'jetCoreRegionalStepLoose', + chi2n_par = 1.4, + res_par = ( 0.003, 0.002 ), + minNumberLayers = 3, + maxNumberLostLayers = 2, + minNumber3DLayers = 3, + d0_par1 = ( 0.7, 4.0 ), + dz_par1 = ( 0.8, 4.0 ), + d0_par2 = ( 0.5, 4.0 ), + dz_par2 = ( 0.7, 4.0 ) + ), + RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.highpurityMTS.clone( + name = 'jetCoreRegionalStep', + preFilterName = 'jetCoreRegionalStepTight', + min_eta = -4.1, + max_eta = 4.1, + chi2n_par = 1.2, + res_par = ( 0.003, 0.001 ), + minNumberLayers = 3, + maxNumberLostLayers = 2, + minNumber3DLayers = 3, + d0_par1 = ( 0.6, 4.0 ), + dz_par1 = ( 0.7, 4.0 ), + d0_par2 = ( 0.45, 4.0 ), + dz_par2 = ( 0.55, 4.0 ) + ), + ), #end of vpset +) #end of clone +_JetCoreRegionalStepTask_trackingPhase2 = JetCoreRegionalStepTask.copy() +_JetCoreRegionalStepTask_trackingPhase2.replace(jetCoreRegionalStep, jetCoreRegionalStepSelector) +jetCoreInPhase2.toReplaceWith(JetCoreRegionalStepTask, _JetCoreRegionalStepTask_trackingPhase2) +jetCoreInPhase2.toModify(jetCoreRegionalStepTracks, TrajectoryInEvent = True) +jetCoreInPhase2.toModify(jetCoreRegionalStepTrajectoryBuilder, maxCand = 5) + from RecoTracker.FinalTrackSelectors.TrackCollectionMerger_cfi import * (seedingDeepCore & ~fastSim).toReplaceWith(jetCoreRegionalStepTracks, TrackCollectionMerger.clone( trackProducers = ["jetCoreRegionalStepBarrelTracks", diff --git a/RecoTracker/IterativeTracking/python/iterativeTkConfig.py b/RecoTracker/IterativeTracking/python/iterativeTkConfig.py index cd3713b758a4c..d409cae8d3340 100644 --- a/RecoTracker/IterativeTracking/python/iterativeTkConfig.py +++ b/RecoTracker/IterativeTracking/python/iterativeTkConfig.py @@ -63,6 +63,10 @@ ] from Configuration.ProcessModifiers.vectorHits_cff import vectorHits vectorHits.toModify(_iterations_trackingPhase2PU140, func=lambda x: x.append('PixelLessStep')) + +from Configuration.ProcessModifiers.jetCoreInPhase2_cff import jetCoreInPhase2 +jetCoreInPhase2.toModify(_iterations_trackingPhase2PU140, func=lambda x: x.append('JetCoreRegionalStep')) + _iterations_muonSeeded = [ "MuonSeededStepInOut", "MuonSeededStepOutIn",