Inheritance diagram for L1TGlobalPrescalesVetosESProducer:

Public Types
typedef boost::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 ()

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

virtual	~ESProducer ()

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

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

virtual	~ESProxyFactoryProducer ()

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

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::auto_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const eventsetup::EventSetupRecordKey &iRecord, std::auto_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 53 of file L1TGlobalPrescalesVetosESProducer.cc.

Member Typedef Documentation

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

Definition at line 58 of file L1TGlobalPrescalesVetosESProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 87 of file L1TGlobalPrescalesVetosESProducer.cc.

References l1t::TrigSystem::addProcRole(), cuy::col, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), l1t::TrigSystem::getSettings(), LogTrace, m_bx_mask_default, m_initialPrescaleFactorsAlgoTrig, m_initialTriggerAlgoBxMaskAlgoTrig, m_initialTriggerMaskAlgoTrig, m_initialTriggerMaskVetoAlgoTrig, m_numberPhysTriggers, m_verbosity, makeHLTPrescaleTable::prescales, 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( !input_prescale ){
     LogTrace("L1TGlobalPrescalesVetosESProducer")
       << "\nCould not find file: " << m_prescaleFile
       << "\nFilling the prescale vectors with prescale 1"
       << std::endl;
 
     for( int col=0; col < 1; col++ ){
       prescales.push_back(std::vector<int>());
       for( unsigned int iBit = 0; iBit < m_numberPhysTriggers; ++iBit ){
     int inputDefaultPrescale = 1;
     prescales[col].push_back(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();
     }
     
     int NumPrescaleSets = numColumns_prescale - 1;
     int NumAlgos_prescale = tRow_prescale.size();
 
     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 = 1;
       prescales[iSet].push_back(inputDefaultPrescale);
     }
       }
 
       for( auto it=tRow_prescale.begin(); it!=tRow_prescale.end(); it++ ){
     unsigned int algoBit = it->getRowValue<unsigned int>("algo/prescale-index");
     for( int iSet=0; iSet<NumPrescaleSets; iSet++ ){
       int prescale = it->getRowValue<unsigned int>(std::to_string(iSet));
       prescales[iSet][algoBit] = prescale;
     }
       }
     }
 
   }
   input_prescale.close();
 
 
 
 
 
   // finor mask
   // Setting mask to default 1 (unmask)
   for( unsigned int iAlg=0; iAlg < m_numberPhysTriggers; iAlg++ )
     triggerMasks.push_back(1);
 
   
   std::ifstream input_mask_finor;
   input_mask_finor.open( m_finormaskFile );
   if( !input_mask_finor ){
     LogTrace("L1TGlobalPrescalesVetosESProducer")
       << "\nCould not find file: " << m_finormaskFile
       << "\nFilling the finor mask vectors with 1 (unmask)"
       << std::endl;
   }
   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 it=tRow_mask_finor.begin(); it!=tRow_mask_finor.end(); it++ ){
       unsigned int algoBit = it->getRowValue<unsigned int>("algo");
       unsigned int mask = it->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( !input_mask_veto ){
     LogTrace("L1TGlobalPrescalesVetosESProducer")
       << "\nCould not find file: " << m_vetomaskFile
       << "\nFilling the veto mask vectors with 1 (unmask)"
       << std::endl;
   }
   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 it=tRow_mask_veto.begin(); it!=tRow_mask_veto.end(); it++ ){
       unsigned int algoBit = it->getRowValue<unsigned int>("algo");
       unsigned int veto = it->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( !input_mask_algobx ){
     LogTrace("L1TGlobalPrescalesVetosESProducer")
       << "\nCould not find file: " << m_algobxmaskFile
       << "\nNot filling map"
       << std::endl;
   }
   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 it=tRow_mask_algobx.begin(); it!=tRow_mask_algobx.end(); it++ ){
     int bx = it->getRowValue<unsigned int>("bx/algo");
     std::vector<int> maskedBits;
     for( int iBit=0; iBit<NumAlgoBitsInMask; iBit++ ){
       unsigned int maskBit = it->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( unsigned int iSet=0; iSet < prescales.size(); iSet++ ){
     for( unsigned int iBit=0; iBit < prescales[iSet].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 {
     prescales[iSet][iBit] *= triggerMasks[iBit];
       }
     }
   }
 
   m_initialPrescaleFactorsAlgoTrig = prescales;
   m_initialTriggerMaskAlgoTrig = triggerMasks;
   m_initialTriggerMaskVetoAlgoTrig = triggerVetoMasks;
   m_initialTriggerAlgoBxMaskAlgoTrig = triggerAlgoBxMaskAlgoTrig;
 
 }

L1TGlobalPrescalesVetosESProducer::~L1TGlobalPrescalesVetosESProducer ( )

Definition at line 368 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 383 of file L1TGlobalPrescalesVetosESProducer.cc.

References data_, 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( unsigned int iAlg=0; iAlg < masked.size(); iAlg++ ){
     LogDebug("L1TGlobal") << " " << masked[iAlg];
       }
       LogDebug("L1TGlobal") << " " << std::endl;
     }
   }
 
   // write the condition format to the event setup via the helper:
   using namespace edm::es;
   boost::shared_ptr<L1TGlobalPrescalesVetos> pMenu = boost::shared_ptr< L1TGlobalPrescalesVetos >(data_.getWriteInstance());
   return pMenu;
 }