TRT_ToT_dEdx.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRT_TOT_DEDX_H
#define TRT_TOT_DEDX_H
 
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "AthenaBaseComps/AthAlgTool.h" //MJ
#include "GaudiKernel/IToolSvc.h"  //MJ
#include "TrkEventPrimitives/ParticleHypothesis.h"
#include "StoreGate/ReadDecorHandleKey.h"
 
#include "TRT_ElectronPidTools/ITRT_ToT_dEdx.h"
 
#include "TrkTrack/Track.h"
 
//gas type selection
#include "TRT_ConditionsServices/ITRT_StrawStatusSummaryTool.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
#include "TRT_ConditionsData/TRTDedxcorrection.h"
#include "TRT_ReadoutGeometry/TRT_DetElementContainer.h"
 
#include "TrkToolInterfaces/IPRD_AssociationTool.h"
#include "TRT_ElectronPidTools/ITRT_LocalOccupancy.h"
 
/*
  Tool to calculate dE/dx variable for PID
  o Variable is based on ToT of hits
  o ToT is calculated from bitpattern using the largest island
  o Two version availlable (ToT and ToT/L averaged over used hits)
  o Corrections availlable for Data and MC for both versions defined above
  o Parameters for correction are currently stored in TRT_ToT_Corrections namespace 
  should probably go to a database 
*/
 
class TRT_ID;
class IChronoStatSvc;
class ITRT_StrawSummaryTool;
 
namespace InDet {
   class ITRT_LocalOccupancy;
}
 
class TRT_ToT_dEdx final : virtual public ITRT_ToT_dEdx, public AthAlgTool 
{
public:
  ToolHandle<ITRT_StrawStatusSummaryTool> m_TRTStrawSummaryTool; 
 
public:
  // enums
  enum EDataBaseType {kOldDB,kNewDB};
  enum EstCalc  {kAlgStandard,kAlgReweight,kAlgReweightTrunkOne};
  enum EOccupancyCorrection{kRSOnly, kHitBased, kTrackBased, kGlobal};
  enum EGasType {kXenon,kArgon,kKrypton,kUnset};
 
private:
  SG::ReadDecorHandleKey<xAOD::EventInfo> m_rdhkEvtInfo {this
      , "averageInteractionsPerCrossingKey"
      , "EventInfo.averageInteractionsPerCrossing"
      , "Decoration for Average Interaction Per Crossing"};
  const TRT_ID* m_trtId;                                                // ID TRT helper 
 
  ToolHandle< Trk::IPRD_AssociationTool >  m_assoTool{this, "AssociationTool","InDet::InDetPRD_AssociationToolGangedPixels","PRD_AssociationTool"};
  ToolHandle< InDet::ITRT_LocalOccupancy > m_localOccTool{this, "TRT_LocalOccupancyTool","", "Local occupancy tool"}; 
 
  // Algorithm switchers
 
  bool m_corrected{};                 // If true - make correction using rs-distributions
  bool m_divideByL{};                 // If true - divide ToT to the L of track in straw.
 
  int  m_useTrackPartWithGasType{};   // If kUnset - use any gas for dEdX calculation;
  int  m_toolScenario{};              // Algorithm type for dEdX estimator calculation;
  int  m_correctionType{};            // Type of dEdx correction
  // Different cases for correctionType            //
  // kRSOnly: only r-S calibration                  //
  // kHitBased: Hit-based occupancy calibration     //
  // kTrackBased: Track-based occupancy calibration //
  // kGlobal: Global occupancy calibration          //
 
 
  // Event info
  bool m_isData{};                  // Is Data?
 
  // Track info
  float m_trackConfig_maxRtrack{};  // maximum track radius
  float m_trackConfig_minRtrack{};  // maximum track radius
 
  bool m_useZeroRHitCut{};  // skip tracks with where RHit=0
 
  unsigned int m_nTrunkateHits = 1;
 
 
public:
  TRT_ToT_dEdx(const std::string&,const std::string&,const IInterface*);
  
  virtual ~TRT_ToT_dEdx();
  virtual StatusCode initialize() override;
 
  using ITRT_ToT_dEdx::dEdx;
  using ITRT_ToT_dEdx::usedHits;
  using ITRT_ToT_dEdx::getTest;
  virtual double dEdx(const EventContext& ctx,
                      const Trk::Track* track,
                      bool useHThits,
                      std::optional<float> localOccupancy = std::nullopt) const override final;
 
  virtual double usedHits(const EventContext& ctx,
                          const Trk::Track* track,
                          bool useHThits = true) const override final;
  virtual double getTest(const EventContext& ctx,
                         const double dEdx_obs,
                         const double pTrk,
                         Trk::ParticleHypothesis hypothesis,
                         Trk::ParticleHypothesis antihypothesis,
                         int nUsedHits) const override final;
 
protected:
  bool isGoodHit(const EventContext& ctx,
                 const Trk::TrackStateOnSurface* trackState,
                 bool useHitsHT,
                 double& length) const;
 
