InDet::InDetAmbiScoringTool Class Reference

Concrete implementation of the ITrackScoringTool pABC. More...

#include <InDetAmbiScoringTool.h>

Inheritance diagram for InDet::InDetAmbiScoringTool:

Collaboration diagram for InDet::InDetAmbiScoringTool:

Public Member Functions
	InDetAmbiScoringTool (const std::string &, const std::string &, const IInterface *)
virtual	~InDetAmbiScoringTool ()=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	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	setupScoreModifiers ()
bool	isEmCaloCompatible (const Trk::Track &track, const EventContext &ctx) const
	Check if the cluster is compatible with a EM cluster.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
int	m_maxDblHoles = -1
int	m_maxPixHoles = -1
int	m_maxSCT_Holes = -1
int	m_maxHits = -1
int	m_maxSigmaChi2 = -1
int	m_maxTrtRatio = -1
int	m_maxTrtFittedRatio = -1
int	m_maxB_LayerHits = -1
int	m_maxPixelHits = -1
int	m_maxPixLay = -1
int	m_maxGangedFakes = -1
std::vector< double >	m_factorDblHoles
std::vector< double >	m_factorPixHoles
std::vector< double >	m_factorSCT_Holes
std::vector< double >	m_factorHits
std::vector< double >	m_factorSigmaChi2
std::vector< double >	m_factorB_LayerHits
std::vector< double >	m_factorPixelHits
std::vector< double >	m_factorPixLay
std::vector< double >	m_factorGangedFakes
std::vector< double >	m_boundsSigmaChi2
std::vector< double >	m_boundsTrtRatio
std::vector< double >	m_factorTrtRatio
std::vector< double >	m_boundsTrtFittedRatio
std::vector< double >	m_factorTrtFittedRatio
ToolHandle< ITrtDriftCircleCutTool >	m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}
	Returns minimum number of expected TRT drift circles depending on eta.
std::vector< Trk::TrackScore >	m_summaryTypeScore
	holds the scores assigned to each Trk::SummaryType from the track's Trk::TrackSummary
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}
BooleanProperty	m_useAmbigFcn {this, "useAmbigFcn", true}
	use the scoring tuned to Ambiguity processing or not
BooleanProperty	m_useTRT_AmbigFcn {this, "useTRT_AmbigFcn", false}
BooleanProperty	m_useSigmaChi2 {this, "useSigmaChi2", false}
BooleanProperty	m_usePixel {this, "usePixel", true}
BooleanProperty	m_useSCT {this, "useSCT", true}
DoubleProperty	m_minPt {this, "minPt", 500., "minimal Pt cut"}
	cuts for selecting good tracks
