This validation helper tool writes residual data into the ntuple using the common Trk::ResidualPullCalculator. More...

#include <ResidualValidationNtupleHelper.h>

Inheritance diagram for Trk::ResidualValidationNtupleHelper:

Collaboration diagram for Trk::ResidualValidationNtupleHelper:

Public Member Functions
	ResidualValidationNtupleHelper (const std::string &, const std::string &, const IInterface *)
	~ResidualValidationNtupleHelper ()
StatusCode	initialize ()
	initialize
StatusCode	finalize ()
	finalize
virtual StatusCode	fillMeasurementData (const Trk::MeasurementBase , const Trk::TrackParameters , const int &detectorType, const bool &isOutlier)
	fill residual data
virtual StatusCode	fillHoleData (const Trk::TrackStateOnSurface &, const int &)
	fill special data about holes on track (here: do nothing)
virtual StatusCode	addNtupleItems (TTree *tree, const int &detectorType)
	add items to the ntuple and configure the helper tool: should be called once (per detector type) by the steering tool (Trk::IValidationNtupleTool)
virtual StatusCode	resetVariables (const int &detectorType)
	reset ntuple variables
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
double	calcPull (const double residual, const double locMesCov, const double locTrkCov) const
void	givePullWarning () const
void	fillValues (const int &detectorType, double res1=-1000., double pull1=-1000., double res2=-1000., double pull2=-1000.)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_pullWarning = false
	warn only once, if pull cannot be calculated
bool	m_trkParametersWarning
	warn only once, if no track parameters exist
ToolHandle< Trk::IResidualPullCalculator >	m_residualPullCalculator
	The residual and pull calculator tool.
bool	m_ignoreMissTrkCov
int *	m_isUnbiased
std::vector< float > *	m_PixPullPhi
	hit pull in pixel local phi coord for each Pixel meas't, vector of size nPixelHits UNIT:1
std::vector< float > *	m_PixPullEta
	hit pull in pixel local eta coord for each Pixel meas't, vector of size nPixelHits UNIT:1
std::vector< float > *	m_PixResPhi
	hit residual in pixel local phi for each Pixel meas't, vector of size nPixelHits UNIT:mm
std::vector< float > *	m_PixResEta
	hit residual in pixel local eta for each Pixel meas't, vector of size nPixelHits UNIT:mm
std::vector< float > *	m_SCTPull
	hit pull in SCT local strip coord for each SCT meas't (corrects for fan-shaped strip arrangement in endcap, i.e.
std::vector< float > *	m_SCTRes
	hit residual in SCT local strip coord for each SCT meas't (corrects for fan-shaped strip arrangement in endcap, i.e.
std::vector< float > *	m_TRTPull
	hit pull in TRT drift radius for each TRT meas't, vector of size nTRTHits UNIT:1
std::vector< float > *	m_TRTRes
	hit residual in TRT drift radius for each TRT meas't, vector of size nTRTHits UNIT:mm
std::vector< float > *	m_MDTPull
	hit pull in MDT drift radius for each MDT meas't, vector of size nMDTHits UNIT:1
std::vector< float > *	m_MDTRes
	hit residual in MDT drift radius for each MDT meas't, vector of size nMDTHits UNIT:mm
std::vector< float > *	m_RPCPull
	hit pull in RPC strip coordinate for each RPC meas't, vector of size nRPCHits UNIT:1
std::vector< float > *	m_RPCRes
	hit residual in RPC coordinate for each RPC meas't, vector of size nRPCHits UNIT:mm
std::vector< float > *	m_TGCPull
	hit pull in TGC strip coordinate for each TGC meas't (corrects for fan-shaped strip arrangement), vector of size nTGCHits UNIT:1
std::vector< float > *	m_TGCRes
	hit residual in TGC strip coordinate for each TGC meas't, vector of size nTGCHits UNIT:mm
std::vector< float > *	m_CSCPull
	hit pull in CSC ?
std::vector< float > *	m_CSCRes
	hit residual in CSC ?
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 helper tool writes residual data into the ntuple using the common Trk::ResidualPullCalculator.

Author: Sebas.nosp@m.tian.nosp@m..Flei.nosp@m.schm.nosp@m.ann@c.nosp@m.ern..nosp@m.ch

Definition at line 37 of file ResidualValidationNtupleHelper.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

