InDet::InDetTrtTrackScoringTool Class Reference

Concrete implementation of the ITrackScoringTool pABC. More...

#include <InDetTrtTrackScoringTool.h>

Inheritance diagram for InDet::InDetTrtTrackScoringTool:

Collaboration diagram for InDet::InDetTrtTrackScoringTool:

Public Member Functions
	InDetTrtTrackScoringTool (const std::string &, const std::string &, const IInterface *)
virtual	~InDetTrtTrackScoringTool ()=default
virtual StatusCode	initialize () override
virtual bool	passBasicSelections (const Trk::Track &track) const override
	check track selections independent from TrackSummary
virtual Trk::TrackScore	score (const Trk::Track &track, bool checkBasicSel) const override
	create a score based on how good the passed track is
virtual Trk::TrackScore	simpleScore (const Trk::Track &track, const Trk::TrackSummary &trackSum) const override
	create a score based on how good the passed TrackSummary is
Trk::TrackScore	TRT_ambigScore (const Trk::Track &track, const Trk::TrackSummary &trackSum) const
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 const InterfaceID &	interfaceID ()

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
void	setupTRT_ScoreModifiers ()
bool	isGoodTRT (const Trk::Track &) const
	Decide whether standalone TRT tracks pass the minimum hit requirement.
unsigned int	getEtaBin (const Trk::Perigee &perigee) const
double	getMuDependentNtrtMinCut (unsigned int eta_bin) const
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
	ID TRT helper.
int	m_maxSigmaChi2 = -1
int	m_maxTrtRatio = -1
int	m_maxTrtFittedRatio = -1
std::vector< double >	m_factorSigmaChi2
std::vector< double >	m_factorTrtRatio
std::vector< double >	m_factorTrtFittedRatio
std::vector< double >	m_boundsSigmaChi2
std::vector< double >	m_boundsTrtRatio
std::vector< double >	m_boundsTrtFittedRatio
BooleanProperty	m_useAmbigFcn {this, "useAmbigFcn", true}
	use the scoring tuned to Ambiguity processing or not
BooleanProperty	m_useSigmaChi2 {this, "useSigmaChi2", false}
std::vector< Trk::TrackScore >	m_summaryTypeScore
	holds the scores assigned to each Trk::SummaryType from the track's Trk::TrackSummary
ToolHandle< ITrtDriftCircleCutTool >	m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}
	Returns minimum number of expected TRT drift circles depending on eta.
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
ToolHandle< ILumiBlockMuTool >	m_lumiBlockMuTool
IntegerProperty	m_minTRTonTrk {this, "minTRTonTrk", 15, "minimum number of TRT hits"}
	cuts for selecting good tracks
DoubleProperty	m_maxEta {this, "maxEta", 2.1, "maximal Eta cut"}
DoubleProperty	m_ptmin {this, "PtMin", 1.0, "Minimum Pt"}
BooleanProperty	m_parameterization {this, "UseParameterization", true, "use parameterization to cut instead of custom cut"}
BooleanProperty	m_oldLogic {this, "OldTransitionLogic", false, "use old transition hit logic"}
DoubleProperty	m_minTRTprecision {this, "minTRTPrecisionFraction", 0.5, "minimum fraction of TRT precision hits"}
DoubleArrayProperty	m_TRTTrksEtaBins
DoubleArrayProperty	m_TRTTrksMinTRTHitsThresholds
DoubleArrayProperty	m_TRTTrksMinTRTHitsMuDependencies
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

Concrete implementation of the ITrackScoringTool pABC.

Definition at line 34 of file InDetTrtTrackScoringTool.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

InDetTrtTrackScoringTool()

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