DoubleProperty	m_maxEta {this, "maxEta", 2.7, "maximal Eta cut"}
DoubleProperty	m_maxRPhiImp {this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"}
DoubleProperty	m_maxZImp {this, "maxZImp", 250., "maximal z impact parameter cut"}
IntegerProperty	m_minSiClusters {this, "minSiClusters", 7, "minimal number of Si clusters"}
IntegerProperty	m_maxDoubleHoles {this, "maxDoubleHoles", 2, "maximum number of SCT double holes"}
IntegerProperty	m_maxSiHoles {this, "maxSiHoles", 5, "max number of Silicon (Pixel+SCT) holes"}
IntegerProperty	m_maxPixelHoles {this, "maxPixelHoles", 5, "max number of Pixel holes"}
IntegerProperty	m_maxSctHoles {this, "maxSCTHoles", 5, "max number of SCT holes"}
IntegerProperty	m_minTRTonTrk {this, "minTRTonTrk", 9, "minimum number of TRT hits"}
DoubleProperty	m_minTRTprecision {this, "minTRTPrecisionFraction", 0.5, "minimum fraction of TRT precision hits"}
IntegerProperty	m_minPixel {this, "minPixel", 0, "minimum number of pixel clusters"}
DoubleProperty	m_maxRPhiImpEM {this, "maxRPhiImpEM", 50., "maximal RPhi impact parameter cut track that match EM clusters"}
BooleanProperty	m_useEmClusSeed {this, "doEmCaloSeed", true}
FloatProperty	m_phiWidthEm {this, "phiWidthEM", 0.075}
FloatProperty	m_etaWidthEm {this, "etaWidthEM", 0.05}
SG::ReadHandleKey< ROIPhiRZContainer >	m_caloClusterROIKey {this, "EMROIPhiRZContainer", "", "Name of the calo cluster ROIs in Phi,R,Z parameterization"}
BooleanProperty	m_useITkAmbigFcn {this, "useITkAmbigFcn", false}
	use the ITk scoring tuned to Ambiguity processing or not
ServiceHandle< IInDetEtaDependentCutsSvc >	m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", ""}
	ITk eta-dependent cuts.
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 42 of file InDetAmbiScoringTool.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

InDetAmbiScoringTool()

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

Definition at line 22 of file InDetAmbiScoringTool.cxx.

                                     :
  AthAlgTool(t,n,p),
  m_summaryTypeScore(Trk::numberOfTrackSummaryTypes)
{
  declareInterface<Trk::ITrackScoringTool>(this);
 
  //set values for scores
  m_summaryTypeScore[Trk::numberOfPixelHits]            =  20;
  m_summaryTypeScore[Trk::numberOfPixelHoles]           = -10;  // a hole is bad
  m_summaryTypeScore[Trk::numberOfInnermostPixelLayerHits]           =  10;  // addition for being b-layer
  m_summaryTypeScore[Trk::numberOfGangedPixels]         =  -5;  // decrease for being ganged
  m_summaryTypeScore[Trk::numberOfGangedFlaggedFakes]   = -10;  // decrease for being ganged fake
  m_summaryTypeScore[Trk::numberOfSCTHits]              =  10;  // half of a pixel, since only 1dim
  m_summaryTypeScore[Trk::numberOfSCTHoles]             =  -5;  // a hole is bad !
  m_summaryTypeScore[Trk::numberOfSCTDoubleHoles]       = -15;  // a double hole is even worse !
  m_summaryTypeScore[Trk::numberOfTRTHits]              =   1;  // 10 straws ~ 1 SCT
  m_summaryTypeScore[Trk::numberOfTRTHighThresholdHits] =   0;  // addition for being TR
  m_summaryTypeScore[Trk::numberOfOutliersOnTrack]      =  -1;  // -ME- TRT oulier should not kill 5 TRT on track (was -5)
 
  // scoring for Muons not needed
  m_summaryTypeScore[Trk::numberOfMdtHits]    = 0;
  m_summaryTypeScore[Trk::numberOfTgcPhiHits] = 0;
  m_summaryTypeScore[Trk::numberOfTgcEtaHits] = 0;
  m_summaryTypeScore[Trk::numberOfCscPhiHits] = 0;
  m_summaryTypeScore[Trk::numberOfCscEtaHits] = 0;
  m_summaryTypeScore[Trk::numberOfRpcPhiHits] = 0;
  m_summaryTypeScore[Trk::numberOfRpcEtaHits] = 0;
 
}

~InDetAmbiScoringTool()

virtual InDet::InDetAmbiScoringTool::~InDetAmbiScoringTool ( )

virtualdefault

Member Function Documentation

ambigScore()

Trk::TrackScore InDet::InDetAmbiScoringTool::ambigScore	(	const Trk::Track &	track,
		const Trk::TrackSummary &	trackSum ) const

Definition at line 331 of file InDetAmbiScoringTool.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
  ATH_MSG_DEBUG ("Modifier for pt = " << pt / 1000. << " GeV is: "<< prob);
 
  //
  // --- prob and cuts on holes
  //
  if (m_usePixel) {
    // --- Pixel holes
    int iPixHoles = trackSummary.get(Trk::numberOfPixelHoles);
    if ( iPixHoles > -1 && m_maxPixHoles > 0) {
      if (iPixHoles > m_maxPixHoles) {
        prob /= (iPixHoles - m_maxPixHoles + 1); // holes are bad !
        iPixHoles = m_maxPixHoles;
      }
      prob *= m_factorPixHoles[iPixHoles];
      ATH_MSG_DEBUG ("Modifier for " << iPixHoles << " Pixel holes: "<<m_factorPixHoles[iPixHoles]
         << "  New score now: " << prob);
    }
  }
 
  if (m_useSCT) {
    // --- SCT holes
    int iSCT_Holes = trackSummary.get(Trk::numberOfSCTHoles);
    if (iSCT_Holes > -1 && m_maxSCT_Holes > 0) {
      if (iSCT_Holes > m_maxSCT_Holes) {
        prob /= (iSCT_Holes - m_maxSCT_Holes + 1); // holes are bad !
        iSCT_Holes = m_maxSCT_Holes;
      }
      prob *= m_factorSCT_Holes[iSCT_Holes];
      ATH_MSG_DEBUG ("Modifier for " << iSCT_Holes << " SCT holes: "<<m_factorSCT_Holes[iSCT_Holes]
         << "  New score now: " << prob);
    }
    // --- SCT double holes
    int iDblHoles = trackSummary.get(Trk::numberOfSCTDoubleHoles);
    if (iDblHoles > -1 && m_maxDblHoles > 0) {
      if (iDblHoles > m_maxDblHoles) {
        prob /= (iDblHoles - m_maxDblHoles + 1); // holes are bad !
        iDblHoles = m_maxDblHoles;
      }
      prob *= m_factorDblHoles[iDblHoles];
      ATH_MSG_DEBUG ("Modifier for " << iDblHoles << " double holes: "<<m_factorDblHoles[iDblHoles]
         << "  New score now: " << prob);
    }
  }
  //
  // --- prob for other counters
  //
  if (m_usePixel) {
 
    // ME: this if statement needs to be removed...
    // --- count layers only if holes are not searched for
    // if (trackSummary.get(Trk::numberOfPixelHoles) == -1) {
 
    // --- Pixel layers
    int iPixLay = trackSummary.get(Trk::numberOfContribPixelLayers);
    if (iPixLay > -1 && m_maxPixLay > 0) {
      if (iPixLay > m_maxPixLay) {
        prob *= (iPixLay - m_maxPixLay + 1); // layers are good !
        iPixLay = m_maxPixLay;
      }
      prob *= m_factorPixLay[iPixLay];
      ATH_MSG_DEBUG ("Modifier for " << iPixLay << " Pixel layers: "<<m_factorPixLay[iPixLay]
         << "  New score now: " << prob);
    }
 
    // --- Pixel hits
    int pixelHits = trackSummary.get(Trk::numberOfPixelHits);
    if (pixelHits > -1 && m_maxPixelHits > 0) {
      if (pixelHits > m_maxPixelHits) {
        prob *= (pixelHits - m_maxPixelHits + 1); // hits are good !
        pixelHits = m_maxPixelHits;
      }
      prob *= m_factorPixelHits[pixelHits];
      ATH_MSG_DEBUG ("Modifier for " << pixelHits << " Pixel hits: "<<m_factorPixelHits[pixelHits]
         << "  New score now: " << prob);
    }
    // --- Pixel blayer hits
    int bLayerHits = trackSummary.get(Trk::numberOfInnermostPixelLayerHits);
    if (bLayerHits > -1 && m_maxB_LayerHits > 0) {
      if (bLayerHits > m_maxB_LayerHits) {
        prob *= (bLayerHits - m_maxB_LayerHits + 1); // hits are good !
        bLayerHits = m_maxB_LayerHits;
      }
      prob *= m_factorB_LayerHits[bLayerHits];
      ATH_MSG_DEBUG ("Modifier for " << bLayerHits << " b-layer hits: "<<m_factorB_LayerHits[bLayerHits]
         << "  New score now: " << prob);
    }
    // --- Pixel Ganged fakes
    int pixelGangedFakes = trackSummary.get(Trk::numberOfGangedFlaggedFakes);
    if (pixelGangedFakes > -1 && m_maxGangedFakes > 0) {
      if (pixelGangedFakes > m_maxGangedFakes) {
        prob /= (pixelGangedFakes - m_maxGangedFakes + 1); // ganged are bad !
        pixelGangedFakes = m_maxGangedFakes;
      }
      prob *= m_factorGangedFakes[pixelGangedFakes];
      ATH_MSG_DEBUG ("Modifier for " << pixelGangedFakes << " ganged fakes hits: "<<m_factorGangedFakes[pixelGangedFakes]
         << "  New score now: " << prob);
    }
  }
 
  int iHits = 0;
  iHits += m_usePixel ? trackSummary.get(Trk::numberOfPixelHits) : 3;  // if Pixel off, do not count as inefficient
  iHits += m_useSCT   ? trackSummary.get(Trk::numberOfSCTHits)   : 8;  // if SCT off, do not count as inefficient
  if (iHits > -1 && m_maxHits > 0) {
    if (iHits > m_maxHits) {
      prob *= (iHits - m_maxHits + 1); // hits are good !
      iHits = m_maxHits;
    }
    prob *= m_factorHits[iHits];
    ATH_MSG_DEBUG ("Modifier for " << iHits << " Sihits: "<<m_factorHits[iHits]
       << "  New score now: " << prob);
  }
 
  //
  // --- special treatment for TRT hits
  //
  if (!m_useITkAmbigFcn) {
    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());
      ATH_MSG_DEBUG ("Expected number of TRT hits: " << nTrtExpected << " for eta: "
       << std::abs(track.trackParameters()->front()->eta()));
      double ratio = (nTrtExpected != 0) ? iTRT_Hits / nTrtExpected : 0;
      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];
          ATH_MSG_DEBUG ("Modifier for " << iTRT_Hits << " TRT hits (ratio " << ratio
                 << ") is : "<< m_factorTrtRatio[i] << "  New score now: " << prob);
          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];
            ATH_MSG_DEBUG ("Modifier for TRT fitted ratio of " << fitted
                << " is : "<< m_factorTrtFittedRatio[i] << "  New score now: " << prob);
            break;
          }
      }
    }
  } // end if(!m_useITkAmbigFcn)
 
  // is this a track from the pattern or a fitted track ?
  bool ispatterntrack = (track.info().trackFitter()==Trk::TrackInfo::Unknown);
 
  //
  // --- non binned Chi2
  //
  if (!ispatterntrack) {
    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;
      ATH_MSG_DEBUG ("Modifier for chi2 = " << chi2 << " and NDF = " << indf
         << " is : "<< fac << "  New score now: " << prob);
 
    }
  }
  //
  // --- fit quality prob
  //
  if ( !ispatterntrack && (m_useSigmaChi2) && track.fitQuality() ) {
 
    int    ndf  = track.fitQuality()->numberDoF();
    double chi2 = track.fitQuality()->chiSquared();
    if (ndf > 0) {
      //
      // --- special variable for bad chi2 distribution
      //
      if (m_useSigmaChi2) {
        int sigmaChi2times100 = trackSummary.get(Trk::standardDeviationOfChi2OS);
        if (sigmaChi2times100 > 0) {
          double  testvar = double(sigmaChi2times100)/100. - sqrt(2.*chi2/ndf);
          if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << "sigma chi2 = " << testvar << endmsg;
          if ( testvar< m_boundsSigmaChi2[0] ) {
            prob *= m_factorSigmaChi2[0];
            ATH_MSG_DEBUG ("Modifier for " << testvar << " sigma chi2: "<< m_factorSigmaChi2[0]
               << "  New score now: " << prob);
          } else if (m_boundsSigmaChi2[m_maxSigmaChi2] <= testvar) {
            prob *= m_factorSigmaChi2[m_maxSigmaChi2-1];
            ATH_MSG_DEBUG ("Modifier for " << testvar << " sigma chi2: "<< m_factorSigmaChi2[m_maxSigmaChi2-1]
               << "  New score now: " << prob);
          } else {
            for (int i = 0 ; i<m_maxSigmaChi2 ; ++i ) {
              if ( m_boundsSigmaChi2[i]<=testvar && testvar<m_boundsSigmaChi2[i+1] ) {
          prob *= m_factorSigmaChi2[i];
          ATH_MSG_DEBUG ("Modifier for " << testvar << " sigma chi2: "<< m_factorSigmaChi2[i]
                   << "  New score now: " << prob);
          break;
              }
            }
          }
        }
      }
    }
  }
 
  return Trk::TrackScore(prob);
}

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

