A specific threshold-based pixel clustering algorithm. More...

#include <PixelThresholdClusterizer.h>

Inheritance diagram for PixelThresholdClusterizer:

Public Member Functions
void	clusterizeDetUnit (const edm::DetSet< PixelDigi > &input, const PixelGeomDetUnit pixDet, const TrackerTopology tTopo, const std::vector< short > &badChannels, edmNew::DetSetVector< SiPixelCluster >::FastFiller &output) override

void	clusterizeDetUnit (const edmNew::DetSet< SiPixelCluster > &input, const PixelGeomDetUnit pixDet, const TrackerTopology tTopo, const std::vector< short > &badChannels, edmNew::DetSetVector< SiPixelCluster >::FastFiller &output) override

bool	isCalibrated ()

	PixelThresholdClusterizer (edm::ParameterSet const &conf)

	~PixelThresholdClusterizer () override

Public Member Functions inherited from PixelClusterizerBase
void	setSiPixelGainCalibrationService (SiPixelGainCalibrationServiceBase *in)

virtual	~PixelClusterizerBase ()

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Protected Member Functions
int	calibrate (int adc, int col, int row)

void	clear_buffer (DigiIterator begin, DigiIterator end)
	Clear the internal buffer array. More...

void	clear_buffer (ClusterIterator begin, ClusterIterator end)

template<typename T >
void	clusterizeDetUnitT (const T &input, const PixelGeomDetUnit pixDet, const TrackerTopology tTopo, const std::vector< short > &badChannels, edmNew::DetSetVector< SiPixelCluster >::FastFiller &output)

void	copy_to_buffer (DigiIterator begin, DigiIterator end)
	Copy adc counts from PixelDigis into the buffer, identify seeds. More...

void	copy_to_buffer (ClusterIterator begin, ClusterIterator end)

SiPixelCluster	make_cluster (const SiPixelCluster::PixelPos &pix, edmNew::DetSetVector< SiPixelCluster >::FastFiller &output)
	The actual clustering algorithm: group the neighboring pixels around the seed. More...

bool	setup (const PixelGeomDetUnit *pixDet)
	Private helper methods: More...

Protected Attributes
const bool	doMissCalibrate

const bool	doPhase2Calibration

const bool	doSplitClusters

const bool	dropDuplicates

SiPixelArrayBuffer	theBuffer
	Data storage. More...

std::vector< SiPixelCluster >	theClusters

const int	theClusterThreshold

const int	theClusterThreshold_L1

float	theClusterThresholdInNoiseUnits

const int	theConversionFactor

const int	theConversionFactor_L1

uint32_t	theDetid

const double	theElectronPerADCGain

std::vector< bool >	theFakePixels

int	theLayer

int	theNumOfCols

int	theNumOfRows
	Geometry-related information. More...

const int	theOffset

const int	theOffset_L1

const double	thePhase2DigiBaseline

const int	thePhase2KinkADC

const int	thePhase2ReadoutMode

std::vector< uint8_t >	thePixelOccurrence

const int	thePixelThreshold

float	thePixelThresholdInNoiseUnits
	Clustering-related quantities: More...

std::vector< SiPixelCluster::PixelPos >	theSeeds

const int	theSeedThreshold

float	theSeedThresholdInNoiseUnits

Protected Attributes inherited from PixelClusterizerBase
SiPixelGainCalibrationServiceBase *	theSiPixelGainCalibrationService_

Additional Inherited Members
Public Types inherited from PixelClusterizerBase
typedef edmNew::DetSet< SiPixelCluster >::const_iterator	ClusterIterator

typedef edm::DetSet< PixelDigi >::const_iterator	DigiIterator

Detailed Description

A specific threshold-based pixel clustering algorithm.

An explicit threshold-based clustering algorithm.

General logic of PixelThresholdClusterizer:

The clusterization is performed on a matrix with size equal to the size of the pixel detector, each cell containing the ADC count of the corresponding pixel. The matrix is reset after each clusterization.