Definition at line 18 of file InDetTrtTrackScoringTool.cxx.

  : AthAlgTool(t, n, p)
  , m_trtId(nullptr)
  , m_summaryTypeScore(Trk::numberOfTrackSummaryTypes)
{
  declareInterface<Trk::ITrackScoringTool>(this);
 
  // declare properties
  m_summaryTypeScore[Trk::numberOfTRTHits] = 1;                                          // 10 straws ~ 1 SCT
  m_summaryTypeScore[Trk::numberOfTRTHighThresholdHits] = 0;                             // addition for being TR
}

~InDetTrtTrackScoringTool()

virtual InDet::InDetTrtTrackScoringTool::~InDetTrtTrackScoringTool ( )

virtualdefault

Member Function Documentation

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());
 
  }

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; }

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

getEtaBin()

unsigned int InDet::InDetTrtTrackScoringTool::getEtaBin ( const Trk::Perigee & perigee ) const

private

Definition at line 417 of file InDetTrtTrackScoringTool.cxx.

{
  // Find the correct bin for applying eta-dependent cuts
 
  double tanThetaOver2 = std::tan(perigee.parameters()[Trk::theta] / 2.);
  double abs_eta = (tanThetaOver2 == 0) ? 999.0 : std::abs(std::log(tanThetaOver2));
 
  for (unsigned int i = 0; i < m_TRTTrksEtaBins.size(); ++i) {
    if (abs_eta < m_TRTTrksEtaBins[i]) {
      return i;
    }
  }
  return m_TRTTrksEtaBins.size() - 1;
}

getMuDependentNtrtMinCut()

double InDet::InDetTrtTrackScoringTool::getMuDependentNtrtMinCut ( unsigned int eta_bin ) const

private

Definition at line 433 of file InDetTrtTrackScoringTool.cxx.

{
 
  double minTRT = m_TRTTrksMinTRTHitsThresholds[eta_bin];
 
  if (m_TRTTrksMinTRTHitsMuDependencies[eta_bin] > 0) {
 
    float avg_mu = m_lumiBlockMuTool->averageInteractionsPerCrossing(Gaudi::Hive::currentContext());
 
    // The mu-dependent cuts have only been validted up to mu = 80.
    // Also there is some physical limit to nTRT, so at some point
    // there needs to be a ceiling for this threshold.
    // To be revisited when a higher mu value is reached.
    avg_mu = std::min(80.f,avg_mu);
 
    // minTRT = a + avg_mu * b
    minTRT += avg_mu * m_TRTTrksMinTRTHitsMuDependencies[eta_bin];
  }
 
  return minTRT;
}

initialize()

StatusCode InDet::InDetTrtTrackScoringTool::initialize ( )

overridevirtual

Definition at line 35 of file InDetTrtTrackScoringTool.cxx.

