#include <SimpleIDNtupleTool.h>

Inheritance diagram for InDet::SimpleIDNtupleTool:

Collaboration diagram for InDet::SimpleIDNtupleTool:

Public Member Functions
	SimpleIDNtupleTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SimpleIDNtupleTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual void	dumpTrack (int itrk, const Trk::AlignTrack *alignTrack) override
	fills track information to ntuple
void	fillHits (const Trk::AlignTrack *alignTrack)
	fills hit information to ntuple
virtual void	storeHitmap () override
	stores hitmap for writing to ntuple
virtual void	fillHitmap () override
	fills ntuple with hit information
virtual void	fillSummary () override
	fills ntuple with event and track summary information
virtual void	showStatistics () override
	write statistics out to log file
virtual void	setNtuple (TFile *ntuple) override
	sets the output stream for the logfile
virtual StatusCode	fillNtuple () override
	writes trees and histograms to ntuple
virtual void	fillChi2VChamberShift (const int, const int, int , double , double , double , double , double , double *)
	used for numerical derivatives to write chi2 vs.
virtual void	setLogStream (std::ostream *os)
	returns pointer to TFile containing 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 ()

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.

Protected Attributes
std::ostream *	m_logStream = nullptr
	logfile output stream

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	initializeNtuple ()
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Trk::ITrackParticleCreatorTool >	m_particleCreator
	Pointer to track particle creator tool.
ToolHandle< Trk::IAlignModuleTool >	m_alignModuleTool
	Pointer to AlignmModuleTool.
const TRT_ID *	m_idHelper
TFile *	m_file
TTree *	m_tree
int	m_runNumber
int	m_evtNumber
double	m_xvtx
	x coord of track perigee (xvtx in ntuple)
double	m_yvtx
	y coord of track perigee (yvtx in ntuple)
double	m_zvtx
	z coord of track perigee (zvtx in ntuple)
double	m_d0
	d0 perigee parameter of reconstructed track (d0 in ntuple)
double	m_z0
	z0 perigee parameter of reconstructed track (z0 in ntuple)
double	m_phi0
	phi perigee parameter of reconstructed track (phi0 in ntuple)
double	m_theta
	theta perigee parameter of reconstructed track (theta in ntuple)
double	m_qoverp
	Q over p perigee parameter of reconstructed track (qoverp in ntuple)
double	m_pt
	pt perigee parameter of reconstructed track (pt in ntuple)
double	m_eta
	eta of perigee of reconstructed track (eta in ntuple)
double	m_chi2
	Chi2 of the track fit (chi2 in ntuple)
int	m_ndof
	number of degrees of freedom of the track fit (ndof in ntuple)
double	m_chi2prob
	Chi2 probability of the track fit (chi2prob in ntuple)
int	m_nhits
	number of hits on track [including scattering centers] (nhits in ntuple)
int	m_nhitstrt
	number of TRT hits on track (ntrthits in ntuple)
int	m_nhitssct
	number of SCT hits on track (nscthits in ntuple)
int	m_nhitspix
	number of Pixel hits on track (ntrthits in ntuple)
int	m_nshared
	number of shared hits on track (nshared in ntuple)
int	m_nshsct
	number of shared SCT hits on track (nshsct in ntuple)
int	m_nshpix
	number of shared Pixel hits on track (nshpix in ntuple)
int	m_nholes
	number of holes on track (nholes in ntuple)
int	m_nhsct
	number of SCT holes on track (nhsct in ntuple)
int	m_nhpix
	number of Pixel holes on track (nhpix in ntuple)
double *	m_hit_rho
	radius of hit (hit_rho in ntuple)
double *	m_hit_phi
	phi angle of hit (hit_phi in ntuple)
double *	m_hit_z
	z coord of hit (hit_z in ntuple)
double *	m_hit_cotth
	cot(theta) of hit (hit_cotth in ntuple)
double *	m_hit_eta
	eta angle of hit (hit_eta in ntuple)
double *	m_hit_xloc
	local x coord of hit (hit_xloc in ntuple)
double *	m_hit_yloc
	local y coord of hit (hit_yloc in ntuple)
double *	m_hit_zloc
	local z coord of hit (hit_zloc in ntuple)
double *	m_hit_drd
	drift distance to wire for hit (hit_drd in ntuple)
double *	m_hit_sig
	hit error (hit_sig in ntuple)
double *	m_hit_resx
	X-residual of the hit.
double *	m_hit_resx_err
	X-residual error of the hit.
double *	m_hit_resy
	Y-residual of the hit.
double *	m_hit_resy_err
	Y-residual error of the hit.
double *	m_hit_tpar_x
	track parameter locX
double *	m_hit_tpar_y
	track parameter locY
int *	m_hit_det
	detector type for the hit
int *	m_hit_type
	hit type
double *	m_hit_derivx_transx
	derivatives of X-residual wrt.
double *	m_hit_derivx_transy
	derivatives of X-residual wrt.
double *	m_hit_derivx_transz
	derivatives of X-residual wrt.
double *	m_hit_derivx_rotx
	derivatives of X-residual wrt.
double *	m_hit_derivx_roty
	derivatives of X-residual wrt.
double *	m_hit_derivx_rotz
	derivatives of X-residual wrt.
double *	m_hit_derivx_bowx
	derivatives of X-residual wrt.
double *	m_hit_derivx_bowy
	derivatives of X-residual wrt.
