#include <EcalSelectiveReadoutProducer.h>

Inheritance diagram for EcalSelectiveReadoutProducer:

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

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

	~EcalSelectiveReadoutProducer () override

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

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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 ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	printSrFlags (std::ostream &os, const EBSrFlagCollection &ebSrFlags, const EESrFlagCollection &eeSrFlags, int iEvent=-1, bool withHeader=true)

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	checkWeights (const edm::Event &evt, const edm::ProductID &noZSDigiId) const

bool	getBinOfMax (const edm::Event &evt, const edm::ProductID &noZsDigiId, int &binOfMax) const

const EBDigiCollection *	getEBDigis (edm::Event &event)

const EEDigiCollection *	getEEDigis (edm::Event &event)

const EcalTrigPrimDigiCollection *	getTrigPrims (edm::Event &event) const

void	printTTFlags (const EcalTrigPrimDigiCollection &tp, std::ostream &os) const


void	checkGeometry (const edm::EventSetup &eventSetup)

void	checkTriggerMap (const edm::EventSetup &eventSetup)

void	checkElecMap (const edm::EventSetup &eventSetup)

Static Private Member Functions
static void	checkValidity (const EcalSRSettings &settings)

Private Attributes
std::string	digiProducer_

int	dumpFlags_

edm::EDGetTokenT< EBDigiCollection >	EB_token

std::string	ebdigiCollection_

std::string	ebSrFlagCollection_

std::string	ebSRPdigiCollection_

edm::EDGetTokenT< EcalTrigPrimDigiCollection >	EcTP_token

edm::EDGetTokenT< EEDigiCollection >	EE_token

std::string	eedigiCollection_

edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	eElecmap_token_

std::string	eeSrFlagCollection_

std::string	eeSRPdigiCollection_

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	eTTmap_token_

bool	firstCallEB_

bool	firstCallEE_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geom_token_

edm::ESGetToken< EcalSRSettings, EcalSRSettingsRcd >	hSr_token_

int	iEvent_

bool	produceDigis_

const EcalSRSettings *	settings_

std::unique_ptr< EcalSRSettings >	settingsFromFile_

EcalSelectiveReadoutSuppressor	suppressor_

bool	suppressorSettingsSet_ = false

const EcalElectronicsMapping *	theElecMap

const CaloGeometry *	theGeometry

const EcalTrigTowerConstituentsMap *	theTriggerTowerMap

bool	trigPrimBypass_

int	trigPrimBypassMode_

std::string	trigPrimCollection_

std::string	trigPrimProducer_

bool	useCondDb_

bool	useFullReadout_

bool	writeSrFlags_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 18 of file EcalSelectiveReadoutProducer.h.

Constructor & Destructor Documentation

◆ EcalSelectiveReadoutProducer()

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

explicit

Constructor

Parameters

params seletive readout parameters

Definition at line 19 of file EcalSelectiveReadoutProducer.cc.