{
  ATH_CHECK(m_selectortool.retrieve( DisableTool{m_selectortool.empty() } ));
  ATH_CHECK(m_lumiBlockMuTool.retrieve());
 
  if (detStore()->retrieve(m_trtId, "TRT_ID").isFailure()) {
    ATH_MSG_FATAL("Could not get TRT_ID helper !");
    return StatusCode::FAILURE;
  }
  if (m_useAmbigFcn) {
    setupTRT_ScoreModifiers();
  }
 
  // Read handle for AtlasFieldCacheCondObj
  ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
 
  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 & Trk::ITrackScoringTool::interfaceID ( )

inlinestaticinherited

Definition at line 37 of file ITrackScoringTool.h.

{
  return IID_ITrackScoringTool;
}

isGoodTRT()

bool InDet::InDetTrtTrackScoringTool::isGoodTRT ( const Trk::Track & track ) const

private

Decide whether standalone TRT tracks pass the minimum hit requirement.

Definition at line 336 of file InDetTrtTrackScoringTool.cxx.

{
 
  int nTRT = 0;
 
  // some cointer for the custom cuts
  int nEC = 0;
  int nBRL = 0;
  int firstWheel = -999;
  int lastLayer = -999;
 
  // get list of measurements
  const DataVector<const Trk::MeasurementBase>* trkV = track.measurementsOnTrack();
 
  // loop over the measurements
  DataVector<const Trk::MeasurementBase>::const_iterator im, ime = trkV->end();
  for (im = trkV->begin(); im != ime; ++im) {
 
    const InDet::TRT_DriftCircleOnTrack* trtcircle = nullptr;
    // Make sure is not a pseudomeasurement
    if ((*im)->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      const Trk::RIO_OnTrack* rot = static_cast<const Trk::RIO_OnTrack*>((*im));
      // is it really a TRT ?
      if (rot->rioType(Trk::RIO_OnTrackType::TRT_DriftCircle)) {
        trtcircle = static_cast<const InDet::TRT_DriftCircleOnTrack*>(*im);
      }
    }
    if (!trtcircle) {
      continue;
    }
 
    // increment measurment
    ++nTRT;
 
    // compute some transition area variables...
    if (!m_parameterization && m_oldLogic) {
      Identifier id = trtcircle->detectorElement()->identify();
      int isB = m_trtId->barrel_ec(id);
      if (isB == 2 || isB == -2)
        nEC++;
      else if (isB == 1 || isB == -1)
        nBRL++;
      if (nBRL > 0)
        lastLayer = m_trtId->layer_or_wheel(id);
      if (nEC == 1)
        firstWheel = m_trtId->layer_or_wheel(id);
    }
  }
 
  if (!m_parameterization) {
 
    bool toLower = false;
 
    // Cases where the min number of required TRT drift circles drops to 10
    if (m_oldLogic && int(trkV->size()) <= m_minTRTonTrk) {
      if ((nEC > 0 && nBRL > 0) || (nEC == 0 && nBRL > 0 && lastLayer < 2) ||
          (nEC > 0 && nBRL == 0 && (firstWheel > 10 || firstWheel < 2))) {
        toLower = true;
      }
    }
 
    if ((int(trkV->size()) > m_minTRTonTrk) || toLower) {
      return true; // Ask for a minimum number of TRT hits to process
    } else {
      return false;
    }
  } else {
 
    // new pass, this is using the parameterization
    const DataVector<const Trk::TrackParameters>* vpar = track.trackParameters();
    const Trk::TrackParameters* par = (*vpar)[0];
    int nCutTRT = m_minTRTonTrk;
    assert( m_selectortool.isEnabled() );
    int expected = m_selectortool->minNumberDCs(par);
    if (expected > m_minTRTonTrk)
      nCutTRT = expected;
    return nTRT > nCutTRT;
  }
}

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.

passBasicSelections()

bool InDet::InDetTrtTrackScoringTool::passBasicSelections ( const Trk::Track & track ) const

overridevirtual

check track selections independent from TrackSummary

Reject track below the pT cut

Implements Trk::ITrackScoringTool.

Definition at line 55 of file InDetTrtTrackScoringTool.cxx.

{
 // get parameters without error - this is faster
  const Trk::TrackParameters* input = track.trackParameters()->front();

 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{ m_fieldCacheCondObjInputKey, ctx };
  const AtlasFieldCacheCondObj* fieldCondObj{ *readHandle };
  if (fieldCondObj == nullptr) {
    ATH_MSG_ERROR("simpleScore: Failed to retrieve AtlasFieldCacheCondObj with key "
                  << m_fieldCacheCondObjInputKey.key());
    return false;
  }
  MagField::AtlasFieldCache fieldCache;
  fieldCondObj->getInitializedCache(fieldCache);
 
  if (fieldCache.solenoidOn()) { // B field
    if (input->pT() < m_ptmin) {
      ATH_MSG_DEBUG("Reject track below Pt cut !");
      return false;
    }
  }
 
  if (std::abs(input->eta()) > m_maxEta) {
    return false;
  }
 
  return true;
}

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();
  }

score()

Trk::TrackScore InDet::InDetTrtTrackScoringTool::score ( const Trk::Track & track, bool checkBasicSel ) const