double *	m_hit_derivx_bowz
	derivatives of X-residual wrt.
double *	m_hit_derivy_transx
	derivatives of Y-residual wrt.
double *	m_hit_derivy_transy
	derivatives of Y-residual wrt.
double *	m_hit_derivy_transz
	derivatives of Y-residual wrt.
double *	m_hit_derivy_rotx
	derivatives of Y-residual wrt.
double *	m_hit_derivy_roty
	derivatives of Y-residual wrt.
double *	m_hit_derivy_rotz
	derivatives of Y-residual wrt.
double *	m_hit_derivy_bowx
	derivatives of Y-residual wrt.
double *	m_hit_derivy_bowy
	derivatives of Y-residual wrt.
double *	m_hit_derivy_bowz
	derivatives of Y-residual wrt.
int	m_max_hits
	max number of hits on track stored in ntuple
bool	m_storeDerivatives
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

Definition at line 36 of file SimpleIDNtupleTool.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

◆ SimpleIDNtupleTool()

InDet::SimpleIDNtupleTool::SimpleIDNtupleTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 38 of file SimpleIDNtupleTool.cxx.

    : AthAlgTool(type, name, parent)
    , m_particleCreator("Trk::TrackParticleCreatorTool/TrackParticleCreatorTool", this)
    , m_alignModuleTool{}
    , m_idHelper{}
    , m_file{}
    , m_tree(nullptr)
    , m_runNumber{}
    , m_evtNumber{}
    , m_xvtx{}
    , m_yvtx{}
    , m_zvtx{}
    , m_d0{}
    , m_z0{}
    , m_phi0{}
    , m_theta{}
    , m_qoverp{}
    , m_pt{}
    , m_eta{}
    , m_chi2{}
    , m_ndof{}
    , m_chi2prob{}
    , m_nhits{}
    , m_nhitstrt{}
    , m_nhitssct{}
    , m_nhitspix{}
    , m_nshared{}
    , m_nshsct{}
    , m_nshpix{}
    , m_nholes{}
    , m_nhsct{}
    , m_nhpix{}
    , m_hit_rho{}
    , m_hit_phi{}
    , m_hit_z{}
    , m_hit_cotth{}
    , m_hit_eta{}
    , m_hit_xloc{}
    , m_hit_yloc{}
    , m_hit_zloc{}
    , m_hit_drd{}
    , m_hit_sig{}
    , m_hit_resx{}
    , m_hit_resx_err{}
    , m_hit_resy{}
    , m_hit_resy_err{}
    , m_hit_tpar_x{}
    , m_hit_tpar_y{}
    , m_hit_det{}
    , m_hit_type{}
    , m_hit_derivx_transx{}
    , m_hit_derivx_transy{}
    , m_hit_derivx_transz{}
    , m_hit_derivx_rotx{}
    , m_hit_derivx_roty{}
    , m_hit_derivx_rotz{}
    , m_hit_derivx_bowx{}
    , m_hit_derivx_bowy{}
    , m_hit_derivx_bowz{}
    , m_hit_derivy_transx{}
    , m_hit_derivy_transy{}
    , m_hit_derivy_transz{}
    , m_hit_derivy_rotx{}
    , m_hit_derivy_roty{}
    , m_hit_derivy_rotz{}
    , m_hit_derivy_bowx{}
    , m_hit_derivy_bowy{}
    , m_hit_derivy_bowz{}
    , m_max_hits{150}
    , m_storeDerivatives{false} {
    declareInterface<Trk::IFillNtupleTool>(this);
    declareProperty("TrackParticleCreatorTool", m_particleCreator, "tool to build TrackParticle");
    declareProperty("AlignModuleTool", m_alignModuleTool);
    declareProperty("MaxHits", m_max_hits);
    declareProperty("StoreDerivatives", m_storeDerivatives);
  }

◆ ~SimpleIDNtupleTool()

InDet::SimpleIDNtupleTool::~SimpleIDNtupleTool ( )

virtual

Definition at line 116 of file SimpleIDNtupleTool.cxx.

                                          {
    if (m_hit_rho) {
      delete [] m_hit_rho;
      delete [] m_hit_phi;
      delete [] m_hit_z;
      delete [] m_hit_cotth;
      delete [] m_hit_eta;
      delete [] m_hit_xloc;
      delete [] m_hit_yloc;
      delete [] m_hit_zloc;
      delete [] m_hit_drd;
      delete [] m_hit_sig;
      delete [] m_hit_tpar_x;
      delete [] m_hit_tpar_y;
      delete [] m_hit_resx;
      delete [] m_hit_resx_err;
      delete [] m_hit_resy;
      delete [] m_hit_resy_err;
      delete [] m_hit_det;
      delete [] m_hit_type;
 
      if (m_hit_derivx_transx) {
        delete [] m_hit_derivx_transx;
        delete [] m_hit_derivx_transy;
        delete [] m_hit_derivx_transz;
        delete [] m_hit_derivx_rotx;
        delete [] m_hit_derivx_roty;
        delete [] m_hit_derivx_rotz;
        delete [] m_hit_derivx_bowx;
        delete [] m_hit_derivx_bowy;
        delete [] m_hit_derivx_bowz;
        delete [] m_hit_derivy_transx;
        delete [] m_hit_derivy_transy;
        delete [] m_hit_derivy_transz;
        delete [] m_hit_derivy_rotx;
        delete [] m_hit_derivy_roty;
        delete [] m_hit_derivy_rotz;
        delete [] m_hit_derivy_bowx;
        delete [] m_hit_derivy_bowy;
        delete [] m_hit_derivy_bowz;
      }
    }
  }

