EMConversionBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EGAMMATOOLS_EMCONVERSIONBUILDER_H
#define EGAMMATOOLS_EMCONVERSIONBUILDER_H
 
#include "egammaInterfaces/IEMConversionBuilder.h"
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "StoreGate/ReadHandleKey.h"
 
#include "egammaInterfaces/IEMExtrapolationTools.h"
#include "xAODCaloEvent/CaloClusterFwd.h"
#include "xAODTracking/VertexContainerFwd.h"
 
class EMConversionBuilder final
  : public AthAlgTool
  , virtual public IEMConversionBuilder
{
 
public:
  EMConversionBuilder(const std::string& type,
                      const std::string& name,
                      const IInterface* parent);

  virtual ~EMConversionBuilder() = default;

  StatusCode initialize() override final;
  virtual StatusCode executeRec(const EventContext& ctx,
                                egammaRec* egRec) const override final;
 
private:
  StatusCode vertexExecute(const EventContext& ctx,
                           egammaRec* egRec,
                           const xAOD::VertexContainer* conversions) const;

  bool passPtAndEoverP(const EventContext& ctx,
                       const xAOD::Vertex&,
                       const xAOD::CaloCluster&) const;

  float getMaxTRTTubeHitFraction(const xAOD::Vertex& vertex) const;
 
  // configuration:
  SG::ReadHandleKey<xAOD::VertexContainer> m_conversionContainerKey{
    this,
    "ConversionContainerName",
    "PhotonConversionVertices",
    "Name of the input conversion container"
  };

  ToolHandle<IEMExtrapolationTools> m_extrapolationTool{
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Handle of the extrapolation tool"
  };

  Gaudi::Property<bool> m_rejectAllTRT{
    this,
    "RejectAllTRTConversions",
    false,
    "Ignore all conversion vertices containing exclusively TRT-only tracks"
  };

  Gaudi::Property<int> m_minTRTHits{
    this,
    "minTRTHits",
    0,
    "minimum number of TRT hits for TRT-only tracks (both single and double "
    "track conversion vertices)"
  };

  Gaudi::Property<float> m_minPt_singleTrack{
    this,
    "minPt_singleTrack",
    0 * Gaudi::Units::GeV,
    "minimum pT for single-track conversion vertices"
  };

  Gaudi::Property<float> m_minPt_singleTRT{
    this,
    "minPt_singleTRT",
    2 * Gaudi::Units::GeV,
    "minimum pT for TRT-only single-track conversion vertices"
  };

  Gaudi::Property<float> m_minTRTonlyTrackPt{
    this,
    "minTRTonlyTrackPt",
    0 * Gaudi::Units::GeV,
    "minimum pT for each track in TRT-only double-track conversion vertices"
  };

  Gaudi::Property<float> m_minSumPt_double{
    this,
    "minSumPt_double",
    0 * Gaudi::Units::GeV,
    "minimum sum pT for double track conversion vertices"
  };

  Gaudi::Property<float> m_minSumPt_doubleTRT{
    this,
    "minSumPt_doubleTRT",
    2 * Gaudi::Units::GeV,
    "minimum sum pT for double TRT track conversion vertices"
  };

  Gaudi::Property<float> m_maxEoverP_singleTrack{
    this,
    "maxEoverP_singleTrack",
    10.,
    "Maximum E/p for single track conversion vertices"
  };

  Gaudi::Property<float> m_maxEoverP_singleTrack_EtSf{
    this,
    "maxEoverP_singleTrack_EtSf",
    0.01,
    "Scale maxEoverP_singleTrack by ( 1+sf*Et(cluster)/GeV )"
  };

  Gaudi::Property<float> m_maxTRTTubeHitFraction{
    this,
    "maxTRTTubeHitFraction",
    999.,
    "Maximum fraction of tube hits for vertices with TRT tracks"
  };
  // for 21.0.X: minTRTPrecisionFraction cut applied
  // InDetTRT_StandaloneScoringTool
};
 
#endif