overridevirtual

create a score based on how good the passed track is

Implements Trk::ITrackScoringTool.

Definition at line 90 of file InDetTrtTrackScoringTool.cxx.

{
  if(checkBasicSel && !passBasicSelections(track)){
    ATH_MSG_VERBOSE ("Track fail basic selections");
    return Trk::TrackScore(0);
  }
  if (!track.trackSummary()) {
    ATH_MSG_FATAL("Track without a summary");
  }
  Trk::TrackScore score = Trk::TrackScore(simpleScore(track, *track.trackSummary()));
  return score;
}

setupTRT_ScoreModifiers()

void InDet::InDetTrtTrackScoringTool::setupTRT_ScoreModifiers ( )

private

Definition at line 263 of file InDetTrtTrackScoringTool.cxx.

{
 
  //
  // --- ratio of TRT hits over expected
  //
  constexpr int maxTrtRatio = 7;
  constexpr double TrtRatioBounds[maxTrtRatio + 1] = { 0,   0.2, 0.4, 0.6,
                                                       0.8, 1.0, 1.2, 2.4 };
  // this needs tuning !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  constexpr double goodTrtRatio[maxTrtRatio] = { 0.05, 0.11, 0.12, 0.15,
                                                 0.20, 0.16, 0.17 };
  constexpr double fakeTrtRatio[maxTrtRatio] = { 0.6,  0.08, 0.06, 0.05,
                                                 0.04, 0.03, 0.03 };
  // put it into the private members
  m_maxTrtRatio = m_selectortool.isEnabled() ? maxTrtRatio : 0;
  for (int i = 0; i < m_maxTrtRatio; ++i)
    m_factorTrtRatio.push_back(goodTrtRatio[i] / fakeTrtRatio[i]);
  for (int i = 0; i <= m_maxTrtRatio; ++i)
    m_boundsTrtRatio.push_back(TrtRatioBounds[i]);
 
  //
  // --- ratio of TRT fitted to (fitted+outliers)
  //
  const int maxTrtFittedRatio = 4;
  const double TrtFittedRatioBounds[maxTrtFittedRatio + 1] = { 0, 0.3, 0.6, 0.9, 1.0 };
  // this needs tuning !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  const double goodTrtFittedRatio[maxTrtFittedRatio] = { 0.1, 0.2, 0.3, 0.5 };
  const double fakeTrtFittedRatio[maxTrtFittedRatio] = { 0.6, 0.1, 0.1, 0.1 };
  // put it into the private members
  m_maxTrtFittedRatio = maxTrtFittedRatio;
  for (int i = 0; i < m_maxTrtFittedRatio; ++i)
    m_factorTrtFittedRatio.push_back(goodTrtFittedRatio[i] / fakeTrtFittedRatio[i]);
  for (int i = 0; i <= m_maxTrtFittedRatio; ++i)
    m_boundsTrtFittedRatio.push_back(TrtFittedRatioBounds[i]);
 
  //
  // --- sigma chi2
  //
  if (!m_useSigmaChi2) {
    // do not use it !
    m_maxSigmaChi2 = -1;
  } else {
    constexpr int maxSigmaChi2 = 26;
    constexpr double SigmaChi2Bounds[maxSigmaChi2 + 1] = {
      -5.0, -4.5, -4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0,
      -0.5, 0.0,  0.5,  1.0,  1.5,  2.0,  2.5,  3.0,  3.5,
      4.0,  4.5,  5.0,  5.5,  6.0,  6.5,  7.0,  7.5,  8.0
    };
    constexpr double modiSigmaChi2[maxSigmaChi2] = {
      0.0001, 0.0001, 0.0001, 0.0001, 0.001,  0.005,  0.024,  0.255, 0.644,
      0.045,  0.008,  0.005,  0.004,  0.003,  0.002,  0.001,  0.001, 0.001,
      0.001,  0.001,  0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001
    };
    constexpr double vetoSigmaChi2[maxSigmaChi2] = {
      0.001, 0.001, 0.001, 0.003, 0.014, 0.030, 0.079, 0.244, 0.295,
      0.064, 0.029, 0.028, 0.030, 0.026, 0.023, 0.023, 0.021, 0.019,
      0.016, 0.018, 0.012, 0.009, 0.007, 0.005, 0.001, 0.001
    };
    // put it into the private members
    m_maxSigmaChi2 = maxSigmaChi2;
    for (int i = 0; i < maxSigmaChi2; ++i) {
      if (vetoSigmaChi2[i] == 0.0)
        m_factorSigmaChi2.push_back(1.0);
      else
        m_factorSigmaChi2.push_back(modiSigmaChi2[i] / vetoSigmaChi2[i]);
    }
    for (int i = 0; i < maxSigmaChi2; ++i)
      m_boundsSigmaChi2.push_back(SigmaChi2Bounds[i]);
  }
}

