Small change to #7101 (Integration of the Tracker Clusterizer for Phase2)

SLHCUpgradeSimulations/Configuration/python/phase2TkCustomsBE5DPixel10Ddev.py

@@ -61,7 +61,17 @@ def customise_RawToDigi(process):
     return process
 
 def customise_Reco(process,pileup):
-
+    # insert the new clusterizer
+    process.load('SimTracker.SiPhase2Digitizer.phase2clusterizer_cfi')
+    itIndex = process.pixeltrackerlocalreco.index(process.siPixelClusters)
+    process.pixeltrackerlocalreco.insert(itIndex, process.siPhase2Clusters)
+
+    # keep new clusters
+    alist=['RAWSIM','FEVTDEBUG','FEVTDEBUGHLT','GENRAW','RAWSIMHLT','FEVT']
+    for a in alist:
+        b=a+'output'
+        if hasattr(process,b):
+            getattr(process,b).outputCommands.append('keep *_siPhase2Clusters_*_*')
 
 
     #use with latest pixel geometry

SimTracker/SiPhase2Digitizer/BuildFile.xml

@@ -11,11 +11,12 @@
 <use   name="Geometry/TrackerGeometryBuilder"/>
 <use   name="SimGeneral/NoiseGenerators"/>
 <use   name="SimTracker/Common"/>
+<use   name="DataFormats/SiPixelDetId"/>
+<use   name="DataFormats/SiPixelCluster"/>
 <use   name="CalibTracker/SiPixelESProducers"/>
 <use   name="gsl"/>
 <use   name="clhep"/>
 <use   name="root"/>
-<use   name="rootflx"/>
-<library   file="*.cc" name="SimTrackerSiPhase2DigitizerPlugins">
-  <flags   EDM_PLUGIN="1"/>
-</library>
+<export>
+  <lib name="1"/>
+</export>

SimTracker/SiPhase2Digitizer/interface/ClusterizerAlgorithm.h

@@ -0,0 +1,83 @@
+#ifndef SimTracker_SiPhase2Digitizer_ClusterizerAlgorithm_h
+#define SimTracker_SiPhase2Digitizer_ClusterizerAlgorithm_h
+
+#include "DataFormats/Common/interface/DetSetVector.h"
+#include "DataFormats/Common/interface/DetSetVectorNew.h"
+#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
+#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"
+#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
+
+#include "SimTracker/SiPhase2Digitizer/interface/PixelClusterHitArray.h"
+//#include "SimTracker/SiPhase2Digitizer/interface/PixelClusterSimLink.h"
+
+#include "CalibTracker/SiPixelESProducers/interface/SiPixelGainCalibrationServiceBase.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include <vector>
+#include <map>
+
+class PixelGeomDetUnit;
+
+class PixelClusterSimLink;
+
+class ClusterizerAlgorithm {
+
+public:
+    typedef edm::DetSet<PixelDigi>::const_iterator DigiIterator;
+
+    ClusterizerAlgorithm(edm::ParameterSet const& conf, int maxClusterSize, int maxNumberClusters);
+    void setup(const PixelGeomDetUnit* pixDet);
+    void clusterizeDetUnit(const edm::DetSet<PixelDigi> & pixelDigis, const edm::Handle< edm::DetSetVector< PixelDigiSimLink > > & pixelSimLinks, edmNew::DetSetVector<SiPixelCluster>::FastFiller & clusters) ;
+  //  void makeLinks(edm::OrphanHandle< edmNew::DetSetVector<SiPixelCluster> > & clusters, std::vector<edm::DetSet<PixelClusterSimLink> > & linksByDet);
+
+    unsigned int getSimTrackId(const edm::Handle< edm::DetSetVector< PixelDigiSimLink > > & pixelSimLinks, int channel);
+
+private:
+    void copy_to_buffer(DigiIterator begin, DigiIterator end);
+    void clear_buffer(DigiIterator begin, DigiIterator end);
+
+public:
+    edm::ParameterSet conf_;
+    PixelClusterHitArray hits;
+    int maxClusterSize_;
+    int maxNumberClusters_;
+    int nrows_;
+    int ncols_;
+    unsigned int rawDetId_;
+
+    std::map< SiPixelCluster, std::vector< unsigned int > > tmpSimLinks;
+
+    struct AccretionCluster {
+        static constexpr unsigned short MAXSIZE = 256;
+        unsigned short adc[256];
+        unsigned short x[256];
+        unsigned short y[256];
+        unsigned short xmin = 16000;
+        unsigned short xmax = 0;
+        unsigned short ymin = 16000;
+        unsigned short ymax = 0;
+        unsigned int isize = 0;
+        unsigned int curr = 0;
+        unsigned short top() const { return curr; }
+        void pop() { ++curr; }
+        bool empty() { return curr == isize; }
+        bool add(SiPixelCluster::PixelPos const & p, unsigned short const iadc) {
+            if (isize == MAXSIZE) return false;
+            xmin = std::min(xmin, (unsigned short) p.row());
+            xmax = std::max(xmax, (unsigned short) p.row());
+            ymin = std::min(ymin, (unsigned short) p.col());
+            ymax = std::max(ymax, (unsigned short) p.col());
+            adc[isize] = iadc;
+            x[isize] = p.row();
+            y[isize++] = p.col();
+            return true;
+        }
+        unsigned short size() { return isize; }
+        unsigned short xsize() { return xmax - xmin + 1; }
+        unsigned short ysize() { return ymax - ymin + 1; }
+    };
+
+};
+
+#endif

