#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

	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 &	itemsToGetFromEvent () 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(), 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.

75 { }

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.

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();
   
   // 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);
     
     hbhe_prod->swap(filtered_hbhe);
     ho_prod->swap(filtered_ho);
     hf_prod->swap(filtered_hf);    
   }
 
 
   // 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));
     }
 
   }
 }