simpleScore()

Trk::TrackScore InDet::InDetTrtTrackScoringTool::simpleScore ( const Trk::Track & track, const Trk::TrackSummary & trackSum ) const

overridevirtual

create a score based on how good the passed TrackSummary is

Implements Trk::ITrackScoringTool.

Definition at line 106 of file InDetTrtTrackScoringTool.cxx.

{
  int numTRT = trackSummary.get(Trk::numberOfTRTHits);
  int numTRTTube = trackSummary.get(Trk::numberOfTRTTubeHits);
 
  // TRT precision hits cut
  if (numTRT >= 15 && ((double)(numTRT - numTRTTube)) / numTRT < m_minTRTprecision) {
    return Trk::TrackScore(0);
  }
 
  const Trk::Perigee* perigee = track.perigeeParameters();
  int numTRT_plusOutliers = numTRT + trackSummary.get(Trk::numberOfTRTOutliers);
  unsigned int eta_bin = getEtaBin(*perigee);
  double minTRT = getMuDependentNtrtMinCut(eta_bin);
 
  // nTRT cut from egamma optimization
  if (numTRT_plusOutliers < minTRT) {
    return Trk::TrackScore(0);
  }
 
  // Cut on the minimum number of hits
  bool isGood = m_selectortool.isEnabled() ? isGoodTRT(track) : true;
  if (!isGood) {
    return Trk::TrackScore(0);
  }
 
  //
  // --- Now Start Scoring
  //
 
  if (m_useAmbigFcn) {
 
    //
    //  -- modern score
    //
    return TRT_ambigScore(track, trackSummary);
 
  } else {
 
    //
    // --classical scoring !
    //
    // score of 100 per track
    Trk::TrackScore score(100);
    // --- summary score analysis
    for (int i = 0; i < Trk::numberOfTrackSummaryTypes; ++i) {
      int value = trackSummary.get(static_cast<Trk::SummaryType>(i));
      // value is -1 if undefined.
      if (value > 0) {
        score += m_summaryTypeScore[i] * value;
      }
    }
    // --- prob(chi2,NDF), protect for chi2 <= 0
    if (track.fitQuality() != nullptr && track.fitQuality()->chiSquared() > 0 && track.fitQuality()->numberDoF() > 0) {
      double p = 1.0 - Genfun::CumulativeChiSquare(track.fitQuality()->numberDoF())(track.fitQuality()->chiSquared());
      if (p > 0)
        score += log10(p);
      else
        score -= 50;
    }
    return score;
  }
}

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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

TRT_ambigScore()

Trk::TrackScore InDet::InDetTrtTrackScoringTool::TRT_ambigScore	(	const Trk::Track &	track,
		const Trk::TrackSummary &	trackSum ) const

Definition at line 173 of file InDetTrtTrackScoringTool.cxx.