◆ ResidualValidationNtupleHelper()

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

Definition at line 31 of file ResidualValidationNtupleHelper.cxx.

        :
  AthAlgTool(t,n,p),
  m_trkParametersWarning(false),
  m_residualPullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
  m_isUnbiased(nullptr),
  m_PixPullPhi(nullptr), m_PixPullEta(nullptr), m_PixResPhi(nullptr), m_PixResEta(nullptr),
  m_SCTPull(nullptr),  m_SCTRes(nullptr),
  m_TRTPull(nullptr),  m_TRTRes(nullptr),
  m_MDTPull(nullptr),  m_MDTRes(nullptr),
  m_RPCPull(nullptr),  m_RPCRes(nullptr),
  m_TGCPull(nullptr),  m_TGCRes(nullptr),
  m_CSCPull(nullptr),  m_CSCRes(nullptr)
{
    declareInterface<IValidationNtupleHelperTool>(this);
    // Declare the properties
    declareProperty("IgnoreMissingTrackCovariance", m_ignoreMissTrkCov = false);
    declareProperty("ResidualPullCalculatorTool",   m_residualPullCalculator,               "Tool to calculate residuals and pulls");
    //    declareProperty("NtupleDirectoryName", m_ntupleDirName = "FitterValidation");
    //    declareProperty("NtupleTreeName", m_ntupleTreeName = "Validation");
    //    declareProperty("DoPixels", mjo_doPixels = true);
    //    declareProperty("DoTRT", mjo_doTRT = true);
}

◆ ~ResidualValidationNtupleHelper()

Trk::ResidualValidationNtupleHelper::~ResidualValidationNtupleHelper ( )

default

Member Function Documentation

◆ addNtupleItems()

StatusCode Trk::ResidualValidationNtupleHelper::addNtupleItems	(	TTree *	tree,
		const int &	detectorType )

virtual

add items to the ntuple and configure the helper tool: should be called once (per detector type) by the steering tool (Trk::IValidationNtupleTool)

addNtupleItems

Implements Trk::IValidationNtupleHelperTool.

Definition at line 117 of file ResidualValidationNtupleHelper.cxx.

                              {
 
    TBranch* trackStatesUnbiasedBranch = tree->GetBranch("TrackStatesUnbiased");
    if (!trackStatesUnbiasedBranch) {
      ATH_MSG_ERROR ( "Unable to get Branch TrackStatesUnbiased in ntuple" );
      return StatusCode::FAILURE;
    }
    void* variableAdr = static_cast<void*>(trackStatesUnbiasedBranch->GetAddress());
    if (!variableAdr) {
      ATH_MSG_ERROR ("Unable to get variable address of Branch TrackStatesUnbiased");
      return StatusCode::FAILURE;
    }
    ATH_MSG_VERBOSE ("Address of unbiasedState tree variable: " << variableAdr );
    m_isUnbiased = static_cast<int*>(variableAdr);
 
//     TBranch* nHitsBranch = m_nt->GetBranch("nHits");
//     variableAdr = static_cast<void*>(nHitsBranch->GetAddress());
//     m_hits = static_cast<int*>(variableAdr);
 
    // -------------------------------------------
    // retrieve and add items from/to the ntuple
    //    if (detectorType.test(Pixel)) {
    if (detectorType==Trk::TrackState::Pixel) {
      ATH_MSG_INFO ( "adding Pixel residual/pull variables to ntuple ");
      // add items for pixel
      tree->Branch("PixPullPhi",      &m_PixPullPhi);
      tree->Branch("PixPullEta",      &m_PixPullEta);
      tree->Branch("PixResPhi",       &m_PixResPhi);
      tree->Branch("PixResEta",       &m_PixResEta);
    }
 
    //if (detectorType.test(TRT)) {
    if (detectorType==Trk::TrackState::TRT) {
      ATH_MSG_INFO ("adding TRT residual/pull variables to ntuple ");
      tree->Branch("TRTPull",     &m_TRTPull);
      tree->Branch("TRTRes",      &m_TRTRes);
    }
    if (detectorType==Trk::TrackState::SCT) {
      ATH_MSG_INFO ( "adding SCT residual/pull variables to ntuple ");
      tree->Branch("SCTPull",     &m_SCTPull);
      tree->Branch("SCTRes",      &m_SCTRes);
    }
 
    if (detectorType==Trk::TrackState::MDT) {
      ATH_MSG_INFO ( "adding MDT residual/pull variables to ntuple ");
      // add items for MDT
      tree->Branch("MDTPull",     &m_MDTPull);
      tree->Branch("MDTRes",      &m_MDTRes);
    }
 
    if (detectorType==Trk::TrackState::RPC) {
      ATH_MSG_INFO ("adding RPC residual/pull variables to ntuple ");
      ATH_MSG_INFO ("Reminder: these variables do not distinguish RPC phi from eta hits.");
      // add items for RPC
      tree->Branch("RPCPull",     &m_RPCPull);
      tree->Branch("RPCRes",      &m_RPCRes);
    }
 
    if (detectorType==Trk::TrackState::TGC) {
      ATH_MSG_INFO ( "adding TGC residual/pull variables to ntuple ");
      ATH_MSG_INFO ( "Reminder: these variables do not distinguish TGC phi from eta hits.");
      // add items for TGC
      tree->Branch("TGCPull",     &m_TGCPull);
      tree->Branch("TGCRes",      &m_TGCRes);
    }
 
    if (detectorType==Trk::TrackState::CSC) {
      ATH_MSG_INFO ( "adding CSC residual/pull variables to ntuple ");
      ATH_MSG_INFO ( "Reminder: these variables do not distinguish CSC phi from eta hits.");
      // add items for CSC
      tree->Branch("CSCPull",     &m_CSCPull);
      tree->Branch("CSCRes",      &m_CSCRes);
    }
 
    ATH_MSG_VERBOSE ( "added items to ntuple") ;
    return StatusCode::SUCCESS;
}

