HcalDigiSortedTableProducer Class Reference

Inheritance diagram for HcalDigiSortedTableProducer:

Public Member Functions
	HcalDigiSortedTableProducer (const edm::ParameterSet &iConfig)
	~HcalDigiSortedTableProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override
void	produce (edm::Event &, edm::EventSetup const &) override

Private Attributes
edm::ESHandle< HcalDbService >	dbService_
std::map< HcalSubdetector, edm::Handle< std::vector< HcalDetId > > >	dids_
HcalElectronicsMap const *	emap_
HBDigiSortedTable *	hbDigiTable_
HEDigiSortedTable *	heDigiTable_
HFDigiSortedTable *	hfDigiTable_
HODigiSortedTable *	hoDigiTable_
const unsigned int	nTS_HB_
const unsigned int	nTS_HE_
const unsigned int	nTS_HF_
const unsigned int	nTS_HO_
edm::InputTag	tagHBDetIdList_
edm::InputTag	tagHEDetIdList_
edm::InputTag	tagHFDetIdList_
edm::InputTag	tagHO_
edm::InputTag	tagHODetIdList_
edm::InputTag	tagQIE10_
edm::InputTag	tagQIE11_
edm::EDGetTokenT< std::vector< HcalDetId > >	tokenHBDetIdList_
edm::ESGetToken< HcalDbService, HcalDbRecord >	tokenHcalDbService_
edm::EDGetTokenT< std::vector< HcalDetId > >	tokenHEDetIdList_
edm::EDGetTokenT< std::vector< HcalDetId > >	tokenHFDetIdList_
edm::EDGetTokenT< HODigiCollection >	tokenHO_
edm::EDGetTokenT< std::vector< HcalDetId > >	tokenHODetIdList_
edm::EDGetTokenT< QIE10DigiCollection >	tokenQIE10_
edm::EDGetTokenT< QIE11DigiCollection >	tokenQIE11_

Static Private Attributes
static const std::vector< HcalSubdetector >	subdets_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 34 of file HcalDigiSortedTableProducer.cc.

Constructor & Destructor Documentation

HcalDigiSortedTableProducer()

HcalDigiSortedTableProducer::HcalDigiSortedTableProducer ( const edm::ParameterSet &  iConfig )

inlineexplicit

Definition at line 74 of file HcalDigiSortedTableProducer.cc.

References hbDigiTable_, heDigiTable_, hfDigiTable_, hoDigiTable_, tagHO_, tagQIE10_, tagQIE11_, tokenHO_, tokenQIE10_, and tokenQIE11_.

      : tokenHBDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
            "HBDetIdList", edm::InputTag("hcalDetIdTable", "HBDetIdList")))),
        tokenHEDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
            "HEDetIdList", edm::InputTag("hcalDetIdTable", "HEDetIdList")))),
        tokenHFDetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
            "HFDetIdList", edm::InputTag("hcalDetIdTable", "HFDetIdList")))),
        tokenHODetIdList_(consumes<edm::InRun>(iConfig.getUntrackedParameter<edm::InputTag>(
            "HODetIdList", edm::InputTag("hcalDetIdTable", "HODetIdList")))),
        tagQIE11_(iConfig.getUntrackedParameter<edm::InputTag>("tagQIE11", edm::InputTag("hcalDigis"))),
        tagQIE10_(iConfig.getUntrackedParameter<edm::InputTag>("tagQIE10", edm::InputTag("hcalDigis"))),
        tagHO_(iConfig.getUntrackedParameter<edm::InputTag>("tagHO", edm::InputTag("hcalDigis"))),
        tokenHcalDbService_(esConsumes<HcalDbService, HcalDbRecord, edm::Transition::BeginRun>()),
        nTS_HB_(iConfig.getUntrackedParameter<unsigned int>("nTS_HB", 8)),
        nTS_HE_(iConfig.getUntrackedParameter<unsigned int>("nTS_HE", 8)),
        nTS_HF_(iConfig.getUntrackedParameter<unsigned int>("nTS_HF", 3)),
        nTS_HO_(iConfig.getUntrackedParameter<unsigned int>("nTS_HO", 10)) {
    tokenQIE11_ = consumes<QIE11DigiCollection>(tagQIE11_);
    tokenHO_ = consumes<HODigiCollection>(tagHO_);
    tokenQIE10_ = consumes<QIE10DigiCollection>(tagQIE10_);

    produces<nanoaod::FlatTable>("HBDigiSortedTable");
    produces<nanoaod::FlatTable>("HEDigiSortedTable");
    produces<nanoaod::FlatTable>("HFDigiSortedTable");
    produces<nanoaod::FlatTable>("HODigiSortedTable");

    hbDigiTable_ = nullptr;
    heDigiTable_ = nullptr;
    hfDigiTable_ = nullptr;
    hoDigiTable_ = nullptr;
  }