References digiProducer_, dumpFlags_, EB_token, ebdigiCollection_, ebSrFlagCollection_, ebSRPdigiCollection_, EcTP_token, EE_token, eedigiCollection_, eElecmap_token_, eeSrFlagCollection_, eeSRPdigiCollection_, eTTmap_token_, geom_token_, hSr_token_, EcalSRCondTools::importParameterSet(), HLT_2022v12_cff::InputTag, submitPVValidationJobs::params, produceDigis_, settings_, settingsFromFile_, AlCaHLTBitMon_QueryRunRegistry::string, theElecMap, theGeometry, theTriggerTowerMap, trigPrimBypass_, trigPrimBypassMode_, trigPrimCollection_, trigPrimProducer_, useCondDb_, useFullReadout_, and writeSrFlags_.

     : suppressor_(params, consumesCollector()), firstCallEB_(true), firstCallEE_(true), iEvent_(1) {
   //settings:
   //  settings which are only in python config files:
   digiProducer_ = params.getParameter<string>("digiProducer");
   ebdigiCollection_ = params.getParameter<std::string>("EBdigiCollection");
   eedigiCollection_ = params.getParameter<std::string>("EEdigiCollection");
   ebSRPdigiCollection_ = params.getParameter<std::string>("EBSRPdigiCollection");
   eeSRPdigiCollection_ = params.getParameter<std::string>("EESRPdigiCollection");
   ebSrFlagCollection_ = params.getParameter<std::string>("EBSrFlagCollection");
   eeSrFlagCollection_ = params.getParameter<std::string>("EESrFlagCollection");
   trigPrimProducer_ = params.getParameter<string>("trigPrimProducer");
   trigPrimCollection_ = params.getParameter<string>("trigPrimCollection");
   trigPrimBypass_ = params.getParameter<bool>("trigPrimBypass");
   trigPrimBypassMode_ = params.getParameter<int>("trigPrimBypassMode");
   dumpFlags_ = params.getUntrackedParameter<int>("dumpFlags", 0);
   writeSrFlags_ = params.getUntrackedParameter<bool>("writeSrFlags", false);
   produceDigis_ = params.getUntrackedParameter<bool>("produceDigis", true);
   //   settings which can come from either condition database or python configuration file:
   useCondDb_ = false;
   try {
     if (params.getParameter<bool>("configFromCondDB")) {
       useCondDb_ = true;
     }
   } catch (cms::Exception const&) {
     /* pameter not found */
     edm::LogWarning("EcalSelectiveReadout") << "Parameter configFromCondDB of EcalSelectiveReadout module not found. "
                                                "Selective readout configuration will be read from python file.";
   }
   if (!useCondDb_) {
     settingsFromFile_ = std::make_unique<EcalSRSettings>();
     EcalSRCondTools::importParameterSet(*settingsFromFile_, params);
     settings_ = settingsFromFile_.get();
   }
 
   //declares the products made by this producer:
   if (produceDigis_) {
     produces<EBDigiCollection>(ebSRPdigiCollection_);
     produces<EEDigiCollection>(eeSRPdigiCollection_);
   }
 
   if (writeSrFlags_) {
     produces<EBSrFlagCollection>(ebSrFlagCollection_);
     produces<EESrFlagCollection>(eeSrFlagCollection_);
   }
 
   useFullReadout_ = false;
   useFullReadout_ = params.getParameter<bool>("UseFullReadout");
 
   theGeometry = nullptr;
   theTriggerTowerMap = nullptr;
   theElecMap = nullptr;
 
   EB_token = consumes<EBDigiCollection>(edm::InputTag(digiProducer_, ebdigiCollection_));
   EE_token = consumes<EEDigiCollection>(edm::InputTag(digiProducer_, eedigiCollection_));
   ;
   EcTP_token = consumes<EcalTrigPrimDigiCollection>(edm::InputTag(trigPrimProducer_, trigPrimCollection_));
   if (useFullReadout_) {
     hSr_token_ = esConsumes<EcalSRSettings, EcalSRSettingsRcd>(edm::ESInputTag("", "fullReadout"));
   } else {
     hSr_token_ = esConsumes<EcalSRSettings, EcalSRSettingsRcd>();
   }
   geom_token_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
   eTTmap_token_ = esConsumes<EcalTrigTowerConstituentsMap, IdealGeometryRecord>();
   eElecmap_token_ = esConsumes<EcalElectronicsMapping, EcalMappingRcd>();
   ;
 }

◆ ~EcalSelectiveReadoutProducer()

EcalSelectiveReadoutProducer::~EcalSelectiveReadoutProducer ( )

override

Destructor

Definition at line 87 of file EcalSelectiveReadoutProducer.cc.

87 {}

Member Function Documentation

◆ checkElecMap()

void EcalSelectiveReadoutProducer::checkElecMap ( const edm::EventSetup & eventSetup )

private

Definition at line 234 of file EcalSelectiveReadoutProducer.cc.

References eElecmap_token_, options_cfi::eventSetup, EcalSelectiveReadoutSuppressor::setElecMap(), suppressor_, and theElecMap.

