#include <GpuTask.h>

Inheritance diagram for ecaldqm::GpuTask:

Public Member Functions
void	addDependencies (DependencySet &) override

bool	analyze (void const *, Collections) override

void	beginEvent (edm::Event const &, edm::EventSetup const &, bool const &, bool &) override

bool	filterRunType (short const *) override

	GpuTask ()

template<typename DigiCollection >
void	runOnCpuDigis (DigiCollection const &, Collections)

void	runOnCpuRecHits (EcalRecHitCollection const &, Collections)

void	runOnCpuUncalibRecHits (EcalUncalibratedRecHitCollection const &, Collections)

template<typename DigiCollection >
void	runOnGpuDigis (DigiCollection const &, Collections)

void	runOnGpuRecHits (EcalRecHitCollection const &, Collections)

void	runOnGpuUncalibRecHits (EcalUncalibratedRecHitCollection const &, Collections)

	~GpuTask () override=default

Public Member Functions inherited from ecaldqm::DQWorkerTask
	DQWorkerTask ()

virtual void	endEvent (edm::Event const &, edm::EventSetup const &)

virtual bool	filterTrigger (edm::TriggerResultsByName const &)

virtual void	setTokens (edm::ConsumesCollector &)

	~DQWorkerTask () override

Public Member Functions inherited from ecaldqm::DQWorker
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	beginRun (edm::Run const &, edm::EventSetup const &)

virtual void	bookMEs (DQMStore::IBooker &)

	DQWorker ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	endRun (edm::Run const &, edm::EventSetup const &)

EcalDQMSetupObjects const	getEcalDQMSetupObjects ()

EcalElectronicsMapping const *	GetElectronicsMap ()

CaloGeometry const *	GetGeometry ()

std::string const &	getName () const

CaloTopology const *	GetTopology ()

EcalTrigTowerConstituentsMap const *	GetTrigTowerMap ()

bool	onlineMode () const

virtual void	releaseMEs ()

void	setEventNumber (edm::EventNumber_t _e)

void	setLumiNumber (edm::LuminosityBlockNumber_t _l)

void	setRunNumber (edm::RunNumber_t _r)

void	setSetupObjects (edm::EventSetup const &)

void	setSetupObjectsEndLumi (edm::EventSetup const &)

void	setTime (time_t _t)

void	setTokens (edm::ConsumesCollector &)

virtual	~DQWorker () noexcept(false)

Private Member Functions
void	setParams (edm::ParameterSet const &) override

Private Attributes
EBDigiCollection const *	EBCpuDigis_

EcalRecHitCollection const *	EBCpuRecHits_

EcalUncalibratedRecHitCollection const *	EBCpuUncalibRecHits_

EEDigiCollection const *	EECpuDigis_

EcalRecHitCollection const *	EECpuRecHits_

EcalUncalibratedRecHitCollection const *	EECpuUncalibRecHits_

bool	gpuOnlyPlots_

bool	runGpuTask_

std::vector< int >	uncalibOOTAmps_

Additional Inherited Members
Public Types inherited from ecaldqm::DQWorkerTask
typedef EcalDCCHeaderBlock::EcalDCCEventSettings	EventSettings