~HcalDigiSortedTableProducer()

HcalDigiSortedTableProducer::~HcalDigiSortedTableProducer ( )

inlineoverride

Definition at line 106 of file HcalDigiSortedTableProducer.cc.

References hbDigiTable_, heDigiTable_, hfDigiTable_, and hoDigiTable_.

                                          {
    delete hbDigiTable_;
    delete heDigiTable_;
    delete hfDigiTable_;
    delete hoDigiTable_;
  };

Member Function Documentation

beginRun()

void HcalDigiSortedTableProducer::beginRun ( edm::Run const &  iRun, edm::EventSetup const &  iSetup  )

overrideprivate

Definition at line 130 of file HcalDigiSortedTableProducer.cc.

References dbService_, dids_, emap_, edm::Run::getByToken(), edm::EventSetup::getHandle(), HcalDbService::getHcalMapping(), hbDigiTable_, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, heDigiTable_, hfDigiTable_, hoDigiTable_, nTS_HB_, nTS_HE_, nTS_HF_, nTS_HO_, tokenHBDetIdList_, tokenHcalDbService_, tokenHEDetIdList_, tokenHFDetIdList_, and tokenHODetIdList_.

                                                                                          {
  // List DetIds of interest from emap
  dbService_ = iSetup.getHandle(tokenHcalDbService_);
  emap_ = dbService_->getHcalMapping();

  iRun.getByToken(tokenHBDetIdList_, dids_[HcalBarrel]);
  iRun.getByToken(tokenHEDetIdList_, dids_[HcalEndcap]);
  iRun.getByToken(tokenHFDetIdList_, dids_[HcalForward]);
  iRun.getByToken(tokenHODetIdList_, dids_[HcalOuter]);

  // Create persistent, sorted digi storage
  hbDigiTable_ = new HBDigiSortedTable(*(dids_[HcalBarrel]), nTS_HB_);
  heDigiTable_ = new HEDigiSortedTable(*(dids_[HcalEndcap]), nTS_HE_);
  hfDigiTable_ = new HFDigiSortedTable(*(dids_[HcalForward]), nTS_HF_);
  hoDigiTable_ = new HODigiSortedTable(*(dids_[HcalOuter]), nTS_HO_);
}

produce()

void HcalDigiSortedTableProducer::produce ( edm::Event &  iEvent, edm::EventSetup const &  iSetup  )

overrideprivate

Definition at line 147 of file HcalDigiSortedTableProducer.cc.