Referenced by produce().

                                                                                {
   edm::ESHandle<EcalElectronicsMapping> eElecmap = eventSetup.getHandle(eElecmap_token_);
 
   const EcalElectronicsMapping* pMap = &*eElecmap;
 
   // see if we need to update
   if (pMap != theElecMap) {
     theElecMap = pMap;
     suppressor_.setElecMap(theElecMap);
   }
 }

◆ checkGeometry()

void EcalSelectiveReadoutProducer::checkGeometry ( const edm::EventSetup & eventSetup )

private

call these once an event, to make sure everything is up-to-date

Definition at line 210 of file EcalSelectiveReadoutProducer.cc.

References options_cfi::eventSetup, geom_token_, EcalSelectiveReadoutSuppressor::setGeometry(), suppressor_, and theGeometry.

Referenced by produce().

                                                                                 {
   edm::ESHandle<CaloGeometry> hGeometry = eventSetup.getHandle(geom_token_);
 
   const CaloGeometry* pGeometry = &*hGeometry;
 
   // see if we need to update
   if (pGeometry != theGeometry) {
     theGeometry = pGeometry;
     suppressor_.setGeometry(theGeometry);
   }
 }

◆ checkTriggerMap()

void EcalSelectiveReadoutProducer::checkTriggerMap ( const edm::EventSetup & eventSetup )

private

Definition at line 222 of file EcalSelectiveReadoutProducer.cc.

References eTTmap_token_, options_cfi::eventSetup, EcalSelectiveReadoutSuppressor::setTriggerMap(), suppressor_, and theTriggerTowerMap.

Referenced by produce().

                                                                                   {
   edm::ESHandle<EcalTrigTowerConstituentsMap> eTTmap = eventSetup.getHandle(eTTmap_token_);
 
   const EcalTrigTowerConstituentsMap* pMap = &*eTTmap;
 
   // see if we need to update
   if (pMap != theTriggerTowerMap) {
     theTriggerTowerMap = pMap;
     suppressor_.setTriggerMap(theTriggerTowerMap);
   }
 }

◆ checkValidity()

void EcalSelectiveReadoutProducer::checkValidity ( const EcalSRSettings & settings )

staticprivate

Checks validity of selective setting object is valid to be used for MC, especially checks the number of elements in the vectors

Parameters

forEmulator if true check the restriction that applies for EcalSelectiveReadoutProducer

Exceptions

cms::Exception if the setting is not valid.

Definition at line 495 of file EcalSelectiveReadoutProducer.cc.

References EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, and Exception.

Referenced by produce().

                                                                                {
   if (settings.dccNormalizedWeights_.size() != 1) {
     throw cms::Exception("Configuration")
         << "Selective readout emulator, EcalSelectiveReadout, supports only single set of ZS weights. "
            "while the configuration contains "
         << settings.dccNormalizedWeights_.size() << " set(s)\n";
   }
 
   //   if(settings.dccNormalizedWeights_.size() != 1
   //      && settings.dccNormalizedWeights_.size() != 2
   //      && settings.dccNormalizedWeights_.size() != 54
   //      && settings.dccNormalizedWeights_.size() != 75848){
   //     throw cms::Exception("Configuration") << "Invalid number of DCC weight set (" << settings.dccNormalizedWeights_.size()
   //       << ") in condition object EcalSRSetting::dccNormalizedWeights_. "
   //       << "Valid counts are: 1 (single set), 2 (EB and EE), 54 (one per DCC) and 75848 "
   //       "(one per crystal)\n";
   //   }
 
   if (settings.dccNormalizedWeights_.size() != settings.ecalDccZs1stSample_.size()) {
     throw cms::Exception("Configuration")
         << "Inconsistency between number of weigth sets (" << settings.dccNormalizedWeights_.size() << ") and "
         << "number of ecalDccZs1Sample values (" << settings.ecalDccZs1stSample_.size() << ").";
   }
 }

◆ checkWeights()

void EcalSelectiveReadoutProducer::checkWeights	(	const edm::Event &	evt,
		const edm::ProductID &	noZSDigiId
	)		const

private

Sanity check on the DCC FIR filter weights. Log warning or error message if an unexpected weight set is found. In principle it is checked that the maximum weight is applied to the expected maximum sample.

