TrigEgammaMatchingToolMT.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include <boost/algorithm/string.hpp>
 
 
// L2Calo, L2Electron, L2Photon, EFCalo, Electron and Photon trigger passed access
template<class T>
inline bool TrigEgammaMatchingToolMT::ancestorPassed( const TrigCompositeUtils::Decision *dec, const std::string& trigger, const std::string& key, 
                                                      unsigned int condition) const
{
 
  if( !dec ) return false;
 
  auto initRoi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>( dec, "initialRoI");
  if( !initRoi.isValid() ) 
    return false;
 
  auto vec =  tdt()->features< T >(trigger,condition ,key);
 
  for( auto &featLinkInfo : vec )
  {                                                       
    auto roi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(featLinkInfo.source, "initialRoI");
    if( ! roi.isValid()) continue;                                                              
    if( (*roi.link)->roiWord() == (*initRoi.link)->roiWord()) 
    {
      bool passed = (featLinkInfo.state==TrigCompositeUtils::ActiveState::ACTIVE);
      if(passed)  return true;
    }
  }
  return false;                      
}
 
 
// L1Calo trigger passed access
template<>
inline bool TrigEgammaMatchingToolMT::ancestorPassed<TrigRoiDescriptorCollection>( const TrigCompositeUtils::Decision *dec, 
                                                                                   const std::string& trigger, const std::string& /*key*/,
                                                                                   unsigned int condition ) const
{
  if( !dec ) return false;
  auto initRoi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>( dec, "initialRoI");
  if( !initRoi.isValid() ) 
    return false;
 
  auto vec =  tdt()->features<TrigRoiDescriptorCollection>(trigger,condition,"",TrigDefs::allFeaturesOfType,"initialRoI");       
 
  for( auto &featLinkInfo : vec )
  {                   
    if(!featLinkInfo.isValid())  continue;                             
    if( (*featLinkInfo.link)->roiWord() == (*initRoi.link)->roiWord()) 
    {
      bool passed = (featLinkInfo.state==TrigCompositeUtils::ActiveState::ACTIVE);
      if(passed)  return true; 
    }
  }
  return true;                      
}
 
 
 
 
template<class T>
inline bool TrigEgammaMatchingToolMT::closestObject( const xAOD::Egamma *eg, const TrigCompositeUtils::Decision *&dec, 
                                                     const std::string &trigger, const std::string &key , 
                                                     float dR_value, unsigned int condition
                                                   ) const
{
  double deltaR=0.;        
  auto vec =  tdt()->features<T>(trigger, condition ,key);
  
  
  for( auto &featLinkInfo : vec ){
 
    if(! featLinkInfo.isValid() ) continue;
    const auto *feat = *(featLinkInfo.link);
    if(!feat) continue;
    deltaR = dR(eg->eta(),eg->phi(), feat->eta(),feat->phi());
    if(deltaR < dR_value){
      dec = featLinkInfo.source;
      return true;
    }
  }
  return false;
}
 
 
template<class T>
inline std::vector<TrigCompositeUtils::LinkInfo<T>> TrigEgammaMatchingToolMT::getFeatures( const TrigCompositeUtils::Decision *dec ,
                                                                                           const std::string& trigger, const std::string& key,
                                                                                           unsigned int condition)
const 
{
  std::vector<TrigCompositeUtils::LinkInfo<T>> vec;
  auto initRoi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(dec, "initialRoI"); 
  if( !initRoi.isValid() ) return vec;
 
  auto vec_dec = tdt()->features<T>(trigger,condition, key);
  for ( auto& featLinkInfo : vec_dec ){
    if( !featLinkInfo.isValid() ) continue;
    auto roi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(featLinkInfo.source, "initialRoI");
    if( ! roi.isValid()) continue;                                                              
    if( (*roi.link)->roiWord() == (*initRoi.link)->roiWord() )
      vec.push_back( featLinkInfo );
  }
  return vec;
}
 
 
 
 
 
// L1Calo
template<>
inline TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection> TrigEgammaMatchingToolMT::getFeature<TrigRoiDescriptorCollection>( const TrigCompositeUtils::Decision *dec , 
                                                                                                                const std::string& trigger, unsigned int condition)
