Inheritance diagram for ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >:

Public Member Functions
	PFRecHitTopologyESProducer (edm::ParameterSet const &iConfig)

std::unique_ptr< typename CAL::TopologyTypeHost >	produce (const typename CAL::TopologyRecordType &iRecord)

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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

Private Member Functions
uint32_t	getNeighbourDetId (const uint32_t detId, const uint32_t direction, const CaloSubdetectorTopology &topo)

template<>
uint32_t	getNeighbourDetId (const uint32_t detId, const uint32_t direction, const CaloSubdetectorTopology &topo)

template<>
uint32_t	getNeighbourDetId (const uint32_t detId, const uint32_t direction, const CaloSubdetectorTopology &topo)

Private Attributes
const bool	cutsFromDB_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomToken_

edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd >	hcalCutsToken_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	hcalToken_

Additional Inherited Members
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

template<typename CAL>
class ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >

Definition at line 30 of file PFRecHitTopologyESProducer.cc.

Constructor & Destructor Documentation

◆ PFRecHitTopologyESProducer()

template<typename CAL >

ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >::PFRecHitTopologyESProducer ( edm::ParameterSet const & iConfig )

inline

Definition at line 32 of file PFRecHitTopologyESProducer.cc.

References gpuPixelDoublets::cc, and ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr().

         : ESProducer(iConfig), cutsFromDB_(iConfig.getParameter<bool>("usePFThresholdsFromDB")) {
       auto cc = setWhatProduced(this);
       geomToken_ = cc.consumes();
       if constexpr (std::is_same_v<CAL, HCAL>) {
         hcalToken_ = cc.consumes();
         hcalCutsToken_ = cc.consumes();
       }
     }

Member Function Documentation

◆ fillDescriptions()

template<typename CAL >

static void ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 42 of file PFRecHitTopologyESProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), and submitPVResolutionJobs::desc.

                                                                              {
       edm::ParameterSetDescription desc;
       if constexpr (std::is_same_v<CAL, HCAL>)
         desc.add<bool>("usePFThresholdsFromDB", true);
       else  // only needs to be true for HBHE
         desc.add<bool>("usePFThresholdsFromDB", false);
       descriptions.addWithDefaultLabel(desc);
     }

◆ getNeighbourDetId() [1/3]

template<typename CAL >

uint32_t ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >::getNeighbourDetId	(	const uint32_t	detId,
		const uint32_t	direction,
		const CaloSubdetectorTopology &	topo
	)

private

◆ getNeighbourDetId() [2/3]

template<>

uint32_t ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< ECAL >::getNeighbourDetId	(	const uint32_t	detId,
		const uint32_t	direction,
		const CaloSubdetectorTopology &	topo
	)

private

Definition at line 157 of file PFRecHitTopologyESProducer.cc.

References hcalRecHitTable_cff::detId, CaloSubdetectorTopology::goEast(), CaloSubdetectorTopology::goNorth(), CaloSubdetectorTopology::goSouth(), and CaloSubdetectorTopology::goWest().

                                                                                                     {
     // desired order for PF: NORTH, SOUTH, EAST, WEST, NORTHEAST, SOUTHWEST, SOUTHEAST, NORTHWEST
     if (detId == 0)
       return 0;
 
     if (direction == 0)            // NORTH
       return topo.goNorth(detId);  // larger iphi values (except phi boundary)
     if (direction == 1)            // SOUTH
       return topo.goSouth(detId);  // smaller iphi values (except phi boundary)
     if (direction == 2)            // EAST
       return topo.goEast(detId);   // smaller ieta values
     if (direction == 3)            // WEST
       return topo.goWest(detId);   // larger ieta values
 
     if (direction == 4) {  // NORTHEAST
       const uint32_t NE = getNeighbourDetId(getNeighbourDetId(detId, 0, topo), 2, topo);
       if (NE)
         return NE;
       return getNeighbourDetId(getNeighbourDetId(detId, 2, topo), 0, topo);
     }
     if (direction == 5) {  // SOUTHWEST
       const uint32_t SW = getNeighbourDetId(getNeighbourDetId(detId, 1, topo), 3, topo);
       if (SW)
         return SW;
       return getNeighbourDetId(getNeighbourDetId(detId, 3, topo), 1, topo);
     }
     if (direction == 6) {  // SOUTHEAST
       const uint32_t ES = getNeighbourDetId(getNeighbourDetId(detId, 2, topo), 1, topo);
       if (ES)
         return ES;
       return getNeighbourDetId(getNeighbourDetId(detId, 1, topo), 2, topo);
     }
     if (direction == 7) {  // NORTHWEST
       const uint32_t WN = getNeighbourDetId(getNeighbourDetId(detId, 3, topo), 0, topo);
       if (WN)
         return WN;
       return getNeighbourDetId(getNeighbourDetId(detId, 0, topo), 3, topo);
     }
     return 0;
   }

