Inheritance diagram for L1TGlobalPrescalesVetosFractESProducer:

Public Types
using	ReturnType = std::unique_ptr< L1TGlobalPrescalesVetosFract >

Public Member Functions
	L1TGlobalPrescalesVetosFractESProducer (const edm::ParameterSet &)

ReturnType	produce (const L1TGlobalPrescalesVetosFractRcd &)

	~L1TGlobalPrescalesVetosFractESProducer () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

Private Attributes
PrescalesVetosFractHelper	data_

int	m_bx_mask_default

std::vector< std::vector< double > >	m_initialPrescaleFactorsAlgoTrig

std::map< int, std::vector< int > >	m_initialTriggerAlgoBxMaskAlgoTrig

std::vector< unsigned int >	m_initialTriggerMaskAlgoTrig

std::vector< int >	m_initialTriggerMaskVetoAlgoTrig

unsigned int	m_numberPhysTriggers

int	m_verbosity

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Description: Produces L1T Trigger Menu Condition Format

Implementation: Dummy producer for L1T uGT Trigger Menu

Definition at line 49 of file L1TGlobalPrescalesVetosFractESProducer.cc.

Member Typedef Documentation

◆ ReturnType

using L1TGlobalPrescalesVetosFractESProducer::ReturnType = std::unique_ptr<L1TGlobalPrescalesVetosFract>

Definition at line 54 of file L1TGlobalPrescalesVetosFractESProducer.cc.

Constructor & Destructor Documentation

◆ L1TGlobalPrescalesVetosFractESProducer()

L1TGlobalPrescalesVetosFractESProducer::L1TGlobalPrescalesVetosFractESProducer ( const edm::ParameterSet & conf )

there may be "missing" rows/bits in the xml description meaning that triggers are not unused, so go for max

Definition at line 82 of file L1TGlobalPrescalesVetosFractESProducer.cc.

