#include <EcalZeroSuppressionProducer.h>

Inheritance diagram for EcalZeroSuppressionProducer:

Public Member Functions
	EcalZeroSuppressionProducer (const edm::ParameterSet &params)

void	initCalibrations (const edm::EventSetup &eventSetup)

void	produce (edm::Event &event, const edm::EventSetup &eventSetup) override

	~EcalZeroSuppressionProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
std::string	digiProducer_

edm::EDGetTokenT< EBDigiCollection >	EB_token

std::string	EBdigiCollection_

std::string	EBZSdigiCollection_

edm::EDGetTokenT< EEDigiCollection >	EE_token

std::string	EEdigiCollection_

std::string	EEZSdigiCollection_

double	glbBarrelThreshold_

double	glbEndcapThreshold_

EcalZeroSuppressor< EBDataFrame >	theBarrelZeroSuppressor_

EcalZeroSuppressor< EEDataFrame >	theEndcapZeroSuppressor_

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

Detailed Description

Definition at line 23 of file EcalZeroSuppressionProducer.h.

Constructor & Destructor Documentation

◆ EcalZeroSuppressionProducer()

EcalZeroSuppressionProducer::EcalZeroSuppressionProducer ( const edm::ParameterSet & params )

explicit

Definition at line 4 of file EcalZeroSuppressionProducer.cc.

                                                                                       {
   digiProducer_ = params.getParameter<std::string>("digiProducer");
   EBdigiCollection_ = params.getParameter<std::string>("EBdigiCollection");
   EEdigiCollection_ = params.getParameter<std::string>("EEdigiCollection");
   EBZSdigiCollection_ = params.getParameter<std::string>("EBZSdigiCollection");
   EEZSdigiCollection_ = params.getParameter<std::string>("EEZSdigiCollection");
  
   // initialize the default values for the thresholds in number of noise sigmas
  
   glbBarrelThreshold_ = params.getUntrackedParameter<double>("glbBarrelThreshold", 0.2);
   glbEndcapThreshold_ = params.getUntrackedParameter<double>("glbEndcapThreshold", 0.4);
  
   produces<EBDigiCollection>(EBZSdigiCollection_);
   produces<EEDigiCollection>(EEZSdigiCollection_);
  
   EB_token = consumes<EBDigiCollection>(edm::InputTag(digiProducer_));
   EE_token = consumes<EEDigiCollection>(edm::InputTag(digiProducer_));
   ;
 }

References digiProducer_, EB_token, EBdigiCollection_, EBZSdigiCollection_, EE_token, EEdigiCollection_, EEZSdigiCollection_, glbBarrelThreshold_, glbEndcapThreshold_, CalibrationSummaryClient_cfi::params, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~EcalZeroSuppressionProducer()

EcalZeroSuppressionProducer::~EcalZeroSuppressionProducer ( )

override

Definition at line 24 of file EcalZeroSuppressionProducer.cc.

24 {}

Member Function Documentation

◆ initCalibrations()

void EcalZeroSuppressionProducer::initCalibrations ( const edm::EventSetup & eventSetup )

Definition at line 106 of file EcalZeroSuppressionProducer.cc.

                                                                                   {
   // Pedestals from event setup
  
   edm::ESHandle<EcalPedestals> dbPed;
   eventSetup.get<EcalPedestalsRcd>().get(dbPed);
   const EcalPedestals *thePedestals = dbPed.product();
  
   theBarrelZeroSuppressor_.setPedestals(thePedestals);
   theEndcapZeroSuppressor_.setPedestals(thePedestals);
 }

References edm::EventSetup::get(), get, edm::ESHandle< T >::product(), EcalZeroSuppressor< C >::setPedestals(), theBarrelZeroSuppressor_, and theEndcapZeroSuppressor_.

Referenced by produce().

◆ produce()

void EcalZeroSuppressionProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Produces the EDM products,