◆ calcPull()

double Trk::ResidualValidationNtupleHelper::calcPull	(	const double	residual,
		const double	locMesCov,
		const double	locTrkCov ) const

private

◆ 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::ResidualValidationNtupleHelper::fillHoleData	(	const Trk::TrackStateOnSurface &	,
		const int &	)

virtual

fill special data about holes on track (here: do nothing)

Implements Trk::IValidationNtupleHelperTool.

Definition at line 306 of file ResidualValidationNtupleHelper.cxx.

                    {
    // we do nothing with holes
    return StatusCode::SUCCESS;
}

◆ fillMeasurementData()

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

virtual

fill residual data

Implements Trk::IValidationNtupleHelperTool.

Definition at line 200 of file ResidualValidationNtupleHelper.cxx.

                            {
 
    //const Trk::MeasuredTrackParameters *measuredTrkParameters = dynamic_cast<const Trk::MeasuredTrackParameters*>(trkParameters);
    if (!trkParameters) {
        if (!isOutlier) {
            // outliers usually do have not track parameters, so do not warn for them!
            if(!m_trkParametersWarning) {
                // warn once only!
              ATH_MSG_WARNING ("No TrackParameters: Residuals cannot be filled (filling dummy values).");
              ATH_MSG_WARNING ("   This is possible for slimmed tracks; if residuals are needed choose another track collection");
              ATH_MSG_WARNING ("   (further warnings will be suppressed)");
              m_trkParametersWarning = true;
            }
        }
        fillValues(detectorType);
        return StatusCode::SUCCESS;
    } // end if (!trkPar)
    /* open up to more measurement flavours
    const Trk::RIO_OnTrack *ROT = dynamic_cast<const Trk::RIO_OnTrack*>(measurement);
    if (!ROT) {
        msg(MSG::WARNING) << "No RIO_OnTrack: Residuals cannot be calculated (filling dummy values)." << endmsg;
        fillValues(detectorType);
        return StatusCode::SUCCESS;
    } */
    std::optional<Trk::ResidualPull> residualPull=std::nullopt;
    if (detectorType!=TrackState::unidentified) {
        residualPull = m_residualPullCalculator->residualPull(measurement, trkParameters,
          (*m_isUnbiased==1) ? Trk::ResidualPull::Unbiased : Trk::ResidualPull::Biased);
    } else {
      ATH_MSG_WARNING ("Detector type could not be identified, can not calculate residuals!");
      fillValues(detectorType);
      return StatusCode::FAILURE;
    }
    if (!residualPull) {
      ATH_MSG_WARNING ("Residual Pull Calculator did not succeed!");
      fillValues(detectorType);
      return StatusCode::FAILURE;
    }
 
    if (detectorType==TrackState::Pixel) {
        if ((residualPull->isPullValid()) || m_ignoreMissTrkCov ) {
            fillValues( detectorType,
                        residualPull->residual()[Trk::distPhi],
                        residualPull->pull()[Trk::distPhi],
                        residualPull->residual()[Trk::distEta],
                        residualPull->pull()[Trk::distEta] );
        } else {
            givePullWarning();
            fillValues( detectorType,
                        residualPull->residual()[Trk::distPhi],
                        -1000.,
                        residualPull->residual()[Trk::distEta],
                        -1000. );
        }
    } else {
        if ((residualPull->isPullValid()) || m_ignoreMissTrkCov ) {
            fillValues( detectorType,
                        residualPull->residual()[Trk::loc1],
                        residualPull->pull()[Trk::loc1] );
        } else {
            givePullWarning();
            fillValues( detectorType,
                        residualPull->residual()[Trk::loc1],
                        -1000. );
        }
    }
 
    return StatusCode::SUCCESS;
}

