HcalRawToDigi Class Reference

#include <HcalRawToDigi.h>

Inheritance diagram for HcalRawToDigi:

Classes
struct	Statistics

Public Member Functions
	HcalRawToDigi (const edm::ParameterSet &ps)
virtual void	produce (edm::Event &, const edm::EventSetup &) override
virtual	~HcalRawToDigi ()
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)
virtual	~ProducerBase () noexcept(false)
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
const bool	complainEmptyData_
std::string	electronicsMapLabel_
const int	expectedOrbitMessageTime_
std::vector< int >	fedUnpackList_
HcalDataFrameFilter	filter_
const int	firstFED_
const bool	silent_
struct HcalRawToDigi::Statistics	stats_
edm::EDGetTokenT< FEDRawDataCollection >	tok_data_
const bool	unpackCalib_
HcalUnpacker	unpacker_
const int	unpackerMode_
const bool	unpackTTP_
bool	unpackUMNio_
const bool	unpackZDC_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

HcalRawToDigi is the EDProducer subclass which runs the Hcal Unpack algorithm.

Author

Jeremiah Mans

Version

1st Version June 10, 2005

Definition at line 29 of file HcalRawToDigi.h.

Constructor & Destructor Documentation

HcalRawToDigi::HcalRawToDigi ( const edm::ParameterSet &  ps )

explicit

Definition at line 14 of file HcalRawToDigi.cc.

References electronicsMapLabel_, expectedOrbitMessageTime_, fedUnpackList_, edm::ParameterSet::getParameter(), mps_fire::i, FEDNumbering::MAXHCALFEDID, FEDNumbering::MAXHCALuTCAFEDID, FEDNumbering::MINHCALFEDID, FEDNumbering::MINHCALuTCAFEDID, HcalUnpacker::setExpectedOrbitMessageTime(), HcalUnpacker::setMode(), stats_, AlCaHLTBitMon_QueryRunRegistry::string, tok_data_, unpackCalib_, unpacker_, unpackerMode_, unpackTTP_, unpackUMNio_, and unpackZDC_.

                                                       :
  unpacker_(conf.getUntrackedParameter<int>("HcalFirstFED",int(FEDNumbering::MINHCALFEDID)),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
  filter_(conf.getParameter<bool>("FilterDataQuality"),conf.getParameter<bool>("FilterDataQuality"),
      false,
      0, 0, 
      -1),
  fedUnpackList_(conf.getUntrackedParameter<std::vector<int> >("FEDs", std::vector<int>())),
  firstFED_(conf.getUntrackedParameter<int>("HcalFirstFED",FEDNumbering::MINHCALFEDID)),
  unpackCalib_(conf.getUntrackedParameter<bool>("UnpackCalib",false)),
  unpackZDC_(conf.getUntrackedParameter<bool>("UnpackZDC",false)),
  unpackTTP_(conf.getUntrackedParameter<bool>("UnpackTTP",false)),
  unpackUMNio_(conf.getUntrackedParameter<bool>("UnpackUMNio",false)),
  silent_(conf.getUntrackedParameter<bool>("silent",true)),
  complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData",false)),
  unpackerMode_(conf.getUntrackedParameter<int>("UnpackerMode",0)),
  expectedOrbitMessageTime_(conf.getUntrackedParameter<int>("ExpectedOrbitMessageTime",-1))
{
  electronicsMapLabel_ = conf.getParameter<std::string>("ElectronicsMap");
  tok_data_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("InputLabel"));

  if (fedUnpackList_.empty()) {
    // VME range for back-compatibility
    for (int i=FEDNumbering::MINHCALFEDID; i<=FEDNumbering::MAXHCALFEDID; i++)
      fedUnpackList_.push_back(i);

    // uTCA range 
    for (int i=FEDNumbering::MINHCALuTCAFEDID; i<=FEDNumbering::MAXHCALuTCAFEDID; i++)
      fedUnpackList_.push_back(i);
  } 
  
  unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);
  unpacker_.setMode(unpackerMode_);
  std::ostringstream ss;
  for (unsigned int i=0; i<fedUnpackList_.size(); i++) 
    ss << fedUnpackList_[i] << " ";
  edm::LogInfo("HCAL") << "HcalRawToDigi will unpack FEDs ( " << ss.str() << ")";
    
  // products produced...
  produces<HBHEDigiCollection>();
  produces<HFDigiCollection>();
  produces<HODigiCollection>();
  produces<HcalTrigPrimDigiCollection>();
  produces<HOTrigPrimDigiCollection>();
  produces<HcalUnpackerReport>();
  if (unpackCalib_)
    produces<HcalCalibDigiCollection>();
  if (unpackZDC_)
    produces<ZDCDigiCollection>();
  if (unpackTTP_)
    produces<HcalTTPDigiCollection>();
  if (unpackUMNio_)
    produces<HcalUMNioDigi>();
  produces<QIE10DigiCollection>();
  produces<QIE11DigiCollection>();
  produces<QIE10DigiCollection>("ZDC");
  
  memset(&stats_,0,sizeof(stats_));

}

