RPixDetClusterizer Class Reference

#include <RPixDetClusterizer.h>

Public Member Functions
void	buildClusters (unsigned int detId, const std::vector< CTPPSPixelDigi > &digi, std::vector< CTPPSPixelCluster > &clusters, const CTPPSPixelGainCalibrations *pcalibration, const CTPPSPixelAnalysisMask *mask)
int	calibrate (unsigned int, int, int, int, const CTPPSPixelGainCalibrations *pcalibration)
void	make_cluster (RPixCalibDigi const &aSeed, std::vector< CTPPSPixelCluster > &clusters)
	RPixDetClusterizer (edm::ParameterSet const &conf)
	~RPixDetClusterizer ()

Private Attributes
unsigned short	ADCThreshold_
std::map< unsigned int, RPixCalibDigi >	calib_rpix_digi_map_
std::string	CalibrationFile_
bool	doSingleCalibration_
double	ElectronADCGain_
std::set< CTPPSPixelDigi >	rpix_digi_set_
unsigned short	SeedADCThreshold_
std::vector< RPixCalibDigi >	SeedVector_
int	VcaltoElectronGain_
int	VcaltoElectronOffset_
int	verbosity_

Detailed Description

Definition at line 40 of file RPixDetClusterizer.h.

Constructor & Destructor Documentation

RPixDetClusterizer()

RPixDetClusterizer::RPixDetClusterizer

(

edm::ParameterSet const &

conf

)

Definition at line 16 of file RPixDetClusterizer.cc.

References ADCThreshold_, doSingleCalibration_, ElectronADCGain_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), SeedADCThreshold_, VcaltoElectronGain_, VcaltoElectronOffset_, and verbosity_.

                                                                  : SeedVector_(0) {
  verbosity_ = conf.getUntrackedParameter<int>("RPixVerbosity");
  SeedADCThreshold_ = conf.getParameter<int>("SeedADCThreshold");
  ADCThreshold_ = conf.getParameter<int>("ADCThreshold");
  ElectronADCGain_ = conf.getParameter<double>("ElectronADCGain");
  VcaltoElectronGain_ = conf.getParameter<int>("VCaltoElectronGain");
  VcaltoElectronOffset_ = conf.getParameter<int>("VCaltoElectronOffset");
  doSingleCalibration_ = conf.getParameter<bool>("doSingleCalibration");
}

~RPixDetClusterizer()

RPixDetClusterizer::~RPixDetClusterizer

(

)

Definition at line 26 of file RPixDetClusterizer.cc.

{}

Member Function Documentation

buildClusters()

void RPixDetClusterizer::buildClusters	(	unsigned int	detId,
		const std::vector< CTPPSPixelDigi > &	digi,
		std::vector< CTPPSPixelCluster > &	clusters,
		const CTPPSPixelGainCalibrations *	pcalibration,
		const CTPPSPixelAnalysisMask *	mask
	)

Definition at line 28 of file RPixDetClusterizer.cc.

References gpuClustering::adc, CTPPSPixelAnalysisMask::analysisMask, calib_rpix_digi_map_, calibrate(), bsc_activity_cfg::clusters, hcalRecHitTable_cff::detId, ElectronADCGain_, pwdgSkimBPark_cfi::electrons, Exception, CTPPSPixelIndices::getROCId(), make_cluster(), ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, muonClassificationByHits_cfi::pixel, CTPPSPixelDetId::plane(), rpix_digi_set_, SeedADCThreshold_, SeedVector_, CTPPSPixelIndices::transformToModule(), and verbosity_.