◆ fillValues()

void Trk::ResidualValidationNtupleHelper::fillValues	(	const int &	detectorType,
		double	res1 = -1000.,
		double	pull1 = -1000.,
		double	res2 = -1000.,
		double	pull2 = -1000. )

inlineprivate

Definition at line 125 of file ResidualValidationNtupleHelper.h.

                                                                                                                                        {
   if (detectorType==TrackState::Pixel) {
        m_PixResPhi->push_back(res1);
        m_PixResEta->push_back(res2);
        m_PixPullPhi->push_back(pull1);
        m_PixPullEta->push_back(pull2);
    } else if (detectorType==TrackState::SCT) {
        m_SCTRes->push_back(res1);
        m_SCTPull->push_back(pull1);
    } else if (detectorType==TrackState::TRT) {
        m_TRTRes->push_back(res1);
        m_TRTPull->push_back(pull1);
    } else if (detectorType==TrackState::MDT) {
        m_MDTRes->push_back(res1);
        m_MDTPull->push_back(pull1);
    } else if (detectorType==TrackState::RPC) {
        m_RPCRes->push_back(res1);
        m_RPCPull->push_back(pull1);
    } else if (detectorType==TrackState::TGC) {
        m_TGCRes->push_back(res1);
        m_TGCPull->push_back(pull1);
    } else if (detectorType==TrackState::CSC) {
        m_CSCRes->push_back(res1);
        m_CSCPull->push_back(pull1);
    }
}

◆ finalize()

StatusCode Trk::ResidualValidationNtupleHelper::finalize ( )

finalize

Definition at line 99 of file ResidualValidationNtupleHelper.cxx.

                                                       {
 
  delete m_PixPullPhi; delete m_PixPullEta;
  delete m_PixResPhi;  delete m_PixResEta;
  delete m_SCTPull;    delete m_SCTRes;
  delete m_TRTPull;    delete m_TRTRes;
  delete m_MDTPull;    delete m_MDTRes;
  delete m_RPCPull;    delete m_RPCRes;
  delete m_TGCPull;    delete m_TGCRes;
  delete m_CSCPull;    delete m_CSCRes;
 
  ATH_MSG_INFO ("finalize() successful in " << name() );
  return StatusCode::SUCCESS;
}

◆ givePullWarning()

void Trk::ResidualValidationNtupleHelper::givePullWarning ( ) const

inlineprivate

Definition at line 118 of file ResidualValidationNtupleHelper.h.

                                                                      {
   [[maybe_unused]] static const bool pullWarningOnce = [&]() {
        msg(MSG::WARNING) << "no covariance of the track parameters given, can not calc pull!" << endmsg;
        msg(MSG::WARNING) << "you may want to use the jobOption 'IgnoreMissingTrackCovariance' to calculate it anyhow." << endmsg;
        return true;
   }();
 }

◆ initialize()

StatusCode Trk::ResidualValidationNtupleHelper::initialize ( )

initialize