Definition at line 291 of file EcalSelectiveReadoutProducer.cc.

References EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, getBinOfMax(), EcalSelectiveReadoutSuppressor::getFIRTapCount(), mps_fire::i, settings_, and HLT_2022v12_cff::weights.

Referenced by getEBDigis(), and getEEDigis().

                                                                                                          {
   const vector<float>& weights =
       settings_->dccNormalizedWeights_[0];  //params_.getParameter<vector<double> >("dccNormalizedWeights");
   int nFIRTaps = EcalSelectiveReadoutSuppressor::getFIRTapCount();
   static std::atomic<bool> warnWeightCnt{true};
   bool expected = true;
   if ((int)weights.size() > nFIRTaps &&
       warnWeightCnt.compare_exchange_strong(expected, false, std::memory_order_acq_rel)) {
     edm::LogWarning("Configuration") << "The list of DCC zero suppression FIR "
                                         "weights given in parameter dccNormalizedWeights is longer "
                                         "than the expected depth of the FIR filter :("
                                      << nFIRTaps
                                      << "). "
                                         "The last weights will be discarded.";
   }
 
   if (!weights.empty()) {
     int iMaxWeight = 0;
     double maxWeight = weights[iMaxWeight];
     //looks for index of maximum weight
     for (unsigned i = 0; i < weights.size(); ++i) {
       if (weights[i] > maxWeight) {
         iMaxWeight = i;
         maxWeight = weights[iMaxWeight];
       }
     }
 
     //position of time sample whose maximum weight is applied:
     int maxWeightBin = settings_->ecalDccZs1stSample_[0]  //params_.getParameter<int>("ecalDccZs1stSample")
                        + iMaxWeight;
 
     //gets the bin of maximum (in case of raw data it will not exist)
     int binOfMax = 0;
     bool rc = getBinOfMax(evt, noZsDigiId, binOfMax);
 
     if (rc && maxWeightBin != binOfMax) {
       edm::LogWarning("Configuration") << "The maximum weight of DCC zero suppression FIR filter is not "
                                           "applied to the expected maximum sample("
                                        << binOfMax
                                        << (binOfMax == 1 ? "st"
                                                          : (binOfMax == 2 ? "nd" : (binOfMax == 3 ? "rd" : "th")))
                                        << " time sample). This may indicate faulty 'dccNormalizedWeights' "
                                           "or 'ecalDccZs1sSample' parameters.";
     }
   }
 }

◆ getBinOfMax()

bool EcalSelectiveReadoutProducer::getBinOfMax	(	const edm::Event &	evt,
		const edm::ProductID &	noZsDigiId,
		int &	binOfMax
	)		const

private

Gets the value of the digitizer binOfMaximum parameter.

Parameters

noZsDigiId	product ID of the non-suppressed digis
binOfMax	[out] set the parameter value if found

Returns: true on success, false otherwise

Definition at line 338 of file EcalSelectiveReadoutProducer.cc.

References spr::find(), edm::Event::getStableProvenance(), AlCaHLTBitMon_ParallelJobs::p, edm::parameterSet(), edm::Event::processHistory(), and mps_fire::result.

Referenced by checkWeights().

                                                                     {
   bool rc;
   const edm::StableProvenance& p = evt.getStableProvenance(noZsDigiId);
   const edm::ParameterSet& result = parameterSet(p, evt.processHistory());
   vector<string> ebDigiParamList = result.getParameterNames();
   string bofm("binOfMaximum");
   if (find(ebDigiParamList.begin(), ebDigiParamList.end(), bofm) != ebDigiParamList.end()) {  //bofm found
     binOfMax = result.getParameter<int>("binOfMaximum");
     rc = true;
   } else {
     rc = false;
   }
   return rc;
 }

◆ getEBDigis()

const EBDigiCollection * EcalSelectiveReadoutProducer::getEBDigis ( edm::Event & event )

private

Definition at line 178 of file EcalSelectiveReadoutProducer.cc.

References checkWeights(), EB_token, firstCallEB_, edm::HandleBase::id(), edm::Handle< T >::product(), and mps_fire::result.