HcalRawToDigi::~HcalRawToDigi ( )

virtual

Definition at line 75 of file HcalRawToDigi.cc.

{ }  

Member Function Documentation

void HcalRawToDigi::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 77 of file HcalRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), createfilelist::int, FEDNumbering::MINHCALFEDID, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
  edm::ParameterSetDescription desc;
  desc.addUntracked<int>("HcalFirstFED",int(FEDNumbering::MINHCALFEDID));
  desc.add<int>("firstSample",0);
  desc.add<int>("lastSample",9);
  desc.add<bool>("FilterDataQuality",true);
  desc.addUntracked<std::vector<int>>("FEDs", std::vector<int>());
  desc.addUntracked<bool>("UnpackZDC",true);
  desc.addUntracked<bool>("UnpackCalib",true);
  desc.addUntracked<bool>("UnpackUMNio",true);
  desc.addUntracked<bool>("UnpackTTP",true);
  desc.addUntracked<bool>("silent",true);
  desc.addUntracked<bool>("ComplainEmptyData",false);
  desc.addUntracked<int>("UnpackerMode",0);
  desc.addUntracked<int>("ExpectedOrbitMessageTime",-1);
  desc.add<edm::InputTag>("InputLabel",edm::InputTag("rawDataCollector"));
  desc.add<std::string>("ElectronicsMap","");
  descriptions.add("hcalRawToDigi",desc);
}

void HcalRawToDigi::produce ( edm::Event &  e, const edm::EventSetup &  es  )

overridevirtual

calib

zdc

umnio

Definition at line 99 of file HcalRawToDigi.cc.