Referenced by CTPPSPixelClusterProducer::run().

                                                                              {
  std::map<uint32_t, CTPPSPixelROCAnalysisMask> const &mask = maskera->analysisMask;
  std::set<std::pair<unsigned char, unsigned char> > maskedPixels;

  bool fullyMaskedRoc[6][6] = {{false}};
  CTPPSPixelDetId currentId(detId);

  // read and store masked pixels after converting ROC numbering into module numbering
  CTPPSPixelIndices pI;
  for (auto const &det : mask) {
    uint32_t planeId = det.first & ~rocMask;

    if (planeId == detId) {
      unsigned int rocNum = (det.first & rocMask) >> rocOffset;
      if (rocNum > 5)
        throw cms::Exception("InvalidRocNumber") << "roc number from mask: " << rocNum;
      if (det.second.fullMask)
        fullyMaskedRoc[currentId.plane()][rocNum] = true;
      for (auto const &paio : det.second.maskedPixels) {
        std::pair<unsigned char, unsigned char> pa = paio;
        int modCol, modRow;
        pI.transformToModule(pa.second, pa.first, rocNum, modCol, modRow);
        std::pair<int, int> modPix(modRow, modCol);
        maskedPixels.insert(modPix);
      }
    }
  }

  if (verbosity_)
    edm::LogInfo("RPixDetClusterizer") << detId << " received digi.size()=" << digi.size();

  // creating a set of CTPPSPixelDigi's and fill it

  rpix_digi_set_.clear();
  rpix_digi_set_.insert(digi.begin(), digi.end());
  SeedVector_.clear();

  // calibrate digis here
  calib_rpix_digi_map_.clear();

  for (auto const &RPdit : rpix_digi_set_) {
    uint8_t row = RPdit.row();
    uint8_t column = RPdit.column();
    if (row > maxRow || column > maxCol)
      throw cms::Exception("CTPPSDigiOutofRange") << " row = " << row << "  column = " << column;

    std::pair<unsigned char, unsigned char> pixel = std::make_pair(row, column);
    unsigned short adc = RPdit.adc();
    unsigned short electrons = 0;

    // check if pixel is noisy or dead (i.e. in the mask)
    const bool is_in = maskedPixels.find(pixel) != maskedPixels.end();

    // check if pixel inside a fully masked roc
    int piano = currentId.plane();
    int rocId = pI.getROCId(column, row);

    if (!is_in && !fullyMaskedRoc[piano][rocId]) {
      //calibrate digi and store the new ones
      electrons = calibrate(detId, adc, row, column, pcalibrations);
      if (electrons < SeedADCThreshold_ * ElectronADCGain_)
        electrons = SeedADCThreshold_ * ElectronADCGain_;
      RPixCalibDigi calibDigi(row, column, adc, electrons);
      unsigned int index = column * maxRow + row;
      calib_rpix_digi_map_.insert(std::pair<unsigned int, RPixCalibDigi>(index, calibDigi));
      SeedVector_.push_back(calibDigi);
    }
  }
  if (verbosity_)
    edm::LogInfo("RPixDetClusterizer") << " RPix set size = " << calib_rpix_digi_map_.size();

  for (auto SeedIt : SeedVector_) {
    make_cluster(SeedIt, clusters);
  }
}

calibrate()

int RPixDetClusterizer::calibrate	(	unsigned int	detId,
		int	adc,
		int	row,
		int	col,
		const CTPPSPixelGainCalibrations *	pcalibration
	)

Definition at line 147 of file RPixDetClusterizer.cc.

References gpuClustering::adc, cuy::col, hcalRecHitTable_cff::detId, doSingleCalibration_, ElectronADCGain_, pwdgSkimBPark_cfi::electrons, PedestalClient_cfi::gain, CTPPSPixelGainCalibration::getDetId(), CTPPSPixelGainCalibration::getGain(), CTPPSPixelGainCalibrations::getGainCalibration(), CTPPSPixelGainCalibration::getPed(), createfilelist::int, EcalCondDBWriter_cfi::pedestal, VcaltoElectronGain_, VcaltoElectronOffset_, and verbosity_.

Referenced by buildClusters().

                                                                                                    {
  float gain = 0;
  float pedestal = 0;
  int electrons = 0;

  if (!doSingleCalibration_) {
    const CTPPSPixelGainCalibration &DetCalibs = pcalibrations->getGainCalibration(detId);

    if (DetCalibs.getDetId() != 0) {
      gain = DetCalibs.getGain(col, row) * highRangeCal / lowRangeCal;
      pedestal = DetCalibs.getPed(col, row);
      float vcal = (adc - pedestal) * gain;
      electrons = int(vcal * VcaltoElectronGain_ + VcaltoElectronOffset_);
    } else {
      gain = ElectronADCGain_;
      pedestal = 0;
      electrons = int(adc * gain - pedestal);
    }

    if (verbosity_)
      edm::LogInfo("RPixCalibration") << "calibrate:  adc = " << adc << " electrons = " << electrons
                                      << " gain = " << gain << " pedestal = " << pedestal;
  } else {
    gain = ElectronADCGain_;
    pedestal = 0;
    electrons = int(adc * gain - pedestal);
    if (verbosity_)
      edm::LogInfo("RPixCalibration") << "calibrate:  adc = " << adc << " electrons = " << electrons
                                      << " ElectronADCGain = " << gain << " pedestal = " << pedestal;
  }
  if (electrons < 0) {
    edm::LogInfo("RPixCalibration") << "RPixDetClusterizer::calibrate: *** electrons < 0 *** --> " << electrons
                                    << "  --> electrons = 0";
    electrons = 0;
  }

  return electrons;
}

make_cluster()

void RPixDetClusterizer::make_cluster	(	RPixCalibDigi const &	aSeed,
		std::vector< CTPPSPixelCluster > &	clusters
	)