Static Public Member Functions inherited from ecaldqm::DQWorkerTask
static void	fillDescriptions (edm::ParameterSetDescription &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	fillDescriptions (edm::ParameterSetDescription &_desc)

Public Attributes inherited from ecaldqm::DQWorker
edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	elecMapHandle

edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	elecMapHandleEndLumi

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandle

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandleEndLumi

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandle

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandleEndLumi

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandle

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandleEndLumi

Protected Types inherited from ecaldqm::DQWorker
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Protected Member Functions inherited from ecaldqm::DQWorkerTask
void	setME (edm::ParameterSet const &) final

Protected Member Functions inherited from ecaldqm::DQWorker
void	initialize (std::string const &_name, edm::ParameterSet const &)

void	print_ (std::string const &, int=0) const

virtual void	setSource (edm::ParameterSet const &)

void	setVerbosity (int _verbosity)

Protected Attributes inherited from ecaldqm::DQWorker
bool	booked_

MESetCollection	MEs_

std::string	name_

bool	onlineMode_

Timestamp	timestamp_

int	verbosity_

bool	willConvertToEDM_

Detailed Description

Definition at line 11 of file GpuTask.h.

Constructor & Destructor Documentation

◆ GpuTask()

ecaldqm::GpuTask::GpuTask ( )

Definition at line 13 of file GpuTask.cc.

       : DQWorkerTask(),
         runGpuTask_(false),
         gpuOnlyPlots_(false),
         EBCpuDigis_(nullptr),
         EECpuDigis_(nullptr),
         EBCpuUncalibRecHits_(nullptr),
         EECpuUncalibRecHits_(nullptr),
         EBCpuRecHits_(nullptr),
         EECpuRecHits_(nullptr) {}

◆ ~GpuTask()

ecaldqm::GpuTask::~GpuTask ( )

overridedefault

Member Function Documentation

◆ addDependencies()

void ecaldqm::GpuTask::addDependencies ( DependencySet & dependencies )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 24 of file GpuTask.cc.

References ecaldqm::kEBCpuDigi, ecaldqm::kEBCpuRecHit, ecaldqm::kEBCpuUncalibRecHit, ecaldqm::kEBGpuDigi, ecaldqm::kEBGpuRecHit, ecaldqm::kEBGpuUncalibRecHit, ecaldqm::kEECpuDigi, ecaldqm::kEECpuRecHit, ecaldqm::kEECpuUncalibRecHit, ecaldqm::kEEGpuDigi, ecaldqm::kEEGpuRecHit, ecaldqm::kEEGpuUncalibRecHit, and runGpuTask_.

                                                            {
     // Ensure we run on CPU objects before GPU objects
     if (runGpuTask_) {
       dependencies.push_back(Dependency(kEBGpuDigi, kEBCpuDigi));
       dependencies.push_back(Dependency(kEEGpuDigi, kEECpuDigi));
 
       dependencies.push_back(Dependency(kEBGpuUncalibRecHit, kEBCpuUncalibRecHit));
       dependencies.push_back(Dependency(kEEGpuUncalibRecHit, kEECpuUncalibRecHit));
 
       dependencies.push_back(Dependency(kEBGpuRecHit, kEBCpuRecHit));
       dependencies.push_back(Dependency(kEEGpuRecHit, kEECpuRecHit));
     }
   }

◆ analyze()

bool ecaldqm::GpuTask::analyze	(	void const *	collection_data,
		Collections	collection
	)

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 49 of file GpuTask.h.

References universalConfigTemplate::collection, ecaldqm::kEBCpuDigi, ecaldqm::kEBCpuRecHit, ecaldqm::kEBCpuUncalibRecHit, ecaldqm::kEBGpuDigi, ecaldqm::kEBGpuRecHit, ecaldqm::kEBGpuUncalibRecHit, ecaldqm::kEECpuDigi, ecaldqm::kEECpuRecHit, ecaldqm::kEECpuUncalibRecHit, ecaldqm::kEEGpuDigi, ecaldqm::kEEGpuRecHit, ecaldqm::kEEGpuUncalibRecHit, runGpuTask_, runOnCpuDigis(), runOnCpuRecHits(), runOnCpuUncalibRecHits(), runOnGpuDigis(), runOnGpuRecHits(), and runOnGpuUncalibRecHits().

                                                                                   {
     switch (collection) {
       case kEBCpuDigi:
         if (collection_data && runGpuTask_)
           runOnCpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEECpuDigi:
         if (collection_data && runGpuTask_)
           runOnCpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEBGpuDigi:
         if (collection_data && runGpuTask_)
           runOnGpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEEGpuDigi:
         if (collection_data && runGpuTask_)
           runOnGpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEBCpuUncalibRecHit:
       case kEECpuUncalibRecHit:
         if (collection_data && runGpuTask_)
           runOnCpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEBGpuUncalibRecHit:
       case kEEGpuUncalibRecHit:
         if (collection_data && runGpuTask_)
           runOnGpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEBCpuRecHit:
       case kEECpuRecHit:
         if (collection_data && runGpuTask_)
           runOnCpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       case kEBGpuRecHit:
       case kEEGpuRecHit:
         if (collection_data && runGpuTask_)
           runOnGpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
         return runGpuTask_;
         break;
       default:
         break;
     }
 
     return false;
   }

◆ beginEvent()

void ecaldqm::GpuTask::beginEvent	(	edm::Event const &	,
		edm::EventSetup const &	,
		bool const &	,
		bool &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 103 of file GpuTask.cc.

References EBCpuDigis_, EBCpuRecHits_, EBCpuUncalibRecHits_, EECpuDigis_, EECpuRecHits_, and EECpuUncalibRecHits_.

                                                                                     {
     EBCpuDigis_ = nullptr;
     EECpuDigis_ = nullptr;
     EBCpuUncalibRecHits_ = nullptr;
     EECpuUncalibRecHits_ = nullptr;
     EBCpuRecHits_ = nullptr;
     EECpuRecHits_ = nullptr;
   }

◆ filterRunType()

bool ecaldqm::GpuTask::filterRunType ( short const * runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 92 of file GpuTask.cc.

References EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, EcalDCCHeaderBlock::MTCC, ecaldqm::nDCC, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, and EcalCondDBWriter_cfi::runType.

                                                   {
     for (unsigned iFED(0); iFED != ecaldqm::nDCC; iFED++) {
       if (runType[iFED] == EcalDCCHeaderBlock::COSMIC || runType[iFED] == EcalDCCHeaderBlock::MTCC ||
           runType[iFED] == EcalDCCHeaderBlock::COSMICS_GLOBAL || runType[iFED] == EcalDCCHeaderBlock::PHYSICS_GLOBAL ||
           runType[iFED] == EcalDCCHeaderBlock::COSMICS_LOCAL || runType[iFED] == EcalDCCHeaderBlock::PHYSICS_LOCAL)
         return true;
     }
 
     return false;
   }

◆ runOnCpuDigis()

template<typename DigiCollection >

void ecaldqm::GpuTask::runOnCpuDigis	(	DigiCollection const &	cpuDigis,
		Collections	collection
	)

Definition at line 113 of file GpuTask.cc.

References EcalMGPASample::adc(), cms::cuda::assert(), ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, EBCpuDigis_, EcalBarrel, EcalEndcap, EECpuDigis_, ecaldqm::MESetMulti::fill(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::kEBCpuDigi, ecaldqm::DQWorker::MEs_, EcalDataFrame::sample(), and ecalPh1::sampleSize.

Referenced by analyze().

                                                                                     {
     MESet& meDigiCpu(MEs_.at("DigiCpu"));
     MESet& meDigiCpuAmplitude(MEs_.at("DigiCpuAmplitude"));
 
     int iSubdet(collection == kEBCpuDigi ? EcalBarrel : EcalEndcap);
 
     // Save CpuDigis for comparison with GpuDigis
     // "if constexpr" ensures cpuDigis is the correct type at compile time
     if constexpr (std::is_same_v<DigiCollection, EBDigiCollection>) {
       assert(iSubdet == EcalBarrel);
       EBCpuDigis_ = &cpuDigis;
     } else {
       assert(iSubdet == EcalEndcap);
       EECpuDigis_ = &cpuDigis;
     }
 
     unsigned nCpuDigis(cpuDigis.size());
     meDigiCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuDigis);
 
     for (auto const& cpuDigi : cpuDigis) {
       // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor
       EcalDataFrame cpuDataFrame(cpuDigi);
 
       for (unsigned iSample = 0; iSample < ecalPh1::sampleSize; iSample++) {
         static_cast<MESetMulti&>(meDigiCpuAmplitude).use(iSample);
 
         int cpuAmp(cpuDataFrame.sample(iSample).adc());
         meDigiCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp);
       }
     }
   }

◆ runOnCpuRecHits()

void ecaldqm::GpuTask::runOnCpuRecHits	(	EcalRecHitCollection const &	cpuHits,
		Collections	collection
	)

Definition at line 371 of file GpuTask.cc.

References ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, EBCpuRecHits_, EcalBarrel, EcalEndcap, EECpuRecHits_, ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::kEBCpuRecHit, ecaldqm::DQWorker::MEs_, and edm::SortedCollection< T, SORT >::size().

Referenced by analyze().

                                                                                            {
     MESet& meRecHitCpu(MEs_.at("RecHitCpu"));
     MESet& meRecHitCpuEnergy(MEs_.at("RecHitCpuEnergy"));
     MESet& meRecHitCpuTime(MEs_.at("RecHitCpuTime"));
     MESet& meRecHitCpuFlags(MEs_.at("RecHitCpuFlags"));
 
     int iSubdet(collection == kEBCpuRecHit ? EcalBarrel : EcalEndcap);
 
     // Save CpuRecHits for comparison with GpuRecHits
     if (iSubdet == EcalBarrel)
       EBCpuRecHits_ = &cpuHits;
     else
       EECpuRecHits_ = &cpuHits;
 
     unsigned nCpuHits(cpuHits.size());
     meRecHitCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits);
 
     for (auto const& cpuHit : cpuHits) {
       float cpuEnergy(cpuHit.energy());
       float cpuTime(cpuHit.time());
       uint32_t cpuFlags(cpuHit.flagsBits());
 
       meRecHitCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, cpuEnergy);
       meRecHitCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, cpuTime);
       meRecHitCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags);
     }
   }