References HcalDataFrameFilter::active(), HcalRawToDigi::Statistics::ave_calib, HcalRawToDigi::Statistics::ave_hbhe, HcalRawToDigi::Statistics::ave_hf, HcalRawToDigi::Statistics::ave_ho, HcalRawToDigi::Statistics::ave_tp, HcalRawToDigi::Statistics::ave_tpho, HcalUnpacker::Collections::calibCont, complainEmptyData_, electronicsMapLabel_, FEDRawDataCollection::FEDData(), fedUnpackList_, HcalDataFrameFilter::filter(), filter_, edm::EventSetup::get(), edm::Event::getByToken(), photonIsolationHIProducer_cfi::hbhe, HcalUnpacker::Collections::hbheCont, AnalysisDataFormats_SUSYBSMObjects::hc, photonIsolationHIProducer_cfi::hf, HcalUnpacker::Collections::hfCont, photonIsolationHIProducer_cfi::ho, HcalUnpacker::Collections::hoCont, mps_fire::i, hpstanc_transforms::max, HcalRawToDigi::Statistics::max_calib, HcalRawToDigi::Statistics::max_hbhe, HcalRawToDigi::Statistics::max_hf, HcalRawToDigi::Statistics::max_ho, HcalRawToDigi::Statistics::max_tp, HcalRawToDigi::Statistics::max_tpho, eostools::move(), HcalRawToDigi::Statistics::n, parseEventContent::prod, edm::ESHandle< T >::product(), edm::Event::put(), HcalUnpacker::Collections::qie10, HcalUnpacker::Collections::qie10ZDC, HcalUnpacker::Collections::qie11, edmIntegrityCheck::report, edm::second(), HcalDataFrameFilter::setConditions(), silent_, FEDRawData::size(), stats_, edm::SortedCollection< T, SORT >::swap(), tok_data_, HcalUnpacker::Collections::tpCont, HcalUnpacker::Collections::tphoCont, HcalUnpacker::Collections::ttp, HcalUnpacker::Collections::umnio, HcalUnpacker::unpack(), unpackCalib_, unpacker_, unpackTTP_, unpackUMNio_, unpackZDC_, cms::Exception::what(), hcalSimParameters_cfi::zdc, and HcalUnpacker::Collections::zdcCont.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

