#include <StripClusterizerAlgorithm.h>

Inheritance diagram for StripClusterizerAlgorithm:

Classes
struct	Det

struct	Index

struct	InvalidChargeException

struct	State

Public Types
typedef edmNew::DetSetVector< SiStripCluster >	output_t

Public Member Functions
std::vector< uint32_t > const &	allDetIds () const

SiStripDetCabling const *	cabling () const

void	clusterize (const edm::DetSetVector< SiStripDigi > &, output_t &) const

void	clusterize (const edmNew::DetSetVector< SiStripDigi > &, output_t &) const

virtual void	clusterizeDetUnit (const edm::DetSet< SiStripDigi > &, output_t::TSFastFiller &) const =0

virtual void	clusterizeDetUnit (const edmNew::DetSet< SiStripDigi > &, output_t::TSFastFiller &) const =0

std::vector< const FedChannelConnection * > const &	currentConnection (const Det &det) const

virtual void	initialize (const edm::EventSetup &)

virtual void	stripByStripAdd (State &state, uint16_t strip, uint8_t adc, output_t::TSFastFiller &out) const

virtual void	stripByStripAdd (State &state, uint16_t strip, uint8_t adc, std::vector< SiStripCluster > &out) const

virtual Det	stripByStripBegin (uint32_t id) const =0

virtual void	stripByStripEnd (State &state, output_t::TSFastFiller &out) const

virtual void	stripByStripEnd (State &state, std::vector< SiStripCluster > &out) const

virtual	~StripClusterizerAlgorithm ()

Static Public Attributes
static constexpr unsigned short	invalidI = std::numeric_limits<unsigned short>::max()

Protected Member Functions
Det	findDetId (const uint32_t) const

bool	isModuleBad (const uint32_t &id) const

bool	isModuleUsable (const uint32_t &id) const

	StripClusterizerAlgorithm ()

Protected Attributes
std::string	qualityLabel

Private Member Functions
template<class T >
void	clusterize_ (const T &input, output_t &output) const

Private Attributes
std::vector< std::vector< const FedChannelConnection * > >	connections

std::vector< uint32_t >	detIds

uint32_t	gain_cache_id

edm::ESHandle< SiStripGain >	gainHandle

std::vector< Index >	indices

uint32_t	noise_cache_id

edm::ESHandle< SiStripNoises >	noiseHandle

uint32_t	quality_cache_id

edm::ESHandle< SiStripQuality >	qualityHandle

SiStripDetCabling const *	theCabling = nullptr

Detailed Description

Definition at line 20 of file StripClusterizerAlgorithm.h.

Member Typedef Documentation

◆ output_t

typedef edmNew::DetSetVector<SiStripCluster> StripClusterizerAlgorithm::output_t

Definition at line 60 of file StripClusterizerAlgorithm.h.

Constructor & Destructor Documentation

◆ ~StripClusterizerAlgorithm()

virtual StripClusterizerAlgorithm::~StripClusterizerAlgorithm ( )

inlinevirtual

Definition at line 56 of file StripClusterizerAlgorithm.h.

56 {}

◆ StripClusterizerAlgorithm()

StripClusterizerAlgorithm::StripClusterizerAlgorithm ( )

inlineprotected

Definition at line 88 of file StripClusterizerAlgorithm.h.

88 : qualityLabel(""), noise_cache_id(0), gain_cache_id(0), quality_cache_id(0) {}

Member Function Documentation

◆ allDetIds()

std::vector<uint32_t> const& StripClusterizerAlgorithm::allDetIds ( ) const

inline

Definition at line 81 of file StripClusterizerAlgorithm.h.

81 { return detIds; }

References detIds.

◆ cabling()

SiStripDetCabling const* StripClusterizerAlgorithm::cabling ( ) const

inline

Definition at line 80 of file StripClusterizerAlgorithm.h.

80 { return theCabling; }

References theCabling.

Referenced by initialize().

◆ clusterize() [1/2]

void StripClusterizerAlgorithm::clusterize	(	const edm::DetSetVector< SiStripDigi > &	input,
		output_t &	output
	)		const

Definition at line 196 of file StripClusterizerAlgorithm.cc.

                                                                                                             {
   clusterize_(input, output);
 }

References clusterize_(), input, and convertSQLitetoXML_cfg::output.

◆ clusterize() [2/2]

void StripClusterizerAlgorithm::clusterize	(	const edmNew::DetSetVector< SiStripDigi > &	input,
		output_t &	output
	)		const