◆ runOnCpuUncalibRecHits()

void ecaldqm::GpuTask::runOnCpuUncalibRecHits	(	EcalUncalibratedRecHitCollection const &	cpuHits,
		Collections	collection
	)

Definition at line 210 of file GpuTask.cc.

References ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, EBCpuUncalibRecHits_, EcalBarrel, EcalEndcap, EECpuUncalibRecHits_, ecaldqm::MESetMulti::fill(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::kEBCpuUncalibRecHit, ecaldqm::DQWorker::MEs_, edm::SortedCollection< T, SORT >::size(), and uncalibOOTAmps_.

Referenced by analyze().

                                                                                                               {
     MESet& meUncalibCpu(MEs_.at("UncalibCpu"));
     MESet& meUncalibCpuAmp(MEs_.at("UncalibCpuAmp"));
     MESet& meUncalibCpuAmpError(MEs_.at("UncalibCpuAmpError"));
     MESet& meUncalibCpuPedestal(MEs_.at("UncalibCpuPedestal"));
     MESet& meUncalibCpuJitter(MEs_.at("UncalibCpuJitter"));
     MESet& meUncalibCpuJitterError(MEs_.at("UncalibCpuJitterError"));
     MESet& meUncalibCpuChi2(MEs_.at("UncalibCpuChi2"));
     MESet& meUncalibCpuOOTAmp(MEs_.at("UncalibCpuOOTAmp"));
     MESet& meUncalibCpuFlags(MEs_.at("UncalibCpuFlags"));
 
     int iSubdet(collection == kEBCpuUncalibRecHit ? EcalBarrel : EcalEndcap);
 
     // Save CpuUncalibRecHits for comparison with GpuUncalibRecHits
     if (iSubdet == EcalBarrel)
       EBCpuUncalibRecHits_ = &cpuHits;
     else
       EECpuUncalibRecHits_ = &cpuHits;
 
     unsigned nCpuHits(cpuHits.size());
     meUncalibCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits);
 
     for (auto const& cpuHit : cpuHits) {
       float cpuAmp(cpuHit.amplitude());
       float cpuAmpError(cpuHit.amplitudeError());
       float cpuPedestal(cpuHit.pedestal());
       float cpuJitter(cpuHit.jitter());
       float cpuJitterError(cpuHit.jitterError());
       float cpuChi2(cpuHit.chi2());
       uint32_t cpuFlags(cpuHit.flags());
 
       if (cpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
         cpuJitterError = 0.249999;
 
       meUncalibCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp);
       meUncalibCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmpError);
       meUncalibCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, cpuPedestal);
       meUncalibCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitter);
       meUncalibCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitterError);
       meUncalibCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, cpuChi2);
       meUncalibCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags);
 
       for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) {
         static_cast<MESetMulti&>(meUncalibCpuOOTAmp).use(iAmp);
 
         // Get corresponding OOT Amplitude
         int cpuOOTAmp(cpuHit.outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
         meUncalibCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuOOTAmp);
       }
     }
   }