{
  // Step A: Get Inputs 
  edm::Handle<FEDRawDataCollection> rawraw;  
  e.getByToken(tok_data_,rawraw);
  // get the mapping
  edm::ESHandle<HcalDbService> pSetup;
  es.get<HcalDbRecord>().get( pSetup );
  edm::ESHandle<HcalElectronicsMap> item;
  es.get<HcalElectronicsMapRcd>().get(electronicsMapLabel_, item);
  const HcalElectronicsMap* readoutMap = item.product();
  filter_.setConditions(pSetup.product());
  
  // Step B: Create empty output  : three vectors for three classes...
  std::vector<HBHEDataFrame> hbhe;
  std::vector<HODataFrame> ho;
  std::vector<HFDataFrame> hf;
  std::vector<HcalTriggerPrimitiveDigi> htp;
  std::vector<HcalCalibDataFrame> hc;
  std::vector<ZDCDataFrame> zdc;
  std::vector<HcalTTPDigi> ttp;
  std::vector<HOTriggerPrimitiveDigi> hotp;
  HcalUMNioDigi umnio;
  auto report = std::make_unique<HcalUnpackerReport>();

  // Heuristics: use ave+(max-ave)/8
  if (stats_.max_hbhe>0) hbhe.reserve(stats_.ave_hbhe+(stats_.max_hbhe-stats_.ave_hbhe)/8);
  if (stats_.max_ho>0) ho.reserve(stats_.ave_ho+(stats_.max_ho-stats_.ave_ho)/8);
  if (stats_.max_hf>0) hf.reserve(stats_.ave_hf+(stats_.max_hf-stats_.ave_hf)/8);
  if (stats_.max_calib>0) hc.reserve(stats_.ave_calib+(stats_.max_calib-stats_.ave_calib)/8);
  if (stats_.max_tp>0) htp.reserve(stats_.ave_tp+(stats_.max_tp-stats_.ave_tp)/8);
  if (stats_.max_tpho>0) hotp.reserve(stats_.ave_tpho+(stats_.max_tpho-stats_.ave_tpho)/8);

  if (unpackZDC_) zdc.reserve(24);


  HcalUnpacker::Collections colls;
  colls.hbheCont=&hbhe;
  colls.hoCont=&ho;
  colls.hfCont=&hf;
  colls.tpCont=&htp;
  colls.tphoCont=&hotp;
  colls.calibCont=&hc;
  colls.zdcCont=&zdc;
  colls.umnio=&umnio;
  if (unpackTTP_) colls.ttp=&ttp;
 
  // Step C: unpack all requested FEDs
  for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
    const FEDRawData& fed = rawraw->FEDData(*i);
    if (fed.size()==0) {
      if (complainEmptyData_) {
    if (!silent_) edm::LogWarning("EmptyData") << "No data for FED " << *i;
    report->addError(*i);
      }
    } else if (fed.size()<8*3) {
      if (!silent_) edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
      report->addError(*i);
    } else {
      try {
    unpacker_.unpack(fed,*readoutMap,colls, *report,silent_);
    report->addUnpacked(*i);
      } catch (cms::Exception& e) {
    if (!silent_) edm::LogWarning("Unpacking error") << e.what();
    report->addError(*i);
      } catch (...) {
    if (!silent_) edm::LogWarning("Unpacking exception");
    report->addError(*i);
      }
    }
  }


  // gather statistics
  stats_.max_hbhe=std::max(stats_.max_hbhe,(int)hbhe.size());
  stats_.ave_hbhe=(stats_.ave_hbhe*stats_.n+hbhe.size())/(stats_.n+1);
  stats_.max_ho=std::max(stats_.max_ho,(int)ho.size());
  stats_.ave_ho=(stats_.ave_ho*stats_.n+ho.size())/(stats_.n+1);
  stats_.max_hf=std::max(stats_.max_hf,(int)hf.size());
  stats_.ave_hf=(stats_.ave_hf*stats_.n+hf.size())/(stats_.n+1);
  stats_.max_tp=std::max(stats_.max_tp,(int)htp.size());
  stats_.ave_tp=(stats_.ave_tp*stats_.n+htp.size())/(stats_.n+1);
  stats_.max_tpho=std::max(stats_.max_tpho,(int)hotp.size());
  stats_.ave_tpho=(stats_.ave_tpho*stats_.n+hotp.size())/(stats_.n+1);
  stats_.max_calib=std::max(stats_.max_calib,(int)hc.size());
  stats_.ave_calib=(stats_.ave_calib*stats_.n+hc.size())/(stats_.n+1);


  stats_.n++;

  // check HF duplication
  std::unordered_set<uint32_t> cacheForHFdup;
  unsigned int cntHFdup = 0;
  for( auto & hf_digi : hf ){
     if( ! cacheForHFdup.insert(hf_digi.id().rawId()).second ) cntHFdup++;
  }
  if( cntHFdup ) edm::LogError("HcalRawToDigi") << "Duplicated HF digis found for "<<cntHFdup<<" times"<<std::endl;

  // Step B: encapsulate vectors in actual collections
  auto hbhe_prod = std::make_unique<HBHEDigiCollection>();
  auto hf_prod = std::make_unique<HFDigiCollection>();
  auto ho_prod = std::make_unique<HODigiCollection>();
  auto htp_prod = std::make_unique<HcalTrigPrimDigiCollection>();
  auto hotp_prod = std::make_unique<HOTrigPrimDigiCollection>();
  if (colls.qie10 == 0) {
    colls.qie10 = new QIE10DigiCollection(); 
  }
  std::unique_ptr<QIE10DigiCollection> qie10_prod(colls.qie10);
  if (colls.qie10ZDC == 0) {
    colls.qie10ZDC = new QIE10DigiCollection(); 
  }
  std::unique_ptr<QIE10DigiCollection> qie10ZDC_prod(colls.qie10ZDC);
  if (colls.qie11 == 0) {
    colls.qie11 = new QIE11DigiCollection(); 
  }
  std::unique_ptr<QIE11DigiCollection> qie11_prod(colls.qie11);

  hbhe_prod->swap_contents(hbhe);
  if( !cntHFdup ) hf_prod->swap_contents(hf);
  ho_prod->swap_contents(ho);
  htp_prod->swap_contents(htp);
  hotp_prod->swap_contents(hotp);

  // Step C2: filter FEDs, if required
  if (filter_.active()) {
    HBHEDigiCollection filtered_hbhe=filter_.filter(*hbhe_prod,*report);
    HODigiCollection filtered_ho=filter_.filter(*ho_prod,*report);
    HFDigiCollection filtered_hf=filter_.filter(*hf_prod,*report);
    QIE10DigiCollection filtered_qie10=filter_.filter(*qie10_prod,*report);
    QIE11DigiCollection filtered_qie11=filter_.filter(*qie11_prod,*report);
    
    hbhe_prod->swap(filtered_hbhe);
    ho_prod->swap(filtered_ho);
    hf_prod->swap(filtered_hf);    
    qie10_prod->swap(filtered_qie10);
    qie11_prod->swap(filtered_qie11);
  }


  // Step D: Put outputs into event
  // just until the sorting is proven
  hbhe_prod->sort();
  ho_prod->sort();
  hf_prod->sort();
  htp_prod->sort();
  hotp_prod->sort();
  qie10_prod->sort();
  qie10ZDC_prod->sort();
  qie11_prod->sort();

  e.put(std::move(hbhe_prod));
  e.put(std::move(ho_prod));
  e.put(std::move(hf_prod));
  e.put(std::move(htp_prod));
  e.put(std::move(hotp_prod));
  e.put(std::move(qie10_prod));
  e.put(std::move(qie10ZDC_prod),"ZDC");
  e.put(std::move(qie11_prod));

  if (unpackCalib_) {
    auto hc_prod = std::make_unique<HcalCalibDigiCollection>();
    hc_prod->swap_contents(hc);

    if (filter_.active()) {
      HcalCalibDigiCollection filtered_calib=filter_.filter(*hc_prod,*report);
      hc_prod->swap(filtered_calib);
    }

    hc_prod->sort();
    e.put(std::move(hc_prod));
  }

  if (unpackZDC_) {
    auto prod = std::make_unique<ZDCDigiCollection>();
    prod->swap_contents(zdc);
    
    if (filter_.active()) {
      ZDCDigiCollection filtered_zdc=filter_.filter(*prod,*report);
      prod->swap(filtered_zdc);
    }

    prod->sort();
    e.put(std::move(prod));
  }

  if (unpackTTP_) {
    auto prod = std::make_unique<HcalTTPDigiCollection>();
    prod->swap_contents(ttp);
    
    prod->sort();
    e.put(std::move(prod));
  }
  e.put(std::move(report));
  if (unpackUMNio_) {
    if(colls.umnio != 0) {
      e.put(std::make_unique<HcalUMNioDigi>(umnio));
    }

  }
}

