utility class to assign dense readout module indexing the class holds the information on the expected readout sequence (module types) per FED and their offset in the SoAs of data More...

#include <HGCalMappingModuleIndexer.h>

Public Member Functions
void	finalize ()

uint32_t	getIndexForModule (uint32_t fedid, uint32_t nmod) const
	returns the index for the n-th module in the readout sequence of a FED if the index in the readout sequence is unknown alternative methods which take the (capture block, econd idx) are provided which will find first what should be the internal dense index (index in the readout sequence) More...

uint32_t	getIndexForModule (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx) const

uint32_t	getIndexForModuleData (uint32_t fedid, uint32_t nmod, uint32_t erxidx, uint32_t chidx) const

uint32_t	getIndexForModuleData (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx, uint32_t erxidx, uint32_t chidx) const

uint32_t	getIndexForModuleErx (uint32_t fedid, uint32_t nmod, uint32_t erxidx) const

uint32_t	getIndexForModuleErx (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx, uint32_t erxidx) const

int	getTypeForModule (uint32_t fedid, uint32_t nmod) const

int	getTypeForModule (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx) const
	internal indexer More...

	HGCalMappingModuleIndexer ()

void	processNewModule (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx, uint32_t typecodeIdx, uint32_t nerx, uint32_t nwords)
	for a new module it adds it's type to the readaout sequence vector if the fed id is not yet existing in the mapping it's added a dense indexer is used to create the necessary indices for the new module unused indices will be set with -1 More...

	~HGCalMappingModuleIndexer ()=default

Static Public Member Functions
static std::pair< bool, int >	convertTypeCode (std::string_view typecode)
	decodes silicon or sipm type and cell type for the detector id from the typecode string More...

Public Attributes
std::vector< uint32_t >	dataOffsets_
	global counters (sizes of vectors) More...

std::vector< uint32_t >	erxOffsets_

std::vector< HGCalFEDReadoutSequence_t >	fedReadoutSequences_
	global counters for types of modules, number of e-Rx and words More...

std::vector< uint32_t >	globalTypesCounter_

std::vector< uint32_t >	globalTypesNErx_

std::vector< uint32_t >	globalTypesNWords_
	base offsets to apply per module type with different granularity : module, e-Rx, channel data More...

uint32_t	maxDataIdx_

uint32_t	maxErxIdx_

uint32_t	maxModulesIdx_
	max number of main buffers/capture blocks per FED More...

HGCalDenseIndexerBase	modFedIndexer_
	the sequence of FED readout sequence descriptors More...

std::vector< uint32_t >	moduleOffsets_

uint32_t	nfeds_

Static Public Attributes
static constexpr uint32_t	maxCBperFED_ = 10
	max number of ECON-Ds processed by a main buffer/capture block More...

static constexpr uint32_t	maxECONDperCB_ = 12

Private Member Functions
uint32_t	denseIndexingFor (uint32_t fedid, uint16_t captureblockIdx, uint16_t econdIdx) const
	given capture block and econd indices returns the dense indexer More...

template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Friends
class	boost::serialization::access

template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

utility class to assign dense readout module indexing the class holds the information on the expected readout sequence (module types) per FED and their offset in the SoAs of data

Definition at line 34 of file HGCalMappingModuleIndexer.h.

Constructor & Destructor Documentation

◆ HGCalMappingModuleIndexer()

HGCalMappingModuleIndexer::HGCalMappingModuleIndexer ( )

inline

Definition at line 36 of file HGCalMappingModuleIndexer.h.

References maxCBperFED_, and maxECONDperCB_.

36 : modFedIndexer_({maxCBperFED_, maxECONDperCB_}) {}

HGCalMappingModuleIndexer::maxCBperFED_

static constexpr uint32_t maxCBperFED_

max number of ECON-Ds processed by a main buffer/capture block

Definition: HGCalMappingModuleIndexer.h:211

HGCalMappingModuleIndexer::maxECONDperCB_

static constexpr uint32_t maxECONDperCB_

Definition: HGCalMappingModuleIndexer.h:213

HGCalMappingModuleIndexer::modFedIndexer_

HGCalDenseIndexerBase modFedIndexer_

the sequence of FED readout sequence descriptors

Definition: HGCalMappingModuleIndexer.h:200

◆ ~HGCalMappingModuleIndexer()

HGCalMappingModuleIndexer::~HGCalMappingModuleIndexer ( )

default