Member Function Documentation

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ dumpTrack()

void InDet::SimpleIDNtupleTool::dumpTrack	(	int	itrk,
		const Trk::AlignTrack *	alignTrack )

overridevirtual

fills track information to ntuple

Implements Trk::IFillNtupleTool.

Definition at line 198 of file SimpleIDNtupleTool.cxx.

                                                                              {
    ATH_MSG_DEBUG("In dumpTrack()");
 
    if (!m_tree) initializeNtuple();
 
    // get run and event numbers
    ATH_MSG_DEBUG("Retrieving event info.");
    const xAOD::EventInfo* eventInfo;
    if (evtStore()->retrieve(eventInfo).isFailure()) ATH_MSG_ERROR("Could not retrieve event info.");
    else {
      m_runNumber = eventInfo->runNumber();
      m_evtNumber = eventInfo->eventNumber();
    }
 
    // initialize variables
    constexpr double invalidParameterValue{-999.};
    m_d0 = invalidParameterValue;
    m_z0 = invalidParameterValue;
    m_phi0 = invalidParameterValue;
    m_theta = invalidParameterValue;
    m_qoverp = invalidParameterValue;;
    m_pt = invalidParameterValue;
    m_eta = invalidParameterValue;
    m_xvtx = invalidParameterValue;
    m_yvtx = invalidParameterValue;
    m_zvtx = invalidParameterValue;;
 
    constexpr int initialiseNHits{0};
    m_nhitspix = initialiseNHits;
    m_nhitssct = initialiseNHits;
    m_nhitstrt = initialiseNHits;
    m_nshared = initialiseNHits;
    m_nshpix = initialiseNHits;
    m_nshsct = initialiseNHits;
    m_nholes = initialiseNHits;
    m_nhpix = initialiseNHits;
    m_nhsct = initialiseNHits;
    
    constexpr double invalidChiSq(-1e12);
    constexpr int invalidDegreesOfFreedom{-999};
    m_chi2 = invalidChiSq;
    m_chi2prob = invalidChiSq;
    m_ndof = invalidDegreesOfFreedom;
 
    const Trk::Perigee* aMeasPer = (alignTrack->perigeeParameters());
    if (not aMeasPer) ATH_MSG_ERROR("Could not get Trk::MeasuredPerigee");
    else {
      m_d0 = aMeasPer->parameters()[Trk::d0];
      m_z0 = aMeasPer->parameters()[Trk::z0];
      m_phi0 = aMeasPer->parameters()[Trk::phi0];
      m_theta = aMeasPer->parameters()[Trk::theta];
      m_qoverp = aMeasPer->parameters()[Trk::qOverP];
      ATH_MSG_DEBUG(itrk << ". " << " Track Parameters (d0, z0, phi0, theta, q/p)");
      ATH_MSG_DEBUG(" " << m_d0 << ", " << m_z0 << ", " << m_phi0 << ", " << m_theta << ", " << m_qoverp);
      m_pt = std::sqrt((aMeasPer->momentum().x()) * (aMeasPer->momentum().x())
                       + (aMeasPer->momentum().y()) * (aMeasPer->momentum().y()));
      m_eta = aMeasPer->eta();
      m_xvtx = aMeasPer->position().x();
      m_yvtx = aMeasPer->position().y();
      m_zvtx = aMeasPer->position().z();
 
      xAOD::TrackParticle* trackPart = m_particleCreator->createParticle(*alignTrack);
      uint8_t iSummaryValue(0); // Dummy counter to retrieve summary values
 
      if (not trackPart) ATH_MSG_ERROR("Could not get xAOD::TrackParticle");
      else {
        // hits
        m_nhitspix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHits) ? iSummaryValue : 0;
        m_nhitssct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHits) ? iSummaryValue : 0;
        m_nhitstrt = trackPart->summaryValue(iSummaryValue, xAOD::numberOfTRTHits) ? iSummaryValue : 0;
 
        ATH_MSG_DEBUG("   -- number of Pixel hits : " << m_nhitspix);
        ATH_MSG_DEBUG("   -- number of SCT hits   : " << m_nhitssct);
        ATH_MSG_DEBUG("   -- number of TRT hits   : " << m_nhitstrt);
 
        // shared hits
        m_nshpix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelSharedHits) ? iSummaryValue : 0;
        m_nshsct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTSharedHits) ? iSummaryValue : 0;
        m_nshared = m_nshpix + m_nshsct;
 
        if (m_nshpix < 0) m_nshpix = 0;
        if (m_nshsct < 0) m_nshsct = 0;
        if (m_nshared < 0) m_nshared = 0;
 
        ATH_MSG_DEBUG(" - number of shared hits         : " << m_nshared);
        ATH_MSG_DEBUG("  -- number of Pixel shared hits : " << m_nshpix);
        ATH_MSG_DEBUG("  -- number of SCT shared hits   : " << m_nshsct);
 
        // holes
        m_nhpix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHoles) ? iSummaryValue : 0;
        m_nhsct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHoles) ? iSummaryValue : 0;
        m_nholes = m_nhpix + m_nhsct;
 
        if (m_nhpix < 0) m_nhpix = 0;
        if (m_nhsct < 0) m_nhsct = 0;
        if (m_nholes < 0) m_nholes = 0;
 
        ATH_MSG_DEBUG(" - number of Pixel holes : " << m_nhpix);
        ATH_MSG_DEBUG("  -- number of SCT holes : " << m_nhsct);
        ATH_MSG_DEBUG("  -- number of holes     : " << m_nholes);
      }
 
      // get fit quality and chi2 probability of track
      const Trk::FitQuality* fitQual = alignTrack->fitQuality();
      if (not fitQual) ATH_MSG_ERROR("No fit quality assigned to the track");
      else {
        if (fitQual->chiSquared() > 0. && fitQual->numberDoF() > 0) {
          m_chi2 = fitQual->chiSquared();
          m_ndof = fitQual->numberDoF();
          m_chi2prob = TMath::Prob(m_chi2, m_ndof);
 
          ATH_MSG_DEBUG("  - chi2             : " << m_chi2);
          ATH_MSG_DEBUG("  - ndof             : " << m_ndof);
          ATH_MSG_DEBUG("  - chi2/ndof        : " << m_chi2 / (double) m_ndof);
          ATH_MSG_DEBUG("  - chi2 propability : " << m_chi2prob);
        }
      }
    }
 
    // store information for all hits on this track, including
    // scattering centers
    const Trk::AlignTSOSCollection* alignTSOSCollection = alignTrack->alignTSOSCollection();
    int nhitsTotal = alignTSOSCollection->size();
    if (nhitsTotal > m_max_hits) nhitsTotal = m_max_hits;
 
 
    fillHits(alignTrack);
 
 
    m_file->cd();
    m_tree->Fill();
    ATH_MSG_DEBUG("tree filled");
 
    ++itrk;
    return;
  }