References HODigiSortedTable::adcs_, QIE10DigiSortedTable::adcs_, QIE11DigiSortedTable::adcs_, QIE11DigiSortedTable::add(), QIE10DigiSortedTable::add(), HODigiSortedTable::add(), edm::SortedCollection< T, SORT >::begin(), edm::DataFrameContainer::begin(), QIE11DigiSortedTable::capidErrors_, HODigiSortedTable::capids_, QIE10DigiSortedTable::capids_, QIE11DigiSortedTable::capids_, dbService_, QIE11DigiSortedTable::depths_, HODigiSortedTable::depths_, QIE10DigiSortedTable::depths_, QIE11DataFrame::detid(), QIE10DataFrame::detid(), dids_, HODigiSortedTable::dvs_, edm::SortedCollection< T, SORT >::end(), edm::DataFrameContainer::end(), HODigiSortedTable::ers_, HODigiSortedTable::fcs_, QIE10DigiSortedTable::fcs_, QIE11DigiSortedTable::fcs_, HODigiSortedTable::fiberChans_, HODigiSortedTable::fiberIdleOffsets_, HODigiSortedTable::fibers_, QIE10DigiSortedTable::flags_, QIE11DigiSortedTable::flags_, hbDigiTable_, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, heDigiTable_, hfDigiTable_, hoDigiTable_, HODataFrame::id(), HODigiSortedTable::ietas_, QIE10DigiSortedTable::ietas_, QIE11DigiSortedTable::ietas_, iEvent, HODigiSortedTable::iphis_, QIE10DigiSortedTable::iphis_, QIE11DigiSortedTable::iphis_, QIE11DigiSortedTable::linkErrors_, QIE10DigiSortedTable::linkErrors_, eostools::move(), nTS_HB_, nTS_HE_, nTS_HF_, nTS_HO_, QIE10DigiSortedTable::oks_, HODigiSortedTable::pedestalfcs_, QIE10DigiSortedTable::pedestalfcs_, QIE11DigiSortedTable::pedestalfcs_, HODigiSortedTable::rawIds_, QIE10DigiSortedTable::rawIds_, QIE11DigiSortedTable::rawIds_, QIE11DigiSortedTable::reset(), QIE10DigiSortedTable::reset(), HODigiSortedTable::reset(), QIE11DigiSortedTable::sipmTypes_, HODigiSortedTable::sois_, QIE10DigiSortedTable::sois_, QIE11DigiSortedTable::sois_, AlCaHLTBitMon_QueryRunRegistry::string, HcalDetId::subdet(), HODigiSortedTable::subdets_, QIE11DigiSortedTable::subdets_, QIE10DigiSortedTable::subdets_, QIE10DigiSortedTable::tdcs_, QIE11DigiSortedTable::tdcs_, to_string(), tokenHO_, tokenQIE10_, tokenQIE11_, HODigiSortedTable::valids_, QIE10DigiSortedTable::valids_, and QIE11DigiSortedTable::valids_.

                                                                                       {
  // * Load digis */
  edm::Handle<QIE11DigiCollection> qie11Digis;
  iEvent.getByToken(tokenQIE11_, qie11Digis);

  edm::Handle<QIE10DigiCollection> qie10Digis;
  iEvent.getByToken(tokenQIE10_, qie10Digis);

  edm::Handle<HODigiCollection> hoDigis;
  iEvent.getByToken(tokenHO_, hoDigis);

  // * Process digis */
  // HB
  hbDigiTable_->reset();
  for (QIE11DigiCollection::const_iterator itDigi = qie11Digis->begin(); itDigi != qie11Digis->end(); ++itDigi) {
    const QIE11DataFrame digi = static_cast<const QIE11DataFrame>(*itDigi);
    HcalDetId const& did = digi.detid();
    if (did.subdet() != HcalBarrel)
      continue;

    hbDigiTable_->add(&digi, dbService_);
  }  // End loop over qie11 HB digis

  // HE
  heDigiTable_->reset();
  for (QIE11DigiCollection::const_iterator itDigi = qie11Digis->begin(); itDigi != qie11Digis->end(); ++itDigi) {
    const QIE11DataFrame digi = static_cast<const QIE11DataFrame>(*itDigi);
    HcalDetId const& did = digi.detid();
    if (did.subdet() != HcalEndcap)
      continue;

    heDigiTable_->add(&digi, dbService_);
  }  // End loop over qie11 HE digis

  // HF
  hfDigiTable_->reset();
  for (QIE10DigiCollection::const_iterator itDigi = qie10Digis->begin(); itDigi != qie10Digis->end(); ++itDigi) {
    const QIE10DataFrame digi = static_cast<const QIE10DataFrame>(*itDigi);
    HcalDetId const& did = digi.detid();
    if (did.subdet() != HcalForward)
      continue;

    hfDigiTable_->add(&digi, dbService_);
  }  // End loop over qie10 HF digis

  // HO
  hoDigiTable_->reset();
  for (HODigiCollection::const_iterator itDigi = hoDigis->begin(); itDigi != hoDigis->end(); ++itDigi) {
    const HODataFrame digi = static_cast<const HODataFrame>(*itDigi);
    HcalDetId const& did = digi.id();
    if (did.subdet() != HcalOuter)
      continue;

    hoDigiTable_->add(&digi, dbService_);
  }  // End loop over HO digis

  // * Save to NanoAOD tables */

  // HB
  auto hbNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalBarrel]->size(), "DigiHB", false, false);
  hbNanoTable->addColumn<int>("rawId", hbDigiTable_->rawIds_, "rawId");
  hbNanoTable->addColumn<int>("ieta", hbDigiTable_->ietas_, "ieta");
  hbNanoTable->addColumn<int>("iphi", hbDigiTable_->iphis_, "iphi");
  hbNanoTable->addColumn<int>("depth", hbDigiTable_->depths_, "depth");
  hbNanoTable->addColumn<int>("subdet", hbDigiTable_->subdets_, "subdet");
  hbNanoTable->addColumn<bool>("linkError", hbDigiTable_->linkErrors_, "linkError");
  hbNanoTable->addColumn<bool>("capidError", hbDigiTable_->capidErrors_, "capidError");
  hbNanoTable->addColumn<int>("flags", hbDigiTable_->flags_, "flags");
  hbNanoTable->addColumn<int>("soi", hbDigiTable_->sois_, "soi");
  hbNanoTable->addColumn<bool>("valid", hbDigiTable_->valids_, "valid");
  hbNanoTable->addColumn<uint8_t>("sipmTypes", hbDigiTable_->sipmTypes_, "sipmTypes");

  for (unsigned int iTS = 0; iTS < nTS_HB_; ++iTS) {
    hbNanoTable->addColumn<int>(
        std::string("adc") + std::to_string(iTS), hbDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
    hbNanoTable->addColumn<int>(
        std::string("tdc") + std::to_string(iTS), hbDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
    hbNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
                                hbDigiTable_->capids_[iTS],
                                std::string("capid") + std::to_string(iTS));
    hbNanoTable->addColumn<float>(
        std::string("fc") + std::to_string(iTS), hbDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
    hbNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
                                  hbDigiTable_->pedestalfcs_[iTS],
                                  std::string("pedestalfc") + std::to_string(iTS));
  }
  iEvent.put(std::move(hbNanoTable), "HBDigiSortedTable");

  // HE
  auto heNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalEndcap]->size(), "DigiHE", false, false);
  heNanoTable->addColumn<int>("rawId", heDigiTable_->rawIds_, "rawId");
  heNanoTable->addColumn<int>("ieta", heDigiTable_->ietas_, "ieta");
  heNanoTable->addColumn<int>("iphi", heDigiTable_->iphis_, "iphi");
  heNanoTable->addColumn<int>("depth", heDigiTable_->depths_, "depth");
  heNanoTable->addColumn<int>("subdet", heDigiTable_->subdets_, "subdet");
  heNanoTable->addColumn<bool>("linkError", heDigiTable_->linkErrors_, "linkError");
  heNanoTable->addColumn<bool>("capidError", heDigiTable_->capidErrors_, "capidError");
  heNanoTable->addColumn<int>("flags", heDigiTable_->flags_, "flags");
  heNanoTable->addColumn<int>("soi", heDigiTable_->sois_, "soi");
  heNanoTable->addColumn<bool>("valid", heDigiTable_->valids_, "valid");
  heNanoTable->addColumn<uint8_t>("sipmTypes", heDigiTable_->sipmTypes_, "sipmTypes");

  for (unsigned int iTS = 0; iTS < nTS_HE_; ++iTS) {
    heNanoTable->addColumn<int>(
        std::string("adc") + std::to_string(iTS), heDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
    heNanoTable->addColumn<int>(
        std::string("tdc") + std::to_string(iTS), heDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
    heNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
                                heDigiTable_->capids_[iTS],
                                std::string("capid") + std::to_string(iTS));
    heNanoTable->addColumn<float>(
        std::string("fc") + std::to_string(iTS), heDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
    heNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
                                  heDigiTable_->pedestalfcs_[iTS],
                                  std::string("pedestalfc") + std::to_string(iTS));
  }
  iEvent.put(std::move(heNanoTable), "HEDigiSortedTable");

  // HF
  auto hfNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalForward]->size(), "DigiHF", false, false);
  hfNanoTable->addColumn<int>("rawId", hfDigiTable_->rawIds_, "rawId");
  hfNanoTable->addColumn<int>("ieta", hfDigiTable_->ietas_, "ieta");
  hfNanoTable->addColumn<int>("iphi", hfDigiTable_->iphis_, "iphi");
  hfNanoTable->addColumn<int>("depth", hfDigiTable_->depths_, "depth");
  hfNanoTable->addColumn<int>("subdet", hfDigiTable_->subdets_, "subdet");
  hfNanoTable->addColumn<bool>("linkError", hfDigiTable_->linkErrors_, "linkError");
  hfNanoTable->addColumn<int>("flags", hfDigiTable_->flags_, "flags");
  hfNanoTable->addColumn<int>("soi", hfDigiTable_->sois_, "soi");
  hfNanoTable->addColumn<bool>("valid", hfDigiTable_->valids_, "valid");
  //hfNanoTable->addColumn<uint8_t>("sipmTypes", hfDigiTable_->sipmTypes_, "sipmTypes");

  for (unsigned int iTS = 0; iTS < nTS_HF_; ++iTS) {
    hfNanoTable->addColumn<int>(
        std::string("adc") + std::to_string(iTS), hfDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
    hfNanoTable->addColumn<int>(
        std::string("tdc") + std::to_string(iTS), hfDigiTable_->tdcs_[iTS], std::string("tdc") + std::to_string(iTS));
    //hfNanoTable->addColumn<int>(std::string("tetdc") + std::to_string(iTS),
    //                                hfDigiTable_->tetdcs_[iTS],
    //                                std::string("tetdc") + std::to_string(iTS));
    hfNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
                                hfDigiTable_->capids_[iTS],
                                std::string("capid") + std::to_string(iTS));
    hfNanoTable->addColumn<float>(
        std::string("fc") + std::to_string(iTS), hfDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
    hfNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
                                  hfDigiTable_->pedestalfcs_[iTS],
                                  std::string("pedestalfc") + std::to_string(iTS));
    hfNanoTable->addColumn<float>(
        std::string("ok") + std::to_string(iTS), hfDigiTable_->oks_[iTS], std::string("ok") + std::to_string(iTS));
  }
  iEvent.put(std::move(hfNanoTable), "HFDigiSortedTable");

  // HO
  auto hoNanoTable = std::make_unique<nanoaod::FlatTable>(dids_[HcalOuter]->size(), "DigiHO", false, false);
  hoNanoTable->addColumn<int>("rawId", hoDigiTable_->rawIds_, "rawId");
  hoNanoTable->addColumn<int>("ieta", hoDigiTable_->ietas_, "ieta");
  hoNanoTable->addColumn<int>("iphi", hoDigiTable_->iphis_, "iphi");
  hoNanoTable->addColumn<int>("depth", hoDigiTable_->depths_, "depth");
  hoNanoTable->addColumn<int>("subdet", hoDigiTable_->subdets_, "subdet");
  hoNanoTable->addColumn<int>("fiberIdleOffset", hoDigiTable_->fiberIdleOffsets_, "fiberIdleOffset");
  hoNanoTable->addColumn<int>("soi", hoDigiTable_->sois_, "soi");
  hoNanoTable->addColumn<bool>("valid", hoDigiTable_->valids_, "valid");

  for (unsigned int iTS = 0; iTS < nTS_HO_; ++iTS) {
    hoNanoTable->addColumn<int>(
        std::string("adc") + std::to_string(iTS), hoDigiTable_->adcs_[iTS], std::string("adc") + std::to_string(iTS));
    hoNanoTable->addColumn<int>(std::string("capid") + std::to_string(iTS),
                                hoDigiTable_->capids_[iTS],
                                std::string("capid") + std::to_string(iTS));
    hoNanoTable->addColumn<float>(
        std::string("fc") + std::to_string(iTS), hoDigiTable_->fcs_[iTS], std::string("fc") + std::to_string(iTS));
    hoNanoTable->addColumn<float>(std::string("pedestalfc") + std::to_string(iTS),
                                  hoDigiTable_->pedestalfcs_[iTS],
                                  std::string("pedestalfc") + std::to_string(iTS));
    hoNanoTable->addColumn<int>(std::string("fiber") + std::to_string(iTS),
                                hoDigiTable_->fibers_[iTS],
                                std::string("fiber") + std::to_string(iTS));
    hoNanoTable->addColumn<int>(std::string("fiberChan") + std::to_string(iTS),
                                hoDigiTable_->fiberChans_[iTS],
                                std::string("fiberChan") + std::to_string(iTS));
    hoNanoTable->addColumn<int>(
        std::string("dv") + std::to_string(iTS), hoDigiTable_->dvs_[iTS], std::string("dv") + std::to_string(iTS));
    hoNanoTable->addColumn<int>(
        std::string("er") + std::to_string(iTS), hoDigiTable_->ers_[iTS], std::string("er") + std::to_string(iTS));
  }
  iEvent.put(std::move(hoNanoTable), "HODigiSortedTable");
}

