Inheritance diagram for EcalSelectiveReadoutProducer:

Public Member Functions
	EcalSelectiveReadoutProducer (const edm::ParameterSet &params, esrp::Cache const *)

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

	~EcalSelectiveReadoutProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< esrp::Cache > >
	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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &iDesc)

static void	globalEndJob (esrp::Cache *)

static std::unique_ptr< esrp::Cache >	initializeGlobalCache (const edm::ParameterSet &)

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

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_

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::stream::EDProducer< edm::GlobalCache< esrp::Cache > >
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 43 of file EcalSelectiveReadoutProducer.cc.

Constructor & Destructor Documentation

◆ EcalSelectiveReadoutProducer()

EcalSelectiveReadoutProducer::EcalSelectiveReadoutProducer	(	const edm::ParameterSet &	params,
		esrp::Cache const *
	)

explicit

Constructor

Parameters

params seletive readout parameters

Definition at line 195 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(), ProducerED_cfi::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) {
   //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");
   writeSrFlags_ = params.getUntrackedParameter<bool>("writeSrFlags");
   produceDigis_ = params.getUntrackedParameter<bool>("produceDigis");
   //   settings which can come from either condition database or python configuration file:
   useCondDb_ = params.getParameter<bool>("configFromCondDB");
   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_ = 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 295 of file EcalSelectiveReadoutProducer.cc.

295 {}

Member Function Documentation

◆ checkElecMap()

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

private

Definition at line 449 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 425 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 437 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 710 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 506 of file EcalSelectiveReadoutProducer.cc.

References EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, getBinOfMax(), EcalSelectiveReadoutSuppressor::getFIRTapCount(), mps_fire::i, settings_, and hltDeepSecondaryVertexTagInfosPFPuppi_cfi::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.";
     }
   }
 }

◆ fillDescriptions()

void EcalSelectiveReadoutProducer::fillDescriptions ( edm::ConfigurationDescriptions & iDesc )

static

Definition at line 253 of file EcalSelectiveReadoutProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                        {
   edm::ParameterSetDescription ps;
 
   ps.add<string>("digiProducer");
   ps.add<std::string>("EBdigiCollection");
   ps.add<std::string>("EEdigiCollection");
   ps.add<std::string>("EBSRPdigiCollection");
   ps.add<std::string>("EESRPdigiCollection");
   ps.add<std::string>("EBSrFlagCollection");
   ps.add<std::string>("EESrFlagCollection");
   ps.add<string>("trigPrimProducer");
   ps.add<string>("trigPrimCollection");
   ps.add<bool>("trigPrimBypass");     //also used by suppressor
   ps.add<int>("trigPrimBypassMode");  // also used by suppressor
   ps.addUntracked<int>("dumpFlags", 0);
   ps.addUntracked<bool>("writeSrFlags", false);
   ps.addUntracked<bool>("produceDigis", true);
   ps.add<bool>("configFromCondDB", false);
   ps.add<bool>("UseFullReadout");
 
   //from suppressor_
   ps.add<int>("defaultTtf");
   ps.add<bool>("trigPrimBypassWithPeakFinder");
   ps.add<double>("trigPrimBypassLTH");
   ps.add<double>("trigPrimBypassHTH");
 
   //from importParameterSet
   ps.addOptional<int>("deltaPhi");
   ps.addOptional<int>("deltaEta");
   ps.addOptional<int>("ecalDccZs1stSample");
   ps.addOptional<double>("ebDccAdcToGeV");
   ps.addOptional<double>("eeDccAdcToGeV");
   ps.addOptional<std::vector<double>>("dccNormalizedWeights");
   ps.addOptional<bool>("symetricZS");
   ps.addOptional<double>("srpBarrelLowInterestChannelZS");
   ps.addOptional<double>("srpEndcapLowInterestChannelZS");
   ps.addOptional<double>("srpBarrelHighInterestChannelZS");
   ps.addOptional<double>("srpEndcapHighInterestChannelZS");
 
   iDesc.addDefault(ps);
 }

◆ 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 553 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 393 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 406 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 419 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();
 }

◆ globalEndJob()

static void EcalSelectiveReadoutProducer::globalEndJob ( esrp::Cache * )

inlinestatic

Definition at line 76 of file EcalSelectiveReadoutProducer.cc.

76 {}

◆ initializeGlobalCache()

std::unique_ptr< esrp::Cache > EcalSelectiveReadoutProducer::initializeGlobalCache ( const edm::ParameterSet & )

static

Definition at line 191 of file EcalSelectiveReadoutProducer.cc.

                                                                                                    {
   return std::make_unique<esrp::Cache>();
 }

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

References cms::cuda::assert(), edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), RemoveAddSevLevel::flag, mps_fire::i, l1tPhase2CaloJetEmulator_cfi::iEta, iEvent, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, nEndcaps, srpFlagMarker, submitPVValidationJobs::t, and hcalRecHitTable_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 461 of file EcalSelectiveReadoutProducer.cc.

References EcalTriggerPrimitiveDigi::id(), l1tPhase2CaloJetEmulator_cfi::iEta, EcalTrigTowerDetId::ieta(), EcalTrigTowerDetId::iphi(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, HLT_2024v14_cff::nEta, HLT_2024v14_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
	)

override

Produces the EDM products

Parameters

CMS	event
eventSetup	event conditions

Definition at line 297 of file EcalSelectiveReadoutProducer.cc.

References utilities::cache(), checkElecMap(), checkGeometry(), checkTriggerMap(), checkValidity(), dumpFlags_, ebSrFlagCollection_, ebSRPdigiCollection_, SimL1EmulatorDM_cff::eeDigis, eeSrFlagCollection_, eeSRPdigiCollection_, options_cfi::eventSetup, getEBDigis(), EcalSelectiveReadoutSuppressor::getEcalSelectiveReadout(), getEEDigis(), getTrigPrims(), hSr_token_, 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_ > 0) {
     auto* cache = globalCache();
     std::lock_guard<std::mutex> guard(cache->mutex_);
     auto iEvent_ = cache->iEvent_;
     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);
       ++(cache->iEvent_);
     } else {
       //do not want to dump anymore, so can turn off
       dumpFlags_ = 0;
     }
   }
 
   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_);
   }
 }