{
  //
  // --- start with bonus for high pt tracks
  //
  // double prob = 1.;
  double pt = std::abs(track.trackParameters()->front()->pT());
  double prob = log10(pt) - 1.; // 100 MeV is min and gets score 1
 
  //
  // --- special treatment for TRT hits
  //
  int iTRT_Hits = trackSummary.get(Trk::numberOfTRTHits);
  int iTRT_Outliers = trackSummary.get(Trk::numberOfTRTOutliers);
  //
 
  if (iTRT_Hits > 0 && m_maxTrtRatio > 0) {
    // get expected number of TRT hits
    double nTrtExpected = 30.;
    assert( m_selectortool.isEnabled());
    nTrtExpected = m_selectortool->minNumberDCs(track.trackParameters()->front());
    double ratio = iTRT_Hits / nTrtExpected;
    if (ratio > m_boundsTrtRatio[m_maxTrtRatio])
      ratio = m_boundsTrtRatio[m_maxTrtRatio];
    for (int i = 0; i < m_maxTrtRatio; ++i) {
      if (m_boundsTrtRatio[i] < ratio && ratio <= m_boundsTrtRatio[i + 1]) {
        prob *= m_factorTrtRatio[i];
        break;
      }
    }
  }
 
  if (iTRT_Hits > 0 && iTRT_Outliers >= 0 && m_maxTrtFittedRatio > 0) {
    double fitted = double(iTRT_Hits) / double(iTRT_Hits + iTRT_Outliers);
    if (fitted > m_boundsTrtFittedRatio[m_maxTrtFittedRatio])
      fitted = m_boundsTrtFittedRatio[m_maxTrtFittedRatio];
    for (int i = 0; i < m_maxTrtFittedRatio; ++i) {
      if (fitted <= m_boundsTrtFittedRatio[i + 1]) {
        prob *= m_factorTrtFittedRatio[i];
        break;
      }
    }
  }
 
  //
  // --- non binned Chi2
 
  if (track.fitQuality() != nullptr && track.fitQuality()->chiSquared() > 0 && track.fitQuality()->numberDoF() > 0) {
    int indf = track.fitQuality()->numberDoF();
    double chi2 = track.fitQuality()->chiSquared();
    double fac = 1. / log10(10. + 10. * chi2 / indf); // very soft chi2
    prob *= fac;
  }
 
  //
  // --- do we use the binned prob for chi2/NDF or sigma chi2 ?
  //
  if ((m_useSigmaChi2) && track.fitQuality()) {
    int indf = track.fitQuality()->numberDoF();
    double ichi2 = track.fitQuality()->chiSquared();
    if (indf > 0) {
      //
      // --- binned sigma chi2 score
      //
      if (m_useSigmaChi2) {
        int sigmaChi2times100 = trackSummary.get(Trk::standardDeviationOfChi2OS);
        if (sigmaChi2times100 > 0) {
          double testvar = double(sigmaChi2times100) / 100. - sqrt(2. * ichi2 / indf);
          if (testvar < m_boundsSigmaChi2[0]) {
            prob *= m_factorSigmaChi2[0];
          } else if (m_boundsSigmaChi2[m_maxSigmaChi2] <= testvar) {
            prob *= m_factorSigmaChi2[m_maxSigmaChi2 - 1];
          } else {
            for (int i = 0; i < m_maxSigmaChi2; ++i) {
              if (m_boundsSigmaChi2[i] <= testvar && testvar < m_boundsSigmaChi2[i + 1]) {
                prob *= m_factorSigmaChi2[i];
              }
            }
          }
        }
      }
    }
  }
 
  Trk::TrackScore score(prob);
  return score;
}

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_boundsSigmaChi2

std::vector<double> InDet::InDetTrtTrackScoringTool::m_boundsSigmaChi2

private

Definition at line 80 of file InDetTrtTrackScoringTool.h.

m_boundsTrtFittedRatio

std::vector<double> InDet::InDetTrtTrackScoringTool::m_boundsTrtFittedRatio