◆ runOnGpuDigis()

template<typename DigiCollection >

void ecaldqm::GpuTask::runOnGpuDigis	(	DigiCollection const &	gpuDigis,
		Collections	collection
	)

Definition at line 146 of file GpuTask.cc.

References EcalMGPASample::adc(), cms::cuda::assert(), ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, siStripShotFilter_cfi::DigiCollection, EBCpuDigis_, EcalBarrel, EcalEndcap, EECpuDigis_, ecaldqm::MESetMulti::fill(), ecaldqm::MESet::fill(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), gpuOnlyPlots_, ecaldqm::kEBGpuDigi, ecaldqm::DQWorker::MEs_, EcalDataFrame::sample(), and ecalPh1::sampleSize.

Referenced by analyze().

                                                                                     {
     MESet& meDigiGpuCpu(MEs_.at("DigiGpuCpu"));
     MESet& meDigiGpuCpuAmplitude(MEs_.at("DigiGpuCpuAmplitude"));
 
     int iSubdet(collection == kEBGpuDigi ? EcalBarrel : EcalEndcap);
 
     // Get CpuDigis saved from GpuTask::runOnCpuDigis() for this event
     // "if constexpr" ensures cpuDigis is the correct type at compile time
     // Note: gpuDigis is a collection and cpuDigis is a pointer to a collection (for historical reasons)
     DigiCollection const* cpuDigis;
     if constexpr (std::is_same_v<DigiCollection, EBDigiCollection>) {
       assert(iSubdet == EcalBarrel);
       cpuDigis = EBCpuDigis_;
     } else {
       assert(iSubdet == EcalEndcap);
       cpuDigis = EECpuDigis_;
     }
 
     if (!cpuDigis) {
       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
                                  << "CpuDigis Collection. Aborting runOnGpuDigis\n";
       return;
     }
 
     unsigned nGpuDigis(gpuDigis.size());
     unsigned nCpuDigis(cpuDigis->size());
 
     meDigiGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis - nCpuDigis);
 
     if (gpuOnlyPlots_) {
       MESet& meDigiGpu(MEs_.at("DigiGpu"));
       meDigiGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis);
     }
 
     for (auto const& gpuDigi : gpuDigis) {
       // Find CpuDigi with matching DetId
       DetId gpuId(gpuDigi.id());
       typename DigiCollection::const_iterator cpuItr(cpuDigis->find(gpuId));
       if (cpuItr == cpuDigis->end()) {
         edm::LogWarning("EcalDQM") << "GpuTask: Did not find CpuDigi DetId " << gpuId.rawId() << " in CPU collection\n";
         continue;
       }
 
       // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor
       EcalDataFrame gpuDataFrame(gpuDigi);
       EcalDataFrame cpuDataFrame(*cpuItr);
 
       for (unsigned iSample = 0; iSample < ecalPh1::sampleSize; iSample++) {
         static_cast<MESetMulti&>(meDigiGpuCpuAmplitude).use(iSample);
 
         int gpuAmp(gpuDataFrame.sample(iSample).adc());
         int cpuAmp(cpuDataFrame.sample(iSample).adc());
 
         meDigiGpuCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp);
 
         if (gpuOnlyPlots_) {
           MESet& meDigiGpuAmplitude(MEs_.at("DigiGpuAmplitude"));
           static_cast<MESetMulti&>(meDigiGpuAmplitude).use(iSample);
           meDigiGpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp);
         }
       }
     }
   }

