InDetTrackPerfMonTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/


#include "InDetTrackPerfMonTool.h"

#include "GaudiKernel/SystemOfUnits.h"

#include "xAODEventInfo/EventInfo.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTruth/TruthParticleContainer.h"

#include <algorithm>
#include <limits>
#include <cmath> // to get std::isnan(), std::abs etc.
#include <utility>
#include <cstdlib> // to getenv
 

InDetTrackPerfMonTool::InDetTrackPerfMonTool(
    const std::string& type,
    const std::string& name,
    const IInterface* parent ) :
        ManagedMonitorToolBase( type, name, parent )
{ }
 

InDetTrackPerfMonTool::~InDetTrackPerfMonTool() = default;
 

StatusCode InDetTrackPerfMonTool::initialize() {
 
  ATH_CHECK( ManagedMonitorToolBase::initialize() );

  if( not m_trkAnaDefSvc ) {
    ATH_MSG_DEBUG( "Retrieving TrkAnaDefSvc" << m_anaTag.value() );
    m_trkAnaDefSvc = Gaudi::svcLocator()->service( "TrkAnaDefSvc"+m_anaTag.value() );
    ATH_CHECK( m_trkAnaDefSvc.isValid() );
  }
 
  ATH_MSG_DEBUG( "Initializing sub-tools" );
 
  ATH_CHECK( m_trigDecTool.retrieve( EnableTool{ m_trkAnaDefSvc->doTrigNavigation() } ) );
  ATH_CHECK( m_trackQualitySelectionTool.retrieve() );
  ATH_CHECK( m_vertexQualitySelectionTool.retrieve() );
  ATH_CHECK( m_roiSelectionTool.retrieve( EnableTool{ m_trkAnaDefSvc->doTrigNavigation() } ) );
  ATH_CHECK( m_trackRoiSelectionTool.retrieve( EnableTool{ m_trkAnaDefSvc->doTrigNavigation() } ) );
  ATH_CHECK( m_vertexRoiSelectionTool.retrieve( EnableTool{ m_trkAnaDefSvc->doTrigNavigation() } ) );
  ATH_CHECK( m_trackMatchingTool.retrieve( EnableTool{ m_doMatch.value() } ) );
  ATH_CHECK( m_trkAnaInfoWriteTool.retrieve( EnableTool{ m_writeOut.value() } ) );
 
  ATH_MSG_DEBUG( "Initializing collections" );

  ATH_CHECK( m_eventInfoContainerName.initialize() );
  ATH_CHECK( m_truthEventName.initialize(
      m_trkAnaDefSvc->useTruth() and not m_truthEventName.key().empty() ) );
  ATH_CHECK( m_truthPileUpEventName.initialize(
      m_trkAnaDefSvc->useTruth() and not m_truthPileUpEventName.key().empty() and
      m_trkAnaDefSvc->hasFullPileupTruth() ) );

  ATH_CHECK( m_offlineTrkParticleName.initialize(
      m_trkAnaDefSvc->useOffline() and not m_offlineTrkParticleName.key().empty() ) );
  ATH_CHECK( m_triggerTrkParticleName.initialize(
      m_trkAnaDefSvc->useTrigger() and not m_triggerTrkParticleName.key().empty() ) );
  ATH_CHECK( m_truthParticleName.initialize(
      m_trkAnaDefSvc->useTruth() and not m_truthParticleName.key().empty() ) );

  ATH_CHECK( m_offlineVertexContainerName.initialize( 
      m_trkAnaDefSvc->useOffline() and not m_offlineVertexContainerName.key().empty() ) );
  ATH_CHECK( m_triggerVertexContainerName.initialize(
      m_trkAnaDefSvc->useTrigger() and not m_triggerVertexContainerName.key().empty() ) );
  ATH_CHECK( m_truthVertexContainerName.initialize(
      m_trkAnaDefSvc->useTruth() and not m_truthVertexContainerName.key().empty() ) );

  ATH_CHECK( m_trkAnaInfoKey.initialize() );

  const std::vector< std::string >& configuredChains = m_trkAnaDefSvc->configuredChains();
  m_trkAnaPlotsMgrVec.reserve( configuredChains.size() );

  for( const std::string& thisChain : configuredChains ) {
    ATH_MSG_DEBUG( "Booking TrkAnalysis/histograms for chain : " << thisChain );

    m_trkAnaPlotsMgrVec.emplace_back(
        std::make_unique< IDTPM::TrackAnalysisPlotsMgr >(
            m_trkAnaDefSvc->plotsFullDir( thisChain ),
            m_anaTag.value(),
            thisChain ) );
  } // close m_configuredChains loop 
 
  return StatusCode::SUCCESS;
}
 

