Inheritance diagram for EcalUncalibRecHitProducerGPU:

Public Member Functions
	EcalUncalibRecHitProducerGPU (edm::ParameterSet const &ps)

	~EcalUncalibRecHitProducerGPU () 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

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

Private Types
using	InputProduct = cms::cuda::Product< ecal::DigisCollection< calo::common::DevStoragePolicy > >

using	OutputProduct = cms::cuda::Product< ecal::UncalibratedRecHit< calo::common::DevStoragePolicy > >

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

Private Attributes
ecal::multifit::ConfigurationParameters	configParameters_

const edm::EDGetTokenT< InputProduct >	digisTokenEB_

const edm::EDGetTokenT< InputProduct >	digisTokenEE_

const edm::ESGetToken< EcalGainRatiosGPU, EcalGainRatiosRcd >	gainRatiosToken_

const edm::ESGetToken< EcalMultifitParametersGPU, JobConfigurationGPURecord >	multifitParametersToken_

const edm::ESGetToken< EcalPedestalsGPU, EcalPedestalsRcd >	pedestalsToken_

const edm::ESGetToken< EcalPulseCovariancesGPU, EcalPulseCovariancesRcd >	pulseCovariancesToken_

const edm::ESGetToken< EcalPulseShapesGPU, EcalPulseShapesRcd >	pulseShapesToken_

const edm::EDPutTokenT< OutputProduct >	recHitsTokenEB_

const edm::EDPutTokenT< OutputProduct >	recHitsTokenEE_

const edm::ESGetToken< EcalSampleMask, EcalSampleMaskRcd >	sampleMaskToken_

const edm::ESGetToken< EcalSamplesCorrelationGPU, EcalSamplesCorrelationRcd >	samplesCorrelationToken_

const edm::ESGetToken< EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrectionsRcd >	timeBiasCorrectionsToken_

const edm::ESGetToken< EcalTimeCalibConstantsGPU, EcalTimeCalibConstantsRcd >	timeCalibConstantsToken_

const edm::ESGetToken< EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd >	timeOffsetConstantToken_

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 33 of file EcalUncalibRecHitProducerGPU.cc.

Member Typedef Documentation

◆ InputProduct

using EcalUncalibRecHitProducerGPU::InputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy> >

private

Definition at line 43 of file EcalUncalibRecHitProducerGPU.cc.

◆ OutputProduct

using EcalUncalibRecHitProducerGPU::OutputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> >

private

Definition at line 45 of file EcalUncalibRecHitProducerGPU.cc.

Constructor & Destructor Documentation

◆ EcalUncalibRecHitProducerGPU()

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

explicit

Definition at line 98 of file EcalUncalibRecHitProducerGPU.cc.