Member Data Documentation

dbService_

edm::ESHandle<HcalDbService> HcalDigiSortedTableProducer::dbService_

private

Definition at line 61 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

dids_

std::map<HcalSubdetector, edm::Handle<std::vector<HcalDetId> > > HcalDigiSortedTableProducer::dids_

private

Definition at line 36 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

emap_

HcalElectronicsMap const* HcalDigiSortedTableProducer::emap_

private

Definition at line 40 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

hbDigiTable_

HBDigiSortedTable* HcalDigiSortedTableProducer::hbDigiTable_

private

Definition at line 63 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), HcalDigiSortedTableProducer(), produce(), and ~HcalDigiSortedTableProducer().

heDigiTable_

HEDigiSortedTable* HcalDigiSortedTableProducer::heDigiTable_

private

Definition at line 64 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), HcalDigiSortedTableProducer(), produce(), and ~HcalDigiSortedTableProducer().

hfDigiTable_

HFDigiSortedTable* HcalDigiSortedTableProducer::hfDigiTable_

private

Definition at line 65 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), HcalDigiSortedTableProducer(), produce(), and ~HcalDigiSortedTableProducer().

hoDigiTable_

HODigiSortedTable* HcalDigiSortedTableProducer::hoDigiTable_

private

Definition at line 66 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), HcalDigiSortedTableProducer(), produce(), and ~HcalDigiSortedTableProducer().

