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
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
0054 enableDigi_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableDigi");
0055 enableUncalib_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableUncalib");
0056 enableRecHit_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableRecHit");
0057
0058
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
0192
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
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
0225
0226
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
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
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
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)
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
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
0359
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
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)
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)
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
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
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
0536
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
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 }