Merge pull request #13753 from makortel/new_quadruplets_v4

Quadruplet seeding by propagating triplet to 4th layer
cms-sw · Mar 29, 2016 · 161217c · 161217c
2 parents 50a3872 + e4daef5
commit 161217c
Show file tree

Hide file tree

Showing 31 changed files with 651 additions and 23 deletions.
diff --git a/Calibration/IsolatedParticles/python/isoTrack_cff.py b/Calibration/IsolatedParticles/python/isoTrack_cff.py
@@ -30,7 +30,10 @@
             beamSpot = cms.InputTag( "hltOnlineBeamSpot" )
             )
         ),
-                                     CleanerPSet = cms.PSet(  ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ),
+                                     CleanerPSet = cms.PSet(
+                                         ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+                                         useQuadrupletAlgo = cms.bool(False)
+                                     ),
                                      OrderedHitsFactoryPSet = cms.PSet( 
         ComponentName = cms.string( "StandardHitTripletGenerator" ),
         SeedingLayers = cms.string( "hltESPPixelLayerTripletsHITHB" ),
@@ -74,7 +77,10 @@
             ptMin = cms.double( 0.35 )
             )
         ),
-                                     CleanerPSet = cms.PSet(  ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ),
+                                     CleanerPSet = cms.PSet(
+                                         ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+                                         useQuadrupletAlgo = cms.bool(False)
+                                     ),
                                      OrderedHitsFactoryPSet = cms.PSet( 
         ComponentName = cms.string( "StandardHitTripletGenerator" ),
         GeneratorPSet = cms.PSet( 

diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
@@ -20,12 +20,22 @@ def esproducers_by_type(process, *types):
 #                     pset.minGoodStripCharge = cms.PSet(refToPSet_ = cms.string('HLTSiStripClusterChargeCutNone'))
 #     return process
 
+# Add quadruplet-specific pixel track duplicate cleaning mode (PR #13753)
+def customiseFor13753(process):
+    for producer in producers_by_type(process, "PixelTrackProducer"):
+        if producer.CleanerPSet.ComponentName.value() == "PixelTrackCleanerBySharedHits" and not hasattr(producer.CleanerPSet, "useQuadrupletAlgo"):
+            producer.CleanerPSet.useQuadrupletAlgo = cms.bool(False)
+    return process
+
 #
 # CMSSW version specific customizations
 def customizeHLTforCMSSW(process, menuType="GRun"):
     import os
     cmsswVersion = os.environ['CMSSW_VERSION']
 
+    if cmsswVersion >= "CMSSW_8_1":
+        process = customiseFor13753(process)
+
     if cmsswVersion >= "CMSSW_8_0":
 #       process = customiseFor12718(process)
         pass

diff --git a/RecoHI/HiTracking/python/HIPixel3ProtoTracks_cfi.py b/RecoHI/HiTracking/python/HIPixel3ProtoTracks_cfi.py
@@ -41,6 +41,7 @@
 
     # Cleaner
     CleanerPSet = cms.PSet(  
-      ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) 
+      ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+      useQuadrupletAlgo = cms.bool(False),
     )
 )
diff --git a/RecoMuon/L3MuonProducer/test/newL3.py b/RecoMuon/L3MuonProducer/test/newL3.py
@@ -73,7 +73,10 @@ def producers_by_type(process, type):
 	        beamSpot = cms.InputTag( "hltOnlineBeamSpot" )
 	      )
 	    ),
-	    CleanerPSet = cms.PSet(  ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ),
+	    CleanerPSet = cms.PSet(
+              ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+              useQuadrupletAlgo = cms.bool(False)
+            ),
 	    OrderedHitsFactoryPSet = cms.PSet(
 	      ComponentName = cms.string( "StandardHitTripletGenerator" ),
 	      GeneratorPSet = cms.PSet(
@@ -457,7 +460,10 @@ def producers_by_type(process, type):
 	        beamSpot = cms.InputTag( "hltOnlineBeamSpot" )
 	      )
 	    ),
