TrigIDR4Mon.cxx

Go to the documentation of this file.

 
#include "TrigInDetAnalysisExample/ChainString.h"
#include "TrigInDetAnalysisExample/TIDAHistogram.h"
#include "TrigDecisionTool/ChainGroup.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
 
#include "TrigIDR4Mon.h"
#include "Utils.h"
 
#include "MsgMacros.h"
 
 
TrigIDR4Mon::TrigIDR4Mon( const std::string & name, ISvcLocator* pSvcLocator) 
  :  AthMonitorAlgorithm(name, pSvcLocator), 
     m_tdt("Trig::TrigDecisionTool/TrigDecisionTool"),
     m_sliceTag("")
{
# ifdef USE_DATE_TIME_STAMP
  MY_MSG_INFO << "TrigIDR4Mon::TrigIDR4Mon() compiled: " << __DATE__ << " " << __TIME__ << endmsg;
# endif
 
  declareProperty( "SliceTag",   m_sliceTag = "" );
  
  MY_MSG_DEBUG << "TrigIDR4Mon::TrigIDR4Mon() exiting " << gDirectory->GetName() << endmsg;
  
}
 
 
 
TrigIDR4Mon::~TrigIDR4Mon() { }
 
 
 
StatusCode TrigIDR4Mon::initialize() {
 
  MY_MSG_DEBUG << " ----- enter initialize() ----- " << endmsg;
 
  MY_MSG_INFO << "TrigIDR4Mon::initialize() " << gDirectory->GetName() << " " << m_sliceTag << endmsg;

 
  MY_MSG_DEBUG << "TrigIDR4Mon::name:      " << name()     << endmsg;
  MY_MSG_DEBUG << "TrigIDR4Mon::SliceTag:  " << m_sliceTag << endmsg;
 
  ATH_CHECK(m_monTools.retrieve());
 
  MY_MSG_INFO <<  "TrigIDR4Mon::initialize() retrieved " << m_monTools.size() << " MonTools"  << endmsg;
 
  ATH_CHECK(m_tdt.retrieve());
 
  ATH_CHECK(bookHistograms());
 
  MY_MSG_DEBUG <<  " -----  exit init() ----- "  << endmsg;
 
  return AthMonitorAlgorithm::initialize();
 
}
 
 
StatusCode TrigIDR4Mon::bookHistograms() {
 
  MY_MSG_DEBUG <<  "           ----- enter book() ----- "  << endmsg;
 
  //  MY_MSG_INFO <<  "            TrigIDR4Mon::book() " << gDirectory->GetName()  << endmsg;

  // "^[[91;1m"
  // "^[[m"
 
  MY_MSG_DEBUG <<  "^[[91;1m" << name() << "\t:AnalysisConfig " << "^[[m"  << endmsg;
  
  std::string lastvtx = "";

 
  std::vector<std::string> chains;
  
  chains.reserve( m_monTools.size() );
  

  //  std::vector<ToolHandle<GenericMonitoringTool>*> monTools; 
  std::vector<IDTPM2::TrackAnalysis*> monTools; 
 
  monTools.reserve(m_monTools.size());
  
  ToolHandleArray<IDTPM2::TrackAnalysis>::iterator toolitr = m_monTools.begin();
 
  std::vector<GenericMonitoringTool*> tools;  // not tool hanldes ?? no, because we are creating these on the fly
  
  // sort out all the chain stuff
 
  int chaincount = 0;
 
  
  while ( toolitr!=m_monTools.end() ) {
 
      std::string toolname = toolitr->name();
 
      if ( toolname.find(":")==std::string::npos ) toolname = ":"+toolname;
      
      ChainString chainName = toolname;
      
      
      if ( chainName.head() == "" ) { 
    
    std::string selectChain = chainName.raw();
 
    //     toolitr->setPath( m_sliceTag+"/"+chainName );
    
    if ( std::find(chains.begin(), chains.end(), selectChain) == chains.end()) { // deduplicate   
      MY_MSG_DEBUG <<  "TrigIDR4Mon::bookHistograms() adding offline tool: " << selectChain  << endmsg;
      chains.push_back( selectChain );
      monTools.push_back( toolitr->get() );

      if ( (*toolitr)->isInitialized() ) {
        if ( !(*toolitr)->refTracks().empty()     ) ATH_CHECK( initializeKeys( (*toolitr)->refTracks()     ) );    
        if ( !(*toolitr)->refTracks_tag().empty() ) ATH_CHECK( initializeKeys( (*toolitr)->refTracks_tag() ) );
      }
        
    }
    toolitr++;  //cppcheck-suppress postfixOperator 
      }
      else { 
    
 
    if ( chainName.head().find("HLT_")==std::string::npos && chainName.head().find("EF_")==std::string::npos ) {
      // with the O2 optimisation that ATLAS uses, unevaluated pre- and postfix operators produce identical code - I prefer the postfix
      toolitr++;  //cppcheck-suppress postfixOperator 
      continue;
    }
    
    
    std::string selectChain = chainName.head();
    
 
    MY_MSG_DEBUG <<  "checking chain: " << chainName.head()  << endmsg;
    
    if ( selectChain=="" ) { 
      MY_MSG_WARNING << "^[[91;1m" << "No chain matched\tchain input " << chainName.head() << "  :  " << chainName.tail() << "^[[m"<< endmsg;
      // with the O2 optimisation that ATLAS uses, unevaluated pre- and postfix operators produce identical code - I prefer the postfix
      toolitr++;  //cppcheck-suppress postfixOperator 
      continue;
    }

    
    selectChain = chainName.subs( selectChain );
    
    if (  std::find(chains.begin(), chains.end(), selectChain) == chains.end() ) { // deduplicate
 
      MY_MSG_DEBUG <<  "TrigIDR4Mon::bookHistograms() adding trigger tool: " << selectChain  << endmsg;
 
      chains.push_back( selectChain );
 
      //      (*toolitr)->setTDT( m_tdt );
      monTools.push_back( toolitr->get() );
      //  monTools.push_back( new TrackAnalysis( "TrackAnalysis", toolitr->name(), this ) );
      //  monTools.back()->addHistograms( (*toolitr) );
      //      monTools.back()->addHistograms( (*toolitr) );
 
      if ( (*toolitr)->isInitialized() ) { 
        if ( !(*toolitr)->refTracks().empty()     ) ATH_CHECK( initializeKeys( (*toolitr)->refTracks()     ) );
        if ( !(*toolitr)->refTracks_tag().empty() ) ATH_CHECK( initializeKeys( (*toolitr)->refTracks_tag() ) );
      }
      
      chaincount++;
      
    }
 
    // with the O2 optimisation that ATLAS uses, unevaluated pre- and postfix operators produce identical code - I prefer the postfix
    //cppcheck-suppress postfixOperator^
    toolitr++; //cppcheck-suppress postfixOperator 
      }
 
  }
    
  m_chainNames = chains;
 
  m_tools = monTools;
  
  MY_MSG_INFO <<  " configured " << chaincount << " (" << m_tools.size() << ") analyses"  << endmsg;
  
  MY_MSG_DEBUG <<   " ----- exit book() ----- "  << endmsg;
 
  return StatusCode::SUCCESS;
  
}
 
 
 
 
 
