Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-03-17 10:54:35 

0001 #include "DQM/EcalMonitorTasks/interface/GpuTask.h"
0002 
0003 #include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h"
0004 #include "DQM/EcalCommon/interface/MESetMulti.h"
0005 
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008 
0009 #include "DataFormats/EcalRawData/interface/EcalDCCHeaderBlock.h"
0010 #include "DataFormats/EcalDigi/interface/EcalConstants.h"
0011 
0012 namespace ecaldqm {
0013   GpuTask::GpuTask()
0014       : DQWorkerTask(),
0015         runGpuTask_(false),
0016         enableDigi_(false),
0017         enableUncalib_(false),
0018         enableRecHit_(false),
0019         digi1D_(false),
0020         digi2D_(false),
0021         uncalib1D_(false),
0022         uncalib2D_(false),
0023         rechit1D_(false),
0024         rechit2D_(false),
0025         EBCpuDigis_(nullptr),
0026         EECpuDigis_(nullptr),
0027         EBCpuUncalibRecHits_(nullptr),
0028         EECpuUncalibRecHits_(nullptr),
0029         EBCpuRecHits_(nullptr),
0030         EECpuRecHits_(nullptr) {}
0031 
0032   void GpuTask::addDependencies(DependencySet& dependencies) {
0033     // Ensure we run on CPU objects before GPU objects
0034     if (runGpuTask_) {
0035       dependencies.push_back(Dependency(kEBGpuDigi, kEBCpuDigi));
0036       dependencies.push_back(Dependency(kEEGpuDigi, kEECpuDigi));
0037 
0038       dependencies.push_back(Dependency(kEBGpuUncalibRecHit, kEBCpuUncalibRecHit));
0039       dependencies.push_back(Dependency(kEEGpuUncalibRecHit, kEECpuUncalibRecHit));
0040 
0041       dependencies.push_back(Dependency(kEBGpuRecHit, kEBCpuRecHit));
0042       dependencies.push_back(Dependency(kEEGpuRecHit, kEECpuRecHit));
0043     }
0044   }
0045 
0046   void GpuTask::setParams(edm::ParameterSet const& params) {
0047     runGpuTask_ = params.getUntrackedParameter<bool>("runGpuTask");
0048 
0049     // Enabling objects set to false if runGpuTask_ is false
0050     enableDigi_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableDigi");
0051     enableUncalib_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableUncalib");
0052     enableRecHit_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableRecHit");
0053 
0054     // Flags set to false if corresponding type is not enabled
0055     digi1D_ = enableDigi_ && params.getUntrackedParameter<bool>("digi1D");
0056     digi2D_ = enableDigi_ && params.getUntrackedParameter<bool>("digi2D");
0057     uncalib1D_ = enableUncalib_ && params.getUntrackedParameter<bool>("uncalib1D");
0058     uncalib2D_ = enableUncalib_ && params.getUntrackedParameter<bool>("uncalib2D");
0059     rechit1D_ = enableRecHit_ && params.getUntrackedParameter<bool>("rechit1D");
0060     rechit2D_ = enableRecHit_ && params.getUntrackedParameter<bool>("rechit2D");
0061 
0062     uncalibOOTAmps_ = params.getUntrackedParameter<std::vector<int> >("uncalibOOTAmps");
0063 
0064     if (!enableDigi_) {
0065       MEs_.erase(std::string("DigiCpu"));
0066       MEs_.erase(std::string("DigiCpuAmplitude"));
0067       MEs_.erase(std::string("DigiGpuCpu"));
0068       MEs_.erase(std::string("DigiGpuCpuAmplitude"));
0069     }
0070     if (!enableUncalib_) {
0071       MEs_.erase(std::string("UncalibCpu"));
0072       MEs_.erase(std::string("UncalibCpuAmp"));
0073       MEs_.erase(std::string("UncalibCpuAmpError"));
0074       MEs_.erase(std::string("UncalibCpuPedestal"));
0075       MEs_.erase(std::string("UncalibCpuJitter"));
0076       MEs_.erase(std::string("UncalibCpuJitterError"));
0077       MEs_.erase(std::string("UncalibCpuChi2"));
0078       MEs_.erase(std::string("UncalibCpuOOTAmp"));
0079       MEs_.erase(std::string("UncalibCpuFlags"));
0080       MEs_.erase(std::string("UncalibGpuCpu"));
0081       MEs_.erase(std::string("UncalibGpuCpuAmp"));
0082       MEs_.erase(std::string("UncalibGpuCpuAmpError"));
0083       MEs_.erase(std::string("UncalibGpuCpuPedestal"));
0084       MEs_.erase(std::string("UncalibGpuCpuJitter"));
0085       MEs_.erase(std::string("UncalibGpuCpuJitterError"));
0086       MEs_.erase(std::string("UncalibGpuCpuChi2"));
0087       MEs_.erase(std::string("UncalibGpuCpuOOTAmp"));
0088       MEs_.erase(std::string("UncalibGpuCpuFlags"));
0089     }
0090     if (!enableRecHit_) {
0091       MEs_.erase(std::string("RecHitCpu"));
0092       MEs_.erase(std::string("RecHitCpuEnergy"));
0093       MEs_.erase(std::string("RecHitCpuTime"));
0094       MEs_.erase(std::string("RecHitCpuFlags"));
0095       MEs_.erase(std::string("RecHitGpuCpu"));
0096       MEs_.erase(std::string("RecHitGpuCpuEnergy"));
0097       MEs_.erase(std::string("RecHitGpuCpuTime"));
0098       MEs_.erase(std::string("RecHitGpuCpuFlags"));
0099     }
0100     if (!digi1D_) {
0101       MEs_.erase(std::string("DigiGpu"));
0102       MEs_.erase(std::string("DigiGpuAmplitude"));
0103     }
0104     if (!uncalib1D_) {
0105       MEs_.erase(std::string("UncalibGpu"));
0106       MEs_.erase(std::string("UncalibGpuAmp"));
0107       MEs_.erase(std::string("UncalibGpuAmpError"));
0108       MEs_.erase(std::string("UncalibGpuPedestal"));
0109       MEs_.erase(std::string("UncalibGpuJitter"));
0110       MEs_.erase(std::string("UncalibGpuJitterError"));
0111       MEs_.erase(std::string("UncalibGpuChi2"));
0112       MEs_.erase(std::string("UncalibGpuOOTAmp"));
0113       MEs_.erase(std::string("UncalibGpuFlags"));
0114     }
0115     if (!rechit1D_) {
0116       MEs_.erase(std::string("RecHitGpu"));
0117       MEs_.erase(std::string("RecHitGpuEnergy"));
0118       MEs_.erase(std::string("RecHitGpuTime"));
0119       MEs_.erase(std::string("RecHitGpuFlags"));
0120     }
0121     if (!digi2D_) {
0122       MEs_.erase(std::string("Digi2D"));
0123       MEs_.erase(std::string("Digi2DAmplitude"));
0124     }
0125     if (!uncalib2D_) {
0126       MEs_.erase(std::string("Uncalib2D"));
0127       MEs_.erase(std::string("Uncalib2DAmp"));
0128       MEs_.erase(std::string("Uncalib2DAmpError"));
0129       MEs_.erase(std::string("Uncalib2DPedestal"));
0130       MEs_.erase(std::string("Uncalib2DJitter"));
0131       MEs_.erase(std::string("Uncalib2DJitterError"));
0132       MEs_.erase(std::string("Uncalib2DChi2"));
0133       MEs_.erase(std::string("Uncalib2DOOTAmp"));
0134       MEs_.erase(std::string("Uncalib2DFlags"));
0135     }
0136     if (!rechit2D_) {
0137       MEs_.erase(std::string("RecHit2D"));
0138       MEs_.erase(std::string("RecHit2DEnergy"));
0139       MEs_.erase(std::string("RecHit2DTime"));
0140       MEs_.erase(std::string("RecHit2DFlags"));
0141     }
0142   }
0143 
0144   bool GpuTask::filterRunType(short const* runType) {
0145     for (unsigned iFED(0); iFED != ecaldqm::nDCC; iFED++) {
0146       if (runType[iFED] == EcalDCCHeaderBlock::COSMIC || runType[iFED] == EcalDCCHeaderBlock::MTCC ||
0147           runType[iFED] == EcalDCCHeaderBlock::COSMICS_GLOBAL || runType[iFED] == EcalDCCHeaderBlock::PHYSICS_GLOBAL ||
0148           runType[iFED] == EcalDCCHeaderBlock::COSMICS_LOCAL || runType[iFED] == EcalDCCHeaderBlock::PHYSICS_LOCAL)
0149         return true;
0150     }
0151 
0152     return false;
0153   }
0154 
0155   void GpuTask::beginEvent(edm::Event const&, edm::EventSetup const&, bool const&, bool&) {
0156     EBCpuDigis_ = nullptr;
0157     EECpuDigis_ = nullptr;
0158     EBCpuUncalibRecHits_ = nullptr;
0159     EECpuUncalibRecHits_ = nullptr;
0160     EBCpuRecHits_ = nullptr;
0161     EECpuRecHits_ = nullptr;
0162   }
0163 
0164   template <typename DigiCollection>
0165   void GpuTask::runOnCpuDigis(DigiCollection const& cpuDigis, Collections collection) {
0166     MESet& meDigiCpu(MEs_.at("DigiCpu"));
0167     MESet& meDigiCpuAmplitude(MEs_.at("DigiCpuAmplitude"));
0168 
0169     int iSubdet(collection == kEBCpuDigi ? EcalBarrel : EcalEndcap);
0170 
0171     // Save CpuDigis for comparison with GpuDigis
0172     // "if constexpr" ensures cpuDigis is the correct type at compile time
0173     if constexpr (std::is_same_v<DigiCollection, EBDigiCollection>) {
0174       assert(iSubdet == EcalBarrel);
0175       EBCpuDigis_ = &cpuDigis;
0176     } else {
0177       assert(iSubdet == EcalEndcap);
0178       EECpuDigis_ = &cpuDigis;
0179     }
0180 
0181     unsigned nCpuDigis(cpuDigis.size());
0182     meDigiCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuDigis);
0183 
0184     for (auto const& cpuDigi : cpuDigis) {
0185       // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor
0186       EcalDataFrame cpuDataFrame(cpuDigi);
0187 
0188       for (unsigned iSample = 0; iSample < ecalPh1::sampleSize; iSample++) {
0189         static_cast<MESetMulti&>(meDigiCpuAmplitude).use(iSample);
0190 
0191         int cpuAmp(cpuDataFrame.sample(iSample).adc());
0192         meDigiCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp);
0193       }
0194     }
0195   }
0196 
0197   template <typename DigiCollection>
0198   void GpuTask::runOnGpuDigis(DigiCollection const& gpuDigis, Collections collection) {
0199     MESet& meDigiGpuCpu(MEs_.at("DigiGpuCpu"));
0200     MESet& meDigiGpuCpuAmplitude(MEs_.at("DigiGpuCpuAmplitude"));
0201 
0202     int iSubdet(collection == kEBGpuDigi ? EcalBarrel : EcalEndcap);
0203 
0204     // Get CpuDigis saved from GpuTask::runOnCpuDigis() for this event
0205     // "if constexpr" ensures cpuDigis is the correct type at compile time
0206     // Note: gpuDigis is a collection and cpuDigis is a pointer to a collection (for historical reasons)
0207     DigiCollection const* cpuDigis;
0208     if constexpr (std::is_same_v<DigiCollection, EBDigiCollection>) {
0209       assert(iSubdet == EcalBarrel);
0210       cpuDigis = EBCpuDigis_;
0211     } else {
0212       assert(iSubdet == EcalEndcap);
0213       cpuDigis = EECpuDigis_;
0214     }
0215 
0216     if (!cpuDigis) {
0217       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
0218                                  << "CpuDigis Collection. Aborting runOnGpuDigis\n";
0219       return;
0220     }
0221 
0222     unsigned nGpuDigis(gpuDigis.size());
0223     unsigned nCpuDigis(cpuDigis->size());
0224 
0225     meDigiGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis - nCpuDigis);
0226 
0227     if (digi1D_) {
0228       MESet& meDigiGpu(MEs_.at("DigiGpu"));
0229       meDigiGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis);
0230     }
0231 
0232     if (digi2D_) {
0233       MESet& meDigi2D(MEs_.at("Digi2D"));
0234       meDigi2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuDigis, nGpuDigis);
0235     }
0236 
0237     for (auto const& gpuDigi : gpuDigis) {
0238       // Find CpuDigi with matching DetId
0239       DetId gpuId(gpuDigi.id());
0240       typename DigiCollection::const_iterator cpuItr(cpuDigis->find(gpuId));
0241       if (cpuItr == cpuDigis->end()) {
0242         edm::LogWarning("EcalDQM") << "GpuTask: Did not find CpuDigi DetId " << gpuId.rawId() << " in CPU collection\n";
0243         continue;
0244       }
0245 
0246       // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor
0247       EcalDataFrame gpuDataFrame(gpuDigi);
0248       EcalDataFrame cpuDataFrame(*cpuItr);
0249 
0250       for (unsigned iSample = 0; iSample < ecalPh1::sampleSize; iSample++) {
0251         static_cast<MESetMulti&>(meDigiGpuCpuAmplitude).use(iSample);
0252 
0253         int gpuAmp(gpuDataFrame.sample(iSample).adc());
0254         int cpuAmp(cpuDataFrame.sample(iSample).adc());
0255 
0256         meDigiGpuCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp);
0257 
0258         if (digi1D_) {
0259           MESet& meDigiGpuAmplitude(MEs_.at("DigiGpuAmplitude"));
0260           static_cast<MESetMulti&>(meDigiGpuAmplitude).use(iSample);
0261           meDigiGpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp);
0262         }
0263 
0264         if (digi2D_) {
0265           MESet& meDigi2DAmplitude(MEs_.at("Digi2DAmplitude"));
0266           static_cast<MESetMulti&>(meDigi2DAmplitude).use(iSample);
0267           meDigi2DAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp, gpuAmp);
0268         }
0269       }
0270     }
0271   }
0272 
0273   void GpuTask::runOnCpuUncalibRecHits(EcalUncalibratedRecHitCollection const& cpuHits, Collections collection) {
0274     MESet& meUncalibCpu(MEs_.at("UncalibCpu"));
0275     MESet& meUncalibCpuAmp(MEs_.at("UncalibCpuAmp"));
0276     MESet& meUncalibCpuAmpError(MEs_.at("UncalibCpuAmpError"));
0277     MESet& meUncalibCpuPedestal(MEs_.at("UncalibCpuPedestal"));
0278     MESet& meUncalibCpuJitter(MEs_.at("UncalibCpuJitter"));
0279     MESet& meUncalibCpuJitterError(MEs_.at("UncalibCpuJitterError"));
0280     MESet& meUncalibCpuChi2(MEs_.at("UncalibCpuChi2"));
0281     MESet& meUncalibCpuOOTAmp(MEs_.at("UncalibCpuOOTAmp"));
0282     MESet& meUncalibCpuFlags(MEs_.at("UncalibCpuFlags"));
0283 
0284     int iSubdet(collection == kEBCpuUncalibRecHit ? EcalBarrel : EcalEndcap);
0285 
0286     // Save CpuUncalibRecHits for comparison with GpuUncalibRecHits
0287     if (iSubdet == EcalBarrel)
0288       EBCpuUncalibRecHits_ = &cpuHits;
0289     else
0290       EECpuUncalibRecHits_ = &cpuHits;
0291 
0292     unsigned nCpuHits(cpuHits.size());
0293     meUncalibCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits);
0294 
0295     for (auto const& cpuHit : cpuHits) {
0296       float cpuAmp(cpuHit.amplitude());
0297       float cpuAmpError(cpuHit.amplitudeError());
0298       float cpuPedestal(cpuHit.pedestal());
0299       float cpuJitter(cpuHit.jitter());
0300       float cpuJitterError(cpuHit.jitterError());
0301       float cpuChi2(cpuHit.chi2());
0302       uint32_t cpuFlags(cpuHit.flags());
0303 
0304       if (cpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
0305         cpuJitterError = 0.249999;
0306 
0307       meUncalibCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp);
0308       meUncalibCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmpError);
0309       meUncalibCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, cpuPedestal);
0310       meUncalibCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitter);
0311       meUncalibCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitterError);
0312       meUncalibCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, cpuChi2);
0313       meUncalibCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags);
0314 
0315       for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) {
0316         static_cast<MESetMulti&>(meUncalibCpuOOTAmp).use(iAmp);
0317 
0318         // Get corresponding OOT Amplitude
0319         int cpuOOTAmp(cpuHit.outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
0320         meUncalibCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuOOTAmp);
0321       }
0322     }
0323   }
0324 
0325   void GpuTask::runOnGpuUncalibRecHits(EcalUncalibratedRecHitCollection const& gpuHits, Collections collection) {
0326     MESet& meUncalibGpuCpu(MEs_.at("UncalibGpuCpu"));
0327     MESet& meUncalibGpuCpuAmp(MEs_.at("UncalibGpuCpuAmp"));
0328     MESet& meUncalibGpuCpuAmpError(MEs_.at("UncalibGpuCpuAmpError"));
0329     MESet& meUncalibGpuCpuPedestal(MEs_.at("UncalibGpuCpuPedestal"));
0330     MESet& meUncalibGpuCpuJitter(MEs_.at("UncalibGpuCpuJitter"));
0331     MESet& meUncalibGpuCpuJitterError(MEs_.at("UncalibGpuCpuJitterError"));
0332     MESet& meUncalibGpuCpuChi2(MEs_.at("UncalibGpuCpuChi2"));
0333     MESet& meUncalibGpuCpuOOTAmp(MEs_.at("UncalibGpuCpuOOTAmp"));
0334     MESet& meUncalibGpuCpuFlags(MEs_.at("UncalibGpuCpuFlags"));
0335 
0336     int iSubdet(collection == kEBGpuUncalibRecHit ? EcalBarrel : EcalEndcap);
0337 
0338     // Get CpuUncalibRecHits saved from GpuTask::runOnCpuUncalibRecHits() for this event
0339     // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons)
0340     EcalUncalibratedRecHitCollection const* cpuHits =
0341         (iSubdet == EcalBarrel) ? EBCpuUncalibRecHits_ : EECpuUncalibRecHits_;
0342     if (!cpuHits) {
0343       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
0344                                  << "CpuUncalibRecHits Collection. Aborting runOnGpuUncalibRecHits\n";
0345       return;
0346     }
0347 
0348     unsigned nGpuHits(gpuHits.size());
0349     unsigned nCpuHits(cpuHits->size());
0350 
0351     meUncalibGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits);
0352 
0353     if (uncalib1D_) {
0354       MESet& meUncalibGpu(MEs_.at("UncalibGpu"));
0355       meUncalibGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
0356     }
0357 
0358     if (uncalib2D_) {
0359       MESet& meUncalib2D(MEs_.at("Uncalib2D"));
0360       meUncalib2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits, nGpuHits);
0361     }
0362 
0363     for (auto const& gpuHit : gpuHits) {
0364       // Find CpuUncalibRecHit with matching DetId
0365       DetId gpuId(gpuHit.id());
0366       EcalUncalibratedRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId));
0367       if (cpuItr == cpuHits->end()) {
0368         edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuUncalibRecHit DetId " << gpuId.rawId()
0369                                    << " in CPU collection\n";
0370         continue;
0371       }
0372 
0373       float gpuAmp(gpuHit.amplitude());
0374       float gpuAmpError(gpuHit.amplitudeError());
0375       float gpuPedestal(gpuHit.pedestal());
0376       float gpuJitter(gpuHit.jitter());
0377       float gpuJitterError(gpuHit.jitterError());
0378       float gpuChi2(gpuHit.chi2());
0379       uint32_t gpuFlags(gpuHit.flags());
0380 
0381       if (gpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
0382         gpuJitterError = 0.249999;
0383 
0384       float cpuAmp(cpuItr->amplitude());
0385       float cpuAmpError(cpuItr->amplitudeError());
0386       float cpuPedestal(cpuItr->pedestal());
0387       float cpuJitter(cpuItr->jitter());
0388       float cpuJitterError(cpuItr->jitterError());
0389       float cpuChi2(cpuItr->chi2());
0390       uint32_t cpuFlags(cpuItr->flags());
0391 
0392       if (cpuJitterError == 10000)  // Set this so 10000 (special value) shows up in last bin
0393         cpuJitterError = 0.249999;
0394 
0395       meUncalibGpuCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp);
0396       meUncalibGpuCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError - cpuAmpError);
0397       meUncalibGpuCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal - cpuPedestal);
0398       meUncalibGpuCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter - cpuJitter);
0399       meUncalibGpuCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError - cpuJitterError);
0400       meUncalibGpuCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2 - cpuChi2);
0401       meUncalibGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags);
0402 
0403       if (uncalib1D_) {
0404         MESet& meUncalibGpuAmp(MEs_.at("UncalibGpuAmp"));
0405         MESet& meUncalibGpuAmpError(MEs_.at("UncalibGpuAmpError"));
0406         MESet& meUncalibGpuPedestal(MEs_.at("UncalibGpuPedestal"));
0407         MESet& meUncalibGpuJitter(MEs_.at("UncalibGpuJitter"));
0408         MESet& meUncalibGpuJitterError(MEs_.at("UncalibGpuJitterError"));
0409         MESet& meUncalibGpuChi2(MEs_.at("UncalibGpuChi2"));
0410         MESet& meUncalibGpuFlags(MEs_.at("UncalibGpuFlags"));
0411 
0412         meUncalibGpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp);
0413         meUncalibGpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError);
0414         meUncalibGpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal);
0415         meUncalibGpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter);
0416         meUncalibGpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError);
0417         meUncalibGpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2);
0418         meUncalibGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags);
0419       }
0420 
0421       if (uncalib2D_) {
0422         MESet& meUncalib2DAmp(MEs_.at("Uncalib2DAmp"));
0423         MESet& meUncalib2DAmpError(MEs_.at("Uncalib2DAmpError"));
0424         MESet& meUncalib2DPedestal(MEs_.at("Uncalib2DPedestal"));
0425         MESet& meUncalib2DJitter(MEs_.at("Uncalib2DJitter"));
0426         MESet& meUncalib2DJitterError(MEs_.at("Uncalib2DJitterError"));
0427         MESet& meUncalib2DChi2(MEs_.at("Uncalib2DChi2"));
0428         MESet& meUncalib2DFlags(MEs_.at("Uncalib2DFlags"));
0429 
0430         meUncalib2DAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp, gpuAmp);
0431         meUncalib2DAmpError.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmpError, gpuAmpError);
0432         meUncalib2DPedestal.fill(getEcalDQMSetupObjects(), iSubdet, cpuPedestal, gpuPedestal);
0433         meUncalib2DJitter.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitter, gpuJitter);
0434         meUncalib2DJitterError.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitterError, gpuJitterError);
0435         meUncalib2DChi2.fill(getEcalDQMSetupObjects(), iSubdet, cpuChi2, gpuChi2);
0436         meUncalib2DFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags, gpuFlags);
0437       }
0438 
0439       for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) {
0440         static_cast<MESetMulti&>(meUncalibGpuCpuOOTAmp).use(iAmp);
0441 
0442         // Get corresponding OOT Amplitude
0443         int gpuOOTAmp(gpuHit.outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
0444         int cpuOOTAmp(cpuItr->outOfTimeAmplitude(uncalibOOTAmps_[iAmp]));
0445 
0446         meUncalibGpuCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp - cpuOOTAmp);
0447 
0448         if (uncalib1D_) {
0449           MESet& meUncalibGpuOOTAmp(MEs_.at("UncalibGpuOOTAmp"));
0450           static_cast<MESetMulti&>(meUncalibGpuOOTAmp).use(iAmp);
0451           meUncalibGpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp);
0452         }
0453 
0454         if (uncalib2D_) {
0455           MESet& meUncalib2DOOTAmp(MEs_.at("Uncalib2DOOTAmp"));
0456           static_cast<MESetMulti&>(meUncalib2DOOTAmp).use(iAmp);
0457           meUncalib2DOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuOOTAmp, gpuOOTAmp);
0458         }
0459       }
0460     }
0461   }
0462 
0463   void GpuTask::runOnCpuRecHits(EcalRecHitCollection const& cpuHits, Collections collection) {
0464     MESet& meRecHitCpu(MEs_.at("RecHitCpu"));
0465     MESet& meRecHitCpuEnergy(MEs_.at("RecHitCpuEnergy"));
0466     MESet& meRecHitCpuTime(MEs_.at("RecHitCpuTime"));
0467     MESet& meRecHitCpuFlags(MEs_.at("RecHitCpuFlags"));
0468 
0469     int iSubdet(collection == kEBCpuRecHit ? EcalBarrel : EcalEndcap);
0470 
0471     // Save CpuRecHits for comparison with GpuRecHits
0472     if (iSubdet == EcalBarrel)
0473       EBCpuRecHits_ = &cpuHits;
0474     else
0475       EECpuRecHits_ = &cpuHits;
0476 
0477     unsigned nCpuHits(cpuHits.size());
0478     meRecHitCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits);
0479 
0480     for (auto const& cpuHit : cpuHits) {
0481       float cpuEnergy(cpuHit.energy());
0482       float cpuTime(cpuHit.time());
0483       uint32_t cpuFlags(cpuHit.flagsBits());
0484 
0485       meRecHitCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, cpuEnergy);
0486       meRecHitCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, cpuTime);
0487       meRecHitCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags);
0488     }
0489   }
0490 
0491   void GpuTask::runOnGpuRecHits(EcalRecHitCollection const& gpuHits, Collections collection) {
0492     MESet& meRecHitGpuCpu(MEs_.at("RecHitGpuCpu"));
0493     MESet& meRecHitGpuCpuEnergy(MEs_.at("RecHitGpuCpuEnergy"));
0494     MESet& meRecHitGpuCpuTime(MEs_.at("RecHitGpuCpuTime"));
0495     MESet& meRecHitGpuCpuFlags(MEs_.at("RecHitGpuCpuFlags"));
0496 
0497     int iSubdet(collection == kEBGpuRecHit ? EcalBarrel : EcalEndcap);
0498 
0499     // Get CpuRecHits saved from GpuTask::runOnCpuRecHits() for this event
0500     // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons)
0501     EcalRecHitCollection const* cpuHits = (iSubdet == EcalBarrel) ? EBCpuRecHits_ : EECpuRecHits_;
0502     if (!cpuHits) {
0503       edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE")
0504                                  << "CpuRecHits Collection. Aborting runOnGpuRecHits\n";
0505       return;
0506     }
0507 
0508     unsigned nGpuHits(gpuHits.size());
0509     unsigned nCpuHits(cpuHits->size());
0510 
0511     meRecHitGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits);
0512 
0513     if (rechit1D_) {
0514       MESet& meRecHitGpu(MEs_.at("RecHitGpu"));
0515       meRecHitGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits);
0516     }
0517     if (rechit2D_) {
0518       MESet& meRecHit2D(MEs_.at("RecHit2D"));
0519       meRecHit2D.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits, nGpuHits);
0520     }
0521 
0522     for (auto const& gpuHit : gpuHits) {
0523       // Find CpuRecHit with matching DetId
0524       DetId gpuId(gpuHit.detid());
0525       EcalRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId));
0526       if (cpuItr == cpuHits->end()) {
0527         edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuRecHit DetId " << gpuId.rawId()
0528                                    << " in CPU collection\n";
0529         continue;
0530       }
0531 
0532       float gpuEnergy(gpuHit.energy());
0533       float gpuTime(gpuHit.time());
0534       uint32_t gpuFlags(gpuHit.flagsBits());
0535 
0536       float cpuEnergy(cpuItr->energy());
0537       float cpuTime(cpuItr->time());
0538       uint32_t cpuFlags(cpuItr->flagsBits());
0539 
0540       meRecHitGpuCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy - cpuEnergy);
0541       meRecHitGpuCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime - cpuTime);
0542       meRecHitGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags);
0543 
0544       if (rechit1D_) {
0545         MESet& meRecHitGpuEnergy(MEs_.at("RecHitGpuEnergy"));
0546         MESet& meRecHitGpuTime(MEs_.at("RecHitGpuTime"));
0547         MESet& meRecHitGpuFlags(MEs_.at("RecHitGpuFlags"));
0548 
0549         meRecHitGpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy);
0550         meRecHitGpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime);
0551         meRecHitGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags);
0552       }
0553 
0554       if (rechit2D_) {
0555         MESet& meRecHit2DEnergy(MEs_.at("RecHit2DEnergy"));
0556         MESet& meRecHit2DTime(MEs_.at("RecHit2DTime"));
0557         MESet& meRecHit2DFlags(MEs_.at("RecHit2DFlags"));
0558 
0559         meRecHit2DEnergy.fill(getEcalDQMSetupObjects(), iSubdet, cpuEnergy, gpuEnergy);
0560         meRecHit2DTime.fill(getEcalDQMSetupObjects(), iSubdet, cpuTime, gpuTime);
0561         meRecHit2DFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags, gpuFlags);
0562       }
0563     }
0564   }
0565 
0566   DEFINE_ECALDQM_WORKER(GpuTask);
0567 }  // namespace ecaldqm
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!