Referenced by produce().

                                                                                 {
   edm::Handle<EBDigiCollection> hEBDigis;
   event.getByToken(EB_token, hEBDigis);
   //product() method is called before id() in order to get an exception
   //if the handle is not available (check not done by id() method).
   const EBDigiCollection* result = hEBDigis.product();
   if (firstCallEB_) {
     checkWeights(event, hEBDigis.id());
     firstCallEB_ = false;
   }
   return result;
 }

◆ getEEDigis()

const EEDigiCollection * EcalSelectiveReadoutProducer::getEEDigis ( edm::Event & event )

private

Definition at line 191 of file EcalSelectiveReadoutProducer.cc.

References checkWeights(), EE_token, firstCallEE_, edm::HandleBase::id(), edm::Handle< T >::product(), and mps_fire::result.

Referenced by produce().

                                                                                 {
   edm::Handle<EEDigiCollection> hEEDigis;
   event.getByToken(EE_token, hEEDigis);
   //product() method is called before id() in order to get an exception
   //if the handle is not available (check not done by id() method).
   const EEDigiCollection* result = hEEDigis.product();
   if (firstCallEE_) {
     checkWeights(event, hEEDigis.id());
     firstCallEE_ = false;
   }
   return result;
 }

◆ getTrigPrims()

const EcalTrigPrimDigiCollection * EcalSelectiveReadoutProducer::getTrigPrims ( edm::Event & event ) const

private

Definition at line 204 of file EcalSelectiveReadoutProducer.cc.

References EcTP_token, and edm::Handle< T >::product().

Referenced by produce().

                                                                                                   {
   edm::Handle<EcalTrigPrimDigiCollection> hTPDigis;
   event.getByToken(EcTP_token, hTPDigis);
   return hTPDigis.product();
 }

◆ printSrFlags()

void EcalSelectiveReadoutProducer::printSrFlags	(	std::ostream &	os,
		const EBSrFlagCollection &	ebSrFlags,
		const EESrFlagCollection &	eeSrFlags,
		int	iEvent = `-1`,
		bool	withHeader = `true`
	)

static

Help function to print SR flags.

Parameters

ebSrFlags	the action flags of EB
eeSrFlag	the action flags of EE
iEvent	event number. Ignored if <0.
withHeader,if	true an output description is written out as header.

Definition at line 355 of file EcalSelectiveReadoutProducer.cc.

References cms::cuda::assert(), edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), RemoveAddSevLevel::flag, mps_fire::i, L1TowerCalibrationProducer_cfi::iEta, iEvent, nEndcaps, srpFlagMarker, submitPVValidationJobs::t, and protons_cff::time.