◆ 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

◆ fillChi2VChamberShift()

virtual void Trk::IFillNtupleTool::fillChi2VChamberShift	(	const int	,
		const int	,
		int *	,
		double **	,
		double **	,
		double **	,
		double **	,
		double **	,
		double **	)

inlinevirtualinherited

used for numerical derivatives to write chi2 vs.

chamber positions

Definition at line 59 of file IFillNtupleTool.h.

61 {}

◆ fillHitmap()

void InDet::SimpleIDNtupleTool::fillHitmap ( )

overridevirtual

fills ntuple with hit information

Implements Trk::IFillNtupleTool.

Definition at line 590 of file SimpleIDNtupleTool.cxx.

590 {

591 }

◆ fillHits()

void InDet::SimpleIDNtupleTool::fillHits ( const Trk::AlignTrack * alignTrack )

fills hit information to ntuple

Definition at line 336 of file SimpleIDNtupleTool.cxx.

                                                                   {
    ATH_MSG_DEBUG("In fillHits()");
 
    // store information for all  hits on this track
    // initialize ntuple variables
    for (int i = 0; i < m_max_hits; i++) {
      m_hit_rho[i] = -999.;
      m_hit_phi[i] = -999.;
      m_hit_z[i] = -999.;
      m_hit_cotth[i] = -999.;
      m_hit_eta[i] = -999.;
      m_hit_xloc[i] = -999.;
      m_hit_yloc[i] = -999.;
      m_hit_zloc[i] = -999.;
      m_hit_drd[i] = -999.;
      m_hit_sig[i] = -999.;
 
      m_hit_tpar_x[i] = -999.;
      m_hit_tpar_y[i] = -999.;
 
      m_hit_resx[i] = -999.;
      m_hit_resx_err[i] = -999.;
      m_hit_resy[i] = -999.;
      m_hit_resy_err[i] = -999.;
 
      m_hit_det[i] = -999;
      m_hit_type[i] = -999;
 
      if (m_storeDerivatives) {
        m_hit_derivx_transx[i] = -999.;
        m_hit_derivx_transy[i] = -999.;
        m_hit_derivx_transz[i] = -999.;
        m_hit_derivx_rotx[i] = -999.;
        m_hit_derivx_roty[i] = -999.;
        m_hit_derivx_rotz[i] = -999.;
        m_hit_derivx_bowx[i] = -999.;
        m_hit_derivx_bowy[i] = -999.;
        m_hit_derivx_bowz[i] = -999.;
 
        m_hit_derivy_transx[i] = -999.;
        m_hit_derivy_transy[i] = -999.;
        m_hit_derivy_transz[i] = -999.;
        m_hit_derivy_rotx[i] = -999.;
        m_hit_derivy_roty[i] = -999.;
        m_hit_derivy_rotz[i] = -999.;
        m_hit_derivy_bowx[i] = -999.;
        m_hit_derivy_bowy[i] = -999.;
        m_hit_derivy_bowz[i] = -999.;
      }
    }
 
    const Trk::AlignTSOSCollection* alignTSOSCollection = alignTrack->alignTSOSCollection();
    m_nhits = alignTSOSCollection->size();
    ATH_MSG_DEBUG("have " << m_nhits << " hits on alignTrack in total");
 
    int nhits = 0;
 
    DataVector<Trk::AlignTSOS>::const_iterator atsit = alignTSOSCollection->begin();
    DataVector<Trk::AlignTSOS>::const_iterator atsit_end = alignTSOSCollection->end();
    for (; atsit != atsit_end; ++atsit) {
      const Trk::AlignTSOS* atsos = *atsit;
      ATH_MSG_DEBUG("in loop over AlignTSOS, nhits=" << nhits);
      if (nhits == m_max_hits) break;
 
      if (!atsos->type(Trk::TrackStateOnSurface::Measurement)) continue;
 
      m_hit_det[nhits] = atsos->measType();
      ATH_MSG_DEBUG("measurement type: " << atsos->dumpMeasType());
 
 
      // get RIO
      const Trk::RIO_OnTrack* rio = atsos->rio();
      ATH_MSG_DEBUG("have RIO");
      Amg::Vector3D pos = rio->globalPosition();
 
      double locPosX(0.);
      if (rio->localParameters().contains(Trk::locX)) locPosX = rio->localParameters()[Trk::locX];
      double locPosY(0.);
      if (rio->localParameters().contains(Trk::locY)) locPosY = rio->localParameters()[Trk::locY];
      double locPosZ(0.);
      if (rio->localParameters().contains(Trk::locZ)) locPosZ = rio->localParameters()[Trk::locZ];
 
      double error = Amg::error(rio->localCovariance(), Trk::locX);
      ATH_MSG_DEBUG("error: " << error);
 
      Identifier id = rio->identify();
 
 
      m_hit_xloc[nhits] = locPosX;
      m_hit_yloc[nhits] = locPosY;
      m_hit_zloc[nhits] = locPosZ;
 
      m_hit_rho[nhits] = pos.perp();
      m_hit_phi[nhits] = pos.phi();
      m_hit_z[nhits] = pos.z();
      m_hit_sig[nhits] = error;
 
      // get residual x
      std::vector<Trk::Residual>::const_iterator ires = atsos->firstResidual();
 
      m_hit_resx[nhits] = ires->residual();
      m_hit_resx_err[nhits] = ires->error();
 
      // get residual y if applicable
      if (atsos->nResDim() > 1) {
        ++ires;
        m_hit_resy[nhits] = ires->residual();
        m_hit_resy_err[nhits] = ires->error();
      }
 
      // get local track parameters
      const Trk::TrackParameters* trackPars = nullptr;
      if (atsos->firstResidual()->residualType() == Trk::HitOnly) trackPars = atsos->trackParameters();
      else trackPars = atsos->unbiasedTrackPars();
 
      m_hit_tpar_x[nhits] = trackPars->parameters()[Trk::locX];
      m_hit_tpar_y[nhits] = trackPars->parameters()[Trk::locY];
 
 
      if (m_idHelper->is_barrel(id)) {
        m_hit_cotth[nhits] = 0.;
        m_hit_eta[nhits] = 0.;
      } else {
        m_hit_cotth[nhits] = 1. / std::tan(pos.theta());
        double etaval = -std::log(std::tan(std::atan(1. / std::abs(m_hit_cotth[nhits])) / 2.));
        if (m_hit_cotth[nhits] < 0.) etaval *= -1.;
        m_hit_eta[nhits] = etaval;
      }
      if (atsos->measType() != Trk::TrackState::TRT) m_hit_drd[nhits] = locPosX;
 
      // fill derivatives
      if (m_storeDerivatives) {
        //const std::vector<CLHEP::HepVector> * derivs = atsos->derivatives();
        const std::vector<Amg::VectorX>* derivs = atsos->derivatives();
        if (derivs) {
          int npar = derivs->at(0).rows();
 
          const DataVector<Trk::AlignPar>* alignPars = m_alignModuleTool->getAlignPars(atsos->module());
          int naPar = alignPars->size();
 
          if (npar != naPar) ATH_MSG_WARNING("number of derivatives on AlignTSOS doesn't match the one on AlignModule");
 
          else {
            for (int i = 0; i < npar; i++) {
              double derivative = (*derivs)[0][i];
              Trk::AlignModule::TransformParameters ptype = alignPars->at(i)->paramType();
              switch (ptype) {
              case Trk::AlignModule::TransX:
                m_hit_derivx_transx[nhits] = derivative;
                break;
 
              case Trk::AlignModule::TransY:
                m_hit_derivx_transy[nhits] = derivative;
                break;
 
              case Trk::AlignModule::TransZ:
                m_hit_derivx_transz[nhits] = derivative;
                break;
 
              case Trk::AlignModule::RotX:
                m_hit_derivx_rotx[nhits] = derivative;
                break;
 
              case Trk::AlignModule::RotY:
                m_hit_derivx_roty[nhits] = derivative;
                break;
 
              case Trk::AlignModule::RotZ:
                m_hit_derivx_rotz[nhits] = derivative;
                break;
 
              case Trk::AlignModule::BowX:
                m_hit_derivx_bowx[nhits] = derivative;
                break;
 
              case Trk::AlignModule::BowY:
                m_hit_derivx_bowy[nhits] = derivative;
                break;
 
              case Trk::AlignModule::BowZ:
                m_hit_derivx_bowz[nhits] = derivative;
                break;
 
              default:
                ATH_MSG_WARNING("Unknown parameter type " << ptype);
              }
            }
            if (atsos->nResDim() > 1) {
              for (int i = 0; i < npar; i++) {
                double derivative = (*derivs)[1][i];
                Trk::AlignModule::TransformParameters ptype = alignPars->at(i)->paramType();
                switch (ptype) {
                case Trk::AlignModule::TransX:
                  m_hit_derivy_transx[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::TransY:
                  m_hit_derivy_transy[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::TransZ:
                  m_hit_derivy_transz[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::RotX:
                  m_hit_derivy_rotx[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::RotY:
                  m_hit_derivy_roty[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::RotZ:
                  m_hit_derivy_rotz[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::BowX:
                  m_hit_derivy_bowx[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::BowY:
                  m_hit_derivy_bowy[nhits] = derivative;
                  break;
 
                case Trk::AlignModule::BowZ:
                  m_hit_derivy_bowz[nhits] = derivative;
                  break;
 
                default:
                  ATH_MSG_WARNING("Unknown parameter type " << ptype);
                }
              }
            }
          }
        }
      } // end of storing derivatives
 
      ++nhits;
 
      if (nhits >= m_max_hits) {
        ATH_MSG_WARNING("Number of hits on track more that maximum: " << m_nhits << " > " << m_max_hits << " "
                                                                      << "Some hits will not be stored.");
        break;
      }
    } //atsos
 
    ATH_MSG_DEBUG("done with loop over TSOS");
  }

◆ fillNtuple()

StatusCode InDet::SimpleIDNtupleTool::fillNtuple ( )

overridevirtual

writes trees and histograms to ntuple

Implements Trk::IFillNtupleTool.

Definition at line 181 of file SimpleIDNtupleTool.cxx.

                                            {
    if (m_file && m_file->IsOpen()) {
      m_file->cd();
      if (m_tree) m_tree->Write();
      else ATH_MSG_WARNING("Variable m_tree not set, nothing to write.");
    } else ATH_MSG_WARNING("Variable m_file not set or not pointing to open output file.");
    return StatusCode::SUCCESS;
  }

◆ fillSummary()

void InDet::SimpleIDNtupleTool::fillSummary ( )

overridevirtual

fills ntuple with event and track summary information

Implements Trk::IFillNtupleTool.

Definition at line 594 of file SimpleIDNtupleTool.cxx.

594 {

595 }

◆ finalize()

StatusCode InDet::SimpleIDNtupleTool::finalize ( )

overridevirtual

Implements Trk::IFillNtupleTool.

Definition at line 191 of file SimpleIDNtupleTool.cxx.

                                          {
    ATH_MSG_DEBUG("finalize() of SimpleIDNtupleTool");
 
    return StatusCode::SUCCESS;
  }

◆ initialize()

StatusCode InDet::SimpleIDNtupleTool::initialize ( )

overridevirtual

Implements Trk::IFillNtupleTool.

Definition at line 161 of file SimpleIDNtupleTool.cxx.

                                            {
    ATH_MSG_DEBUG("initialize() of SimpleIDNtupleTool");
 
    // retrieve TRT ID helper
    ATH_CHECK(detStore()->retrieve(m_idHelper, "TRT_ID"));
 
    // get TrackParticleCreatorTool
    ATH_CHECK(m_particleCreator.retrieve());
 
    // get AlignModuleTool
    if (m_alignModuleTool.empty() || m_alignModuleTool.retrieve().isFailure()) {
      ATH_MSG_FATAL("Failed to retrieve tool " << m_alignModuleTool);
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("Retrieved tool " << m_alignModuleTool);
 
    return StatusCode::SUCCESS;
  }

◆ initializeNtuple()

void InDet::SimpleIDNtupleTool::initializeNtuple ( )

private

Definition at line 602 of file SimpleIDNtupleTool.cxx.

                                            {
    m_hit_rho = new double[m_max_hits];
    m_hit_phi = new double[m_max_hits];
    m_hit_z = new double[m_max_hits];
    m_hit_cotth = new double[m_max_hits];
    m_hit_eta = new double[m_max_hits];
    m_hit_xloc = new double[m_max_hits];
    m_hit_yloc = new double[m_max_hits];
    m_hit_zloc = new double[m_max_hits];
    m_hit_drd = new double[m_max_hits];
    m_hit_sig = new double[m_max_hits];
 
    m_hit_tpar_x = new double[m_max_hits];
    m_hit_tpar_y = new double[m_max_hits];
 
    m_hit_resx = new double[m_max_hits];
    m_hit_resx_err = new double[m_max_hits];
    m_hit_resy = new double[m_max_hits];
    m_hit_resy_err = new double[m_max_hits];
 
    m_hit_det = new int[m_max_hits];
    m_hit_type = new int[m_max_hits];
 
    m_file->cd();
    m_tree = new TTree("IDAlign", "Inner Detector Alignment Ntuple");
 
    m_tree->Branch("run", &m_runNumber, "run/I");
    m_tree->Branch("evt", &m_evtNumber, "evt/I");
 
    m_tree->Branch("xvtx", &m_xvtx, "xvtx/D");
    m_tree->Branch("yvtx", &m_yvtx, "yvtx/D");
    m_tree->Branch("zvtx", &m_zvtx, "zvtx/D");
    m_tree->Branch("d0", &m_d0, "d0/D");
    m_tree->Branch("z0", &m_z0, "z0/D");
    m_tree->Branch("phi0", &m_phi0, "phi0/D");
    m_tree->Branch("theta", &m_theta, "theta/D");
    m_tree->Branch("qoverp", &m_qoverp, "qoverp/D");
    m_tree->Branch("pt", &m_pt, "pt/D");
    m_tree->Branch("eta", &m_eta, "eta/D");
    m_tree->Branch("chi2", &m_chi2, "chi2/D");
    m_tree->Branch("ndof", &m_ndof, "ndof/I");
    m_tree->Branch("chi2prob", &m_chi2prob, "chi2prob/D");
 
    m_tree->Branch("nhits", &m_nhits, "nhits/I");
    m_tree->Branch("nhitstrt", &m_nhitstrt, "nhitstrt/I");
    m_tree->Branch("nhitssct", &m_nhitssct, "nhitssct/I");
    m_tree->Branch("nhitspix", &m_nhitspix, "nhitspix/I");
    m_tree->Branch("nshared", &m_nshared, "nshared/I");
    m_tree->Branch("nshsct", &m_nshsct, "nshsct/I");
    m_tree->Branch("nshpix", &m_nshpix, "nshpix/I");
    m_tree->Branch("nholes", &m_nholes, "nholes/I");
    m_tree->Branch("nhsct", &m_nhsct, "nhsct/I");
    m_tree->Branch("nhpix", &m_nhpix, "nhpix/I");
 
    m_tree->Branch("hit_rho", m_hit_rho, "hit_rho[nhits]/D");
    m_tree->Branch("hit_phi", m_hit_phi, "hit_phi[nhits]/D");
    m_tree->Branch("hit_z", m_hit_z, "hit_z[nhits]/D");
    m_tree->Branch("hit_cotth", m_hit_cotth, "hit_cotth[nhits]/D");
    m_tree->Branch("hit_eta", m_hit_eta, "hit_eta[nhits]/D");
    m_tree->Branch("hit_xloc", m_hit_xloc, "hit_xloc[nhits]/D");
    m_tree->Branch("hit_yloc", m_hit_yloc, "hit_yloc[nhits]/D");
    m_tree->Branch("hit_zloc", m_hit_zloc, "hit_zloc[nhits]/D");
    m_tree->Branch("hit_drd", m_hit_drd, "hit_drd[nhits]/D");
    m_tree->Branch("hit_sig", m_hit_sig, "hit_sig[nhits]/D");
 
    m_tree->Branch("hit_tpar_x", m_hit_tpar_x, "hit_tpar_x[nhits]/D");
    m_tree->Branch("hit_tpar_y", m_hit_tpar_y, "hit_tpar_y[nhits]/D");
 
    m_tree->Branch("hit_resx", m_hit_resx, "hit_resx[nhits]/D");
    m_tree->Branch("hit_resx_err", m_hit_resx_err, "hit_resx_err[nhits]/D");
    m_tree->Branch("hit_resy", m_hit_resy, "hit_resy[nhits]/D");
    m_tree->Branch("hit_resy_err", m_hit_resy_err, "hit_resy_err[nhits]/D");
 
    m_tree->Branch("hit_det", m_hit_det, "hit_det[nhits]/I");
    m_tree->Branch("hit_type", m_hit_type, "hit_type[nhits]/I");
 
    if (m_storeDerivatives) {
      m_hit_derivx_transx = new double[m_max_hits];
      m_hit_derivx_transy = new double[m_max_hits];
      m_hit_derivx_transz = new double[m_max_hits];
      m_hit_derivx_rotx = new double[m_max_hits];
      m_hit_derivx_roty = new double[m_max_hits];
      m_hit_derivx_rotz = new double[m_max_hits];
      m_hit_derivx_bowx = new double[m_max_hits];
      m_hit_derivx_bowy = new double[m_max_hits];
      m_hit_derivx_bowz = new double[m_max_hits];
      m_hit_derivy_transx = new double[m_max_hits];
      m_hit_derivy_transy = new double[m_max_hits];
      m_hit_derivy_transz = new double[m_max_hits];
      m_hit_derivy_rotx = new double[m_max_hits];
      m_hit_derivy_roty = new double[m_max_hits];
      m_hit_derivy_rotz = new double[m_max_hits];
      m_hit_derivy_bowx = new double[m_max_hits];
      m_hit_derivy_bowy = new double[m_max_hits];
      m_hit_derivy_bowz = new double[m_max_hits];
 
      m_tree->Branch("derivx_transx", m_hit_derivx_transx, "derivx_transx[nhits]/D");
      m_tree->Branch("derivx_transy", m_hit_derivx_transy, "derivx_transy[nhits]/D");
      m_tree->Branch("derivx_transz", m_hit_derivx_transz, "derivx_transz[nhits]/D");
      m_tree->Branch("derivx_rotx", m_hit_derivx_rotx, "derivx_rotx[nhits]/D");
      m_tree->Branch("derivx_roty", m_hit_derivx_roty, "derivx_roty[nhits]/D");
      m_tree->Branch("derivx_rotz", m_hit_derivx_rotz, "derivx_rotz[nhits]/D");
      m_tree->Branch("derivx_bowx", m_hit_derivx_bowx, "derivx_bowx[nhits]/D");
      m_tree->Branch("derivx_bowy", m_hit_derivx_bowy, "derivx_bowy[nhits]/D");
      m_tree->Branch("derivx_bowz", m_hit_derivx_bowz, "derivx_bowz[nhits]/D");
      m_tree->Branch("derivy_transx", m_hit_derivy_transx, "derivy_transx[nhits]/D");
      m_tree->Branch("derivy_transy", m_hit_derivy_transy, "derivy_transy[nhits]/D");
      m_tree->Branch("derivy_transz", m_hit_derivy_transz, "derivy_transz[nhits]/D");
      m_tree->Branch("derivy_rotx", m_hit_derivy_rotx, "derivy_rotx[nhits]/D");
      m_tree->Branch("derivy_roty", m_hit_derivy_roty, "derivy_roty[nhits]/D");
      m_tree->Branch("derivy_rotz", m_hit_derivy_rotz, "derivy_rotz[nhits]/D");
      m_tree->Branch("derivy_bowx", m_hit_derivy_bowx, "derivy_bowx[nhits]/D");
      m_tree->Branch("derivy_bowy", m_hit_derivy_bowy, "derivy_bowy[nhits]/D");
      m_tree->Branch("derivy_bowz", m_hit_derivy_bowz, "derivy_bowz[nhits]/D");
    }
    return;
  }

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

inlinestaticinherited

Definition at line 80 of file IFillNtupleTool.h.

81 { return IID_TRKALIGNINTERFACES_IFillNtupleTool; }

IID_TRKALIGNINTERFACES_IFillNtupleTool

static const InterfaceID IID_TRKALIGNINTERFACES_IFillNtupleTool("IFillNtupleTool", 1, 0)

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

◆ setLogStream()

virtual void Trk::IFillNtupleTool::setLogStream ( std::ostream * os )

inlinevirtualinherited

returns pointer to TFile containing ntuple

sets the output stream for the logfile

Definition at line 67 of file IFillNtupleTool.h.

67{ m_logStream = os; }

Trk::IFillNtupleTool::m_logStream

std::ostream * m_logStream

logfile output stream

Definition IFillNtupleTool.h:76

ReadFromCoolCompare.os

int os

Definition ReadFromCoolCompare.py:226

◆ setNtuple()

virtual void InDet::SimpleIDNtupleTool::setNtuple ( TFile * ntuple )

inlineoverridevirtual

sets the output stream for the logfile

Implements Trk::IFillNtupleTool.

Definition at line 56 of file SimpleIDNtupleTool.h.

56{ m_file=ntuple; }

◆ showStatistics()

void InDet::SimpleIDNtupleTool::showStatistics ( )

overridevirtual

write statistics out to log file

Implements Trk::IFillNtupleTool.

Definition at line 598 of file SimpleIDNtupleTool.cxx.

598 {

599 }

◆ storeHitmap()

void InDet::SimpleIDNtupleTool::storeHitmap ( )

overridevirtual

stores hitmap for writing to ntuple

Implements Trk::IFillNtupleTool.

Definition at line 586 of file SimpleIDNtupleTool.cxx.

586 {

587 }

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

ToolHandle<Trk::IAlignModuleTool> InDet::SimpleIDNtupleTool::m_alignModuleTool

private

Pointer to AlignmModuleTool.

Definition at line 63 of file SimpleIDNtupleTool.h.

◆ m_chi2

double InDet::SimpleIDNtupleTool::m_chi2

private

Chi2 of the track fit (chi2 in ntuple)

Definition at line 107 of file SimpleIDNtupleTool.h.

◆ m_chi2prob

double InDet::SimpleIDNtupleTool::m_chi2prob

private

Chi2 probability of the track fit (chi2prob in ntuple)

Definition at line 113 of file SimpleIDNtupleTool.h.

◆ m_d0

double InDet::SimpleIDNtupleTool::m_d0

private

d0 perigee parameter of reconstructed track (d0 in ntuple)

Definition at line 86 of file SimpleIDNtupleTool.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_eta

double InDet::SimpleIDNtupleTool::m_eta

private

eta of perigee of reconstructed track (eta in ntuple)

Definition at line 104 of file SimpleIDNtupleTool.h.

◆ m_evtNumber

int InDet::SimpleIDNtupleTool::m_evtNumber

private

Definition at line 72 of file SimpleIDNtupleTool.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_file

TFile* InDet::SimpleIDNtupleTool::m_file

private

Definition at line 67 of file SimpleIDNtupleTool.h.

◆ m_hit_cotth

double* InDet::SimpleIDNtupleTool::m_hit_cotth

private

cot(theta) of hit (hit_cotth in ntuple)

Definition at line 157 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_bowx

double* InDet::SimpleIDNtupleTool::m_hit_derivx_bowx

private

derivatives of X-residual wrt.

rotation X

Definition at line 194 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_bowy

double* InDet::SimpleIDNtupleTool::m_hit_derivx_bowy

private

derivatives of X-residual wrt.

rotation Y

Definition at line 195 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_bowz

double* InDet::SimpleIDNtupleTool::m_hit_derivx_bowz

private

derivatives of X-residual wrt.

rotation Y

Definition at line 196 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_rotx

double* InDet::SimpleIDNtupleTool::m_hit_derivx_rotx

private

derivatives of X-residual wrt.

rotation X

Definition at line 191 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_roty

double* InDet::SimpleIDNtupleTool::m_hit_derivx_roty

private

derivatives of X-residual wrt.

rotation Y

Definition at line 192 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_rotz

double* InDet::SimpleIDNtupleTool::m_hit_derivx_rotz

private

derivatives of X-residual wrt.

rotation Y

Definition at line 193 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_transx

double* InDet::SimpleIDNtupleTool::m_hit_derivx_transx

private

derivatives of X-residual wrt.

translation X

Definition at line 188 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_transy

double* InDet::SimpleIDNtupleTool::m_hit_derivx_transy

private

derivatives of X-residual wrt.

translation Y

Definition at line 189 of file SimpleIDNtupleTool.h.

◆ m_hit_derivx_transz

double* InDet::SimpleIDNtupleTool::m_hit_derivx_transz

private

derivatives of X-residual wrt.

translation Y

Definition at line 190 of file SimpleIDNtupleTool.h.