InDet::TRT_ElectronPidToolRun2 Class Reference

TRT_ElectronPidToolRun2 is a tool for identification of electrons based on information mainly from the TRT and partially from the whole ID. More...

#include <TRT_ElectronPidToolRun2.h>

Inheritance diagram for InDet::TRT_ElectronPidToolRun2:

Collaboration diagram for InDet::TRT_ElectronPidToolRun2:

Public Member Functions
	TRT_ElectronPidToolRun2 (const std::string &, const std::string &, const IInterface *)
virtual	~TRT_ElectronPidToolRun2 ()
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	finalize () override
	standard Athena-Algorithm method
virtual std::vector< float >	electronProbability (const EventContext &ctx, const Trk::Track &track) const override final
	Electron probabilities to be returned.
virtual double	probHT (const double pTrk, const Trk::ParticleHypothesis hypothesis, const int HitPart, const int Layer, const int Strawlayer) const override final
	return high threshold probability
virtual double	probHTRun2 (const EventContext &ctx, float pTrk, Trk::ParticleHypothesis hypothesis, int TrtPart, int GasType, int StrawLayer, float ZR, float rTrkWire, float Occupancy) const override final
	DeclareInterfaceID (ITRT_ElectronPidTool, 1, 0)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static std::vector< float >	electronProbability_old (const Trk::Track &track)
	Electron probabilities to be returned.
static const InterfaceID &	interfaceID ()
	AlgTool interface methods.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	CheckGeometry (int BEC, int Layer, int Strawlayer) const
double	sqr (double a)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const TRT_ID *	m_trtId {nullptr}
UnsignedIntegerProperty	m_minTRThits
FloatProperty	m_ptMinNN
BooleanProperty	m_calculateNN
ToolHandle< ITRT_ToT_dEdx >	m_TRTdEdxTool
ToolHandle< InDet::ITRT_LocalOccupancy >	m_LocalOccTool
ToolHandle< ITRT_StrawStatusSummaryTool >	m_TRTStrawSummaryTool
SG::ReadCondHandleKey< HTcalculator >	m_HTReadKey
SG::ReadCondHandleKey< InDet::TRTPIDNN >	m_TRTPIDNNReadKey
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

TRT_ElectronPidToolRun2 is a tool for identification of electrons based on information mainly from the TRT and partially from the whole ID.

Given a track, multiple quantities are calculated (see also TrkTrackSummary/TrackSummary.h):

1: eProbabilityComb - combined probability from High Threshold (HT) and Time-over- Threshold (ToT) information (see below).

2: eProbabilityHT - likelihood calculated using High Threshold (HT) information. Sensitive to Transition Radiation (TR) photons emitted by electrons, when traversing the TRT radiator material between the straws. Electrons start to emit TR at 500 MeV, but only fully at 5 GeV.

3: eProbabilityToT - likelihood calculated using Time-over-Threshold (ToT) information. Sensitive to (increased) ionization by electrons compared to heavier particles (eg. pions, protons, etc.). ToT is computed only for straws without a HT hit (to avoid correlations). The separation is largest at low momentum, and deminishes with increased energy.

4: eProbabilityBrem - Electron probability from Brem fitting (DNA).

5: eProbabilityNN - neural network that combines HT, ToT and other hit- and track-level properties into a combined classifier.

6: TRTTrackOccupancy - fraction of TRT straws that fired in the modules that are traversed by the track.

7: TRTdEdx - calibrated dE/dx measurement from all TRT hits along the track (see TRT_ToT_dEdx.h).

8: eProbabilityNumberOfTRTHitsUsedFordEdx - number of good TRT hits that entered the dE/dx calculation.

Definition at line 88 of file TRT_ElectronPidToolRun2.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TRT_ElectronPidToolRun2()

InDet::TRT_ElectronPidToolRun2::TRT_ElectronPidToolRun2	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 67 of file TRT_ElectronPidToolRun2.cxx.

  :
  AthAlgTool(t,n,p)
{
  declareInterface<ITRT_ElectronPidTool>(this);
  declareInterface<ITRT_ElectronToTTool>(this);
}

~TRT_ElectronPidToolRun2()

InDet::TRT_ElectronPidToolRun2::~TRT_ElectronPidToolRun2 ( )

virtualdefault

default destructor

Member Function Documentation

CheckGeometry()

