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
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
0050 enableDigi_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableDigi");
0051 enableUncalib_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableUncalib");
0052 enableRecHit_ = runGpuTask_ && params.getUntrackedParameter<bool>("enableRecHit");
0053
0054
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
0172
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
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
0205
0206
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
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
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
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)
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
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
0339
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
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)
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)
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
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
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
0500
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
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 }