initialize()

StatusCode InDet::InDetAmbiScoringTool::initialize ( )

overridevirtual

Definition at line 56 of file InDetAmbiScoringTool.cxx.

{
  StatusCode sc = AlgTool::initialize();
  if (sc.isFailure()) return sc;
 
  sc = m_extrapolator.retrieve();
  if (sc.isFailure()) {
    msg(MSG::FATAL) << "Failed to retrieve tool " << m_extrapolator << endmsg;
    return StatusCode::FAILURE;
  } else
    msg(MSG::DEBUG) << "Retrieved tool " << m_extrapolator << endmsg;
 
  // Get segment selector tool
  //
  ATH_CHECK(m_selectortool.retrieve( DisableTool{m_selectortool.empty()} ) );
 
  ATH_CHECK(m_beamSpotKey.initialize());
 
  if (m_useAmbigFcn && m_useTRT_AmbigFcn) {
    msg(MSG::FATAL) << "Both on, normal ambi funciton and the one for back tracking, configuration problem, not recoverable" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Read handle for AtlasFieldCacheCondObj
  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
 
  if (not m_etaDependentCutsSvc.name().empty()) ATH_CHECK(m_etaDependentCutsSvc.retrieve());
 
  if (m_useAmbigFcn || m_useTRT_AmbigFcn) setupScoreModifiers();
 
  ATH_CHECK( m_caloClusterROIKey.initialize(m_useEmClusSeed) );
 
  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;
}

isEmCaloCompatible()

bool InDet::InDetAmbiScoringTool::isEmCaloCompatible ( const Trk::Track & track, const EventContext & ctx ) const

private

Check if the cluster is compatible with a EM cluster.

Definition at line 842 of file InDetAmbiScoringTool.cxx.

{
  const Trk::TrackParameters * Tp = track.trackParameters()->front();
 
  //Switch to the track parameters of the first measurment instead of the perigee parameters
  ATH_MSG_VERBOSE ("--> Looping over TSOS's");
  for (const auto *tsos : *track.trackStateOnSurfaces() ) {
    // get measurment from TSOS
    const auto *meas = tsos->measurementOnTrack();
    const auto *tp = tsos->trackParameters();
    // if we do not have a measurement, we should just mark it
    if (!meas || !tp) {
      continue;
    } else {
      Tp = tp;
      break;
    }
  }
 
  double F = Tp->momentum().phi();
  double E = Tp->momentum().eta();
  double R = Tp->position().perp();
  double Z = Tp->position().z();
  SG::ReadHandle<ROIPhiRZContainer> calo(m_caloClusterROIKey, ctx);
  return calo->hasMatchingROI(F, E,  R, Z, m_phiWidthEm, m_etaWidthEm);
}

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::InDetAmbiScoringTool::passBasicSelections ( const Trk::Track & track ) const

overridevirtual

check track selections independent from TrackSummary

Implements Trk::ITrackScoringTool.

Definition at line 92 of file InDetAmbiScoringTool.cxx.

{
  //
  // --- kinematic selection (done as well on input ?)
  //
  // --- beam spot position
  Amg::Vector3D beamSpotPosition(0,0,0);
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
  if (beamSpotHandle.isValid()) beamSpotPosition = beamSpotHandle->beamVtx().position();
  // --- create surface
  Trk::PerigeeSurface perigeeSurface(beamSpotPosition);
 
  const Trk::TrackParameters* input = track.trackParameters()->front();
  double trackEta = input->eta();
 
  // cuts on parameters
  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()){
    double minPt = m_etaDependentCutsSvc.name().empty() ?
      m_minPt.value() : m_etaDependentCutsSvc->getMinPtAtEta(trackEta);
    if (std::abs(input->pT()) < minPt) {
      ATH_MSG_DEBUG ("Track pt < "<<m_minPt<<", reject it");
      return false;
    }
  }
  double maxEta = m_etaDependentCutsSvc.name().empty() ?
    m_maxEta.value() : m_etaDependentCutsSvc->getMaxEta();
  if (std::abs(input->eta()) > maxEta) {
    ATH_MSG_DEBUG ("Track eta > "<<maxEta<<", reject it");
    return false;
  }
 
  // uses perigee on track or extrapolates, no material in any case, we cut on impacts
  // add back extrapolation without errors
  std::unique_ptr<const Trk::TrackParameters> parm( m_extrapolator->extrapolateDirectly(ctx,*input, perigeeSurface) );
 
  if (!parm || parm->surfaceType()!=Trk::SurfaceType::Perigee) {
     ATH_MSG_WARNING( "Extrapolation of perigee failed, this should never happen" );
     return false;
  }
 
  ATH_MSG_VERBOSE ("extrapolated perigee: "<<*parm);
  double maxZ0 = m_etaDependentCutsSvc.name().empty() ?
    m_maxZImp.value() : m_etaDependentCutsSvc->getMaxZImpactAtEta(trackEta);
  if (std::abs(parm->parameters()[Trk::z0]) > maxZ0) {
    ATH_MSG_DEBUG ("Track Z impact > "<<maxZ0<<", reject it");
    return false;
  }
 
  double maxD0 = m_etaDependentCutsSvc.name().empty() ?
    m_maxRPhiImp.value() : m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(trackEta);
  if(m_useEmClusSeed) {
     if (isEmCaloCompatible( track, ctx ) ) {
       maxD0 = m_maxRPhiImpEM;
     }
  }
  if (std::abs(parm->parameters()[Trk::d0]) > maxD0) {
    ATH_MSG_DEBUG ("Track Rphi impact > "<<maxD0<<", reject it");
    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::InDetAmbiScoringTool::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 168 of file InDetAmbiScoringTool.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");
   }
   ATH_MSG_VERBOSE ("Track has TrackSummary "<<*track.trackSummary());
   Trk::TrackScore score = Trk::TrackScore( simpleScore(track, *track.trackSummary()) );
 
   ATH_MSG_DEBUG ("Track has Score: "<<score);
 
   return score;
}

