#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

	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 Attributes
const std::string	digiProducer_

const std::string	ebDigiCollection_

const edm::EDGetTokenT < EBDigiCollection >	ebToken_

const std::string	ebZSdigiCollection_

const std::string	eeDigiCollection_

const edm::EDGetTokenT < EEDigiCollection >	eeToken_

const std::string	eeZSdigiCollection_

const double	glbBarrelThreshold_

const double	glbEndcapThreshold_

const edm::ESGetToken < EcalPedestals, EcalPedestalsRcd >	pedestalToken_

EcalZeroSuppressor< EBDataFrame >	theBarrelZeroSuppressor_

EcalZeroSuppressor< EEDataFrame >	theEndcapZeroSuppressor_

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 22 of file EcalZeroSuppressionProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 4 of file EcalZeroSuppressionProducer.cc.

References ebZSdigiCollection_, and eeZSdigiCollection_.

     : glbBarrelThreshold_(params.getUntrackedParameter<double>("glbBarrelThreshold", 0.2)),
       glbEndcapThreshold_(params.getUntrackedParameter<double>("glbEndcapThreshold", 0.4)),
       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")),
       ebToken_(consumes<EBDigiCollection>(edm::InputTag(digiProducer_))),
       eeToken_(consumes<EEDigiCollection>(edm::InputTag(digiProducer_))),
       pedestalToken_(esConsumes()) {
   produces<EBDigiCollection>(ebZSdigiCollection_);
   produces<EEDigiCollection>(eeZSdigiCollection_);
 }

EcalZeroSuppressionProducer::~EcalZeroSuppressionProducer ( )

override

Definition at line 19 of file EcalZeroSuppressionProducer.cc.

19 {}

Member Function Documentation

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

Definition at line 101 of file EcalZeroSuppressionProducer.cc.

References edm::EventSetup::getData(), pedestalToken_, EcalZeroSuppressor< C >::setPedestals(), theBarrelZeroSuppressor_, and theEndcapZeroSuppressor_.

Referenced by produce().

                                                                                   {
   // Pedestals from event setup
   const auto &thePedestals = eventSetup.getData(pedestalToken_);
 
   theBarrelZeroSuppressor_.setPedestals(&thePedestals);
   theEndcapZeroSuppressor_.setPedestals(&thePedestals);
 }

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

override

Produces the EDM products,

Definition at line 21 of file EcalZeroSuppressionProducer.cc.

References EcalZeroSuppressor< C >::accept(), ebDigiCollection_, ebToken_, ebZSdigiCollection_, eeDigiCollection_, eeToken_, eeZSdigiCollection_, glbBarrelThreshold_, glbEndcapThreshold_, initCalibrations(), edm::HandleBase::isValid(), eostools::move(), edm::Handle< T >::product(), edm::DataFrameContainer::size(), MCScenario_CRAFT1_22X::sorter(), theBarrelZeroSuppressor_, and theEndcapZeroSuppressor_.

                                                                                           {
   // Get Inputs
 
   initCalibrations(eventSetup);
 
   edm::Handle<EBDigiCollection> pEBDigis;
   edm::Handle<EEDigiCollection> pEEDigis;
 
   const EBDigiCollection *fullBarrelDigis = nullptr;
   const EEDigiCollection *fullEndcapDigis = nullptr;
 
   event.getByToken(ebToken_, 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(eeToken_, 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
 
   auto gzsBarrelDigis = std::make_unique<EBDigiCollection>();
   auto gzsEndcapDigis = std::make_unique<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_);
 }