◆ runOnGpuRecHits()

void ecaldqm::GpuTask::runOnGpuRecHits	(	EcalRecHitCollection const &	gpuHits,
		Collections	collection
	)

Definition at line 399 of file GpuTask.cc.

References ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, EBCpuRecHits_, EcalBarrel, EcalEndcap, EECpuRecHits_, edm::SortedCollection< T, SORT >::end(), ecaldqm::MESet::fill(), edm::SortedCollection< T, SORT >::find(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), gpuOnlyPlots_, ecaldqm::kEBGpuRecHit, ecaldqm::DQWorker::MEs_, and edm::SortedCollection< T, SORT >::size().

Referenced by analyze().

                                                                                            {
     MESet& meRecHitGpuCpu(MEs_.at("RecHitGpuCpu"));
     MESet& meRecHitGpuCpuEnergy(MEs_.at("RecHitGpuCpuEnergy"));
     MESet& meRecHitGpuCpuTime(MEs_.at("RecHitGpuCpuTime"));
     MESet& meRecHitGpuCpuFlags(MEs_.at("RecHitGpuCpuFlags"));
 
     int iSubdet(collection == kEBGpuRecHit ? EcalBarrel : EcalEndcap);
 
     // Get CpuRecHits saved from GpuTask::runOnCpuRecHits() for this event
     // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons)
     EcalRecHitCollection const* cpuHits = (iSubdet == EcalBarrel) ? EBCpuRecHits_ : EECpuRecHits_;
     if (!cpuHits) {
       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
                                  << "CpuRecHits Collection. Aborting runOnGpuRecHits\n";
       return;
     }
 
     unsigned nGpuHits(gpuHits.size());
     unsigned nCpuHits(cpuHits->size());
 
     meRecHitGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits);
 
     if (gpuOnlyPlots_) {
       MESet& meRecHitGpu(MEs_.at("RecHitGpu"));
       meRecHitGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
     }
 
     for (auto const& gpuHit : gpuHits) {
       // Find CpuRecHit with matching DetId
       DetId gpuId(gpuHit.detid());
       EcalRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId));
       if (cpuItr == cpuHits->end()) {
         edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuRecHit DetId " << gpuId.rawId()
                                    << " in CPU collection\n";
         continue;
       }
 
       float gpuEnergy(gpuHit.energy());
       float gpuTime(gpuHit.time());
       uint32_t gpuFlags(gpuHit.flagsBits());
 
       float cpuEnergy(cpuItr->energy());
       float cpuTime(cpuItr->time());
       uint32_t cpuFlags(cpuItr->flagsBits());
 
       meRecHitGpuCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy - cpuEnergy);
       meRecHitGpuCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime - cpuTime);
       meRecHitGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags);
 
       if (gpuOnlyPlots_) {
         MESet& meRecHitGpuEnergy(MEs_.at("RecHitGpuEnergy"));
         MESet& meRecHitGpuTime(MEs_.at("RecHitGpuTime"));
         MESet& meRecHitGpuFlags(MEs_.at("RecHitGpuFlags"));
 
         meRecHitGpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy);
         meRecHitGpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime);
         meRecHitGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags);
       }
     }
   }