The search starts from seed pixels, i.e. pixels with sufficiently large amplitudes, found at the time of filling of the matrix and stored in a SiPixelArrayBuffer.

Translate the pixel charge to electrons, we are suppose to do the calibrations ADC->electrons here. Modify the thresholds to be in electrons, convert adc to electrons. d.k. 20/3/06 Get rid of the noiseVector. d.k. 28/3/06

A threshold-based clustering algorithm which clusters SiPixelDigis into SiPixelClusters for each DetUnit. The algorithm is straightforward and purely topological: the clustering process starts with seed pixels and continues by adding adjacent pixels above the pixel threshold. Once the cluster is made, it has to be above the cluster threshold as well.

The clusterization is performed on a matrix with size equal to the size of the pixel detector, each cell containing the ADC count of the corresponding pixel. The matrix is reset after each clusterization.

The search starts from seed pixels, i.e. pixels with sufficiently large amplitudes, found at the time of filling of the matrix and stored in a

At this point the noise and dead channels are ignored, but soon they won't be.

SiPixelCluster contains a barrycenter, but it should be noted that that information is largely useless. One must use a PositionEstimator class to compute the RecHit position and its error for every given cluster.

Author: Largely copied from NewPixelClusterizer in ORCA written by Danek Kotlinski (PSI). Ported to CMSSW by Petar Maksimovic (JHU). DetSetVector data container implemented by V.Chiochia (Uni Zurich)

Sets the PixelArrayBuffer dimensions and pixel thresholds. Makes clusters and stores them in theCache if the option useCache has been set.

Definition at line 57 of file PixelThresholdClusterizer.h.

Constructor & Destructor Documentation

◆ PixelThresholdClusterizer()

PixelThresholdClusterizer::PixelThresholdClusterizer ( edm::ParameterSet const & conf )

Constructor: Initilize the buffer to hold pixels from a detector module. This is a vector of 44k ints, stays valid all the time.

Definition at line 44 of file PixelThresholdClusterizer.cc.

References SiPixelArrayBuffer::setSize(), theBuffer, theFakePixels, theNumOfCols, theNumOfRows, and thePixelOccurrence.

     :  // Get thresholds in electrons
       thePixelThreshold(conf.getParameter<int>("ChannelThreshold")),
       theSeedThreshold(conf.getParameter<int>("SeedThreshold")),
       theClusterThreshold(conf.getParameter<int>("ClusterThreshold")),
       theClusterThreshold_L1(conf.getParameter<int>("ClusterThreshold_L1")),
       theConversionFactor(conf.getParameter<int>("VCaltoElectronGain")),
       theConversionFactor_L1(conf.getParameter<int>("VCaltoElectronGain_L1")),
       theOffset(conf.getParameter<int>("VCaltoElectronOffset")),
       theOffset_L1(conf.getParameter<int>("VCaltoElectronOffset_L1")),
       theElectronPerADCGain(conf.getParameter<double>("ElectronPerADCGain")),
       doPhase2Calibration(conf.getParameter<bool>("Phase2Calibration")),
       dropDuplicates(conf.getParameter<bool>("DropDuplicates")),
       thePhase2ReadoutMode(conf.getParameter<int>("Phase2ReadoutMode")),
       thePhase2DigiBaseline(conf.getParameter<double>("Phase2DigiBaseline")),
       thePhase2KinkADC(conf.getParameter<int>("Phase2KinkADC")),
       theNumOfRows(0),
       theNumOfCols(0),
       theDetid(0),
       // Get the constants for the miss-calibration studies
       doMissCalibrate(conf.getParameter<bool>("MissCalibrate")),
       doSplitClusters(conf.getParameter<bool>("SplitClusters")) {
   theBuffer.setSize(theNumOfRows, theNumOfCols);
   theFakePixels.clear();
   thePixelOccurrence.clear();
 }

◆ ~PixelThresholdClusterizer()

PixelThresholdClusterizer::~PixelThresholdClusterizer ( )

