Inheritance diagram for L1TGlobalPrescalesVetosESProducer:

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

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

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

ReturnType	produce (const L1TGlobalPrescalesVetosRcd &)

	~L1TGlobalPrescalesVetosESProducer () override

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

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer ()(false) override

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

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Private Attributes
PrescalesVetosHelper	data_

int	m_bx_mask_default

std::vector< std::vector< int > >	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::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::ESProducer
	ESProducer (const ESProducer &)=delete

ESProducer const &	operator= (const ESProducer &)=delete

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 TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

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

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

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Detailed Description

Description: Produces L1T Trigger Menu Condition Format

Implementation: Dummy producer for L1T uGT Trigger Menu

Definition at line 51 of file L1TGlobalPrescalesVetosESProducer.cc.

Member Typedef Documentation

using L1TGlobalPrescalesVetosESProducer::ReturnType = std::unique_ptr<L1TGlobalPrescalesVetos>

Definition at line 56 of file L1TGlobalPrescalesVetosESProducer.cc.

Constructor & Destructor Documentation

L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer ( 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 85 of file L1TGlobalPrescalesVetosESProducer.cc.

References l1t::TriggerSystem::addProcessor(), patPFMETCorrections_cff::algo, 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, RecoTauDiscriminantConfiguration::mask, l1t::XmlConfigParser::readDOMFromString(), l1t::XmlConfigParser::readRootElement(), l1t::TriggerSystem::setConfigured(), edm::ESProducer::setWhatProduced(), AlCaHLTBitMon_QueryRunRegistry::string, tmp, and TriggerAnalyzer::veto.

                                                                                                 :
   data_(new L1TGlobalPrescalesVetos())
 {
   //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<int> > 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("L1TGlobalPrescalesVetosESProducer")
       << "\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<int>(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<int>());
         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<unsigned int> prescalesForSet = settings_prescale.at("prescales").getTableColumn<unsigned int>(col.first.c_str());
         for(unsigned int row=0; row<prescalesForSet.size(); row++){
           unsigned int 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("L1TGlobalPrescalesVetosESProducer")
       << "\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("L1TGlobalPrescalesVetosESProducer")
       << "\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("L1TGlobalPrescalesVetosESProducer")
       << "\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;
 
 }

L1TGlobalPrescalesVetosESProducer::~L1TGlobalPrescalesVetosESProducer ( )

override

Definition at line 348 of file L1TGlobalPrescalesVetosESProducer.cc.

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

Member Function Documentation

L1TGlobalPrescalesVetosESProducer::ReturnType L1TGlobalPrescalesVetosESProducer::produce ( const L1TGlobalPrescalesVetosRcd & iRecord )

Definition at line 363 of file L1TGlobalPrescalesVetosESProducer.cc.

References data_, DEFINE_FWK_EVENTSETUP_MODULE, l1t::PrescalesVetosHelper::getWriteInstance(), LogDebug, m_bx_mask_default, m_initialPrescaleFactorsAlgoTrig, m_initialTriggerAlgoBxMaskAlgoTrig, m_initialTriggerMaskVetoAlgoTrig, m_verbosity, l1t::PrescalesVetosHelper::setBxMaskDefault(), l1t::PrescalesVetosHelper::setPrescaleFactorTable(), l1t::PrescalesVetosHelper::setTriggerAlgoBxMask(), and l1t::PrescalesVetosHelper::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<L1TGlobalPrescalesVetos>(*data_.getWriteInstance());
 }