◆ runOnGpuUncalibRecHits()

void ecaldqm::GpuTask::runOnGpuUncalibRecHits	(	EcalUncalibratedRecHitCollection const &	gpuHits,
		Collections	collection
	)

Definition at line 262 of file GpuTask.cc.

References ecaldqm::MESetCollection::at(), universalConfigTemplate::collection, EBCpuUncalibRecHits_, EcalBarrel, EcalEndcap, EECpuUncalibRecHits_, edm::SortedCollection< T, SORT >::end(), ecaldqm::MESetMulti::fill(), ecaldqm::MESet::fill(), edm::SortedCollection< T, SORT >::find(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), gpuOnlyPlots_, ecaldqm::kEBGpuUncalibRecHit, ecaldqm::DQWorker::MEs_, edm::SortedCollection< T, SORT >::size(), and uncalibOOTAmps_.

Referenced by analyze().

                                                                                                               {
     MESet& meUncalibGpuCpu(MEs_.at("UncalibGpuCpu"));
     MESet& meUncalibGpuCpuAmp(MEs_.at("UncalibGpuCpuAmp"));
     MESet& meUncalibGpuCpuAmpError(MEs_.at("UncalibGpuCpuAmpError"));
     MESet& meUncalibGpuCpuPedestal(MEs_.at("UncalibGpuCpuPedestal"));
     MESet& meUncalibGpuCpuJitter(MEs_.at("UncalibGpuCpuJitter"));
     MESet& meUncalibGpuCpuJitterError(MEs_.at("UncalibGpuCpuJitterError"));
     MESet& meUncalibGpuCpuChi2(MEs_.at("UncalibGpuCpuChi2"));
     MESet& meUncalibGpuCpuOOTAmp(MEs_.at("UncalibGpuCpuOOTAmp"));
     MESet& meUncalibGpuCpuFlags(MEs_.at("UncalibGpuCpuFlags"));
 
     int iSubdet(collection == kEBGpuUncalibRecHit ? EcalBarrel : EcalEndcap);
 
     // Get CpuUncalibRecHits saved from GpuTask::runOnCpuUncalibRecHits() for this event
     // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons)
     EcalUncalibratedRecHitCollection const* cpuHits =
         (iSubdet == EcalBarrel) ? EBCpuUncalibRecHits_ : EECpuUncalibRecHits_;
     if (!cpuHits) {
       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
                                  << "CpuUncalibRecHits Collection. Aborting runOnGpuUncalibRecHits\n";
       return;
     }
 
     unsigned nGpuHits(gpuHits.size());
     unsigned nCpuHits(cpuHits->size());
 
     meUncalibGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits);
 
     if (gpuOnlyPlots_) {
       MESet& meUncalibGpu(MEs_.at("UncalibGpu"));
       meUncalibGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
     }
 
     for (auto const& gpuHit : gpuHits) {
       // Find CpuUncalibRecHit with matching DetId
       DetId gpuId(gpuHit.id());
       EcalUncalibratedRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId));
       if (cpuItr == cpuHits->end()) {
         edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuUncalibRecHit DetId " << gpuId.rawId()
                                    << " in CPU collection\n";
         continue;
       }
 
       float gpuAmp(gpuHit.amplitude());
       float gpuAmpError(gpuHit.amplitudeError());
       float gpuPedestal(gpuHit.pedestal());
       float gpuJitter(gpuHit.jitter());
       float gpuJitterError(gpuHit.jitterError());
       float gpuChi2(gpuHit.chi2());
       uint32_t gpuFlags(gpuHit.flags());
 
       if (gpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
         gpuJitterError = 0.249999;
 
       float cpuAmp(cpuItr->amplitude());
       float cpuAmpError(cpuItr->amplitudeError());
       float cpuPedestal(cpuItr->pedestal());
       float cpuJitter(cpuItr->jitter());
       float cpuJitterError(cpuItr->jitterError());
       float cpuChi2(cpuItr->chi2());
       uint32_t cpuFlags(cpuItr->flags());
 
       if (cpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
         cpuJitterError = 0.249999;
 
       meUncalibGpuCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp);
       meUncalibGpuCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError - cpuAmpError);
       meUncalibGpuCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal - cpuPedestal);
       meUncalibGpuCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter - cpuJitter);
       meUncalibGpuCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError - cpuJitterError);
       meUncalibGpuCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2 - cpuChi2);
       meUncalibGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags);
 
       if (gpuOnlyPlots_) {
         MESet& meUncalibGpuAmp(MEs_.at("UncalibGpuAmp"));
         MESet& meUncalibGpuAmpError(MEs_.at("UncalibGpuAmpError"));
         MESet& meUncalibGpuPedestal(MEs_.at("UncalibGpuPedestal"));
         MESet& meUncalibGpuJitter(MEs_.at("UncalibGpuJitter"));
         MESet& meUncalibGpuJitterError(MEs_.at("UncalibGpuJitterError"));
         MESet& meUncalibGpuChi2(MEs_.at("UncalibGpuChi2"));
         MESet& meUncalibGpuFlags(MEs_.at("UncalibGpuFlags"));
 
         meUncalibGpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp);
         meUncalibGpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError);
         meUncalibGpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal);
         meUncalibGpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter);
         meUncalibGpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError);
         meUncalibGpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2);
         meUncalibGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags);
       }
 
       for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) {
         static_cast<MESetMulti&>(meUncalibGpuCpuOOTAmp).use(iAmp);
 
         // Get corresponding OOT Amplitude
         int gpuOOTAmp(gpuHit.outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
         int cpuOOTAmp(cpuItr->outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
 
         meUncalibGpuCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp - cpuOOTAmp);
 
         if (gpuOnlyPlots_) {
           MESet& meUncalibGpuOOTAmp(MEs_.at("UncalibGpuOOTAmp"));
           static_cast<MESetMulti&>(meUncalibGpuOOTAmp).use(iAmp);
           meUncalibGpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp);
         }
       }
     }
   }