setupScoreModifiers()

void InDet::InDetAmbiScoringTool::setupScoreModifiers ( )

private

Definition at line 552 of file InDetAmbiScoringTool.cxx.

{
  //
  // --- number of Pixel holes
  //
  // --- NewTracking and BackTracking
  const int maxPixHoles = 2; // there is an explicit cut
  const double goodPixHoles[maxPixHoles+1] = {1.0 , 0.04 , 0.004 };
  const double fakePixHoles[maxPixHoles+1] = {1.0 , 0.30 , 0.200 };
  // put it into the private members
  m_maxPixHoles = maxPixHoles;
  for (int i=0; i<=m_maxPixHoles; ++i) m_factorPixHoles.push_back(goodPixHoles[i]/fakePixHoles[i]);
 
  //
  // --- number of SCT holes
  //
  if (!m_useTRT_AmbigFcn) {
    // --- NewTracking
    const int maxSCT_Holes = 5; // moved from 3 -> 5 , there is an explicit cut anyway
    const double goodSCT_Holes[maxSCT_Holes+1] = { 1.0 , 0.06 , 0.010 , 0.0007, 0.0005, 0.0003  };
    const double fakeSCT_Holes[maxSCT_Holes+1] = { 1.0 , 0.15 , 0.100 , 0.0100, 0.0100, 0.0100 };
    // put it into the private members
    m_maxSCT_Holes = maxSCT_Holes;
    for (int i=0; i<=m_maxSCT_Holes; ++i) m_factorSCT_Holes.push_back(goodSCT_Holes[i]/fakeSCT_Holes[i]);
  } else {
    // --- BackTracking
    const int maxSCT_Holes = 6;
    const double goodSCT_Holes[maxSCT_Holes+1] = {0.910, 0.074, 0.014, 0.001, 0.001, 0.00001, 0.00001};
    const double fakeSCT_Holes[maxSCT_Holes+1] = {0.910, 0.192, 0.229, 0.061, 0.065, 0.016  , 0.025};
    // put it into the private members
    m_maxSCT_Holes = maxSCT_Holes;
    for (int i=0; i<=m_maxSCT_Holes; ++i) m_factorSCT_Holes.push_back(goodSCT_Holes[i]/fakeSCT_Holes[i]);
  }
 
  //
  // --- number of SCT double holes
  //
  // --- NewTracking and BackTracking
  const int maxDblHoles = 3; // there is a cut on this anyway !
  const double goodDblHoles[maxDblHoles+1] = { 1.  , 0.03 , 0.007 , 0.0003  };
  const double fakeDblHoles[maxDblHoles+1] = { 1.  , 0.09 , 0.09  , 0.008  };
  // put it into the private members
  m_maxDblHoles = maxDblHoles;
  for (int i=0; i<=m_maxDblHoles; ++i) m_factorDblHoles.push_back(goodDblHoles[i]/fakeDblHoles[i]);
 
  //
  // --- number of Blayer hits
  //
  if (!m_useTRT_AmbigFcn) {
    // --- NewTracking
    if (m_useITkAmbigFcn) {
      const int maxB_LayerHitsITk = 8;
      m_maxB_LayerHits = maxB_LayerHitsITk;
      const double blayModi[maxB_LayerHitsITk + 1] = {0.25, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5};
      for (int i = 0; i <= m_maxB_LayerHits; ++i) m_factorB_LayerHits.push_back(blayModi[i]);
    } else {
      const int maxB_LayerHits = 3;
      const double goodB_LayerHits[maxB_LayerHits+1] = {0.203, 0.732, 0.081, 0.010};
      const double fakeB_LayerHits[maxB_LayerHits+1] = {0.808, 0.174, 0.018, 0.002};
      // put it into the private members
      m_maxB_LayerHits = maxB_LayerHits;
      for (int i=0; i<=m_maxB_LayerHits; ++i) m_factorB_LayerHits.push_back(goodB_LayerHits[i]/fakeB_LayerHits[i]);
    }
  } else {
    // --- BackTracking
    const int maxB_LayerHits = 3;
    const double goodB_LayerHits[maxB_LayerHits+1] = {0.605, 0.349, 0.044, 0.010};
    const double fakeB_LayerHits[maxB_LayerHits+1] = {0.865, 0.124, 0.011, 0.002};
    // put it into the private members
    m_maxB_LayerHits = maxB_LayerHits;
    for (int i=0; i<=m_maxB_LayerHits; ++i) m_factorB_LayerHits.push_back(goodB_LayerHits[i]/fakeB_LayerHits[i]);
  }
 
  //
  // --- number of Pixel hits without Blayer
  //
  if (!m_useTRT_AmbigFcn) {
    // --- NewTracking
    if (m_useITkAmbigFcn) {
      const int maxPixelHitsITk = 26;
      m_maxPixelHits = maxPixelHitsITk;
      double maxScore = 30.0;
      double minScore = 5.00;
      int maxBarrel = 10;
      int minBarrel = 3;
      int minEnd = 5;
 
      double step[2] = {
        (maxScore - minScore) / (maxBarrel - minBarrel), (maxScore - minScore) / (maxPixelHitsITk - minEnd)
      };
 
      for (int i = 0; i <= maxPixelHitsITk; i++) {
        if (i < minEnd) m_factorPixelHits.push_back(0.01 + (i * 0.33));
        else m_factorPixelHits.push_back(minScore + ((i - minEnd) * step[1]));
      }
    } else {
      const int maxPixelHits = 8; // we see up to 8 with IBL (was 6)
      const double goodPixelHits[maxPixelHits+1] = {0.095, 0.031, 0.118, 0.615, 0.137, 0.011, 0.01   , 0.011, 0.012};
      const double fakePixelHits[maxPixelHits+1] = {0.658, 0.100, 0.091, 0.124, 0.026, 0.002, 0.001  , 0.001, 0.001};
      m_maxPixelHits = maxPixelHits;
      for (int i=0; i<=m_maxPixelHits; ++i) m_factorPixelHits.push_back(goodPixelHits[i]/fakePixelHits[i]);
    }
  } else {
    // --- BackTracking
    const int maxPixelHits = 8; // we see up to 8 with IBL (was 6)
    const double goodPixelHits[maxPixelHits+1] = {0.401, 0.079, 0.140, 0.291, 0.011, 0.078, 0.01   , 0.011, 0.012};
    const double fakePixelHits[maxPixelHits+1] = {0.673, 0.138, 0.113, 0.057, 0.002, 0.011, 0.001  , 0.001, 0.001};
    m_maxPixelHits = maxPixelHits;
    for (int i=0; i<=m_maxPixelHits; ++i) m_factorPixelHits.push_back(goodPixelHits[i]/fakePixelHits[i]);
  }
 
  //
  // --- number of Pixel layers
  //
  if (!m_useTRT_AmbigFcn) {
    // --- NewTracking
    if (m_useITkAmbigFcn) {
      const int maxPixelLayITk = 16;
      m_maxPixLay = maxPixelLayITk;
      double maxScore = 30.0;
      double minScore = 5.00;
      int maxBarrel = 10;
      int minBarrel = 3;
      int minEnd = 5;
 
      double step[2] = {
        (maxScore - minScore) / (maxBarrel - minBarrel), (maxScore - minScore) / (maxPixelLayITk - minEnd)
      };
 
      for (int i = 0; i <= maxPixelLayITk; i++) {
        if (i < minEnd) m_factorPixLay.push_back(0.01 + (i * 0.33));
        else m_factorPixLay.push_back(minScore + ((i - minEnd) * step[1]));
      }
    } else {
      const int maxPixLay = 7; // 3 barrel, 3 endcap, IBL, in practice one should see maybe 5 (was 3)
      const double goodPixLay[maxPixLay+1] = {0.095, 0.033, 0.131, 0.740,   0.840, 0.940, 1.040,1.140};
      const double fakePixLay[maxPixLay+1] = {0.658, 0.106, 0.092, 0.144,   0.144, 0.144, 0.144,0.144};
      // put it into the private members
      m_maxPixLay = maxPixLay;
      for (int i=0; i<=m_maxPixLay; ++i) m_factorPixLay.push_back(goodPixLay[i]/fakePixLay[i]);
    }
  } else {
    // --- BackTracking
    const int maxPixLay = 7; // 3 barrel, 3 endcap, IBL, in practice one should see maybe 5 (was 5)
    const double goodPixLay[maxPixLay+1] = {0.401, 0.088, 0.152, 0.355,   0.405, 0.455, 0.505, 0.555};
    const double fakePixLay[maxPixLay+1] = {0.673, 0.146, 0.115, 0.065,   0.065, 0.065, 0.065, 0.065};
    // put it into the private members
    m_maxPixLay = maxPixLay;
    for (int i=0; i<=m_maxPixLay; ++i) m_factorPixLay.push_back(goodPixLay[i]/fakePixLay[i]);
  }
 
  //
  // --- number of Pixel Ganged Fakes
  //
  // --- NewTracking and BackTracking
  const int maxGangedFakes = 2; // there is an explicit cut
  const double goodGangedFakes[maxGangedFakes+1] = {0.62 , 0.23 , 0.15 };
  const double fakeGangedFakes[maxGangedFakes+1] = {0.12 , 0.41 , 0.47 };
  // put it into the private members
  m_maxGangedFakes = maxGangedFakes;
  for (int i=0; i<=m_maxGangedFakes; ++i) m_factorGangedFakes.push_back(goodGangedFakes[i]/fakeGangedFakes[i]);
 
  //
  // --- total number of SCT+Pixel hits
  //
  // --- NewTracking and BackTracking
  if (m_useITkAmbigFcn) {
    const int maxHitsITk = 26;
    m_maxHits = maxHitsITk;
    double maxScore = 40.0;
    double minScore = 5.00;
    int maxBarrel = 25;
    int minBarrel = 9;
    int minEnd = 12;
 
    double step[2] = {
      (maxScore - minScore) / (maxBarrel - minBarrel), (maxScore - minScore) / (maxHitsITk - minEnd)
    };
 
    for (int i = 0; i <= maxHitsITk; i++) {
      if (i < minEnd) m_factorHits.push_back(0.01 + (i * 1.0 / minEnd));
      else m_factorHits.push_back(minScore + ((i - minEnd) * step[1]));
    }
  } else {
    const int maxHits = 19; // there is a min cut on this anyway !
    const double goodSiHits[maxHits+1] = { 0.001 , 0.002 , 0.003 , 0.004 , 0.01 , 0.01 , 0.01 ,
                       0.015 , 0.02 , 0.06 , 0.1  , 0.3  , 0.2   , 0.50 , 0.055,
                       0.03  , 0.015  , 0.010  , 0.002  , 0.0005 };
    const double fakeSiHits[maxHits+1] = { 1.0   , 1.0   , 1.0   , 1.0   , 0.5 , 0.25  , 0.15 ,
                       0.20  , 0.1  , 0.2  , 0.08 , 0.07 , 0.035 , 0.08 , 0.008,
                       0.004 , 0.0015 , 0.0008 , 0.0001 , 0.00001 };
    // put it into the private members
    m_maxHits = maxHits;
    for (int i=0; i<=m_maxHits; ++i) m_factorHits.push_back(goodSiHits[i]/fakeSiHits[i]);
  }
 
  //
  // --- ratio of TRT hits over expected
  //
  // --- NewTracking and BackTracking
  const int maxTrtRatio = 7 ;
  const double TrtRatioBounds[maxTrtRatio+1] = {  0,   0.2,  0.4,  0.6,  0.8,  1.0,  1.2, 2.4};
  // this needs tuning !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  const double goodTrtRatio[maxTrtRatio]     = {      0.05, 0.11, 0.12, 0.15, 0.20, 0.16, 0.17};
  const 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)
  //
  // --- NewTracking and BackTracking
  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) {
    m_maxSigmaChi2 = -1 ;
  } else {
    // --- NewTracking and BackTracking
    const int maxSigmaChi2 = 13 ;
    const double SigmaChi2Bounds[maxSigmaChi2+1] = { -5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,6.,7.,8.};
    const double goodSigmaChi2[maxSigmaChi2] = {0.00004, 0.0004, 0.002, 0.15, 0.8, 0.015, 0.01 , 0.009, 0.008, 0.0007 , 0.0006 , 0.0005, 0.00004};
    const double fakeSigmaChi2[maxSigmaChi2] = {0.0008 , 0.005 , 0.02 , 0.2 , 0.3, 0.1  , 0.1  , 0.1  , 0.1  , 0.01   , 0.01   , 0.01  , 0.001};
    // put it into the private members
    m_maxSigmaChi2 = maxSigmaChi2;
    for (int i=0; i<m_maxSigmaChi2; ++i) m_factorSigmaChi2.push_back(goodSigmaChi2[i]/fakeSigmaChi2[i]);
    for (int i=0; i<=m_maxSigmaChi2; ++i) m_boundsSigmaChi2.push_back(SigmaChi2Bounds[i]);
  }
 
  //
  // --- debug output
  //
  if (msgLvl(MSG::VERBOSE)) {
 
    for (int i=0; i<=m_maxPixHoles; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " Pixel holes: " << m_factorPixHoles[i] <<endmsg;
 
    for (int i=0; i<=m_maxSCT_Holes; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " SCT holes: " << m_factorSCT_Holes[i] <<endmsg;
 
    for (int i=0; i<=m_maxDblHoles; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " double SCT holes: " << m_factorDblHoles[i] <<endmsg;
 
    for (int i=0; i<=m_maxPixLay; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " Pixel layers: " << m_factorPixLay[i] <<endmsg;
 
    for (int i=0; i<=m_maxB_LayerHits; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " b-layer hits: " << m_factorB_LayerHits[i] <<endmsg;
 
    for (int i=0; i<=m_maxPixelHits; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " Pixel hits: " << m_factorPixelHits[i] <<endmsg;
 
    for (int i=0; i<=m_maxGangedFakes; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " ganged fakes: " << m_factorGangedFakes[i] <<endmsg;
 
    for (int i=0; i<=m_maxHits; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << i << " Si hits: " << m_factorHits[i] <<endmsg;
 
    if (m_selectortool.isEnabled()) {
       for (int i=0; i<m_maxTrtRatio; ++i)
          msg(MSG::VERBOSE) << "Modifier for " << m_boundsTrtRatio[i] << " < TRT ratio  < "
                            << m_boundsTrtRatio[i+1] <<"  : " <<m_factorTrtRatio[i] <<endmsg;
    }
 
    for (int i=0; i<m_maxTrtFittedRatio; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << m_boundsTrtFittedRatio[i] << " < TRT fitted ratio  < "
      << m_boundsTrtFittedRatio[i+1] <<"  : " <<m_factorTrtFittedRatio[i] <<endmsg;
 
 
    // only if used
    for (int i=0; i<m_maxSigmaChi2; ++i)
      msg(MSG::VERBOSE) << "Modifier for " << m_boundsSigmaChi2[i] << " < sigma(chi2) - sqrt(2chi2)  < " << m_boundsSigmaChi2[i+1]
      <<"  : " <<m_factorSigmaChi2[i] <<endmsg;
  }
 
}

simpleScore()

Trk::TrackScore InDet::InDetAmbiScoringTool::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 187 of file InDetAmbiScoringTool.cxx.

{
  int numPixel          = trackSummary.get(Trk::numberOfPixelHits);
  int numSCT            = trackSummary.get(Trk::numberOfSCTHits);
  int numTRT            = trackSummary.get(Trk::numberOfTRTHits);
  int numTRTTube        = trackSummary.get(Trk::numberOfTRTTubeHits);
  int numPixelHoles     = trackSummary.get(Trk::numberOfPixelHoles);
  int numSCTHoles       = trackSummary.get(Trk::numberOfSCTHoles);
  int numSCTDoubleHoles = trackSummary.get(Trk::numberOfSCTDoubleHoles);
  int numPixelDead      = trackSummary.get(Trk::numberOfPixelDeadSensors);
  int numSCTDead        = trackSummary.get(Trk::numberOfSCTDeadSensors);
 
  if (numPixelDead<0) numPixelDead = 0;
  if (numSCTDead<0)   numSCTDead   = 0;
 
  // is this a track from the pattern or a fitted track ?
  bool ispatterntrack = (track.info().trackFitter()==Trk::TrackInfo::Unknown);
  //
  // --- reject bad tracks
  //
  //
  // --- the following cuts we only apply to fitted tracks
  //
  if (ispatterntrack) {
    ATH_MSG_DEBUG ("==> this is a pattern track, no hit cuts !");
  } else {
    ATH_MSG_DEBUG ("==> this is a refitted track, so we can use the chi2 and other stuff ! ");
 
    double trackEta = track.trackParameters()->front()->eta();
 
    // NdF cut :
    if (track.fitQuality()) {
      ATH_MSG_DEBUG ("numberDoF = "<<track.fitQuality()->numberDoF());
    }
    // Number of double Holes
    if (numSCTDoubleHoles>=0) {
      int maxDoubleHoles = m_etaDependentCutsSvc.name().empty() ?
        m_maxDoubleHoles.value() :  m_etaDependentCutsSvc->getMaxDoubleHolesAtEta(trackEta);
      if (numSCTDoubleHoles > maxDoubleHoles ) {
        ATH_MSG_DEBUG ("Track has "<< numSCTDoubleHoles <<" double holes, reject it!");
        return Trk::TrackScore(0);
      }
    }
    // Number of Si (Pixel+SCT) Holes
    if (numSCTHoles>=0 && numPixelHoles>=0) {
      int maxSiHoles = m_etaDependentCutsSvc.name().empty() ?
        m_maxSiHoles.value() :  m_etaDependentCutsSvc->getMaxSiHolesAtEta(trackEta);
      if (numPixelHoles+numSCTHoles > maxSiHoles ) {
        ATH_MSG_DEBUG ("Track has "<< numPixelHoles <<" Pixel and " << numSCTHoles << " SCT holes, reject it!");
        return Trk::TrackScore(0);
      }
    }
    // Number of Pixel Holes
    if ( numPixelHoles>=0 ) {
      int maxPixelHoles = m_etaDependentCutsSvc.name().empty() ?
        m_maxPixelHoles.value() : m_etaDependentCutsSvc->getMaxPixelHolesAtEta(trackEta);
      if (numPixelHoles > maxPixelHoles ) {
        ATH_MSG_DEBUG ("Track has "<< numPixelHoles <<" Pixel  holes, reject it!");
        return Trk::TrackScore(0);
      }
    }
    // Number of SCT Holes
    if ( numSCTHoles>=0 ) {
      int maxSctHoles = m_etaDependentCutsSvc.name().empty() ?
        m_maxSctHoles.value() : m_etaDependentCutsSvc->getMaxSctHolesAtEta(trackEta);
      if ( numSCTHoles > maxSctHoles ) {
        ATH_MSG_DEBUG ("Track has "<< numSCTHoles << " SCT holes, reject it!");
        return Trk::TrackScore(0);
      }
    }
    // TRT cut
    if (!m_useITkAmbigFcn && numTRT > 0 && numTRT < m_minTRTonTrk) {
      ATH_MSG_DEBUG ("Track has " << numTRT << " TRT hits,  reject it");
      return Trk::TrackScore(0);
    }
    // TRT precision hits cut
    if (!m_useITkAmbigFcn && numTRT >= 15 && ((double)(numTRT-numTRTTube))/numTRT < m_minTRTprecision) {
      ATH_MSG_DEBUG ("Track has " << ((double)numTRTTube)/numTRT << " TRT tube hit fraction,  reject it");
      return Trk::TrackScore(0);
    }
    // Number of Si Clusters
    if ( numSCT>=0 && numPixel>=0) {
      int minSiClusters = m_etaDependentCutsSvc.name().empty() ?
        m_minSiClusters.value() : m_etaDependentCutsSvc->getMinSiHitsAtEta(trackEta);
      if (numPixel+numSCT+numPixelDead+numSCTDead < minSiClusters) {
        ATH_MSG_DEBUG ("Track has " << numPixel+numSCT << " Si clusters and " << numPixelDead+numSCTDead << " dead sensors, reject it");
        return Trk::TrackScore(0);
      }
    }
    // Number of pixel clusters
    if (numPixel>=0) {
      int minPixel = m_etaDependentCutsSvc.name().empty() ?
        m_minPixel.value() : m_etaDependentCutsSvc->getMinPixelHitsAtEta(trackEta);
      if(numPixel < minPixel) {
        ATH_MSG_DEBUG ("Track has " << numPixel << " pixel hits, reject it");
        return Trk::TrackScore(0);
      }
    }
  }
 
  //
  // --- now start scoring
  //
 
  if ( m_useAmbigFcn || m_useTRT_AmbigFcn) {
 
    //
    // --- use scoring function
    //
 
    return ambigScore(track,trackSummary);
 
  } else {
 
    //
    // use classical score
    //
    // 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;
        ATH_MSG_DEBUG ("\tType ["<<i<<"], value \t= "<<value<<"], score \t="<<score);
      }
    }
    // --- 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.

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_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> InDet::InDetAmbiScoringTool::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

private

Definition at line 86 of file InDetAmbiScoringTool.h.

{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_boundsSigmaChi2

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

private

Definition at line 76 of file InDetAmbiScoringTool.h.

m_boundsTrtFittedRatio

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

private

Definition at line 77 of file InDetAmbiScoringTool.h.

m_boundsTrtRatio

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

private

Definition at line 77 of file InDetAmbiScoringTool.h.

m_caloClusterROIKey

SG::ReadHandleKey<ROIPhiRZContainer> InDet::InDetAmbiScoringTool::m_caloClusterROIKey {this, "EMROIPhiRZContainer", "", "Name of the calo cluster ROIs in Phi,R,Z parameterization"}

private

Definition at line 134 of file InDetAmbiScoringTool.h.

{this, "EMROIPhiRZContainer", "", "Name of the calo cluster ROIs in Phi,R,Z parameterization"};

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_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::InDetAmbiScoringTool::m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", ""}

private

ITk eta-dependent cuts.

Definition at line 141 of file InDetAmbiScoringTool.h.

{this, "InDetEtaDependentCutsSvc", ""};

m_etaWidthEm

FloatProperty InDet::InDetAmbiScoringTool::m_etaWidthEm {this, "etaWidthEM", 0.05}

private

Definition at line 132 of file InDetAmbiScoringTool.h.

{this, "etaWidthEM", 0.05};

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_extrapolator

ToolHandle<Trk::IExtrapolator> InDet::InDetAmbiScoringTool::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator"}

private

Definition at line 88 of file InDetAmbiScoringTool.h.

{this, "Extrapolator", "Trk::Extrapolator"};

m_factorB_LayerHits

std::vector<double> InDet::InDetAmbiScoringTool::m_factorB_LayerHits

private

Definition at line 75 of file InDetAmbiScoringTool.h.

m_factorDblHoles

std::vector<double> InDet::InDetAmbiScoringTool::m_factorDblHoles

private

Definition at line 74 of file InDetAmbiScoringTool.h.

m_factorGangedFakes

std::vector<double> InDet::InDetAmbiScoringTool::m_factorGangedFakes

private

Definition at line 75 of file InDetAmbiScoringTool.h.

m_factorHits

std::vector<double> InDet::InDetAmbiScoringTool::m_factorHits

private

Definition at line 74 of file InDetAmbiScoringTool.h.

m_factorPixelHits

std::vector<double> InDet::InDetAmbiScoringTool::m_factorPixelHits

private

Definition at line 75 of file InDetAmbiScoringTool.h.

m_factorPixHoles

std::vector<double> InDet::InDetAmbiScoringTool::m_factorPixHoles

private

Definition at line 74 of file InDetAmbiScoringTool.h.

m_factorPixLay

std::vector<double> InDet::InDetAmbiScoringTool::m_factorPixLay

private

Definition at line 75 of file InDetAmbiScoringTool.h.

m_factorSCT_Holes

std::vector<double> InDet::InDetAmbiScoringTool::m_factorSCT_Holes

private

Definition at line 74 of file InDetAmbiScoringTool.h.

m_factorSigmaChi2

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

private

Definition at line 75 of file InDetAmbiScoringTool.h.

m_factorTrtFittedRatio

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

private

Definition at line 77 of file InDetAmbiScoringTool.h.

m_factorTrtRatio

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

private

Definition at line 77 of file InDetAmbiScoringTool.h.

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::InDetAmbiScoringTool::m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

private

Definition at line 92 of file InDetAmbiScoringTool.h.

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

m_maxB_LayerHits

int InDet::InDetAmbiScoringTool::m_maxB_LayerHits = -1

private

Definition at line 72 of file InDetAmbiScoringTool.h.

m_maxDblHoles

int InDet::InDetAmbiScoringTool::m_maxDblHoles = -1

private

Definition at line 70 of file InDetAmbiScoringTool.h.

m_maxDoubleHoles

IntegerProperty InDet::InDetAmbiScoringTool::m_maxDoubleHoles {this, "maxDoubleHoles", 2, "maximum number of SCT double holes"}

private

Definition at line 113 of file InDetAmbiScoringTool.h.

{this, "maxDoubleHoles", 2, "maximum number of SCT double holes"};

m_maxEta

DoubleProperty InDet::InDetAmbiScoringTool::m_maxEta {this, "maxEta", 2.7, "maximal Eta cut"}

private

Definition at line 105 of file InDetAmbiScoringTool.h.

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

m_maxGangedFakes

int InDet::InDetAmbiScoringTool::m_maxGangedFakes = -1

private

Definition at line 73 of file InDetAmbiScoringTool.h.

m_maxHits

int InDet::InDetAmbiScoringTool::m_maxHits = -1

private

Definition at line 71 of file InDetAmbiScoringTool.h.

m_maxPixelHits

int InDet::InDetAmbiScoringTool::m_maxPixelHits = -1

private

Definition at line 72 of file InDetAmbiScoringTool.h.

m_maxPixelHoles

IntegerProperty InDet::InDetAmbiScoringTool::m_maxPixelHoles {this, "maxPixelHoles", 5, "max number of Pixel holes"}

private

Definition at line 117 of file InDetAmbiScoringTool.h.

{this, "maxPixelHoles", 5, "max number of Pixel holes"};

m_maxPixHoles

int InDet::InDetAmbiScoringTool::m_maxPixHoles = -1

private

Definition at line 70 of file InDetAmbiScoringTool.h.

m_maxPixLay

int InDet::InDetAmbiScoringTool::m_maxPixLay = -1

private

Definition at line 73 of file InDetAmbiScoringTool.h.

m_maxRPhiImp

DoubleProperty InDet::InDetAmbiScoringTool::m_maxRPhiImp {this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"}

private

Definition at line 106 of file InDetAmbiScoringTool.h.

{this, "maxRPhiImp", 10., "maximal RPhi impact parameter cut"};

m_maxRPhiImpEM

DoubleProperty InDet::InDetAmbiScoringTool::m_maxRPhiImpEM {this, "maxRPhiImpEM", 50., "maximal RPhi impact parameter cut track that match EM clusters"}

private

Definition at line 128 of file InDetAmbiScoringTool.h.

{this, "maxRPhiImpEM", 50., "maximal RPhi impact parameter cut track that match EM clusters"};

m_maxSCT_Holes

int InDet::InDetAmbiScoringTool::m_maxSCT_Holes = -1

private

Definition at line 70 of file InDetAmbiScoringTool.h.

m_maxSctHoles

IntegerProperty InDet::InDetAmbiScoringTool::m_maxSctHoles {this, "maxSCTHoles", 5, "max number of SCT holes"}

private

Definition at line 119 of file InDetAmbiScoringTool.h.

{this, "maxSCTHoles", 5, "max number of SCT holes"};

m_maxSigmaChi2

int InDet::InDetAmbiScoringTool::m_maxSigmaChi2 = -1

private

Definition at line 71 of file InDetAmbiScoringTool.h.

m_maxSiHoles

IntegerProperty InDet::InDetAmbiScoringTool::m_maxSiHoles {this, "maxSiHoles", 5, "max number of Silicon (Pixel+SCT) holes"}

private

Definition at line 115 of file InDetAmbiScoringTool.h.

{this, "maxSiHoles", 5, "max number of Silicon (Pixel+SCT) holes"};

m_maxTrtFittedRatio

int InDet::InDetAmbiScoringTool::m_maxTrtFittedRatio = -1

private

Definition at line 72 of file InDetAmbiScoringTool.h.

m_maxTrtRatio

int InDet::InDetAmbiScoringTool::m_maxTrtRatio = -1

private

Definition at line 71 of file InDetAmbiScoringTool.h.

m_maxZImp

DoubleProperty InDet::InDetAmbiScoringTool::m_maxZImp {this, "maxZImp", 250., "maximal z impact parameter cut"}

private

Definition at line 108 of file InDetAmbiScoringTool.h.

{this, "maxZImp", 250., "maximal z impact parameter cut"};

m_minPixel

IntegerProperty InDet::InDetAmbiScoringTool::m_minPixel {this, "minPixel", 0, "minimum number of pixel clusters"}

private

Definition at line 125 of file InDetAmbiScoringTool.h.

{this, "minPixel", 0, "minimum number of pixel clusters"};

m_minPt

DoubleProperty InDet::InDetAmbiScoringTool::m_minPt {this, "minPt", 500., "minimal Pt cut"}

private

cuts for selecting good tracks

Definition at line 104 of file InDetAmbiScoringTool.h.

{this, "minPt", 500., "minimal Pt cut"};

m_minSiClusters

IntegerProperty InDet::InDetAmbiScoringTool::m_minSiClusters {this, "minSiClusters", 7, "minimal number of Si clusters"}

private

Definition at line 111 of file InDetAmbiScoringTool.h.

{this, "minSiClusters", 7, "minimal number of Si clusters"};

m_minTRTonTrk

IntegerProperty InDet::InDetAmbiScoringTool::m_minTRTonTrk {this, "minTRTonTrk", 9, "minimum number of TRT hits"}

private

Definition at line 121 of file InDetAmbiScoringTool.h.

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

m_minTRTprecision

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

private

Definition at line 123 of file InDetAmbiScoringTool.h.

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

m_phiWidthEm

FloatProperty InDet::InDetAmbiScoringTool::m_phiWidthEm {this, "phiWidthEM", 0.075}

private

Definition at line 131 of file InDetAmbiScoringTool.h.

{this, "phiWidthEM", 0.075};

m_selectortool

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

private

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

Definition at line 80 of file InDetAmbiScoringTool.h.

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

m_summaryTypeScore

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

private

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

Definition at line 84 of file InDetAmbiScoringTool.h.

m_useAmbigFcn

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

private

use the scoring tuned to Ambiguity processing or not

Definition at line 96 of file InDetAmbiScoringTool.h.

{this, "useAmbigFcn", true};

m_useEmClusSeed

BooleanProperty InDet::InDetAmbiScoringTool::m_useEmClusSeed {this, "doEmCaloSeed", true}

private

Definition at line 130 of file InDetAmbiScoringTool.h.

{this, "doEmCaloSeed", true};

m_useITkAmbigFcn

BooleanProperty InDet::InDetAmbiScoringTool::m_useITkAmbigFcn {this, "useITkAmbigFcn", false}

private

use the ITk scoring tuned to Ambiguity processing or not

Definition at line 138 of file InDetAmbiScoringTool.h.

{this, "useITkAmbigFcn", false};

m_usePixel

BooleanProperty InDet::InDetAmbiScoringTool::m_usePixel {this, "usePixel", true}

private

Definition at line 100 of file InDetAmbiScoringTool.h.

{this, "usePixel", true};

m_useSCT

BooleanProperty InDet::InDetAmbiScoringTool::m_useSCT {this, "useSCT", true}

private

Definition at line 101 of file InDetAmbiScoringTool.h.

{this, "useSCT", true};

m_useSigmaChi2

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

private

Definition at line 98 of file InDetAmbiScoringTool.h.

{this, "useSigmaChi2", false};

m_useTRT_AmbigFcn

BooleanProperty InDet::InDetAmbiScoringTool::m_useTRT_AmbigFcn {this, "useTRT_AmbigFcn", false}

private

Definition at line 97 of file InDetAmbiScoringTool.h.

{this, "useTRT_AmbigFcn", 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:

• InDetAmbiScoringTool.h
• InDetAmbiScoringTool.cxx