SimTracker/SiPhase2Digitizer/interface/PixelClusterHitArray.h

@@ -0,0 +1,34 @@
+#ifndef SimTracker_SiPhase2Digitizer_HitArray_h
+#define SimTracker_SiPhase2Digitizer_HitArray_h
+
+#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
+
+#include <vector>
+
+class PixelClusterHitArray {
+
+public:
+        PixelClusterHitArray(int rows, int cols);
+	PixelClusterHitArray() { }
+
+	void setSize(int rows, int cols);
+	int operator()(int row, int col) const;
+	int operator()(const SiPixelCluster::PixelPos&) const;
+	int rows() const { return nrows; }
+	int columns() const { return ncols; }
+
+	bool inside(int row, int col) const;
+	void set(int row, int col, int adc);
+	void set(const SiPixelCluster::PixelPos&, int adc);
+	int size() const { return pixel_vec.size(); }
+
+	int index(int row, int col) const { return col * nrows + row; }
+	int index(const SiPixelCluster::PixelPos& pix) const { return index(pix.row(), pix.col()); }
+
+private:
+	int nrows;
+	int ncols;
+	std::vector<int> pixel_vec;
+};
+
+#endif

SimTracker/SiPhase2Digitizer/interface/PixelClusterSimLink.h

@@ -0,0 +1,34 @@
+#ifndef SimTracker_SiPhase2Digitizer_PixelClusterSimLinks_h
+#define SimTracker_SiPhase2Digitizer_PixelClusterSimLinks_h
+
+#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
+#include "DataFormats/Common/interface/DetSetVector.h"
+#include "DataFormats/Common/interface/DetSetVectorNew.h"
+#include "DataFormats/Common/interface/Ref.h"
+
+#include <vector>
+#include <algorithm>
+
+class PixelClusterSimLink {
+
+public:
+    PixelClusterSimLink() { };
+    void setSimTracks(std::vector< unsigned int > simTrack) {
+        simTracks_ = simTrack;
+        std::sort(simTracks_.begin(), simTracks_.end() );
+        simTracks_.erase(std::unique(simTracks_.begin(), simTracks_.end()), simTracks_.end());
+    };
+    void setCluster(edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster>  cluster) { cluster_ = cluster; };
+
+    std::vector< unsigned int > getSimTracks() { return simTracks_; };
+    edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster>  getCluster() { return cluster_; };
+
+    inline bool operator< ( const PixelClusterSimLink& other ) const { return true; }
+
+private:
+    edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster>  cluster_;
+    std::vector< unsigned int > simTracks_;
+
+};
+
+#endif

SimTracker/SiPhase2Digitizer/plugins/BuildFile.xml

@@ -1,4 +1,9 @@
-<use   name="SimTracker/SiPhase2Digitizer"/>
-<library   file="*.cc" name="SimTrackerSiPhase2DigitizerPlugins">
+<use name="SimTracker/SiPhase2Digitizer"/>
+<use name="CalibTracker/SiPixelESProducers"/>
+<use name="DataFormats/TrackerRecHit2D"/>
+<library   file="Phase2TrackerDigitizer.cc PSPDigitizerAlgorithm.cc Phase2TrackerDigitizerAlgorithm.cc PixelDigitizerAlgorithm.cc PSSDigitizerAlgorithm.cc SSDigitizerAlgorithm.cc" name="SimTrackerSiPhase2DigitizerPlugins">
+  <flags   EDM_PLUGIN="1"/>
+</library>
+<library   file="SiPhase2Clusterizer.cc ../src/ClusterizerAlgorithm.cc ../src/PixelClusterHitArray.cc" name="SimTrackerSiPhase2ClusterizerPlugins">
   <flags   EDM_PLUGIN="1"/>
 </library>