Definition at line 64 of file ResidualValidationNtupleHelper.cxx.

                                                         {
 
 
  StatusCode sc = AthAlgTool::initialize();
  if (sc.isFailure()) return sc;
 
  // get the ResidualPullCalculator
  sc = m_residualPullCalculator.retrieve();
  if (sc.isFailure()) {
    ATH_MSG_ERROR ("Could not retrieve "<< m_residualPullCalculator <<" (to calculate residuals,pulls) ");
    return sc;
  }
  m_PixPullPhi = new std::vector<float>();
  m_PixPullEta = new std::vector<float>();
  m_PixResPhi  = new std::vector<float>();
  m_PixResEta  = new std::vector<float>();
  m_SCTPull = new std::vector<float>();
  m_SCTRes  = new std::vector<float>();
  m_TRTPull = new std::vector<float>();
  m_TRTRes  = new std::vector<float>();
  m_MDTPull = new std::vector<float>();
  m_MDTRes  = new std::vector<float>();
  m_RPCPull = new std::vector<float>();
  m_RPCRes  = new std::vector<float>();
  m_TGCPull = new std::vector<float>();
  m_TGCRes  = new std::vector<float>();
  m_CSCPull = new std::vector<float>();
  m_CSCRes  = new std::vector<float>();
 
  return sc;
}

◆ 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::IValidationNtupleHelperTool::interfaceID ( )

inlinestaticinherited

Interface ID, declared here, and defined below.

Definition at line 76 of file IValidationNtupleHelperTool.h.

                                                                      {
    return IID_IValidationNtupleHelperTool;
}

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

StatusCode Trk::ResidualValidationNtupleHelper::resetVariables ( const int & detectorType )

virtual

reset ntuple variables

Implements Trk::IValidationNtupleHelperTool.

Definition at line 276 of file ResidualValidationNtupleHelper.cxx.

                                  {
    if (detectorType==TrackState::Pixel) {
        m_PixPullPhi->clear();
        m_PixPullEta->clear();
        m_PixResPhi->clear();
        m_PixResEta->clear();
    } else if (detectorType==TrackState::SCT) {
        m_SCTPull->clear();
        m_SCTRes->clear();
    } else if (detectorType==TrackState::TRT) {
        m_TRTRes->clear();
        m_TRTPull->clear();
    } else if (detectorType==TrackState::MDT) {
        m_MDTRes->clear();
        m_MDTPull->clear();
    } else if (detectorType==TrackState::RPC) {
        m_RPCRes->clear();
        m_RPCPull->clear();
    } else if (detectorType==TrackState::TGC) {
        m_TGCRes->clear();
        m_TGCPull->clear();
    } else if (detectorType==TrackState::CSC) {
        m_CSCRes->clear();
        m_CSCPull->clear();
    }
    return StatusCode::SUCCESS;
}

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

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_CSCPull

private

hit pull in CSC ?

?? coordinate for each CSC meas't, vector of size nCSCHits UNIT:1

Definition at line 113 of file ResidualValidationNtupleHelper.h.

◆ m_CSCRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_CSCRes

private

hit residual in CSC ?

?? coordinate for each CSC meas't, vector of size nCSCHits UNIT:mm

Definition at line 114 of file ResidualValidationNtupleHelper.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_ignoreMissTrkCov

bool Trk::ResidualValidationNtupleHelper::m_ignoreMissTrkCov

private

Definition at line 88 of file ResidualValidationNtupleHelper.h.

◆ m_isUnbiased

int* Trk::ResidualValidationNtupleHelper::m_isUnbiased

private

Definition at line 90 of file ResidualValidationNtupleHelper.h.

◆ m_MDTPull

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_MDTPull

private

hit pull in MDT drift radius for each MDT meas't, vector of size nMDTHits UNIT:1

Definition at line 104 of file ResidualValidationNtupleHelper.h.

◆ m_MDTRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_MDTRes

private

hit residual in MDT drift radius for each MDT meas't, vector of size nMDTHits UNIT:mm

Definition at line 105 of file ResidualValidationNtupleHelper.h.

◆ m_PixPullEta

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_PixPullEta

private

hit pull in pixel local eta coord for each Pixel meas't, vector of size nPixelHits UNIT:1

Definition at line 94 of file ResidualValidationNtupleHelper.h.

◆ m_PixPullPhi

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_PixPullPhi

private

hit pull in pixel local phi coord for each Pixel meas't, vector of size nPixelHits UNIT:1

Definition at line 93 of file ResidualValidationNtupleHelper.h.

