l1t::TriggerSystem Class Reference

#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

TriggerSystem()

l1t::TriggerSystem::TriggerSystem ( void  )

inline

Definition at line 77 of file TriggerSystem.h.

                        {
      isConfigured = false;
      logs = nullptr;
    }

References isConfigured, and logs.

~TriggerSystem()

l1t::TriggerSystem::~TriggerSystem ( void  )

inline

Definition at line 82 of file TriggerSystem.h.

{}

Member Function Documentation

addDaq()

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

Definition at line 43 of file TriggerSystem.cc.

                                                                                 {
    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);
    }
  }

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

addMask()

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

Definition at line 179 of file TriggerSystem.cc.

                                                                         {
    // 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");
  }

References triggerObjects_cff::id, and ValidateTausOnZEEFastSim_cff::proc.

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

addParameter()

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.

                                                                                                      {
    // 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");
  }

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

Referenced by metTools.AddMETCollection::__init__(), trackTools.MakeAODTrackCandidates::__init__(), coreTools.RunOnData::__init__(), runJetUncertainties.RunJetUncertainties::__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__init__(), cmsswVersionTools.PickRelValInputFiles::__init__(), coreTools.RemoveMCMatching::__init__(), trackTools.MakePATTrackCandidates::__init__(), trigTools.SwitchOnTrigger::__init__(), trigTools.SwitchOnTriggerStandAlone::__init__(), tauTools.AddTauCollection::__init__(), trackTools.MakeTrackCandidates::__init__(), trigTools.SwitchOnTriggerMatching::__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().

addProcessor()

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

Definition at line 26 of file TriggerSystem.cc.

                                                                                                               {
    // 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);
    }
  }

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

addTable()

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 111 of file TriggerSystem.cc.

                                                  {
    // 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");
  }

References mps_check::columns, eostools::move(), ValidateTausOnZEEFastSim_cff::proc, postprocess-scan-build::rows, and createJobs::tmp.

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

configureSystemFromFiles()

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

Definition at line 8 of file TriggerSystem.cc.

                                                                                                             {
    // 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;
  }

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

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

disableProcOrRoleOrDaq()

void l1t::TriggerSystem::disableProcOrRoleOrDaq

(

const char *

procOrRoleOrDaq

)

Definition at line 282 of file TriggerSystem.cc.

                                                                        {
    // 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");
  }

References ValidateTausOnZEEFastSim_cff::proc.

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

getMasks()

const map< string, Mask > & l1t::TriggerSystem::getMasks

(

const char *

processor

)

const

Definition at line 261 of file TriggerSystem.cc.

                                                                      {
    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;
  }

References AlCaHLTBitMon_ParallelJobs::p.

getParameters()

const map< string, Parameter > & l1t::TriggerSystem::getParameters

(

const char *

processor

)

const

Definition at line 168 of file TriggerSystem.cc.

                                                                                {
    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;
  }

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by L1TMuonBarrelParamsHelper::configFromDB(), L1TMuonEndCapObjectKeysOnlineProd::fillObjectKeys(), L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer(), L1TMuonGlobalParamsHelper::loadFromOnline(), L1TMuonEndCapParamsOnlineProd::newObject(), L1TCaloParamsOnlineProd::newObject(), and L1TGlobalPrescalesVetosOnlineProd::newObject().

getProcToRoleAssignment()

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

inlinenoexcept

Definition at line 60 of file TriggerSystem.h.

{ return procToRole; }

References procToRole.

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

getRoleToProcsAssignment()

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

inlinenoexcept

Definition at line 61 of file TriggerSystem.h.

                                                                                               {
      return roleForProcs;
    }

References roleForProcs.

isMasked()

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

Definition at line 272 of file TriggerSystem.cc.

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

References visualization-live-secondInstance_cfg::m, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by L1TMuonGlobalParamsHelper::loadFromOnline().

isProcEnabled()

bool l1t::TriggerSystem::isProcEnabled

(

const char *

proccessor

)

const

Definition at line 339 of file TriggerSystem.cc.

                                                       {
    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;
  }

References AlCaHLTBitMon_ParallelJobs::p.

setConfigured()

void l1t::TriggerSystem::setConfigured ( bool  state = true )

inlinenoexcept

Definition at line 74 of file TriggerSystem.h.

{ isConfigured = state; }

References isConfigured.

Referenced by L1TMuonEndCapObjectKeysOnlineProd::fillObjectKeys(), L1TGlobalPrescalesVetosESProducer::L1TGlobalPrescalesVetosESProducer(), L1TMuonGlobalParamsOnlineProd::newObject(), L1TMuonEndCapParamsOnlineProd::newObject(), L1TMuonBarrelParamsOnlineProd::newObject(), L1TGlobalPrescalesVetosOnlineProd::newObject(), and L1TCaloParamsOnlineProd::newObject().

setLogStream()

void l1t::TriggerSystem::setLogStream ( std::ostream *  s ) const

inlinenoexcept

Definition at line 75 of file TriggerSystem.h.

{ logs = s; }

References logs, and alignCSCRings::s.

setSystemId()

void l1t::TriggerSystem::setSystemId ( const char *  id )

inlinenoexcept

Definition at line 72 of file TriggerSystem.h.

{ sysId = id; }

References triggerObjects_cff::id, and sysId.

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

systemId()

std::string l1t::TriggerSystem::systemId ( void  ) const

inlinenoexcept

Definition at line 71 of file TriggerSystem.h.

{ return sysId; }

References sysId.

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

Member Data Documentation

crateForProcs

std::map<std::string, std::set<std::string> > l1t::TriggerSystem::crateForProcs

private

Definition at line 24 of file TriggerSystem.h.

daqttcToCrate

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

private

Definition at line 22 of file TriggerSystem.h.

daqttcToRole

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

private

Definition at line 21 of file TriggerSystem.h.

isConfigured

bool l1t::TriggerSystem::isConfigured

private

Definition at line 33 of file TriggerSystem.h.

Referenced by setConfigured(), and TriggerSystem().

logs

std::ostream* l1t::TriggerSystem::logs

mutableprivate

Definition at line 34 of file TriggerSystem.h.

Referenced by setLogStream(), and TriggerSystem().

procEnabled

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

private

Definition at line 20 of file TriggerSystem.h.

procMasks

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

private

Definition at line 31 of file TriggerSystem.h.

procParameters

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

private

Definition at line 29 of file TriggerSystem.h.

procToRole

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

private

Definition at line 18 of file TriggerSystem.h.

Referenced by getProcToRoleAssignment().

procToSlot

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

private

Definition at line 19 of file TriggerSystem.h.

roleForDaqttcs

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

private

Definition at line 26 of file TriggerSystem.h.

roleForProcs

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

private

Definition at line 23 of file TriggerSystem.h.

Referenced by getRoleToProcsAssignment().

sysId

std::string l1t::TriggerSystem::sysId

private

Definition at line 16 of file TriggerSystem.h.

Referenced by setSystemId(), and systemId().