bool InDet::TRT_ElectronPidToolRun2::CheckGeometry ( int BEC, int Layer, int Strawlayer ) const

private

Definition at line 556 of file TRT_ElectronPidToolRun2.cxx.

                                                                                         {
 
  //first check that the BEC is valid:
  if( BEC!=-2 && BEC !=-1 && BEC!=1 && BEC!=2){
    ATH_MSG_ERROR("Found a wrong TRT part: "<<BEC<<" expected one of (-2,-1,1,2)");
    return false;
  }
  const int part = abs(BEC)-1;
 
  //next check that the layer is valid
  if( Layer < 0){
    ATH_MSG_ERROR("Found a negative TRT Layer");
    return false; //must be positive
  }
 
  static const int nlayers[2]={3,14};
 
  if( not ( Layer < nlayers[part] ) ){
    ATH_MSG_ERROR("Found TRT Layer index "<<Layer<<" in part "<<BEC<<" but part only has "<<nlayers[part]<<" layers.");
    return false;
  }
 
  //and finally check that the StrawLayer is valid:
  if( StrawLayer < 0){
    ATH_MSG_ERROR("Found a negative TRT StrawLayer");
    return false; //must be positive
  }
 
  static const int strawsPerBEC[2][14]={{19,24,30, 0, 0, 0,0,0,0,0,0,0,0,0},
                                        {16,16,16,16,16,16,8,8,8,8,8,8,8,8}};
 
  if(not(StrawLayer < strawsPerBEC[part][Layer])){
    ATH_MSG_ERROR("TRT part " << BEC << " Layer " << Layer << " only has "
                              << strawsPerBEC[part][Layer]
                              << " straws. Found index " << StrawLayer);
    return false;
  }
 
  return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

Trk::ITRT_ElectronPidTool::DeclareInterfaceID ( ITRT_ElectronPidTool , 1 , 0  )

inherited

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

electronProbability()

std::vector< float > InDet::TRT_ElectronPidToolRun2::electronProbability ( const EventContext & ctx, const Trk::Track & track ) const

finaloverridevirtual

Electron probabilities to be returned.

Implements Trk::ITRT_ElectronPidTool.

Definition at line 135 of file TRT_ElectronPidToolRun2.cxx.

{
 
  // Get the probability calculator
  SG::ReadCondHandle<HTcalculator> readHandle{m_HTReadKey,ctx};
  const HTcalculator* HTcalc = (*readHandle);
  // make sure some calibration is available
  if(HTcalc==nullptr) {
    ATH_MSG_WARNING ("  No Pid calibration from the DB.");
    return {};
  }
 
  // Get the PID NN
  const InDet::TRTPIDNN* PIDNN = nullptr;
  if (m_calculateNN) {
    SG::ReadCondHandle<InDet::TRTPIDNN> readHandlePIDNN{m_TRTPIDNNReadKey,ctx};
    PIDNN = (*readHandlePIDNN);
    // make sure some calibration is available
    if(PIDNN==nullptr) {
      ATH_MSG_WARNING ("  No PID NN available from the DB.");
      return {};
    }
  }
 
  // Initialize the vector with default PID values
  std::vector<float> PIDvalues = Trk::eProbabilityDefault;
 
  // Check for perigee:
  const Trk::TrackParameters* perigee = track.perigeeParameters();
  if (!perigee) return PIDvalues;
 
  // Get parameters at perigee and check that they are reasonable:
  const AmgVector(Trk::TrackParameters::dim)& parameterVector = perigee->parameters();
  double qOverP = parameterVector[Trk::qOverP];
  double theta  = parameterVector[Trk::theta];
  double phi    = parameterVector[Trk::phi];
 
  // Check the parameters are reasonable:
  if (tan(theta/2.0) < 0.0001) {
    ATH_MSG_DEBUG("  Track has negative theta or is VERY close to beampipe! "
                  "(tan(theta/2) < 0.0001). Returning default Pid values.");
    return PIDvalues;
  }
 
  if (qOverP == 0.0) {
    ATH_MSG_DEBUG ("  Track momentum infinite! (i.e. q/p = 0). Returning default Pid values.");
    return PIDvalues;
  }
 
  double pTrk = fabs(1.0 / qOverP);
  double pT   = pTrk * sin(theta);
  double eta  = -log(tan(theta/2.0));
 
  // Check the tool to get the local occupancy (i.e. for the track in question):
  PIDvalues[Trk::TRTTrackOccupancy] = m_LocalOccTool->LocalOccupancy(ctx,track);
 
  if (PIDvalues[Trk::TRTTrackOccupancy] > 1.0  || PIDvalues[Trk::TRTTrackOccupancy]  < 0.0) {
    ATH_MSG_WARNING("  Occupancy was outside allowed range! Returning default Pid values. Occupancy = "
                    << PIDvalues[Trk::TRTTrackOccupancy] );
    return PIDvalues;
  }
 
  ATH_MSG_DEBUG ("");
  ATH_MSG_DEBUG ("");
  ATH_MSG_DEBUG ("check---------------------------------------------------------------------------------------");
  ATH_MSG_DEBUG ("check  Got track:   pT: " << pT << "   eta: " << eta << "   phi: " << phi);
  ATH_MSG_DEBUG ("check---------------------------------------------------------------------------------------");
 
  // For calculation of HT probability:
  double pHTel_prod = 1.0;
  double pHTpi_prod = 1.0;
 
  // ------------------------------------------------------------------------------------
  // Loop over TRT hits on track, and calculate HT and R-ToT probability:
  // ------------------------------------------------------------------------------------
 
  std::vector<double> hit_HTMB;
  std::vector<double> hit_gasType;
  std::vector<double> hit_tot;
  std::vector<double> hit_L;
  std::vector<double> hit_rTrkWire;
  std::vector<double> hit_HitZ;
  std::vector<double> hit_HitR;
  std::vector<double> hit_isPrec;
 
  unsigned int nTRThits     = 0;
  unsigned int nTRThitsHTMB = 0;
  unsigned int nXehits      = 0;
  unsigned int nArhits      = 0;
  unsigned int nPrecHits    = 0;
 
 
  // Check for track states:
  const Trk::TrackStates* recoTrackStates = track.trackStateOnSurfaces();
  if (not recoTrackStates) {
    ATH_MSG_DEBUG("track.trackStateOnSurfaces() was zero");
    //m_timingProfile->chronoStop("Tool::electronProb");
    return PIDvalues;
  }
 
  Trk::TrackStates::const_iterator tsosIter    = recoTrackStates->begin();
  Trk::TrackStates::const_iterator tsosIterEnd = recoTrackStates->end();
 
  // Loop over track states on surfaces (i.e. generalized hits):
  for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
 
    const Trk::MeasurementBase *measurement = (*tsosIter)->measurementOnTrack();
    if (!measurement) continue;
 
    // Get drift circle (ensures that hit is from TRT):
    // use the type methods to avoid dynamic_cast in a loop
    const InDet::TRT_DriftCircleOnTrack* driftcircle = nullptr;
    if (measurement->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      const Trk::RIO_OnTrack* tmpRio =
        static_cast<const Trk::RIO_OnTrack*>(measurement);
      if (tmpRio->rioType(Trk::RIO_OnTrackType::TRT_DriftCircle)) {
        driftcircle = static_cast<const InDet::TRT_DriftCircleOnTrack*>(tmpRio);
      }
    }
 
    if (!driftcircle) continue;
 
    // From now (May 2015) onwards, we ONLY USE MIDDLE HT BIT:
    bool isHTMB  = (driftcircle->prepRawData()->getWord() & 0x00020000) > 0;
 
    nTRThits++;
    if (isHTMB) nTRThitsHTMB++;
    hit_HTMB.push_back(static_cast<double>(isHTMB));
 
 
    // ------------------------------------------------------------------------------------
    // Get the necessary input for the probability calculations:
    // ------------------------------------------------------------------------------------
    Identifier DCid = driftcircle->identify();
 
    // Part of TRT hit belongs to (TrtPart = 0: Barrel, 1: EndcapA, 2: EndcapB).
    int TrtPart = 0;                      // 0: Barrel, 1: EndcapA, 2: EndcapB
    if (abs(m_trtId->barrel_ec(DCid)) == 2)
      TrtPart = (m_trtId->layer_or_wheel(DCid) < 6) ? 1 : 2;
 
    // Get Straw Layer (Barrel: 0-72, EndcapA: 0-95 (16 layers in 6 modules), EndcapB: 0-63 (8 layers in 8 modules)):
    int StrawLayer = 0;
    if (TrtPart == 0) {
      // Barrel:
      if (m_trtId->layer_or_wheel(DCid) == 0) {
        StrawLayer = m_trtId->straw_layer(DCid);
      } else if (m_trtId->layer_or_wheel(DCid) == 1) {
        StrawLayer = 19 + m_trtId->straw_layer(DCid);
      } else {
        StrawLayer = 19 + 24 + m_trtId->straw_layer(DCid);
      }
    } else {
      // Endcap:
      if (m_trtId->layer_or_wheel(DCid) < 6) {
        StrawLayer =
          16 * m_trtId->layer_or_wheel(DCid) + m_trtId->straw_layer(DCid);
      } else {
        StrawLayer =
          8 * (m_trtId->layer_or_wheel(DCid) - 6) + m_trtId->straw_layer(DCid);
      }
    }
 
    // Get Z (Barrel) or R (Endcap) location of the hit, and distance from track to wire (i.e. anode) in straw:
    double HitZ = 0.;
    double HitR = 0.;
    double rTrkWire = 0.;
    bool hasTrackParameters = true; // Keep track of this for HT prob calculation
    if ((*tsosIter)->trackParameters()) {
      // If we have precise information (from hit), get that:
      const Amg::Vector3D& gp = driftcircle->globalPosition();
      HitR = gp.perp();
      HitZ = gp.z();
      rTrkWire = fabs((*tsosIter)->trackParameters()->parameters()[Trk::driftRadius]);
      if (rTrkWire > 2.2) rTrkWire = 2.175;   // cut off track-to-wire distance for outliers
    } else {
      // Otherwise just use the straw coordinates:
      hasTrackParameters = false; // Jared - pass this to HT calculation
      HitZ = driftcircle->associatedSurface().center().z();
      HitR = driftcircle->associatedSurface().center().perp();
      rTrkWire = 0;
    }
 
    // fill vectors for NN PID
    if (m_calculateNN and pT >= m_ptMinNN) {
      hit_HitZ.push_back(HitZ);
      hit_HitR.push_back(HitR);
      hit_rTrkWire.push_back(rTrkWire);
      hit_L.push_back(TRT_ToT_dEdx::calculateTrackLengthInStraw((*tsosIter), m_trtId));
      hit_tot.push_back(driftcircle->timeOverThreshold());
    }
 
    // ------------------------------------------------------------------------------------
    // Collection and checks of input variables for HT probability calculation:
    // ------------------------------------------------------------------------------------
 
    int SL_max[3] = {73, 96, 64};
    if (StrawLayer > SL_max[TrtPart]  ||  StrawLayer < 0) {
      ATH_MSG_WARNING("  StrawLayer was outside allowed range!  TrtPart = " << TrtPart << "  SL = " << StrawLayer);
      continue;
    }
 
    double ZRpos[3] = {fabs(HitZ), HitR, HitR};
    double ZRpos_min[3] = {  0.0,  630.0,  630.0};
    double ZRpos_max[3] = {720.0, 1030.0, 1030.0};
    if (ZRpos[TrtPart] > ZRpos_max[TrtPart]) {
      ATH_MSG_WARNING("  ZRpos was above allowed range - adjusted!  TrtPart = " << TrtPart << "  ZRpos = " << ZRpos[TrtPart]);
      ZRpos[TrtPart] = ZRpos_max[TrtPart] - 0.001;
    }
    if (ZRpos[TrtPart] < ZRpos_min[TrtPart]) {
      ATH_MSG_WARNING("  ZRpos was below allowed range - adjusted!  TrtPart = " << TrtPart << "  ZRpos = " << ZRpos[TrtPart]);
      ZRpos[TrtPart] = ZRpos_min[TrtPart] + 0.001;
    }
 
    // ------------------------------------------------------------------------------------
    // Calculate the HT probability:
    // ------------------------------------------------------------------------------------
 
    // getStatusHT returns enum {Undefined, Dead, Good, Xenon, Argon, Krypton, EmulatedArgon, EmulatedKrypton}.
    // Our representation of 'GasType' is 0:Xenon, 1:Argon, 2:Krypton
    int GasType=0; // Xenon is default
    if (!m_TRTStrawSummaryTool.empty()) {
      int stat = m_TRTStrawSummaryTool->getStatusHT(DCid,ctx);
      if       ( stat==2 || stat==3 ) { GasType = 0; } // Xe
      else if  ( stat==1 || stat==4 ) { GasType = 1; } // Ar
      else if  ( stat==5 )            { GasType = 1; } // Kr -- ESTIMATED AS AR UNTIL PID IS TUNED TO HANDLE KR
      else if  ( stat==6 )            { GasType = 1; } // Emulated Ar
      else if  ( stat==7 )            { GasType = 1;
      } // Emulated Kr -- ESTIMATED AS AR UNTIL PID IS TUNED TO HANDLE KR
      else {
        ATH_MSG_FATAL(
          "getStatusHT = "
          << stat
          << ", must be 'Good(2)||Xenon(3)' or 'Dead(1)||Argon(4)' or "
             "'Krypton(5)' or 'EmulatedArgon(6)' or 'EmulatedKr(7)'!");
        throw std::exception();
      }
    }
 
    ATH_MSG_DEBUG("check Hit: "
                  << nTRThits << "  TrtPart: " << TrtPart
                  << "  GasType: " << GasType << "  SL: " << StrawLayer
                  << "  ZRpos: " << ZRpos[TrtPart] << "  TWdist: " << rTrkWire
                  << "  Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy]  << "  HTMB: " << isHTMB);
 
    if (m_calculateNN and pT >= m_ptMinNN) {
      // RNN gas type observables
      hit_gasType.push_back(static_cast<double>(GasType));
      if (GasType == 0) {
        nXehits++;
      } else if (GasType == 1) {
        nArhits++;
      }
 
      // RNN hit preciion observables
      float errDc = sqrt(driftcircle->localCovariance()(Trk::driftRadius, Trk::driftRadius));
      bool isPrec = false;
      if (errDc < 1.0) {
        isPrec = true;
        nPrecHits++;
      }
      hit_isPrec.push_back(static_cast<double>(isPrec));
    }
 
    // Then call pHT functions with these values:
    // ------------------------------------------
 
    double pHTel = HTcalc->getProbHT(pTrk,
                                     Trk::electron,
                                     TrtPart,
                                     GasType,
                                     StrawLayer,
                                     ZRpos[TrtPart],
                                     rTrkWire,
                                     PIDvalues[Trk::TRTTrackOccupancy] ,
                                     hasTrackParameters);
    double pHTpi = HTcalc->getProbHT(pTrk,
                                     Trk::pion,
                                     TrtPart,
                                     GasType,
                                     StrawLayer,
                                     ZRpos[TrtPart],
                                     rTrkWire,
                                     PIDvalues[Trk::TRTTrackOccupancy] ,
                                     hasTrackParameters);
 
    if (pHTel > 0.999 || pHTpi > 0.999 || pHTel < 0.001 || pHTpi < 0.001) {
      ATH_MSG_DEBUG("  pHT outside allowed range!  pHTel = "
                    << pHTel << "  pHTpi = " << pHTpi
                    << "     TrtPart: " << TrtPart << "  SL: " << StrawLayer
                    << "  ZRpos: " << ZRpos[TrtPart] << "  TWdist: " << rTrkWire
                    << "  Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy] );
      continue;
    }
 
    if (pHTel > 0.80 || pHTpi > 0.50 || pHTel < 0.025 || pHTpi < 0.010) {
      ATH_MSG_DEBUG("  pHT has abnormal value!  pHTel = "
                    << pHTel << "  pHTpi = " << pHTpi
                    << "     TrtPart: " << TrtPart << "  SL: " << StrawLayer
                    << "  ZRpos: " << ZRpos[TrtPart] << "  TWdist: " << rTrkWire
                    << "  Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy] );
      continue;
    }
 
    // From now (May 2015) onwards, we ONLY USE MIDDLE HT BIT:
    if (isHTMB) {pHTel_prod *=     pHTel;  pHTpi_prod *=     pHTpi;}
    else        {pHTel_prod *= 1.0-pHTel;  pHTpi_prod *= 1.0-pHTpi;}
    ATH_MSG_DEBUG ("check         pHT(el): " << pHTel << "  pHT(pi): " << pHTpi );
 
  } // end of loop over hits
 
 
  // If number of hits is adequate (default is 5 hits), calculate HT and ToT probability.
  if (not (nTRThits >= m_minTRThits)) return PIDvalues;
 
  // Calculate electron probability (HT)
  PIDvalues[Trk::eProbabilityHT] = pHTel_prod / (pHTel_prod + pHTpi_prod);
 
  ATH_MSG_DEBUG ("check  nTRThits: " << nTRThits << "  : " << nTRThitsHTMB
                                     << "  pHTel_prod: " << pHTel_prod
                                     << "  pHTpi_prod: " << pHTpi_prod
                                     << "  probEl: " << PIDvalues[Trk::eProbabilityHT]);
 
  PIDvalues[Trk::TRTdEdx] = m_TRTdEdxTool->dEdx(
    ctx,
    &track,
    true, //be expicit as optional below can be converted to bool
    PIDvalues[Trk::TRTTrackOccupancy]); // default dEdx using all hits
 
  PIDvalues[Trk::eProbabilityNumberOfTRTHitsUsedFordEdx] =
    m_TRTdEdxTool->usedHits(ctx, &track);
  double dEdx_noHTHits = m_TRTdEdxTool->dEdx(
    ctx,
    &track,
    false,//be expicit as optional below can be converted to bool
    PIDvalues[Trk::TRTTrackOccupancy]); // Divide by L, exclude HT hits
 
  double dEdx_usedHits_noHTHits = m_TRTdEdxTool->usedHits(ctx, &track, false);
  PIDvalues[Trk::eProbabilityToT] = m_TRTdEdxTool->getTest(
    ctx, dEdx_noHTHits, pTrk, Trk::electron, Trk::pion, dEdx_usedHits_noHTHits);
 
  // Limit the probability values the upper and lower limits that are given/trusted for each part:
  double limProbHT = HTcalculator::Limit(PIDvalues[Trk::eProbabilityHT]);
  double limProbToT = HTcalculator::Limit(PIDvalues[Trk::eProbabilityToT]);
 
  // Calculate the combined probability, assuming no correlations (none are expected).
  PIDvalues[Trk::eProbabilityComb] =
    (limProbHT * limProbToT) /
    ((limProbHT * limProbToT) + ((1.0 - limProbHT) * (1.0 - limProbToT)));
 
  // Troels: VERY NASTY NAMING, BUT AGREED UPON FOR NOW (for debugging, 27. NOV. 2014):
  PIDvalues[Trk::eProbabilityBrem] = pHTel_prod; // decorates electron LH to el brem for now... (still used?)
 
  if (!m_calculateNN or pT < m_ptMinNN) {
    return PIDvalues;
  }
 
  // Calculate RNN PID score
  std::map<std::string, std::map<std::string, double>> scalarInputs_NN = PIDNN->getScalarInputs();
  std::map<std::string, std::map<std::string, std::vector<double>>> vectorInputs_NN = PIDNN->getVectorInputs();
 
  // Calculate the hit fraction
  if (nTRThits == 0)[[unlikely]]{
    ATH_MSG_ERROR("Number of TRT hits is zero");
    return {};
  }
  double fAr = static_cast<double>(nArhits) / nTRThits;
  double fHTMB = static_cast<double>(nTRThitsHTMB) / nTRThits;
  double PHF = static_cast<double>(nPrecHits) / nTRThits;
 
  if (!scalarInputs_NN.empty()) {
    std::map<std::string, double>& trackVarMap = scalarInputs_NN.begin()->second;
    storeNNVariable(trackVarMap, "trkOcc", static_cast<double>(PIDvalues[Trk::TRTTrackOccupancy]));
    storeNNVariable(trackVarMap, "p", pTrk);
    storeNNVariable(trackVarMap, "pT", pT);
    storeNNVariable(trackVarMap, "nXehits", static_cast<double>(nXehits));
    storeNNVariable(trackVarMap, "fAr", fAr);
    storeNNVariable(trackVarMap, "fHTMB", fHTMB);
    storeNNVariable(trackVarMap, "PHF", PHF);
    storeNNVariable(trackVarMap, "dEdx", static_cast<double>(dEdx_noHTHits));
  }
 
  if (!vectorInputs_NN.empty()) {
    std::map<std::string, std::vector<double>>& hitVarMap = vectorInputs_NN.begin()->second;
    storeNNVariable(hitVarMap, "hit_HTMB", hit_HTMB);
    storeNNVariable(hitVarMap, "hit_gasType", hit_gasType);
    storeNNVariable(hitVarMap, "hit_tot", hit_tot);
    storeNNVariable(hitVarMap, "hit_L", hit_L);
    storeNNVariable(hitVarMap, "hit_rTrkWire", hit_rTrkWire);
    storeNNVariable(hitVarMap, "hit_HitZ", hit_HitZ);
    storeNNVariable(hitVarMap, "hit_HitR", hit_HitR);
    storeNNVariable(hitVarMap, "hit_isPrec", hit_isPrec);
  }
  PIDvalues[Trk::eProbabilityNN] = PIDNN->evaluate(scalarInputs_NN, vectorInputs_NN);
 
  ATH_MSG_DEBUG ("check NN PID calculation: ");
  for (const auto& scalarInputs : scalarInputs_NN) {
    ATH_MSG_DEBUG ("  scalar inputs: " << scalarInputs.first);
    for (const auto& variable : scalarInputs.second) {
      ATH_MSG_DEBUG ("    " << variable.first << " = " << variable.second);
    }
  }
  for (const auto& vectorInputs : vectorInputs_NN) {
    ATH_MSG_DEBUG ("  vector inputs: " << vectorInputs.first);
    for (const auto& variable : vectorInputs.second) {
      ATH_MSG_DEBUG ("    " << variable.first << " = " << variable.second);
    }
  }
  ATH_MSG_DEBUG ("  eProbilityNN: " << PIDvalues[Trk::eProbabilityNN]);
 
  return PIDvalues;
}

electronProbability_old()

std::vector< float > InDet::TRT_ElectronPidToolRun2::electronProbability_old ( const Trk::Track & track )

static

Electron probabilities to be returned.

Definition at line 122 of file TRT_ElectronPidToolRun2.cxx.

{
  // Simply return values without calculation
  std::vector<float> PIDvalues = Trk::eProbabilityDefault;
  return PIDvalues;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode InDet::TRT_ElectronPidToolRun2::finalize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 115 of file TRT_ElectronPidToolRun2.cxx.

{
  return AthAlgTool::finalize();
}

initialize()

StatusCode InDet::TRT_ElectronPidToolRun2::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 87 of file TRT_ElectronPidToolRun2.cxx.

{
  StatusCode sc = AthAlgTool::initialize();
  if (sc.isFailure()) return sc;
 
  // Get the TRT Identifier-helper:
  CHECK (detStore()->retrieve(m_trtId, "TRT_ID"));
 
  /* Get the TRT_ToT_dEdx tool */
  CHECK( m_TRTdEdxTool.retrieve() );
 
  CHECK( m_LocalOccTool.retrieve() );
 
  ATH_CHECK( m_HTReadKey.initialize() );
 
  ATH_CHECK( m_TRTPIDNNReadKey.initialize(m_calculateNN) );
 
  CHECK( m_TRTStrawSummaryTool.retrieve() );
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & ITRT_ElectronToTTool::interfaceID ( )

inlinestaticinherited

AlgTool interface methods.

Definition at line 25 of file ITRT_ElectronToTTool.h.

{ return IID_ITRT_ElectronToTTool; };

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

probHT()

double InDet::TRT_ElectronPidToolRun2::probHT ( const double p, const Trk::ParticleHypothesis hypothesis, const int HitPart, const int Layer, const int Strawlayer ) const

finaloverridevirtual

return high threshold probability

Returns

double of probability

Implements Trk::ITRT_ElectronPidTool.

Definition at line 603 of file TRT_ElectronPidToolRun2.cxx.

{
  if (not CheckGeometry(HitPart,Layer,StrawLayer) ){
    ATH_MSG_ERROR("TRT geometry fail. Returning default value.");
    return 0.5;
  }
 
  return 1.0;
}

probHTRun2()

double InDet::TRT_ElectronPidToolRun2::probHTRun2 ( const EventContext & ctx, float pTrk, Trk::ParticleHypothesis hypothesis, int TrtPart, int GasType, int StrawLayer, float ZR, float rTrkWire, float Occupancy ) const

finaloverridevirtual

Implements Trk::ITRT_ElectronPidTool.

Definition at line 619 of file TRT_ElectronPidToolRun2.cxx.

{
  SG::ReadCondHandle<HTcalculator> readHandle{ m_HTReadKey, ctx };
  bool hasTrackPar = true;
  return (*readHandle)
    ->getProbHT(pTrk,
                hypothesis,
                TrtPart,
                GasType,
                StrawLayer,
                ZR,
                rTrkWire,
                Occupancy,
                hasTrackPar);
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sqr()

double InDet::TRT_ElectronPidToolRun2::sqr ( double a )

inlineprivate

Definition at line 133 of file TRT_ElectronPidToolRun2.h.

{return a*a;} 

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_calculateNN

BooleanProperty InDet::TRT_ElectronPidToolRun2::m_calculateNN

private

Initial value:

{this, "CalculateNNPid", true,
      "Decide whether to use NN PID"}

Definition at line 140 of file TRT_ElectronPidToolRun2.h.

                                 {this, "CalculateNNPid", true,
      "Decide whether to use NN PID"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_HTReadKey

SG::ReadCondHandleKey<HTcalculator> InDet::TRT_ElectronPidToolRun2::m_HTReadKey

private

Initial value:

{ this,
                                                     "HTcalculator",
                                                     "HTcalculator",
                                                     "HTcalculator in-key" }

Definition at line 160 of file TRT_ElectronPidToolRun2.h.

                                                 { this,
                                                     "HTcalculator",
                                                     "HTcalculator",
                                                     "HTcalculator in-key" };

m_LocalOccTool

ToolHandle<InDet::ITRT_LocalOccupancy> InDet::TRT_ElectronPidToolRun2::m_LocalOccTool

private

Initial value:

{
      this,
      "TRT_LocalOccupancyTool",
      {},
      "TRT Local occupancy tool"
    }

Definition at line 147 of file TRT_ElectronPidToolRun2.h.

                                                       {
      this,
      "TRT_LocalOccupancyTool",
      {},
      "TRT Local occupancy tool"
    };

m_minTRThits

UnsignedIntegerProperty InDet::TRT_ElectronPidToolRun2::m_minTRThits

private

Initial value:

{this, "MinimumTRThitsForIDpid", 5,
      "Minimum number of TRT hits to give PID"}

Definition at line 136 of file TRT_ElectronPidToolRun2.h.

                                        {this, "MinimumTRThitsForIDpid", 5,
      "Minimum number of TRT hits to give PID"};

m_ptMinNN

FloatProperty InDet::TRT_ElectronPidToolRun2::m_ptMinNN

private

Initial value:

{this, "MinimumTrackPtForNNPid", 2000.,
      "Minimum track pt to calculate NN response for PID"}

Definition at line 138 of file TRT_ElectronPidToolRun2.h.

                           {this, "MinimumTrackPtForNNPid", 2000.,
      "Minimum track pt to calculate NN response for PID"};

m_TRTdEdxTool

ToolHandle<ITRT_ToT_dEdx> InDet::TRT_ElectronPidToolRun2::m_TRTdEdxTool

private

Initial value:

{ this,
                                             "TRT_ToT_dEdx_Tool",
                                             {},
                                             "TRT ToT dEdx Tool"}

Definition at line 143 of file TRT_ElectronPidToolRun2.h.

                                           { this,
                                             "TRT_ToT_dEdx_Tool",
                                             {},
                                             "TRT ToT dEdx Tool"};

m_trtId

const TRT_ID* InDet::TRT_ElectronPidToolRun2::m_trtId {nullptr}

private

Definition at line 135 of file TRT_ElectronPidToolRun2.h.

{nullptr}; // TRT ID helper (identifying barrel/wheels and global position)

m_TRTPIDNNReadKey

SG::ReadCondHandleKey<InDet::TRTPIDNN> InDet::TRT_ElectronPidToolRun2::m_TRTPIDNNReadKey

private

Initial value:

{ this,
                                                     "TRTPIDNN",
                                                     "TRTPIDNN",
                                                     "TRTPIDNN in-key" }

Definition at line 165 of file TRT_ElectronPidToolRun2.h.

                                                        { this,
                                                     "TRTPIDNN",
                                                     "TRTPIDNN",
                                                     "TRTPIDNN in-key" };

m_TRTStrawSummaryTool

ToolHandle<ITRT_StrawStatusSummaryTool> InDet::TRT_ElectronPidToolRun2::m_TRTStrawSummaryTool

private

Initial value:

{
      this,
      "TRTStrawSummaryTool",
      "InDetTRTStrawStatusSummaryTool",
      "TRT straw summary tool"
    }

Definition at line 153 of file TRT_ElectronPidToolRun2.h.

                                                                 {
      this,
      "TRTStrawSummaryTool",
      "InDetTRTStrawStatusSummaryTool",
      "TRT straw summary tool"
    };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• TRT_ElectronPidToolRun2.h
• TRT_ElectronPidToolRun2.cxx