Inheritance diagram for L1TGlobalPrescalesVetosESProducer:

Public Types
typedef std::shared_ptr< L1TGlobalPrescalesVetos >	ReturnType

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

virtual	~ESProducer ()(false)

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

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

virtual	~ESProxyFactoryProducer () noexcept(false)

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
template<typename T >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())

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

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

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

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

template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())

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

virtual void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList)
	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 52 of file L1TGlobalPrescalesVetosESProducer.cc.

Member Typedef Documentation

typedef std::shared_ptr<L1TGlobalPrescalesVetos> L1TGlobalPrescalesVetosESProducer::ReturnType

Definition at line 57 of file L1TGlobalPrescalesVetosESProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 86 of file L1TGlobalPrescalesVetosESProducer.cc.

References l1t::TrigSystem::addProcRole(), edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), l1t::TrigSystem::getSettings(), createfilelist::int, m_bx_mask_default, m_initialPrescaleFactorsAlgoTrig, m_initialTriggerAlgoBxMaskAlgoTrig, m_initialTriggerMaskAlgoTrig, m_initialTriggerMaskVetoAlgoTrig, m_numberPhysTriggers, m_verbosity, RecoTauDiscriminantConfiguration::mask, l1t::XmlConfigReader::readDOMFromString(), l1t::XmlConfigReader::readRootElement(), l1t::TrigSystem::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 );
     }
 
     XmlConfigReader xmlReader_prescale;
     l1t::TrigSystem ts_prescale;
     ts_prescale.addProcRole("uGtProcessor", "uGtProcessor");
 
     // 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();
 
     std::map<string, l1t::Setting> settings_prescale = ts_prescale.getSettings("uGtProcessor");
     std::vector<l1t::TableRow> tRow_prescale = settings_prescale["prescales"].getTableRows();
 
     unsigned int numColumns_prescale = 0;
     if( tRow_prescale.size()>0 ){
       std::vector<std::string> firstRow_prescale = tRow_prescale[0].getRow();
       numColumns_prescale = firstRow_prescale.size() - 1;
     }
     
     if (numColumns_prescale > 0) {
       // set all prescales to 1 (unprescaled) by default
       const int inputDefaultPrescale = 1;
       for (unsigned int iSet=0; iSet<numColumns_prescale; ++iSet)
     prescales.push_back(std::vector<int>(m_numberPhysTriggers, inputDefaultPrescale));
 
       for (auto & row : tRow_prescale) {
     unsigned int algoBit = row.getRowValue<unsigned int>("algo/prescale-index");
     for (unsigned int iSet=0; iSet<numColumns_prescale; ++iSet) {
       int prescale = row.getRowValue<unsigned int>(std::to_string(iSet));
       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 );
     }
 
     XmlConfigReader xmlReader_mask_finor;
     l1t::TrigSystem ts_mask_finor;
     ts_mask_finor.addProcRole("uGtProcessor", "uGtProcessor");
 
     // 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();
 
     std::map<string, l1t::Setting> settings_mask_finor = ts_mask_finor.getSettings("uGtProcessor");
 
     std::vector<l1t::TableRow> tRow_mask_finor = settings_mask_finor["finorMask"].getTableRows();
 
     for (auto & row : tRow_mask_finor) {
       unsigned int algoBit = row.getRowValue<unsigned int>("algo");
       unsigned int mask    = row.getRowValue<unsigned int>("mask");
       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 );
     }
 
     XmlConfigReader xmlReader_mask_veto;
     l1t::TrigSystem ts_mask_veto;
     ts_mask_veto.addProcRole("uGtProcessor", "uGtProcessor");
 
     // 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();
 
     std::map<string, l1t::Setting> settings_mask_veto = ts_mask_veto.getSettings("uGtProcessor");
     std::vector<l1t::TableRow> tRow_mask_veto = settings_mask_veto["vetoMask"].getTableRows();
 
     for(auto & row : tRow_mask_veto){
       unsigned int algoBit = row.getRowValue<unsigned int>("algo");
       unsigned int veto    = row.getRowValue<unsigned int>("veto");
       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 );
     }
 
     XmlConfigReader xmlReader_mask_algobx;
     l1t::TrigSystem ts_mask_algobx;
     ts_mask_algobx.addProcRole("uGtProcessor", "uGtProcessor");
 
     // 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();
 
     std::map<string, l1t::Setting> settings_mask_algobx = ts_mask_algobx.getSettings("uGtProcessor");
     std::vector<l1t::TableRow> tRow_mask_algobx = settings_mask_algobx["algorithmBxMask"].getTableRows();
 
     unsigned int numCol_mask_algobx = 0;
     if( tRow_mask_algobx.size()>0 ){
       std::vector<std::string> firstRow_mask_algobx = tRow_mask_algobx[0].getRow();
       numCol_mask_algobx = firstRow_mask_algobx.size();
     }
     
     int NumAlgoBitsInMask = numCol_mask_algobx - 1;
     if( NumAlgoBitsInMask > 0 ){
       for(auto & row : tRow_mask_algobx){
     int bx = row.getRowValue<unsigned int>("bx/algo");
     std::vector<int> maskedBits;
     for( int iBit=0; iBit<NumAlgoBitsInMask; iBit++ ){
       unsigned int maskBit = row.getRowValue<unsigned int>(std::to_string(iBit));
       if( int(maskBit)!=m_bx_mask_default ) maskedBits.push_back(iBit);
     }
     if( maskedBits.size()>0 ) triggerAlgoBxMaskAlgoTrig[bx] = maskedBits;
       }
     }
 
   }
   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 351 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 366 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.size()==0 ) 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;
     }
   }
 
   // write the condition format to the event setup via the helper:
   using namespace edm::es;
   std::shared_ptr<L1TGlobalPrescalesVetos> pMenu(data_.getWriteInstance());
   return pMenu;
 }