#include <TriggerSystem.h>

Public Member Functions
void	addDaq (const char daq, const char role, const char *crate)

void	addMask (const char id, const char procOrRoleOrDaq)

void	addParameter (const char id, const char procOrRole, const char type, const char value, const char *delim=",")

void	addProcessor (const char processor, const char role, const char crate, const char slot)

void	addTable (const char id, const char procOrRole, const char columns, const char types, const std::vector< std::string > &rows, const char *delim)

void	configureSystemFromFiles (const char hwCfgFile, const char topCfgFile, const char *key)

void	disableProcOrRoleOrDaq (const char *procOrRoleOrDaq)

const std::map< std::string, Mask > &	getMasks (const char *processor) const

const std::map< std::string, Parameter > &	getParameters (const char *processor) const

const std::map< std::string, std::string > &	getProcToRoleAssignment (void) const noexcept

const std::map< std::string, std::set< std::string > > &	getRoleToProcsAssignment (void) const noexcept

bool	isMasked (const char proccessor, const char id) const

bool	isProcEnabled (const char *proccessor) const

void	setConfigured (bool state=true) noexcept

void	setLogStream (std::ostream *s) const noexcept

void	setSystemId (const char *id) noexcept

std::string	systemId (void) const noexcept

	TriggerSystem (void)

	~TriggerSystem (void)

Private Attributes
std::map< std::string, std::set< std::string > >	crateForProcs

std::map< std::string, std::string >	daqttcToCrate

std::map< std::string, std::string >	daqttcToRole

bool	isConfigured

std::ostream *	logs

std::map< std::string, bool >	procEnabled

std::map< std::string, std::map< std::string, Mask > >	procMasks

std::map< std::string, std::map< std::string, Parameter > >	procParameters

std::map< std::string, std::string >	procToRole

std::map< std::string, std::string >	procToSlot

std::map< std::string, std::set< std::string > >	roleForDaqttcs

std::map< std::string, std::set< std::string > >	roleForProcs

std::string	sysId

Detailed Description

Definition at line 14 of file TriggerSystem.h.

Constructor & Destructor Documentation

l1t::TriggerSystem::TriggerSystem ( void )

inline

Definition at line 76 of file TriggerSystem.h.

                        {
         isConfigured = false;
         logs = 0;
     }

l1t::TriggerSystem::~TriggerSystem ( void )

inline

Definition at line 81 of file TriggerSystem.h.

81 {}

Member Function Documentation

void l1t::TriggerSystem::addDaq	(	const char *	daq,
		const char *	role,
		const char *	crate
	)

Definition at line 43 of file TriggerSystem.cc.

Referenced by l1t::XmlConfigParser::readHwDescription().

                                                                                {
     auto d2r = daqttcToRole.find(daq);
     if( d2r != daqttcToRole.end() && d2r->second != role )
         throw runtime_error("DAQttc: '" + string(daq) + "' already exists but with different role: " + d2r->second);
     else {
         daqttcToRole [daq] = role;
         daqttcToCrate[daq] = crate;
         roleForDaqttcs[role].insert(daq);
     }
 }

void l1t::TriggerSystem::addMask	(	const char *	id,
		const char *	procOrRoleOrDaq
	)

Definition at line 179 of file TriggerSystem.cc.

References hcalTTPDigis_cfi::id, RecoTauDiscriminantConfiguration::mask, and proc.

