Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-07-12 02:41:34 

0001 // system include files
0002 #include <memory>
0003 
0004 // user include files
0005 #include "FWCore/Framework/interface/Frameworkfwd.h"
0006 #include "FWCore/Framework/interface/stream/EDProducer.h"
0007 #include "FWCore/Framework/interface/Event.h"
0008 
0009 #include "FWCore/Utilities/interface/ESInputTag.h"
0010 #include "FWCore/Utilities/interface/Transition.h"
0011 
0012 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0013 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0014 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0015 
0016 #include "DataFormats/NanoAOD/interface/FlatTable.h"
0017 
0018 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
0019 #include "CommonTools/Utils/interface/StringObjectFunction.h"
0020 
0021 #include "CalibFormats/HcalObjects/interface/HcalCoderDb.h"
0022 #include "CalibFormats/HcalObjects/interface/HcalDbRecord.h"
0023 #include "CalibFormats/HcalObjects/interface/HcalDbService.h"
0024 #include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
0025 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
0026 #include "DataFormats/HcalDetId/interface/HcalGenericDetId.h"
0027 #include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h"
0028 #include "CondFormats/HcalObjects/interface/HcalChannelQuality.h"
0029 
0030 #include "DPGAnalysis/HcalNanoAOD/interface/QIE11DigiSortedTable.h"
0031 #include "DPGAnalysis/HcalNanoAOD/interface/QIE10DigiSortedTable.h"
0032 #include "DPGAnalysis/HcalNanoAOD/interface/HODigiSortedTable.h"
0033 
0034 class HcalDigiSortedTableProducer : public edm::stream::EDProducer<> {
0035 private:
0036   std::map<HcalSubdetector, edm::Handle<std::vector<HcalDetId>>> dids_;
0037 
0038   //std::map<HcalSubdetector, std::vector<HcalElectronicsId> > eids_;
0039   static const std::vector<HcalSubdetector> subdets_;
0040   HcalElectronicsMap const* emap_;
0041 
0042   edm::InputTag tagHBDetIdList_;
0043   edm::InputTag tagHEDetIdList_;
0044   edm::InputTag tagHFDetIdList_;
0045   edm::InputTag tagHODetIdList_;
0046 
0047   edm::EDGetTokenT<std::vector<HcalDetId>> tokenHBDetIdList_;
0048   edm::EDGetTokenT<std::vector<HcalDetId>> tokenHEDetIdList_;
0049   edm::EDGetTokenT<std::vector<HcalDetId>> tokenHFDetIdList_;
0050   edm::EDGetTokenT<std::vector<HcalDetId>> tokenHODetIdList_;
0051 
0052   edm::InputTag tagQIE11_;
0053   edm::InputTag tagQIE10_;
0054   edm::InputTag tagHO_;
0055 
0056   edm::EDGetTokenT<QIE11DigiCollection> tokenQIE11_;
0057   edm::EDGetTokenT<QIE10DigiCollection> tokenQIE10_;
0058   edm::EDGetTokenT<HODigiCollection> tokenHO_;
0059 
0060   edm::ESGetToken<HcalDbService, HcalDbRecord> tokenHcalDbService_;
0061   edm::ESHandle<HcalDbService> dbService_;
0062 
0063   HBDigiSortedTable* hbDigiTable_;
0064   HEDigiSortedTable* heDigiTable_;
0065   HFDigiSortedTable* hfDigiTable_;
0066   HODigiSortedTable* hoDigiTable_;
0067 
0068   const unsigned int nTS_HB_;
0069   const unsigned int nTS_HE_;
0070   const unsigned int nTS_HF_;
0071   const unsigned int nTS_HO_;
0072 
0073 public:
0074   explicit HcalDigiSortedTableProducer(const edm::ParameterSet& iConfig)
0075       : tokenHBDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
0076             "HBDetIdList", edm::InputTag("hcalDetIdTable", "HBDetIdList")))),
0077         tokenHEDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
0078             "HEDetIdList", edm::InputTag("hcalDetIdTable", "HEDetIdList")))),
0079         tokenHFDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
0080             "HFDetIdList", edm::InputTag("hcalDetIdTable", "HFDetIdList")))),
0081         tokenHODetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
0082             "HODetIdList", edm::InputTag("hcalDetIdTable", "HODetIdList")))),
0083         tagQIE11_(iConfig.getUntrackedParameter<edm::InputTag>("tagQIE11", edm::InputTag("hcalDigis"))),
0084         tagQIE10_(iConfig.getUntrackedParameter<edm::InputTag>("tagQIE10", edm::InputTag("hcalDigis"))),
0085         tagHO_(iConfig.getUntrackedParameter<edm::InputTag>("tagHO", edm::InputTag("hcalDigis"))),
0086         tokenHcalDbService_(esConsumes<HcalDbService, HcalDbRecord, edm::Transition::BeginRun>()),
0087         nTS_HB_(iConfig.getUntrackedParameter<unsigned int>("nTS_HB", 8)),
0088         nTS_HE_(iConfig.getUntrackedParameter<unsigned int>("nTS_HE", 8)),
0089         nTS_HF_(iConfig.getUntrackedParameter<unsigned int>("nTS_HF", 3)),
0090         nTS_HO_(iConfig.getUntrackedParameter<unsigned int>("nTS_HO", 10)) {
0091     tokenQIE11_ = consumes<QIE11DigiCollection>(tagQIE11_);
0092     tokenHO_ = consumes<HODigiCollection>(tagHO_);
0093     tokenQIE10_ = consumes<QIE10DigiCollection>(tagQIE10_);
0094 
0095     produces<nanoaod::FlatTable>("HBDigiSortedTable");
0096     produces<nanoaod::FlatTable>("HEDigiSortedTable");
0097     produces<nanoaod::FlatTable>("HFDigiSortedTable");
0098     produces<nanoaod::FlatTable>("HODigiSortedTable");
0099 
0100     hbDigiTable_ = nullptr;
0101     heDigiTable_ = nullptr;
0102     hfDigiTable_ = nullptr;
0103     hoDigiTable_ = nullptr;
0104   }
0105 
0106   ~HcalDigiSortedTableProducer() override {
0107     delete hbDigiTable_;
0108     delete heDigiTable_;
0109     delete hfDigiTable_;
0110     delete hoDigiTable_;
0111   };
0112 
0113   /*
0114     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0115         edm::ParameterSetDescription desc;
0116         desc.add<edm::InputTag>("tagQIE11")->setComment("Input QIE 11 digi collection");
0117         // desc.add<std::string>("name")->setComment("");
0118         descriptions.add("HcalDigiTable", desc);
0119     }
0120     */
0121 
0122 private:
0123   void beginRun(edm::Run const&, edm::EventSetup const&) override;
0124   void produce(edm::Event&, edm::EventSetup const&) override;
0125 };
0126 
0127 const std::vector<HcalSubdetector> HcalDigiSortedTableProducer::subdets_ = {
0128     HcalBarrel, HcalEndcap, HcalForward, HcalOuter};
0129 
0130 void HcalDigiSortedTableProducer::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0131   // List DetIds of interest from emap
0132   dbService_ = iSetup.getHandle(tokenHcalDbService_);
0133   emap_ = dbService_->getHcalMapping();
0134 
0135   iRun.getByToken(tokenHBDetIdList_, dids_[HcalBarrel]);
0136   iRun.getByToken(tokenHEDetIdList_, dids_[HcalEndcap]);
0137   iRun.getByToken(tokenHFDetIdList_, dids_[HcalForward]);
0138   iRun.getByToken(tokenHODetIdList_, dids_[HcalOuter]);
0139 
0140   // Create persistent, sorted digi storage
0141   hbDigiTable_ = new HBDigiSortedTable(*(dids_[HcalBarrel]), nTS_HB_);
0142   heDigiTable_ = new HEDigiSortedTable(*(dids_[HcalEndcap]), nTS_HE_);
0143   hfDigiTable_ = new HFDigiSortedTable(*(dids_[HcalForward]), nTS_HF_);
0144   hoDigiTable_ = new HODigiSortedTable(*(dids_[HcalOuter]), nTS_HO_);
0145 }
0146 
0147 void HcalDigiSortedTableProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0148   // * Load digis */
0149   edm::Handle<QIE11DigiCollection> qie11Digis;
0150   iEvent.getByToken(tokenQIE11_, qie11Digis);
0151 
0152   edm::Handle<QIE10DigiCollection> qie10Digis;
0153   iEvent.getByToken(tokenQIE10_, qie10Digis);
0154 
0155   edm::Handle<HODigiCollection> hoDigis;
0156   iEvent.getByToken(tokenHO_, hoDigis);
0157 
0158   // * Process digis */
0159   // HB
0160   hbDigiTable_->reset();
0161   for (QIE11DigiCollection::const_iterator itDigi = qie11Digis->begin(); itDigi != qie11Digis->end(); ++itDigi) {
0162     const QIE11DataFrame digi = static_cast<const QIE11DataFrame>(*itDigi);
0163     HcalDetId const& did = digi.detid();
0164     if (did.subdet() != HcalBarrel)
0165       continue;
0166 
0167     hbDigiTable_->add(&digi, dbService_);
0168   }  // End loop over qie11 HB digis
0169 
0170   // HE
0171   heDigiTable_->reset();
0172   for (QIE11DigiCollection::const_iterator itDigi = qie11Digis->begin(); itDigi != qie11Digis->end(); ++itDigi) {
0173     const QIE11DataFrame digi = static_cast<const QIE11DataFrame>(*itDigi);
0174     HcalDetId const& did = digi.detid();
0175     if (did.subdet() != HcalEndcap)
0176       continue;
0177 
0178     heDigiTable_->add(&digi, dbService_);
0179   }  // End loop over qie11 HE digis
0180 
0181   // HF
0182   hfDigiTable_->reset();
0183   for (QIE10DigiCollection::const_iterator itDigi = qie10Digis->begin(); itDigi != qie10Digis->end(); ++itDigi) {
0184     const QIE10DataFrame digi = static_cast<const QIE10DataFrame>(*itDigi);
0185     HcalDetId const& did = digi.detid();
0186     if (did.subdet() != HcalForward)
0187       continue;
0188 
0189     hfDigiTable_->add(&digi, dbService_);
0190   }  // End loop over qie10 HF digis
0191 
0192   // HO
0193   hoDigiTable_->reset();
0194   for (HODigiCollection::const_iterator itDigi = hoDigis->begin(); itDigi != hoDigis->end(); ++itDigi) {
0195     const HODataFrame digi = static_cast<const HODataFrame>(*itDigi);
0196     HcalDetId const& did = digi.id();
0197     if (did.subdet() != HcalOuter)
0198       continue;
0199 
0200     hoDigiTable_->add(&digi, dbService_);
0201   }  // End loop over HO digis
0202 
0203   // * Save to NanoAOD tables */
0204 
0205   // HB
0206   auto hbNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalBarrel]->size(), "DigiHB", false, false);
0207   hbNanoTable->addColumn<int>("rawId", hbDigiTable_->rawIds_, "rawId");
0208   hbNanoTable->addColumn<int>("ieta", hbDigiTable_->ietas_, "ieta");
0209   hbNanoTable->addColumn<int>("iphi", hbDigiTable_->iphis_, "iphi");
0210   hbNanoTable->addColumn<int>("depth", hbDigiTable_->depths_, "depth");
0211   hbNanoTable->addColumn<int>("subdet", hbDigiTable_->subdets_, "subdet");
0212   hbNanoTable->addColumn<bool>("linkError", hbDigiTable_->linkErrors_, "linkError");
0213   hbNanoTable->addColumn<bool>("capidError", hbDigiTable_->capidErrors_, "capidError");
0214   hbNanoTable->addColumn<int>("flags", hbDigiTable_->flags_, "flags");
0215   hbNanoTable->addColumn<int>("soi", hbDigiTable_->sois_, "soi");
0216   hbNanoTable->addColumn<bool>("valid", hbDigiTable_->valids_, "valid");
0217   hbNanoTable->addColumn<uint8_t>("sipmTypes", hbDigiTable_->sipmTypes_, "sipmTypes");
0218 
0219   for (unsigned int iTS = 0; iTS < nTS_HB_; ++iTS) {
0220     hbNanoTable->addColumn<int>(
0221         std::string("adc") + std::to_string(iTS), hbDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
0222     hbNanoTable->addColumn<int>(
0223         std::string("tdc") + std::to_string(iTS), hbDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
0224     hbNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
0225                                 hbDigiTable_->capids_[iTS],
0226                                 std::string("capid") + std::to_string(iTS));
0227     hbNanoTable->addColumn<float>(
0228         std::string("fc") + std::to_string(iTS), hbDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
0229     hbNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
0230                                   hbDigiTable_->pedestalfcs_[iTS],
0231                                   std::string("pedestalfc") + std::to_string(iTS));
0232   }
0233   iEvent.put(std::move(hbNanoTable), "HBDigiSortedTable");
0234 
0235   // HE
0236   auto heNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalEndcap]->size(), "DigiHE", false, false);
0237   heNanoTable->addColumn<int>("rawId", heDigiTable_->rawIds_, "rawId");
0238   heNanoTable->addColumn<int>("ieta", heDigiTable_->ietas_, "ieta");
0239   heNanoTable->addColumn<int>("iphi", heDigiTable_->iphis_, "iphi");
0240   heNanoTable->addColumn<int>("depth", heDigiTable_->depths_, "depth");
0241   heNanoTable->addColumn<int>("subdet", heDigiTable_->subdets_, "subdet");
0242   heNanoTable->addColumn<bool>("linkError", heDigiTable_->linkErrors_, "linkError");
0243   heNanoTable->addColumn<bool>("capidError", heDigiTable_->capidErrors_, "capidError");
0244   heNanoTable->addColumn<int>("flags", heDigiTable_->flags_, "flags");
0245   heNanoTable->addColumn<int>("soi", heDigiTable_->sois_, "soi");
0246   heNanoTable->addColumn<bool>("valid", heDigiTable_->valids_, "valid");
0247   heNanoTable->addColumn<uint8_t>("sipmTypes", heDigiTable_->sipmTypes_, "sipmTypes");
0248 
0249   for (unsigned int iTS = 0; iTS < nTS_HE_; ++iTS) {
0250     heNanoTable->addColumn<int>(
0251         std::string("adc") + std::to_string(iTS), heDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
0252     heNanoTable->addColumn<int>(
0253         std::string("tdc") + std::to_string(iTS), heDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
0254     heNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
0255                                 heDigiTable_->capids_[iTS],
0256                                 std::string("capid") + std::to_string(iTS));
0257     heNanoTable->addColumn<float>(
0258         std::string("fc") + std::to_string(iTS), heDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
0259     heNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
0260                                   heDigiTable_->pedestalfcs_[iTS],
0261                                   std::string("pedestalfc") + std::to_string(iTS));
0262   }
0263   iEvent.put(std::move(heNanoTable), "HEDigiSortedTable");
0264 
0265   // HF
0266   auto hfNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalForward]->size(), "DigiHF", false, false);
0267   hfNanoTable->addColumn<int>("rawId", hfDigiTable_->rawIds_, "rawId");
0268   hfNanoTable->addColumn<int>("ieta", hfDigiTable_->ietas_, "ieta");
0269   hfNanoTable->addColumn<int>("iphi", hfDigiTable_->iphis_, "iphi");
0270   hfNanoTable->addColumn<int>("depth", hfDigiTable_->depths_, "depth");
0271   hfNanoTable->addColumn<int>("subdet", hfDigiTable_->subdets_, "subdet");
0272   hfNanoTable->addColumn<bool>("linkError", hfDigiTable_->linkErrors_, "linkError");
0273   hfNanoTable->addColumn<int>("flags", hfDigiTable_->flags_, "flags");
0274   hfNanoTable->addColumn<int>("soi", hfDigiTable_->sois_, "soi");
0275   hfNanoTable->addColumn<bool>("valid", hfDigiTable_->valids_, "valid");
0276   //hfNanoTable->addColumn<uint8_t>("sipmTypes", hfDigiTable_->sipmTypes_, "sipmTypes");
0277 
0278   for (unsigned int iTS = 0; iTS < nTS_HF_; ++iTS) {
0279     hfNanoTable->addColumn<int>(
0280         std::string("adc") + std::to_string(iTS), hfDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
0281     hfNanoTable->addColumn<int>(
0282         std::string("tdc") + std::to_string(iTS), hfDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
0283     //hfNanoTable->addColumn<int>(std::string("tetdc") + std::to_string(iTS),
0284     //                                hfDigiTable_->tetdcs_[iTS],
0285     //                                std::string("tetdc") + std::to_string(iTS));
0286     hfNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
0287                                 hfDigiTable_->capids_[iTS],
0288                                 std::string("capid") + std::to_string(iTS));
0289     hfNanoTable->addColumn<float>(
0290         std::string("fc") + std::to_string(iTS), hfDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
0291     hfNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
0292                                   hfDigiTable_->pedestalfcs_[iTS],
0293                                   std::string("pedestalfc") + std::to_string(iTS));
0294     hfNanoTable->addColumn<float>(
0295         std::string("ok") + std::to_string(iTS), hfDigiTable_->oks_[iTS], std::string("ok") + std::to_string(iTS));
0296   }
0297   iEvent.put(std::move(hfNanoTable), "HFDigiSortedTable");
0298 
0299   // HO
0300   auto hoNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalOuter]->size(), "DigiHO", false, false);
0301   hoNanoTable->addColumn<int>("rawId", hoDigiTable_->rawIds_, "rawId");
0302   hoNanoTable->addColumn<int>("ieta", hoDigiTable_->ietas_, "ieta");
0303   hoNanoTable->addColumn<int>("iphi", hoDigiTable_->iphis_, "iphi");
0304   hoNanoTable->addColumn<int>("depth", hoDigiTable_->depths_, "depth");
0305   hoNanoTable->addColumn<int>("subdet", hoDigiTable_->subdets_, "subdet");
0306   hoNanoTable->addColumn<int>("fiberIdleOffset", hoDigiTable_->fiberIdleOffsets_, "fiberIdleOffset");
0307   hoNanoTable->addColumn<int>("soi", hoDigiTable_->sois_, "soi");
0308   hoNanoTable->addColumn<bool>("valid", hoDigiTable_->valids_, "valid");
0309 
0310   for (unsigned int iTS = 0; iTS < nTS_HO_; ++iTS) {
0311     hoNanoTable->addColumn<int>(
0312         std::string("adc") + std::to_string(iTS), hoDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
0313     hoNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
0314                                 hoDigiTable_->capids_[iTS],
0315                                 std::string("capid") + std::to_string(iTS));
0316     hoNanoTable->addColumn<float>(
0317         std::string("fc") + std::to_string(iTS), hoDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
0318     hoNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
0319                                   hoDigiTable_->pedestalfcs_[iTS],
0320                                   std::string("pedestalfc") + std::to_string(iTS));
0321     hoNanoTable->addColumn<int>(std::string("fiber") + std::to_string(iTS),
0322                                 hoDigiTable_->fibers_[iTS],
0323                                 std::string("fiber") + std::to_string(iTS));
0324     hoNanoTable->addColumn<int>(std::string("fiberChan") + std::to_string(iTS),
0325                                 hoDigiTable_->fiberChans_[iTS],
0326                                 std::string("fiberChan") + std::to_string(iTS));
0327     hoNanoTable->addColumn<int>(
0328         std::string("dv") + std::to_string(iTS), hoDigiTable_->dvs_[iTS], std::string("dv") + std::to_string(iTS));
0329     hoNanoTable->addColumn<int>(
0330         std::string("er") + std::to_string(iTS), hoDigiTable_->ers_[iTS], std::string("er") + std::to_string(iTS));
0331   }
0332   iEvent.put(std::move(hoNanoTable), "HODigiSortedTable");
0333 }
0334 
0335 #include "FWCore/Framework/interface/MakerMacros.h"
0336 //define this as a plug-in
0337 DEFINE_FWK_MODULE(HcalDigiSortedTableProducer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!