override

Definition at line 71 of file PixelThresholdClusterizer.cc.

71 {}

Member Function Documentation

◆ calibrate()

int PixelThresholdClusterizer::calibrate	(	int	adc,
		int	col,
		int	row
	)

protected

Definition at line 280 of file PixelThresholdClusterizer.cc.

References gpuClustering::adc, cuy::col, doMissCalibrate, doPhase2Calibration, pwdgSkimBPark_cfi::electrons, PedestalClient_cfi::gain, SiPixelGainCalibrationServiceBase::getGain(), SiPixelGainCalibrationServiceBase::getPedestal(), createfilelist::int, SiPixelGainCalibrationServiceBase::isDead(), SiPixelGainCalibrationServiceBase::isNoisy(), EcalCondDBWriter_cfi::pedestal, conifer::pow(), theConversionFactor, theConversionFactor_L1, theDetid, theElectronPerADCGain, theLayer, theOffset, theOffset_L1, thePhase2DigiBaseline, thePhase2KinkADC, thePhase2ReadoutMode, and PixelClusterizerBase::theSiPixelGainCalibrationService_.

Referenced by copy_to_buffer().

                                                                   {
   int electrons = 0;
 
   if (doPhase2Calibration) {
     const float gain = theElectronPerADCGain;
     int p2rm = (thePhase2ReadoutMode < -1 ? -1 : thePhase2ReadoutMode);
 
     if (p2rm == -1) {
       electrons = int(adc * gain);
     } else {
       if (adc < thePhase2KinkADC) {
         electrons = int((adc + 0.5) * gain);
       } else {
         const int dualslopeparam = (thePhase2ReadoutMode < 10 ? thePhase2ReadoutMode : 10);
         const int dualslope = int(dualslopeparam <= 1 ? 1. : pow(2, dualslopeparam - 1));
         adc -= thePhase2KinkADC;
         adc *= dualslope;
         adc += thePhase2KinkADC;
         electrons = int((adc + 0.5 * dualslope) * gain);
       }
       electrons += int(thePhase2DigiBaseline);
     }
 
     return electrons;
   }
 
   if (doMissCalibrate) {
     // do not perform calibration if pixel is dead!
 
     if (!theSiPixelGainCalibrationService_->isDead(theDetid, col, row) &&
         !theSiPixelGainCalibrationService_->isNoisy(theDetid, col, row)) {
       // Linear approximation of the TANH response
       // Pixel(0,0,0)
       //const float gain = 2.95; // 1 ADC = 2.95 VCALs (1/0.339)
       //const float pedestal = -83.; // -28/0.339
       // Roc-0 average
       //const float gain = 1./0.357; // 1 ADC = 2.80 VCALs
       //const float pedestal = -28.2 * gain; // -79.
 
       float DBgain = theSiPixelGainCalibrationService_->getGain(theDetid, col, row);
       float pedestal = theSiPixelGainCalibrationService_->getPedestal(theDetid, col, row);
       float DBpedestal = pedestal * DBgain;
 
       // Roc-6 average
       //const float gain = 1./0.313; // 1 ADC = 3.19 VCALs
       //const float pedestal = -6.2 * gain; // -19.8
       //
       float vcal = adc * DBgain - DBpedestal;
 
       // atanh calibration
       // Roc-6 average
       //const float p0 = 0.00492;
       //const float p1 = 1.998;
       //const float p2 = 90.6;
       //const float p3 = 134.1;
       // Roc-6 average
       //const float p0 = 0.00382;
       //const float p1 = 0.886;
       //const float p2 = 112.7;
       //const float p3 = 113.0;
       //float vcal = ( atanh( (adc-p3)/p2) + p1)/p0;
 
       if (theLayer == 1) {
         electrons = int(vcal * theConversionFactor_L1 + theOffset_L1);
       } else {
         electrons = int(vcal * theConversionFactor + theOffset);
       }
     }
   } else {  // No misscalibration in the digitizer
     // Simple (default) linear gain
     const float gain = theElectronPerADCGain;  // default: 1 ADC = 135 electrons
     const float pedestal = 0.;                 //
     electrons = int(adc * gain + pedestal);
   }
 
   return electrons;
 }