◆ getNeighbourDetId() [3/3]

template<>

uint32_t ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< HCAL >::getNeighbourDetId	(	const uint32_t	detId,
		const uint32_t	direction,
		const CaloSubdetectorTopology &	topo
	)

private

Definition at line 201 of file PFRecHitTopologyESProducer.cc.

References hcalRecHitTable_cff::detId, ALPAKA_ACCELERATOR_NAMESPACE::particleFlowRecHitProducer::HCAL::getZside(), CaloSubdetectorTopology::goEast(), CaloSubdetectorTopology::goNorth(), CaloSubdetectorTopology::goSouth(), and CaloSubdetectorTopology::goWest().

                                                                                                     {
     // desired order for PF: NORTH, SOUTH, EAST, WEST, NORTHEAST, SOUTHWEST, SOUTHEAST, NORTHWEST
     if (detId == 0)
       return 0;
 
     if (direction == 0)            // NORTH
       return topo.goNorth(detId);  // larger iphi values (except phi boundary)
     if (direction == 1)            // SOUTH
       return topo.goSouth(detId);  // smaller iphi values (except phi boundary)
     if (direction == 2)            // EAST
       return topo.goEast(detId);   // smaller ieta values
     if (direction == 3)            // WEST
       return topo.goWest(detId);   // larger ieta values
 
     std::pair<uint32_t, uint32_t> directions;
     if (direction == 4) {  // NORTHEAST
       if (HCAL::getZside(detId) > 0)
         directions = {2, 0};  // positive eta: east -> move to smaller |ieta| (finner phi granularity) first
       else
         directions = {0, 2};      // negative eta: move in phi first then move to east (coarser phi granularity)
     } else if (direction == 5) {  // SOUTHWEST
       if (HCAL::getZside(detId) > 0)
         directions = {1, 3};  // positive eta: move in phi first then move to west (coarser phi granularity)
       else
         directions = {3, 1};      // negative eta: west -> move to smaller |ieta| (finner phi granularity) first
     } else if (direction == 6) {  // SOUTHEAST
       if (HCAL::getZside(detId) > 0)
         directions = {2, 1};  // positive eta: east -> move to smaller |ieta| (finner phi granularity) first
       else
         directions = {1, 2};      // negative eta: move in phi first then move to east (coarser phi granularity)
     } else if (direction == 7) {  // NORTHWEST
       if (HCAL::getZside(detId) > 0)
         directions = {0, 3};  // positive eta: move in phi first then move to west (coarser phi granularity)
       else
         directions = {3, 0};  // negative eta: west -> move to smaller |ieta| (finner phi granularity) first
     } else
       return 0;
     const uint32_t nn1 = getNeighbourDetId(detId, directions.first, topo);   // nearest neighbour in direction 1
     const uint32_t nn2 = getNeighbourDetId(detId, directions.second, topo);  // nearest neighbour in direction 2
     const uint32_t nnn = getNeighbourDetId(nn1, directions.second, topo);    // next-to-nearest neighbour
     if (nnn == nn1 || nnn == nn2)                                            // avoid duplicates
       return 0;
     return nnn;
   }

◆ produce()

template<typename CAL >

std::unique_ptr<typename CAL::TopologyTypeHost> ALPAKA_ACCELERATOR_NAMESPACE::PFRecHitTopologyESProducer< CAL >::produce ( const typename CAL::TopologyRecordType & iRecord )

inline

Definition at line 51 of file PFRecHitTopologyESProducer.cc.

References cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), hcalRecHitTable_cff::detId, EcalBarrel, spr::find(), relativeConstraints::geom, CaloSubdetectorGeometry::getGeometry(), cms::alpakatools::host(), dqm-mbProfile::log, LogDebug, dqmiodumpmetadata::n, l1tHGCalVFEProducer_cfi::noiseThreshold, and dumpMFGeometry_cfg::prod.

                                                                                                        {
       const auto& geom = iRecord.get(geomToken_);
       auto product = std::make_unique<typename CAL::TopologyTypeHost>(CAL::kSize, cms::alpakatools::host());
       auto view = product->view();
       const int calEnums[2] = {CAL::kSubdetectorBarrelId, CAL::kSubdetectorEndcapId};
       for (const auto subdet : calEnums) {
         // Construct topology
         //  for HCAL: using dedicated record
         //  for ECAL: from CaloGeometry (separate for barrel and endcap)
         const CaloSubdetectorGeometry* geo = geom.getSubdetectorGeometry(CAL::kDetectorId, subdet);
         const CaloSubdetectorTopology* topo;
         std::variant<EcalBarrelTopology, EcalEndcapTopology> topoVar;  // need to store ECAL topology temporarily
         if constexpr (std::is_same_v<CAL, HCAL>)
           topo = &iRecord.get(hcalToken_);
         else if (subdet == EcalSubdetector::EcalBarrel)
           topo = &topoVar.emplace<EcalBarrelTopology>(geom);
         else
           topo = &topoVar.emplace<EcalEndcapTopology>(geom);
 
         // Fill product
         for (auto const detId : geom.getValidDetIds(CAL::kDetectorId, subdet)) {
           const uint32_t denseId = CAL::detId2denseId(detId);
           assert(denseId < CAL::kSize);
 
           // Fill SoA members with HCAL PF Thresholds from GT
           if constexpr (std::is_same_v<CAL, HCAL>) {
             view.cutsFromDB() = false;
             if (cutsFromDB_) {
               view.cutsFromDB() = true;
               const HcalPFCuts& pfCuts = iRecord.get(hcalCutsToken_);
               const HcalTopology& htopo = iRecord.get(hcalToken_);
               std::unique_ptr<HcalPFCuts> prod = std::make_unique<HcalPFCuts>(pfCuts);
               prod->setTopo(&htopo);
               view.noiseThreshold(denseId) = prod->getValues(detId.rawId())->noiseThreshold();
               view.seedThreshold(denseId) = prod->getValues(detId.rawId())->seedThreshold();
             }
           }
 
           const GlobalPoint pos = geo->getGeometry(detId)->getPosition();
           view.positionX(denseId) = pos.x();
           view.positionY(denseId) = pos.y();
           view.positionZ(denseId) = pos.z();
 
           for (uint32_t n = 0; n < 8; n++) {
             uint32_t neighDetId = getNeighbourDetId(detId, n, *topo);
             if (CAL::detIdInRange(neighDetId))
               view.neighbours(denseId)(n) = CAL::detId2denseId(neighDetId);
             else
               view.neighbours(denseId)(n) = CAL::kInvalidDenseId;
           }
         }
       }
 
       // Remove neighbours that are not backward compatible (only for HCAL)
       if constexpr (std::is_same_v<CAL, HCAL>) {
         for (const auto subdet : calEnums)
           for (auto const detId : geom.getValidDetIds(CAL::kDetectorId, subdet)) {
             const uint32_t denseId = CAL::detId2denseId(detId);
             for (uint32_t n = 0; n < 8; n++) {
               if (view.neighbours(denseId)[n] == CAL::kInvalidDenseId)
                 continue;
               const ::reco::PFRecHitsTopologyNeighbours& neighboursOfNeighbour =
                   view.neighbours(view.neighbours(denseId)[n]);
               if (std::find(neighboursOfNeighbour.begin(), neighboursOfNeighbour.end(), denseId) ==
                   neighboursOfNeighbour.end())
                 view.neighbours(denseId)[n] = CAL::kInvalidDenseId;
             }
           }
       }
 
       // Print results (for debugging)
       LogDebug("PFRecHitTopologyESProducer").log([&](auto& log) {
         for (const auto subdet : calEnums)
           for (const auto detId : geom.getValidDetIds(CAL::kDetectorId, subdet)) {
             const uint32_t denseId = CAL::detId2denseId(detId);
             log.format("detId:{} denseId:{} pos:{},{},{} neighbours:{},{},{},{};{},{},{},{}\n",
                        (uint32_t)detId,
                        denseId,
                        view[denseId].positionX(),
                        view[denseId].positionY(),
                        view[denseId].positionZ(),
                        view[denseId].neighbours()(0),
                        view[denseId].neighbours()(1),
                        view[denseId].neighbours()(2),
                        view[denseId].neighbours()(3),
                        view[denseId].neighbours()(4),
                        view[denseId].neighbours()(5),
                        view[denseId].neighbours()(6),
                        view[denseId].neighbours()(7));
           }
       });
 
       return product;
     }