InDetSecVtxTrackSelectionTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
//Author: Lianyou Shan <lianyou.shan@cern.ch>
 
#include "InDetSecVtxTrackSelectionTool/InDetSecVtxTrackSelectionTool.h"
#include "InDetSecVtxTrackCut.h"
 
#include "AsgMessaging/Check.h"
#include "xAODTracking/TrackingPrimitives.h"
#ifndef XAOD_ANALYSIS
#include "TrkTrack/Track.h"
#include "VxVertex/Vertex.h"
#include "TrkTrackSummary/TrackSummary.h"
#endif
 
#include <memory>
 
InDet::InDetSecVtxTrackSelectionTool::InDetSecVtxTrackSelectionTool(const std::string& name )
  : asg::AsgTool(name) 
  , m_acceptInfo( "InDetSecVtxTrackSelection" )
{
 
#ifndef XAOD_STANDALONE
  declareInterface<IInDetTrackSelectionTool>(this);
#endif
 
}
 
// we must define the destructor in order to use forward-declaration with unique_ptr
InDet::InDetSecVtxTrackSelectionTool::~InDetSecVtxTrackSelectionTool() = default;
 
StatusCode InDet::InDetSecVtxTrackSelectionTool::initialize() {
  // Make sure we haven't already been initialized - this would be a sign of improper usage.
  StatusCode ini = StatusCode::SUCCESS ;
  if (m_isInitialized) {
    ATH_MSG_ERROR( "Tool has already been initialized. This is illegitimate." );
    ATH_MSG_ERROR( "This call to initialize() will do nothing." );
    return ini;
  }
 
  // Greet the user:
  ATH_CHECK( asg::AsgTool::initialize() );
 
  // if the CutLevel string is set to something recognizable,
  // then do a soft set on the cuts (i.e. not overwriting those already set)
 
  if ( m_minD0 >= 0 ) 
  {
    ATH_MSG_DEBUG( "  Maximum on d0: " << m_minD0 << " mm" );
    m_trackCuts["D0"].push_back(std::make_unique<D0minCut>(this, m_minD0));
  }
 
  if ( m_NPixel0TRT > 0 )
  {
    ATH_MSG_DEBUG( "  Minimum number of Pixel hit when TRT has zero hit: " << m_NPixel0TRT  );
 
    auto minPixelHits = std::make_unique< FuncSummaryValueCut<3> >
    (  this, std::array<xAOD::SummaryType,3>
             (  
               { xAOD::numberOfTRTHits, xAOD::numberOfPixelHits, xAOD::numberOfPixelDeadSensors } 
//  eta acceptance and outliers are ignored for TRT  
             ) 
    );
 
    minPixelHits->setFunction( [=] (const std::array<uint8_t, 3>& vals )
     {  return ( vals[0] > 0 ) || ( ( vals[1] >= m_NPixel0TRT ) || ( vals[2] >= m_NPixel0TRT ) ) ; } 
                             );
 
    m_trackCuts["minPixelHits0TRT"].push_back( std::move( minPixelHits ) );
 
  }
 
  if ( m_minInDetHits > 0 )
  {
    ATH_MSG_DEBUG( "  Minimum number of Pixel + SCT + TRT hits: " << m_minInDetHits  );
 
    auto mintotHits = std::make_unique< FuncSummaryValueCut<4> >
    (  this, std::array<xAOD::SummaryType,4>
             (
               { xAOD::numberOfInnermostPixelLayerHits, xAOD::numberOfPixelHits, 
                 xAOD::numberOfSCTHits, xAOD::numberOfTRTHits }
             )
    );
 
    mintotHits->setFunction( [=] (const std::array<uint8_t, 4>& vals )
      {  return ( vals[0] + vals[1] + vals[2] + vals[3] ) >= m_minInDetHits ; }
    );
 
    m_trackCuts["minTotalHits"].push_back( std::move( mintotHits ) );
  }
 
 
  //  std::lock_guard<std::mutex> lock{m_mutex};
  for (const auto& cutFamily : m_trackCuts) {
    for (const auto& cut : cutFamily.second) {
      ATH_CHECK( cut->initialize() );
    }
    const std::string& cutFamilyName = cutFamily.first;
    //    m_numTracksPassedCuts.push_back(0);
    if (m_acceptInfo.addCut( cutFamilyName, "Selection of SecVtx tracks according to " + cutFamilyName ) < 0) {
      ATH_MSG_ERROR( "Failed to add cut family " << cutFamilyName << " because the TAccept object is full." );
      return StatusCode::FAILURE;
    }
    ATH_MSG_VERBOSE("Adding cut family " << cutFamilyName);
  }
 
  m_isInitialized = true;
  
  return ini ;
}
  