SimTracker/SiPhase2Digitizer/plugins/SiPhase2Clusterizer.cc

@@ -0,0 +1,121 @@
+#include "SimTracker/SiPhase2Digitizer/plugins/SiPhase2Clusterizer.h"
+#include "SimTracker/SiPhase2Digitizer/interface/ClusterizerAlgorithm.h"
+//#include "SimTracker/SiPhase2Digitizer/interface/PixelClusterSimLink.h"
+
+#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
+#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
+#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
+#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"
+#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetType.h"
+#include "Geometry/TrackerGeometryBuilder/interface/RectangularPixelTopology.h"
+
+#include "DataFormats/Common/interface/DetSetVector.h"
+#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"
+#include "DataFormats/DetId/interface/DetId.h"
+#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
+#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+
+#include "FWCore/PluginManager/interface/ModuleDef.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include <vector>
+
+namespace cms {
+
+    SimTrackerSiPhase2Clusterizer::SimTrackerSiPhase2Clusterizer(edm::ParameterSet const& conf) :
+        conf_(conf),
+        src_(conf.getParameter< edm::InputTag >("src")),
+        maxClusterSize_(conf.getParameter< int >("maxClusterSize")),
+        maxNumberClusters_(conf.getParameter< int >("maxNumberClusters")),
+        generateClusterSimLink_(conf.getParameter< bool >("clusterSimLink")) {
+
+        // Objects that will be produced
+        produces< SiPixelClusterCollectionNew >(); 
+
+        // Optionally produce simlinks
+        //if (generateClusterSimLink_) produces< edm::DetSetVector<PixelClusterSimLink> >();
+
+        // Set the algorithm to use
+        clusterizer_ = new ClusterizerAlgorithm(conf, maxClusterSize_, maxNumberClusters_);
+    }
+
+    SimTrackerSiPhase2Clusterizer::~SimTrackerSiPhase2Clusterizer() { }
+
+    void SimTrackerSiPhase2Clusterizer::beginJob(edm::Run const& run, edm::EventSetup const& eventSetup) {
+        edm::LogInfo("SimTrackerSiPhase2Clusterizer") << "[SiPhase2Clusterizer::beginJob]";
+    }
+
+    void SimTrackerSiPhase2Clusterizer::produce(edm::Event & e, const edm::EventSetup & eventSetup) {
+
+        // Get the Digis
+        edm::Handle< edm::DetSetVector< PixelDigi > >  digis;
+        e.getByLabel(src_, digis);
+
+        // Get the simlinks for the Digis
+        edm::Handle< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinks;
+        e.getByLabel(src_, pixelSimLinks);
+
+        // Get the geometry
+        edm::ESHandle< TrackerGeometry > geomHandle;
+        eventSetup.get< TrackerDigiGeometryRecord >().get(geomHandle);
+        const TrackerGeometry* tkGeom = &(*geomHandle); 
+
+        edm::ESHandle<TrackerTopology> tTopoHandle;
+        eventSetup.get<IdealGeometryRecord>().get(tTopoHandle);
+        const TrackerTopology* tTopo = tTopoHandle.product();
+
+        // Global container for the clusters of each modules
+        std::auto_ptr< SiPixelClusterCollectionNew > outputClusters(new SiPixelClusterCollectionNew());
+
+        // Go over all the modules
+        for (edm::DetSetVector< PixelDigi >::const_iterator DSViter = digis->begin(); DSViter != digis->end(); ++DSViter) {
+
+            if (!isOuterTracker(DSViter->detId(), tTopo)) continue;
+
+            // Geometry & detID
+            DetId detId(DSViter->detId());
+            const GeomDetUnit* geomDetUnit = tkGeom->idToDetUnit(detId);
+            const PixelGeomDetUnit* pixDet = dynamic_cast< const PixelGeomDetUnit* >(geomDetUnit);
+            if (!pixDet) assert(0);
+
+            // Container for the clusters that will be produced for this modules
+            edmNew::DetSetVector<SiPixelCluster>::FastFiller clusters(*outputClusters, DSViter->detId());
+
+            // Setup the clusterizer algorithm for this detector (see ClusterizerAlgorithm for more details)
+            clusterizer_->setup(pixDet);
+
+            // Pass the list of Digis to the main algorithm
+            // This function will store the clusters in the previously created container
+            clusterizer_->clusterizeDetUnit(*DSViter, pixelSimLinks, clusters);
+
+            if (clusters.empty()) clusters.abort();
+        }
+
+        // Add the data to the output
+        edm::OrphanHandle< edmNew::DetSetVector<SiPixelCluster> > clusterCollection = e.put(outputClusters);
+
+        // Do the same operations for the SimLinks if we have to generate them
+        /*if (generateClusterSimLink_) {
+            std::vector< edm::DetSet< PixelClusterSimLink > > linksByDet;
+            clusterizer_->makeLinks(clusterCollection, linksByDet);
+            std::auto_ptr< edm::DetSetVector< PixelClusterSimLink > > outputLinks(new edm::DetSetVector< PixelClusterSimLink >(linksByDet));
+            e.put(outputLinks);
+        }*/
+    }
+
+    bool SimTrackerSiPhase2Clusterizer::isOuterTracker(unsigned int detid, const TrackerTopology* topo) {
+        DetId theDetId(detid);
+        if (theDetId.det() == DetId::Tracker) {
+            if (theDetId.subdetId() == PixelSubdetector::PixelBarrel) return (topo->pxbLayer(detid) >= 5);
+            else if (theDetId.subdetId() == PixelSubdetector::PixelEndcap) return (topo->pxfDisk(detid) >= 11);
+            else return false;
+        }
+        return false;
+    }
+}
+
+using cms::SimTrackerSiPhase2Clusterizer;
+DEFINE_FWK_MODULE(SimTrackerSiPhase2Clusterizer);
+