Member Function Documentation

◆ convertTypeCode()

static std::pair<bool, int> HGCalMappingModuleIndexer::convertTypeCode ( std::string_view typecode )

inlinestatic

decodes silicon or sipm type and cell type for the detector id from the typecode string

Definition at line 151 of file HGCalMappingModuleIndexer.h.

References HcalObjRepresent::isSiPM(), and funct::true.

                                                                      {
     if (typecode.size() < 5)
       throw cms::Exception("InvalidHGCALTypeCode") << typecode << " is invalid for decoding readout cell type";
 
     bool isSiPM = {typecode.find("TM") != std::string::npos ? true : false};
     int celltype;
     if (isSiPM) {
       celltype = 0;  // Assign SiPM type coarse or molded with next version of modulelocator
     } else {
       celltype = {typecode[4] == '1' ? 0 : typecode[4] == '2' ? 1 : 2};
     }
     return std::pair<bool, bool>(isSiPM, celltype);
   }

◆ denseIndexingFor()

uint32_t HGCalMappingModuleIndexer::denseIndexingFor	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx
	)		const

inlineprivate

given capture block and econd indices returns the dense indexer

Definition at line 219 of file HGCalMappingModuleIndexer.h.

References HGCalDenseIndexerBase::denseIndex(), Exception, PixelSLinkDataInputSource_cfi::fedid, fedReadoutSequences_, heavyIonCSV_trainingSettings::idx, modFedIndexer_, and nfeds_.

Referenced by getIndexForModule(), getIndexForModuleData(), getIndexForModuleErx(), and getTypeForModule().

                                                                                                {
     if (fedid > nfeds_)
       throw cms::Exception("ValueError") << "FED ID=" << fedid << " is unknown to current mapping";
     uint32_t idx = modFedIndexer_.denseIndex({{captureblockIdx, econdIdx}});
     auto dense_idx = fedReadoutSequences_[fedid].moduleLUT_[idx];
     if (dense_idx < 0)
       throw cms::Exception("ValueError") << "FED ID=" << fedid << " capture block=" << captureblockIdx
                                          << " econ=" << econdIdx << "has not been assigned a dense indexing"
                                          << std::endl;
     return uint32_t(dense_idx);
   }

◆ finalize()

void HGCalMappingModuleIndexer::finalize ( )

inline

Definition at line 81 of file HGCalMappingModuleIndexer.h.

References dataOffsets_, erxOffsets_, fedReadoutSequences_, globalTypesCounter_, globalTypesNErx_, globalTypesNWords_, mps_fire::i, maxDataIdx_, maxErxIdx_, maxModulesIdx_, moduleOffsets_, nfeds_, and heppy_batch::val.