Definition at line 26 of file EcalZeroSuppressionProducer.cc.

                                                                                           {
   // Get Inputs
  
   initCalibrations(eventSetup);
  
   edm::Handle<EBDigiCollection> pEBDigis;
   edm::Handle<EEDigiCollection> pEEDigis;
  
   const EBDigiCollection *fullBarrelDigis = nullptr;
   const EEDigiCollection *fullEndcapDigis = nullptr;
  
   event.getByToken(EB_token, pEBDigis);
   if (pEBDigis.isValid()) {
     fullBarrelDigis = pEBDigis.product();  // get a ptr to the produc
     edm::LogInfo("ZeroSuppressionInfo") << "total # fullBarrelDigis: " << fullBarrelDigis->size();
   } else {
     edm::LogError("ZeroSuppressionError") << "Error! can't get the product " << EBdigiCollection_.c_str();
   }
  
   event.getByToken(EE_token, pEEDigis);
   if (pEEDigis.isValid()) {
     fullEndcapDigis = pEEDigis.product();  // get a ptr to the product
     edm::LogInfo("ZeroSuppressionInfo") << "total # fullEndcapDigis: " << fullEndcapDigis->size();
   } else {
     edm::LogError("ZeroSuppressionError") << "Error! can't get the product " << EEdigiCollection_.c_str();
   }
  
   // collection of zero suppressed digis to put in the event
  
   std::unique_ptr<EBDigiCollection> gzsBarrelDigis(new EBDigiCollection());
   std::unique_ptr<EEDigiCollection> gzsEndcapDigis(new EEDigiCollection());
  
   CaloDigiCollectionSorter sorter(5);
  
   // Barrel zero suppression
  
   if (fullBarrelDigis) {
     for (EBDigiCollection::const_iterator digiItr = (*fullBarrelDigis).begin(); digiItr != (*fullBarrelDigis).end();
          ++digiItr) {
       bool isAccepted = theBarrelZeroSuppressor_.accept(*digiItr, glbBarrelThreshold_);
       if (isAccepted) {
         (*gzsBarrelDigis).push_back(digiItr->id(), digiItr->begin());
       }
     }
     edm::LogInfo("ZeroSuppressionInfo") << "EB Digis: " << gzsBarrelDigis->size();
  
     // std::vector<EBDataFrame> sortedDigisEB =
     // sorter.sortedVector(*gzsBarrelDigis); LogDebug("ZeroSuppressionDump") <<
     // "Top 10 EB digis"; for(int i = 0; i < std::min(10,(int)
     // sortedDigisEB.size()); ++i)
     //  {
     //    LogDebug("ZeroSuppressionDump") << sortedDigisEB[i];
     //  }
   }
  
   // Endcap zero suppression
  
   if (fullEndcapDigis) {
     for (EEDigiCollection::const_iterator digiItr = (*fullEndcapDigis).begin(); digiItr != (*fullEndcapDigis).end();
          ++digiItr) {
       bool isAccepted = theEndcapZeroSuppressor_.accept(*digiItr, glbEndcapThreshold_);
       if (isAccepted) {
         (*gzsEndcapDigis).push_back(digiItr->id(), digiItr->begin());
       }
     }
     edm::LogInfo("ZeroSuppressionInfo") << "EB Digis: " << gzsBarrelDigis->size();
  
     //    std::vector<EEDataFrame> sortedDigisEE =
     //    sorter.sortedVector(*gzsEndcapDigis);
     // LogDebug("ZeroSuppressionDump")  << "Top 10 EE digis";
     // for(int i = 0; i < std::min(10,(int) sortedDigisEE.size()); ++i)
     //  {
     //    LogDebug("ZeroSuppressionDump") << sortedDigisEE[i];
     //  }
   }
   // Step D: Put outputs into event
   event.put(std::move(gzsBarrelDigis), EBZSdigiCollection_);
   event.put(std::move(gzsEndcapDigis), EEZSdigiCollection_);
 }