private

Definition at line 81 of file InDetTrtTrackScoringTool.h.

m_boundsTrtRatio

std::vector<double> InDet::InDetTrtTrackScoringTool::m_boundsTrtRatio

private

Definition at line 80 of file InDetTrtTrackScoringTool.h.

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_factorSigmaChi2

std::vector<double> InDet::InDetTrtTrackScoringTool::m_factorSigmaChi2

private

Definition at line 77 of file InDetTrtTrackScoringTool.h.

m_factorTrtFittedRatio

std::vector<double> InDet::InDetTrtTrackScoringTool::m_factorTrtFittedRatio

private

Definition at line 78 of file InDetTrtTrackScoringTool.h.

m_factorTrtRatio

std::vector<double> InDet::InDetTrtTrackScoringTool::m_factorTrtRatio

private

Definition at line 77 of file InDetTrtTrackScoringTool.h.

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::InDetTrtTrackScoringTool::m_fieldCacheCondObjInputKey

private

Initial value:

{
    this,
    "AtlasFieldCacheCondObj",
    "fieldCondObj",
    "Name of the Magnetic Field conditions object key"
  }

Definition at line 96 of file InDetTrtTrackScoringTool.h.

                                                                         {
    this,
    "AtlasFieldCacheCondObj",
    "fieldCondObj",
    "Name of the Magnetic Field conditions object key"
  };

m_lumiBlockMuTool

ToolHandle<ILumiBlockMuTool> InDet::InDetTrtTrackScoringTool::m_lumiBlockMuTool

private

Initial value:

{
    this,
    "LuminosityTool",
    "LumiBlockMuTool/LumiBlockMuTool",
    "Luminosity Tool"
  }

Definition at line 103 of file InDetTrtTrackScoringTool.h.

                                                {
    this,
    "LuminosityTool",
    "LumiBlockMuTool/LumiBlockMuTool",
    "Luminosity Tool"
  };

m_maxEta

DoubleProperty InDet::InDetTrtTrackScoringTool::m_maxEta {this, "maxEta", 2.1, "maximal Eta cut"}

private

Definition at line 113 of file InDetTrtTrackScoringTool.h.

{this, "maxEta", 2.1, "maximal Eta cut"};

m_maxSigmaChi2

int InDet::InDetTrtTrackScoringTool::m_maxSigmaChi2 = -1

private

Definition at line 75 of file InDetTrtTrackScoringTool.h.

m_maxTrtFittedRatio

int InDet::InDetTrtTrackScoringTool::m_maxTrtFittedRatio = -1

private

Definition at line 75 of file InDetTrtTrackScoringTool.h.

m_maxTrtRatio

int InDet::InDetTrtTrackScoringTool::m_maxTrtRatio = -1

private

Definition at line 75 of file InDetTrtTrackScoringTool.h.

m_minTRTonTrk

IntegerProperty InDet::InDetTrtTrackScoringTool::m_minTRTonTrk {this, "minTRTonTrk", 15, "minimum number of TRT hits"}

private

cuts for selecting good tracks

Definition at line 111 of file InDetTrtTrackScoringTool.h.

{this, "minTRTonTrk", 15, "minimum number of TRT hits"};

m_minTRTprecision

DoubleProperty InDet::InDetTrtTrackScoringTool::m_minTRTprecision {this, "minTRTPrecisionFraction", 0.5, "minimum fraction of TRT precision hits"}

private

Definition at line 119 of file InDetTrtTrackScoringTool.h.

{this, "minTRTPrecisionFraction", 0.5, "minimum fraction of TRT precision hits"};

m_oldLogic

BooleanProperty InDet::InDetTrtTrackScoringTool::m_oldLogic {this, "OldTransitionLogic", false, "use old transition hit logic"}

private

Definition at line 117 of file InDetTrtTrackScoringTool.h.

{this, "OldTransitionLogic", false, "use old transition hit logic"};