Referenced by produce().

                                                                  {
   const char srpFlagMarker[] = {'.', 'z', 'Z', 'F', '4', '5', '6', '7'};
   if (withHeader) {
     time_t t;
     time(&t);
     const char* date = ctime(&t);
     os << "#SRP flag map\n#\n"
           "# Generatied on: "
        << date
        << "\n#\n"
           "# +-->Phi/Y "
        << srpFlagMarker[0]
        << ": suppressed\n"
           "# |         "
        << srpFlagMarker[1]
        << ": ZS 1\n"
           "# |         "
        << srpFlagMarker[2]
        << ": ZS 2\n"
           "# V Eta/X   "
        << srpFlagMarker[3]
        << ": full readout\n"
           "#\n";
   }
 
   //EE-,EB,EE+ map wil be written onto file in following format:
   //
   //      72
   // <-------------->
   //  20
   // <--->
   //  EEE                A             +-----> Y
   // EEEEE               |             |
   // EE EE               | 20   EE-    |
   // EEEEE               |             |
   //  EEE                V             V X
   // BBBBBBBBBBBBBBBBB   A
   // BBBBBBBBBBBBBBBBB   |             +-----> Phi
   // BBBBBBBBBBBBBBBBB   |             |
   // BBBBBBBBBBBBBBBBB   | 34  EB      |
   // BBBBBBBBBBBBBBBBB   |             |
   // BBBBBBBBBBBBBBBBB   |             V Eta
   // BBBBBBBBBBBBBBBBB   |
   // BBBBBBBBBBBBBBBBB   |
   // BBBBBBBBBBBBBBBBB   V
   //  EEE                A             +-----> Y
   // EEEEE               |             |
   // EE EE               | 20 EE+      |
   // EEEEE               |             |
   //  EEE                V             V X
   //
   //
   //
   //
   //event header:
   if (iEvent >= 0) {
     os << "# Event " << iEvent << "\n";
   }
 
   //retrieve flags:
   const int nEndcaps = 2;
   const int nScX = 20;
   const int nScY = 20;
   int eeSrf[nEndcaps][nScX][nScY];
   for (size_t i = 0; i < sizeof(eeSrf) / sizeof(int); ((int*)eeSrf)[i++] = -1) {
   };
   for (EESrFlagCollection::const_iterator it = eeSrFlags.begin(); it != eeSrFlags.end(); ++it) {
     const EESrFlag& flag = *it;
     int iZ0 = flag.id().zside() > 0 ? 1 : 0;
     int iX0 = flag.id().ix() - 1;
     int iY0 = flag.id().iy() - 1;
     assert(iZ0 >= 0 && iZ0 < nEndcaps);
     assert(iX0 >= 0 && iX0 < nScX);
     assert(iY0 >= 0 && iY0 < nScY);
     eeSrf[iZ0][iX0][iY0] = flag.value();
   }
   const int nEbTtEta = 34;
   const int nEeTtEta = 11;
   const int nTtEta = nEeTtEta * 2 + nEbTtEta;
   const int nTtPhi = 72;
   int ebSrf[nEbTtEta][nTtPhi];
   for (size_t i = 0; i < sizeof(ebSrf) / sizeof(int); ((int*)ebSrf)[i++] = -1) {
   };
   for (EBSrFlagCollection::const_iterator it = ebSrFlags.begin(); it != ebSrFlags.end(); ++it) {
     const EBSrFlag& flag = *it;
     int iEta = flag.id().ieta();
     int iEta0 = iEta + nTtEta / 2 - (iEta >= 0 ? 1 : 0);  //0->55 from eta=-3 to eta=3
     int iEbEta0 = iEta0 - nEeTtEta;                       //0->33 from eta=-1.48 to eta=1.48
     int iPhi0 = flag.id().iphi() - 1;
     assert(iEbEta0 >= 0 && iEbEta0 < nEbTtEta);
     assert(iPhi0 >= 0 && iPhi0 < nTtPhi);
 
     //     cout << __FILE__ << ":" << __LINE__ << ": "
     //   <<  iEta << "\t" << flag.id().iphi() << " -> "
     //   << iEbEta0 << "\t" << iPhi0
     //   << "... Flag: " << flag.value() << "\n";
 
     ebSrf[iEbEta0][iPhi0] = flag.value();
   }
 
   //print flags:
 
   //EE-
   for (int iX0 = 0; iX0 < nScX; ++iX0) {
     for (int iY0 = 0; iY0 < nScY; ++iY0) {
       int srFlag = eeSrf[0][iX0][iY0];
       assert(srFlag >= -1 && srFlag < (int)(sizeof(srpFlagMarker) / sizeof(srpFlagMarker[0])));
       os << (srFlag == -1 ? ' ' : srpFlagMarker[srFlag]);
     }
     os << "\n";  //one Y supercystal column per line
   }              //next supercrystal X-index
 
   //EB
   for (int iEta0 = 0; iEta0 < nEbTtEta; ++iEta0) {
     for (int iPhi0 = 0; iPhi0 < nTtPhi; ++iPhi0) {
       int srFlag = ebSrf[iEta0][iPhi0];
       assert(srFlag >= -1 && srFlag < (int)(sizeof(srpFlagMarker) / sizeof(srpFlagMarker[0])));
       os << (srFlag == -1 ? '?' : srpFlagMarker[srFlag]);
     }
     os << "\n";  //one phi per line
   }
 
   //EE+
   for (int iX0 = 0; iX0 < nScX; ++iX0) {
     for (int iY0 = 0; iY0 < nScY; ++iY0) {
       int srFlag = eeSrf[1][iX0][iY0];
       assert(srFlag >= -1 && srFlag < (int)(sizeof(srpFlagMarker) / sizeof(srpFlagMarker[0])));
       os << (srFlag == -1 ? ' ' : srpFlagMarker[srFlag]);
     }
     os << "\n";  //one Y supercystal column per line
   }              //next supercrystal X-index
 
   //event trailer:
   os << "\n";
 }