References edm::ParameterSet::getParameter().

     : digisTokenEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEB"))},
       digisTokenEE_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEE"))},
       recHitsTokenEB_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"))},
       recHitsTokenEE_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEE"))},
       pedestalsToken_{esConsumes<EcalPedestalsGPU, EcalPedestalsRcd>()},
       gainRatiosToken_{esConsumes<EcalGainRatiosGPU, EcalGainRatiosRcd>()},
       pulseShapesToken_{esConsumes<EcalPulseShapesGPU, EcalPulseShapesRcd>()},
       pulseCovariancesToken_{esConsumes<EcalPulseCovariancesGPU, EcalPulseCovariancesRcd>()},
       samplesCorrelationToken_{esConsumes<EcalSamplesCorrelationGPU, EcalSamplesCorrelationRcd>()},
       timeBiasCorrectionsToken_{esConsumes<EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrectionsRcd>()},
       timeCalibConstantsToken_{esConsumes<EcalTimeCalibConstantsGPU, EcalTimeCalibConstantsRcd>()},
       sampleMaskToken_{esConsumes<EcalSampleMask, EcalSampleMaskRcd>()},
       timeOffsetConstantToken_{esConsumes<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd>()},
       multifitParametersToken_{esConsumes<EcalMultifitParametersGPU, JobConfigurationGPURecord>()} {
   std::pair<double, double> EBtimeFitLimits, EEtimeFitLimits;
   EBtimeFitLimits.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
   EBtimeFitLimits.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
   EEtimeFitLimits.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
   EEtimeFitLimits.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
 
   auto EBtimeConstantTerm = ps.getParameter<double>("EBtimeConstantTerm");
   auto EEtimeConstantTerm = ps.getParameter<double>("EEtimeConstantTerm");
   auto EBtimeNconst = ps.getParameter<double>("EBtimeNconst");
   auto EEtimeNconst = ps.getParameter<double>("EEtimeNconst");
 
   auto outOfTimeThreshG12pEB = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
   auto outOfTimeThreshG12mEB = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
   auto outOfTimeThreshG61pEB = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
   auto outOfTimeThreshG61mEB = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
   auto outOfTimeThreshG12pEE = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
   auto outOfTimeThreshG12mEE = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
   auto outOfTimeThreshG61pEE = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
   auto outOfTimeThreshG61mEE = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
   auto amplitudeThreshEB = ps.getParameter<double>("amplitudeThresholdEB");
   auto amplitudeThreshEE = ps.getParameter<double>("amplitudeThresholdEE");
 
   // max number of digis to allocate for
   configParameters_.maxNumberHitsEB = ps.getParameter<uint32_t>("maxNumberHitsEB");
   configParameters_.maxNumberHitsEE = ps.getParameter<uint32_t>("maxNumberHitsEE");
 
   // switch to run timing computation kernels
   configParameters_.shouldRunTimingComputation = ps.getParameter<bool>("shouldRunTimingComputation");
 
   // minimize kernel launch conf
   auto threadsMinimize = ps.getUntrackedParameter<std::vector<uint32_t>>("kernelMinimizeThreads");
   configParameters_.kernelMinimizeThreads[0] = threadsMinimize[0];
   configParameters_.kernelMinimizeThreads[1] = threadsMinimize[1];
   configParameters_.kernelMinimizeThreads[2] = threadsMinimize[2];
 
   //
   // configuration and physics parameters: done once
   // assume there is a single device
   // use sync copying
   //
 
   // time fit parameters and limits
   configParameters_.timeFitLimitsFirstEB = EBtimeFitLimits.first;
   configParameters_.timeFitLimitsSecondEB = EBtimeFitLimits.second;
   configParameters_.timeFitLimitsFirstEE = EEtimeFitLimits.first;
   configParameters_.timeFitLimitsSecondEE = EEtimeFitLimits.second;
 
   // time constant terms
   configParameters_.timeConstantTermEB = EBtimeConstantTerm;
   configParameters_.timeConstantTermEE = EEtimeConstantTerm;
 
   // time N const
   configParameters_.timeNconstEB = EBtimeNconst;
   configParameters_.timeNconstEE = EEtimeNconst;
 
   // amplitude threshold for time flags
   configParameters_.amplitudeThreshEB = amplitudeThreshEB;
   configParameters_.amplitudeThreshEE = amplitudeThreshEE;
 
   // out of time thresholds gain-dependent
   configParameters_.outOfTimeThreshG12pEB = outOfTimeThreshG12pEB;
   configParameters_.outOfTimeThreshG12pEE = outOfTimeThreshG12pEE;
   configParameters_.outOfTimeThreshG61pEB = outOfTimeThreshG61pEB;
   configParameters_.outOfTimeThreshG61pEE = outOfTimeThreshG61pEE;
   configParameters_.outOfTimeThreshG12mEB = outOfTimeThreshG12mEB;
   configParameters_.outOfTimeThreshG12mEE = outOfTimeThreshG12mEE;
   configParameters_.outOfTimeThreshG61mEB = outOfTimeThreshG61mEB;
   configParameters_.outOfTimeThreshG61mEE = outOfTimeThreshG61mEE;
 }

◆ ~EcalUncalibRecHitProducerGPU()

EcalUncalibRecHitProducerGPU::~EcalUncalibRecHitProducerGPU ( )

override

Definition at line 183 of file EcalUncalibRecHitProducerGPU.cc.

183 {}

Member Function Documentation

◆ fillDescriptions()

void EcalUncalibRecHitProducerGPU::fillDescriptions ( edm::ConfigurationDescriptions & confDesc )

static

Definition at line 64 of file EcalUncalibRecHitProducerGPU.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("digisLabelEB", edm::InputTag("ecalRawToDigiGPU", "ebDigis"));
   desc.add<edm::InputTag>("digisLabelEE", edm::InputTag("ecalRawToDigiGPU", "eeDigis"));
 
   desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
   desc.add<std::string>("recHitsLabelEE", "EcalUncalibRecHitsEE");
 
   desc.add<double>("EBtimeFitLimits_Lower", 0.2);
   desc.add<double>("EBtimeFitLimits_Upper", 1.4);
   desc.add<double>("EEtimeFitLimits_Lower", 0.2);
   desc.add<double>("EEtimeFitLimits_Upper", 1.4);
   desc.add<double>("EBtimeConstantTerm", .6);
   desc.add<double>("EEtimeConstantTerm", 1.0);
   desc.add<double>("EBtimeNconst", 28.5);
   desc.add<double>("EEtimeNconst", 31.8);
   desc.add<double>("outOfTimeThresholdGain12pEB", 5);
   desc.add<double>("outOfTimeThresholdGain12mEB", 5);
   desc.add<double>("outOfTimeThresholdGain61pEB", 5);
   desc.add<double>("outOfTimeThresholdGain61mEB", 5);
   desc.add<double>("outOfTimeThresholdGain12pEE", 1000);
   desc.add<double>("outOfTimeThresholdGain12mEE", 1000);
   desc.add<double>("outOfTimeThresholdGain61pEE", 1000);
   desc.add<double>("outOfTimeThresholdGain61mEE", 1000);
   desc.add<double>("amplitudeThresholdEB", 10);
   desc.add<double>("amplitudeThresholdEE", 10);
   desc.add<uint32_t>("maxNumberHitsEB", 61200);
   desc.add<uint32_t>("maxNumberHitsEE", 14648);
   desc.addUntracked<std::vector<uint32_t>>("kernelMinimizeThreads", {32, 1, 1});
   desc.add<bool>("shouldRunTimingComputation", true);
   confDesc.addWithDefaultLabel(desc);
 }