◆ clear_buffer() [1/2]

void PixelThresholdClusterizer::clear_buffer	(	DigiIterator	begin,
		DigiIterator	end
	)

protected

Clear the internal buffer array.

Pixels which are not part of recognized clusters are NOT ERASED during the cluster finding. Erase them now.

TO DO: ask Danek... wouldn't it be faster to simply memcopy() zeros into the whole buffer array?

Definition at line 135 of file PixelThresholdClusterizer.cc.

References mps_fire::end, SiPixelArrayBuffer::set_adc(), and theBuffer.

                                                                                  {
   for (DigiIterator di = begin; di != end; ++di) {
     theBuffer.set_adc(di->row(), di->column(), 0);  // reset pixel adc to 0
   }
 }

◆ clear_buffer() [2/2]

void PixelThresholdClusterizer::clear_buffer	(	ClusterIterator	begin,
		ClusterIterator	end
	)

protected

Definition at line 141 of file PixelThresholdClusterizer.cc.

References mps_fire::end, mps_fire::i, muonClassificationByHits_cfi::pixel, SiPixelArrayBuffer::set_adc(), and theBuffer.

                                                                                        {
   for (ClusterIterator ci = begin; ci != end; ++ci) {
     for (int i = 0; i < ci->size(); ++i) {
       const SiPixelCluster::Pixel pixel = ci->pixel(i);
 
       theBuffer.set_adc(pixel.x, pixel.y, 0);  // reset pixel adc to 0
     }
   }
 }

◆ clusterizeDetUnit() [1/2]

void PixelThresholdClusterizer::clusterizeDetUnit	(	const edm::DetSet< PixelDigi > &	input,
		const PixelGeomDetUnit *	pixDet,
		const TrackerTopology *	tTopo,
		const std::vector< short > &	badChannels,
		edmNew::DetSetVector< SiPixelCluster >::FastFiller &	output
	)

inlineoverridevirtual

Implements PixelClusterizerBase.

Definition at line 63 of file PixelThresholdClusterizer.h.

References input.

                                                                                         {
     clusterizeDetUnitT(input, pixDet, tTopo, badChannels, output);
   }

◆ clusterizeDetUnit() [2/2]

void PixelThresholdClusterizer::clusterizeDetUnit	(	const edmNew::DetSet< SiPixelCluster > &	input,
		const PixelGeomDetUnit *	pixDet,
		const TrackerTopology *	tTopo,
		const std::vector< short > &	badChannels,
		edmNew::DetSetVector< SiPixelCluster >::FastFiller &	output
	)

inlineoverridevirtual

Implements PixelClusterizerBase.

Definition at line 70 of file PixelThresholdClusterizer.h.

References input.

                                                                                         {
     clusterizeDetUnitT(input, pixDet, tTopo, badChannels, output);
   }

◆ clusterizeDetUnitT()

template<typename T >

void PixelThresholdClusterizer::clusterizeDetUnitT	(	const T &	input,
		const PixelGeomDetUnit *	pixDet,
		const TrackerTopology *	tTopo,
		const std::vector< short > &	badChannels,
		edmNew::DetSetVector< SiPixelCluster >::FastFiller &	output
	)

protected

◆ copy_to_buffer() [1/2]

void PixelThresholdClusterizer::copy_to_buffer	(	DigiIterator	begin,
		DigiIterator	end
	)

protected

Copy adc counts from PixelDigis into the buffer, identify seeds.

Definition at line 154 of file PixelThresholdClusterizer.cc.

