#include <HeterogeneousHGCalHEFCellPositionsFiller.h>

Inheritance diagram for HeterogeneousHGCalHEFCellPositionsFiller:

Public Member Functions
	HeterogeneousHGCalHEFCellPositionsFiller (const edm::ParameterSet &)

std::unique_ptr< HeterogeneousHGCalHEFCellPositionsConditions >	produce (const HeterogeneousHGCalHEFCellPositionsConditionsRecord &)

	~HeterogeneousHGCalHEFCellPositionsFiller () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

Private Member Functions
void	set_conditions_ ()

Private Attributes
const hgcal_conditions::HeterogeneousHEFCellPositionsConditionsESProduct *	d_conds = nullptr

const HGCalDDDConstants *	ddd_ = nullptr

edm::ESGetToken< HGCalGeometry, IdealGeometryRecord >	geometryToken_

const HGCalParameters *	params_ = nullptr

hgcal_conditions::positions::HGCalPositionsMapping *	posmap_

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 31 of file HeterogeneousHGCalHEFCellPositionsFiller.h.

Constructor & Destructor Documentation

◆ HeterogeneousHGCalHEFCellPositionsFiller()

HeterogeneousHGCalHEFCellPositionsFiller::HeterogeneousHGCalHEFCellPositionsFiller ( const edm::ParameterSet & ps )

explicit

Definition at line 3 of file HeterogeneousHGCalHEFCellPositionsFiller.cc.

References geometryToken_, posmap_, and edm::ESProducer::setWhatProduced().

                                                                                                             {
   geometryToken_ = setWhatProduced(this).consumesFrom<HGCalGeometry, IdealGeometryRecord>(
       edm::ESInputTag{"", "HGCalHESiliconSensitive"});
   posmap_ = new hgcal_conditions::positions::HGCalPositionsMapping();
 }

◆ ~HeterogeneousHGCalHEFCellPositionsFiller()

HeterogeneousHGCalHEFCellPositionsFiller::~HeterogeneousHGCalHEFCellPositionsFiller ( )

override

Definition at line 9 of file HeterogeneousHGCalHEFCellPositionsFiller.cc.

References posmap_.

9 { delete posmap_; }

HeterogeneousHGCalHEFCellPositionsFiller::posmap_

hgcal_conditions::positions::HGCalPositionsMapping * posmap_

Definition: HeterogeneousHGCalHEFCellPositionsFiller.h:48

Member Function Documentation

◆ produce()

std::unique_ptr< HeterogeneousHGCalHEFCellPositionsConditions > HeterogeneousHGCalHEFCellPositionsFiller::produce ( const HeterogeneousHGCalHEFCellPositionsConditionsRecord & iRecord )

Definition at line 82 of file HeterogeneousHGCalHEFCellPositionsFiller.cc.

