VP1Trig::VP1TriggerSystem Class Reference

#include <VP1TriggerSystem.h>

Inheritance diagram for VP1Trig::VP1TriggerSystem:

Collaboration diagram for VP1Trig::VP1TriggerSystem:

Public Member Functions
	VP1TriggerSystem ()
virtual	~VP1TriggerSystem ()
void	log_info (const QString &msg)
void	log_warning (const QString &msg)
void	log_verbose (const QString &msg)
void	log_error (const QString &msg)
void	log_fatal (const QString &msg)
void	log_debug (const QString &msg)
std::string	prefix (std::string str)
QString	qstr (char c)
QString	qstr (std::string str)

Static Public Member Functions
static const QString	pfx1 ()
static const QString	pfx2 ()
static const QString	pfx3 ()

Private Member Functions
bool	loadTriggerHandles (StoreGateSvc *m_storeGate, QString triglvl)
void	clearTriggerHandles ()
std::vector< VP1Trig::VP1TriggerHandleEF >	getHandleEF ()
std::vector< VP1Trig::VP1TriggerHandleL2 >	getHandleL2 ()
std::vector< VP1Trig::VP1TriggerHandleL1 >	getHandleL1 ()

Private Attributes
ToolHandle< Trig::TrigDecisionTool >	m_trigDec
ToolHandle< TrigMatchTool >	m_trigMatch
std::vector< VP1Trig::VP1TriggerHandleEF >	m_handleEF
std::vector< VP1Trig::VP1TriggerHandleL2 >	m_handleL2
std::vector< VP1Trig::VP1TriggerHandleL1 >	m_handleL1
std::string	m_name
int	m_lvl

Friends
class	VP1TriggerProcessor

Detailed Description

Definition at line 55 of file VP1TriggerSystem.h.

Constructor & Destructor Documentation

VP1TriggerSystem()

VP1Trig::VP1TriggerSystem::VP1TriggerSystem

(

)

Definition at line 58 of file VP1TriggerSystem.cxx.

  : Logger("VP1TriggerSystem"),
    m_trigDec("Trig::TrigDecisionTool/TrigDecisionTool"),
    m_trigMatch("TrigMatchTool/TrigMatchTool") {log_verbose("constructor");}

~VP1TriggerSystem()

VP1Trig::VP1TriggerSystem::~VP1TriggerSystem ( )

virtual

Definition at line 66 of file VP1TriggerSystem.cxx.

{log_verbose("destructor");}

Member Function Documentation

clearTriggerHandles()

void VP1Trig::VP1TriggerSystem::clearTriggerHandles ( )

private

Definition at line 220 of file VP1TriggerSystem.cxx.

{
  log_verbose("Clearing trigger handles");
  m_handleL1.clear();
  m_handleL2.clear();
  m_handleEF.clear();
}

getHandleEF()

std::vector<VP1Trig::VP1TriggerHandleEF> VP1Trig::VP1TriggerSystem::getHandleEF ( )

inlineprivate

Definition at line 86 of file VP1TriggerSystem.h.

getHandleL1()

std::vector<VP1Trig::VP1TriggerHandleL1> VP1Trig::VP1TriggerSystem::getHandleL1 ( )

inlineprivate

Definition at line 88 of file VP1TriggerSystem.h.

getHandleL2()

std::vector<VP1Trig::VP1TriggerHandleL2> VP1Trig::VP1TriggerSystem::getHandleL2 ( )

inlineprivate

Definition at line 87 of file VP1TriggerSystem.h.

loadTriggerHandles()

bool VP1Trig::VP1TriggerSystem::loadTriggerHandles ( StoreGateSvc *  m_storeGate, QString  triglvl  )

private

Definition at line 71 of file VP1TriggerSystem.cxx.