-	    CleanerPSet = cms.PSet(  ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ),
+	    CleanerPSet = cms.PSet(
+              ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+              useQuadrupletAlgo = cms.bool(False)
+            ),
 	    OrderedHitsFactoryPSet = cms.PSet(
 	      ComponentName = cms.string( "StandardHitTripletGenerator" ),
 	      GeneratorPSet = cms.PSet(
@@ -512,7 +518,10 @@ def producers_by_type(process, type):
 	      fixImpactParameter = cms.double( 0.0 )
 	    ),
 	    RegionFactoryPSet = IterMasterMuonTrackingRegionBuilder,
-	    CleanerPSet = cms.PSet(  ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ),
+	    CleanerPSet = cms.PSet(
+              ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ),
+              useQuadrupletAlgo = cms.bool(False)
+            ),
 	    OrderedHitsFactoryPSet = cms.PSet(
 	      ComponentName = cms.string( "StandardHitTripletGenerator" ),
 	      GeneratorPSet = cms.PSet(

diff --git a/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h b/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h
@@ -31,7 +31,7 @@ class   PixelTripletLowPtGenerator :
 
   virtual void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & trs,
                             const edm::Event & ev, const edm::EventSetup& es,
-                            SeedingLayerSetsHits::SeedingLayerSet pairLayers,
+                            const SeedingLayerSetsHits::SeedingLayerSet& pairLayers,
                             const std::vector<SeedingLayerSetsHits::SeedingLayer>& thirdLayers) override;
 
  private:

diff --git a/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc b/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc
@@ -77,7 +77,7 @@ void PixelTripletLowPtGenerator::hitTriplets(
     OrderedHitTriplets & result,
     const edm::Event & ev,
     const edm::EventSetup& es,
-    SeedingLayerSetsHits::SeedingLayerSet pairLayers,
+    const SeedingLayerSetsHits::SeedingLayerSet& pairLayers,
     const std::vector<SeedingLayerSetsHits::SeedingLayer>& thirdLayers)
 {
 

diff --git a/RecoPixelVertexing/PixelTrackFitting/interface/PixelTrackCleanerBySharedHits.h b/RecoPixelVertexing/PixelTrackFitting/interface/PixelTrackCleanerBySharedHits.h
@@ -24,7 +24,8 @@ class PixelTrackCleanerBySharedHits : public PixelTrackCleaner {
   typedef pixeltrackfitting::TracksWithRecHits TracksWithRecHits;
   virtual TracksWithRecHits cleanTracks(const TracksWithRecHits & tracksWithRecHits, const TrackerTopology *tTopo);
 
-
+private:
+  const bool useQuadrupletAlgo_;
 };
 
 #endif
diff --git a/RecoPixelVertexing/PixelTrackFitting/python/PixelTrackReconstruction_cfi.py b/RecoPixelVertexing/PixelTrackFitting/python/PixelTrackReconstruction_cfi.py
@@ -31,7 +31,8 @@
         )
     ),
     CleanerPSet = cms.PSet(
-        ComponentName = cms.string('PixelTrackCleanerBySharedHits')
+        ComponentName = cms.string('PixelTrackCleanerBySharedHits'),
+        useQuadrupletAlgo = cms.bool(False),
     )
 )
 

diff --git a/RecoPixelVertexing/PixelTrackFitting/src/PixelTrackCleanerBySharedHits.cc b/RecoPixelVertexing/PixelTrackFitting/src/PixelTrackCleanerBySharedHits.cc
@@ -9,7 +9,8 @@ using namespace std;
 using namespace reco;
 using namespace pixeltrackfitting;
 
-PixelTrackCleanerBySharedHits::PixelTrackCleanerBySharedHits( const edm::ParameterSet& cfg)
+PixelTrackCleanerBySharedHits::PixelTrackCleanerBySharedHits( const edm::ParameterSet& cfg):
+  useQuadrupletAlgo_(cfg.getParameter<bool>("useQuadrupletAlgo"))
 {}
 
 PixelTrackCleanerBySharedHits::~PixelTrackCleanerBySharedHits()
@@ -59,12 +60,24 @@ TracksWithRecHits PixelTrackCleanerBySharedHits::cleanTracks(const TracksWithRec
         }
 	if (commonRecHits > 1) break;
       }
-
-      if (commonRecHits > 1) {
-	if (track1->pt() > track2->pt()) trackOk[iTrack2] = false;
-	else { trackOk[iTrack1] = false; break;}
-      }
 
+      auto cleanTrack = [&](){
+	if (track1->pt() > track2->pt()) { trackOk[iTrack2] = false; return false; }
+	trackOk[iTrack1] = false;
+        return true;
+      };
+
+      if(useQuadrupletAlgo_) {
+        if(commonRecHits >= 1) {
+          if     (recHits1.size() > recHits2.size()) trackOk[iTrack2] = false;
+          else if(recHits1.size() < recHits2.size()) trackOk[iTrack1] = false;
+          else if(recHits1.size() == 3) { if(cleanTrack()) break; } // same number of hits
+          else if(commonRecHits > 1) { if(cleanTrack()) break; }// same number of hits, size != 3 (i.e. == 4)
+        }
+      }
+      else if (commonRecHits > 1) {
+        if(cleanTrack()) break;
+      }
     }
   }
 