◆ printTTFlags()

void EcalSelectiveReadoutProducer::printTTFlags	(	const EcalTrigPrimDigiCollection &	tp,
		std::ostream &	os
	)		const

private

Definition at line 246 of file EcalSelectiveReadoutProducer.cc.

References EcalTriggerPrimitiveDigi::id(), EcalTrigTowerDetId::ieta(), L1TowerCalibrationProducer_cfi::iEta, EcalTrigTowerDetId::iphi(), HLT_2022v12_cff::nEta, HLT_2022v12_cff::nPhi, EcalSelectiveReadout::nTriggerTowersInEta, EcalSelectiveReadout::nTriggerTowersInPhi, EcalTriggerPrimitiveDigi::size(), tccFlagMarker, cmsswSequenceInfo::tp, and EcalTriggerPrimitiveDigi::ttFlag().

                                                                                                        {
   const char tccFlagMarker[] = {'x', '.', 'S', '?', 'C', 'E', 'E', 'E', 'E'};
   const int nEta = EcalSelectiveReadout::nTriggerTowersInEta;
   const int nPhi = EcalSelectiveReadout::nTriggerTowersInPhi;
 
   //static bool firstCall=true;
   //  if(firstCall){
   //  firstCall=false;
   os << "# TCC flag map\n#\n"
         "# +-->Phi            "
      << tccFlagMarker[0 + 1]
      << ": 000 (low interest)\n"
         "# |                  "
      << tccFlagMarker[1 + 1]
      << ": 001 (mid interest)\n"
         "# |                  "
      << tccFlagMarker[2 + 1]
      << ": 010 (not valid)\n"
         "# V Eta              "
      << tccFlagMarker[3 + 1]
      << ": 011 (high interest)\n"
         "#                    "
      << tccFlagMarker[4 + 1]
      << ": 1xx forced readout (Hw error)\n"
         "#\n";
   //}
 
   vector<vector<int> > ttf(nEta, vector<int>(nPhi, -1));
   for (EcalTrigPrimDigiCollection::const_iterator it = tp.begin(); it != tp.end(); ++it) {
     const EcalTriggerPrimitiveDigi& trigPrim = *it;
     if (trigPrim.size() > 0) {
       int iEta = trigPrim.id().ieta();
       int iEta0 = iEta < 0 ? iEta + nEta / 2 : iEta + nEta / 2 - 1;
       int iPhi0 = trigPrim.id().iphi() - 1;
       ttf[iEta0][iPhi0] = trigPrim.ttFlag();
     }
   }
   for (int iEta = 0; iEta < nEta; ++iEta) {
     for (int iPhi = 0; iPhi < nPhi; ++iPhi) {
       os << tccFlagMarker[ttf[iEta][iPhi] + 1];
     }
     os << "\n";
   }
 }

◆ produce()

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

overridevirtual

Produces the EDM products

Parameters

CMS	event
eventSetup	event conditions

Implements edm::one::EDProducerBase.

Definition at line 89 of file EcalSelectiveReadoutProducer.cc.