{
  log_verbose("loadTriggerHandles()");
  
  //Safety handle check
  if(m_handleL1.size()!=0 || m_handleL2.size()!=0 || m_handleEF.size()!=0)
    clearTriggerHandles();
  
  
  if(triglvl.compare("ALL", Qt::CaseInsensitive)==0 || triglvl.compare("L1", Qt::CaseInsensitive)==0) {
    //######################################## L1 ############################################### >
    log_info("Retrieving L1 data via TrigDecisionTool: start");
    
    //VARs
    std::string trigID;
    int trigcount=0;
    
    //Try to retrieve the TrigDecisionTool
    if(m_trigDec.retrieve().isFailure()) {
      log_fatal("Could not retrieve TrigDecisionTool!");
      return false; //ref: daqstatus
    }
    //Try to retrieve the TrigMatchTool
    if(m_trigMatch.retrieve().isFailure()) {
      log_fatal("Could not retrieve TrigMatchTool!");
      return false; //ref: daqstatus
    }
    
    //Loading entire ChainGroup information via TrigDecisionTool
    const Trig::ChainGroup* allChains = m_trigDec->getChainGroup(".*"); //all triggers
    if(!allChains) {
      log_fatal("ChainGroup could not be loaded!");
      return false; //ref: daqstatus
    }
    
    //Retrieve list of valid triggers associated with ChainGroup
    std::vector<std::string> trigList = allChains->getListOfTriggers();
    std::vector<std::string>::iterator trigItr; //Iterator over trigList
    
    //Loop over list of triggers
    for(trigItr=trigList.begin(); trigItr!=trigList.end(); ++trigItr) {
      
      //Safety Check: item not empty!
      if((*trigItr).empty()) continue;
      
      //Process passed triggers
      if(m_trigDec->isPassed((*trigItr))) {
    ++trigcount;
    trigID = std::string((*trigItr).c_str());
    //std::cout << "INFO :: Processing trigger chain: " << trigger << "[" << trigcount << "] ";
    
    using namespace Trig;
    Trig::FeatureContainer f = m_trigDec->features(trigID); //get trigger and its objects
    //std::cout << "fsize: " << f.getCombinations().size() << std::endl;
    
    //Export to L1 handle
    VP1TriggerHandleL1 handleL1(f, QString::fromStdString(trigID));
    m_handleL1.push_back(handleL1);
      }//END: passed triggers
    }//END: loop over chain group items
    log_verbose("Retrieving L1 data: complete");
  }
  
  
  if(triglvl.compare("ALL", Qt::CaseInsensitive)==0 || triglvl.compare("L2", Qt::CaseInsensitive)==0) {
    //######################################## L2 ############################################### >
    // Retrieve MuonFeatureDetailsContainer based on
    /* MuFastMon.cxx
       Authors: Akimasa Ishikawa (akimasa.ishikawa@cern.ch)
       Kunihiro Nagano (nagano@mail.cern.ch) */
    log_verbose("Retrieving L2 data: start");
    
    const DataHandle<MuonFeatureDetailsContainer> mfdContainer;
    const DataHandle<MuonFeatureDetailsContainer> lastmfdContainer;
    bool runL2=false;
 
    while(runL2==false) {
      if(storeGate->retrieve(mfdContainer,lastmfdContainer).isSuccess())
    log_verbose("MuonFeatureDetailsContainer retrieved");
      
      if(!mfdContainer) {
    log_fatal("MuonFeatureDetailsContainer not retrieved!");
        return false; //ref: daqstatus
      }
      
      // -----------------------------
      // Dump muonFeatureDetails info
      // -----------------------------
      std::vector<const MuonFeatureDetails*> vec_muonFeatureDetails;
      
      for(; mfdContainer!=lastmfdContainer; mfdContainer++) {
    MuonFeatureDetailsContainer::const_iterator mfd     = mfdContainer->begin();
    MuonFeatureDetailsContainer::const_iterator lastmfd = mfdContainer->end();
        for(; mfd != lastmfd; ++mfd) {
          if((*mfd)==0) continue;
          vec_muonFeatureDetails.push_back(*mfd);
        }
      }
      
      VP1TriggerHandleL2 handleL2(vec_muonFeatureDetails);
      m_handleL2.push_back(handleL2);
      
      runL2=true;
    } //END: looping MuonFetureDetails
    log_verbose("Retrieving L2 data: complete");
  }
  
  
  if(triglvl.compare("ALL", Qt::CaseInsensitive)==0 || triglvl.compare("EF", Qt::CaseInsensitive)==0) {
    //######################################## EF ############################################### >
    //--- Note: Adapted from the code TrigEDMchecker.cxx, which was                  ---
    //--- "Adapted from code by A.Hamilton to check trigger EDM; R.Goncalo 21/11/07" ---
    log_verbose("Retrieving EF data: start");
    
    const DataHandle<TrigMuonEFInfoContainer> trigMuon;
    const DataHandle<TrigMuonEFInfoContainer> lastTrigMuon;
    unsigned int muonCounter=0;
    
    if(storeGate->retrieve(trigMuon,lastTrigMuon).isSuccess()) {
      for(int i=0; trigMuon!=lastTrigMuon; ++trigMuon, ++i) {
    TrigMuonEFInfoContainer::const_iterator MuonItr  = trigMuon->begin(); //Iterators over top-level EDM
    TrigMuonEFInfoContainer::const_iterator MuonItrE = trigMuon->end();   //objects (TrigMuonEFInfoContainer)
    
    for(int j=0; MuonItr!=MuonItrE; ++MuonItr, ++j ) { //looping over TrigMuonEFInfo objects
      const TrigMuonEFInfo* muonInfo = (*MuonItr);
      std::vector<std::string> chains = m_trigMatch->chainsPassedByObject<TrigMuonEFInfo>(muonInfo);
      std::vector<std::string>::iterator itChain; //iterator over chains
      QList<QString> chainIDs;
      
      for(itChain=chains.begin(); itChain!=chains.end(); ++itChain)
        chainIDs << QString((*itChain).c_str());
      
      VP1TriggerHandleEF handleEF(muonInfo, QString("Muon No. ")+QString::number(++muonCounter), chainIDs);
      m_handleEF.push_back(handleEF);
    }
      }//loop
    } else {
      log_fatal("Could not retrieve TrigMuonEF from StoreGate!");
      return false; //ref: daqstatus
    }
    log_verbose("Retrieving EF data: complete");
  }//END: EF
  
  return true; //ref: daqstatus  
}