◆ produce()

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

overrideprivate

Definition at line 185 of file EcalUncalibRecHitProducerGPU.cc.

                                                                                       {
   //DurationMeasurer<std::chrono::milliseconds> timer{std::string{"produce duration"}};
 
   // cuda products
   auto const& ebDigisProduct = event.get(digisTokenEB_);
   auto const& eeDigisProduct = event.get(digisTokenEE_);
   // event data
   ecal::multifit::EventOutputDataGPU eventOutputDataGPU;
 
   // raii
   cms::cuda::ScopedContextProduce ctx{ebDigisProduct};
 
   // get actual obj
   auto const& ebDigis = ctx.get(ebDigisProduct);
   auto const& eeDigis = ctx.get(eeDigisProduct);
   ecal::multifit::EventInputDataGPU inputDataGPU{ebDigis, eeDigis};
   const uint32_t neb = ebDigis.size;
   const uint32_t nee = eeDigis.size;
 
   // stop here if there are no digis
   if (neb + nee > 0) {
     if ((neb > configParameters_.maxNumberHitsEB) || (nee > configParameters_.maxNumberHitsEE)) {
       edm::LogError("EcalUncalibRecHitProducerGPU")
           << "Max number of channels exceeded in barrel or endcap. Number of barrel channels: " << neb
           << " with maxNumberHitsEB=" << configParameters_.maxNumberHitsEB << ", number of endcap channels: " << nee
           << " with maxNumberHitsEE=" << configParameters_.maxNumberHitsEE;
     }
 
     // conditions
     auto const& timeCalibConstantsData = setup.getData(timeCalibConstantsToken_);
     auto const& sampleMaskData = setup.getData(sampleMaskToken_);
     auto const& timeOffsetConstantData = setup.getData(timeOffsetConstantToken_);
     auto const& multifitParametersData = setup.getData(multifitParametersToken_);
 
     auto const& pedestals = setup.getData(pedestalsToken_).getProduct(ctx.stream());
     auto const& gainRatios = setup.getData(gainRatiosToken_).getProduct(ctx.stream());
     auto const& pulseShapes = setup.getData(pulseShapesToken_).getProduct(ctx.stream());
     auto const& pulseCovariances = setup.getData(pulseCovariancesToken_).getProduct(ctx.stream());
     auto const& samplesCorrelation = setup.getData(samplesCorrelationToken_).getProduct(ctx.stream());
     auto const& timeBiasCorrections = setup.getData(timeBiasCorrectionsToken_).getProduct(ctx.stream());
     auto const& timeCalibConstants = timeCalibConstantsData.getProduct(ctx.stream());
     auto const& multifitParameters = multifitParametersData.getProduct(ctx.stream());
 
     // assign ptrs/values: this is done not to change how things look downstream
     configParameters_.amplitudeFitParametersEB = multifitParameters.amplitudeFitParametersEB.get();
     configParameters_.amplitudeFitParametersEE = multifitParameters.amplitudeFitParametersEE.get();
     configParameters_.timeFitParametersEB = multifitParameters.timeFitParametersEB.get();
     configParameters_.timeFitParametersEE = multifitParameters.timeFitParametersEE.get();
     configParameters_.timeFitParametersSizeEB = multifitParametersData.getValues()[2].get().size();
     configParameters_.timeFitParametersSizeEE = multifitParametersData.getValues()[3].get().size();
 
     // bundle up conditions
     ecal::multifit::ConditionsProducts conditions{pedestals,
                                                   gainRatios,
                                                   pulseShapes,
                                                   pulseCovariances,
                                                   samplesCorrelation,
                                                   timeBiasCorrections,
                                                   timeCalibConstants,
                                                   sampleMaskData,
                                                   timeOffsetConstantData,
                                                   timeCalibConstantsData.getOffset(),
                                                   multifitParameters};
 
     // dev mem
     eventOutputDataGPU.allocate(configParameters_, ctx.stream());
 
     // scratch mem
     ecal::multifit::EventDataForScratchGPU eventDataForScratchGPU;
     eventDataForScratchGPU.allocate(configParameters_, ctx.stream());
 
     //
     // schedule algorithms
     //
     ecal::multifit::entryPoint(
         inputDataGPU, eventOutputDataGPU, eventDataForScratchGPU, conditions, configParameters_, ctx.stream());
   }
 
   // set the size of eb and ee
   eventOutputDataGPU.recHitsEB.size = neb;
   eventOutputDataGPU.recHitsEE.size = nee;
 
   // put into the event
   ctx.emplace(event, recHitsTokenEB_, std::move(eventOutputDataGPU.recHitsEB));
   ctx.emplace(event, recHitsTokenEE_, std::move(eventOutputDataGPU.recHitsEE));
 }