◆ setParams()

void ecaldqm::GpuTask::setParams ( edm::ParameterSet const & params )

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 38 of file GpuTask.cc.

References ecaldqm::MESetCollection::erase(), gpuOnlyPlots_, ecaldqm::DQWorker::MEs_, submitPVValidationJobs::params, runGpuTask_, AlCaHLTBitMon_QueryRunRegistry::string, and uncalibOOTAmps_.

                                                        {
     runGpuTask_ = params.getUntrackedParameter<bool>("runGpuTask");
     // Only makes sense to run GPU-only plots if we're running at all...
     gpuOnlyPlots_ = runGpuTask_ && params.getUntrackedParameter<bool>("gpuOnlyPlots");
     uncalibOOTAmps_ = params.getUntrackedParameter<std::vector<int> >("uncalibOOTAmps");
 
     if (!runGpuTask_) {
       MEs_.erase(std::string("DigiCpuAmplitude"));
       MEs_.erase(std::string("DigiGpuCpuAmplitude"));
       MEs_.erase(std::string("UncalibCpu"));
       MEs_.erase(std::string("UncalibCpuAmp"));
       MEs_.erase(std::string("UncalibCpuAmpError"));
       MEs_.erase(std::string("UncalibCpuPedestal"));
       MEs_.erase(std::string("UncalibCpuJitter"));
       MEs_.erase(std::string("UncalibCpuJitterError"));
       MEs_.erase(std::string("UncalibCpuChi2"));
       MEs_.erase(std::string("UncalibCpuOOTAmp"));
       MEs_.erase(std::string("UncalibCpuFlags"));
       MEs_.erase(std::string("UncalibGpuCpu"));
       MEs_.erase(std::string("UncalibGpuCpuAmp"));
       MEs_.erase(std::string("UncalibGpuCpuAmpError"));
       MEs_.erase(std::string("UncalibGpuCpuPedestal"));
       MEs_.erase(std::string("UncalibGpuCpuJitter"));
       MEs_.erase(std::string("UncalibGpuCpuJitterError"));
       MEs_.erase(std::string("UncalibGpuCpuChi2"));
       MEs_.erase(std::string("UncalibGpuCpuOOTAmp"));
       MEs_.erase(std::string("UncalibGpuCpuFlags"));
       MEs_.erase(std::string("RecHitCpu"));
       MEs_.erase(std::string("RecHitCpuEnergy"));
       MEs_.erase(std::string("RecHitCpuTime"));
       MEs_.erase(std::string("RecHitCpuFlags"));
       MEs_.erase(std::string("RecHitGpuCpu"));
       MEs_.erase(std::string("RecHitGpuCpuEnergy"));
       MEs_.erase(std::string("RecHitGpuCpuTime"));
       MEs_.erase(std::string("RecHitGpuCpuFlags"));
     }
     if (!gpuOnlyPlots_) {
       MEs_.erase(std::string("DigiGpuAmplitude"));
       MEs_.erase(std::string("RecHitGpu"));
       MEs_.erase(std::string("RecHitGpuEnergy"));
       MEs_.erase(std::string("RecHitGpuTime"));
       MEs_.erase(std::string("RecHitGpuFlags"));
       MEs_.erase(std::string("UncalibGpu"));
       MEs_.erase(std::string("UncalibGpuAmp"));
       MEs_.erase(std::string("UncalibGpuAmpError"));
       MEs_.erase(std::string("UncalibGpuPedestal"));
       MEs_.erase(std::string("UncalibGpuJitter"));
       MEs_.erase(std::string("UncalibGpuJitterError"));
       MEs_.erase(std::string("UncalibGpuChi2"));
       MEs_.erase(std::string("UncalibGpuOOTAmp"));
       MEs_.erase(std::string("UncalibGpuFlags"));
     }
   }