nTS_HB_

const unsigned int HcalDigiSortedTableProducer::nTS_HB_

private

Definition at line 68 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

nTS_HE_

const unsigned int HcalDigiSortedTableProducer::nTS_HE_

private

Definition at line 69 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

nTS_HF_

const unsigned int HcalDigiSortedTableProducer::nTS_HF_

private

Definition at line 70 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

nTS_HO_

const unsigned int HcalDigiSortedTableProducer::nTS_HO_

private

Definition at line 71 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun(), and produce().

subdets_

const std::vector< HcalSubdetector > HcalDigiSortedTableProducer::subdets_

staticprivate

Initial value:

= {
    HcalBarrel, HcalEndcap, HcalForward, HcalOuter}

Definition at line 39 of file HcalDigiSortedTableProducer.cc.

tagHBDetIdList_

edm::InputTag HcalDigiSortedTableProducer::tagHBDetIdList_

private

Definition at line 42 of file HcalDigiSortedTableProducer.cc.

tagHEDetIdList_

edm::InputTag HcalDigiSortedTableProducer::tagHEDetIdList_

private

Definition at line 43 of file HcalDigiSortedTableProducer.cc.

tagHFDetIdList_

edm::InputTag HcalDigiSortedTableProducer::tagHFDetIdList_