References checkElecMap(), checkGeometry(), checkTriggerMap(), checkValidity(), dumpFlags_, ebSrFlagCollection_, ebSRPdigiCollection_, SimL1EmulatorDM_cff::eeDigis, eeSrFlagCollection_, eeSRPdigiCollection_, options_cfi::eventSetup, getEBDigis(), EcalSelectiveReadoutSuppressor::getEcalSelectiveReadout(), getEEDigis(), getTrigPrims(), hSr_token_, iEvent_, eostools::move(), EcalSelectiveReadout::print(), EcalSelectiveReadout::printHeader(), printSrFlags(), EcalSelectiveReadoutSuppressor::printTTFlags(), produceDigis_, edm::ESHandle< T >::product(), EcalSelectiveReadoutSuppressor::run(), EcalSelectiveReadoutSuppressor::setSettings(), settings_, suppressor_, suppressorSettingsSet_, trigPrimBypass_, trigPrimBypassMode_, pileupReCalc_HLTpaths::trunc, useCondDb_, and writeSrFlags_.

                                                                                            {
   if (useCondDb_) {
     //getting selective readout configuration:
     edm::ESHandle<EcalSRSettings> hSr = eventSetup.getHandle(hSr_token_);
 
     settings_ = hSr.product();
   }
 
   //gets the trigger primitives:
   EcalTrigPrimDigiCollection emptyTPColl;
   const EcalTrigPrimDigiCollection* trigPrims =
       (trigPrimBypass_ && trigPrimBypassMode_ == 0) ? &emptyTPColl : getTrigPrims(event);
 
   //gets the digis from the events:
   EBDigiCollection dummyEbDigiColl;
   EEDigiCollection dummyEeDigiColl;
 
   const EBDigiCollection* ebDigis = produceDigis_ ? getEBDigis(event) : &dummyEbDigiColl;
   const EEDigiCollection* eeDigis = produceDigis_ ? getEEDigis(event) : &dummyEeDigiColl;
 
   //runs the selective readout algorithm:
   unique_ptr<EBDigiCollection> selectedEBDigis;
   unique_ptr<EEDigiCollection> selectedEEDigis;
   unique_ptr<EBSrFlagCollection> ebSrFlags;
   unique_ptr<EESrFlagCollection> eeSrFlags;
 
   if (produceDigis_) {
     selectedEBDigis = std::make_unique<EBDigiCollection>();
     selectedEEDigis = std::make_unique<EEDigiCollection>();
   }
 
   if (writeSrFlags_) {
     ebSrFlags = std::make_unique<EBSrFlagCollection>();
     eeSrFlags = std::make_unique<EESrFlagCollection>();
   }
 
   if (not suppressorSettingsSet_) {
     //Check the validity of EcalSRSettings
     checkValidity(*settings_);
 
     suppressor_.setSettings(settings_);
     suppressorSettingsSet_ = true;
 
     // check that everything is up-to-date
     checkGeometry(eventSetup);
     checkTriggerMap(eventSetup);
     checkElecMap(eventSetup);
   }
 
   suppressor_.run(eventSetup,
                   *trigPrims,
                   *ebDigis,
                   *eeDigis,
                   selectedEBDigis.get(),
                   selectedEEDigis.get(),
                   ebSrFlags.get(),
                   eeSrFlags.get());
 
   if (dumpFlags_ >= iEvent_) {
     ofstream ttfFile("TTF.txt", (iEvent_ == 1 ? ios::trunc : ios::app));
     suppressor_.printTTFlags(ttfFile, iEvent_, iEvent_ == 1 ? true : false);
 
     ofstream srfFile("SRF.txt", (iEvent_ == 1 ? ios::trunc : ios::app));
     if (iEvent_ == 1) {
       suppressor_.getEcalSelectiveReadout()->printHeader(srfFile);
     }
     srfFile << "# Event " << iEvent_ << "\n";
     suppressor_.getEcalSelectiveReadout()->print(srfFile);
     srfFile << "\n";
 
     ofstream afFile("AF.txt", (iEvent_ == 1 ? ios::trunc : ios::app));
     printSrFlags(afFile, *ebSrFlags, *eeSrFlags, iEvent_, iEvent_ == 1 ? true : false);
   }
 
   ++iEvent_;  //event counter
 
   if (produceDigis_) {
     //puts the selected digis into the event:
     event.put(std::move(selectedEBDigis), ebSRPdigiCollection_);
     event.put(std::move(selectedEEDigis), eeSRPdigiCollection_);
   }
 
   //puts the SR flags into the event:
   if (writeSrFlags_) {
     event.put(std::move(ebSrFlags), ebSrFlagCollection_);
     event.put(std::move(eeSrFlags), eeSrFlagCollection_);
   }
 }