File indexing completed on 2023-03-17 11:27:33
0001
0002
0003
0004
0005
0006
0007
0008 #include "CondFormats/EcalObjects/interface/EcalMGPAGainRatio.h"
0009 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0010 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
0011 #include "Validation/GlobalDigis/interface/GlobalDigisProducer.h"
0012
0013 GlobalDigisProducer::GlobalDigisProducer(const edm::ParameterSet &iPSet)
0014 : fName(""),
0015 verbosity(0),
0016 frequency(0),
0017 label(""),
0018 getAllProvenances(false),
0019 printProvenanceInfo(false),
0020 theCSCStripPedestalSum(0),
0021 theCSCStripPedestalCount(0),
0022 count(0) {
0023 std::string MsgLoggerCat = "GlobalDigisProducer_GlobalDigisProducer";
0024
0025
0026 fName = iPSet.getUntrackedParameter<std::string>("Name");
0027 verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
0028 frequency = iPSet.getUntrackedParameter<int>("Frequency");
0029 label = iPSet.getParameter<std::string>("Label");
0030 edm::ParameterSet m_Prov = iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
0031 getAllProvenances = m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
0032 printProvenanceInfo = m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");
0033
0034
0035 ECalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalEBSrc");
0036 ECalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalEESrc");
0037 ECalESSrc_ = iPSet.getParameter<edm::InputTag>("ECalESSrc");
0038 HCalSrc_ = iPSet.getParameter<edm::InputTag>("HCalSrc");
0039 HCalDigi_ = iPSet.getParameter<edm::InputTag>("HCalDigi");
0040 SiStripSrc_ = iPSet.getParameter<edm::InputTag>("SiStripSrc");
0041 SiPxlSrc_ = iPSet.getParameter<edm::InputTag>("SiPxlSrc");
0042 MuDTSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSrc");
0043 MuCSCStripSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCStripSrc");
0044 MuCSCWireSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCWireSrc");
0045
0046 ECalEBSrc_Token_ = consumes<EBDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalEBSrc"));
0047 ECalEESrc_Token_ = consumes<EEDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalEESrc"));
0048 ECalESSrc_Token_ = consumes<ESDigiCollection>(iPSet.getParameter<edm::InputTag>("ECalESSrc"));
0049 HCalSrc_Token_ = consumes<edm::PCaloHitContainer>(iPSet.getParameter<edm::InputTag>("HCalSrc"));
0050 HBHEDigi_Token_ = consumes<edm::SortedCollection<HBHEDataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0051 HODigi_Token_ = consumes<edm::SortedCollection<HODataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0052 HFDigi_Token_ = consumes<edm::SortedCollection<HFDataFrame>>(iPSet.getParameter<edm::InputTag>("HCalDigi"));
0053 SiStripSrc_Token_ = consumes<edm::DetSetVector<SiStripDigi>>(iPSet.getParameter<edm::InputTag>("SiStripSrc"));
0054 SiPxlSrc_Token_ = consumes<edm::DetSetVector<PixelDigi>>(iPSet.getParameter<edm::InputTag>("SiPxlSrc"));
0055 MuDTSrc_Token_ = consumes<DTDigiCollection>(iPSet.getParameter<edm::InputTag>("MuDTSrc"));
0056 MuCSCStripSrc_Token_ = consumes<CSCStripDigiCollection>(iPSet.getParameter<edm::InputTag>("MuCSCStripSrc"));
0057 MuCSCWireSrc_Token_ = consumes<CSCWireDigiCollection>(iPSet.getParameter<edm::InputTag>("MuCSCWireSrc"));
0058
0059 const std::string barrelHitsName("EcalHitsEB");
0060 const std::string endcapHitsName("EcalHitsEE");
0061 const std::string preshowerHitsName("EcalHitsES");
0062 EBHits_Token_ = consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("barrelHitsName")));
0063 EEHits_Token_ = consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("endcapHitsName")));
0064 ESHits_Token_ =
0065 consumes<CrossingFrame<PCaloHit>>(edm::InputTag(std::string("mix"), std::string("preshowerHitsName")));
0066
0067 ecalADCtoGevToken_ = esConsumes();
0068 tTopoToken_ = esConsumes();
0069 hcaldbToken_ = esConsumes();
0070
0071
0072 verbosity %= 10;
0073
0074
0075 produces<PGlobalDigi>(label);
0076
0077
0078 if (verbosity >= 0) {
0079 edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
0080 << "Initialized as EDProducer with parameter values:\n"
0081 << " Name = " << fName << "\n"
0082 << " Verbosity = " << verbosity << "\n"
0083 << " Frequency = " << frequency << "\n"
0084 << " Label = " << label << "\n"
0085 << " GetProv = " << getAllProvenances << "\n"
0086 << " PrintProv = " << printProvenanceInfo << "\n"
0087 << " ECalEBSrc = " << ECalEBSrc_.label() << ":" << ECalEBSrc_.instance() << "\n"
0088 << " ECalEESrc = " << ECalEESrc_.label() << ":" << ECalEESrc_.instance() << "\n"
0089 << " ECalESSrc = " << ECalESSrc_.label() << ":" << ECalESSrc_.instance() << "\n"
0090 << " HCalSrc = " << HCalSrc_.label() << ":" << HCalSrc_.instance() << "\n"
0091 << " HCalDigi = " << HCalDigi_.label() << ":" << HCalDigi_.instance() << "\n"
0092 << " SiStripSrc = " << SiStripSrc_.label() << ":" << SiStripSrc_.instance() << "\n"
0093 << " SiPixelSrc = " << SiPxlSrc_.label() << ":" << SiPxlSrc_.instance() << "\n"
0094 << " MuDTSrc = " << MuDTSrc_.label() << ":" << MuDTSrc_.instance() << "\n"
0095 << " MuCSCStripSrc = " << MuCSCStripSrc_.label() << ":" << MuCSCStripSrc_.instance()
0096 << "\n"
0097 << " MuCSCWireSrc = " << MuCSCWireSrc_.label() << ":" << MuCSCWireSrc_.instance()
0098 << "\n"
0099 << "===============================\n";
0100 }
0101
0102
0103
0104 ECalgainConv_[0] = 0.;
0105 ECalgainConv_[1] = 1.;
0106 ECalgainConv_[2] = 2.;
0107 ECalgainConv_[3] = 12.;
0108 ECalbarrelADCtoGeV_ = 0.035;
0109 ECalendcapADCtoGeV_ = 0.06;
0110 }
0111
0112 GlobalDigisProducer::~GlobalDigisProducer() {}
0113
0114 void GlobalDigisProducer::beginJob(void) {
0115 std::string MsgLoggerCat = "GlobalDigisProducer_beginJob";
0116
0117 EcalMGPAGainRatio *defaultRatios = new EcalMGPAGainRatio();
0118
0119 ECalgainConv_[0] = 0.;
0120 ECalgainConv_[1] = 1.;
0121 ECalgainConv_[2] = defaultRatios->gain12Over6();
0122 ECalgainConv_[3] = ECalgainConv_[2] * (defaultRatios->gain6Over1());
0123
0124 delete defaultRatios;
0125
0126 if (verbosity >= 0) {
0127 edm::LogInfo(MsgLoggerCat) << "Modified Calorimeter gain constants: g0 = " << ECalgainConv_[0]
0128 << ", g1 = " << ECalgainConv_[1] << ", g2 = " << ECalgainConv_[2]
0129 << ", g3 = " << ECalgainConv_[3];
0130
0131
0132
0133 }
0134
0135
0136 clear();
0137 return;
0138 }
0139
0140 void GlobalDigisProducer::endJob() {
0141 std::string MsgLoggerCat = "GlobalDigisProducer_endJob";
0142 if (verbosity >= 0)
0143 edm::LogInfo(MsgLoggerCat) << "Terminating having processed " << count << " events.";
0144 return;
0145 }
0146
0147 void GlobalDigisProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0148 std::string MsgLoggerCat = "GlobalDigisProducer_produce";
0149
0150
0151 ++count;
0152
0153
0154
0155 const EcalADCToGeVConstant *agc = &iSetup.getData(ecalADCtoGevToken_);
0156 ECalbarrelADCtoGeV_ = agc->getEBValue();
0157 ECalendcapADCtoGeV_ = agc->getEEValue();
0158 if (verbosity >= 0) {
0159 edm::LogInfo(MsgLoggerCat) << "Modified Calorimeter ADCtoGeV constants: barrel = " << ECalbarrelADCtoGeV_
0160 << ", endcap = " << ECalendcapADCtoGeV_;
0161 }
0162
0163
0164 edm::RunNumber_t nrun = iEvent.id().run();
0165 edm::EventNumber_t nevt = iEvent.id().event();
0166
0167 if (verbosity > 0) {
0168 edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count << " events total)";
0169 } else if (verbosity == 0) {
0170 if (nevt % frequency == 0 || nevt == 1) {
0171 edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count
0172 << " events total)";
0173 }
0174 }
0175
0176
0177 clear();
0178
0179
0180 if (getAllProvenances) {
0181 std::vector<const edm::StableProvenance *> AllProv;
0182 iEvent.getAllStableProvenance(AllProv);
0183
0184 if (verbosity >= 0)
0185 edm::LogInfo(MsgLoggerCat) << "Number of Provenances = " << AllProv.size();
0186
0187 if (printProvenanceInfo && (verbosity >= 0)) {
0188 TString eventout("\nProvenance info:\n");
0189
0190 for (unsigned int i = 0; i < AllProv.size(); ++i) {
0191 eventout += "\n ******************************";
0192 eventout += "\n Module : ";
0193
0194 eventout += AllProv[i]->moduleLabel();
0195 eventout += "\n ProductID : ";
0196
0197 eventout += AllProv[i]->productID().id();
0198 eventout += "\n ClassName : ";
0199
0200 eventout += AllProv[i]->className();
0201 eventout += "\n InstanceName : ";
0202
0203 eventout += AllProv[i]->productInstanceName();
0204 eventout += "\n BranchName : ";
0205
0206 eventout += AllProv[i]->branchName();
0207 }
0208 eventout += "\n ******************************\n";
0209 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0210 printProvenanceInfo = false;
0211 }
0212 getAllProvenances = false;
0213 }
0214
0215
0216
0217 fillECal(iEvent, iSetup);
0218
0219 fillHCal(iEvent, iSetup);
0220
0221 fillTrk(iEvent, iSetup);
0222
0223 fillMuon(iEvent, iSetup);
0224
0225 if (verbosity > 0)
0226 edm::LogInfo(MsgLoggerCat) << "Done gathering data from event.";
0227
0228
0229 std::unique_ptr<PGlobalDigi> pOut(new PGlobalDigi);
0230
0231 if (verbosity > 2)
0232 edm::LogInfo(MsgLoggerCat) << "Saving event contents:";
0233
0234
0235
0236 storeECal(*pOut);
0237
0238 storeHCal(*pOut);
0239
0240 storeTrk(*pOut);
0241
0242 storeMuon(*pOut);
0243
0244
0245 iEvent.put(std::move(pOut), label);
0246
0247 return;
0248 }
0249
0250 void GlobalDigisProducer::fillECal(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0251 std::string MsgLoggerCat = "GlobalDigisProducer_fillECal";
0252
0253 TString eventout;
0254 if (verbosity > 0)
0255 eventout = "\nGathering info:";
0256
0257
0258
0259 edm::Handle<CrossingFrame<PCaloHit>> crossingFrame;
0260
0261
0262
0263
0264
0265
0266
0267
0268
0269
0270 bool isBarrel = true;
0271 edm::Handle<EBDigiCollection> EcalDigiEB;
0272 iEvent.getByToken(ECalEBSrc_Token_, EcalDigiEB);
0273 if (!EcalDigiEB.isValid()) {
0274 edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiEB in event!";
0275 return;
0276 }
0277 if (EcalDigiEB->empty())
0278 isBarrel = false;
0279
0280 if (isBarrel) {
0281
0282 iEvent.getByToken(EBHits_Token_, crossingFrame);
0283 if (!crossingFrame.isValid()) {
0284 edm::LogWarning(MsgLoggerCat) << "Unable to find cal barrel crossingFrame in event!";
0285 return;
0286 }
0287
0288
0289
0290 std::unique_ptr<MixCollection<PCaloHit>> barrelHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0291
0292
0293 MapType ebSimMap;
0294 for (MixCollection<PCaloHit>::MixItr hitItr = barrelHits->begin(); hitItr != barrelHits->end(); ++hitItr) {
0295 EBDetId ebid = EBDetId(hitItr->id());
0296
0297 uint32_t crystid = ebid.rawId();
0298 ebSimMap[crystid] += hitItr->energy();
0299 }
0300
0301
0302 const EBDigiCollection *barrelDigi = EcalDigiEB.product();
0303
0304 std::vector<double> ebAnalogSignal;
0305 std::vector<double> ebADCCounts;
0306 std::vector<double> ebADCGains;
0307 ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES);
0308 ebADCCounts.reserve(EBDataFrame::MAXSAMPLES);
0309 ebADCGains.reserve(EBDataFrame::MAXSAMPLES);
0310
0311 int i = 0;
0312 for (unsigned int digis = 0; digis < EcalDigiEB->size(); ++digis) {
0313
0314
0315
0316
0317
0318 ++i;
0319
0320 EBDataFrame ebdf = (*barrelDigi)[digis];
0321 int nrSamples = ebdf.size();
0322
0323 EBDetId ebid = ebdf.id();
0324
0325
0326 double Emax = 0;
0327 int Pmax = 0;
0328 double pedestalPreSampleAnalog = 0.;
0329
0330 for (int sample = 0; sample < nrSamples; ++sample) {
0331
0332 ebAnalogSignal[sample] = 0.;
0333 ebADCCounts[sample] = 0.;
0334 ebADCGains[sample] = -1.;
0335 }
0336
0337
0338 for (int sample = 0; sample < nrSamples; ++sample) {
0339
0340
0341 EcalMGPASample thisSample = ebdf[sample];
0342 ebADCCounts[sample] = (thisSample.adc());
0343 ebADCGains[sample] = (thisSample.gainId());
0344 ebAnalogSignal[sample] = (ebADCCounts[sample] * ECalgainConv_[(int)ebADCGains[sample]] * ECalbarrelADCtoGeV_);
0345 if (Emax < ebAnalogSignal[sample]) {
0346 Emax = ebAnalogSignal[sample];
0347 Pmax = sample;
0348 }
0349 if (sample < 3) {
0350 pedestalPreSampleAnalog += ebADCCounts[sample] * ECalgainConv_[(int)ebADCGains[sample]] * ECalbarrelADCtoGeV_;
0351 }
0352 }
0353 pedestalPreSampleAnalog /= 3.;
0354
0355
0356 double Erec = Emax - pedestalPreSampleAnalog * ECalgainConv_[(int)ebADCGains[Pmax]];
0357
0358
0359 EBCalAEE.push_back(Erec);
0360 EBCalSHE.push_back(ebSimMap[ebid.rawId()]);
0361 EBCalmaxPos.push_back(Pmax);
0362 }
0363
0364 if (verbosity > 1) {
0365 eventout += "\n Number of EBDigis collected:.............. ";
0366 eventout += i;
0367 }
0368 }
0369
0370
0371
0372
0373 bool isEndCap = true;
0374 edm::Handle<EEDigiCollection> EcalDigiEE;
0375 iEvent.getByToken(ECalEESrc_Token_, EcalDigiEE);
0376 if (!EcalDigiEE.isValid()) {
0377 edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiEE in event!";
0378 return;
0379 }
0380 if (EcalDigiEE->empty())
0381 isEndCap = false;
0382
0383 if (isEndCap) {
0384
0385 iEvent.getByToken(EEHits_Token_, crossingFrame);
0386 if (!crossingFrame.isValid()) {
0387 edm::LogWarning(MsgLoggerCat) << "Unable to find cal endcap crossingFrame in event!";
0388 return;
0389 }
0390
0391
0392
0393 std::unique_ptr<MixCollection<PCaloHit>> endcapHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0394
0395
0396 MapType eeSimMap;
0397 for (MixCollection<PCaloHit>::MixItr hitItr = endcapHits->begin(); hitItr != endcapHits->end(); ++hitItr) {
0398 EEDetId eeid = EEDetId(hitItr->id());
0399
0400 uint32_t crystid = eeid.rawId();
0401 eeSimMap[crystid] += hitItr->energy();
0402 }
0403
0404
0405 const EEDigiCollection *endcapDigi = EcalDigiEE.product();
0406
0407 std::vector<double> eeAnalogSignal;
0408 std::vector<double> eeADCCounts;
0409 std::vector<double> eeADCGains;
0410 eeAnalogSignal.reserve(EEDataFrame::MAXSAMPLES);
0411 eeADCCounts.reserve(EEDataFrame::MAXSAMPLES);
0412 eeADCGains.reserve(EEDataFrame::MAXSAMPLES);
0413
0414 int i = 0;
0415
0416
0417
0418
0419 for (unsigned int digis = 0; digis < EcalDigiEE->size(); ++digis) {
0420 ++i;
0421
0422 EEDataFrame eedf = (*endcapDigi)[digis];
0423 int nrSamples = eedf.size();
0424
0425 EEDetId eeid = eedf.id();
0426
0427
0428 double Emax = 0;
0429 int Pmax = 0;
0430 double pedestalPreSampleAnalog = 0.;
0431
0432 for (int sample = 0; sample < nrSamples; ++sample) {
0433
0434 eeAnalogSignal[sample] = 0.;
0435 eeADCCounts[sample] = 0.;
0436 eeADCGains[sample] = -1.;
0437 }
0438
0439
0440 for (int sample = 0; sample < nrSamples; ++sample) {
0441
0442
0443 EcalMGPASample thisSample = eedf[sample];
0444
0445 eeADCCounts[sample] = (thisSample.adc());
0446 eeADCGains[sample] = (thisSample.gainId());
0447 eeAnalogSignal[sample] = (eeADCCounts[sample] * ECalgainConv_[(int)eeADCGains[sample]] * ECalbarrelADCtoGeV_);
0448 if (Emax < eeAnalogSignal[sample]) {
0449 Emax = eeAnalogSignal[sample];
0450 Pmax = sample;
0451 }
0452 if (sample < 3) {
0453 pedestalPreSampleAnalog += eeADCCounts[sample] * ECalgainConv_[(int)eeADCGains[sample]] * ECalbarrelADCtoGeV_;
0454 }
0455 }
0456 pedestalPreSampleAnalog /= 3.;
0457
0458
0459 double Erec = Emax - pedestalPreSampleAnalog * ECalgainConv_[(int)eeADCGains[Pmax]];
0460
0461
0462 EECalAEE.push_back(Erec);
0463 EECalSHE.push_back(eeSimMap[eeid.rawId()]);
0464 EECalmaxPos.push_back(Pmax);
0465 }
0466
0467 if (verbosity > 1) {
0468 eventout += "\n Number of EEDigis collected:.............. ";
0469 eventout += i;
0470 }
0471 }
0472
0473
0474
0475
0476 bool isPreshower = true;
0477 edm::Handle<ESDigiCollection> EcalDigiES;
0478 iEvent.getByToken(ECalESSrc_Token_, EcalDigiES);
0479 if (!EcalDigiES.isValid()) {
0480 edm::LogWarning(MsgLoggerCat) << "Unable to find EcalDigiES in event!";
0481 return;
0482 }
0483 if (EcalDigiES->empty())
0484 isPreshower = false;
0485
0486 if (isPreshower) {
0487
0488 iEvent.getByToken(ESHits_Token_, crossingFrame);
0489 if (!crossingFrame.isValid()) {
0490 edm::LogWarning(MsgLoggerCat) << "Unable to find cal preshower crossingFrame in event!";
0491 return;
0492 }
0493
0494
0495
0496 std::unique_ptr<MixCollection<PCaloHit>> preshowerHits(new MixCollection<PCaloHit>(crossingFrame.product()));
0497
0498
0499 MapType esSimMap;
0500 for (MixCollection<PCaloHit>::MixItr hitItr = preshowerHits->begin(); hitItr != preshowerHits->end(); ++hitItr) {
0501 ESDetId esid = ESDetId(hitItr->id());
0502
0503 uint32_t crystid = esid.rawId();
0504 esSimMap[crystid] += hitItr->energy();
0505 }
0506
0507
0508 const ESDigiCollection *preshowerDigi = EcalDigiES.product();
0509
0510 std::vector<double> esADCCounts;
0511 esADCCounts.reserve(ESDataFrame::MAXSAMPLES);
0512
0513 int i = 0;
0514 for (unsigned int digis = 0; digis < EcalDigiES->size(); ++digis) {
0515
0516
0517
0518
0519
0520 ++i;
0521
0522 ESDataFrame esdf = (*preshowerDigi)[digis];
0523 int nrSamples = esdf.size();
0524
0525 ESDetId esid = esdf.id();
0526
0527
0528 for (int sample = 0; sample < nrSamples; ++sample) {
0529
0530 esADCCounts[sample] = 0.;
0531 }
0532
0533
0534 for (int sample = 0; sample < nrSamples; ++sample) {
0535 ESSample thisSample = esdf[sample];
0536
0537 esADCCounts[sample] = (thisSample.adc());
0538 }
0539
0540 ESCalADC0.push_back(esADCCounts[0]);
0541 ESCalADC1.push_back(esADCCounts[1]);
0542 ESCalADC2.push_back(esADCCounts[2]);
0543 ESCalSHE.push_back(esSimMap[esid.rawId()]);
0544 }
0545
0546 if (verbosity > 1) {
0547 eventout += "\n Number of ESDigis collected:.............. ";
0548 eventout += i;
0549 }
0550 }
0551
0552 if (verbosity > 0)
0553 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0554
0555 return;
0556 }
0557
0558 void GlobalDigisProducer::storeECal(PGlobalDigi &product) {
0559 std::string MsgLoggerCat = "GlobalDigisProducer_storeECal";
0560
0561 if (verbosity > 2) {
0562 TString eventout("\n nEBDigis = ");
0563 eventout += EBCalmaxPos.size();
0564 for (unsigned int i = 0; i < EBCalmaxPos.size(); ++i) {
0565 eventout += "\n (maxPos, AEE, SHE) = (";
0566 eventout += EBCalmaxPos[i];
0567 eventout += ", ";
0568 eventout += EBCalAEE[i];
0569 eventout += ", ";
0570 eventout += EBCalSHE[i];
0571 eventout += ")";
0572 }
0573 eventout += "\n nEEDigis = ";
0574 eventout += EECalmaxPos.size();
0575 for (unsigned int i = 0; i < EECalmaxPos.size(); ++i) {
0576 eventout += "\n (maxPos, AEE, SHE) = (";
0577 eventout += EECalmaxPos[i];
0578 eventout += ", ";
0579 eventout += EECalAEE[i];
0580 eventout += ", ";
0581 eventout += EECalSHE[i];
0582 eventout += ")";
0583 }
0584 eventout += "\n nESDigis = ";
0585 eventout += ESCalADC0.size();
0586 for (unsigned int i = 0; i < ESCalADC0.size(); ++i) {
0587 eventout += "\n (ADC0, ADC1, ADC2, SHE) = (";
0588 eventout += ESCalADC0[i];
0589 eventout += ", ";
0590 eventout += ESCalADC1[i];
0591 eventout += ", ";
0592 eventout += ESCalADC2[i];
0593 eventout += ", ";
0594 eventout += ESCalSHE[i];
0595 eventout += ")";
0596 }
0597 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0598 }
0599
0600 product.putEBCalDigis(EBCalmaxPos, EBCalAEE, EBCalSHE);
0601 product.putEECalDigis(EECalmaxPos, EECalAEE, EECalSHE);
0602 product.putESCalDigis(ESCalADC0, ESCalADC1, ESCalADC2, ESCalSHE);
0603
0604 return;
0605 }
0606
0607 void GlobalDigisProducer::fillHCal(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0608 std::string MsgLoggerCat = "GlobalDigisProducer_fillHCal";
0609
0610 TString eventout;
0611 if (verbosity > 0)
0612 eventout = "\nGathering info:";
0613
0614
0615 const auto &HCalconditions = iSetup.getHandle(hcaldbToken_);
0616 if (!HCalconditions.isValid()) {
0617 edm::LogWarning(MsgLoggerCat) << "Unable to find HCalconditions in event!";
0618 return;
0619 }
0620
0621 CaloSamples tool;
0622
0623
0624
0625
0626 edm::Handle<edm::PCaloHitContainer> hcalHits;
0627 iEvent.getByToken(HCalSrc_Token_, hcalHits);
0628 if (!hcalHits.isValid()) {
0629 edm::LogWarning(MsgLoggerCat) << "Unable to find hcalHits in event!";
0630 return;
0631 }
0632 const edm::PCaloHitContainer *simhitResult = hcalHits.product();
0633
0634 MapType fHBEnergySimHits;
0635 MapType fHEEnergySimHits;
0636 MapType fHOEnergySimHits;
0637 MapType fHFEnergySimHits;
0638 for (std::vector<PCaloHit>::const_iterator simhits = simhitResult->begin(); simhits != simhitResult->end();
0639 ++simhits) {
0640 HcalDetId detId(simhits->id());
0641 uint32_t cellid = detId.rawId();
0642
0643 if (detId.subdet() == sdHcalBrl) {
0644 fHBEnergySimHits[cellid] += simhits->energy();
0645 }
0646 if (detId.subdet() == sdHcalEC) {
0647 fHEEnergySimHits[cellid] += simhits->energy();
0648 }
0649 if (detId.subdet() == sdHcalOut) {
0650 fHOEnergySimHits[cellid] += simhits->energy();
0651 }
0652 if (detId.subdet() == sdHcalFwd) {
0653 fHFEnergySimHits[cellid] += simhits->energy();
0654 }
0655 }
0656
0657
0658
0659
0660 edm::Handle<edm::SortedCollection<HBHEDataFrame>> hbhe;
0661 iEvent.getByToken(HBHEDigi_Token_, hbhe);
0662 if (!hbhe.isValid()) {
0663 edm::LogWarning(MsgLoggerCat) << "Unable to find HBHEDataFrame in event!";
0664 return;
0665 }
0666 edm::SortedCollection<HBHEDataFrame>::const_iterator ihbhe;
0667
0668 int iHB = 0;
0669 int iHE = 0;
0670 for (ihbhe = hbhe->begin(); ihbhe != hbhe->end(); ++ihbhe) {
0671 HcalDetId cell(ihbhe->id());
0672
0673 if ((cell.subdet() == sdHcalBrl) || (cell.subdet() == sdHcalEC)) {
0674
0675 const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0676 const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0677 const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0678
0679 HcalCoderDb coder(*channelCoder, *shape);
0680 coder.adc2fC(*ihbhe, tool);
0681
0682
0683 if (cell.subdet() == sdHcalBrl) {
0684 ++iHB;
0685 float fDigiSum = 0.0;
0686 for (int ii = 0; ii < tool.size(); ++ii) {
0687
0688 int capid = (*ihbhe)[ii].capid();
0689 fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0690 }
0691
0692 HBCalAEE.push_back(fDigiSum);
0693 HBCalSHE.push_back(fHBEnergySimHits[cell.rawId()]);
0694 }
0695
0696
0697 if (cell.subdet() == sdHcalEC) {
0698 ++iHE;
0699 float fDigiSum = 0.0;
0700 for (int ii = 0; ii < tool.size(); ++ii) {
0701 int capid = (*ihbhe)[ii].capid();
0702 fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0703 }
0704
0705 HECalAEE.push_back(fDigiSum);
0706 HECalSHE.push_back(fHEEnergySimHits[cell.rawId()]);
0707 }
0708 }
0709 }
0710
0711 if (verbosity > 1) {
0712 eventout += "\n Number of HBDigis collected:.............. ";
0713 eventout += iHB;
0714 }
0715
0716 if (verbosity > 1) {
0717 eventout += "\n Number of HEDigis collected:.............. ";
0718 eventout += iHE;
0719 }
0720
0721
0722
0723
0724 edm::Handle<edm::SortedCollection<HODataFrame>> ho;
0725 iEvent.getByToken(HODigi_Token_, ho);
0726 if (!ho.isValid()) {
0727 edm::LogWarning(MsgLoggerCat) << "Unable to find HODataFrame in event!";
0728 return;
0729 }
0730 edm::SortedCollection<HODataFrame>::const_iterator iho;
0731
0732 int iHO = 0;
0733 for (iho = ho->begin(); iho != ho->end(); ++iho) {
0734 HcalDetId cell(iho->id());
0735
0736 if (cell.subdet() == sdHcalOut) {
0737
0738 const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0739 const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0740 const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0741
0742 HcalCoderDb coder(*channelCoder, *shape);
0743 coder.adc2fC(*iho, tool);
0744
0745 ++iHO;
0746 float fDigiSum = 0.0;
0747 for (int ii = 0; ii < tool.size(); ++ii) {
0748
0749 int capid = (*iho)[ii].capid();
0750 fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0751 }
0752
0753 HOCalAEE.push_back(fDigiSum);
0754 HOCalSHE.push_back(fHOEnergySimHits[cell.rawId()]);
0755 }
0756 }
0757
0758 if (verbosity > 1) {
0759 eventout += "\n Number of HODigis collected:.............. ";
0760 eventout += iHO;
0761 }
0762
0763
0764
0765
0766 edm::Handle<edm::SortedCollection<HFDataFrame>> hf;
0767 iEvent.getByToken(HFDigi_Token_, hf);
0768 if (!hf.isValid()) {
0769 edm::LogWarning(MsgLoggerCat) << "Unable to find HFDataFrame in event!";
0770 return;
0771 }
0772 edm::SortedCollection<HFDataFrame>::const_iterator ihf;
0773
0774 int iHF = 0;
0775 for (ihf = hf->begin(); ihf != hf->end(); ++ihf) {
0776 HcalDetId cell(ihf->id());
0777
0778 if (cell.subdet() == sdHcalFwd) {
0779
0780 const HcalCalibrations &calibrations = HCalconditions->getHcalCalibrations(cell);
0781 const HcalQIECoder *channelCoder = HCalconditions->getHcalCoder(cell);
0782 const HcalQIEShape *shape = HCalconditions->getHcalShape(channelCoder);
0783
0784 HcalCoderDb coder(*channelCoder, *shape);
0785 coder.adc2fC(*ihf, tool);
0786
0787 ++iHF;
0788 float fDigiSum = 0.0;
0789 for (int ii = 0; ii < tool.size(); ++ii) {
0790
0791 int capid = (*ihf)[ii].capid();
0792 fDigiSum += (tool[ii] - calibrations.pedestal(capid));
0793 }
0794
0795 HFCalAEE.push_back(fDigiSum);
0796 HFCalSHE.push_back(fHFEnergySimHits[cell.rawId()]);
0797 }
0798 }
0799
0800 if (verbosity > 1) {
0801 eventout += "\n Number of HFDigis collected:.............. ";
0802 eventout += iHF;
0803 }
0804
0805 if (verbosity > 0)
0806 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0807
0808 return;
0809 }
0810
0811 void GlobalDigisProducer::storeHCal(PGlobalDigi &product) {
0812 std::string MsgLoggerCat = "GlobalDigisProducer_storeHCal";
0813
0814 if (verbosity > 2) {
0815 TString eventout("\n nHBDigis = ");
0816 eventout += HBCalAEE.size();
0817 for (unsigned int i = 0; i < HBCalAEE.size(); ++i) {
0818 eventout += "\n (AEE, SHE) = (";
0819 eventout += HBCalAEE[i];
0820 eventout += ", ";
0821 eventout += HBCalSHE[i];
0822 eventout += ")";
0823 }
0824 eventout += "\n nHEDigis = ";
0825 eventout += HECalAEE.size();
0826 for (unsigned int i = 0; i < HECalAEE.size(); ++i) {
0827 eventout += "\n (AEE, SHE) = (";
0828 eventout += HECalAEE[i];
0829 eventout += ", ";
0830 eventout += HECalSHE[i];
0831 eventout += ")";
0832 }
0833 eventout += "\n nHODigis = ";
0834 eventout += HOCalAEE.size();
0835 for (unsigned int i = 0; i < HOCalAEE.size(); ++i) {
0836 eventout += "\n (AEE, SHE) = (";
0837 eventout += HOCalAEE[i];
0838 eventout += ", ";
0839 eventout += HOCalSHE[i];
0840 eventout += ")";
0841 }
0842 eventout += "\n nHFDigis = ";
0843 eventout += HFCalAEE.size();
0844 for (unsigned int i = 0; i < HFCalAEE.size(); ++i) {
0845 eventout += "\n (AEE, SHE) = (";
0846 eventout += HFCalAEE[i];
0847 eventout += ", ";
0848 eventout += HFCalSHE[i];
0849 eventout += ")";
0850 }
0851
0852 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0853 }
0854
0855 product.putHBCalDigis(HBCalAEE, HBCalSHE);
0856 product.putHECalDigis(HECalAEE, HECalSHE);
0857 product.putHOCalDigis(HOCalAEE, HOCalSHE);
0858 product.putHFCalDigis(HFCalAEE, HFCalSHE);
0859
0860 return;
0861 }
0862
0863 void GlobalDigisProducer::fillTrk(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0864
0865 const TrackerTopology *const tTopo = &iSetup.getData(tTopoToken_);
0866
0867 std::string MsgLoggerCat = "GlobalDigisProducer_fillTrk";
0868
0869 TString eventout;
0870 if (verbosity > 0)
0871 eventout = "\nGathering info:";
0872
0873
0874 edm::Handle<edm::DetSetVector<SiStripDigi>> stripDigis;
0875 iEvent.getByToken(SiStripSrc_Token_, stripDigis);
0876 if (!stripDigis.isValid()) {
0877 edm::LogWarning(MsgLoggerCat) << "Unable to find stripDigis in event!";
0878 return;
0879 }
0880
0881 int nStripBrl = 0, nStripFwd = 0;
0882 edm::DetSetVector<SiStripDigi>::const_iterator DSViter;
0883 for (DSViter = stripDigis->begin(); DSViter != stripDigis->end(); ++DSViter) {
0884 unsigned int id = DSViter->id;
0885 DetId detId(id);
0886 edm::DetSet<SiStripDigi>::const_iterator begin = DSViter->data.begin();
0887 edm::DetSet<SiStripDigi>::const_iterator end = DSViter->data.end();
0888 edm::DetSet<SiStripDigi>::const_iterator iter;
0889
0890
0891 if (detId.subdetId() == sdSiTIB) {
0892 for (iter = begin; iter != end; ++iter) {
0893 ++nStripBrl;
0894 if (tTopo->tibLayer(id) == 1) {
0895 TIBL1ADC.push_back((*iter).adc());
0896 TIBL1Strip.push_back((*iter).strip());
0897 }
0898 if (tTopo->tibLayer(id) == 2) {
0899 TIBL2ADC.push_back((*iter).adc());
0900 TIBL2Strip.push_back((*iter).strip());
0901 }
0902 if (tTopo->tibLayer(id) == 3) {
0903 TIBL3ADC.push_back((*iter).adc());
0904 TIBL3Strip.push_back((*iter).strip());
0905 }
0906 if (tTopo->tibLayer(id) == 4) {
0907 TIBL4ADC.push_back((*iter).adc());
0908 TIBL4Strip.push_back((*iter).strip());
0909 }
0910 }
0911 }
0912
0913
0914 if (detId.subdetId() == sdSiTOB) {
0915 for (iter = begin; iter != end; ++iter) {
0916 ++nStripBrl;
0917 if (tTopo->tobLayer(id) == 1) {
0918 TOBL1ADC.push_back((*iter).adc());
0919 TOBL1Strip.push_back((*iter).strip());
0920 }
0921 if (tTopo->tobLayer(id) == 2) {
0922 TOBL2ADC.push_back((*iter).adc());
0923 TOBL2Strip.push_back((*iter).strip());
0924 }
0925 if (tTopo->tobLayer(id) == 3) {
0926 TOBL3ADC.push_back((*iter).adc());
0927 TOBL3Strip.push_back((*iter).strip());
0928 }
0929 if (tTopo->tobLayer(id) == 4) {
0930 TOBL4ADC.push_back((*iter).adc());
0931 TOBL4Strip.push_back((*iter).strip());
0932 }
0933 }
0934 }
0935
0936
0937 if (detId.subdetId() == sdSiTID) {
0938 for (iter = begin; iter != end; ++iter) {
0939 ++nStripFwd;
0940 if (tTopo->tidWheel(id) == 1) {
0941 TIDW1ADC.push_back((*iter).adc());
0942 TIDW1Strip.push_back((*iter).strip());
0943 }
0944 if (tTopo->tidWheel(id) == 2) {
0945 TIDW2ADC.push_back((*iter).adc());
0946 TIDW2Strip.push_back((*iter).strip());
0947 }
0948 if (tTopo->tidWheel(id) == 3) {
0949 TIDW3ADC.push_back((*iter).adc());
0950 TIDW3Strip.push_back((*iter).strip());
0951 }
0952 }
0953 }
0954
0955
0956 if (detId.subdetId() == sdSiTEC) {
0957 for (iter = begin; iter != end; ++iter) {
0958 ++nStripFwd;
0959 if (tTopo->tecWheel(id) == 1) {
0960 TECW1ADC.push_back((*iter).adc());
0961 TECW1Strip.push_back((*iter).strip());
0962 }
0963 if (tTopo->tecWheel(id) == 2) {
0964 TECW2ADC.push_back((*iter).adc());
0965 TECW2Strip.push_back((*iter).strip());
0966 }
0967 if (tTopo->tecWheel(id) == 3) {
0968 TECW3ADC.push_back((*iter).adc());
0969 TECW3Strip.push_back((*iter).strip());
0970 }
0971 if (tTopo->tecWheel(id) == 4) {
0972 TECW4ADC.push_back((*iter).adc());
0973 TECW4Strip.push_back((*iter).strip());
0974 }
0975 if (tTopo->tecWheel(id) == 5) {
0976 TECW5ADC.push_back((*iter).adc());
0977 TECW5Strip.push_back((*iter).strip());
0978 }
0979 if (tTopo->tecWheel(id) == 6) {
0980 TECW6ADC.push_back((*iter).adc());
0981 TECW6Strip.push_back((*iter).strip());
0982 }
0983 if (tTopo->tecWheel(id) == 7) {
0984 TECW7ADC.push_back((*iter).adc());
0985 TECW7Strip.push_back((*iter).strip());
0986 }
0987 if (tTopo->tecWheel(id) == 8) {
0988 TECW8ADC.push_back((*iter).adc());
0989 TECW8Strip.push_back((*iter).strip());
0990 }
0991 }
0992 }
0993 }
0994
0995 if (verbosity > 1) {
0996 eventout += "\n Number of BrlStripDigis collected:........ ";
0997 eventout += nStripBrl;
0998 }
0999
1000 if (verbosity > 1) {
1001 eventout += "\n Number of FrwdStripDigis collected:....... ";
1002 eventout += nStripFwd;
1003 }
1004
1005
1006 edm::Handle<edm::DetSetVector<PixelDigi>> pixelDigis;
1007 iEvent.getByToken(SiPxlSrc_Token_, pixelDigis);
1008 if (!pixelDigis.isValid()) {
1009 edm::LogWarning(MsgLoggerCat) << "Unable to find pixelDigis in event!";
1010 return;
1011 }
1012
1013 int nPxlBrl = 0, nPxlFwd = 0;
1014 edm::DetSetVector<PixelDigi>::const_iterator DPViter;
1015 for (DPViter = pixelDigis->begin(); DPViter != pixelDigis->end(); ++DPViter) {
1016 unsigned int id = DPViter->id;
1017 DetId detId(id);
1018 edm::DetSet<PixelDigi>::const_iterator begin = DPViter->data.begin();
1019 edm::DetSet<PixelDigi>::const_iterator end = DPViter->data.end();
1020 edm::DetSet<PixelDigi>::const_iterator iter;
1021
1022
1023 if (detId.subdetId() == sdPxlBrl) {
1024 for (iter = begin; iter != end; ++iter) {
1025 ++nPxlBrl;
1026 if (tTopo->pxbLayer(id) == 1) {
1027 BRL1ADC.push_back((*iter).adc());
1028 BRL1Row.push_back((*iter).row());
1029 BRL1Col.push_back((*iter).column());
1030 }
1031 if (tTopo->pxbLayer(id) == 2) {
1032 BRL2ADC.push_back((*iter).adc());
1033 BRL2Row.push_back((*iter).row());
1034 BRL2Col.push_back((*iter).column());
1035 }
1036 if (tTopo->pxbLayer(id) == 3) {
1037 BRL3ADC.push_back((*iter).adc());
1038 BRL3Row.push_back((*iter).row());
1039 BRL3Col.push_back((*iter).column());
1040 }
1041 }
1042 }
1043
1044
1045 if (detId.subdetId() == sdPxlFwd) {
1046 for (iter = begin; iter != end; ++iter) {
1047 ++nPxlFwd;
1048 if (tTopo->pxfDisk(id) == 1) {
1049 if (tTopo->pxfSide(id) == 1) {
1050 FWD1nADC.push_back((*iter).adc());
1051 FWD1nRow.push_back((*iter).row());
1052 FWD1nCol.push_back((*iter).column());
1053 }
1054 if (tTopo->pxfSide(id) == 2) {
1055 FWD1pADC.push_back((*iter).adc());
1056 FWD1pRow.push_back((*iter).row());
1057 FWD1pCol.push_back((*iter).column());
1058 }
1059 }
1060 if (tTopo->pxfDisk(id) == 2) {
1061 if (tTopo->pxfSide(id) == 1) {
1062 FWD2nADC.push_back((*iter).adc());
1063 FWD2nRow.push_back((*iter).row());
1064 FWD2nCol.push_back((*iter).column());
1065 }
1066 if (tTopo->pxfSide(id) == 2) {
1067 FWD2pADC.push_back((*iter).adc());
1068 FWD2pRow.push_back((*iter).row());
1069 FWD2pCol.push_back((*iter).column());
1070 }
1071 }
1072 }
1073 }
1074 }
1075
1076 if (verbosity > 1) {
1077 eventout += "\n Number of BrlPixelDigis collected:........ ";
1078 eventout += nPxlBrl;
1079 }
1080
1081 if (verbosity > 1) {
1082 eventout += "\n Number of FrwdPixelDigis collected:....... ";
1083 eventout += nPxlFwd;
1084 }
1085
1086 if (verbosity > 0)
1087 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1088
1089 return;
1090 }
1091
1092 void GlobalDigisProducer::storeTrk(PGlobalDigi &product) {
1093 std::string MsgLoggerCat = "GlobalDigisProducer_storeTrk";
1094
1095 if (verbosity > 2) {
1096
1097 TString eventout("\n nTIBL1 = ");
1098 eventout += TIBL1ADC.size();
1099 for (unsigned int i = 0; i < TIBL1ADC.size(); ++i) {
1100 eventout += "\n (ADC, strip) = (";
1101 eventout += TIBL1ADC[i];
1102 eventout += ", ";
1103 eventout += TIBL1Strip[i];
1104 eventout += ")";
1105 }
1106 eventout += "\n nTIBL2 = ";
1107 eventout += TIBL2ADC.size();
1108 for (unsigned int i = 0; i < TIBL2ADC.size(); ++i) {
1109 eventout += "\n (ADC, strip) = (";
1110 eventout += TIBL2ADC[i];
1111 eventout += ", ";
1112 eventout += TIBL2Strip[i];
1113 eventout += ")";
1114 }
1115 eventout += "\n nTIBL3 = ";
1116 eventout += TIBL3ADC.size();
1117 for (unsigned int i = 0; i < TIBL3ADC.size(); ++i) {
1118 eventout += "\n (ADC, strip) = (";
1119 eventout += TIBL3ADC[i];
1120 eventout += ", ";
1121 eventout += TIBL3Strip[i];
1122 eventout += ")";
1123 }
1124 eventout += "\n nTIBL4 = ";
1125 eventout += TIBL4ADC.size();
1126 for (unsigned int i = 0; i < TIBL4ADC.size(); ++i) {
1127 eventout += "\n (ADC, strip) = (";
1128 eventout += TIBL4ADC[i];
1129 eventout += ", ";
1130 eventout += TIBL4Strip[i];
1131 eventout += ")";
1132 }
1133 eventout += "\n nTOBL1 = ";
1134 eventout += TOBL1ADC.size();
1135 for (unsigned int i = 0; i < TOBL1ADC.size(); ++i) {
1136 eventout += "\n (ADC, strip) = (";
1137 eventout += TOBL1ADC[i];
1138 eventout += ", ";
1139 eventout += TOBL1Strip[i];
1140 eventout += ")";
1141 }
1142 eventout += "\n nTOBL2 = ";
1143 eventout += TOBL2ADC.size();
1144 for (unsigned int i = 0; i < TOBL2ADC.size(); ++i) {
1145 eventout += "\n (ADC, strip) = (";
1146 eventout += TOBL2ADC[i];
1147 eventout += ", ";
1148 eventout += TOBL2Strip[i];
1149 eventout += ")";
1150 }
1151 eventout += "\n nTOBL3 = ";
1152 eventout += TOBL3ADC.size();
1153 for (unsigned int i = 0; i < TOBL3ADC.size(); ++i) {
1154 eventout += "\n (ADC, strip) = (";
1155 eventout += TOBL3ADC[i];
1156 eventout += ", ";
1157 eventout += TOBL3Strip[i];
1158 eventout += ")";
1159 }
1160 eventout += "\n nTOBL4 = ";
1161 eventout += TOBL4ADC.size();
1162 for (unsigned int i = 0; i < TOBL4ADC.size(); ++i) {
1163 eventout += "\n (ADC, strip) = (";
1164 eventout += TOBL4ADC[i];
1165 eventout += ", ";
1166 eventout += TOBL4Strip[i];
1167 eventout += ")";
1168 }
1169 eventout += "\n nTIDW1 = ";
1170 eventout += TIDW1ADC.size();
1171 for (unsigned int i = 0; i < TIDW1ADC.size(); ++i) {
1172 eventout += "\n (ADC, strip) = (";
1173 eventout += TIDW1ADC[i];
1174 eventout += ", ";
1175 eventout += TIDW1Strip[i];
1176 eventout += ")";
1177 }
1178 eventout += "\n nTIDW2 = ";
1179 eventout += TIDW2ADC.size();
1180 for (unsigned int i = 0; i < TIDW2ADC.size(); ++i) {
1181 eventout += "\n (ADC, strip) = (";
1182 eventout += TIDW2ADC[i];
1183 eventout += ", ";
1184 eventout += TIDW2Strip[i];
1185 eventout += ")";
1186 }
1187 eventout += "\n nTIDW3 = ";
1188 eventout += TIDW3ADC.size();
1189 for (unsigned int i = 0; i < TIDW3ADC.size(); ++i) {
1190 eventout += "\n (ADC, strip) = (";
1191 eventout += TIDW3ADC[i];
1192 eventout += ", ";
1193 eventout += TIDW3Strip[i];
1194 eventout += ")";
1195 }
1196 eventout += "\n nTECW1 = ";
1197 eventout += TECW1ADC.size();
1198 for (unsigned int i = 0; i < TECW1ADC.size(); ++i) {
1199 eventout += "\n (ADC, strip) = (";
1200 eventout += TECW1ADC[i];
1201 eventout += ", ";
1202 eventout += TECW1Strip[i];
1203 eventout += ")";
1204 }
1205 eventout += "\n nTECW2 = ";
1206 eventout += TECW2ADC.size();
1207 for (unsigned int i = 0; i < TECW2ADC.size(); ++i) {
1208 eventout += "\n (ADC, strip) = (";
1209 eventout += TECW2ADC[i];
1210 eventout += ", ";
1211 eventout += TECW2Strip[i];
1212 eventout += ")";
1213 }
1214 eventout += "\n nTECW3 = ";
1215 eventout += TECW3ADC.size();
1216 for (unsigned int i = 0; i < TECW3ADC.size(); ++i) {
1217 eventout += "\n (ADC, strip) = (";
1218 eventout += TECW3ADC[i];
1219 eventout += ", ";
1220 eventout += TECW3Strip[i];
1221 eventout += ")";
1222 }
1223 eventout += "\n nTECW4 = ";
1224 eventout += TECW4ADC.size();
1225 for (unsigned int i = 0; i < TECW4ADC.size(); ++i) {
1226 eventout += "\n (ADC, strip) = (";
1227 eventout += TECW4ADC[i];
1228 eventout += ", ";
1229 eventout += TECW4Strip[i];
1230 eventout += ")";
1231 }
1232 eventout += "\n nTECW5 = ";
1233 eventout += TECW5ADC.size();
1234 for (unsigned int i = 0; i < TECW5ADC.size(); ++i) {
1235 eventout += "\n (ADC, strip) = (";
1236 eventout += TECW5ADC[i];
1237 eventout += ", ";
1238 eventout += TECW5Strip[i];
1239 eventout += ")";
1240 }
1241 eventout += "\n nTECW6 = ";
1242 eventout += TECW6ADC.size();
1243 for (unsigned int i = 0; i < TECW6ADC.size(); ++i) {
1244 eventout += "\n (ADC, strip) = (";
1245 eventout += TECW6ADC[i];
1246 eventout += ", ";
1247 eventout += TECW6Strip[i];
1248 eventout += ")";
1249 }
1250 eventout += "\n nTECW7 = ";
1251 eventout += TECW7ADC.size();
1252 for (unsigned int i = 0; i < TECW7ADC.size(); ++i) {
1253 eventout += "\n (ADC, strip) = (";
1254 eventout += TECW7ADC[i];
1255 eventout += ", ";
1256 eventout += TECW7Strip[i];
1257 eventout += ")";
1258 }
1259 eventout += "\n nTECW8 = ";
1260 eventout += TECW8ADC.size();
1261 for (unsigned int i = 0; i < TECW8ADC.size(); ++i) {
1262 eventout += "\n (ADC, strip) = (";
1263 eventout += TECW8ADC[i];
1264 eventout += ", ";
1265 eventout += TECW8Strip[i];
1266 eventout += ")";
1267 }
1268
1269
1270 eventout += "\n nBRL1 = ";
1271 eventout += BRL1ADC.size();
1272 for (unsigned int i = 0; i < BRL1ADC.size(); ++i) {
1273 eventout += "\n (ADC, row, column) = (";
1274 eventout += BRL1ADC[i];
1275 eventout += ", ";
1276 eventout += BRL1Row[i];
1277 eventout += ", ";
1278 eventout += BRL1Col[i];
1279 eventout += ")";
1280 }
1281 eventout += "\n nBRL2 = ";
1282 eventout += BRL2ADC.size();
1283 for (unsigned int i = 0; i < BRL2ADC.size(); ++i) {
1284 eventout += "\n (ADC, row, column) = (";
1285 eventout += BRL2ADC[i];
1286 eventout += ", ";
1287 eventout += BRL2Row[i];
1288 eventout += ", ";
1289 eventout += BRL2Col[i];
1290 eventout += ")";
1291 }
1292 eventout += "\n nBRL3 = ";
1293 eventout += BRL3ADC.size();
1294 for (unsigned int i = 0; i < BRL3ADC.size(); ++i) {
1295 eventout += "\n (ADC, row, column) = (";
1296 eventout += BRL3ADC[i];
1297 eventout += ", ";
1298 eventout += BRL3Row[i];
1299 eventout += ", ";
1300 eventout += BRL3Col[i];
1301 eventout += ")";
1302 }
1303 eventout += "\n nFWD1p = ";
1304 eventout += FWD1pADC.size();
1305 for (unsigned int i = 0; i < FWD1pADC.size(); ++i) {
1306 eventout += "\n (ADC, row, column) = (";
1307 eventout += FWD1pADC[i];
1308 eventout += ", ";
1309 eventout += FWD1pRow[i];
1310 eventout += ", ";
1311 eventout += FWD1pCol[i];
1312 eventout += ")";
1313 }
1314 eventout += "\n nFWD1p = ";
1315 eventout += FWD1nADC.size();
1316 for (unsigned int i = 0; i < FWD1nADC.size(); ++i) {
1317 eventout += "\n (ADC, row, column) = (";
1318 eventout += FWD1nADC[i];
1319 eventout += ", ";
1320 eventout += FWD1nRow[i];
1321 eventout += ", ";
1322 eventout += FWD1nCol[i];
1323 eventout += ")";
1324 }
1325 eventout += "\n nFWD1p = ";
1326 eventout += FWD2pADC.size();
1327 for (unsigned int i = 0; i < FWD2pADC.size(); ++i) {
1328 eventout += "\n (ADC, row, column) = (";
1329 eventout += FWD2pADC[i];
1330 eventout += ", ";
1331 eventout += FWD2pRow[i];
1332 eventout += ", ";
1333 eventout += FWD2pCol[i];
1334 eventout += ")";
1335 }
1336 eventout += "\n nFWD2p = ";
1337 eventout += FWD2nADC.size();
1338 for (unsigned int i = 0; i < FWD2nADC.size(); ++i) {
1339 eventout += "\n (ADC, row, column) = (";
1340 eventout += FWD2nADC[i];
1341 eventout += ", ";
1342 eventout += FWD2nRow[i];
1343 eventout += ", ";
1344 eventout += FWD2nCol[i];
1345 eventout += ")";
1346 }
1347
1348 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1349 }
1350
1351
1352 product.putTIBL1Digis(TIBL1ADC, TIBL1Strip);
1353 product.putTIBL2Digis(TIBL2ADC, TIBL2Strip);
1354 product.putTIBL3Digis(TIBL3ADC, TIBL3Strip);
1355 product.putTIBL4Digis(TIBL4ADC, TIBL4Strip);
1356 product.putTOBL1Digis(TOBL1ADC, TOBL1Strip);
1357 product.putTOBL2Digis(TOBL2ADC, TOBL2Strip);
1358 product.putTOBL3Digis(TOBL3ADC, TOBL3Strip);
1359 product.putTOBL4Digis(TOBL4ADC, TOBL4Strip);
1360 product.putTIDW1Digis(TIDW1ADC, TIDW1Strip);
1361 product.putTIDW2Digis(TIDW2ADC, TIDW2Strip);
1362 product.putTIDW3Digis(TIDW3ADC, TIDW3Strip);
1363 product.putTECW1Digis(TECW1ADC, TECW1Strip);
1364 product.putTECW2Digis(TECW2ADC, TECW2Strip);
1365 product.putTECW3Digis(TECW3ADC, TECW3Strip);
1366 product.putTECW4Digis(TECW4ADC, TECW4Strip);
1367 product.putTECW5Digis(TECW5ADC, TECW5Strip);
1368 product.putTECW6Digis(TECW6ADC, TECW6Strip);
1369 product.putTECW7Digis(TECW7ADC, TECW7Strip);
1370 product.putTECW8Digis(TECW8ADC, TECW8Strip);
1371
1372
1373 product.putBRL1Digis(BRL1ADC, BRL1Row, BRL1Col);
1374 product.putBRL2Digis(BRL2ADC, BRL2Row, BRL2Col);
1375 product.putBRL3Digis(BRL3ADC, BRL3Row, BRL3Col);
1376 product.putFWD1pDigis(FWD1pADC, FWD1pRow, FWD1pCol);
1377 product.putFWD1nDigis(FWD1nADC, FWD1nRow, FWD1nCol);
1378 product.putFWD2pDigis(FWD2pADC, FWD2pRow, FWD2pCol);
1379 product.putFWD2nDigis(FWD2nADC, FWD2nRow, FWD2nCol);
1380
1381 return;
1382 }
1383
1384 void GlobalDigisProducer::fillMuon(edm::Event &iEvent, const edm::EventSetup &iSetup) {
1385 std::string MsgLoggerCat = "GlobalDigisProducer_fillMuon";
1386
1387 TString eventout;
1388 if (verbosity > 0)
1389 eventout = "\nGathering info:";
1390
1391
1392 edm::Handle<DTDigiCollection> dtDigis;
1393 iEvent.getByToken(MuDTSrc_Token_, dtDigis);
1394 if (!dtDigis.isValid()) {
1395 edm::LogWarning(MsgLoggerCat) << "Unable to find dtDigis in event!";
1396 return;
1397 }
1398
1399 int nDt = 0;
1400 DTDigiCollection::DigiRangeIterator detUnitIt;
1401 for (detUnitIt = dtDigis->begin(); detUnitIt != dtDigis->end(); ++detUnitIt) {
1402 const DTLayerId &id = (*detUnitIt).first;
1403 const DTDigiCollection::Range &range = (*detUnitIt).second;
1404
1405 for (DTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1406 ++nDt;
1407
1408 DTWireId wireId(id, (*digiIt).wire());
1409 if (wireId.station() == 1) {
1410 MB1SLayer.push_back(id.superlayer());
1411 MB1Time.push_back((*digiIt).time());
1412 MB1Layer.push_back(id.layer());
1413 }
1414 if (wireId.station() == 2) {
1415 MB2SLayer.push_back(id.superlayer());
1416 MB2Time.push_back((*digiIt).time());
1417 MB2Layer.push_back(id.layer());
1418 }
1419 if (wireId.station() == 3) {
1420 MB3SLayer.push_back(id.superlayer());
1421 MB3Time.push_back((*digiIt).time());
1422 MB3Layer.push_back(id.layer());
1423 }
1424 if (wireId.station() == 4) {
1425 MB4SLayer.push_back(id.superlayer());
1426 MB4Time.push_back((*digiIt).time());
1427 MB4Layer.push_back(id.layer());
1428 }
1429 }
1430 }
1431
1432 if (verbosity > 1) {
1433 eventout += "\n Number of DtMuonDigis collected:.......... ";
1434 eventout += nDt;
1435 }
1436
1437
1438 edm::Handle<CSCStripDigiCollection> strips;
1439 iEvent.getByToken(MuCSCStripSrc_Token_, strips);
1440 if (!strips.isValid()) {
1441 edm::LogWarning(MsgLoggerCat) << "Unable to find muon strips in event!";
1442 return;
1443 }
1444
1445 int nStrips = 0;
1446 for (CSCStripDigiCollection::DigiRangeIterator j = strips->begin(); j != strips->end(); ++j) {
1447 std::vector<CSCStripDigi>::const_iterator digiItr = (*j).second.first;
1448 std::vector<CSCStripDigi>::const_iterator last = (*j).second.second;
1449
1450 for (; digiItr != last; ++digiItr) {
1451 ++nStrips;
1452
1453
1454 std::vector<int> adcCounts = digiItr->getADCCounts();
1455 theCSCStripPedestalSum += adcCounts[0];
1456 theCSCStripPedestalSum += adcCounts[1];
1457 theCSCStripPedestalCount += 2;
1458
1459
1460 if (theCSCStripPedestalCount > 100) {
1461 float pedestal = theCSCStripPedestalSum / theCSCStripPedestalCount;
1462 if (adcCounts[5] > (pedestal + 100))
1463 CSCStripADC.push_back(adcCounts[4] - pedestal);
1464 }
1465 }
1466 }
1467
1468 if (verbosity > 1) {
1469 eventout += "\n Number of CSCStripDigis collected:........ ";
1470 eventout += nStrips;
1471 }
1472
1473
1474 edm::Handle<CSCWireDigiCollection> wires;
1475 iEvent.getByToken(MuCSCWireSrc_Token_, wires);
1476 if (!wires.isValid()) {
1477 edm::LogWarning(MsgLoggerCat) << "Unable to find muon wires in event!";
1478 return;
1479 }
1480
1481 int nWires = 0;
1482 for (CSCWireDigiCollection::DigiRangeIterator j = wires->begin(); j != wires->end(); ++j) {
1483 std::vector<CSCWireDigi>::const_iterator digiItr = (*j).second.first;
1484 std::vector<CSCWireDigi>::const_iterator endDigi = (*j).second.second;
1485
1486 for (; digiItr != endDigi; ++digiItr) {
1487 ++nWires;
1488
1489 CSCWireTime.push_back(digiItr->getTimeBin());
1490 }
1491 }
1492
1493 if (verbosity > 1) {
1494 eventout += "\n Number of CSCWireDigis collected:......... ";
1495 eventout += nWires;
1496 }
1497
1498 if (verbosity > 0)
1499 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1500
1501 return;
1502 }
1503
1504 void GlobalDigisProducer::storeMuon(PGlobalDigi &product) {
1505 std::string MsgLoggerCat = "GlobalDigisProducer_storeMuon";
1506
1507 if (verbosity > 2) {
1508
1509 TString eventout("\n nMB1 = ");
1510 eventout += MB1SLayer.size();
1511 for (unsigned int i = 0; i < MB1SLayer.size(); ++i) {
1512 eventout += "\n (slayer, time, layer) = (";
1513 eventout += MB1SLayer[i];
1514 eventout += ", ";
1515 eventout += MB1Time[i];
1516 eventout += ", ";
1517 eventout += MB1Layer[i];
1518 eventout += ")";
1519 }
1520 eventout += "\n nMB2 = ";
1521 eventout += MB2SLayer.size();
1522 for (unsigned int i = 0; i < MB2SLayer.size(); ++i) {
1523 eventout += "\n (slayer, time, layer) = (";
1524 eventout += MB2SLayer[i];
1525 eventout += ", ";
1526 eventout += MB2Time[i];
1527 eventout += ", ";
1528 eventout += MB2Layer[i];
1529 eventout += ")";
1530 }
1531 eventout += "\n nMB3 = ";
1532 eventout += MB3SLayer.size();
1533 for (unsigned int i = 0; i < MB3SLayer.size(); ++i) {
1534 eventout += "\n (slayer, time, layer) = (";
1535 eventout += MB3SLayer[i];
1536 eventout += ", ";
1537 eventout += MB3Time[i];
1538 eventout += ", ";
1539 eventout += MB3Layer[i];
1540 eventout += ")";
1541 }
1542 eventout += "\n nMB2 = ";
1543 eventout += MB4SLayer.size();
1544 for (unsigned int i = 0; i < MB4SLayer.size(); ++i) {
1545 eventout += "\n (slayer, time, layer) = (";
1546 eventout += MB4SLayer[i];
1547 eventout += ", ";
1548 eventout += MB4Time[i];
1549 eventout += ", ";
1550 eventout += MB4Layer[i];
1551 eventout += ")";
1552 }
1553
1554
1555 eventout += "\n nCSCStrip = ";
1556 eventout += CSCStripADC.size();
1557 for (unsigned int i = 0; i < CSCStripADC.size(); ++i) {
1558 eventout += "\n (adc) = (";
1559 eventout += CSCStripADC[i];
1560 eventout += ")";
1561 }
1562
1563
1564 eventout += "\n nCSCWire = ";
1565 eventout += CSCWireTime.size();
1566 for (unsigned int i = 0; i < CSCWireTime.size(); ++i) {
1567 eventout += "\n (time) = (";
1568 eventout += CSCWireTime[i];
1569 eventout += ")";
1570 }
1571
1572 edm::LogInfo(MsgLoggerCat) << eventout << "\n";
1573 }
1574
1575 product.putMB1Digis(MB1SLayer, MB1Time, MB1Layer);
1576 product.putMB2Digis(MB2SLayer, MB2Time, MB2Layer);
1577 product.putMB3Digis(MB3SLayer, MB3Time, MB3Layer);
1578 product.putMB4Digis(MB4SLayer, MB4Time, MB4Layer);
1579
1580 product.putCSCstripDigis(CSCStripADC);
1581
1582 product.putCSCwireDigis(CSCWireTime);
1583
1584 return;
1585 }
1586
1587 void GlobalDigisProducer::clear() {
1588 std::string MsgLoggerCat = "GlobalDigisProducer_clear";
1589
1590 if (verbosity > 0)
1591 edm::LogInfo(MsgLoggerCat) << "Clearing event holders";
1592
1593
1594
1595 EECalmaxPos.clear();
1596 EECalAEE.clear();
1597 EECalSHE.clear();
1598
1599 EBCalmaxPos.clear();
1600 EBCalAEE.clear();
1601 EBCalSHE.clear();
1602
1603 ESCalADC0.clear();
1604 ESCalADC1.clear();
1605 ESCalADC2.clear();
1606 ESCalSHE.clear();
1607
1608
1609 HBCalAEE.clear();
1610 HBCalSHE.clear();
1611 HECalAEE.clear();
1612 HECalSHE.clear();
1613 HOCalAEE.clear();
1614 HOCalSHE.clear();
1615 HFCalAEE.clear();
1616 HFCalSHE.clear();
1617
1618
1619 TIBL1ADC.clear();
1620 TIBL2ADC.clear();
1621 TIBL3ADC.clear();
1622 TIBL4ADC.clear();
1623 TIBL1Strip.clear();
1624 TIBL2Strip.clear();
1625 TIBL3Strip.clear();
1626 TIBL4Strip.clear();
1627
1628 TOBL1ADC.clear();
1629 TOBL2ADC.clear();
1630 TOBL3ADC.clear();
1631 TOBL4ADC.clear();
1632 TOBL1Strip.clear();
1633 TOBL2Strip.clear();
1634 TOBL3Strip.clear();
1635 TOBL4Strip.clear();
1636
1637 TIDW1ADC.clear();
1638 TIDW2ADC.clear();
1639 TIDW3ADC.clear();
1640 TIDW1Strip.clear();
1641 TIDW2Strip.clear();
1642 TIDW3Strip.clear();
1643
1644 TECW1ADC.clear();
1645 TECW2ADC.clear();
1646 TECW3ADC.clear();
1647 TECW4ADC.clear();
1648 TECW5ADC.clear();
1649 TECW6ADC.clear();
1650 TECW7ADC.clear();
1651 TECW8ADC.clear();
1652 TECW1Strip.clear();
1653 TECW2Strip.clear();
1654 TECW3Strip.clear();
1655 TECW4Strip.clear();
1656 TECW5Strip.clear();
1657 TECW6Strip.clear();
1658 TECW7Strip.clear();
1659 TECW8Strip.clear();
1660
1661 BRL1ADC.clear();
1662 BRL1Row.clear();
1663 BRL1Col.clear();
1664 BRL2ADC.clear();
1665 BRL2Row.clear();
1666 BRL2Col.clear();
1667 BRL3ADC.clear();
1668 BRL3Row.clear();
1669 BRL3Col.clear();
1670
1671 FWD1pADC.clear();
1672 FWD1pRow.clear();
1673 FWD1pCol.clear();
1674 FWD1nADC.clear();
1675 FWD1nRow.clear();
1676 FWD1nCol.clear();
1677 FWD2pADC.clear();
1678 FWD2pRow.clear();
1679 FWD2pCol.clear();
1680 FWD2nADC.clear();
1681 FWD2nRow.clear();
1682 FWD2nCol.clear();
1683
1684
1685 MB1SLayer.clear();
1686 MB1Time.clear();
1687 MB1Layer.clear();
1688 MB2SLayer.clear();
1689 MB2Time.clear();
1690 MB2Layer.clear();
1691 MB3SLayer.clear();
1692 MB3Time.clear();
1693 MB3Layer.clear();
1694 MB4SLayer.clear();
1695 MB4Time.clear();
1696 MB4Layer.clear();
1697
1698 CSCStripADC.clear();
1699
1700 CSCWireTime.clear();
1701
1702 return;
1703 }
1704
1705
1706