Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-01-04 00:29:34 

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