StatusCode TrigIDR4Mon::execute(const EventContext& context) const {
 
  MY_MSG_DEBUG <<  " ----- enter fill() ----- "  << endmsg;
  MY_MSG_DEBUG <<  "TrigIDR4Mon::execute() " << IDTPM2::stime() << "\tm_tools.size() = " << m_tools.size()  << endmsg;
 
  static thread_local long allcounts = 0;
 
  if ( allcounts && allcounts%1000==0 ) {
    MY_MSG_INFO << "TrigIDR4Mon::execute() " << IDTPM2::stime() << "\tcounts: " << allcounts << "\tm_tools.size() = " << m_tools.size() << endmsg;
  }
  allcounts++;
  
  const Trig::ChainGroup*          chainGroup = m_tdt->getChainGroup( "HLT_.*, EF_.*" );
  const std::vector<std::string> selectChains = chainGroup->getListOfTriggers();
  
 
#if 1
  for ( size_t itools=m_tools.size() ; itools-- ; ) {
    MY_MSG_DEBUG <<  "TrigIDR4Mon::fillHistograms() calling execute() on tool " << itools << " : " << m_tools[itools]->name()  << endmsg;
    m_tools[itools]->execute(context);
  }
#endif
 
#if 0
  
  
  static std::once_flag flag;
  std::call_once(flag, [&]() {
    for ( unsigned i=0 ; i<selectChains.size() ; i++ ) {
      MY_MSG_DEBUG <<  "\tchain " << selectChains[i] << " from TDT"  << endmsg;
    }
    
    for ( size_t i=selectChains.size() ; i-- ; ) {
      if ( i>5 ) i=5;
      MY_MSG_INFO <<  "^[[91;1m" << "configured chain " << selectChains[i] << "^[[m"  << endmsg;
    }
  });
  
  if (msgLvl(MSG::DEBUG)) {
    const std::vector<bool> isPassed = chainGroup->isPassedForEach();
    for ( unsigned i=0 ; i<selectChains.size() ; i++ ) {
      if ( isPassed[i] ) {
        MY_MSG_DEBUG <<  "chain " << selectChains[i] << "\tpass: " << isPassed[i] << "\tprescale: " << m_tdt->getPrescale(selectChains[i])  << endmsg;
      }
    }
  }
  
#endif
  
  MY_MSG_DEBUG << " ----- exit fill() ----- " << endmsg;
 
  return StatusCode::SUCCESS;
}
 
 
 
 
 
// bool newEventsBlock, bool newLumiBlock, bool newRun are protected varibales
// correctly set before this is called
StatusCode TrigIDR4Mon::finalize() {
 
  MY_MSG_INFO <<  "finalize() " << name() << endmsg;
 
  for ( size_t itools=m_tools.size() ; itools-- ; ) {
    MY_MSG_DEBUG <<  "TrigIDR4Mon::finalize() calling finalize() on tool " << itools << " : " << m_tools[itools]->name()  << endmsg;
    if ( (m_tools[itools]->finalize()).isFailure() ) {
      MY_MSG_DEBUG <<  "finalize() failed on tool" << m_tools[itools]->name()  << endmsg;
    }
  }
  
  MY_MSG_DEBUG <<  "finalize() out" << name() << endmsg;
  
  return StatusCode::SUCCESS;
}