References l1t::TriggerSystem::addProcessor(), nano_mu_digi_cff::bx, cuy::col, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), l1t::TriggerSystem::getParameters(), createfilelist::int, m_bx_mask_default, m_initialPrescaleFactorsAlgoTrig, m_initialTriggerAlgoBxMaskAlgoTrig, m_initialTriggerMaskAlgoTrig, m_initialTriggerMaskVetoAlgoTrig, m_numberPhysTriggers, m_verbosity, gpuClustering::pixelStatus::mask, hltrates_dqm_sourceclient-live_cfg::prescales, push_back(), l1t::XmlConfigParser::readDOMFromString(), l1t::XmlConfigParser::readRootElement(), l1t::TriggerSystem::setConfigured(), edm::ESProducer::setWhatProduced(), AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, to_string(), and PbPb_ZMuSkimMuonDPG_cff::veto.

     : data_(new L1TGlobalPrescalesVetosFract()) {
   //the following line is needed to tell the framework what
   // data is being produced
   setWhatProduced(this);
   //setWhatProduced(this, conf.getParameter<std::string>("label"));
 
   m_numberPhysTriggers = 512;
 
   // directory in /data/Luminosity for the trigger menu
   std::string menuDir = conf.getParameter<std::string>("TriggerMenuLuminosity");
   //std::string menuDir = "startup";
 
   m_verbosity = conf.getParameter<int>("Verbosity");
   m_bx_mask_default = conf.getParameter<int>("AlgoBxMaskDefault");
 
   // XML files
   std::string prescalesFileName = conf.getParameter<std::string>("PrescaleXMLFile");
   std::string algobxmaskFileName = conf.getParameter<std::string>("AlgoBxMaskXMLFile");
   std::string finormaskFileName = conf.getParameter<std::string>("FinOrMaskXMLFile");
   std::string vetomaskFileName = conf.getParameter<std::string>("VetoMaskXMLFile");
 
   // Full path
   edm::FileInPath f1_prescale("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + prescalesFileName);
   std::string m_prescaleFile = f1_prescale.fullPath();
 
   edm::FileInPath f1_mask_algobx("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + algobxmaskFileName);
   std::string m_algobxmaskFile = f1_mask_algobx.fullPath();
 
   edm::FileInPath f1_mask_finor("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + finormaskFileName);
   std::string m_finormaskFile = f1_mask_finor.fullPath();
 
   edm::FileInPath f1_mask_veto("L1Trigger/L1TGlobal/data/Luminosity/" + menuDir + "/" + vetomaskFileName);
   std::string m_vetomaskFile = f1_mask_veto.fullPath();
 
   // XML payloads
   std::string xmlPayload_prescale;
   std::string xmlPayload_mask_algobx;
   std::string xmlPayload_mask_finor;
   std::string xmlPayload_mask_veto;
 
   std::vector<std::vector<double> > prescales;
   std::vector<unsigned int> triggerMasks;
   std::vector<int> triggerVetoMasks;
   std::map<int, std::vector<int> > triggerAlgoBxMaskAlgoTrig;
 
   // Prescales
   std::ifstream input_prescale;
   input_prescale.open(m_prescaleFile);
   if (not m_prescaleFile.empty() and not input_prescale) {
     edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
         << "\nCould not find prescale file: " << m_prescaleFile
         << "\nDeafulting to a single prescale column, with all prescales set to 1 (unprescaled)";
 
     const int inputDefaultPrescale = 1;
     // by default, fill a single prescale column
     prescales.push_back(std::vector<double>(m_numberPhysTriggers, inputDefaultPrescale));
   } else {
     while (!input_prescale.eof()) {
       string tmp;
       getline(input_prescale, tmp, '\n');
       xmlPayload_prescale.append(tmp);
     }
 
     l1t::XmlConfigParser xmlReader_prescale;
     l1t::TriggerSystem ts_prescale;
     ts_prescale.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
 
     // run the parser
     xmlReader_prescale.readDOMFromString(xmlPayload_prescale);  // initialize it
     xmlReader_prescale.readRootElement(ts_prescale, "uGT");     // extract all of the relevant context
     ts_prescale.setConfigured();
 
     const std::map<std::string, l1t::Parameter>& settings_prescale = ts_prescale.getParameters("uGtProcessor");
     std::map<std::string, unsigned int> prescaleColumns = settings_prescale.at("prescales").getColumnIndices();
 
     unsigned int numColumns_prescale = prescaleColumns.size();
 
     int NumPrescaleSets = numColumns_prescale - 1;
     std::vector<unsigned int> algoBits =
         settings_prescale.at("prescales").getTableColumn<unsigned int>("algo/prescale-index");
     int NumAlgos_prescale = *std::max_element(algoBits.begin(), algoBits.end()) + 1;
 
     if (NumPrescaleSets > 0) {
       // Fill default prescale set
       for (int iSet = 0; iSet < NumPrescaleSets; iSet++) {
         prescales.push_back(std::vector<double>());
         for (int iBit = 0; iBit < NumAlgos_prescale; ++iBit) {
           int inputDefaultPrescale = 0;  // only prescales that are set in the block below are used
           prescales[iSet].push_back(inputDefaultPrescale);
         }
       }
 
       for (auto& col : prescaleColumns) {
         if (col.second < 1)
           continue;  // we don't care for the algorithms' indicies in 0th column
         int iSet = col.second - 1;
         std::vector<double> prescalesForSet =
             settings_prescale.at("prescales").getTableColumn<double>(col.first.c_str());
         for (unsigned int row = 0; row < prescalesForSet.size(); row++) {
           double prescale = prescalesForSet[row];
           unsigned int algoBit = algoBits[row];
           prescales[iSet][algoBit] = prescale;
         }
       }
     }
   }
   input_prescale.close();
 
 
   // finor mask
   // set all masks to 1 (unmasked) by default
   triggerMasks.insert(triggerMasks.end(), m_numberPhysTriggers, 1);
 
   std::ifstream input_mask_finor;
   input_mask_finor.open(m_finormaskFile);
   if (not m_finormaskFile.empty() and not input_mask_finor) {
     edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
         << "\nCould not find finor mask file: " << m_finormaskFile
         << "\nDeafulting the finor mask for all triggers to 1 (unmasked)";
   } else {
     while (!input_mask_finor.eof()) {
       string tmp;
       getline(input_mask_finor, tmp, '\n');
       xmlPayload_mask_finor.append(tmp);
     }
 
     l1t::XmlConfigParser xmlReader_mask_finor;
     l1t::TriggerSystem ts_mask_finor;
     ts_mask_finor.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
 
     // run the parser
     xmlReader_mask_finor.readDOMFromString(xmlPayload_mask_finor);  // initialize it
     xmlReader_mask_finor.readRootElement(ts_mask_finor, "uGT");     // extract all of the relevant context
     ts_mask_finor.setConfigured();
 
     const std::map<std::string, l1t::Parameter>& settings_mask_finor = ts_mask_finor.getParameters("uGtProcessor");
 
     std::vector<unsigned int> algo_mask_finor =
         settings_mask_finor.at("finorMask").getTableColumn<unsigned int>("algo");
     std::vector<unsigned int> mask_mask_finor =
         settings_mask_finor.at("finorMask").getTableColumn<unsigned int>("mask");
 
     for (unsigned int row = 0; row < algo_mask_finor.size(); row++) {
       unsigned int algoBit = algo_mask_finor[row];
       unsigned int mask = mask_mask_finor[row];
       if (algoBit < m_numberPhysTriggers)
         triggerMasks[algoBit] = mask;
     }
   }
   input_mask_finor.close();
 
 
   // veto mask
   // Setting veto mask to default 0 (no veto)
   for (unsigned int iAlg = 0; iAlg < m_numberPhysTriggers; iAlg++)
     triggerVetoMasks.push_back(0);
 
   std::ifstream input_mask_veto;
   input_mask_veto.open(m_vetomaskFile);
   if (not m_vetomaskFile.empty() and not input_mask_veto) {
     edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
         << "\nCould not find veto mask file: " << m_vetomaskFile
         << "\nDeafulting the veto mask for all triggers to 1 (unmasked)";
   } else {
     while (!input_mask_veto.eof()) {
       string tmp;
       getline(input_mask_veto, tmp, '\n');
       xmlPayload_mask_veto.append(tmp);
     }
 
     l1t::XmlConfigParser xmlReader_mask_veto;
     l1t::TriggerSystem ts_mask_veto;
     ts_mask_veto.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
 
     // run the parser
     xmlReader_mask_veto.readDOMFromString(xmlPayload_mask_veto);  // initialize it
     xmlReader_mask_veto.readRootElement(ts_mask_veto, "uGT");     // extract all of the relevant context
     ts_mask_veto.setConfigured();
 
     const std::map<std::string, l1t::Parameter>& settings_mask_veto = ts_mask_veto.getParameters("uGtProcessor");
     std::vector<unsigned int> algo_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<unsigned int>("algo");
     std::vector<unsigned int> veto_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<unsigned int>("veto");
 
     for (unsigned int row = 0; row < algo_mask_veto.size(); row++) {
       unsigned int algoBit = algo_mask_veto[row];
       unsigned int veto = veto_mask_veto[row];
       if (algoBit < m_numberPhysTriggers)
         triggerVetoMasks[algoBit] = int(veto);
     }
   }
   input_mask_veto.close();
 
 
   // Algo bx mask
   std::ifstream input_mask_algobx;
   input_mask_algobx.open(m_algobxmaskFile);
   if (not m_algobxmaskFile.empty() and not input_mask_algobx) {
     edm::LogError("L1TGlobalPrescalesVetosFractESProducer")
         << "\nCould not find bx mask file: " << m_algobxmaskFile << "\nNot filling the bx mask map";
   } else {
     while (!input_mask_algobx.eof()) {
       string tmp;
       getline(input_mask_algobx, tmp, '\n');
       xmlPayload_mask_algobx.append(tmp);
     }
 
     l1t::XmlConfigParser xmlReader_mask_algobx;
     l1t::TriggerSystem ts_mask_algobx;
     ts_mask_algobx.addProcessor("uGtProcessor", "uGtProcessor", "-1", "-1");
 
     // run the parser
     xmlReader_mask_algobx.readDOMFromString(xmlPayload_mask_algobx);  // initialize it
     xmlReader_mask_algobx.readRootElement(ts_mask_algobx, "uGT");     // extract all of the relevant context
     ts_mask_algobx.setConfigured();
 
     const std::map<std::string, l1t::Parameter>& settings_mask_algobx = ts_mask_algobx.getParameters("uGtProcessor");
     std::map<std::string, unsigned int> mask_algobx_columns =
         settings_mask_algobx.at("algorithmBxMask").getColumnIndices();
     std::vector<unsigned int> bunches =
         settings_mask_algobx.at("algorithmBxMask").getTableColumn<unsigned int>("bx/algo");
 
     unsigned int numCol_mask_algobx = mask_algobx_columns.size();
 
     int NumAlgoBitsInMask = numCol_mask_algobx - 1;
     for (int iBit = 0; iBit < NumAlgoBitsInMask; iBit++) {
       std::vector<unsigned int> algo =
           settings_mask_algobx.at("algorithmBxMask").getTableColumn<unsigned int>(std::to_string(iBit).c_str());
       for (unsigned int bx = 0; bx < bunches.size(); bx++) {
         if (algo[bx] != unsigned(m_bx_mask_default))
           triggerAlgoBxMaskAlgoTrig[bunches[bx]].push_back(iBit);
       }
     }
   }
   input_mask_algobx.close();
 
   // Set prescales to zero if masked
   for (auto& prescale : prescales) {
     for (unsigned int iBit = 0; iBit < prescale.size(); iBit++) {
       // Add protection in case prescale table larger than trigger mask size
       if (iBit >= triggerMasks.size()) {
         edm::LogWarning("L1TGlobal") << "\nWarning: algoBit in prescale table >= triggerMasks.size() "
                                      << "\nWarning: no information on masking bit or not, setting as unmasked "
                                      << std::endl;
       } else {
         prescale[iBit] *= triggerMasks[iBit];
       }
     }
   }
 
   m_initialPrescaleFactorsAlgoTrig = prescales;
   m_initialTriggerMaskAlgoTrig = triggerMasks;
   m_initialTriggerMaskVetoAlgoTrig = triggerVetoMasks;
   m_initialTriggerAlgoBxMaskAlgoTrig = triggerAlgoBxMaskAlgoTrig;
 }

◆ ~L1TGlobalPrescalesVetosFractESProducer()

L1TGlobalPrescalesVetosFractESProducer::~L1TGlobalPrescalesVetosFractESProducer ( )

override

Definition at line 342 of file L1TGlobalPrescalesVetosFractESProducer.cc.

                                                                                 {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ produce()

L1TGlobalPrescalesVetosFractESProducer::ReturnType L1TGlobalPrescalesVetosFractESProducer::produce ( const L1TGlobalPrescalesVetosFractRcd & iRecord )

Definition at line 352 of file L1TGlobalPrescalesVetosFractESProducer.cc.

References data_, l1t::PrescalesVetosFractHelper::getWriteInstance(), LogDebug, m_bx_mask_default, m_initialPrescaleFactorsAlgoTrig, m_initialTriggerAlgoBxMaskAlgoTrig, m_initialTriggerMaskVetoAlgoTrig, m_verbosity, l1t::PrescalesVetosFractHelper::setBxMaskDefault(), l1t::PrescalesVetosFractHelper::setPrescaleFactorTable(), l1t::PrescalesVetosFractHelper::setTriggerAlgoBxMask(), and l1t::PrescalesVetosFractHelper::setTriggerMaskVeto().

                                                     {
   // configure the helper class parameters via its set funtions, e.g.:
   data_.setBxMaskDefault(m_bx_mask_default);
   data_.setPrescaleFactorTable(m_initialPrescaleFactorsAlgoTrig);
   data_.setTriggerMaskVeto(m_initialTriggerMaskVetoAlgoTrig);
   data_.setTriggerAlgoBxMask(m_initialTriggerAlgoBxMaskAlgoTrig);
 
   if (m_verbosity) {
     LogDebug("L1TGlobal") << " ====> Prescales table <=== " << std::endl;
     for (unsigned int ix = 0; ix < m_initialPrescaleFactorsAlgoTrig.size(); ix++) {
       LogDebug("L1TGlobal") << " Prescale set = " << ix << std::endl;
       for (unsigned int iy = 0; iy < m_initialPrescaleFactorsAlgoTrig[ix].size(); iy++) {
         LogDebug("L1TGlobal") << "\t Algo " << iy << ": " << m_initialPrescaleFactorsAlgoTrig[ix][iy] << std::endl;
       }
     }
 
     LogDebug("L1TGlobal") << " ====> Trigger mask veto <=== " << std::endl;
     for (unsigned int ix = 0; ix < m_initialTriggerMaskVetoAlgoTrig.size(); ix++) {
       LogDebug("L1TGlobal") << "\t Algo " << ix << ": " << m_initialTriggerMaskVetoAlgoTrig[ix] << std::endl;
     }
 
     LogDebug("L1TGlobal") << " ====> Algo bx mask <=== " << std::endl;
     if (m_initialTriggerAlgoBxMaskAlgoTrig.empty())
       LogDebug("L1TGlobal") << "\t(empty map)" << std::endl;
     for (auto& it : m_initialTriggerAlgoBxMaskAlgoTrig) {
       LogDebug("L1TGlobal") << " bx = " << it.first << " : iAlg =";
       std::vector<int> masked = it.second;
       for (int& iAlg : masked) {
         LogDebug("L1TGlobal") << " " << iAlg;
       }
       LogDebug("L1TGlobal") << " " << std::endl;
     }
   }
 
   // Return copy so that we don't give away our owned pointer to framework
   return std::make_unique<L1TGlobalPrescalesVetosFract>(*data_.getWriteInstance());
 }