ElectronJetDRAssociator.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "ElectronJetDRAssociator.h"
#include "D3PDMakerInterfaces/ICollectionGetterTool.h"
#include "D3PDMakerInterfaces/ICollectionGetterRegistryTool.h"
#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
#include "xAODTracking/Vertex.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTracking/TrackParticle.h"
#include <cmath>
 
 
namespace D3PD {
 

ElectronJetDRAssociator::ElectronJetDRAssociator (const std::string& type,
                                                  const std::string& name,
                                                  const IInterface* parent)
  : Base (type, name, parent),
    m_target(0),
    m_eg(0)
{
  declareProperty ("Target", m_targetLabel,
                   "Target label for the getter for the jets to which"
                   " to associate.");
 
  declareProperty ("VertexContainerName", 
                   m_vertexContainerName = "VxPrimaryCandidate",
                   "Primary vertex container name");
 
  declareProperty ("DRCut",  m_drcut = 0.7,
                   "DR cut between electrons and jets");
 
  declareProperty ("CollectionGetterRegistry", m_registry,
                   "The ICollectionGetterRegistryTool instance.");
 
  book().ignore();  // Avoid coverity warnings.
}
  
  
StatusCode ElectronJetDRAssociator::initialize()
{
  CHECK( m_trackToVertexIPEstimator.retrieve() );
  CHECK( Base::initialize() );
  return StatusCode::SUCCESS;
}
 

StatusCode ElectronJetDRAssociator::configureD3PD (IAddVariable* tree,
                                                   const std::type_info& ti)
{
  CHECK( m_registry.retrieve() );
  CHECK( m_registry->get (m_targetLabel, this, m_target) );
  CHECK( Base::configureD3PD (tree, ti) );
  return StatusCode::SUCCESS;
}
 
  
StatusCode ElectronJetDRAssociator::reset (const xAOD::Electron& eg)
{
  m_eg = &eg;
  if (m_target)
    CHECK( m_target->reset (true) );
  return StatusCode::SUCCESS;
}
  

const xAOD::Jet* ElectronJetDRAssociator::next()
{
  if (!m_target) return 0;
 
  const xAOD::CaloCluster * clus= m_eg->caloCluster();
  if (!clus){
    ATH_MSG_WARNING("No cluster from the electron found!");
    return 0;
  }
 
  while (const xAOD::Jet* myjet = m_target->next<xAOD::Jet>()) {
 
    float dr = hypot (clus->p4().DeltaPhi(myjet->p4()),
                      myjet->eta() - clus->etaBE(2));
    ATH_MSG_DEBUG("The value of DR between Electron and Jet is dr= "<<dr);
    if (dr < m_drcut) {
      float signedIP=-9999.9;
      float PTRel=-9999.9;
      float reducedPt=-9999.9;
      ATH_MSG_DEBUG("CATA egamma pt clus " << clus->et() );
      if( findSignedIPAndPTRelEleJetPair( m_eg, myjet,
                                          signedIP, PTRel ).isFailure() )
      {
        continue;
      }
      if ( findReducedPt ( m_eg, myjet, reducedPt ).isFailure() )
    {
      continue;
    }
 
      *m_signedIP = signedIP;
      *m_ptrel = PTRel;
      *m_dr = dr;
      *m_jetSize = myjet->numConstituents();
      *m_reducedPt = reducedPt;
 
      return myjet;
    }
  }
  
  return 0;
}
  

StatusCode ElectronJetDRAssociator::book()
{
  CHECK( addVariable( "dr" , m_dr,
                      "DR between electron and associated jet.") );
  CHECK( addVariable( "signedIP" , m_signedIP,
                      "Signed impact parameter between electron and jet.") );
  CHECK( addVariable( "ptrel", m_ptrel,
                      "Relative Pt between electron and jet.") );
  CHECK( addVariable( "jetSize", m_jetSize,
              "Number of jet constituents.") );
  CHECK( addVariable( "reducedPt", m_reducedPt,
              "Jet Pt with electron removed.") );
  CHECK( Base::book() );
  return StatusCode::SUCCESS;
}
  
StatusCode
ElectronJetDRAssociator::findReducedPt (const xAOD::Electron* eg,
                                        const xAOD::Jet* j,
                                        float& reducedPt  )
{
  reducedPt=-9999.;
 
  if ( !eg || !j )
    return StatusCode::SUCCESS;
 
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track) {
    // Could legitimately be 0 for forward electrons...
    return StatusCode::SUCCESS;
  }
 
  float px = j->px() - track->p4().Px();
  float py = j->py() - track->p4().Py();
  reducedPt = hypot (px, py);
  
  return StatusCode::SUCCESS;
}
 

StatusCode
ElectronJetDRAssociator::findSignedIPAndPTRelEleJetPair (const xAOD::Electron* eg,
                                                         const xAOD::Jet* j0,
                                                         float& signedIP,
                                                         float& PTRel  )
{
  signedIP=-9999;
  PTRel =-9999;
 
  if( j0==0 )
    return StatusCode::SUCCESS;
 
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track) {
    // Could legitimately be 0 for forward electrons...
    return StatusCode::SUCCESS;
  }
 
  PTRel= track->p4().Perp (j0->p4().Vect());
 
  CLHEP::Hep3Vector jetDirection( (j0)->px(), (j0)->py(), (j0)->pz());
  CLHEP::Hep3Vector unit = jetDirection.unit();
 
  if (!evtStore()->contains<xAOD::VertexContainer>(m_vertexContainerName))
    return StatusCode::SUCCESS;
 
  const xAOD::Vertex* vx = 0;
  {
    const xAOD::VertexContainer * vxcontainer = nullptr;
    if ( evtStore()->retrieve(vxcontainer, m_vertexContainerName).isFailure() )
      REPORT_MESSAGE (MSG::WARNING)
        << "Vertex container " << m_vertexContainerName 
        << " not found in StoreGate!";
    else if (!vxcontainer->empty())
      vx = vxcontainer->front();
  }
 
  if (!vx) {
    REPORT_MESSAGE (MSG::WARNING)
      << "No vertex found.";
    return StatusCode::SUCCESS;
  }
 
  signedIP = m_trackToVertexIPEstimator->get2DLifetimeSignOfTrack
    (track->perigeeParameters(), unit, *vx);
    
  return StatusCode::SUCCESS;
}
 
 
} // namespace D3PD