ecaldqm::GpuTask Class Reference

#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 &)
bool	checkElectronicsMap (bool=true)
bool	checkGeometry (bool=true)
bool	checkTopology (bool=true)
bool	checkTrigTowerMap (bool=true)
	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
bool	digi1D_
bool	digi2D_
EBDigiCollection const *	EBCpuDigis_
EcalRecHitCollection const *	EBCpuRecHits_
EcalUncalibratedRecHitCollection const *	EBCpuUncalibRecHits_
EEDigiCollection const *	EECpuDigis_
EcalRecHitCollection const *	EECpuRecHits_
EcalUncalibratedRecHitCollection const *	EECpuUncalibRecHits_
bool	enableDigi_
bool	enableRecHit_
bool	enableUncalib_
bool	rechit1D_
bool	rechit2D_
bool	runGpuTask_
bool	uncalib1D_
bool	uncalib2D_
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),
        enableDigi_(false),
        enableUncalib_(false),
        enableRecHit_(false),
        digi1D_(false),
        digi2D_(false),
        uncalib1D_(false),
        uncalib2D_(false),
        rechit1D_(false),
        rechit2D_(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 32 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 59 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 155 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 144 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 165 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                    {
    // Return if not enabled
    if (!enableDigi_)
      return;

    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 479 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                           {
    // Return if not enabled
    if (!enableRecHit_)
      return;

    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 281 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                                              {
    // Return if not enabled
    if (!enableUncalib_)
      return;

    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 202 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                    {
    // Return if not enabled
    if (!enableDigi_)
      return;

    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 (digi1D_) {
      MESet& meDigiGpu(MEs_.at("DigiGpu"));
      meDigiGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis);
    }

    if (digi2D_) {
      MESet& meDigi2D(MEs_.at("Digi2D"));
      meDigi2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuDigis, 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 (digi1D_) {
          MESet& meDigiGpuAmplitude(MEs_.at("DigiGpuAmplitude"));
          static_cast<MESetMulti&>(meDigiGpuAmplitude).use(iSample);
          meDigiGpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp);
        }

        if (digi2D_) {
          MESet& meDigi2DAmplitude(MEs_.at("Digi2DAmplitude"));
          static_cast<MESetMulti&>(meDigi2DAmplitude).use(iSample);
          meDigi2DAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp, gpuAmp);
        }
      }
    }
  }

runOnGpuRecHits()

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

Definition at line 511 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                           {
    // Return if not enabled
    if (!enableRecHit_)
      return;

    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 (rechit1D_) {
      MESet& meRecHitGpu(MEs_.at("RecHitGpu"));
      meRecHitGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
    }
    if (rechit2D_) {
      MESet& meRecHit2D(MEs_.at("RecHit2D"));
      meRecHit2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits, 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 (rechit1D_) {
        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);
      }

      if (rechit2D_) {
        MESet& meRecHit2DEnergy(MEs_.at("RecHit2DEnergy"));
        MESet& meRecHit2DTime(MEs_.at("RecHit2DTime"));
        MESet& meRecHit2DFlags(MEs_.at("RecHit2DFlags"));

        meRecHit2DEnergy.fill(getEcalDQMSetupObjects(), iSubdet, cpuEnergy, gpuEnergy);
        meRecHit2DTime.fill(getEcalDQMSetupObjects(), iSubdet, cpuTime, gpuTime);
        meRecHit2DFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags, gpuFlags);
      }
    }
  }

runOnGpuUncalibRecHits()

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

Definition at line 337 of file GpuTask.cc.

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

