#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_

const edm::ParameterSet &	params_

std::set< CTPPSPixelDigi >	rpix_digi_set_

unsigned short	SeedADCThreshold_

std::vector< RPixCalibDigi >	SeedVector_

int	VcaltoElectronGain_

int	VcaltoElectronOffset_

int	verbosity_

Detailed Description

Definition at line 52 of file RPixDetClusterizer.h.

Constructor & Destructor Documentation

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

Definition at line 15 of file RPixDetClusterizer.cc.

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

                                                                  :
   params_(conf), 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 ( )

Definition at line 28 of file RPixDetClusterizer.cc.

28 {}

Member Function Documentation

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

Definition at line 30 of file RPixDetClusterizer.cc.

References ecalMGPA::adc(), CTPPSPixelAnalysisMask::analysisMask, calib_rpix_digi_map_, calibrate(), ElectronADCGain_, electrons_cff::electrons, Exception, make_cluster(), RecoTauDiscriminantConfiguration::mask, digitizers_cfi::pixel, rpix_digi_set_, SeedADCThreshold_, SeedVector_, and verbosity_.

Referenced by CTPPSPixelClusterProducer::run().

 {
 
   std::map<uint32_t, CTPPSPixelROCAnalysisMask> const & mask = maskera->analysisMask;
   std::map<uint32_t, CTPPSPixelROCAnalysisMask>::const_iterator mask_it = mask.find(detId); 
 
   std::set<std::pair<unsigned char, unsigned char> > maskedPixels;
   if( mask_it != mask.end()) maskedPixels = mask_it->second.maskedPixels;
 
   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();
     if(!is_in){
 //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);
   }
 }

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

Definition at line 120 of file RPixDetClusterizer.cc.

References doSingleCalibration_, ElectronADCGain_, electrons_cff::electrons, muonCSCDigis_cfi::gain, CTPPSPixelGainCalibration::getDetId(), CTPPSPixelGainCalibration::getGain(), CTPPSPixelGainCalibrations::getGainCalibration(), CTPPSPixelGainCalibration::getPed(), createfilelist::int, muonCSCDigis_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;
 
 }

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

check if seed already used

Definition at line 81 of file RPixDetClusterizer.cc.

References RPixTempCluster::adc, RPixTempCluster::addPixel(), EnergyCorrector::c, calib_rpix_digi_map_, RPixTempCluster::col, CTPPSPixelDigi::column(), RPixCalibDigi::electrons(), RPixTempCluster::empty(), RPixTempCluster::isize, SiStripPI::max, 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() )) {
         CTPPSPixelCluster acluster(atempCluster.isize,atempCluster.adc, atempCluster.row,atempCluster.col);
         clusters.push_back(acluster);
         return;
       }
       calib_rpix_digi_map_.erase(currIndex);
     }
  
       }
     }
          
   }  // while accretion
 
   CTPPSPixelCluster cluster(atempCluster.isize,atempCluster.adc, atempCluster.row,atempCluster.col);
   clusters.push_back(cluster);
 }