Referenced by HGCalMappingESProducer::prepareModuleMapperIndexer().

                   {
     //max indices at different levels
     nfeds_ = fedReadoutSequences_.size();
     maxModulesIdx_ = std::accumulate(globalTypesCounter_.begin(), globalTypesCounter_.end(), 0);
     maxErxIdx_ =
         std::inner_product(globalTypesCounter_.begin(), globalTypesCounter_.end(), globalTypesNErx_.begin(), 0);
     maxDataIdx_ =
         std::inner_product(globalTypesCounter_.begin(), globalTypesCounter_.end(), globalTypesNWords_.begin(), 0);
 
     //compute the global offset to assign per board type, eRx and channel data
     moduleOffsets_.resize(maxModulesIdx_, 0);
     erxOffsets_.resize(maxModulesIdx_, 0);
     dataOffsets_.resize(maxModulesIdx_, 0);
     for (size_t i = 1; i < globalTypesCounter_.size(); i++) {
       moduleOffsets_[i] = globalTypesCounter_[i - 1];
       erxOffsets_[i] = globalTypesCounter_[i - 1] * globalTypesNErx_[i - 1];
       dataOffsets_[i] = globalTypesCounter_[i - 1] * globalTypesNWords_[i - 1];
     }
     std::partial_sum(moduleOffsets_.begin(), moduleOffsets_.end(), moduleOffsets_.begin());
     std::partial_sum(erxOffsets_.begin(), erxOffsets_.end(), erxOffsets_.begin());
     std::partial_sum(dataOffsets_.begin(), dataOffsets_.end(), dataOffsets_.begin());
 
     //now go through the FEDs and ascribe the offsets per module in the readout sequence
     std::vector<uint32_t> typeCounters(globalTypesCounter_.size(), 0);
     for (auto &fedit : fedReadoutSequences_) {
       //assign the indexing in the look-up table
       size_t nconn(0);
       fedit.moduleLUT_.resize(fedit.readoutTypes_.size(), -1);
       for (size_t i = 0; i < fedit.readoutTypes_.size(); i++) {
         if (fedit.readoutTypes_[i] == -1)
           continue;  //unexisting
         fedit.moduleLUT_[i] = nconn;
         nconn++;
       }
 
       //remove unexisting ECONs building a final compact readout sequence
       std::remove_if(
           fedit.readoutTypes_.begin(), fedit.readoutTypes_.end(), [&](int val) -> bool { return val == -1; });
 
       //assign the final offsets at the different levels
       size_t nmods = fedit.readoutTypes_.size();
       fedit.modOffsets_.resize(nmods, 0);
       fedit.erxOffsets_.resize(nmods, 0);
       fedit.chDataOffsets_.resize(nmods, 0);
       for (size_t i = 0; i < nmods; i++) {
         uint32_t type_val = fedit.readoutTypes_[i];
 
         //module offset : global offset for this type + current index for this type
         uint32_t baseMod_offset = moduleOffsets_[type_val] + typeCounters[type_val];
         fedit.modOffsets_[i] = baseMod_offset;  // + internalMod_offset;
 
         //erx-level offset : global offset of e-Rx of this type + #e-Rrx * current index for this type
         uint32_t baseErx_offset = erxOffsets_[type_val];
         uint32_t internalErx_offset = globalTypesNErx_[type_val] * typeCounters[type_val];
         fedit.erxOffsets_[i] = baseErx_offset + internalErx_offset;
 
         //channel data offset: global offset for data of this type + #words * current index for this type
         uint32_t baseData_offset = dataOffsets_[type_val];
         uint32_t internalData_offset = globalTypesNWords_[type_val] * typeCounters[type_val];
         fedit.chDataOffsets_[i] = baseData_offset + internalData_offset;
 
         typeCounters[type_val]++;
       }
     }
   }