const
{
  auto initRoi = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(dec, "initialRoI"); 
 
  if( initRoi.isValid() ){
    // includeFailedDecisions
 
    auto vec_dec =  tdt()->features<TrigRoiDescriptorCollection>(trigger, condition,"",TrigDefs::allFeaturesOfType,"initialRoI");
    for( auto &featLinkInfo: vec_dec ){
      if( !featLinkInfo.isValid() ) continue;
      if( (*featLinkInfo.link)->roiWord() == (*initRoi.link)->roiWord() )  return featLinkInfo; 
    }
  }
 
  return TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>();
}
 
 
// L2Calo
template<>
inline TrigCompositeUtils::LinkInfo<xAOD::TrigEMClusterContainer> TrigEgammaMatchingToolMT::getFeature<xAOD::TrigEMClusterContainer>( const TrigCompositeUtils::Decision *dec , 
                                                                                                                  const std::string& trigger, unsigned int condition)
const
{
  std::vector<TrigCompositeUtils::LinkInfo<xAOD::TrigEMClusterContainer>> vec = getFeatures<xAOD::TrigEMClusterContainer>(dec, trigger, key("FastCalo") , condition);
  return !vec.empty() ? vec.front() : TrigCompositeUtils::LinkInfo<xAOD::TrigEMClusterContainer>();
}
 
 
// L2Electron
template<>
inline std::vector<TrigCompositeUtils::LinkInfo<xAOD::TrigElectronContainer>> TrigEgammaMatchingToolMT::getFeatures<xAOD::TrigElectronContainer>( 
                                                                const TrigCompositeUtils::Decision *dec , const std::string& trigger, unsigned int condition)
const
{
  if(boost::contains(trigger,"lrt")){
    return getFeatures<xAOD::TrigElectronContainer>(dec, trigger, key("FastElectrons_LRT"), condition);
  }else{
    return getFeatures<xAOD::TrigElectronContainer>(dec, trigger, key("FastElectrons"), condition);
  }
}
 
 
// L2Photon
template<>
inline TrigCompositeUtils::LinkInfo<xAOD::TrigPhotonContainer> TrigEgammaMatchingToolMT::getFeature<xAOD::TrigPhotonContainer>( 
                                                                const TrigCompositeUtils::Decision *dec , const std::string& trigger, unsigned int condition)
const
{
  auto vec = getFeatures<xAOD::TrigPhotonContainer>(dec, trigger, key("FastPhotons") , condition);
  return !vec.empty() ? vec.front() : TrigCompositeUtils::LinkInfo<xAOD::TrigPhotonContainer>();
}
 
 
// EFCalo
template<>
inline std::vector<TrigCompositeUtils::LinkInfo<xAOD::CaloClusterContainer>> TrigEgammaMatchingToolMT::getFeatures<xAOD::CaloClusterContainer>( 
                                                                const TrigCompositeUtils::Decision *dec , const std::string& trigger, unsigned int condition)
const
{
  std::vector<std::string> parts;
  boost::split(parts,trigger,boost::is_any_of("_"));
 
  if(boost::contains(trigger,"lrt")){
    return getFeatures<xAOD::CaloClusterContainer>(dec, trigger, key("PrecisionCalo_LRT"), condition );
  }else if(boost::contains(parts.at(0),"g")){
    return getFeatures<xAOD::CaloClusterContainer>(dec, trigger, key("PrecisionCalo_Photon"), condition );
  }else{
    return getFeatures<xAOD::CaloClusterContainer>(dec, trigger, key("PrecisionCalo_Electron"), condition );
  }
 
}
 
 
 
// Electron
template<>
inline std::vector<TrigCompositeUtils::LinkInfo<xAOD::ElectronContainer>> TrigEgammaMatchingToolMT::getFeatures<xAOD::ElectronContainer>( 
                                                                const TrigCompositeUtils::Decision *dec , const std::string& trigger, unsigned int condition)
const
{
  if (boost::contains(trigger,"gsf")){
    return getFeatures<xAOD::ElectronContainer>(dec, trigger, key("Electrons_GSF") , condition);
  }else if(boost::contains(trigger,"lrt")){
    return getFeatures<xAOD::ElectronContainer>(dec, trigger, key("Electrons_LRT") , condition);
  }else{
    return getFeatures<xAOD::ElectronContainer>(dec, trigger, key("Electrons") , condition);
  }
}
 
 
// Photon
template<>
inline std::vector<TrigCompositeUtils::LinkInfo<xAOD::PhotonContainer>> TrigEgammaMatchingToolMT::getFeatures<xAOD::PhotonContainer>( const TrigCompositeUtils::Decision *dec , 
                                                                                                                  const std::string& trigger, unsigned int condition)
const
{
  return getFeatures<xAOD::PhotonContainer>(dec, trigger, key("Photons"), condition );
}