diff --git a/RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGenerator.h b/RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGenerator.h
@@ -0,0 +1,38 @@
+#ifndef HitQuadrupletGenerator_H
+#define HitQuadrupletGenerator_H
+
+/** abstract interface for generators of hit triplets pairs
+ *  compatible with a TrackingRegion.
+ */
+
+#include "RecoTracker/TkTrackingRegions/interface/OrderedHitsGenerator.h"
+#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitSeeds.h"
+
+#include "FWCore/Utilities/interface/RunningAverage.h"
+
+class TrackingRegion;
+namespace edm { class Event; class EventSetup; }
+#include <vector>
+
+class HitQuadrupletGenerator : public OrderedHitsGenerator {
+public:
+
+  HitQuadrupletGenerator(unsigned int size=500);
+
+  virtual ~HitQuadrupletGenerator() { }
+
+  virtual const OrderedHitSeeds & run(
+    const TrackingRegion& region, const edm::Event & ev, const edm::EventSetup& es) final;
+
+  virtual void hitQuadruplets( const TrackingRegion& reg, OrderedHitSeeds& prs,
+      const edm::Event & ev,  const edm::EventSetup& es) = 0;
+
+  virtual void clear() final;
+
+private:
+  OrderedHitSeeds theQuadruplets;
+  edm::RunningAverage localRA;
+};
+
+
+#endif
diff --git a/RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayers.h b/RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayers.h
@@ -0,0 +1,37 @@
+#ifndef RecoPixelVertexing_PixelTriplets_HitQuadrupletGeneratorFromTripletAndLayers_h
+#define RecoPixelVertexing_PixelTriplets_HitQuadrupletGeneratorFromTripletAndLayers_h
+
+/** A HitQuadrupletGenerator from HitTripletGenerator and vector of
+    Layers. The HitTripletGenerator provides a set of hit triplets.
+    For each triplet the search for compatible hit(s) is done among
+    provided Layers
+ */
+
+#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitSeeds.h"
+#include <vector>
+#include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h"
+#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h"
+
+class HitTripletGeneratorFromPairAndLayers;
+
+class HitQuadrupletGeneratorFromTripletAndLayers {
+
+public:
+  typedef LayerHitMapCache  LayerCacheType;
+
+  HitQuadrupletGeneratorFromTripletAndLayers();
+  virtual ~HitQuadrupletGeneratorFromTripletAndLayers();
+
+  void init( std::unique_ptr<HitTripletGeneratorFromPairAndLayers>&& tripletGenerator, LayerCacheType* layerCache);
+
+  virtual void hitQuadruplets( const TrackingRegion& region, OrderedHitSeeds& result,
+                               const edm::Event& ev, const edm::EventSetup& es,
+                               const SeedingLayerSetsHits::SeedingLayerSet& tripletLayers,
+                               const std::vector<SeedingLayerSetsHits::SeedingLayer>& fourthLayers) = 0;
+
+protected:
+  std::unique_ptr<HitTripletGeneratorFromPairAndLayers> theTripletGenerator;
+  LayerCacheType *theLayerCache;
+};
+#endif
+
diff --git a/...ixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayersFactory.h b/...ixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayersFactory.h
@@ -0,0 +1,12 @@
+#ifndef PixelTriplets_HitQuadrupletGeneratorFromTripletAndLayersFactory_H
+#define PixelTriplets_HitQuadrupletGeneratorFromTripletAndLayersFactory_H
+
+#include "RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayers.h"
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+
+namespace edm {class ParameterSet; class ConsumesCollector;}
+
+typedef edmplugin::PluginFactory<HitQuadrupletGeneratorFromTripletAndLayers *(const edm::ParameterSet &, edm::ConsumesCollector&)>
+	HitQuadrupletGeneratorFromTripletAndLayersFactory;
+
+#endif
diff --git a/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h b/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h
@@ -31,7 +31,7 @@ class HitTripletGeneratorFromPairAndLayers {
 
   virtual void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & trs,
                             const edm::Event & ev, const edm::EventSetup& es,
-                            SeedingLayerSetsHits::SeedingLayerSet pairLayers,
+                            const SeedingLayerSetsHits::SeedingLayerSet& pairLayers,
                             const std::vector<SeedingLayerSetsHits::SeedingLayer>& thirdLayers) = 0;
 protected:
   std::unique_ptr<HitPairGeneratorFromLayerPair> thePairGenerator;

diff --git a/RecoPixelVertexing/PixelTriplets/plugins/BuildFile.xml b/RecoPixelVertexing/PixelTriplets/plugins/BuildFile.xml
@@ -1,6 +1,7 @@
 <use   name="RecoTracker/TkTrackingRegions"/>
 <use   name="RecoPixelVertexing/PixelTriplets"/>
 <use   name="RecoTracker/TkSeedingLayers"/>