Referenced by l1t::XmlConfigParser::readContext().

                                                                        {
 
     // first try to locate a processor with name matching the procOrRoleOrDaq argument
     auto processor = procMasks.find(procOrRoleOrDaq);
     if( processor != procMasks.end() ){
         // processor found -> apply settings to this processor
         auto mask = processor->second.find(id);
         if( mask != processor->second.end() ){
             // setting with this id already exists -> always take the latest value
             //if( logs)
             //   *logs << "Warning: overriding already existing " << id
             //         << " = (" << setting->second.getType() << ") " << setting->second.getValue()
             //         << " with new value (" << type << ") " << value << endl;
             mask->second = Mask(id, procOrRoleOrDaq);
         } else
             processor->second.insert(
                  make_pair(string(id), Mask(id, procOrRoleOrDaq))
             );
         // let's run a consistency check
         auto p2r = procToRole.find(procOrRoleOrDaq);
         if( p2r == procToRole.end() )
             if( logs )
                *logs << "Warning: TriggerSystem object doesn't yet assign "
                      << " a role to the processor " << procOrRoleOrDaq << endl;
         return;
     }
 
     // if we've got here, the procOrRoleOrDaq argument may have meaning of role
     auto role = roleForProcs.find(procOrRoleOrDaq);
     if( role != roleForProcs.end() ){
         // apply setting on all of the processors for this role
         for(auto &proc : role->second){
             auto processor = procMasks.find( proc );
             if( processor != procMasks.end() ){
                 // processor found -> apply settings to this processor
                 //  unless the setting with such id already exists
                 auto mask = processor->second.find(id);
                 if( mask == processor->second.end() )
                     processor->second.insert(
                        make_pair(string(id), Mask(id, procOrRoleOrDaq))
                     );
             } else {
                 // here, copy constructor creates no overhead over the move constructor, whould that be defined
                 procMasks.insert(
                    make_pair(proc, map<string,Mask>( {{id,Mask(id, procOrRoleOrDaq)}} ) )
                 );
             }
         }           
        return;
     }
 
     // if we've got here, the procOrRoleOrDaq argument the only choise left is daqttc configuration
     //  that, in turn, can again be a daqttc processor or daqttc role
     // in either case, for daq we do not have any independent configuration apart from the mask status
     //  and the slot location of the processor that is masked (sitting, of course, in the same crate)
     auto d2c = daqttcToCrate.find(procOrRoleOrDaq);
     if( d2c != daqttcToCrate.end() ){
         // now, as we know crate of this daqttc, look for the crate's processors that match the id name
         size_t idLen = strlen(id);
         string slot = id + (idLen>2 ? idLen - 2 : 0); // last two digits of the port comptise the slot #
         auto processors = crateForProcs.find(d2c->second);
         if( processors != crateForProcs.end() ){
             for(auto &proc : processors->second)
                 if( procToSlot[proc] == slot )
                     procEnabled[proc] = false;
         } else
             if( logs )
                *logs << "Warning: no processors in daqttc crate for "
                      << procOrRoleOrDaq << " ... do nothing" << endl;
         return;
     }
 
     // so, finally, this is daqttc role
     auto r2d = roleForDaqttcs.find(procOrRoleOrDaq);
     if( r2d != roleForDaqttcs.end() ){
         for(auto &daq : r2d->second){
             auto processors = crateForProcs.find(daq);
             if( processors != crateForProcs.end() ){
                 for(auto &proc : processors->second)
                     procEnabled[proc] = false;
             } else
                 if( logs )
                    *logs << "Warning: no processors in daqttc crate " << d2c->second
                          << " for " << procOrRoleOrDaq << " ... do nothing" << endl;
             return;
     }
     }
 
     // if we ever reach here, we've ran out of options
     throw runtime_error ("Processor/DAQ or Role '" + string(procOrRoleOrDaq) + "' was not found in the map for masking");
 }

void l1t::TriggerSystem::addParameter	(	const char *	id,
		const char *	procOrRole,
		const char *	type,
		const char *	value,
		const char *	delim = `","`
	)

Definition at line 54 of file TriggerSystem.cc.

References eostools::move(), proc, and tmp.