◆ m_PixResEta

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_PixResEta

private

hit residual in pixel local eta for each Pixel meas't, vector of size nPixelHits UNIT:mm

Definition at line 96 of file ResidualValidationNtupleHelper.h.

◆ m_PixResPhi

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_PixResPhi

private

hit residual in pixel local phi for each Pixel meas't, vector of size nPixelHits UNIT:mm

Definition at line 95 of file ResidualValidationNtupleHelper.h.

◆ m_pullWarning

bool Trk::ResidualValidationNtupleHelper::m_pullWarning = false

private

warn only once, if pull cannot be calculated

Definition at line 82 of file ResidualValidationNtupleHelper.h.

◆ m_residualPullCalculator

ToolHandle<Trk::IResidualPullCalculator> Trk::ResidualValidationNtupleHelper::m_residualPullCalculator

private

The residual and pull calculator tool.

Definition at line 86 of file ResidualValidationNtupleHelper.h.

◆ m_RPCPull

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_RPCPull

private

hit pull in RPC strip coordinate for each RPC meas't, vector of size nRPCHits UNIT:1

Definition at line 107 of file ResidualValidationNtupleHelper.h.

◆ m_RPCRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_RPCRes

private

hit residual in RPC coordinate for each RPC meas't, vector of size nRPCHits UNIT:mm

Definition at line 108 of file ResidualValidationNtupleHelper.h.

◆ m_SCTPull

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_SCTPull

private

hit pull in SCT local strip coord for each SCT meas't (corrects for fan-shaped strip arrangement in endcap, i.e.

pull is perpendicular to strip direction), vector of size nSCTHits UNIT:1

Definition at line 98 of file ResidualValidationNtupleHelper.h.

◆ m_SCTRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_SCTRes

private

hit residual in SCT local strip coord for each SCT meas't (corrects for fan-shaped strip arrangement in endcap, i.e.

residual is perpendicular to strip direction), vector of size nSCTHits UNIT:mm

Definition at line 99 of file ResidualValidationNtupleHelper.h.

◆ m_TGCPull

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_TGCPull

private

hit pull in TGC strip coordinate for each TGC meas't (corrects for fan-shaped strip arrangement), vector of size nTGCHits UNIT:1

Definition at line 110 of file ResidualValidationNtupleHelper.h.

◆ m_TGCRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_TGCRes

private

hit residual in TGC strip coordinate for each TGC meas't, vector of size nTGCHits UNIT:mm

Definition at line 111 of file ResidualValidationNtupleHelper.h.

◆ m_trkParametersWarning

bool Trk::ResidualValidationNtupleHelper::m_trkParametersWarning

private

warn only once, if no track parameters exist

Definition at line 83 of file ResidualValidationNtupleHelper.h.

◆ m_TRTPull

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_TRTPull

private

hit pull in TRT drift radius for each TRT meas't, vector of size nTRTHits UNIT:1

Definition at line 101 of file ResidualValidationNtupleHelper.h.

◆ m_TRTRes

std::vector<float>* Trk::ResidualValidationNtupleHelper::m_TRTRes

private

hit residual in TRT drift radius for each TRT meas't, vector of size nTRTHits UNIT:mm

Definition at line 102 of file ResidualValidationNtupleHelper.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

◆ ResidualValidationNtupleHelper()

◆ ~ResidualValidationNtupleHelper()

Member Function Documentation

◆ addNtupleItems()

◆ calcPull()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ fillHoleData()

◆ fillMeasurementData()

◆ fillValues()

◆ finalize()

◆ givePullWarning()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ resetVariables()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_CSCPull

◆ m_CSCRes

◆ m_detStore

◆ m_evtStore

◆ m_ignoreMissTrkCov

◆ m_isUnbiased

◆ m_MDTPull

◆ m_MDTRes

◆ m_PixPullEta

◆ m_PixPullPhi

◆ m_PixResEta

◆ m_PixResPhi

◆ m_pullWarning

◆ m_residualPullCalculator

◆ m_RPCPull

◆ m_RPCRes

◆ m_SCTPull

◆ m_SCTRes

◆ m_TGCPull

◆ m_TGCRes

◆ m_trkParametersWarning

◆ m_TRTPull

◆ m_TRTRes

◆ m_varHandleArraysDeclared

◆ m_vhka