EMTrackMatchBuilder.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EGAMMATOOLS_EMTRACKMATCHBUILDER_H
#define EGAMMATOOLS_EMTRACKMATCHBUILDER_H

 
// INCLUDE HEADER FILES:
#include "egammaInterfaces/IEMExtrapolationTools.h"
#include "egammaInterfaces/IEMTrackMatchBuilder.h"
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/ToolHandle.h"
#include "egammaRecEvent/egammaRecContainer.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "TrkEventPrimitives/PropDirection.h"
#include "xAODCaloEvent/CaloClusterFwd.h"
#include "xAODTracking/TrackParticleContainerFwd.h"
 
namespace Reco {
class ITrackToVertex;
}
 
class CaloDetDescrManager;
 
class EMTrackMatchBuilder final
  : public AthAlgTool
  , virtual public IEMTrackMatchBuilder
{
 
public:
  EMTrackMatchBuilder(const std::string& type,
                      const std::string& name,
                      const IInterface* parent);

  virtual ~EMTrackMatchBuilder() = default;

  StatusCode initialize() override final;
  virtual StatusCode executeRec(
    const EventContext& ctx,
    EgammaRecContainer* egammas) const override final;
 
private:
  StatusCode trackExecute(const EventContext& ctx,
                          egammaRec* eg,
                          const xAOD::TrackParticleContainer* trackPC,
                          const CaloDetDescrManager& caloDD) const;

  struct TrackMatch
  {
  public:
    bool hasPix;
    int trackNumber;
    int hitsScore;
    double dR;
    double seconddR;
    double deltaPhiLast;
    std::array<double, 4> deltaEta;
    std::array<double, 4> deltaPhi;
    std::array<double, 4> deltaPhiRescaled;
  };

  class TrackMatchSorter
  {
  public:
    TrackMatchSorter(double distance = 0.0)
      : m_distance(distance){};
    bool operator()(const TrackMatch& match1, const TrackMatch& match2) const;
 
  private:
    double m_distance;
  };

  bool inBroadWindow(const EventContext& ctx,
                     std::vector<TrackMatch>& trackMatches,
                     const xAOD::CaloCluster& cluster,
                     int trackNumber,
                     const xAOD::TrackParticle& trkPB,
                     const CaloDetDescrManager& caloDD) const;

  bool isCandidateMatch(const xAOD::CaloCluster* cluster,
                        const xAOD::TrackParticle* track,
                        bool flip) const;
 
  // configuration:
  SG::ReadHandleKey<xAOD::TrackParticleContainer> m_TrackParticlesKey{
    this,
    "TrackParticlesName",
    "",
    "Name of the input track particle container"
  };
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloDetDescrMgrKey{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  };

  Gaudi::Property<double> m_broadDeltaEta{ this,
                                           "broadDeltaEta",
                                           0.1,
                                           "Value of broad cut for delta eta" };

  Gaudi::Property<double> m_broadDeltaPhi{ this,
                                           "broadDeltaPhi",
                                           0.1,
                                           "Value of broad cut for delta phi" };

  Gaudi::Property<double> m_narrowDeltaEta{
    this,
    "narrowDeltaEta",
    0.05,
    "Value of narrow cut for delta eta"
  };

  Gaudi::Property<double> m_narrowDeltaPhi{
    this,
    "narrowDeltaPhi",
    0.05,
    "Value of the narrowd cut for delta phi"
  };

  Gaudi::Property<double> m_narrowDeltaPhiBrem{
    this,
    "narrowDeltaPhiBrem",
    0.1,
    "Value of the narrow cut for delta phi  Brem"
  };

  Gaudi::Property<double> m_narrowDeltaPhiRescale{
    this,
    "narrowDeltaPhiRescale",
    0.05,
    "Value of the narrow cut for delta phi Rescale"
  };

  Gaudi::Property<double> m_narrowDeltaPhiRescaleBrem{
    this,
    "narrowDeltaPhiRescaleBrem",
    0.1,
    "Value of the narrow cut for delta phi Rescale Brem"
  };

  Gaudi::Property<double> m_MaxDeltaPhiRescale{
    this,
    "MaxDeltaPhiRescale",
    0.25,
    "Maximum Value of the deltaPhi rescale"
  };

  Gaudi::Property<bool> m_useCandidateMatch{
    this,
    "useCandidateMatch",
    true,
    "Boolean to use candidate matching"
  };

  Gaudi::Property<bool> m_useScoring{
    this,
    "useScoring",
    true,
    "Boolean to apply heuristic when tracks have close deltaR"
  };

  Gaudi::Property<bool> m_useRescaleMetric{ this,
                                            "UseRescaleMetric",
                                            true,
                                            "Use Rescale Metric" };

  Gaudi::Property<bool> m_SecondPassRescale{ this,
                                             "SecondPassRescale",
                                             true,
                                             "Do second pass with rescale" };

  Gaudi::Property<float> m_deltaEtaResolution{ this,
                                               "DeltaEtaResolution",
                                               1.0,
                                               "The deltaEta resolution" };
 
  Gaudi::Property<float> m_deltaPhiResolution{ this,
                                               "DeltaPhiResolution",
                                               1.0,
                                               "The deltaPhi resolution" };
 
  Gaudi::Property<float> m_deltaPhiRescaleResolution{
    this,
    "DeltaPhiRescaleResolution",
    1.0,
    "The deltaPhiRescale resolution"
  };

  Gaudi::Property<float> m_distanceForScore{
    this,
    "DistanceForScore",
    0.01,
    "The distance from which one goes from using better deltaR to using score."
  };
 
  ToolHandle<IEMExtrapolationTools> m_extrapolationTool{
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Name of the extrapolation tool"
  };

  Gaudi::Property<bool> m_isCosmics{ this,
                                     "isCosmics",
                                     false,
                                     "Boolean for use of cosmics" };
 
  // Calculated values based on resolutions
  double m_deltaEtaWeight{};
  double m_deltaPhiWeight{};
  double m_deltaPhiRescaleWeight{};
 
  TrackMatchSorter m_sorter;
};
 
#endif