#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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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_

std::string	eeSrFlagCollection_

std::string	eeSRPdigiCollection_

bool	firstCallEB_

bool	firstCallEE_

int	iEvent_

edm::ParameterSet	params_

bool	produceDigis_

const EcalSRSettings *	settings_

std::unique_ptr< EcalSRSettings >	settingsFromFile_

std::unique_ptr< EcalSelectiveReadoutSuppressor >	suppressor_

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<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

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

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

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)

template<Transition B>
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 (std::string instanceName)

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

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 14 of file EcalSelectiveReadoutProducer.h.

Constructor & Destructor Documentation

◆ EcalSelectiveReadoutProducer()

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

explicit

Constructor

Parameters

params seletive readout parameters

Definition at line 20 of file EcalSelectiveReadoutProducer.cc.

     : params_(params), 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_ = unique_ptr<EcalSRSettings>(new 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_));
   ;
 }

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

◆ ~EcalSelectiveReadoutProducer()

EcalSelectiveReadoutProducer::~EcalSelectiveReadoutProducer ( )

override

Destructor

Definition at line 80 of file EcalSelectiveReadoutProducer.cc.

80 {}

Member Function Documentation

◆ checkElecMap()

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

private

Definition at line 234 of file EcalSelectiveReadoutProducer.cc.

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

References options_cfi::eventSetup, get, suppressor_, and theElecMap.

Referenced by produce().

◆ 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 208 of file EcalSelectiveReadoutProducer.cc.

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

References options_cfi::eventSetup, get, suppressor_, and theGeometry.

Referenced by produce().

◆ checkTriggerMap()

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

private

Definition at line 221 of file EcalSelectiveReadoutProducer.cc.

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

References options_cfi::eventSetup, get, suppressor_, and theTriggerTowerMap.

Referenced by produce().

◆ 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 496 of file EcalSelectiveReadoutProducer.cc.

                                                                                {
   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() << ").";
   }
 }

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

Referenced by produce().

◆ 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 292 of file EcalSelectiveReadoutProducer.cc.

                                                                                                          {
   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.";
     }
   }
 }

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

Referenced by getEBDigis(), and getEEDigis().

◆ 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 339 of file EcalSelectiveReadoutProducer.cc.

                                                                     {
   bool rc;
   const edm::Provenance p = evt.getProvenance(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;
 }

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

Referenced by checkWeights().

◆ getEBDigis()

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

private

Definition at line 176 of file EcalSelectiveReadoutProducer.cc.

                                                                                 {
   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;
 }

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

Referenced by produce().

◆ getEEDigis()

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

private

Definition at line 189 of file EcalSelectiveReadoutProducer.cc.

                                                                                 {
   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;
 }

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

Referenced by produce().

◆ getTrigPrims()

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

private

Definition at line 202 of file EcalSelectiveReadoutProducer.cc.

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

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

Referenced by produce().

◆ 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 356 of file EcalSelectiveReadoutProducer.cc.

                                                                  {
   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";
 }

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

Referenced by produce().

◆ printTTFlags()

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

private

Definition at line 247 of file EcalSelectiveReadoutProducer.cc.

                                                                                                        {
   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";
   }
 }

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

◆ 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 82 of file EcalSelectiveReadoutProducer.cc.

                                                                                            {
   if (useCondDb_) {
     //getting selective readout configuration:
     edm::ESHandle<EcalSRSettings> hSr;
  
     if (useFullReadout_) {
       eventSetup.get<EcalSRSettingsRcd>().get("fullReadout", hSr);
     } else {
       eventSetup.get<EcalSRSettingsRcd>().get(hSr);
     }
     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 = unique_ptr<EBDigiCollection>(new EBDigiCollection);
     selectedEEDigis = unique_ptr<EEDigiCollection>(new EEDigiCollection);
   }
  
   if (writeSrFlags_) {
     ebSrFlags = unique_ptr<EBSrFlagCollection>(new EBSrFlagCollection);
     eeSrFlags = unique_ptr<EESrFlagCollection>(new EESrFlagCollection);
   }
  
   if (suppressor_.get() == nullptr) {
     //Check the validity of EcalSRSettings
     checkValidity(*settings_);
  
     //instantiates the selective readout algorithm:
     suppressor_ = unique_ptr<EcalSelectiveReadoutSuppressor>(new EcalSelectiveReadoutSuppressor(params_, settings_));
  
     // 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_);
   }
 }