+<use   name="RecoPixelVertexing/PixelTrackFitting"/>
 <library   file="*.cc" name="RecoPixelVertexingPixelTripletsPlugins">
   <flags   EDM_PLUGIN="1"/>
 </library>

diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CombinedHitQuadrupletGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/CombinedHitQuadrupletGenerator.cc
@@ -0,0 +1,50 @@
+#include "CombinedHitQuadrupletGenerator.h"
+
+#include "RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayers.h"
+#include "RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGeneratorFromTripletAndLayersFactory.h"
+#include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h"
+#include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayersFactory.h"
+#include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h"
+#include "LayerQuadruplets.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "DataFormats/Common/interface/Handle.h"
+
+
+using namespace std;
+using namespace ctfseeding;
+
+CombinedHitQuadrupletGenerator::CombinedHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC):
+  theSeedingLayerToken(iC.consumes<SeedingLayerSetsHits>(cfg.getParameter<edm::InputTag>("SeedingLayers")))
+{
+  edm::ParameterSet generatorPSet = cfg.getParameter<edm::ParameterSet>("GeneratorPSet");
+  std::string       generatorName = generatorPSet.getParameter<std::string>("ComponentName");
+  edm::ParameterSet tripletGeneratorPSet = cfg.getParameter<edm::ParameterSet>("TripletGeneratorPSet");
+  std::string tripletGeneratorName = tripletGeneratorPSet.getParameter<std::string>("ComponentName");
+
+  std::unique_ptr<HitTripletGeneratorFromPairAndLayers> tripletGenerator(HitTripletGeneratorFromPairAndLayersFactory::get()->create(tripletGeneratorName, tripletGeneratorPSet, iC));
+  // Some CPU wasted here because same pairs are generated multiple times
+  tripletGenerator->init(std::make_unique<HitPairGeneratorFromLayerPair>(0, 1, &theLayerCache), &theLayerCache);
+
+  theGenerator.reset(HitQuadrupletGeneratorFromTripletAndLayersFactory::get()->create(generatorName, generatorPSet, iC));
+  theGenerator->init(std::move(tripletGenerator), &theLayerCache);
+}
+
+CombinedHitQuadrupletGenerator::~CombinedHitQuadrupletGenerator() {}
+
+void CombinedHitQuadrupletGenerator::hitQuadruplets(
+   const TrackingRegion& region, OrderedHitSeeds & result,
+   const edm::Event& ev, const edm::EventSetup& es)
+{
+  edm::Handle<SeedingLayerSetsHits> hlayers;
+  ev.getByToken(theSeedingLayerToken, hlayers);
+  const SeedingLayerSetsHits& layers = *hlayers;
+  if(layers.numberOfLayersInSet() != 4)
+    throw cms::Exception("Configuration") << "CombinedHitQuadrupletsGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 4, got " << layers.numberOfLayersInSet();
+
+  std::vector<LayerQuadruplets::LayerSetAndLayers> quadlayers = LayerQuadruplets::layers(layers);
+  for(const auto& tripletAndLayers: quadlayers) {
+    theGenerator->hitQuadruplets(region, result, ev, es, tripletAndLayers.first, tripletAndLayers.second);
+  }
+  theLayerCache.clear();
+}
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CombinedHitQuadrupletGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/CombinedHitQuadrupletGenerator.h
@@ -0,0 +1,44 @@
+#ifndef CombinedHitQuadrupletGenerator_H
+#define CombinedHitQuadrupletGenerator_H
+
+/** A HitQuadrupletGenerator consisting of a set of
+ *  quadruplet generators of type HitQuadrupletGeneratorFromPairAndLayers
+ *  initialised from provided layers in the form of PixelLayerQuadruplets
+ */
+
+#include <vector>
+#include "RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGenerator.h"
+#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/EDGetToken.h"
+
+
+class TrackingRegion;
+class HitQuadrupletGeneratorFromTripletAndLayers;
+class SeedingLayerSetsHits;
+
+namespace edm { class Event; }
+namespace edm { class EventSetup; }
+
+class CombinedHitQuadrupletGenerator : public HitQuadrupletGenerator {
+public:
+  typedef LayerHitMapCache  LayerCacheType;
+
+public:
+
+  CombinedHitQuadrupletGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector& iC);
+
+  virtual ~CombinedHitQuadrupletGenerator();
+
+  /// from base class
+  virtual void hitQuadruplets( const TrackingRegion& reg, OrderedHitSeeds & triplets,
+      const edm::Event & ev,  const edm::EventSetup& es);
+
+private:
+  edm::EDGetTokenT<SeedingLayerSetsHits> theSeedingLayerToken;
+
+  LayerCacheType            theLayerCache;
+
+  std::unique_ptr<HitQuadrupletGeneratorFromTripletAndLayers> theGenerator;
+};
+#endif