References gpuClustering::adc, cms::cuda::assert(), calibrate(), cuy::col, gather_cfg::cout, doMissCalibrate, doPhase2Calibration, dropDuplicates, HPSPFTauProducerPuppi_cfi::electron, mps_fire::end, PedestalClient_cfi::gain, mps_fire::i, recoMuon::in, SiPixelArrayBuffer::index(), createfilelist::int, EcalCondDBWriter_cfi::pedestal, MatrixUtil::remove(), SiPixelArrayBuffer::set_adc(), theBuffer, theConversionFactor, theConversionFactor_L1, theDetid, theElectronPerADCGain, theFakePixels, theLayer, theNumOfCols, theOffset, theOffset_L1, thePixelOccurrence, thePixelThreshold, theSeeds, and theSeedThreshold.

                                                                                    {
 #ifdef PIXELREGRESSION
   static std::atomic<int> s_ic = 0;
   in ic = ++s_ic;
   if (ic == 1) {
     // std::cout << (doMissCalibrate ? "VI from db" : "VI linear") << std::endl;
   }
 #endif
 
   //If called with empty/invalid DetSet, warn the user
   if (end <= begin) {
     edm::LogWarning("PixelThresholdClusterizer") << " copy_to_buffer called with empty or invalid range" << std::endl;
     return;
   }
 
   int electron[end - begin];  // pixel charge in electrons
   memset(electron, 0, (end - begin) * sizeof(int));
 
   if (doPhase2Calibration) {
     int i = 0;
     for (DigiIterator di = begin; di != end; ++di) {
       electron[i] = calibrate(di->adc(), di->column(), di->row());
       i++;
     }
     assert(i == (end - begin));
   }
 
   else {
     if (doMissCalibrate) {
       if (theLayer == 1) {
         (*theSiPixelGainCalibrationService_)
             .calibrate(theDetid, begin, end, theConversionFactor_L1, theOffset_L1, electron);
       } else {
         (*theSiPixelGainCalibrationService_).calibrate(theDetid, begin, end, theConversionFactor, theOffset, electron);
       }
     } else {
       int i = 0;
       const float gain = theElectronPerADCGain;  // default: 1 ADC = 135 electrons
       for (DigiIterator di = begin; di != end; ++di) {
         auto adc = di->adc();
         const float pedestal = 0.;  //
         electron[i] = int(adc * gain + pedestal);
         ++i;
       }
       assert(i == (end - begin));
     }
   }
 
   int i = 0;
 #ifdef PIXELREGRESSION
   static std::atomic<int> eqD = 0;
 #endif
   for (DigiIterator di = begin; di != end; ++di) {
     int row = di->row();
     int col = di->column();
     // VV: do not calibrate a fake pixel, it already has a unit of 10e-:
     int adc = (di->flag() != 0) ? di->adc() * 10 : electron[i];  // this is in electrons
     i++;
 
 #ifdef PIXELREGRESSION
     int adcOld = calibrate(di->adc(), col, row);
     //assert(adc==adcOld);
     if (adc != adcOld)
       std::cout << "VI " << eqD << ' ' << ic << ' ' << end - begin << ' ' << i << ' ' << di->adc() << ' ' << adc << ' '
                 << adcOld << std::endl;
     else
       ++eqD;
 #endif
 
     if (adc < 100)
       adc = 100;  // put all negative pixel charges into the 100 elec bin
     /* This is semi-random good number. The exact number (in place of 100) is irrelevant from the point
        of view of the final cluster charge since these are typically >= 20000.
     */
 
     thePixelOccurrence[theBuffer.index(row, col)]++;  // increment the occurrence counter
     uint8_t occurrence =
         (!dropDuplicates) ? 1 : thePixelOccurrence[theBuffer.index(row, col)];  // get the occurrence counter
 
     switch (occurrence) {
       // the 1st occurrence (standard treatment)
       case 1:
         if (adc >= thePixelThreshold) {
           theBuffer.set_adc(row, col, adc);
           // VV: add pixel to the fake list. Only when running on digi collection
           if (di->flag() != 0)
             theFakePixels[row * theNumOfCols + col] = true;
           if (adc >= theSeedThreshold)
             theSeeds.push_back(SiPixelCluster::PixelPos(row, col));
         }
         break;
 
       // the 2nd occurrence (duplicate pixel: reset the buffer to 0 and remove from the list of seed pixels)
       case 2:
         theBuffer.set_adc(row, col, 0);
         std::remove(theSeeds.begin(), theSeeds.end(), SiPixelCluster::PixelPos(row, col));
         break;
 
         // in case a pixel appears more than twice, nothing needs to be done because it was already removed at the 2nd occurrence
     }
   }
   assert(i == (end - begin));
 }