Member Data Documentation

const bool HcalRawToDigi::complainEmptyData_

private

Definition at line 44 of file HcalRawToDigi.h.

Referenced by produce().

std::string HcalRawToDigi::electronicsMapLabel_

private

Definition at line 46 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const int HcalRawToDigi::expectedOrbitMessageTime_

private

Definition at line 45 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

std::vector<int> HcalRawToDigi::fedUnpackList_

private

Definition at line 40 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

HcalDataFrameFilter HcalRawToDigi::filter_

private

Definition at line 39 of file HcalRawToDigi.h.

Referenced by produce().

const int HcalRawToDigi::firstFED_

private

Definition at line 41 of file HcalRawToDigi.h.

const bool HcalRawToDigi::silent_

private

Definition at line 44 of file HcalRawToDigi.h.

Referenced by produce().

struct HcalRawToDigi::Statistics HcalRawToDigi::stats_

private

Referenced by HcalRawToDigi(), and produce().

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigi::tok_data_

private

Definition at line 37 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const bool HcalRawToDigi::unpackCalib_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

HcalUnpacker HcalRawToDigi::unpacker_

private

Definition at line 38 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const int HcalRawToDigi::unpackerMode_

private

Definition at line 45 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

const bool HcalRawToDigi::unpackTTP_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

bool HcalRawToDigi::unpackUMNio_

private

Definition at line 43 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const bool HcalRawToDigi::unpackZDC_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().