Member Data Documentation

◆ EBCpuDigis_

EBDigiCollection const* ecaldqm::GpuTask::EBCpuDigis_

private

Definition at line 39 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuDigis(), and runOnGpuDigis().

◆ EBCpuRecHits_

EcalRecHitCollection const* ecaldqm::GpuTask::EBCpuRecHits_

private

Definition at line 45 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuRecHits(), and runOnGpuRecHits().

◆ EBCpuUncalibRecHits_

EcalUncalibratedRecHitCollection const* ecaldqm::GpuTask::EBCpuUncalibRecHits_

private

Definition at line 42 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuUncalibRecHits(), and runOnGpuUncalibRecHits().

◆ EECpuDigis_

EEDigiCollection const* ecaldqm::GpuTask::EECpuDigis_

private

Definition at line 40 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuDigis(), and runOnGpuDigis().

◆ EECpuRecHits_

EcalRecHitCollection const* ecaldqm::GpuTask::EECpuRecHits_

private

Definition at line 46 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuRecHits(), and runOnGpuRecHits().

◆ EECpuUncalibRecHits_

EcalUncalibratedRecHitCollection const* ecaldqm::GpuTask::EECpuUncalibRecHits_

private

Definition at line 43 of file GpuTask.h.

Referenced by beginEvent(), runOnCpuUncalibRecHits(), and runOnGpuUncalibRecHits().

◆ gpuOnlyPlots_

bool ecaldqm::GpuTask::gpuOnlyPlots_

private

Definition at line 36 of file GpuTask.h.

Referenced by runOnGpuDigis(), runOnGpuRecHits(), runOnGpuUncalibRecHits(), and setParams().

◆ runGpuTask_

bool ecaldqm::GpuTask::runGpuTask_

private

Definition at line 35 of file GpuTask.h.

Referenced by addDependencies(), analyze(), and setParams().

◆ uncalibOOTAmps_

std::vector<int> ecaldqm::GpuTask::uncalibOOTAmps_

private

Definition at line 37 of file GpuTask.h.

Referenced by runOnCpuUncalibRecHits(), runOnGpuUncalibRecHits(), and setParams().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GpuTask()

◆ ~GpuTask()

Member Function Documentation

◆ addDependencies()

◆ analyze()

◆ beginEvent()

◆ filterRunType()

◆ runOnCpuDigis()

◆ runOnCpuRecHits()

◆ runOnCpuUncalibRecHits()

◆ runOnGpuDigis()

◆ runOnGpuRecHits()

◆ runOnGpuUncalibRecHits()

◆ setParams()

Member Data Documentation

◆ EBCpuDigis_

◆ EBCpuRecHits_

◆ EBCpuUncalibRecHits_

◆ EECpuDigis_

◆ EECpuRecHits_

◆ EECpuUncalibRecHits_

◆ gpuOnlyPlots_

◆ runGpuTask_

◆ uncalibOOTAmps_