References ddd_, relativeConstraints::geom, geometryToken_, HGCalDDDConstants::getParameter(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getTransientHandle(), params_, posmap_, set_conditions_(), and up.

                                                                        {
   auto geom = iRecord.getTransientHandle(geometryToken_);
   ddd_ = &(geom->topology().dddConstants());
   params_ = ddd_->getParameter();
 
   set_conditions_();
 
   std::unique_ptr<HeterogeneousHGCalHEFCellPositionsConditions> up =
       std::make_unique<HeterogeneousHGCalHEFCellPositionsConditions>(posmap_);
   return up;
 }

◆ set_conditions_()

void HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_ ( )

private

Definition at line 12 of file HeterogeneousHGCalHEFCellPositionsFiller.cc.

Referenced by produce().

                                                                {
   //fill the CPU position structure from the geometry
   posmap_->zLayer.clear();
   posmap_->nCellsLayer.clear();
   posmap_->nCellsWaferUChunk.clear();
   posmap_->nCellsHexagon.clear();
   posmap_->detid.clear();
 
   int nlayers = ddd_->lastLayer(true) - ddd_->firstLayer() + 1;
   int upper_estimate_wafer_number_1D = 2 * nlayers * (ddd_->waferMax() - ddd_->waferMin());
   int upper_estimate_wafer_number_2D = upper_estimate_wafer_number_1D * (ddd_->waferMax() - ddd_->waferMin());
   int upper_estimate_cell_number = upper_estimate_wafer_number_2D * 3 * 12 * 12;
   posmap_->zLayer.resize(nlayers * 2);
   posmap_->nCellsLayer.reserve(nlayers * 2);
   posmap_->nCellsWaferUChunk.reserve(upper_estimate_wafer_number_1D);
   posmap_->nCellsHexagon.reserve(upper_estimate_wafer_number_2D);
   posmap_->detid.reserve(upper_estimate_cell_number);
   //set position-related variables
   posmap_->waferSize = static_cast<float>(params_->waferSize_);
   posmap_->sensorSeparation = static_cast<float>(params_->sensorSeparation_);
   posmap_->firstLayer = ddd_->firstLayer();
   assert(posmap_->firstLayer == 1);  //otherwise the loop over the layers has to be changed
   posmap_->lastLayer = ddd_->lastLayer(true);
   posmap_->waferMin = ddd_->waferMin();
   posmap_->waferMax = ddd_->waferMax();
 
   unsigned sumCellsLayer, sumCellsWaferUChunk;
 
   //store detids following a geometry ordering
   for (int ilayer = 1; ilayer <= posmap_->lastLayer; ++ilayer) {
     sumCellsLayer = 0;
     posmap_->zLayer[ilayer - 1] = static_cast<float>(ddd_->waferZ(ilayer, true));            //originally a double
     posmap_->zLayer[ilayer - 1 + nlayers] = static_cast<float>(ddd_->waferZ(ilayer, true));  //originally a double
 
     for (int iwaferU = posmap_->waferMin; iwaferU < posmap_->waferMax; ++iwaferU) {
       sumCellsWaferUChunk = 0;
 
       for (int iwaferV = posmap_->waferMin; iwaferV < posmap_->waferMax; ++iwaferV) {
         //0: fine; 1: coarseThin; 2: coarseThick (as defined in DataFormats/ForwardDetId/interface/HGCSiliconDetId.h)
         int type_ = ddd_->waferType(ilayer, iwaferU, iwaferV, false);
 
         int nCellsHexSide = ddd_->numberCellsHexagon(ilayer, iwaferU, iwaferV, false);
         int nCellsHexTotal = ddd_->numberCellsHexagon(ilayer, iwaferU, iwaferV, true);
         sumCellsLayer += nCellsHexTotal;
         sumCellsWaferUChunk += nCellsHexTotal;
         posmap_->nCellsHexagon.push_back(nCellsHexTotal);
 
         //left side of wafer
         for (int cellUmax = nCellsHexSide, icellV = 0; cellUmax < 2 * nCellsHexSide and icellV < nCellsHexSide;
              ++cellUmax, ++icellV) {
           for (int icellU = 0; icellU <= cellUmax; ++icellU) {
             HGCSiliconDetId detid_(DetId::HGCalHSi, 1, type_, ilayer, iwaferU, iwaferV, icellU, icellV);
             posmap_->detid.push_back(detid_.rawId());
           }
         }
         //right side of wafer
         for (int cellUmin = 1, icellV = nCellsHexSide; cellUmin <= nCellsHexSide and icellV < 2 * nCellsHexSide;
              ++cellUmin, ++icellV) {
           for (int icellU = cellUmin; icellU < 2 * nCellsHexSide; ++icellU) {
             HGCSiliconDetId detid_(DetId::HGCalHSi, 1, type_, ilayer, iwaferU, iwaferV, icellU, icellV);
             posmap_->detid.push_back(detid_.rawId());
           }
         }
       }
       posmap_->nCellsWaferUChunk.push_back(sumCellsWaferUChunk);
     }
     posmap_->nCellsLayer.push_back(sumCellsLayer);
   }
 }