◆ copy_to_buffer() [2/2]

void PixelThresholdClusterizer::copy_to_buffer	(	ClusterIterator	begin,
		ClusterIterator	end
	)

protected

Definition at line 258 of file PixelThresholdClusterizer.cc.

References gpuClustering::adc, SiPixelArrayBuffer::add_adc(), cuy::col, mps_fire::end, mps_fire::i, muonClassificationByHits_cfi::pixel, theBuffer, thePixelThreshold, theSeeds, and theSeedThreshold.

                                                                                          {
   // loop over clusters
   for (ClusterIterator ci = begin; ci != end; ++ci) {
     // loop over pixels
     for (int i = 0; i < ci->size(); ++i) {
       const SiPixelCluster::Pixel pixel = ci->pixel(i);
 
       int row = pixel.x;
       int col = pixel.y;
       int adc = pixel.adc;
       if (adc >= thePixelThreshold) {
         theBuffer.add_adc(row, col, adc);
         if (adc >= theSeedThreshold)
           theSeeds.push_back(SiPixelCluster::PixelPos(row, col));
       }
     }
   }
 }

◆ fillPSetDescription()

void PixelThresholdClusterizer::fillPSetDescription ( edm::ParameterSetDescription & desc )

static

Definition at line 74 of file PixelThresholdClusterizer.cc.

References submitPVResolutionJobs::desc.

Referenced by SiPixelClusterProducer::fillDescriptions().

                                                                                     {
   desc.add<int>("ChannelThreshold", 1000);
   desc.add<bool>("MissCalibrate", true);
   desc.add<bool>("SplitClusters", false);
   desc.add<int>("VCaltoElectronGain", 65);
   desc.add<int>("VCaltoElectronGain_L1", 65);
   desc.add<int>("VCaltoElectronOffset", -414);
   desc.add<int>("VCaltoElectronOffset_L1", -414);
   desc.add<int>("SeedThreshold", 1000);
   desc.add<int>("ClusterThreshold_L1", 4000);
   desc.add<int>("ClusterThreshold", 4000);
   desc.add<double>("ElectronPerADCGain", 135.);
   desc.add<bool>("DropDuplicates", true);
   desc.add<bool>("Phase2Calibration", false);
   desc.add<int>("Phase2ReadoutMode", -1);
   desc.add<double>("Phase2DigiBaseline", 1200.);
   desc.add<int>("Phase2KinkADC", 8);
 }

◆ isCalibrated()

bool PixelThresholdClusterizer::isCalibrated ( )

inline

Definition at line 80 of file PixelThresholdClusterizer.h.

80 { return doMissCalibrate; }

PixelThresholdClusterizer::doMissCalibrate

const bool doMissCalibrate

Definition: PixelThresholdClusterizer.h:128

◆ make_cluster()

SiPixelCluster PixelThresholdClusterizer::make_cluster	(	const SiPixelCluster::PixelPos &	pix,
		edmNew::DetSetVector< SiPixelCluster >::FastFiller &	output
	)

protected

The actual clustering algorithm: group the neighboring pixels around the seed.

