Inheritance diagram for HEBRecHitGPU:

Public Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

	HEBRecHitGPU (const edm::ParameterSet &ps)

void	produce (edm::Event &, const edm::EventSetup &) override

	~HEBRecHitGPU () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
std::string	assert_error_message_ (std::string, const size_t &)

void	assert_sizes_constants_ (const HGCConstantVectorData &)

void	convert_collection_data_to_soa_ (const uint32_t &, const HGChebUncalibratedRecHitCollection &)

void	convert_constant_data_ (KernelConstantData< HGChebUncalibRecHitConstantData > *)

Private Attributes
HGChebUncalibRecHitConstantData	cdata_

HGCUncalibRecHitDevice	d_uncalib_

HGCUncalibRecHitHost < HGChebUncalibratedRecHitCollection >	h_uncalib_

KernelConstantData < HGChebUncalibRecHitConstantData > *	kcdata_

HGCRecHitGPUProduct	prod_

edm::EDPutTokenT < cms::cuda::Product < HGCRecHitGPUProduct > >	recHitGPUToken_

std::unique_ptr < HGChebRecHitCollection >	rechits_

std::unique_ptr < hgcal::RecHitTools >	tools_

edm::EDGetTokenT < HGChebUncalibratedRecHitCollection >	uncalibRecHitCPUToken_

HGCConstantVectorData	vdata_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 24 of file HEBRecHitGPU.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 60 of file HEBRecHitGPU.cc.

References edm::ParameterSet::getParameter().

     : uncalibRecHitCPUToken_{consumes<HGCUncalibratedRecHitCollection>(
           ps.getParameter<edm::InputTag>("HGCHEBUncalibRecHitsTok"))},
       recHitGPUToken_{produces<cms::cuda::Product<HGCRecHitGPUProduct>>()} {
   cdata_.keV2DIGI_ = ps.getParameter<double>("HGCHEB_keV2DIGI");
   cdata_.noise_MIP_ = ps.getParameter<edm::ParameterSet>("HGCHEB_noise_MIP").getParameter<double>("noise_MIP");
   vdata_.weights_ = ps.getParameter<std::vector<double>>("weights");
   cdata_.uncalib2GeV_ = 1e-6 / cdata_.keV2DIGI_;
   cdata_.layerOffset_ = 28;
   assert_sizes_constants_(vdata_);
 
   kcdata_ = new KernelConstantData<HGChebUncalibRecHitConstantData>(cdata_, vdata_);
   convert_constant_data_(kcdata_);
 
   tools_ = std::make_unique<hgcal::RecHitTools>();
 }

HEBRecHitGPU::~HEBRecHitGPU ( )

override

Definition at line 77 of file HEBRecHitGPU.cc.

References kcdata_.

77 { delete kcdata_; }

HEBRecHitGPU::kcdata_

KernelConstantData< HGChebUncalibRecHitConstantData > * kcdata_

Definition: HEBRecHitGPU.cc:57

Member Function Documentation

std::string HEBRecHitGPU::assert_error_message_	(	std::string	var,
		const size_t &	s
	)

private

Definition at line 79 of file HEBRecHitGPU.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and cond::impl::to_string().

Referenced by assert_sizes_constants_().

                                                                             {
   std::string str1 = "The '";
   std::string str2 = "' array must be of size ";
   std::string str3 = " to hold the configuration data.";
   return str1 + var + str2 + std::to_string(s) + str3;
 }

void HEBRecHitGPU::assert_sizes_constants_ ( const HGCConstantVectorData & vd )

private

Definition at line 86 of file HEBRecHitGPU.cc.

References assert_error_message_(), HGCConstantVectorData::fCPerMIP_, HGChebUncalibRecHitConstantData::heb_weights, vdata_, and HGCConstantVectorData::weights_.

                                                                           {
   if (vdata_.weights_.size() != HGChebUncalibRecHitConstantData::heb_weights)
     edm::LogError("WrongSize") << this->assert_error_message_("weights", vdata_.fCPerMIP_.size());
 }

void HEBRecHitGPU::beginRun	(	edm::Run const &	,
		edm::EventSetup const &	setup
	)

override

Definition at line 91 of file HEBRecHitGPU.cc.

91 {}

void HEBRecHitGPU::convert_collection_data_to_soa_	(	const uint32_t &	,
		const HGChebUncalibratedRecHitCollection &
	)

private

void HEBRecHitGPU::convert_constant_data_ ( KernelConstantData< HGChebUncalibRecHitConstantData > * kcdata )

private

Definition at line 113 of file HEBRecHitGPU.cc.

References KernelConstantData< T >::data_, mps_fire::i, KernelConstantData< T >::vdata_, HGCConstantVectorData::weights_, and HGChebUncalibRecHitConstantData::weights_.

                                                                                                      {
   for (size_t i = 0; i < kcdata->vdata_.weights_.size(); ++i)
     kcdata->data_.weights_[i] = kcdata->vdata_.weights_[i];
 }

void HEBRecHitGPU::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 93 of file HEBRecHitGPU.cc.

References d_uncalib_, HGCUncalibRecHitDevice::get(), HGCRecHitGPUProduct::get(), cms::cuda::impl::ScopedContextGetterBase::get(), h_uncalib_, kcdata_, eostools::move(), nhits, prod_, recHitGPUToken_, rechits_, KernelManagerHGCalRecHit::run_kernels(), and uncalibRecHitCPUToken_.

                                                                       {
   cms::cuda::ScopedContextProduce ctx{event.streamID()};
 
   const auto &hits = event.get(uncalibRecHitCPUToken_);
   unsigned int nhits(hits.size());
   rechits_ = std::make_unique<HGCRecHitCollection>();
 
   if (nhits == 0)
     edm::LogError("HEBRecHitGPU") << "WARNING: no input hits!";
 
   prod_ = HGCRecHitGPUProduct(nhits, ctx.stream());
   d_uncalib_ = HGCUncalibRecHitDevice(nhits, ctx.stream());
   h_uncalib_ = HGCUncalibRecHitHost<HGChebUncalibratedRecHitCollection>(nhits, hits, ctx.stream());
 
   KernelManagerHGCalRecHit km(h_uncalib_.get(), d_uncalib_.get(), prod_.get());
   km.run_kernels(kcdata_, ctx.stream());
 
   ctx.emplace(event, recHitGPUToken_, std::move(prod_));
 }