StatusCode InDet::InDetSecVtxTrackSelectionTool::finalize()
{
  StatusCode fin = StatusCode::SUCCESS ;
 
  if (!m_isInitialized) {
    ATH_MSG_ERROR( "You are attempting to finalize a tool that has not been initialized()." );
  }
 
  if (m_numTracksProcessed == 0) {
    ATH_MSG_INFO( "No tracks processed in selection tool." );
    return fin ;
  }
  ATH_MSG_DEBUG( m_numTracksPassed << " / " << m_numTracksProcessed << " = "
        << m_numTracksPassed*100./m_numTracksProcessed << "% passed all cuts." );
 
  return fin ; 
 
}
 
 
const asg::AcceptInfo& InDet::InDetSecVtxTrackSelectionTool::getAcceptInfo() const
{  
  return m_acceptInfo;
}
 
 
asg::AcceptData
InDet::InDetSecVtxTrackSelectionTool::accept( const xAOD::IParticle* p ) const
{
  asg::AcceptData acceptData(&m_acceptInfo);     
  // Check if this is a track:
  if( p->type() != xAOD::Type::TrackParticle ) {
    ATH_MSG_ERROR( "accept(...) Function received a non-track" );
    return acceptData;
  }
    
  // Cast it to a track (we have already checked its type so we do not have to dynamic_cast):
  const xAOD::TrackParticle* trk = static_cast< const xAOD::TrackParticle* >( p );
    
  // Let the specific function do the work:
//#ifndef XAOD_ANALYSIS
//  m_accept = m_trkFilter->accept( *trk, nullptr );
//  if ( ! (bool)( m_accept ) ) return m_accept ;
//#endif
 
  return accept( *trk, nullptr );
}
 
 
asg::AcceptData InDet::InDetSecVtxTrackSelectionTool::accept( const xAOD::TrackParticle& trk,
                                 const xAOD::Vertex* vtx ) const
{
  if (!m_isInitialized) {
    if (!m_warnInit) {
      ATH_MSG_WARNING( "Tool is not initialized! Calling accept() will not be very helpful." );
      m_warnInit = true;
    }
  }
 
  asg::AcceptData acceptData(&m_acceptInfo);
 
  bool passAll = true;
 
  for ( const auto & accessor : m_trackAccessors ) {
    if( !  accessor.second->access( trk, vtx ).isSuccess() ) {
      ATH_MSG_WARNING("Track access for " << accessor.first << " unsuccessful.");
    }
  }
 
  // loop over all cuts
  UShort_t cutFamilyIndex = 0;
  for ( const auto& cutFamily : m_trackCuts ) {
    bool pass = true;
 
    for ( const auto& cut : cutFamily.second ) {
      if (! cut->result() ) {
    pass = false;
    passAll = false;
    break;
      }
    }
    acceptData.setCutResult( cutFamilyIndex, pass );
    //    if (pass) m_numTracksPassedCuts.at(cutFamilyIndex)++; // number of tracks that pass each cut family
    cutFamilyIndex++;
  }
 
 
  if (passAll) m_numTracksPassed++;
 
  m_numTracksProcessed++;
  
  return acceptData;
}
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
void InDet::InDetSecVtxTrackSelectionTool::setCutLevel(InDet::CutLevel /* level */, Bool_t /* overwrite */)
{
#ifndef XAOD_STANDALONE
  ATH_MSG_WARNING( "InDetTrackSelectionTool::setCutLevel() is not designed to be called manually in Athena." );
  ATH_MSG_WARNING( "It may not behave as intended. Instead, configure it in the job options through the CutLevel property." );
#endif // XAOD_STANDALONE
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
 
 
#ifndef XAOD_ANALYSIS
 
asg::AcceptData
InDet::InDetSecVtxTrackSelectionTool::accept( const Trk::Track& /* track */,
                          const Trk::Vertex* /* vertex */ ) const
{
  if (!m_isInitialized) ATH_MSG_WARNING( "Tool is not initialized! Calling accept() will not be very helpful." );
 
  asg::AcceptData acceptData(&m_acceptInfo);
  
  bool passAll = true;
 
  // for faster lookup in setCutResult we will keep track of the index explicitly
  UShort_t cutFamilyIndex = 0;
  for ( const auto& cutFamily : m_trackCuts ) {
    bool pass = true;
    for ( const auto& cut : cutFamily.second ) {
      if (! cut->result() ) {
    pass = false;
    passAll = false;
    break;
      }
    }
    acceptData.setCutResult( cutFamilyIndex, pass );
    if (pass)
      cutFamilyIndex++;
  }
  
  if (passAll)
    m_numTracksPassed++;
 
  m_numTracksProcessed++;
 
  return acceptData;
}
 
#endif // XAOD_ANALYSIS