StatusCode InDetTrackPerfMonTool::bookHistograms()
{
  ATH_MSG_DEBUG( "Booking plots" );
 
  for( size_t iAna=0 ; iAna < m_trkAnaPlotsMgrVec.size() ; iAna++ ) {

    ATH_CHECK( m_trkAnaPlotsMgrVec[iAna]->initialize() );

    std::vector< HistData > hists = m_trkAnaPlotsMgrVec[iAna]->retrieveBookedHistograms();
    for ( size_t ih=0 ; ih<hists.size() ; ih++ ) {
      ATH_CHECK( regHist( hists[ih].first, hists[ih].second, all ) );
    }
 
    // do the same for Efficiencies, but there's a twist:
    std::vector< EfficiencyData > effs = m_trkAnaPlotsMgrVec[iAna]->retrieveBookedEfficiencies();
    for ( size_t ie=0 ; ie<effs.size() ; ie++ ) {
      ATH_CHECK( regEfficiency( effs[ie].first, MonGroup( this, effs[ie].second, all ) ) );
    }
 
  } // closing loop over TrkAnalyses
  
  return StatusCode::SUCCESS;
}
 

StatusCode InDetTrackPerfMonTool::fillHistograms() {
 
  ATH_MSG_DEBUG("Filling hists " << name() << " ...");

  SG::WriteHandle< xAOD::BaseContainer > outTrkAnaInfoContHandle( m_trkAnaInfoKey );
  if( m_writeOut ) {
    ATH_CHECK( outTrkAnaInfoContHandle.record(
                  std::make_unique< xAOD::BaseContainer >(),
                  std::make_unique< xAOD::AuxContainerBase >() ) );
  }

  IDTPM::TrackAnalysisCollections thisTrkAnaCollections( m_anaTag.value() );
  ATH_CHECK( thisTrkAnaCollections.initialize() );

  ATH_CHECK( loadCollections( thisTrkAnaCollections ) );
 
  ATH_MSG_DEBUG( "Processing event = " <<
                 thisTrkAnaCollections.eventInfo()->eventNumber() <<
                 "\n==========================================" );
  ATH_MSG_DEBUG( "ALL Track Info: " << thisTrkAnaCollections.printInfo() );

  if( thisTrkAnaCollections.empty() ) {
    ATH_MSG_DEBUG( "Some FULL collections are empty." );
  }

  ATH_CHECK( m_trackQualitySelectionTool->selectTracks( thisTrkAnaCollections ) );

  if( thisTrkAnaCollections.empty( IDTPM::TrackAnalysisCollections::FS ) ) {
    ATH_MSG_DEBUG( "Some collections are empty after quality selection." );
  }

  ATH_CHECK( m_vertexQualitySelectionTool->selectVertices( thisTrkAnaCollections ) );

  for( size_t iAna=0 ; iAna < m_trkAnaPlotsMgrVec.size() ; iAna++ ) {
 
    const std::string& thisChain = m_trkAnaPlotsMgrVec[iAna]->chain();
    ATH_MSG_DEBUG( "Processing chain = " << thisChain );


    if( m_trkAnaDefSvc->doTrigNavigation() and 
        not thisChain.empty() and thisChain != "Offline" ) {
 
      unsigned decisionType = TrigDefs::Physics; // TrigDefs::includeFailedDecisions;
 
      if( not m_trigDecTool->isPassed( thisChain, decisionType ) ) {
        ATH_MSG_DEBUG( "Trigger chain " << thisChain << " is not fired. Skipping" );
        continue;
      }
    }

    std::vector< TrigCompositeUtils::LinkInfo< TrigRoiDescriptorCollection > > selectedRois;
    size_t selectedRoisSize(1); // by default only one "dummy" RoI, i.e. for offline analysis
 
    if( m_trkAnaDefSvc->doTrigNavigation() ) {
      selectedRois = m_roiSelectionTool->getRois( thisChain ); 
      selectedRoisSize = selectedRois.size();
    }

    for( size_t ir=0 ; ir<selectedRoisSize ; ir++ ) {

      thisTrkAnaCollections.clear( IDTPM::TrackAnalysisCollections::InRoI );

      ElementLink< TrigRoiDescriptorCollection > thisRoiLink;
      std::string thisRoiStr( "Full Scan" );
      if( m_trkAnaDefSvc->doTrigNavigation() ) {
        thisRoiLink = selectedRois.at(ir).link;

        if( not thisRoiLink.isValid() ) {
          ATH_MSG_WARNING( "Found non-valid RoI ElementLink" );
          continue;
        }

        thisRoiStr = std::string( **thisRoiLink.cptr() );
      }
 
      ATH_MSG_DEBUG( "Processing selected RoI : " << thisRoiStr );

      if( m_trkAnaDefSvc->doTrigNavigation() ) {
        ATH_CHECK( m_trackRoiSelectionTool->selectTracksInRoI(
                          thisTrkAnaCollections, thisRoiLink ) );

        ATH_CHECK( m_vertexRoiSelectionTool->selectVerticesInRoI(
                          thisTrkAnaCollections, thisRoiLink ) );
      } else {
        thisTrkAnaCollections.copyFS();
      }

      if( thisTrkAnaCollections.empty( IDTPM::TrackAnalysisCollections::InRoI ) ) {
        ATH_MSG_DEBUG( "Some collections are empty after RoI selection." );
      }

      std::string chainRoIName = thisChain;
      if( m_trkAnaDefSvc->doTrigNavigation() ) {
        chainRoIName += "_RoI_"+std::to_string(ir);
      }
 
      if( m_doMatch.value() ) {
        ATH_MSG_DEBUG( "Doing Test-Reference matching..." );
        ATH_CHECK( m_trackMatchingTool->match( thisTrkAnaCollections,
                                               chainRoIName, thisRoiStr ) );
      }

      ATH_CHECK( m_trkAnaPlotsMgrVec[iAna]->fill( thisTrkAnaCollections ) );

      if( m_writeOut ) {
        ATH_CHECK( m_trkAnaInfoWriteTool->write( outTrkAnaInfoContHandle,
                                                 thisTrkAnaCollections,
                                                 thisChain, ir, thisRoiStr ) );
      }
 
      thisTrkAnaCollections.newRoI();
    } // close selectedRois loop
 
    thisTrkAnaCollections.newChain();
  } // close TrkAnalyses loop 
 
  if( m_writeOut ) {
    ATH_MSG_DEBUG( m_trkAnaInfoWriteTool->printInfo( outTrkAnaInfoContHandle ) );
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode InDetTrackPerfMonTool::procHistograms() {
 
  ATH_MSG_DEBUG( "Finalizing plots" );
 
  if( endOfRunFlag() ) {
    for( size_t iAna=0 ; iAna < m_trkAnaPlotsMgrVec.size() ; iAna++ ) {
      m_trkAnaPlotsMgrVec[iAna]->finalize();
    }
  }
 
  ATH_MSG_DEBUG( "Successfully finalized hists" );
 
  return StatusCode::SUCCESS;
}
 

StatusCode InDetTrackPerfMonTool::loadCollections( IDTPM::TrackAnalysisCollections& trkAnaColls ) {
 
  ATH_MSG_DEBUG( "Loading collections" );

  ATH_CHECK( trkAnaColls.fillEventInfo(
      m_eventInfoContainerName, m_truthEventName, m_truthPileUpEventName ) );

  ATH_CHECK( trkAnaColls.fillTruthPartContainer( m_truthParticleName ) );
  ATH_CHECK( trkAnaColls.fillOfflTrackContainer( m_offlineTrkParticleName ) );
  ATH_CHECK( trkAnaColls.fillTrigTrackContainer( m_triggerTrkParticleName ) );

  ATH_CHECK( trkAnaColls.fillTruthVertexContainer( m_truthVertexContainerName ) );
  ATH_CHECK( trkAnaColls.fillOfflVertexContainer( m_offlineVertexContainerName ) );
  ATH_CHECK( trkAnaColls.fillTrigVertexContainer( m_triggerVertexContainerName ) );
 
  return StatusCode::SUCCESS;
}