◆ getIndexForModule() [1/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModule	(	uint32_t	fedid,
		uint32_t	nmod
	)		const

inline

returns the index for the n-th module in the readout sequence of a FED if the index in the readout sequence is unknown alternative methods which take the (capture block, econd idx) are provided which will find first what should be the internal dense index (index in the readout sequence)

Definition at line 170 of file HGCalMappingModuleIndexer.h.

References PixelSLinkDataInputSource_cfi::fedid, and fedReadoutSequences_.

Referenced by getIndexForModule().

                                                                   {
     return fedReadoutSequences_[fedid].modOffsets_[nmod];
   };

◆ getIndexForModule() [2/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModule	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx
	)		const

inline

Definition at line 173 of file HGCalMappingModuleIndexer.h.

References denseIndexingFor(), PixelSLinkDataInputSource_cfi::fedid, and getIndexForModule().

                                                                                                 {
     uint32_t nmod = denseIndexingFor(fedid, captureblockIdx, econdIdx);
     return getIndexForModule(fedid, nmod);
   };

◆ getIndexForModuleData() [1/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModuleData	(	uint32_t	fedid,
		uint32_t	nmod,
		uint32_t	erxidx,
		uint32_t	chidx
	)		const

inline

Definition at line 184 of file HGCalMappingModuleIndexer.h.

References PixelSLinkDataInputSource_cfi::fedid, fedReadoutSequences_, and HGCalMappingCellIndexer::maxChPerErx_.

Referenced by getIndexForModuleData().

                                                                                                        {
     return fedReadoutSequences_[fedid].chDataOffsets_[nmod] + erxidx * HGCalMappingCellIndexer::maxChPerErx_ + chidx;
   };

◆ getIndexForModuleData() [2/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModuleData	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx,
		uint32_t	erxidx,
		uint32_t	chidx
	)		const

inline

Definition at line 187 of file HGCalMappingModuleIndexer.h.

References denseIndexingFor(), PixelSLinkDataInputSource_cfi::fedid, and getIndexForModuleData().

                                                                                                           {
     uint32_t nmod = denseIndexingFor(fedid, captureblockIdx, econdIdx);
     return getIndexForModuleData(fedid, nmod, erxidx, chidx);
   };

◆ getIndexForModuleErx() [1/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModuleErx	(	uint32_t	fedid,
		uint32_t	nmod,
		uint32_t	erxidx
	)		const

inline

Definition at line 177 of file HGCalMappingModuleIndexer.h.

References PixelSLinkDataInputSource_cfi::fedid, and fedReadoutSequences_.

Referenced by getIndexForModuleErx().

                                                                                       {
     return fedReadoutSequences_[fedid].erxOffsets_[nmod] + erxidx;
   };

◆ getIndexForModuleErx() [2/2]

uint32_t HGCalMappingModuleIndexer::getIndexForModuleErx	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx,
		uint32_t	erxidx
	)		const

inline

Definition at line 180 of file HGCalMappingModuleIndexer.h.

References denseIndexingFor(), PixelSLinkDataInputSource_cfi::fedid, and getIndexForModuleErx().

                                                                                                                     {
     uint32_t nmod = denseIndexingFor(fedid, captureblockIdx, econdIdx);
     return getIndexForModuleErx(fedid, nmod, erxidx);
   }

◆ getTypeForModule() [1/2]

int HGCalMappingModuleIndexer::getTypeForModule	(	uint32_t	fedid,
		uint32_t	nmod
	)		const

inline

Definition at line 193 of file HGCalMappingModuleIndexer.h.

References PixelSLinkDataInputSource_cfi::fedid, and fedReadoutSequences_.

Referenced by getTypeForModule().

193 { return fedReadoutSequences_[fedid].readoutTypes_[nmod]; }

HGCalMappingModuleIndexer::fedReadoutSequences_

std::vector< HGCalFEDReadoutSequence_t > fedReadoutSequences_

global counters for types of modules, number of e-Rx and words

Definition: HGCalMappingModuleIndexer.h:202

PixelSLinkDataInputSource_cfi.fedid

fedid

Definition: PixelSLinkDataInputSource_cfi.py:6

◆ getTypeForModule() [2/2]

int HGCalMappingModuleIndexer::getTypeForModule	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx
	)		const

inline

internal indexer

Definition at line 194 of file HGCalMappingModuleIndexer.h.

References denseIndexingFor(), PixelSLinkDataInputSource_cfi::fedid, and getTypeForModule().

◆ processNewModule()

void HGCalMappingModuleIndexer::processNewModule	(	uint32_t	fedid,
		uint16_t	captureblockIdx,
		uint16_t	econdIdx,
		uint32_t	typecodeIdx,
		uint32_t	nerx,
		uint32_t	nwords
	)

inline

for a new module it adds it's type to the readaout sequence vector if the fed id is not yet existing in the mapping it's added a dense indexer is used to create the necessary indices for the new module unused indices will be set with -1

Definition at line 46 of file HGCalMappingModuleIndexer.h.

References dataOffsets_, HGCalDenseIndexerBase::denseIndex(), PixelSLinkDataInputSource_cfi::fedid, fedReadoutSequences_, globalTypesCounter_, globalTypesNErx_, globalTypesNWords_, HGCalFEDReadoutSequence_t::id, heavyIonCSV_trainingSettings::idx, modFedIndexer_, and HGCalFEDReadoutSequence_t::readoutTypes_.

Referenced by HGCalMappingESProducer::prepareModuleMapperIndexer().

                                          {
     //add fed if needed
     if (fedid >= fedReadoutSequences_.size()) {
       fedReadoutSequences_.resize(fedid + 1);
     }
     HGCalFEDReadoutSequence_t &frs = fedReadoutSequences_[fedid];
     frs.id = fedid;
 
     //assign position, resize if needed, and fill the type code
     uint32_t idx = modFedIndexer_.denseIndex({{captureblockIdx, econdIdx}});
     if (idx >= frs.readoutTypes_.size()) {
       frs.readoutTypes_.resize(idx + 1, -1);
     }
     frs.readoutTypes_[idx] = typecodeIdx;
 
     //count another typecodein the global list
     if (typecodeIdx >= globalTypesCounter_.size()) {
       globalTypesCounter_.resize(typecodeIdx + 1, 0);
       globalTypesNErx_.resize(typecodeIdx + 1, 0);
       globalTypesNWords_.resize(typecodeIdx + 1, 0);
       dataOffsets_.resize(typecodeIdx + 1, 0);
     }
     globalTypesCounter_[typecodeIdx]++;
     globalTypesNErx_[typecodeIdx] = nerx;
     globalTypesNWords_[typecodeIdx] = nwords;
   }