Referenced by editorTools.UserCodeTool::__init__(), coreTools.RunOnData::__init__(), metTools.AddMETCollection::__init__(), HiCoreTools.RestrictInputToAOD::__init__(), trackTools.MakeAODTrackCandidates::__init__(), runJetUncertainties.RunJetUncertainties::__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__init__(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool::__init__(), editorTools.ChangeSource::__init__(), cmsswVersionTools.PickRelValInputFiles::__init__(), HiCoreTools.RemoveMCMatching::__init__(), coreTools.RemoveMCMatching::__init__(), trackTools.MakePATTrackCandidates::__init__(), trigTools.SwitchOnTrigger::__init__(), HiCoreTools.RemoveAllPATObjectsBut::__init__(), HiCoreTools.RemoveSpecificPATObjects::__init__(), trigTools.SwitchOnTriggerStandAlone::__init__(), trackTools.MakeTrackCandidates::__init__(), tauTools.AddTauCollection::__init__(), trigTools.SwitchOnTriggerMatching::__init__(), HiCoreTools.RemoveCleaning::__init__(), HiCoreTools.AddCleaning::__init__(), trigTools.SwitchOnTriggerMatchingStandAlone::__init__(), trigTools.SwitchOnTriggerMatchEmbedding::__init__(), jetTools.AddJetCollection::__init__(), jetTools.SwitchJetCollection::__init__(), jetTools.UpdateJetCollection::__init__(), jetTools.AddJetID::__init__(), jetTools.SetTagInfos::__init__(), and l1t::XmlConfigParser::readContext().

                                                                                                                                {
     // some tables forget to specify delimeter and we get an empty string here
     //  force the "," default delimeter
     if( strlen(delim) == 0 ) delim = ",";
 
     // first try to locate a processor with name matching the procOrRole argument
     auto processor = procParameters.find(procOrRole);
     if( processor != procParameters.end() ){
         // processor found -> apply settings to this processor
         auto setting = processor->second.find(id);
         if( setting != processor->second.end() ){
             // setting with this id already exists -> always take the latest value
             // if( logs )
             //    *logs << "Warning: overriding already existing " << id
             //          << " = (" << setting->second.getType() << ") " << setting->second.getValue()
             //          << " with new value (" << type << ") " << value << endl;
             setting->second = Parameter(id,procOrRole,type,value,delim);
         } else
             processor->second.insert(
                  make_pair(string(id), Parameter(id,procOrRole,type,value,delim))
             );
         // let's run a consistency check
         auto p2r = procToRole.find(procOrRole);
         if( p2r == procToRole.end() )
             if( logs )
                *logs << "Warning: TriggerSystem object doesn't yet assign "
                      << " a role to the processor " << procOrRole << endl;
         return;
     }
 
     // if we've got here, the procOrRole argument must have meaning of role,
     //  throw exception otherwise
     auto role = roleForProcs.find(procOrRole);
     if( role != roleForProcs.end() ){
         // apply setting on all of the processors for this role
         for(auto &proc : role->second){
             auto processor = procParameters.find(proc);
             if( processor != procParameters.end() ){
                 // processor found -> apply settings to this processor
                 //  unless the setting with such id already exists
                 auto setting = processor->second.find(id);
                 if( setting == processor->second.end() )
                     processor->second.insert(
                        make_pair(string(id), Parameter(id,procOrRole,type,value,delim))
                     );
             } else {
                 map<string,Parameter> tmp;
                 tmp.insert( make_pair(id, Parameter(id,procOrRole,type,value)) );
                 procParameters.insert( make_pair(proc, std::move(tmp)) );
                 // construct with brace-initialization, although better looking, cannot use move constructor:
                 //procParameters.insert(
                 //   make_pair(proc, map<string,Parameter>( {{id,Parameter(id,procOrRole,type,value)}} ) )
                 //);
             }
         }           
     } else
         throw runtime_error("Processor or Role '" + string(procOrRole) + "' was not found");
 }

void l1t::TriggerSystem::addProcessor	(	const char *	processor,
		const char *	role,
		const char *	crate,
		const char *	slot
	)

Definition at line 27 of file TriggerSystem.cc.

References edm::eventsetup::heterocontainer::insert().

Referenced by L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer(), L1TCaloParamsOnlineProd::newObject(), L1TGlobalPrescalesVetosOnlineProd::newObject(), and l1t::XmlConfigParser::readHwDescription().

                                                                                                               {
     // every processor must have a single defined role
     auto p2r = procToRole.find(processor);
     if( p2r != procToRole.end() && p2r->second != role )
         throw std::runtime_error("Processor: '" + string(processor) + "' already exists but with different role: '" + p2r->second + "'");
     else {
         procEnabled[processor] = true;
         procToRole [processor] = role;
         procToSlot [processor] = slot;
         procParameters.insert( make_pair(string(processor),std::map<std::string,Parameter>()) ) ;
         procMasks.     insert( make_pair(string(processor),std::map<std::string,Mask>()) ) ;
         roleForProcs [role]. insert(processor);
         crateForProcs[crate].insert(processor);
     }
 }

void l1t::TriggerSystem::addTable	(	const char *	id,
		const char *	procOrRole,
		const char *	columns,
		const char *	types,
		const std::vector< std::string > &	rows,
		const char *	delim
	)

Definition at line 113 of file TriggerSystem.cc.

References eostools::move(), proc, and tmp.

Referenced by l1t::XmlConfigParser::readContext().

                                                                                                                                                            {
     // some tables forget to specify delimeter and we get an empty string here
     //  force the "," default delimeter
     if( strlen(delim) == 0 ) delim = ",";
 
     // first try to locate a processor with name matching the procOrRole argument
     auto processor = procParameters.find(procOrRole);
     if( processor != procParameters.end() ){
         // processor found -> apply settings to this processor
         auto setting = processor->second.find(id);
         if( setting != processor->second.end() )
             // setting with this id already exists -> always take latest value
             setting->second = Parameter(id,procOrRole,types,columns,rows,delim);
         else
             processor->second.insert(
                  make_pair(string(id), Parameter(id,procOrRole,types,columns,rows,delim))
             );
         // let's run a consistency check
         auto p2r = procToRole.find(procOrRole);
         if( p2r == procToRole.end() )
             if( logs )
                *logs << "Warning: TriggerSystem object doesn't yet assign "
                      << " a role to the processor " << procOrRole << endl;
         return;
     }
 
     // if we've got here, the procOrRole argument must have meaning of role,
     //  throw exception otherwise
     auto role = roleForProcs.find(procOrRole);
     if( role != roleForProcs.end() ){
         // apply setting on all of the processors for this role
         for(auto &proc : role->second){
             auto processor = procParameters.find( proc );
             if( processor != procParameters.end() ){
                 // processor found -> apply settings to this processor
                 //  unless the setting with such id already exists
                 auto setting = processor->second.find(id);
                 if( setting == processor->second.end() )
                     processor->second.insert(
                        make_pair(string(id), Parameter(id,procOrRole,types,columns,rows,delim))
                     );
             } else {
                 map<string,Parameter> tmp;
                 tmp.insert( make_pair(id, Parameter(id,procOrRole,types,columns,rows,delim)) );
                 procParameters.insert( make_pair(proc, std::move(tmp)) );
                 // construct with brace-initialization, although better looking, cannot use move constructor:
                 //procParameters.insert(
                 //   make_pair(proc, map<string,Parameter>( {{id,Parameter(id,procOrRole,types,columns,rows,delim)}} ) )
                 //);
             }
         }           
     } else
         throw runtime_error("Processor or Role '" + string(procOrRole) + "' was not found");
 }

void l1t::TriggerSystem::configureSystemFromFiles	(	const char *	hwCfgFile,
		const char *	topCfgFile,
		const char *	key
	)

Definition at line 8 of file TriggerSystem.cc.

References l1t::XmlConfigParser::buildGlobalDoc(), l1t::XmlConfigParser::readContexts(), l1t::XmlConfigParser::readDOMFromFile(), and l1t::XmlConfigParser::readRootElement().

Referenced by L1TMuonBarrelParamsESProducer::L1TMuonBarrelParamsESProducer(), and L1TMuonGlobalParamsESProducer::L1TMuonGlobalParamsESProducer().

                                                                                                            {
         // read hw description xml
         // this will set the sysId
   {  
     XmlConfigParser xmlRdr;
     xmlRdr.readDOMFromFile(hwCfgFile);
     xmlRdr.readRootElement(*this);
   }
   // read configuration xml files
   {
     XmlConfigParser xmlRdr;
     xmlRdr.readDOMFromFile(topCfgFile);
     xmlRdr.buildGlobalDoc(key, topCfgFile);
     xmlRdr.readContexts(key, sysId, *this);
   }
   isConfigured = true;
 }

void l1t::TriggerSystem::disableProcOrRoleOrDaq ( const char * procOrRoleOrDaq )

Definition at line 291 of file TriggerSystem.cc.

References proc.

Referenced by l1t::XmlConfigParser::readContext(), and l1t::XmlConfigParser::readHwDescription().

                                                                       {
     // follow the standard search steps to identify if the argument is processor or role or daqttc processor/role
 
     // the argument is simply a processor's name
     auto processor = procEnabled.find(procOrRoleOrDaq);
     if( processor != procEnabled.end() ){
         processor->second = false;
         return;
     }
 
     // role
     auto role = roleForProcs.find(procOrRoleOrDaq);
     if( role != roleForProcs.end() ){
         // apply setting on all of the processors for this role
         for(auto &proc : role->second)
             // by design procEnabled must have every single processor for every role
             procEnabled[proc] = false;
         return;
     }
 
     // the whole daq of a crate is disables -> disable all of the processors in the crate
     auto d2c = daqttcToCrate.find(procOrRoleOrDaq);
     if( d2c != daqttcToCrate.end() ){
         auto processors = crateForProcs.find(d2c->second);
         if( processors != crateForProcs.end() ){
             for(auto &proc : processors->second)
                 // by design procEnabled must have every single processor for every crate
                 procEnabled[proc] = false;
         } else
             if( logs )
                *logs << "Warning: no processors in daqttc crate for "
                      << procOrRoleOrDaq << " ... do nothing" << endl;
         return;
     }
 
     // so, finally, this is daqttc role
     auto r2d = roleForDaqttcs.find(procOrRoleOrDaq);
     if( r2d != roleForDaqttcs.end() ){
         for(auto &daq : r2d->second){
             auto d2c = daqttcToCrate.find(daq);
             if( d2c != daqttcToCrate.end() ){
                 auto processors = crateForProcs.find(d2c->second);
                 if( processors != crateForProcs.end() ){
                     for(auto &proc : processors->second)
                         procEnabled[proc] = false;
                 } else
                     if( logs )
                        *logs << "Warning: no processors in daqttc crate " << d2c->second
                              << " for " << procOrRoleOrDaq << " ... do nothing" << endl;
             } else
                 if( logs )
                    *logs << "Warning: daqttc " << daq << " has no crate "
                          << " ... do nothing" << endl;
             return;
         }
     }
 
     // if we ever reach here, we've ran out of options
     throw runtime_error("Processor/DAQ or Role '" + string(procOrRoleOrDaq) + "' was not found");
 }

const map< string, Mask > & l1t::TriggerSystem::getMasks ( const char * processor ) const

Definition at line 271 of file TriggerSystem.cc.

Referenced by getRoleToProcsAssignment(), and L1TMuonGlobalParamsHelper::loadFromOnline().

                                                                     {
     if( !isConfigured )
         throw std::runtime_error("TriggerSystem is not configured yet. First call the configureSystem method");
 
     auto processor = procMasks.find(p);
     if( processor == procMasks.end() )
         throw std::runtime_error("Processor '" + string(p) + "' was not found in the configuration");
 
     return processor->second;
 }

const map< string, Parameter > & l1t::TriggerSystem::getParameters ( const char * processor ) const

Definition at line 168 of file TriggerSystem.cc.

Referenced by L1TMuonBarrelParamsHelper::configFromDB(), getRoleToProcsAssignment(), L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer(), L1TMuonGlobalParamsHelper::loadFromOnline(), L1TMuonEndcapParamsOnlineProd::newObject(), L1TCaloParamsOnlineProd::newObject(), and L1TGlobalPrescalesVetosOnlineProd::newObject().

                                                                               {
     if( !isConfigured )
         throw runtime_error("TriggerSystem is not configured yet. First call the configureSystem method");
 
     auto processor = procParameters.find(p);
     if( processor == procParameters.end() )
         throw runtime_error("Processor '" + string(p) + "' was not found in the configuration");
 
     return processor->second;
 }

const std::map<std::string, std::string>& l1t::TriggerSystem::getProcToRoleAssignment ( void ) const

inlinenoexcept

Definition at line 61 of file TriggerSystem.h.

References procToRole.

Referenced by L1TMuonBarrelParamsHelper::configFromDB(), and L1TMuonGlobalParamsHelper::loadFromOnline().

61 { return procToRole; }

l1t::TriggerSystem::procToRole

std::map< std::string, std::string > procToRole

Definition: TriggerSystem.h:18

const std::map<std::string, std::set<std::string> >& l1t::TriggerSystem::getRoleToProcsAssignment ( void ) const

inlinenoexcept

Definition at line 62 of file TriggerSystem.h.

References getMasks(), getParameters(), isMasked(), isProcEnabled(), and roleForProcs.

62 { return roleForProcs; }

l1t::TriggerSystem::roleForProcs

std::map< std::string, std::set< std::string > > roleForProcs

Definition: TriggerSystem.h:23

bool l1t::TriggerSystem::isMasked	(	const char *	proccessor,
		const char *	id
	)		const

Definition at line 282 of file TriggerSystem.cc.

References funct::m, and RecoTauDiscriminantConfiguration::mask.

Referenced by getRoleToProcsAssignment(), and L1TMuonGlobalParamsHelper::loadFromOnline().

                                                                 {
     const std::map<std::string, Mask>& m = getMasks(p);
 
     auto mask = m.find(id);
     if( mask == m.end() ) return false;
 
     return true;
 }

bool l1t::TriggerSystem::isProcEnabled ( const char * proccessor ) const

Definition at line 352 of file TriggerSystem.cc.

Referenced by getRoleToProcsAssignment().

                                                      {
     if( !isConfigured )
         throw std::runtime_error("TriggerSystem is not configured yet. First call the configureSystem method");
 
     auto processor = procEnabled.find(p);
     if( processor == procEnabled.end() )
         throw runtime_error("Processor '" + string(p) + "' not found");
 
     return processor->second;
 }