Definition at line 199 of file StripClusterizerAlgorithm.cc.

                                                                                                                {
   clusterize_(input, output);
 }

References clusterize_(), input, and convertSQLitetoXML_cfg::output.

◆ clusterize_()

template<class T >

void StripClusterizerAlgorithm::clusterize_	(	const T &	input,
		output_t &	output
	)		const

inlineprivate

Definition at line 98 of file StripClusterizerAlgorithm.h.

                                                            {
     for (typename T::const_iterator it = input.begin(); it != input.end(); it++) {
       output_t::TSFastFiller ff(output, it->detId());
       clusterizeDetUnit(*it, ff);
       if (ff.empty())
         ff.abort();
     }
   }

References clusterizeDetUnit(), alignCSCRings::ff, input, and convertSQLitetoXML_cfg::output.

Referenced by clusterize().

◆ clusterizeDetUnit() [1/2]

virtual void StripClusterizerAlgorithm::clusterizeDetUnit	(	const edm::DetSet< SiStripDigi > &	,
		output_t::TSFastFiller &
	)		const

pure virtual

Implemented in ThreeThresholdAlgorithm.

Referenced by clusterize_().

◆ clusterizeDetUnit() [2/2]

virtual void StripClusterizerAlgorithm::clusterizeDetUnit	(	const edmNew::DetSet< SiStripDigi > &	,
		output_t::TSFastFiller &
	)		const

pure virtual

Implemented in ThreeThresholdAlgorithm.

◆ currentConnection()

std::vector<const FedChannelConnection*> const& StripClusterizerAlgorithm::currentConnection ( const Det & det ) const

inline

Definition at line 83 of file StripClusterizerAlgorithm.h.

                                                                                         {
     return connections[det.ind];
   }

References connections, and StripClusterizerAlgorithm::Det::ind.

◆ findDetId()

StripClusterizerAlgorithm::Det StripClusterizerAlgorithm::findDetId ( const uint32_t id ) const

protected

Definition at line 161 of file StripClusterizerAlgorithm.cc.

                                                                                          {
   auto b = detIds.begin();
   auto e = detIds.end();
   auto p = std::lower_bound(b, e, id);
   if (p == e || id != (*p)) {
 #ifdef NOT_ON_MONTECARLO
     edm::LogWarning("StripClusterizerAlgorithm") << "id " << id << " not connected. this is impossible on data "
                                                  << "old id " << detId << std::endl;
 #endif
     return Det();
   }
   Det det;
   det.ind = p - detIds.begin();
  
   det.detId = id;
   det.noiseRange = noiseHandle->getRangeByPos(indices[det.ind].ni);
   det.gainRange = gainHandle->getRangeByPos(indices[det.ind].gi);
   det.qualityRange = qualityHandle->getRangeByPos(indices[det.ind].qi);
   det.quality = qualityHandle.product();
  
 #ifdef EDM_ML_DEBUG
   assert(detIds[det.ind] == det.detId);
   auto oldg = gainHandle->getRange(id);
   assert(oldg == det.gainRange);
   auto oldn = noiseHandle->getRange(id);
   assert(oldn == det.noiseRange);
   auto oldq = qualityHandle->getRange(id);
   assert(oldq == det.qualityRange);
 #endif
 #ifdef EDM_ML_DEBUG
   assert(isModuleUsable(id));
 #endif
   return det;
 }

References cms::cuda::assert(), b, StripClusterizerAlgorithm::Det::detId, detIds, MillePedeFileConverter_cfg::e, gainHandle, StripClusterizerAlgorithm::Det::gainRange, SiStripNoises::getRange(), SiStripBadStrip::getRange(), SiStripGain::getRange(), SiStripNoises::getRangeByPos(), SiStripBadStrip::getRangeByPos(), SiStripGain::getRangeByPos(), triggerObjects_cff::id, StripClusterizerAlgorithm::Det::ind, indices, isModuleUsable(), cuda_std::lower_bound(), noiseHandle, StripClusterizerAlgorithm::Det::noiseRange, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< T >::product(), StripClusterizerAlgorithm::Det::quality, qualityHandle, and StripClusterizerAlgorithm::Det::qualityRange.

Referenced by ThreeThresholdAlgorithm::clusterizeDetUnit_(), and ThreeThresholdAlgorithm::stripByStripBegin().

◆ initialize()

void StripClusterizerAlgorithm::initialize ( const edm::EventSetup & es )