log_debug()

void VP1Trig::Logger::log_debug ( const QString &  msg )

inherited

Definition at line 54 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                                {
  std::cout<<prefix(m_name)<<"DEBUG "<<msg.toStdString()<<std::endl;
}

log_error()

void VP1Trig::Logger::log_error ( const QString &  msg )

inherited

Definition at line 46 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                                {
  std::cout<<prefix(m_name)<<"ERROR "<<msg.toStdString()<<std::endl;
}

log_fatal()

void VP1Trig::Logger::log_fatal ( const QString &  msg )

inherited

Definition at line 49 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                                {
  std::cout<<prefix(m_name)<<"FATAL "<<msg.toStdString()<<std::endl;
}

log_info()

void VP1Trig::Logger::log_info ( const QString &  msg )

inherited

Definition at line 32 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                               {
  if(m_lvl>=1)
    std::cout<<prefix(m_name)<<"INFO "<<msg.toStdString()<<std::endl;
}

log_verbose()

void VP1Trig::Logger::log_verbose ( const QString &  msg )

inherited

Definition at line 40 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                                  {
  if(m_lvl>=3)
    std::cout<<prefix(m_name)<<"VERBOSE "<<msg.toStdString()<<std::endl;
}

log_warning()

void VP1Trig::Logger::log_warning ( const QString &  msg )

inherited

Definition at line 36 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

                                                  {
  if(m_lvl>=2)
    std::cout<<prefix(m_name)<<"WARNING "<<msg.toStdString()<<std::endl;
}

pfx1()

static const QString VP1Trig::Logger::pfx1 ( )

inlinestaticinherited

Definition at line 65 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

pfx2()

static const QString VP1Trig::Logger::pfx2 ( )

inlinestaticinherited

Definition at line 66 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

pfx3()

static const QString VP1Trig::Logger::pfx3 ( )

inlinestaticinherited

Definition at line 67 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

prefix()

std::string VP1Trig::Logger::prefix ( std::string  str )

inherited

Definition at line 61 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

{
  //15 character prefix standard
  if(int(str.size())>15) {
    str=str.substr(0,15);
    str=str+std::string("...   ");
    return str;
  }
  else if(int(str.size())==15) {
    str=str+std::string("      ");
    return str;
  }
  int q=21-int(str.size());
  for(int i=0;i<q;++i)
    str=str+std::string(" ");
  return str;
}

qstr() [1/2]

QString VP1Trig::Logger::qstr ( char  c )

inherited

Definition at line 82 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

{
  std::stringstream ss; ss<<c; 
  std::string cStr=ss.str();
  ss.str(std::string()); ss.clear();
  return QString::fromStdString(cStr);
}

qstr() [2/2]

QString VP1Trig::Logger::qstr ( std::string  str )

inherited

Definition at line 93 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

{
  return QString::fromStdString(str);
}

Friends And Related Function Documentation

VP1TriggerProcessor

friend class VP1TriggerProcessor

friend

Definition at line 70 of file VP1TriggerSystem.h.

Member Data Documentation

m_handleEF

std::vector<VP1Trig::VP1TriggerHandleEF> VP1Trig::VP1TriggerSystem::m_handleEF

private

Definition at line 81 of file VP1TriggerSystem.h.

m_handleL1

std::vector<VP1Trig::VP1TriggerHandleL1> VP1Trig::VP1TriggerSystem::m_handleL1

private

Definition at line 83 of file VP1TriggerSystem.h.

m_handleL2

std::vector<VP1Trig::VP1TriggerHandleL2> VP1Trig::VP1TriggerSystem::m_handleL2

private

Definition at line 82 of file VP1TriggerSystem.h.

m_lvl

int VP1Trig::Logger::m_lvl

privateinherited

Definition at line 71 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

m_name

std::string VP1Trig::Logger::m_name

privateinherited

Definition at line 70 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

m_trigDec

ToolHandle<Trig::TrigDecisionTool> VP1Trig::VP1TriggerSystem::m_trigDec

private

Definition at line 77 of file VP1TriggerSystem.h.

m_trigMatch

ToolHandle<TrigMatchTool> VP1Trig::VP1TriggerSystem::m_trigMatch

private

Definition at line 78 of file VP1TriggerSystem.h.

---

The documentation for this class was generated from the following files:

• VP1TriggerSystem.h
• VP1TriggerSystem.cxx