Definition at line 361 of file PixelThresholdClusterizer.cc.

                                                                                                              {
   //First we acquire the seeds for the clusters
   uint16_t seed_adc;
   std::stack<SiPixelCluster::PixelPos, std::vector<SiPixelCluster::PixelPos> > dead_pixel_stack;
 
   //The individual modules have been loaded into a buffer.
   //After each pixel has been considered by the clusterizer, we set the adc count to 1
   //to mark that we have already considered it.
   //The only difference between dead/noisy pixels and standard ones is that for dead/noisy pixels,
   //We consider the charge of the pixel to always be zero.
 
   /*  this is not possible as dead and noisy pixel cannot make it into a seed...
   if ( doMissCalibrate &&
        (theSiPixelGainCalibrationService_->isDead(theDetid,pix.col(),pix.row()) ||
     theSiPixelGainCalibrationService_->isNoisy(theDetid,pix.col(),pix.row())) )
     {
       std::cout << "IMPOSSIBLE" << std::endl;
       seed_adc = 0;
       theBuffer.set_adc(pix, 1);
     }
     else {
   */
   // Note: each ADC value is limited here to 65535 (std::numeric_limits<uint16_t>::max),
   //       as it is later stored as uint16_t in SiPixelCluster and PixelClusterizerBase/AccretionCluster
   //       (reminder: ADC values here may be expressed in number of electrons)
   seed_adc = std::min(theBuffer(pix.row(), pix.col()), int(std::numeric_limits<uint16_t>::max()));
   theBuffer.set_adc(pix, 1);
   //  }
 
   AccretionCluster acluster, cldata;
   acluster.add(pix, seed_adc);
   cldata.add(pix, seed_adc);
 
   //Here we search all pixels adjacent to all pixels in the cluster.
   bool dead_flag = false;
   while (!acluster.empty()) {
     //This is the standard algorithm to find and add a pixel
     auto curInd = acluster.top();
     acluster.pop();
     for (auto c = std::max(0, int(acluster.y[curInd]) - 1);
          c < std::min(int(acluster.y[curInd]) + 2, theBuffer.columns());
          ++c) {
       for (auto r = std::max(0, int(acluster.x[curInd]) - 1);
            r < std::min(int(acluster.x[curInd]) + 2, theBuffer.rows());
            ++r) {
         if (theBuffer(r, c) >= thePixelThreshold) {
           SiPixelCluster::PixelPos newpix(r, c);
           auto const newpix_adc = std::min(theBuffer(r, c), int(std::numeric_limits<uint16_t>::max()));
           if (!acluster.add(newpix, newpix_adc))
             goto endClus;
           // VV: no fake pixels in cluster, leads to non-contiguous clusters
           if (!theFakePixels[r * theNumOfCols + c]) {
             cldata.add(newpix, newpix_adc);
           }
           theBuffer.set_adc(newpix, 1);
         }
 
         /* //Commenting out the addition of dead pixels to the cluster until further testing -- dfehling 06/09
           //Check on the bounds of the module; this is to keep the isDead and isNoisy modules from returning errors
           else if(r>= 0 && c >= 0 && (r <= (theNumOfRows-1.)) && (c <= (theNumOfCols-1.))){
           //Check for dead/noisy pixels check that the buffer is not -1 (already considered).  Check whether we want to split clusters separated by dead pixels or not.
           if((theSiPixelGainCalibrationService_->isDead(theDetid,c,r) || theSiPixelGainCalibrationService_->isNoisy(theDetid,c,r)) && theBuffer(r,c) != 1){
 
           //If a pixel is dead or noisy, check to see if we want to split the clusters or not.
           //Push it into a dead pixel stack in case we want to split the clusters.  Otherwise add it to the cluster.
           //If we are splitting the clusters, we will iterate over the dead pixel stack later.
 
           SiPixelCluster::PixelPos newpix(r,c);
           if(!doSplitClusters){
 
           cluster.add(newpix, std::min(theBuffer(r, c), int(std::numeric_limits<uint16_t>::max())));}
           else if(doSplitClusters){
           dead_pixel_stack.push(newpix);
           dead_flag = true;}
 
           theBuffer.set_adc(newpix, 1);
           }
 
           }
           */
       }
     }
 
   }  // while accretion
 endClus:
   SiPixelCluster cluster(cldata.isize, cldata.adc, cldata.x, cldata.y, cldata.xmin, cldata.ymin);
   //Here we split the cluster, if the flag to do so is set and we have found a dead or noisy pixel.
 
   if (dead_flag && doSplitClusters) {
     // Set separate cluster threshold for L1 (needed for phase1)
     auto clusterThreshold = theClusterThreshold;
     if (theLayer == 1)
       clusterThreshold = theClusterThreshold_L1;
 
     //Set the first cluster equal to the existing cluster.
     SiPixelCluster first_cluster = cluster;
     bool have_second_cluster = false;
     while (!dead_pixel_stack.empty()) {
       //consider each found dead pixel
       SiPixelCluster::PixelPos deadpix = dead_pixel_stack.top();
       dead_pixel_stack.pop();
       theBuffer.set_adc(deadpix, 1);
 
       //Clusterize the split cluster using the dead pixel as a seed
       SiPixelCluster second_cluster = make_cluster(deadpix, output);
 
       //If both clusters would normally have been found by the clusterizer, put them into output
       if (second_cluster.charge() >= clusterThreshold && first_cluster.charge() >= clusterThreshold) {
         output.push_back(second_cluster);
         have_second_cluster = true;
       }
 
       //We also want to keep the merged cluster in data and let the RecHit algorithm decide which set to keep
       //This loop adds the second cluster to the first.
       const std::vector<SiPixelCluster::Pixel>& branch_pixels = second_cluster.pixels();
       for (unsigned int i = 0; i < branch_pixels.size(); i++) {
         auto const temp_x = branch_pixels[i].x;
         auto const temp_y = branch_pixels[i].y;
         auto const temp_adc = branch_pixels[i].adc;
         SiPixelCluster::PixelPos newpix(temp_x, temp_y);
         cluster.add(newpix, temp_adc);
       }
     }
 
     //Remember to also add the first cluster if we added the second one.
     if (first_cluster.charge() >= clusterThreshold && have_second_cluster) {
       output.push_back(first_cluster);
       std::push_heap(output.begin(), output.end(), [](SiPixelCluster const& cl1, SiPixelCluster const& cl2) {
         return cl1.minPixelRow() < cl2.minPixelRow();
       });
     }
   }
 
   return cluster;
 }