Referenced by analyze().

                                                                                                              {
    // Return if not enabled
    if (!enableUncalib_)
      return;

    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 (uncalib1D_) {
      MESet& meUncalibGpu(MEs_.at("UncalibGpu"));
      meUncalibGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
    }

    if (uncalib2D_) {
      MESet& meUncalib2D(MEs_.at("Uncalib2D"));
      meUncalib2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits, 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 (uncalib1D_) {
        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);
      }

      if (uncalib2D_) {
        MESet& meUncalib2DAmp(MEs_.at("Uncalib2DAmp"));
        MESet& meUncalib2DAmpError(MEs_.at("Uncalib2DAmpError"));
        MESet& meUncalib2DPedestal(MEs_.at("Uncalib2DPedestal"));
        MESet& meUncalib2DJitter(MEs_.at("Uncalib2DJitter"));
        MESet& meUncalib2DJitterError(MEs_.at("Uncalib2DJitterError"));
        MESet& meUncalib2DChi2(MEs_.at("Uncalib2DChi2"));
        MESet& meUncalib2DFlags(MEs_.at("Uncalib2DFlags"));

        meUncalib2DAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp, gpuAmp);
        meUncalib2DAmpError.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmpError, gpuAmpError);
        meUncalib2DPedestal.fill(getEcalDQMSetupObjects(), iSubdet, cpuPedestal, gpuPedestal);
        meUncalib2DJitter.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitter, gpuJitter);
        meUncalib2DJitterError.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitterError, gpuJitterError);
        meUncalib2DChi2.fill(getEcalDQMSetupObjects(), iSubdet, cpuChi2, gpuChi2);
        meUncalib2DFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags, 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 (uncalib1D_) {
          MESet& meUncalibGpuOOTAmp(MEs_.at("UncalibGpuOOTAmp"));
          static_cast<MESetMulti&>(meUncalibGpuOOTAmp).use(iAmp);
          meUncalibGpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp);
        }

        if (uncalib2D_) {
          MESet& meUncalib2DOOTAmp(MEs_.at("Uncalib2DOOTAmp"));
          static_cast<MESetMulti&>(meUncalib2DOOTAmp).use(iAmp);
          meUncalib2DOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuOOTAmp, gpuOOTAmp);
        }
      }
    }
  }

setParams()

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 46 of file GpuTask.cc.