check if seed already used

Definition at line 108 of file RPixDetClusterizer.cc.

References RPixTempCluster::adc, RPixTempCluster::addPixel(), HltBtagPostValidation_cff::c, calib_rpix_digi_map_, bsc_activity_cfg::clusters, RPixTempCluster::col, CTPPSPixelDigi::column(), RPixCalibDigi::electrons(), RPixTempCluster::empty(), RPixTempCluster::isize, SiStripPI::max, SiStripPI::min, RPixTempCluster::pop(), alignCSCRings::r, CTPPSPixelDigi::row(), RPixTempCluster::row, and RPixTempCluster::top().

Referenced by buildClusters().

                                                                                                        {
  unsigned int seedIndex = aSeed.column() * maxRow + aSeed.row();
  if (calib_rpix_digi_map_.find(seedIndex) == calib_rpix_digi_map_.end()) {
    return;
  }
  // creating a temporary cluster
  RPixTempCluster atempCluster;

  // filling the cluster with the seed
  atempCluster.addPixel(aSeed.row(), aSeed.column(), aSeed.electrons());
  calib_rpix_digi_map_.erase(seedIndex);

  while (!atempCluster.empty()) {
    //This is the standard algorithm to find and add a pixel
    auto curInd = atempCluster.top();
    atempCluster.pop();
    for (auto c = std::max(0, int(atempCluster.col[curInd]) - 1);
         c < std::min(int(atempCluster.col[curInd]) + 2, maxCol);
         ++c) {
      for (auto r = std::max(0, int(atempCluster.row[curInd]) - 1);
           r < std::min(int(atempCluster.row[curInd]) + 2, maxRow);
           ++r) {
        unsigned int currIndex = c * maxRow + r;
        if (calib_rpix_digi_map_.find(currIndex) != calib_rpix_digi_map_.end()) {
          if (!atempCluster.addPixel(r, c, calib_rpix_digi_map_[currIndex].electrons())) {
            clusters.emplace_back(atempCluster.isize, atempCluster.adc, atempCluster.row, atempCluster.col);
            return;
          }
          calib_rpix_digi_map_.erase(currIndex);
        }
      }
    }

  }  // while accretion

  clusters.emplace_back(atempCluster.isize, atempCluster.adc, atempCluster.row, atempCluster.col);
}

Member Data Documentation

ADCThreshold_

unsigned short RPixDetClusterizer::ADCThreshold_

private

Definition at line 59 of file RPixDetClusterizer.h.

Referenced by RPixDetClusterizer().

calib_rpix_digi_map_

std::map<unsigned int, RPixCalibDigi> RPixDetClusterizer::calib_rpix_digi_map_

private

Definition at line 56 of file RPixDetClusterizer.h.

Referenced by buildClusters(), and make_cluster().

CalibrationFile_

std::string RPixDetClusterizer::CalibrationFile_

private

Definition at line 64 of file RPixDetClusterizer.h.

doSingleCalibration_

bool RPixDetClusterizer::doSingleCalibration_

private

Definition at line 63 of file RPixDetClusterizer.h.

Referenced by calibrate(), and RPixDetClusterizer().

ElectronADCGain_

double RPixDetClusterizer::ElectronADCGain_

private

Definition at line 60 of file RPixDetClusterizer.h.

Referenced by buildClusters(), calibrate(), and RPixDetClusterizer().

rpix_digi_set_

std::set<CTPPSPixelDigi> RPixDetClusterizer::rpix_digi_set_

private

Definition at line 55 of file RPixDetClusterizer.h.

Referenced by buildClusters().

SeedADCThreshold_

unsigned short RPixDetClusterizer::SeedADCThreshold_

private

Definition at line 58 of file RPixDetClusterizer.h.

Referenced by buildClusters(), and RPixDetClusterizer().

SeedVector_

std::vector<RPixCalibDigi> RPixDetClusterizer::SeedVector_

private

Definition at line 65 of file RPixDetClusterizer.h.

Referenced by buildClusters().

VcaltoElectronGain_

int RPixDetClusterizer::VcaltoElectronGain_

private

Definition at line 61 of file RPixDetClusterizer.h.

Referenced by calibrate(), and RPixDetClusterizer().

VcaltoElectronOffset_

int RPixDetClusterizer::VcaltoElectronOffset_

private

Definition at line 62 of file RPixDetClusterizer.h.

Referenced by calibrate(), and RPixDetClusterizer().

verbosity_

int RPixDetClusterizer::verbosity_

private

Definition at line 57 of file RPixDetClusterizer.h.

Referenced by buildClusters(), calibrate(), and RPixDetClusterizer().