This validation tool writes basic information about Trk::Track into an ntuple; it is also the steering tool for all Trk::IValidationNtupleHelperTool. More...

#include <MeasurementVectorNtupleTool.h>

Inheritance diagram for Trk::MeasurementVectorNtupleTool:

Collaboration diagram for Trk::MeasurementVectorNtupleTool:

Public Member Functions
	MeasurementVectorNtupleTool (const std::string &, const std::string &, const IInterface *)
	~MeasurementVectorNtupleTool ()
StatusCode	initialize ()
StatusCode	finalize ()
virtual StatusCode	addNtupleItems (TTree *tree)
	add branches to the tree Should be called once (per track collection and tree) dunring the initialisation phase by the calling algorithm (usually Trk::TrackValidationNtupleWriter)
virtual StatusCode	fillTrackData (const Trk::Track &, const int iterationIndex, const unsigned int fitStatCode)
	fill ntuple data of a given track without writing the record.
virtual StatusCode	fillTrackParticleData (const Trk::TrackParticleBase &)
	fill ntuple data of a given TrackParticle without writing the record.
virtual StatusCode	fillTrackTruthData (const TrackParameters *&, const TrackTruth &, const int)
	fill data about the truth match (score, parameter-pulls etc)
virtual void	resetVariables ()
	reset the variables after writing the record to disk ntuple
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 ()
	Interface ID, declared here, and defined below.

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
StatusCode	fillMeasurementData (const Trk::MeasurementBase , const Trk::TrackParameters , const bool &isOutlier, const int &detectorType)
	fill variables with call for each measurement TSoS
StatusCode	callHelperTools (const Trk::MeasurementBase , const Trk::TrackParameters , const bool &isOutlier, const int &detectorType, const int &nCurrentHit)
	call the helper tools
virtual StatusCode	fillHoleData (const Trk::TrackStateOnSurface &)
	fill ntuple data of holes on track without writing the record
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const AtlasDetectorID *	m_idHelper
	Used to find out the sub-det from PRD->identify().
MeasurementTypeID *	m_detTypeHelper
ToolHandle< Trk::IUpdator >	m_updatorHandle
	Tool handle of updator for unbiased states.
Trk::IUpdator *	m_updator
	updator for unbiased states
ToolHandle< Trk::IResidualPullCalculator >	m_residualPullCalculator
	The residual and pull calculator tool.
ToolHandle< Trk::ITrackHoleSearchTool >	m_holeSearchTool
	The hole search tool.
ToolHandleArray< IValidationNtupleHelperTool >	m_PixelNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for Pixel
ToolHandleArray< IValidationNtupleHelperTool >	m_SCTNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for SCT
ToolHandleArray< IValidationNtupleHelperTool >	m_TRTNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for TRT
ToolHandleArray< IValidationNtupleHelperTool >	m_MDTNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for MDT
ToolHandleArray< IValidationNtupleHelperTool >	m_CSCNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for CSC
ToolHandleArray< IValidationNtupleHelperTool >	m_RPCNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for RPC
ToolHandleArray< IValidationNtupleHelperTool >	m_TGCNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for TGC
ToolHandleArray< IValidationNtupleHelperTool >	m_GeneralNtupleHelperToolHandles
	jobOption: List of Ntuple validation helper tools for data independent from detector technology
bool	m_useROTwithMaxAssgnProb
	jobOption: use ROT with max.
bool	m_ignoreMissTrkCov
	jobOption: ignore missing covariance of track parameters for pull calculation?
std::vector< IValidationNtupleHelperTool * >	m_PixelHelperTools
	the helper tools for Pixel data
std::vector< IValidationNtupleHelperTool * >	m_SCTHelperTools
	the helper tools for SCT data
std::vector< IValidationNtupleHelperTool * >	m_TRTHelperTools
	the helper tools for TRT data
std::vector< IValidationNtupleHelperTool * >	m_MDTHelperTools
	the helper tools for MDT data
std::vector< IValidationNtupleHelperTool * >	m_CSCHelperTools
	the helper tools for CSC data
std::vector< IValidationNtupleHelperTool * >	m_RPCHelperTools
	the helper tools for RPC data
std::vector< IValidationNtupleHelperTool * >	m_TGCHelperTools
	the helper tools for TGC data
std::vector< IValidationNtupleHelperTool * >	m_GeneralHelperTools
	the helper tools for data independent from detector technology
bool	m_pullWarning
	warn only ones, if pull cannot be calculated
bool	m_UpdatorWarning
	warn only ones, if unbiased track states can not be calculated
bool	m_trkParametersWarning
	warn once only, if no track parameters exist
bool	m_doTruth
	switch to turn truth on/off
bool	m_doHoleSearch
	switch to turn hole search on/off
std::map< const IValidationNtupleHelperTool *, bool >	m_helperToolWarning
int	m_isUnbiased
	flag if track states are unbiased to the related measurements (0:no, 1:yes)
std::vector< float > *	m_residualLocX
	residual in Trk::LocX for each measurement on the track, vector of size nHits, value set to -1000 if meas't was outlier UNIT:mm
std::vector< float > *	m_residualLocY
	residual in Trk::LocY for each meas't on the track (value is set to -1000 if no second local coord.
std::vector< float > *	m_pullLocX
	pull in Trk::LocX for each measurement on the track, vector of size nHits, value set to -1000 if meas't was outlier UNIT:1