References digi1D_, digi2D_, enableDigi_, enableRecHit_, enableUncalib_, ecaldqm::MESetCollection::erase(), ecaldqm::DQWorker::MEs_, submitPVValidationJobs::params, rechit1D_, rechit2D_, runGpuTask_, AlCaHLTBitMon_QueryRunRegistry::string, uncalib1D_, uncalib2D_, and uncalibOOTAmps_.

                                                       {
    runGpuTask_ = params.getUntrackedParameter<bool>("runGpuTask");

    // Enabling objects set to false if runGpuTask_ is false
    enableDigi_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableDigi");
    enableUncalib_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableUncalib");
    enableRecHit_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableRecHit");

    // Flags set to false if corresponding type is not enabled
    digi1D_ = enableDigi_ && params.getUntrackedParameter<bool>("digi1D");
    digi2D_ = enableDigi_ && params.getUntrackedParameter<bool>("digi2D");
    uncalib1D_ = enableUncalib_ && params.getUntrackedParameter<bool>("uncalib1D");
    uncalib2D_ = enableUncalib_ && params.getUntrackedParameter<bool>("uncalib2D");
    rechit1D_ = enableRecHit_ && params.getUntrackedParameter<bool>("rechit1D");
    rechit2D_ = enableRecHit_ && params.getUntrackedParameter<bool>("rechit2D");

    uncalibOOTAmps_ = params.getUntrackedParameter<std::vector<int> >("uncalibOOTAmps");

    if (!enableDigi_) {
      MEs_.erase(std::string("DigiCpu"));
      MEs_.erase(std::string("DigiCpuAmplitude"));
      MEs_.erase(std::string("DigiGpuCpu"));
      MEs_.erase(std::string("DigiGpuCpuAmplitude"));
    }
    if (!enableUncalib_) {
      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"));
    }
    if (!enableRecHit_) {
      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 (!digi1D_) {
      MEs_.erase(std::string("DigiGpu"));
      MEs_.erase(std::string("DigiGpuAmplitude"));
    }
    if (!uncalib1D_) {
      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"));
    }
    if (!rechit1D_) {
      MEs_.erase(std::string("RecHitGpu"));
      MEs_.erase(std::string("RecHitGpuEnergy"));
      MEs_.erase(std::string("RecHitGpuTime"));
      MEs_.erase(std::string("RecHitGpuFlags"));
    }
    if (!digi2D_) {
      MEs_.erase(std::string("Digi2D"));
      MEs_.erase(std::string("Digi2DAmplitude"));
    }
    if (!uncalib2D_) {
      MEs_.erase(std::string("Uncalib2D"));
      MEs_.erase(std::string("Uncalib2DAmp"));
      MEs_.erase(std::string("Uncalib2DAmpError"));
      MEs_.erase(std::string("Uncalib2DPedestal"));
      MEs_.erase(std::string("Uncalib2DJitter"));
      MEs_.erase(std::string("Uncalib2DJitterError"));
      MEs_.erase(std::string("Uncalib2DChi2"));
      MEs_.erase(std::string("Uncalib2DOOTAmp"));
      MEs_.erase(std::string("Uncalib2DFlags"));
    }
    if (!rechit2D_) {
      MEs_.erase(std::string("RecHit2D"));
      MEs_.erase(std::string("RecHit2DEnergy"));
      MEs_.erase(std::string("RecHit2DTime"));
      MEs_.erase(std::string("RecHit2DFlags"));
    }
  }

Member Data Documentation

digi1D_

bool ecaldqm::GpuTask::digi1D_

private

Definition at line 40 of file GpuTask.h.

Referenced by runOnGpuDigis(), and setParams().

digi2D_

bool ecaldqm::GpuTask::digi2D_

private

Definition at line 41 of file GpuTask.h.

Referenced by runOnGpuDigis(), and setParams().

EBCpuDigis_

EBDigiCollection const* ecaldqm::GpuTask::EBCpuDigis_

private

Definition at line 49 of file GpuTask.h.

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

EBCpuRecHits_

EcalRecHitCollection const* ecaldqm::GpuTask::EBCpuRecHits_

private

Definition at line 55 of file GpuTask.h.

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

EBCpuUncalibRecHits_

EcalUncalibratedRecHitCollection const* ecaldqm::GpuTask::EBCpuUncalibRecHits_

private

Definition at line 52 of file GpuTask.h.

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

EECpuDigis_

EEDigiCollection const* ecaldqm::GpuTask::EECpuDigis_

private

Definition at line 50 of file GpuTask.h.

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

EECpuRecHits_

EcalRecHitCollection const* ecaldqm::GpuTask::EECpuRecHits_

private

Definition at line 56 of file GpuTask.h.

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

EECpuUncalibRecHits_

EcalUncalibratedRecHitCollection const* ecaldqm::GpuTask::EECpuUncalibRecHits_

private

Definition at line 53 of file GpuTask.h.

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

enableDigi_

bool ecaldqm::GpuTask::enableDigi_

private

Definition at line 36 of file GpuTask.h.

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

enableRecHit_

bool ecaldqm::GpuTask::enableRecHit_

private

Definition at line 38 of file GpuTask.h.

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

enableUncalib_

bool ecaldqm::GpuTask::enableUncalib_

private

Definition at line 37 of file GpuTask.h.

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

rechit1D_

bool ecaldqm::GpuTask::rechit1D_

private

Definition at line 44 of file GpuTask.h.

Referenced by runOnGpuRecHits(), and setParams().

rechit2D_

bool ecaldqm::GpuTask::rechit2D_

private

Definition at line 45 of file GpuTask.h.

Referenced by runOnGpuRecHits(), and setParams().

runGpuTask_

bool ecaldqm::GpuTask::runGpuTask_

private

Definition at line 35 of file GpuTask.h.

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

uncalib1D_

bool ecaldqm::GpuTask::uncalib1D_

private

Definition at line 42 of file GpuTask.h.

Referenced by runOnGpuUncalibRecHits(), and setParams().

uncalib2D_

bool ecaldqm::GpuTask::uncalib2D_

private

Definition at line 43 of file GpuTask.h.

Referenced by runOnGpuUncalibRecHits(), and setParams().

uncalibOOTAmps_

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

private

Definition at line 47 of file GpuTask.h.

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