private

Definition at line 44 of file HcalDigiSortedTableProducer.cc.

tagHO_

edm::InputTag HcalDigiSortedTableProducer::tagHO_

private

Definition at line 54 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer().

tagHODetIdList_

edm::InputTag HcalDigiSortedTableProducer::tagHODetIdList_

private

Definition at line 45 of file HcalDigiSortedTableProducer.cc.

tagQIE10_

edm::InputTag HcalDigiSortedTableProducer::tagQIE10_

private

Definition at line 53 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer().

tagQIE11_

edm::InputTag HcalDigiSortedTableProducer::tagQIE11_

private

Definition at line 52 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer().

tokenHBDetIdList_

edm::EDGetTokenT<std::vector<HcalDetId> > HcalDigiSortedTableProducer::tokenHBDetIdList_

private

Definition at line 47 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

tokenHcalDbService_

edm::ESGetToken<HcalDbService, HcalDbRecord> HcalDigiSortedTableProducer::tokenHcalDbService_

private

Definition at line 60 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

tokenHEDetIdList_

edm::EDGetTokenT<std::vector<HcalDetId> > HcalDigiSortedTableProducer::tokenHEDetIdList_

private

Definition at line 48 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

tokenHFDetIdList_

edm::EDGetTokenT<std::vector<HcalDetId> > HcalDigiSortedTableProducer::tokenHFDetIdList_

private

Definition at line 49 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

tokenHO_

edm::EDGetTokenT<HODigiCollection> HcalDigiSortedTableProducer::tokenHO_

private

Definition at line 58 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer(), and produce().

tokenHODetIdList_

edm::EDGetTokenT<std::vector<HcalDetId> > HcalDigiSortedTableProducer::tokenHODetIdList_

private

Definition at line 50 of file HcalDigiSortedTableProducer.cc.

Referenced by beginRun().

tokenQIE10_

edm::EDGetTokenT<QIE10DigiCollection> HcalDigiSortedTableProducer::tokenQIE10_

private

Definition at line 57 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer(), and produce().

tokenQIE11_

edm::EDGetTokenT<QIE11DigiCollection> HcalDigiSortedTableProducer::tokenQIE11_

private

Definition at line 56 of file HcalDigiSortedTableProducer.cc.

Referenced by HcalDigiSortedTableProducer(), and produce().