virtual

Definition at line 24 of file StripClusterizerAlgorithm.cc.

                                                                   {
   uint32_t n_cache_id = es.get<SiStripNoisesRcd>().cacheIdentifier();
   uint32_t g_cache_id = es.get<SiStripGainRcd>().cacheIdentifier();
   uint32_t q_cache_id = es.get<SiStripQualityRcd>().cacheIdentifier();
  
   bool mod = false;
   if (g_cache_id != gain_cache_id) {
     es.get<SiStripGainRcd>().get(gainHandle);
     gain_cache_id = g_cache_id;
     mod = true;
   }
   if (n_cache_id != noise_cache_id) {
     es.get<SiStripNoisesRcd>().get(noiseHandle);
     noise_cache_id = n_cache_id;
     mod = true;
   }
   if (q_cache_id != quality_cache_id) {
     es.get<SiStripQualityRcd>().get(qualityLabel, qualityHandle);
     quality_cache_id = q_cache_id;
     mod = true;
   }
  
   if (mod) {
     // redo indexing!
     theCabling = qualityHandle->cabling();
     assert(theCabling);
     auto const& conn = cabling()->connected();
     COUT << "cabling " << conn.size() << std::endl;
     detIds.clear();
     detIds.reserve(conn.size());
     for (auto const& c : conn) {
       if (!isModuleBad(c.first))
         detIds.push_back(c.first);
     }
     indices.clear();
     indices.resize(detIds.size());
     COUT << "good detIds " << detIds.size() << std::endl;
  
     if (detIds.empty())
       return;
  
     {
       connections.clear();
       connections.resize(detIds.size());
       //connections (slow, not a big deal)
       auto const& conns = cabling()->getDetCabling();
       for (auto i = 0U; i < detIds.size(); ++i) {
         auto c = conns.find(detIds[i]);
         if (c != conns.end())
           connections[i] = (*c).second;
       }
     }
  
     {  // quality
       std::vector<uint32_t> dum;
       qualityHandle->getDetIds(dum);
       assert(dum.size() < invalidI);
       unsigned short j = 0, i = 0;
       while (i < dum.size() && j < detIds.size()) {
         if (dum[i] < detIds[j])
           ++i;
         else if (detIds[j] < dum[i]) {
           indices[j].qi = invalidI;
           ++j;
         } else {
           indices[j].qi = i;
           ++i;
           ++j;
         }
       }
       unsigned int nn = 0;
       for (auto k = 0U; k < detIds.size(); ++k) {
         if (indices[k].qi < invalidI) {
           ++nn;
           assert(dum[indices[k].qi] == detIds[k]);
         }
       }
       assert(nn <= dum.size());
       COUT << "quality " << dum.size() << " " << nn << std::endl;
     }
     {  //noise
       std::vector<uint32_t> dum;
       noiseHandle->getDetIds(dum);
       assert(dum.size() < invalidI);
       unsigned short j = 0, i = 0;
       while (i < dum.size() && j < detIds.size()) {
         if (dum[i] < detIds[j])
           ++i;
         else if (detIds[j] < dum[i]) {
           indices[j].ni = invalidI;
           ++j;
         } else {
           indices[j].ni = i;
           ++i;
           ++j;
         }
       }
       unsigned int nn = 0;
       for (auto k = 0U; k < detIds.size(); ++k) {
         if (indices[k].ni < invalidI) {
           ++nn;
           assert(dum[indices[k].ni] == detIds[k]);
         }
       }
       assert(nn <= dum.size());
       COUT << "noise " << dum.size() << " " << nn << std::endl;
     }
     {  //gain
       std::vector<uint32_t> dum;
       gainHandle->getDetIds(dum);
       assert(dum.size() < invalidI);
       unsigned short j = 0, i = 0;
       while (i < dum.size() && j < detIds.size()) {
         if (dum[i] < detIds[j])
           ++i;
         else if (detIds[j] < dum[i]) {
           indices[j].gi = invalidI;
           ++j;
         } else {
           indices[j].gi = i;
           ++i;
           ++j;
         }
       }
       unsigned int nn = 0;
       for (auto k = 0U; k < detIds.size(); ++k) {
         if (indices[k].gi < invalidI) {
           ++nn;
           assert(dum[indices[k].gi] == detIds[k]);
         }
       }
       assert(nn <= dum.size());
       COUT << "gain " << dum.size() << " " << nn << std::endl;
     }
   }
 }