SimTracker/SiPhase2Digitizer/plugins/SiPhase2Clusterizer.h

@@ -0,0 +1,46 @@
+#ifndef SimTracker_SiPhase2Digitizer_SimTrackerSiPhase2Clusterizer_h
+#define SimTracker_SiPhase2Digitizer_SimTrackerSiPhase2Clusterizer_h
+
+#include "SimTracker/SiPhase2Digitizer/interface/ClusterizerAlgorithm.h"
+
+#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
+#include "Geometry/Records/interface/StackedTrackerGeometryRecord.h"
+
+#include "DataFormats/DetId/interface/DetId.h"
+#include "DataFormats/Common/interface/DetSetVector.h"
+#include "DataFormats/Common/interface/DetSetVectorNew.h"
+#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"
+#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "DataFormats/Common/interface/Handle.h"
+
+#include "FWCore/Framework/interface/EDProducer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/InputTag.h"
+
+namespace cms {
+
+    class SimTrackerSiPhase2Clusterizer : public edm::EDProducer {
+
+        public:
+            explicit SimTrackerSiPhase2Clusterizer(const edm::ParameterSet & conf);
+            virtual ~SimTrackerSiPhase2Clusterizer();
+    	    void setupClusterizer();
+    	    void beginJob(edm::Run const& run, edm::EventSetup const& eventSetup);
+    	    virtual void produce(edm::Event & e, const edm::EventSetup & eventSetup);
+            bool isOuterTracker(unsigned int detid, const TrackerTopology* topo);
+
+  	private:
+    	    edm::ParameterSet conf_;
+    	    ClusterizerAlgorithm* clusterizer_;
+            edm::InputTag src_;
+            int maxClusterSize_;
+            int maxNumberClusters_;
+            bool generateClusterSimLink_;
+    };
+}
+
+#endif

SimTracker/SiPhase2Digitizer/python/phase2clusterizer_cfi.py

@@ -0,0 +1,12 @@
+import FWCore.ParameterSet.Config as cms
+
+# Clusterizer options
+siPhase2Clusters = cms.EDProducer('SimTrackerSiPhase2Clusterizer',
+    src = cms.InputTag("simSiPixelDigis"), 
+    maxClusterSize = cms.int32(8),
+    maxNumberClusters = cms.int32(-1),
+    clusterSimLink = cms.bool(True)
+)
+
+
+