std::vector< float > *	m_pullLocY
	pull in Trk::LocY for each measurement on the track (value is set to -1000 if no second local coord.
std::vector< int > *	m_DetectorType
	Detector type of the measurement, enum according to TrkEventPrimitives/TrackStateDefs.h, vector of size nHits.
std::vector< int > *	m_isOutlier
	flag if measurement is outlier (1) or not (0), vector of size nHits UNIT:0:no, 1:yes
int	m_nPixelHits
	number of measurements in the Pixels (without outliers)
int	m_nSCTHits
	number of measurements in the SCT (without outliers)
int	m_nTRTHits
	number of measurements in the TRT (without outliers)
int	m_nMDTHits
	number of measurements in the MDTs (without outliers)
int	m_nCSCHits
	number of measurements in the CSC (without outliers)
int	m_nRPCHits
	number of measurements in the RPC (without outliers)
int	m_nTGCHits
	number of measurements in the TGC (without outliers)
std::vector< int > *	m_pixelHitIndex
	corresp.
std::vector< int > *	m_sctHitIndex
	corresp.
std::vector< int > *	m_trtHitIndex
	corresp.
std::vector< int > *	m_mdtHitIndex
	corresp.
std::vector< int > *	m_cscHitIndex
	corresp.
std::vector< int > *	m_rpcHitIndex
	corresp.
std::vector< int > *	m_tgcHitIndex
	icorresp.
int	m_nHoles
	number of holes on track
int	m_nPixelHoles
	number of Pixel holes on track
int	m_nSctHoles
	number of SCT holes on track
std::vector< int > *	m_HoleDetectorType
	detector type of the hole (vector of size nHoles)
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

This validation tool writes basic information about Trk::Track into an ntuple; it is also the steering tool for all Trk::IValidationNtupleHelperTool.

You use an existing ntuple tree (which has to have the same track-wise structure) and just use the Trk::BasicValidationNtupleTool to add some ntuple variables.

One can give a list of Trk::IValidationNtupleHelperTool for each detector type by joboptions which are called by Trk::BasicValidationNtupleTool if a measurement of the related detector is found on the track. Those Trk::IValidationNtupleHelperTool can add items to the ntuple and fill special data needed for validation.

Every entry (track) contains the event number, a track id (numbering the tracks within one event) and an optional iteration index, which can be used if different intermediate results of a track are produced in the refit procedure. The track id is the same for all tracks generated within one iteration process and reset to 0 every time a new event is started.

Definition at line 52 of file MeasurementVectorNtupleTool.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

◆ MeasurementVectorNtupleTool()

Trk::MeasurementVectorNtupleTool::MeasurementVectorNtupleTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 29 of file MeasurementVectorNtupleTool.cxx.

        :
        AthAlgTool(t,n,p),
        m_idHelper(nullptr),
        m_detTypeHelper(nullptr),
        m_updatorHandle("Trk::KalmanUpdator/TrkKalmanUpdator"),
        m_updator(nullptr),
        m_residualPullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
        m_holeSearchTool("InDet::InDetTrackHoleSearchTool/InDetHoleSearchTool"),
        m_PixelNtupleHelperToolHandles(this), // retrieve as private tools
        m_SCTNtupleHelperToolHandles(this),
        m_TRTNtupleHelperToolHandles(this),
        m_MDTNtupleHelperToolHandles(this),
        m_CSCNtupleHelperToolHandles(this),
        m_RPCNtupleHelperToolHandles(this),
        m_TGCNtupleHelperToolHandles(this),
        m_GeneralNtupleHelperToolHandles(this),
        //m_useROTwithMaxAssgnProb
        //m_ignoreMissTrkCov
        //vectors could be initialised here
        m_pullWarning{},
        m_UpdatorWarning{},
        m_trkParametersWarning{},
        m_doTruth{},
        m_doHoleSearch(true),
        //map could be initialised here
        m_isUnbiased{},
        m_residualLocX(nullptr),
        m_residualLocY(nullptr),
        m_pullLocX(nullptr),
        m_pullLocY(nullptr),
        m_DetectorType(nullptr),
        m_isOutlier(nullptr),
        m_nPixelHits{},
        m_nSCTHits{},
        m_nTRTHits{},
        m_nMDTHits{},
        m_nCSCHits{},
        m_nRPCHits{},
        m_nTGCHits{},
        m_pixelHitIndex(nullptr),
        m_sctHitIndex(nullptr),
        m_trtHitIndex(nullptr),
        m_mdtHitIndex(nullptr),
        m_cscHitIndex(nullptr),
        m_rpcHitIndex(nullptr),
        m_tgcHitIndex(nullptr),
        m_nHoles{},
        m_nPixelHoles{},
        m_nSctHoles{},
        m_HoleDetectorType(nullptr)
{
  declareInterface<ITrackValidationNtupleTool>(this);
 
  declareProperty("UseROTwithMaxAssgnProb",       m_useROTwithMaxAssgnProb = true,        "In case of CompetingRIOsOnTrack: Use the ROT with maximum assignment probabilty to calculate residuals, etc or use mean measurement?");
  declareProperty("IgnoreMissingTrackCovarianceForPulls", m_ignoreMissTrkCov = false,   "Do not warn, if track states do not have covariance matries when calculating pulls");
  declareProperty("UpdatorTool",                  m_updatorHandle,                        "Measurement updator to calculate unbiased track states");
  declareProperty("ResidualPullCalculatorTool",   m_residualPullCalculator,               "Tool to calculate residuals and pulls");
  declareProperty("HoleSearchTool",               m_holeSearchTool,                       "Tool to search for holes on track");
                    // these are for detector-internal validation, unless an
                    // specific <-> general index hit mapper is there.
  declareProperty("PixelNtupleHelperTools",       m_PixelNtupleHelperToolHandles,
                  "List of Pixel validation tools");
  declareProperty("SCTNtupleHelperTools",         m_SCTNtupleHelperToolHandles,           "List of SCT validation tools");
  declareProperty("TRTNtupleHelperTools",         m_TRTNtupleHelperToolHandles,           "List of TRT validation tools");
  declareProperty("MDTNtupleHelperTools",         m_MDTNtupleHelperToolHandles,           "List of MDT validation tools");
  declareProperty("CSCNtupleHelperTools",         m_CSCNtupleHelperToolHandles,           "List of CSC validation tools");
  declareProperty("RPCNtupleHelperTools",         m_RPCNtupleHelperToolHandles,           "List of RPC validation tools");
  declareProperty("TGCNtupleHelperTools",         m_TGCNtupleHelperToolHandles,           "List of TGC validation tools");
  declareProperty("GeneralNtupleHelperTools",     m_GeneralNtupleHelperToolHandles,       "List of detector independent validation tools");
  declareProperty("DoTruth",                      m_doTruth,                              "Write truth data?");
  declareProperty("DoHoleSearch",                 m_doHoleSearch,                         "Write hole data?");
  m_UpdatorWarning = false;
  m_pullWarning = false;
  m_trkParametersWarning = false;
 
}

◆ ~MeasurementVectorNtupleTool()

Trk::MeasurementVectorNtupleTool::~MeasurementVectorNtupleTool ( )

default

Member Function Documentation

◆ addNtupleItems()

StatusCode Trk::MeasurementVectorNtupleTool::addNtupleItems ( TTree * tree )

virtual

add branches to the tree Should be called once (per track collection and tree) dunring the initialisation phase by the calling algorithm (usually Trk::TrackValidationNtupleWriter)

Implements Trk::ITrackValidationNtupleTool.

Definition at line 324 of file MeasurementVectorNtupleTool.cxx.

                                                                       {
    if (!tree) return StatusCode::FAILURE;
    ATH_MSG_DEBUG ("added branches to ntuple");
    //-----------------
    // add items  *** Note: Documentation is in the header file, doxygen and wikis! ***
    //
    tree->Branch("TrackStatesUnbiased", &m_isUnbiased        );
    m_isUnbiased=999;
 
    if (!m_residualPullCalculator.empty()) {
      tree->Branch("pullLocX",            &m_pullLocX            );
      tree->Branch("pullLocY",            &m_pullLocY            );
      tree->Branch("residualLocX",        &m_residualLocX        );
      tree->Branch("residualLocY",        &m_residualLocY        );
    }
 
    tree->Branch("DetectorType",        &m_DetectorType      );
    tree->Branch("outlierFlag",         &m_isOutlier         );
 
    tree->Branch("nPixelHits",          &m_nPixelHits        );
    tree->Branch("nSCTHits",            &m_nSCTHits          );
    tree->Branch("nTRTHits",            &m_nTRTHits          );
    tree->Branch("nMDTHits",            &m_nMDTHits          );
    tree->Branch("nCSCHits",            &m_nCSCHits          );
    tree->Branch("nRPCHits",            &m_nRPCHits          );
    tree->Branch("nTGCHits",            &m_nTGCHits          );
 
    tree->Branch("pixelHitIndex",       &m_pixelHitIndex     );
    tree->Branch("sctHitIndex",         &m_sctHitIndex       );
    tree->Branch("trtHitIndex",         &m_trtHitIndex       );
    tree->Branch("mdtHitIndex",         &m_mdtHitIndex       );
    tree->Branch("cscHitIndex",         &m_cscHitIndex       );
    tree->Branch("rpcHitIndex",         &m_rpcHitIndex       );
    tree->Branch("tgcHitIndex",         &m_tgcHitIndex       );
 
    ATH_MSG_VERBOSE ("added own branches to ntuple");
 
    StatusCode sc(StatusCode::SUCCESS);
    ToolHandleArray< IValidationNtupleHelperTool >::iterator itTools;
    // get all the given ntuple helper tools for Pixel
    itTools = m_PixelNtupleHelperToolHandles.begin();
    for (  ; itTools != m_PixelNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::Pixel);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // SCT helper tools
    itTools = m_SCTNtupleHelperToolHandles.begin();
    for (  ; itTools != m_SCTNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::SCT);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // get all the given ntuple helper tools for TRT
    itTools = m_TRTNtupleHelperToolHandles.begin();
    for (  ; itTools != m_TRTNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::TRT);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // get all the given ntuple helper tools for MDT
    itTools = m_MDTNtupleHelperToolHandles.begin();
    for (  ; itTools != m_MDTNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::MDT);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // get all the given ntuple helper tools for CSC
    itTools = m_CSCNtupleHelperToolHandles.begin();
    for (  ; itTools != m_CSCNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::CSC);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // get all the given ntuple helper tools for RPC
    itTools = m_RPCNtupleHelperToolHandles.begin();
    for (  ; itTools != m_RPCNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::RPC);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    // get all the given ntuple helper tools for TGC
    itTools = m_TGCNtupleHelperToolHandles.begin();
    for (  ; itTools != m_TGCNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::TGC);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    itTools = m_GeneralNtupleHelperToolHandles.begin();
    for (  ; itTools != m_GeneralNtupleHelperToolHandles.end(); ++itTools ) {
      // let tool add its items
      sc = (*itTools)->addNtupleItems (tree, TrackState::unidentified);
      if(sc.isFailure())   {
        msg(MSG::ERROR)<<"The helper " << (*itTools) << " could not add its items" << endmsg;
        return sc;
      }
    }
    return StatusCode::SUCCESS;
}

◆ callHelperTools()

StatusCode Trk::MeasurementVectorNtupleTool::callHelperTools	(	const Trk::MeasurementBase *	measurement,
		const Trk::TrackParameters *	trkPar,
		const bool &	isOutlier,
		const int &	detectorType,
		const int &	nCurrentHit )

private

call the helper tools

Definition at line 786 of file MeasurementVectorNtupleTool.cxx.

                            {
 
    // ------------------------------------
    // try if measurement is a competingROT and check if joboption
    //   is set to use ROT with highest assgn. prob. in the case of a competingROT.
    // for general helper tools measurement is always used (the jobOption
    //   has no meaning for them).
    const Trk::MeasurementBase* measurementBaseOrROT = measurement;
    if (m_useROTwithMaxAssgnProb) {
      // use ROT with max assgn prob for calculations
      const Trk::CompetingRIOsOnTrack* comprot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(measurement);
      if (comprot){
        measurementBaseOrROT = &comprot->rioOnTrack(comprot->indexOfMaxAssignProb());
      }
    }
 
    // -------------------------------------------
    // write detector specific data (for used measurements only, i.e. not for outliers)
    if ( !isOutlier && ( detectorType==TrackState::Pixel ||
                         detectorType==TrackState::SCT   ||
                         detectorType==TrackState::TRT   ||
                         detectorType==TrackState::MDT   ||
                         detectorType==TrackState::CSC   ||
                         detectorType==TrackState::RPC   ||
                         detectorType==TrackState::TGC)   ) {
      std::vector< Trk::IValidationNtupleHelperTool* >::const_iterator toolIter;
      std::vector< Trk::IValidationNtupleHelperTool* >::const_iterator toolIterEnd;
      switch (detectorType) {
      case TrackState::Pixel:
        toolIter = m_PixelHelperTools.begin();
        toolIterEnd = m_PixelHelperTools.end();
        m_pixelHitIndex->push_back(nCurrentHit-1);
        m_nPixelHits++;
        break;
      case TrackState::SCT:
        toolIter = m_SCTHelperTools.begin();
        toolIterEnd = m_SCTHelperTools.end();
        m_sctHitIndex->push_back(nCurrentHit-1);
        m_nSCTHits++;
        break;
      case TrackState::TRT:
        toolIter = m_TRTHelperTools.begin();
        toolIterEnd = m_TRTHelperTools.end();
        m_trtHitIndex->push_back(nCurrentHit-1);
        m_nTRTHits++;
        break;
      case TrackState::MDT:
        toolIter = m_MDTHelperTools.begin();
        toolIterEnd = m_MDTHelperTools.end();
        m_mdtHitIndex->push_back(nCurrentHit-1);
        m_nMDTHits++;
        break;
      case TrackState::CSC:
        toolIter = m_CSCHelperTools.begin();
        toolIterEnd = m_CSCHelperTools.end();
        m_cscHitIndex->push_back(nCurrentHit-1);
        m_nCSCHits++;
        break;
      case TrackState::RPC:
        toolIter = m_RPCHelperTools.begin();
        toolIterEnd = m_RPCHelperTools.end();
        m_rpcHitIndex->push_back(nCurrentHit-1);
        m_nRPCHits++;
        break;
      case TrackState::TGC:
        toolIter = m_TGCHelperTools.begin();
        toolIterEnd = m_TGCHelperTools.end();
        m_tgcHitIndex->push_back(nCurrentHit-1);
        m_nTGCHits++;
        break;
      }
      // now run the detector specific helper tools
      for (; toolIter!=toolIterEnd; ++toolIter) {
        if (((*toolIter)->fillMeasurementData(measurementBaseOrROT, trkPar, detectorType, isOutlier)).isFailure()) {
          if (!m_helperToolWarning[(*toolIter)]) {
            msg(MSG::WARNING) << "sub-det helper tool did not succeed to fill data (further warnings for this tool will be suppressed)"  << endmsg;
            m_helperToolWarning[(*toolIter)] = true;
          }
        }
      }
    } //end if (detectorType!=TrackState::unidentified && !isOutlier)
 
    // call the general tools
    if (!m_GeneralHelperTools.empty()) {
      std::vector< Trk::IValidationNtupleHelperTool* >::const_iterator toolIter = m_GeneralHelperTools.begin();
      for (; toolIter!=m_GeneralHelperTools.end(); ++toolIter) {
        if (((*toolIter)->fillMeasurementData(measurement, trkPar, detectorType, isOutlier)).isFailure()) {
          if (!m_helperToolWarning[(*toolIter)]) {
            msg(MSG::WARNING) << "general helper tool did not succeed to fill general data"  << endmsg;
            m_helperToolWarning[(*toolIter)] = true;
          }
        }
      }
    }
 
    return StatusCode::SUCCESS;
}

◆ 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.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ 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.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

◆ fillHoleData()

StatusCode Trk::MeasurementVectorNtupleTool::fillHoleData ( const Trk::TrackStateOnSurface & tsos )

privatevirtual

fill ntuple data of holes on track without writing the record

Definition at line 889 of file MeasurementVectorNtupleTool.cxx.

                                            {
    if (!m_doHoleSearch) return StatusCode::SUCCESS;
    // check if we really have a hole
    if (!tsos.type(Trk::TrackStateOnSurface::Hole)) return StatusCode::FAILURE;
    // hole without track pars is not allowed
    if (!tsos.trackParameters()) return StatusCode::FAILURE;
    // identify the detector type
    int detectorType = TrackState::unidentified;
    const Identifier id = tsos.trackParameters()->associatedSurface().associatedDetectorElementIdentifier();
    if ( id.is_valid() ) {
        if (m_idHelper->is_pixel(id) ) {
            detectorType = TrackState::Pixel;
        } else if (m_idHelper->is_sct(id)) {
            detectorType = TrackState::SCT;
        } else if (m_idHelper->is_trt(id)) {
            detectorType = TrackState::TRT;
        } else if (m_idHelper->is_mdt(id)) {
            detectorType = TrackState::MDT;
        } else if (m_idHelper->is_csc(id)) {
            detectorType = TrackState::CSC;
        } else if (m_idHelper->is_rpc(id)) {
            detectorType = TrackState::RPC;
        } else if (m_idHelper->is_tgc(id)) {
            detectorType = TrackState::TGC;
        } else {
            detectorType = TrackState::unidentified;
        }
    } // end if(isValid)
    // count the holes
    m_nHoles++;
    m_HoleDetectorType->push_back(detectorType);
    ATH_MSG_VERBOSE ("hole #" << m_nHoles-1 << ": detector technology identified as " << detectorType);
    if (detectorType == TrackState::Pixel) m_nPixelHoles++;
    if (detectorType == TrackState::SCT) m_nSctHoles++;
 
    // ----------------------------
    // write detector specific data
    if ( detectorType!=TrackState::unidentified ) {
        std::vector< Trk::IValidationNtupleHelperTool* >::const_iterator toolIter;
        std::vector< Trk::IValidationNtupleHelperTool* >::const_iterator toolIterEnd;
        switch (detectorType) {
        case TrackState::Pixel:
            toolIter = m_PixelHelperTools.begin();
            toolIterEnd = m_PixelHelperTools.end();
            break;
        case TrackState::SCT:
            toolIter = m_SCTHelperTools.begin();
            toolIterEnd = m_SCTHelperTools.end();
            break;
        case TrackState::TRT:
            toolIter = m_TRTHelperTools.begin();
            toolIterEnd = m_TRTHelperTools.end();
            break;
        case TrackState::MDT:
            toolIter = m_MDTHelperTools.begin();
            toolIterEnd = m_MDTHelperTools.end();
            break;
        case TrackState::CSC:
            toolIter = m_CSCHelperTools.begin();
            toolIterEnd = m_CSCHelperTools.end();
            break;
        case TrackState::RPC:
            toolIter = m_RPCHelperTools.begin();
            toolIterEnd = m_RPCHelperTools.end();
            break;
        case TrackState::TGC:
            toolIter = m_TGCHelperTools.begin();
            toolIterEnd = m_TGCHelperTools.end();
            break;
        }
        // now run the detector specific helper tools
        for (; toolIter!=toolIterEnd; ++toolIter) {
            if (((*toolIter)->fillHoleData(tsos, detectorType)).isFailure()) {
                msg(MSG::WARNING) << "sub-det helper tool did not succeed to fill hole data"  << endmsg;
            }
        }
    } //end if (detectorType!=TrackState::unidentified)
 
    // call the general tools
    if (!m_GeneralHelperTools.empty()) {
        std::vector< Trk::IValidationNtupleHelperTool* >::iterator toolIter = m_GeneralHelperTools.begin();
        for (; toolIter!=m_GeneralHelperTools.end(); ++toolIter) {
            if (((*toolIter)->fillHoleData(tsos, detectorType)).isFailure()) {
                msg(MSG::WARNING) << "general helper tool did not succeed to fill general hole data"  << endmsg;
            }
        }
    }
    return StatusCode::SUCCESS;
}

◆ fillMeasurementData()

StatusCode Trk::MeasurementVectorNtupleTool::fillMeasurementData	(	const Trk::MeasurementBase *	measurement,
		const Trk::TrackParameters *	trkParameters,
		const bool &	isOutlier,
		const int &	detectorType )

private

fill variables with call for each measurement TSoS

fill the per-state vector variables

Definition at line 715 of file MeasurementVectorNtupleTool.cxx.

                               {
 
    ATH_MSG_VERBOSE ("in fillMeasurementData");
 
    if (!isOutlier && trkParameters==nullptr) {
      ATH_MSG_VERBOSE ("Given TrackParameters == NULL");
      if(!m_trkParametersWarning) {
        // warn once only!
        msg(MSG::WARNING) << "TSoS (type: measurement) contains no TrackParameters: Residuals, etc. cannot be calculated" << endmsg;
        msg(MSG::WARNING) << "   This is possible for slimmed tracks; if residuals are needed choose another track collection" << endmsg;
        msg(MSG::WARNING) << "   (further warnings will be suppressed)" << endmsg;
        m_trkParametersWarning = true;
      }
    }
 
    m_isOutlier->push_back(isOutlier? 1 : 0);
    if (!m_residualPullCalculator.empty()) {
      // --------------------------------------
      // fill general residuals and pulls
      // for the residuals and pulls always use the ROT.
      // --------------------------------------
      float residualLocX = s_errorEntry;
      float residualLocY = s_errorEntry;
      float pullLocX     = s_errorEntry;
      float pullLocY     = s_errorEntry;
      if (trkParameters) {
        std::optional<Trk::ResidualPull> residualPull
          = m_residualPullCalculator->residualPull(measurement, trkParameters,
                                                   (m_isUnbiased==1) ? Trk::ResidualPull::Unbiased :
                                                    Trk::ResidualPull::Biased);
        if (residualPull) {
          residualLocX = residualPull->residual()[Trk::loc1];
          if (residualPull->dimension() >= 2)
            residualLocY = residualPull->residual()[Trk::loc2];
          if ((residualPull->isPullValid()) || m_ignoreMissTrkCov ) {
            pullLocX = residualPull->pull()[Trk::loc1];
            if (residualPull->dimension() >= 2)
              pullLocY = residualPull->pull()[Trk::loc2];
          } else {
            if (!m_pullWarning && !isOutlier) {  // warn only once!!!
              m_pullWarning = true;
              msg(MSG::WARNING) << "no covariance of the track parameters given, can not compute pull!" << endmsg;
              msg(MSG::INFO) << "Detector type "<< detectorType
                 << (isOutlier? " (flagged as outlier)" : "(not an outlier)") << endmsg;
              msg(MSG::INFO) << "you may want to use the jobOption 'IgnoreMissingTrackCovarianceForPulls' to calculate it anyhow." << endmsg;
              msg(MSG::INFO) << "No further warnings will be given for this type of situation." << endmsg;
            } else {
              ATH_MSG_DEBUG ("invalid pull due to missing COV at detector type " << detectorType
                             << (isOutlier? " (flagged as outlier)." : "."));
            }
          }
        } else {
          msg(MSG::WARNING) << "ResidualPullCalculator failed!" << endmsg;
        }
      }
      m_residualLocX->push_back(residualLocX);
      m_residualLocY->push_back(residualLocY);
      m_pullLocX->push_back(pullLocX);
      m_pullLocY->push_back(pullLocY);
    } // end if (!m_residualPullCalculator.empty())
 
    return StatusCode::SUCCESS;
}

◆ fillTrackData()

StatusCode Trk::MeasurementVectorNtupleTool::fillTrackData	(	const Trk::Track &	track,
		const int	iterationIndex,
		const unsigned int	fitStatCode )

virtual

fill ntuple data of a given track without writing the record.

fill track data into variables without actually writing the record

if this method is called twice without writing the ntuple inbetween the first data will be lost!

Implements Trk::ITrackValidationNtupleTool.

Definition at line 448 of file MeasurementVectorNtupleTool.cxx.

                           {
   // const Trk::FitterStatusCode /*fitStatCode*/ ) const {
 
  ATH_MSG_VERBOSE ("in fillTrackData(trk, indx) filling info about track states");
 
  resetVariables();
  if (m_updator) {
    m_isUnbiased = 1;
  } else {
    m_isUnbiased = 0;
  }
 
  //----------------------------------------------
  // fill info about trackstates in ntuple
  const Trk::TrackStates* trackStates=track.trackStateOnSurfaces();
  if (trackStates == nullptr) {
    msg(MSG::WARNING) << "current track does not have any TrackStateOnSurface vector, no data will be written for this track" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Loop over all track states on surfaces
  int stateIndexCounter=0;
  for (const auto *trackState : *trackStates) {
 
 
    if (!trackState) {
      msg(MSG::WARNING) << "TrackStateOnSurface == Null" << endmsg;
      continue;
    }
    if (trackState->type(Trk::TrackStateOnSurface::Measurement) ||
        trackState->type(Trk::TrackStateOnSurface::Outlier)     ) {
 
      ++stateIndexCounter;
      ATH_MSG_VERBOSE ("try to get measurement for track state");
      // Get pointer to measurement on track
      const Trk::MeasurementBase *measurement = trackState->measurementOnTrack();
      if (!measurement) {
        msg(MSG::ERROR) << "measurementOnTrack == Null for a TrackStateOnSurface "
                        << "of type Measurement or Outlier" << endmsg;
        return StatusCode::FAILURE;
      } // end if (!measurement)
      TrackState::MeasurementType detectorType = m_detTypeHelper->defineType(measurement);
      const Trk::TrackParameters* theParameters = trackState->trackParameters();
      const Trk::TrackParameters* unbiasedParameters = nullptr;
 
      // -----------------------------------------
      // use unbiased track states or normal ones?
      // unbiased track parameters are tried to retrieve if the updator tool
      //    is available and if unbiased track states could be produced before
      //    for the current track (ie. if one trial to get unbiased track states
      //    fails, for all following track states of the current track the biased state
      //    will be used).
      if (theParameters && m_updator && (m_isUnbiased==1)
          && (detectorType!=TrackState::Pseudo)
      && (! trackState->type(Trk::TrackStateOnSurface::Outlier)) ) {
        if ( theParameters->covariance() ) {
            // Get unbiased state
          unbiasedParameters = m_updator->removeFromState( *theParameters,
                               measurement->localParameters(),
                               measurement->localCovariance()).release();
          if (unbiasedParameters) {
            theParameters = unbiasedParameters;
            ATH_MSG_VERBOSE ("successfully calculated unbiased state");
          } else {
            if (measurement->localParameters().contains(Trk::locX)) {
              double covTrk = (*theParameters->covariance())(Trk::locX,Trk::locX);
              double covRot = measurement->localCovariance()(Trk::locX,Trk::locX);
              if (std::abs(covTrk-covRot)<0.001*covRot) {
                ATH_MSG_DEBUG("Track not overconstrained in local X (track_cov_x = "<<covTrk<<" vs. meas_cov_x="<<covRot<<" => do not calculate unbiased residual.");
              } else ATH_MSG_INFO ("Could not get unbiased track parameters, use normal parameters");
            } else ATH_MSG_INFO ("Could not get unbiased track parameters, use normal parameters");
            m_isUnbiased = 0;
          } // end if no unbiased track parameters
        } else if(!m_UpdatorWarning) {
          // warn only once!
          msg(MSG::WARNING) << "TrackParameters contain no covariance: Unbiased track states can not be calculated (ie. pulls and residuals will be too small)" << endmsg;
          m_UpdatorWarning = true;
          m_isUnbiased = 0;
        } else {
          m_isUnbiased = 0;
        } // end if no measured track parameters
      } // end if m_updator
 
      m_DetectorType->push_back((int)detectorType);
      ATH_MSG_VERBOSE ("meas #" << stateIndexCounter <<
                       ": detector technology identified as " << detectorType);
 
      if ((fillMeasurementData(measurement,
                               theParameters,
                               (trackState->type(Trk::TrackStateOnSurface::Outlier)),
                               detectorType)).isFailure())
        msg(MSG::WARNING) << "info about TrackState could not be written to ntuple" << endmsg;
      if ((callHelperTools(measurement,
                           theParameters,
                           (trackState->type(Trk::TrackStateOnSurface::Outlier)),
                           detectorType,
                           stateIndexCounter)).isFailure())
        msg(MSG::WARNING) << "Could not call helper Tool! " << endmsg;
 
      delete unbiasedParameters;
    } // end if(TSoS is measurement)
  } // end for loop on trackstates
 
 
  //----------------------------------------------
  // do hole search if selected
  if (m_doHoleSearch) {
    std::unique_ptr<const Trk::TrackStates> holesOnTrack (m_holeSearchTool->getHolesOnTrack(track, track.info().particleHypothesis()));
    // loop over holes
    if (!holesOnTrack) {
      msg(MSG::WARNING) << "Got no holes on track" << endmsg;
      return StatusCode::SUCCESS;
    }
    for (const auto *it : *holesOnTrack) {
      if (!it) {
        msg(MSG::WARNING) << "TrackStateOnSurface from hole search tool == Null" << endmsg;
        continue;
      }
      if (fillHoleData(*it).isFailure()) {
        msg(MSG::WARNING) << "info about TrackState (hole) could not be written to ntuple" << endmsg;
      }
    } // end loop on holes
  }
 
  return StatusCode::SUCCESS;
}

◆ fillTrackParticleData()

StatusCode Trk::MeasurementVectorNtupleTool::fillTrackParticleData ( const Trk::TrackParticleBase & )

virtual

fill ntuple data of a given TrackParticle without writing the record.

fill trackparticle data into variables without actually writing the record

if this method is called twice without writing the ntuple inbetween the first data will be lost!

Implements Trk::ITrackValidationNtupleTool.

Definition at line 581 of file MeasurementVectorNtupleTool.cxx.

{
 
  ATH_MSG_WARNING ("MeasurementVectorNtupleTool not meant to be used with TrackParticles.");
 
  return StatusCode::SUCCESS;
}

◆ fillTrackTruthData()

StatusCode Trk::MeasurementVectorNtupleTool::fillTrackTruthData	(	const TrackParameters *&	,
		const TrackTruth &	,
		const int	)

virtual

fill data about the truth match (score, parameter-pulls etc)

Implements Trk::ITrackValidationNtupleTool.

Definition at line 704 of file MeasurementVectorNtupleTool.cxx.

{
 
  // implement code here (truth trajectory?)
  return StatusCode::SUCCESS;
 
}

◆ finalize()

StatusCode Trk::MeasurementVectorNtupleTool::finalize ( )

Definition at line 299 of file MeasurementVectorNtupleTool.cxx.

                                                    {
 
  ATH_MSG_DEBUG ("start finalize() in " << name());
 
  if (!m_residualPullCalculator.empty()) {
    delete m_pullLocX;
    delete m_pullLocY;
    delete m_residualLocX;
    delete m_residualLocY;
  }
  delete m_DetectorType;
  delete m_isOutlier;
  delete m_pixelHitIndex;
  delete m_sctHitIndex;
  delete m_trtHitIndex;
  delete m_mdtHitIndex;
  delete m_cscHitIndex;
  delete m_rpcHitIndex;
  delete m_tgcHitIndex;
  if (m_doHoleSearch) delete m_HoleDetectorType;
  delete m_detTypeHelper;
 
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Trk::MeasurementVectorNtupleTool::initialize ( )

Definition at line 117 of file MeasurementVectorNtupleTool.cxx.

                                                      {
 
  if (!m_residualPullCalculator.empty()) {
    m_pullLocX      = new std::vector<float>();
    m_pullLocY      = new std::vector<float>();
    m_residualLocX  = new std::vector<float>();
    m_residualLocY  = new std::vector<float>();
  }
 
  m_DetectorType  = new std::vector<int>();
  m_isOutlier     = new std::vector<int>();
 
  m_pixelHitIndex = new std::vector<int>();
  m_sctHitIndex   = new std::vector<int>();
  m_trtHitIndex   = new std::vector<int>();
  m_mdtHitIndex   = new std::vector<int>();
  m_cscHitIndex   = new std::vector<int>();
  m_rpcHitIndex   = new std::vector<int>();
  m_tgcHitIndex   = new std::vector<int>();
  if (m_doHoleSearch) {
    m_HoleDetectorType  = new std::vector<int>();
  }
 
  if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
    ATH_MSG_ERROR ("Could not get AtlasDetectorID helper" );
    return StatusCode::FAILURE;
  }
  m_detTypeHelper = new MeasurementTypeID(m_idHelper);
 
  StatusCode sc(StatusCode::SUCCESS);
  // ----------------------------------
  // use updator to get unbiased states
  if ( ! m_updatorHandle.empty() ) {
    sc = m_updatorHandle.retrieve();
    if (sc.isFailure()) {
      msg(MSG::FATAL) << "Could not retrieve measurement updator tool: "<< m_updatorHandle << endmsg;
      return sc;
    }
    m_updator = &(*m_updatorHandle);
  } else {
    ATH_MSG_DEBUG ("No Updator for unbiased track states given, use normal states!");
    m_updator = nullptr;
  }
 
  // need an Atlas id-helper to identify sub-detectors, take the one from detStore
  if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
    ATH_MSG_ERROR ("Could not get AtlasDetectorID helper" );
    return StatusCode::FAILURE;
  }    // ---------------------------------------
 
  // -------------------------------
  // get given helper tools
  ToolHandleArray< Trk::IValidationNtupleHelperTool >::iterator itTools;
  // get all the given ntuple helper tools for Pixel
  if ( m_PixelNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_PixelNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_PixelNtupleHelperToolHandles << endmsg;
  }
  itTools = m_PixelNtupleHelperToolHandles.begin();
  for (  ; itTools != m_PixelNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_PixelHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for SCT
  if ( m_SCTNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_SCTNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_SCTNtupleHelperToolHandles << endmsg;
  }
  itTools = m_SCTNtupleHelperToolHandles.begin();
  for (  ; itTools != m_SCTNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_SCTHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for TRT
  if ( m_TRTNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_TRTNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_TRTNtupleHelperToolHandles << endmsg;
  }
  itTools = m_TRTNtupleHelperToolHandles.begin();
  for (  ; itTools != m_TRTNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_TRTHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for MDT
  if ( m_MDTNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_MDTNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_MDTNtupleHelperToolHandles << endmsg;
  }
  itTools = m_MDTNtupleHelperToolHandles.begin();
  for (  ; itTools != m_MDTNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_MDTHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for CSC
  if ( m_CSCNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_CSCNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_CSCNtupleHelperToolHandles << endmsg;
  }
  itTools = m_CSCNtupleHelperToolHandles.begin();
  for (  ; itTools != m_CSCNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_CSCHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for RPC
  if ( m_RPCNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_RPCNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_RPCNtupleHelperToolHandles << endmsg;
  }
  itTools = m_RPCNtupleHelperToolHandles.begin();
  for (  ; itTools != m_RPCNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_RPCHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools for TGC
  if ( m_TGCNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_TGCNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_TGCNtupleHelperToolHandles << endmsg;
  }
  itTools = m_TGCNtupleHelperToolHandles.begin();
  for (  ; itTools != m_TGCNtupleHelperToolHandles.end(); ++itTools ) {
    // add tool to list
    m_TGCHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
  // get all the given ntuple helper tools independent from detector tech
  if ( m_GeneralNtupleHelperToolHandles.retrieve().isFailure() ) {
    msg(MSG::ERROR) << "Failed to retreive " << m_GeneralNtupleHelperToolHandles << endmsg;
  } else {
    msg(MSG::INFO) << "Retrieved " << m_GeneralNtupleHelperToolHandles << endmsg;
  }
  itTools = m_GeneralNtupleHelperToolHandles.begin();
  for (  ; itTools != m_GeneralNtupleHelperToolHandles.end(); ++itTools ) {
        // add tool to list
    m_GeneralHelperTools.push_back(&(*(*itTools)));
    m_helperToolWarning[&(*(*itTools))] = false;
  }
 
  // get the ResidualPullCalculator
  if (m_residualPullCalculator.empty()) {
    msg(MSG::INFO) << "No residual/pull calculator for general hit residuals configured."
                   << endmsg;
    msg(MSG::INFO) << "It is recommended to give R/P calculators to the det-specific tool"
                   << " handle lists then." << endmsg;
  } else {
    sc = m_residualPullCalculator.retrieve();
    if (sc.isFailure()) {
      msg(MSG::FATAL) << "Could not retrieve "<< m_residualPullCalculator <<" (to calculate residuals and pulls) "<< endmsg;
      return sc;
    } else {
      msg(MSG::INFO) << "Generic hit residuals&pulls will be calculated in one or both "
                     << "available local coordinates" << endmsg;
    }
  }
  // get the hole search tool if needed
  if (m_doHoleSearch) {
    sc = m_holeSearchTool.retrieve();
    if (sc.isFailure()) {
      msg(MSG::FATAL) << "Could not retrieve "<< m_holeSearchTool <<" (needed for hole search) "<< endmsg;
      return sc;
    }
  }
 
  ATH_MSG_DEBUG ("successfully initialized in " << name());
  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::ITrackValidationNtupleTool::interfaceID ( )

inlinestaticinherited

Interface ID, declared here, and defined below.

Definition at line 69 of file ITrackValidationNtupleTool.h.

                                                                     {
    return IID_ITrackValidationNtupleTool;
}

◆ 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.

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

◆ resetVariables()

void Trk::MeasurementVectorNtupleTool::resetVariables ( )

virtual

reset the variables after writing the record to disk ntuple

Implements Trk::ITrackValidationNtupleTool.

Definition at line 593 of file MeasurementVectorNtupleTool.cxx.

                                                    {
 
  // reset the counters
  m_nPixelHits = 0;
  m_nSCTHits = 0;
  m_nTRTHits = 0;
  m_nMDTHits = 0;
  m_nCSCHits = 0;
  m_nRPCHits = 0;
  m_nTGCHits = 0;
 
  m_pixelHitIndex->clear();
  m_sctHitIndex->clear();
  m_trtHitIndex->clear();
  m_mdtHitIndex->clear();
  m_cscHitIndex->clear();
  m_rpcHitIndex->clear();
  m_tgcHitIndex->clear();
 
  if (m_doHoleSearch) {
    m_nHoles      = 0;
    m_nPixelHoles = 0;
    m_nSctHoles   = 0;
    m_HoleDetectorType->clear();
  }
 
  // clear data vectors
  if (!m_residualPullCalculator.empty()) {
    m_pullLocX->clear();
    m_pullLocY->clear();
    m_residualLocX->clear();
    m_residualLocY->clear();
  }
  m_DetectorType->clear();
  m_isOutlier->clear();
 
  std::vector< Trk::IValidationNtupleHelperTool* >::iterator toolIter;
  toolIter = m_PixelHelperTools.begin();
  for (  ; toolIter != m_PixelHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::Pixel);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_SCTHelperTools.begin();
  for (  ; toolIter != m_SCTHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::SCT);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_TRTHelperTools.begin();
  for (  ; toolIter != m_TRTHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::TRT);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_MDTHelperTools.begin();
  for (  ; toolIter != m_MDTHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::MDT);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_CSCHelperTools.begin();
  for (  ; toolIter != m_CSCHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::CSC);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_RPCHelperTools.begin();
  for (  ; toolIter != m_RPCHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::RPC);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_TGCHelperTools.begin();
  for (  ; toolIter != m_TGCHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::TGC);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
      return;
    }
  }
  toolIter = m_GeneralHelperTools.begin();
  for (  ; toolIter != m_GeneralHelperTools.end(); ++toolIter ) {
    // let tool reset its variables
    StatusCode sc = (*toolIter)->resetVariables (TrackState::unidentified);
    if(sc.isFailure())   {
      msg(MSG::ERROR)<<"The helper could not reset its ntuple variables" << endmsg;
            return;
    }
  }
}

◆ 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_CSCHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_CSCHelperTools

private

the helper tools for CSC data

Definition at line 129 of file MeasurementVectorNtupleTool.h.

◆ m_cscHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_cscHitIndex

private

corresp.

index for CSC measurement vector

Definition at line 161 of file MeasurementVectorNtupleTool.h.

◆ m_CSCNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_CSCNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for CSC

Definition at line 118 of file MeasurementVectorNtupleTool.h.

◆ m_DetectorType

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_DetectorType

private

Detector type of the measurement, enum according to TrkEventPrimitives/TrackStateDefs.h, vector of size nHits.

Definition at line 146 of file MeasurementVectorNtupleTool.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_detTypeHelper

MeasurementTypeID* Trk::MeasurementVectorNtupleTool::m_detTypeHelper

private

Definition at line 107 of file MeasurementVectorNtupleTool.h.

◆ m_doHoleSearch

bool Trk::MeasurementVectorNtupleTool::m_doHoleSearch

private

switch to turn hole search on/off

Definition at line 138 of file MeasurementVectorNtupleTool.h.

◆ m_doTruth

bool Trk::MeasurementVectorNtupleTool::m_doTruth

private

switch to turn truth on/off

Definition at line 137 of file MeasurementVectorNtupleTool.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_GeneralHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_GeneralHelperTools

private

the helper tools for data independent from detector technology

Definition at line 132 of file MeasurementVectorNtupleTool.h.

◆ m_GeneralNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_GeneralNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for data independent from detector technology

Definition at line 121 of file MeasurementVectorNtupleTool.h.

◆ m_helperToolWarning

std::map<const IValidationNtupleHelperTool*, bool> Trk::MeasurementVectorNtupleTool::m_helperToolWarning

private

Definition at line 139 of file MeasurementVectorNtupleTool.h.

◆ m_HoleDetectorType

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_HoleDetectorType

private

detector type of the hole (vector of size nHoles)

Definition at line 169 of file MeasurementVectorNtupleTool.h.

◆ m_holeSearchTool

ToolHandle<Trk::ITrackHoleSearchTool> Trk::MeasurementVectorNtupleTool::m_holeSearchTool

private

The hole search tool.

Definition at line 113 of file MeasurementVectorNtupleTool.h.

◆ m_idHelper

const AtlasDetectorID* Trk::MeasurementVectorNtupleTool::m_idHelper

private

Used to find out the sub-det from PRD->identify().

Definition at line 106 of file MeasurementVectorNtupleTool.h.

◆ m_ignoreMissTrkCov

bool Trk::MeasurementVectorNtupleTool::m_ignoreMissTrkCov

private

jobOption: ignore missing covariance of track parameters for pull calculation?

Definition at line 124 of file MeasurementVectorNtupleTool.h.

◆ m_isOutlier

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_isOutlier

private

flag if measurement is outlier (1) or not (0), vector of size nHits UNIT:0:no, 1:yes

Definition at line 147 of file MeasurementVectorNtupleTool.h.

◆ m_isUnbiased

int Trk::MeasurementVectorNtupleTool::m_isUnbiased

private

flag if track states are unbiased to the related measurements (0:no, 1:yes)

Definition at line 141 of file MeasurementVectorNtupleTool.h.

◆ m_MDTHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_MDTHelperTools

private

the helper tools for MDT data

Definition at line 128 of file MeasurementVectorNtupleTool.h.

◆ m_mdtHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_mdtHitIndex

private

corresp.

index for MDT measurement vector

Definition at line 160 of file MeasurementVectorNtupleTool.h.

◆ m_MDTNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_MDTNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for MDT

Definition at line 117 of file MeasurementVectorNtupleTool.h.

◆ m_nCSCHits

int Trk::MeasurementVectorNtupleTool::m_nCSCHits

private

number of measurements in the CSC (without outliers)

Definition at line 153 of file MeasurementVectorNtupleTool.h.

◆ m_nHoles

int Trk::MeasurementVectorNtupleTool::m_nHoles

private

number of holes on track

Definition at line 166 of file MeasurementVectorNtupleTool.h.

◆ m_nMDTHits

int Trk::MeasurementVectorNtupleTool::m_nMDTHits

private

number of measurements in the MDTs (without outliers)

Definition at line 152 of file MeasurementVectorNtupleTool.h.

◆ m_nPixelHits

int Trk::MeasurementVectorNtupleTool::m_nPixelHits

private

number of measurements in the Pixels (without outliers)

Definition at line 149 of file MeasurementVectorNtupleTool.h.

◆ m_nPixelHoles

int Trk::MeasurementVectorNtupleTool::m_nPixelHoles

private

number of Pixel holes on track

Definition at line 167 of file MeasurementVectorNtupleTool.h.

◆ m_nRPCHits

int Trk::MeasurementVectorNtupleTool::m_nRPCHits

private

number of measurements in the RPC (without outliers)

Definition at line 154 of file MeasurementVectorNtupleTool.h.

◆ m_nSCTHits

int Trk::MeasurementVectorNtupleTool::m_nSCTHits

private

number of measurements in the SCT (without outliers)

Definition at line 150 of file MeasurementVectorNtupleTool.h.

◆ m_nSctHoles

int Trk::MeasurementVectorNtupleTool::m_nSctHoles

private

number of SCT holes on track

Definition at line 168 of file MeasurementVectorNtupleTool.h.

◆ m_nTGCHits

int Trk::MeasurementVectorNtupleTool::m_nTGCHits

private

number of measurements in the TGC (without outliers)

Definition at line 155 of file MeasurementVectorNtupleTool.h.

◆ m_nTRTHits

int Trk::MeasurementVectorNtupleTool::m_nTRTHits

private

number of measurements in the TRT (without outliers)

Definition at line 151 of file MeasurementVectorNtupleTool.h.

◆ m_PixelHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_PixelHelperTools

private

the helper tools for Pixel data

Definition at line 125 of file MeasurementVectorNtupleTool.h.

◆ m_pixelHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_pixelHitIndex

private

corresp.

index for pixel measurement vector

Definition at line 157 of file MeasurementVectorNtupleTool.h.

◆ m_PixelNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_PixelNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for Pixel

Definition at line 114 of file MeasurementVectorNtupleTool.h.

◆ m_pullLocX

std::vector<float>* Trk::MeasurementVectorNtupleTool::m_pullLocX

private

pull in Trk::LocX for each measurement on the track, vector of size nHits, value set to -1000 if meas't was outlier UNIT:1

Definition at line 144 of file MeasurementVectorNtupleTool.h.

◆ m_pullLocY

std::vector<float>* Trk::MeasurementVectorNtupleTool::m_pullLocY

private

pull in Trk::LocY for each measurement on the track (value is set to -1000 if no second local coord.

exists for the meas't), vector of size nHits UNIT:1

Definition at line 145 of file MeasurementVectorNtupleTool.h.

◆ m_pullWarning

bool Trk::MeasurementVectorNtupleTool::m_pullWarning

private

warn only ones, if pull cannot be calculated

Definition at line 134 of file MeasurementVectorNtupleTool.h.

◆ m_residualLocX

std::vector<float>* Trk::MeasurementVectorNtupleTool::m_residualLocX

private

residual in Trk::LocX for each measurement on the track, vector of size nHits, value set to -1000 if meas't was outlier UNIT:mm

Definition at line 142 of file MeasurementVectorNtupleTool.h.

◆ m_residualLocY

std::vector<float>* Trk::MeasurementVectorNtupleTool::m_residualLocY

private

residual in Trk::LocY for each meas't on the track (value is set to -1000 if no second local coord.

exists for the meas't), vector of size nHits UNIT:mm

Definition at line 143 of file MeasurementVectorNtupleTool.h.

◆ m_residualPullCalculator

ToolHandle<Trk::IResidualPullCalculator> Trk::MeasurementVectorNtupleTool::m_residualPullCalculator

private

The residual and pull calculator tool.

Definition at line 112 of file MeasurementVectorNtupleTool.h.

◆ m_RPCHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_RPCHelperTools

private

the helper tools for RPC data

Definition at line 130 of file MeasurementVectorNtupleTool.h.

◆ m_rpcHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_rpcHitIndex

private

corresp.

index for RPC measurement vector

Definition at line 162 of file MeasurementVectorNtupleTool.h.

◆ m_RPCNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_RPCNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for RPC

Definition at line 119 of file MeasurementVectorNtupleTool.h.

◆ m_SCTHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_SCTHelperTools

private

the helper tools for SCT data

Definition at line 126 of file MeasurementVectorNtupleTool.h.

◆ m_sctHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_sctHitIndex

private

corresp.

index for SCT measurement vector

Definition at line 158 of file MeasurementVectorNtupleTool.h.

◆ m_SCTNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_SCTNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for SCT

Definition at line 115 of file MeasurementVectorNtupleTool.h.

◆ m_TGCHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_TGCHelperTools

private

the helper tools for TGC data

Definition at line 131 of file MeasurementVectorNtupleTool.h.

◆ m_tgcHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_tgcHitIndex

private

icorresp.

index for TGC measurement vector

Definition at line 163 of file MeasurementVectorNtupleTool.h.

◆ m_TGCNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_TGCNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for TGC

Definition at line 120 of file MeasurementVectorNtupleTool.h.

◆ m_trkParametersWarning

bool Trk::MeasurementVectorNtupleTool::m_trkParametersWarning

private

warn once only, if no track parameters exist

Definition at line 136 of file MeasurementVectorNtupleTool.h.

◆ m_TRTHelperTools

std::vector<IValidationNtupleHelperTool*> Trk::MeasurementVectorNtupleTool::m_TRTHelperTools

private

the helper tools for TRT data

Definition at line 127 of file MeasurementVectorNtupleTool.h.

◆ m_trtHitIndex

std::vector<int>* Trk::MeasurementVectorNtupleTool::m_trtHitIndex

private

corresp.

index for TRT measurement vector

Definition at line 159 of file MeasurementVectorNtupleTool.h.

◆ m_TRTNtupleHelperToolHandles

ToolHandleArray<IValidationNtupleHelperTool> Trk::MeasurementVectorNtupleTool::m_TRTNtupleHelperToolHandles

private

jobOption: List of Ntuple validation helper tools for TRT

Definition at line 116 of file MeasurementVectorNtupleTool.h.

◆ m_updator

Trk::IUpdator* Trk::MeasurementVectorNtupleTool::m_updator

private

updator for unbiased states

Definition at line 110 of file MeasurementVectorNtupleTool.h.

◆ m_updatorHandle

ToolHandle<Trk::IUpdator> Trk::MeasurementVectorNtupleTool::m_updatorHandle

private

Tool handle of updator for unbiased states.

Definition at line 109 of file MeasurementVectorNtupleTool.h.

◆ m_UpdatorWarning

bool Trk::MeasurementVectorNtupleTool::m_UpdatorWarning

private

warn only ones, if unbiased track states can not be calculated

Definition at line 135 of file MeasurementVectorNtupleTool.h.

◆ m_useROTwithMaxAssgnProb

bool Trk::MeasurementVectorNtupleTool::m_useROTwithMaxAssgnProb

private

jobOption: use ROT with max.

assignment probabilty in the case of Trk::CompetingRIOsOnTrack or use competingROT itself?

Definition at line 123 of file MeasurementVectorNtupleTool.h.

◆ 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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MeasurementVectorNtupleTool()

◆ ~MeasurementVectorNtupleTool()

Member Function Documentation

◆ addNtupleItems()

◆ callHelperTools()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ fillHoleData()

◆ fillMeasurementData()

◆ fillTrackData()

◆ fillTrackParticleData()

◆ fillTrackTruthData()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ resetVariables()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_CSCHelperTools

◆ m_cscHitIndex

◆ m_CSCNtupleHelperToolHandles

◆ m_DetectorType

◆ m_detStore

◆ m_detTypeHelper

◆ m_doHoleSearch

◆ m_doTruth

◆ m_evtStore

◆ m_GeneralHelperTools

◆ m_GeneralNtupleHelperToolHandles

◆ m_helperToolWarning

◆ m_HoleDetectorType

◆ m_holeSearchTool

◆ m_idHelper

◆ m_ignoreMissTrkCov

◆ m_isOutlier

◆ m_isUnbiased

◆ m_MDTHelperTools

◆ m_mdtHitIndex

◆ m_MDTNtupleHelperToolHandles

◆ m_nCSCHits

◆ m_nHoles

◆ m_nMDTHits

◆ m_nPixelHits

◆ m_nPixelHoles

◆ m_nRPCHits

◆ m_nSCTHits

◆ m_nSctHoles

◆ m_nTGCHits

◆ m_nTRTHits

◆ m_PixelHelperTools

◆ m_pixelHitIndex

◆ m_PixelNtupleHelperToolHandles

◆ m_pullLocX

◆ m_pullLocY

◆ m_pullWarning

◆ m_residualLocX

◆ m_residualLocY

◆ m_residualPullCalculator

◆ m_RPCHelperTools