  double correctNormalization(const EventContext& ctx, double nVtx = -1) const;
 
  double getProb(const EventContext& ctx,
                 const Trk::TrackStateOnSurface* itr,
                 const double dEdx_obs,
                 const double pTrk,
                 Trk::ParticleHypothesis hypothesis,
                 int nUsedHits) const;
  double getProb(const EventContext& ctx,
                 EGasType gasType,
                 const double dEdx_obs,
                 const double pTrk,
                 Trk::ParticleHypothesis hypothesis,
                 int nUsedHits) const;
 
  double predictdEdx(const EventContext& ctx,
                     const Trk::TrackStateOnSurface* itr,
                     const double pTrk,
                     Trk::ParticleHypothesis hypothesis) const;
 
  double predictdEdx(const EventContext& ctx,
                     EGasType gasType,
                     const double pTrk,
                     Trk::ParticleHypothesis hypothesis) const;
 
  double mass(const EventContext& ctx,
              const Trk::TrackStateOnSurface* itr,
              const double pTrk,
              double dEdx) const;
 
  double correctToT_corrRZ(const EventContext& ctx,
                           const Trk::TrackStateOnSurface* itr,
                           double length) const;
 
  EGasType gasTypeInStraw(const EventContext& ctx,
                          const Trk::TrackStateOnSurface* itr) const;
  EGasType gasTypeInStraw(
    const EventContext& ctx,
    const InDet::TRT_DriftCircleOnTrack* driftcircle) const;
 
private:
 
  SG::ReadCondHandleKey<TRTDedxcorrection> m_ReadKey{this,"Dedxcorrection","Dedxcorrection","Dedx constants in-key"};   
 
  double fitFuncEndcap_corrRZ(const EventContext& ctx,
                              EGasType gas,
                              double driftRadius,
                              double rPosition,
                              int Layer,
                              int sign) const;
  double fitFuncBarrel_corrRZ(const EventContext& ctx,
                              EGasType gas,
                              double driftRadius,
                              double zPosition,
                              int Layer,
                              int StrawLayer) const;
 
  double fitFuncBarrelLong_corrRZ(const EventContext& ctx,
                                  EGasType gasType,
                                  double driftRadius,
                                  double zPosition,
                                  int Layer,
                                  int StrawLayer) const;
 
  double fitFuncBarrelShort_corrRZ(const EventContext& ctx,
                                   EGasType gasType,
                                   double driftRadius,
                                   double zPosition,
                                   int StrawLayer) const;
 
  double fitFuncPol_corrRZ(const EventContext& ctx,
                           EGasType gasType,
                           int parameter,
                           double driftRadius,
                           int Layer,
                           int Strawlayer,
                           int sign,
                           int set) const;
 
  double fitFuncEndcap_corrRZL(const EventContext& ctx,
                               EGasType gasType,
                               double driftRadius,
                               double radialPosition,
                               int Layer,
                               int sign) const;
 
  double fitFuncBarrel_corrRZL(const EventContext& ctx,
                               EGasType gasType,
                               double driftRadius,
                               double zPosition,
                               int Layer,
                               int StrawLayer) const;
 
  /* Calibration functions for occupancy corrections */
  double hitOccupancyCorrection(const EventContext& ctx,
                                const Trk::TrackStateOnSurface* itr) const;
  double trackOccupancyCorrection(const EventContext& ctx,
                                  const Trk::Track* track,
                                  bool useHThits,
                                  std::optional<float> localOccupancy) const;
 
public:
  // Setters and getters
 
  void  setDefaultConfiguration();
 
  void  setStatusCorrection(bool value)       { m_corrected = value;        }
  bool  getStatusCorrection() const           { return m_corrected;         }
 
  void  setCorrectionType(EOccupancyCorrection value)  { m_correctionType = value;        }
  bool  getCorrectionType() const                      { return m_correctionType;         }
 
  void  setMinRtrack(float minRtrack)         { m_trackConfig_minRtrack=minRtrack;}
  float getMinRtrack() const                  { return m_trackConfig_minRtrack;   }
 
  void  setMaxRtrack(float maxRtrack)         { m_trackConfig_maxRtrack=maxRtrack;}
  float getMaxRtrack() const                  { return m_trackConfig_maxRtrack;   }
 
  void  setStatusUseZeroRHitCut(bool value)   { m_useZeroRHitCut = value; }
  bool  getStatusUseZeroRHitCut() const       { return m_useZeroRHitCut; }
 
  void  setGasTypeFordEdXCalculation(EGasType gasType) { m_useTrackPartWithGasType = gasType; }
  int   getGasTypeFordEdXCalculation() const           { return m_useTrackPartWithGasType;    }
 
  void  setAlgorithm(EstCalc alg)             { m_toolScenario=alg;    }
  int   getAlgorithm() const                  { return m_toolScenario; }
 
// static methods
static double calculateTrackLengthInStraw(const Trk::TrackStateOnSurface* trackState, const TRT_ID* identifier);
  
};
 
#endif // TRT_TOT_DEDX_H