m_parameterization

BooleanProperty InDet::InDetTrtTrackScoringTool::m_parameterization {this, "UseParameterization", true, "use parameterization to cut instead of custom cut"}

private

Definition at line 115 of file InDetTrtTrackScoringTool.h.

{this, "UseParameterization", true, "use parameterization to cut instead of custom cut"};

m_ptmin

DoubleProperty InDet::InDetTrtTrackScoringTool::m_ptmin {this, "PtMin", 1.0, "Minimum Pt"}

private

Definition at line 114 of file InDetTrtTrackScoringTool.h.

{this, "PtMin", 1.0, "Minimum Pt"};

m_selectortool

ToolHandle<ITrtDriftCircleCutTool> InDet::InDetTrtTrackScoringTool::m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}

private

Returns minimum number of expected TRT drift circles depending on eta.

Definition at line 92 of file InDetTrtTrackScoringTool.h.

{this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"};

m_summaryTypeScore

std::vector<Trk::TrackScore> InDet::InDetTrtTrackScoringTool::m_summaryTypeScore

private

holds the scores assigned to each Trk::SummaryType from the track's Trk::TrackSummary

Definition at line 89 of file InDetTrtTrackScoringTool.h.

m_trtId

const TRT_ID* InDet::InDetTrtTrackScoringTool::m_trtId

private

ID TRT helper.

Definition at line 72 of file InDetTrtTrackScoringTool.h.

m_TRTTrksEtaBins

DoubleArrayProperty InDet::InDetTrtTrackScoringTool::m_TRTTrksEtaBins

private

Initial value:

{this, "TRTTrksEtaBins",
     {999., 999., 999., 999., 999., 999., 999., 999., 999., 999.},
     "Eta bins (10 expected) for TRT-only track cuts"}

Definition at line 122 of file InDetTrtTrackScoringTool.h.

    {this, "TRTTrksEtaBins",
     {999., 999., 999., 999., 999., 999., 999., 999., 999., 999.},
     "Eta bins (10 expected) for TRT-only track cuts"};

m_TRTTrksMinTRTHitsMuDependencies

DoubleArrayProperty InDet::InDetTrtTrackScoringTool::m_TRTTrksMinTRTHitsMuDependencies

private

Initial value:

{this, "TRTTrksMinTRTHitsMuDependencies",
     {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.},
     "Eta-bined Mu-dependent component for nTRT cut"}

Definition at line 130 of file InDetTrtTrackScoringTool.h.

    {this, "TRTTrksMinTRTHitsMuDependencies",
     {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.},
     "Eta-bined Mu-dependent component for nTRT cut"};

m_TRTTrksMinTRTHitsThresholds

DoubleArrayProperty InDet::InDetTrtTrackScoringTool::m_TRTTrksMinTRTHitsThresholds

private

Initial value:

{this, "TRTTrksMinTRTHitsThresholds",
     {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.},
     "Eta-binned nTRT cut for TRT-only cuts"}

Definition at line 126 of file InDetTrtTrackScoringTool.h.

    {this, "TRTTrksMinTRTHitsThresholds",
     {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.},
     "Eta-binned nTRT cut for TRT-only cuts"};

m_useAmbigFcn

BooleanProperty InDet::InDetTrtTrackScoringTool::m_useAmbigFcn {this, "useAmbigFcn", true}

private

use the scoring tuned to Ambiguity processing or not

Definition at line 84 of file InDetTrtTrackScoringTool.h.

{this, "useAmbigFcn", true};

m_useSigmaChi2

BooleanProperty InDet::InDetTrtTrackScoringTool::m_useSigmaChi2 {this, "useSigmaChi2", false}

private

Definition at line 85 of file InDetTrtTrackScoringTool.h.

{this, "useSigmaChi2", false};

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:

• InDetTrtTrackScoringTool.h
• InDetTrtTrackScoringTool.cxx