◆ setup()

bool PixelThresholdClusterizer::setup ( const PixelGeomDetUnit * pixDet )

protected

Private helper methods:

Prepare the Clusterizer to work on a particular DetUnit. Re-init the size of the panel/plaquette (so update nrows and ncols),

Definition at line 97 of file PixelThresholdClusterizer.cc.

References SiPixelArrayBuffer::columns(), hgcalPlots::ncols, PixelTopology::ncolumns(), PixelTopology::nrows(), SiPixelArrayBuffer::rows(), SiPixelArrayBuffer::setSize(), PixelGeomDetUnit::specificTopology(), theBuffer, theFakePixels, theNumOfCols, theNumOfRows, and thePixelOccurrence.

                                                                     {
   // Cache the topology.
   const PixelTopology& topol = pixDet->specificTopology();
 
   // Get the new sizes.
   int nrows = topol.nrows();     // rows in x
   int ncols = topol.ncolumns();  // cols in y
 
   theNumOfRows = nrows;  // Set new sizes
   theNumOfCols = ncols;
 
   if (nrows > theBuffer.rows() || ncols > theBuffer.columns()) {  // change only when a larger is needed
     if (nrows != theNumOfRows || ncols != theNumOfCols)
       edm::LogWarning("setup()") << "pixel buffer redefined to" << nrows << " * " << ncols;
     //theNumOfRows = nrows;  // Set new sizes
     //theNumOfCols = ncols;
     // Resize the buffer
     theBuffer.setSize(nrows, ncols);  // Modify
   }
 
   theFakePixels.resize(nrows * ncols, false);
 
   thePixelOccurrence.resize(nrows * ncols, 0);
 
   return true;
 }