InDetAlignFillTrack Class Reference

#include <InDetAlignFillTrack.h>

Inheritance diagram for InDetAlignFillTrack:

Collaboration diagram for InDetAlignFillTrack:

Public Member Functions
	InDetAlignFillTrack (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	FillTrack () override
virtual int	GetTrks () const override
virtual int	GetTrkHits () const override
virtual int	GetTrkPixHits () const override
virtual int	GetTrkSCTHits () const override
virtual int	GetTrkTRTHits () const override

Private Member Functions
void	bookNtuple ()
void	bookUpNtuple ()
void	bookLowNtuple ()
void	bookMatchingNtuple ()
int	dumpTrackCol (const TrackCollection *)
int	dumpTrackCol (const TrackCollection *, const std::string &)
void	dumpTrack (int, const Trk::Track *, const std::string &)
void	dumpPerigee (const Trk::TrackParameters *, int)
StatusCode	dumpMatching (const TrackCollection *, const TrackCollection *)

Private Attributes
ServiceHandle< INTupleSvc >	m_ntupleSvc {this,"NTupleSvc","NTupleSvc"}
BooleanProperty	m_doTruth {this,"doTruth",false}
	switch on/off the truth information
StringProperty	m_TruthTrkCol {this,"TruthTrkCol","TrackTruthCollection"}
StringProperty	m_inputCol {this,"InputTrkCol","Tracks"}
StringProperty	m_inputUpCol {this,"InputUpTrkCol",""}
StringProperty	m_inputLowCol {this,"InputLowTrkCol",""}
BooleanProperty	m_doMatching {this,"doMatching",true}
	switch on/off the matching information
FloatProperty	m_matchedRcut {this,"dRCut",100.}
FloatProperty	m_mindR {this,"minimumdR",10000.}
StringProperty	m_ntupleName {this,"NtupleName","/NTUPLES/GLOBFILE"}
int	m_totaltrks {0}
int	m_totalhits {0}
int	m_totalPixhits {0}
int	m_totalSCThits {0}
int	m_totalTRThits {0}
int	m_totalUptrks {0}
int	m_totalUphits {0}
int	m_totalUpPixhits {0}
int	m_totalUpSCThits {0}
int	m_totalUpTRThits {0}
int	m_totalLowtrks {0}
int	m_totalLowhits {0}
int	m_totalLowPixhits {0}
int	m_totalLowSCThits {0}
int	m_totalLowTRThits {0}
int	m_events {0}
ToolHandle< Trk::ITruthToTrack >	m_truthToTrack
ToolHandle< Trk::IExtrapolator >	m_extrapolator
ToolHandle< Trk::ITrackParticleCreatorTool >	m_particleCreator
NTuple::Item< long >	m_nt_ntracks
	number of tracks
NTuple::Item< long >	m_nt_nUptracks
	number of Up tracks
NTuple::Item< long >	m_nt_nLowtracks
	number of Low tracks
NTuple::Item< long >	m_nt_nmctracks
	number of mc tracks
NTuple::Item< long >	m_nt_matchingTrk
	matching tracks
NTuple::Array< float >	m_nt_Trk_d0
	d0 parameter
NTuple::Array< float >	m_nt_Trk_z0
	z0 parameter
NTuple::Array< float >	m_nt_Trk_phi0
	phi0 parameter
NTuple::Array< float >	m_nt_Trk_theta0
	theta0 parameter
NTuple::Array< float >	m_nt_Trk_qoverp
	q/p parameter
NTuple::Array< float >	m_nt_Trk_pt
	pt parameter
NTuple::Array< long >	m_nt_Trk_nHits
	number of hits
NTuple::Array< long >	m_nt_Trk_nhitspix
	number of Pixel hits
NTuple::Array< long >	m_nt_Trk_nhitssct
	number of SCT hits
NTuple::Array< long >	m_nt_Trk_nhitstrt
	number of TRT hits
NTuple::Array< long >	m_nt_Trk_nsharedPixels
	number of Pixel shared hits
NTuple::Array< long >	m_nt_Trk_nsharedSCT
	number of SCT shared hits
NTuple::Array< long >	m_nt_Trk_nshared
	number of shared hits
NTuple::Array< long >	m_nt_Trk_nholesPixels
	number of Pixel holes
NTuple::Array< long >	m_nt_Trk_nholesSCT
	number of SCT holes
NTuple::Array< long >	m_nt_Trk_nholes
	number of holes
NTuple::Array< float >	m_nt_Trk_chi2
	number of chi2
NTuple::Array< long >	m_nt_Trk_ndof
	number of ndof
NTuple::Array< float >	m_nt_Trk_chi2Prob
	number of chi2 probability
NTuple::Array< float >	m_nt_Trk_d0_Up
	d0 parameter (Up track)
NTuple::Array< float >	m_nt_Trk_z0_Up
	z0 parameter (Up track)
NTuple::Array< float >	m_nt_Trk_phi0_Up
	phi0 parameter (Up track)
NTuple::Array< float >	m_nt_Trk_theta0_Up
	theta0 parameter (Up track)
NTuple::Array< float >	m_nt_Trk_qoverp_Up
	q/p parameter (Up track)
NTuple::Array< float >	m_nt_Trk_pt_Up
	pt parameter (Up track)
NTuple::Array< long >	m_nt_Trk_nHits_Up
	number of hits (Up track)
NTuple::Array< long >	m_nt_Trk_nhitspix_Up
	number of Pixel hits (Up track)
NTuple::Array< long >	m_nt_Trk_nhitssct_Up
	number of SCT hits (Up track)
NTuple::Array< long >	m_nt_Trk_nhitstrt_Up
	number of TRT hits (Up track)
NTuple::Array< long >	m_nt_Trk_nsharedPixels_Up
	number of Pixel shared hits (Up track)
NTuple::Array< long >	m_nt_Trk_nsharedSCT_Up
	number of SCT shared hits (Up track)
NTuple::Array< long >	m_nt_Trk_nshared_Up
	number of shared hits (Up track)
NTuple::Array< long >	m_nt_Trk_nholesPixels_Up
	number of Pixel holes (Up track)
NTuple::Array< long >	m_nt_Trk_nholesSCT_Up
	number of SCT holes (Up track)
NTuple::Array< long >	m_nt_Trk_nholes_Up
	number of holes (Up track)
NTuple::Array< float >	m_nt_Trk_chi2_Up
	number of chi2 (Up track)
NTuple::Array< long >	m_nt_Trk_ndof_Up
	number of ndof (Up track)
NTuple::Array< float >	m_nt_Trk_chi2Prob_Up
	number of chi2 probability (Up track)
NTuple::Array< float >	m_nt_Trk_d0_Low
	d0 parameter (Low track)
NTuple::Array< float >	m_nt_Trk_z0_Low
	z0 parameter (Low track)
NTuple::Array< float >	m_nt_Trk_phi0_Low
	phi0 parameter (Low track)
NTuple::Array< float >	m_nt_Trk_theta0_Low
	theta0 parameter (Low track)
NTuple::Array< float >	m_nt_Trk_qoverp_Low
	q/p parameter (Low track)
NTuple::Array< float >	m_nt_Trk_pt_Low
	pt parameter (Low track)
NTuple::Array< long >	m_nt_Trk_nHits_Low
	number of hits (Low track)
NTuple::Array< long >	m_nt_Trk_nhitspix_Low
	number of Pixel hits (Low track)
NTuple::Array< long >	m_nt_Trk_nhitssct_Low
	number of SCT hits (Low track)
NTuple::Array< long >	m_nt_Trk_nhitstrt_Low
	number of TRT hits (Low track)
NTuple::Array< long >	m_nt_Trk_nsharedPixels_Low
	number of Pixel shared hits (Low track)
NTuple::Array< long >	m_nt_Trk_nsharedSCT_Low
	number of SCT shared hits (Low track)
NTuple::Array< long >	m_nt_Trk_nshared_Low
	number of shared hits (Low track)
NTuple::Array< long >	m_nt_Trk_nholesPixels_Low
	number of Pixel holes (Low track)
NTuple::Array< long >	m_nt_Trk_nholesSCT_Low
	number of SCT holes (Low track)
NTuple::Array< long >	m_nt_Trk_nholes_Low
	number of holes (Low track)
NTuple::Array< float >	m_nt_Trk_chi2_Low
	number of chi2 (Low track)
NTuple::Array< long >	m_nt_Trk_ndof_Low
	number of ndof (Low track)
NTuple::Array< float >	m_nt_Trk_chi2Prob_Low
	number of chi2 probability (Low track)
NTuple::Array< float >	m_nt_mc_trkistruth
	Has the Track an associated truth track?
NTuple::Array< float >	m_nt_mc_Trk_genParticlePt
	generated pt
NTuple::Array< float >	m_nt_mc_Trk_genParticleEta
	generated eta
NTuple::Array< float >	m_nt_mc_Trk_genParticlePhi
	generated phi
NTuple::Array< float >	m_nt_mc_Trk_d0
	MonteCarlo d0 parameter.
NTuple::Array< float >	m_nt_mc_Trk_z0
	MonteCarlo z0 parameter.
NTuple::Array< float >	m_nt_mc_Trk_phi0
	MonteCarlo phi0 parameter.
NTuple::Array< float >	m_nt_mc_Trk_theta0
	MonteCarlo theta0 parameter.
NTuple::Array< float >	m_nt_mc_Trk_eta
	MonteCarlo eta parameter.
NTuple::Array< float >	m_nt_mc_Trk_qoverp
	MonteCarlo q/p parameter.
NTuple::Array< float >	m_nt_mc_Trk_qoverpt
	MonteCarlo q/pt parameter.
NTuple::Array< float >	m_nt_mc_Trk_pt
	MonteCarlo pt parameter.
NTuple::Array< float >	m_nt_mc_Trk_charge
	MonteCarlo charge parameter.
NTuple::Array< float >	m_nt_mc_Trk_prob
	MonteCarlo prob parameter.
NTuple::Array< float >	m_nt_mc_Trk_pdg
	MonteCarlo pdg parameter.
NTuple::Array< float >	m_nt_mc_Trk_vtxX
	MonteCarlo Vertex.X parameter.
NTuple::Array< float >	m_nt_mc_Trk_vtxY
	MonteCarlo Vertex.Y parameter.
NTuple::Array< float >	m_nt_mc_Trk_vtxZ
	MonteCarlo Vertex.Z parameter.
NTuple::Array< float >	m_nt_Trk_delta_d0
	d0 parameter
NTuple::Array< float >	m_nt_Trk_delta_z0
	z0 parameter
NTuple::Array< float >	m_nt_Trk_delta_phi0
	phi0 parameter
NTuple::Array< float >	m_nt_Trk_delta_theta0
	theta parameter
NTuple::Array< float >	m_nt_Trk_delta_eta
	eta parameter
NTuple::Array< float >	m_nt_Trk_delta_qoverpt
	q/pt parameter
NTuple::Array< float >	m_nt_Trk_delta_pt
	pt parameter
NTuple::Array< float >	m_nt_Trk_delta_charge
	charge parameter

Detailed Description

Definition at line 38 of file InDetAlignFillTrack.h.

Constructor & Destructor Documentation

InDetAlignFillTrack()

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

Definition at line 52 of file InDetAlignFillTrack.cxx.

  : base_class(type, name, parent)
{
}

Member Function Documentation

bookLowNtuple()

void InDetAlignFillTrack::bookLowNtuple ( )

private

Definition at line 638 of file InDetAlignFillTrack.cxx.

                                        {
  ATH_MSG_DEBUG("Booking Low Trk::Track Info...");
 
  std::string nt2id = m_ntupleName + "/TrkTrack_Low";
  std::string comments = "Trk::LowTrack Information";
 
  NTuplePtr nt2(m_ntupleSvc.get(), nt2id);
  if (nt2) {
    ATH_MSG_DEBUG("Ntuple is already booked");
  } else {
    ATH_MSG_DEBUG("Attempting to book general ntuple");
    nt2 = m_ntupleSvc->book(nt2id, CLID_ColumnWiseTuple, comments);
 
    if (nt2) {
      StatusCode sc;
      // sc = nt2->addItem("event", m_nt_event); // event number
      sc = nt2->addItem("nTracks_Low", m_nt_nLowtracks, 0, maxTracks); // number of tracks
 
      // ----------------------------------------------------------------------
      // Trk::Track parameters
      sc = nt2->addItem("Trk_d0_Low", m_nt_nLowtracks, m_nt_Trk_d0_Low);
      sc = nt2->addItem("Trk_z0_Low", m_nt_nLowtracks, m_nt_Trk_z0_Low);
      sc = nt2->addItem("Trk_phi0_Low", m_nt_nLowtracks, m_nt_Trk_phi0_Low);
      sc = nt2->addItem("Trk_theta0_Low", m_nt_nLowtracks, m_nt_Trk_theta0_Low);
      sc = nt2->addItem("Trk_qoverp_Low", m_nt_nLowtracks, m_nt_Trk_qoverp_Low);
      sc = nt2->addItem("Trk_pt_Low", m_nt_nLowtracks, m_nt_Trk_pt_Low);
      // ----------------------------------------------------------------------
 
      // ----------------------------------------------------------------------
      // Trk::Track hits...
      sc = nt2->addItem("Trk_nHits_Low", m_nt_nLowtracks, m_nt_Trk_nHits_Low);
      sc = nt2->addItem("Trk_nhitsPixels_Low", m_nt_nLowtracks, m_nt_Trk_nhitspix_Low);
      sc = nt2->addItem("Trk_nhitsSCT_Low", m_nt_nLowtracks, m_nt_Trk_nhitssct_Low);
      sc = nt2->addItem("Trk_nhitsTRT_Low", m_nt_nLowtracks, m_nt_Trk_nhitstrt_Low);
 
      sc = nt2->addItem("Trk_nsharedPixels_Low", m_nt_nLowtracks, m_nt_Trk_nsharedPixels_Low);
      sc = nt2->addItem("Trk_nsharedSCT_Low", m_nt_nLowtracks, m_nt_Trk_nsharedSCT_Low);
      sc = nt2->addItem("Trk_nshared_Low", m_nt_nLowtracks, m_nt_Trk_nshared_Low);
 
      sc = nt2->addItem("Trk_nholesPixels_Low", m_nt_nLowtracks, m_nt_Trk_nholesPixels_Low);
      sc = nt2->addItem("Trk_nholesSCT_Low", m_nt_nLowtracks, m_nt_Trk_nholesSCT_Low);
      sc = nt2->addItem("Trk_nholes_Low", m_nt_nLowtracks, m_nt_Trk_nholes_Low);
 
      sc = nt2->addItem("Trk_chi2_Low", m_nt_nLowtracks, m_nt_Trk_chi2_Low);
      sc = nt2->addItem("Trk_ndof_Low", m_nt_nLowtracks, m_nt_Trk_ndof_Low);
      sc = nt2->addItem("Trk_chi2Prob_Low", m_nt_nLowtracks, m_nt_Trk_chi2Prob_Low);
      // ----------------------------------------------------------------------
      if (sc.isFailure()) msg(MSG::FATAL) << "Failed ntupleSvc()" << endmsg;
      else msg(MSG::DEBUG) << "Ntuple " << nt2id << " has been booked successfully! " << endmsg;
    } else {
      ATH_MSG_ERROR("Error booking ntuple");
    }
  }
}

bookMatchingNtuple()

void InDetAlignFillTrack::bookMatchingNtuple ( )

private

Definition at line 696 of file InDetAlignFillTrack.cxx.

                                             {
  ATH_MSG_DEBUG("Booking Matching between Up and Low Trk::Track Collections...");
 
  std::string nt3id = m_ntupleName + "/TrkTrack_Matching";
  std::string comments = "Matching between Up and Low Trk::Track Collections";
 
  NTuplePtr nt3(m_ntupleSvc.get(), nt3id);
  if (nt3) {
    ATH_MSG_DEBUG("Ntuple is already booked");
  } else {
    ATH_MSG_DEBUG("Attempting to book general ntuple");
    m_ntupleSvc->book(nt3id, CLID_ColumnWiseTuple, comments);
 
    if (nt3) {
      StatusCode sc;
      // sc = nt3->addItem("event", m_nt_event); // event number
 
      sc = nt3->addItem("nTracks_Match", m_nt_matchingTrk, 0, maxTracks); // number of tracks
 
      // ----------------------------------------------------------------------
      // Matching for the usual Trk::Track parameters
      sc = nt3->addItem("Trk_delta_d0", m_nt_matchingTrk, m_nt_Trk_delta_d0);
      sc = nt3->addItem("Trk_delta_phi0", m_nt_matchingTrk, m_nt_Trk_delta_phi0);
      sc = nt3->addItem("Trk_delta_theta0", m_nt_matchingTrk, m_nt_Trk_delta_theta0);
      sc = nt3->addItem("Trk_delta_eta", m_nt_matchingTrk, m_nt_Trk_delta_eta);
      sc = nt3->addItem("Trk_delta_z0", m_nt_matchingTrk, m_nt_Trk_delta_z0);
      sc = nt3->addItem("Trk_delta_qoverpt", m_nt_matchingTrk, m_nt_Trk_delta_qoverpt);
      sc = nt3->addItem("Trk_delta_pt", m_nt_matchingTrk, m_nt_Trk_delta_pt);
      sc = nt3->addItem("Trk_delta_charge", m_nt_matchingTrk, m_nt_Trk_delta_charge);
      // ----------------------------------------------------------------------
 
      if (sc.isFailure()) msg(MSG::FATAL) << "Failed ntupleSvc()" << endmsg;
      else msg(MSG::DEBUG) << "Ntuple " << nt3id << " has been booked successfully! " << endmsg;
    } else {
      if (msgLvl(MSG::ERROR)) msg(MSG::DEBUG) << "Error booking ntuple" << endmsg;
    }
  }
 
  return;
}

bookNtuple()

void InDetAlignFillTrack::bookNtuple ( )

private

Definition at line 488 of file InDetAlignFillTrack.cxx.

                                     {
  ATH_MSG_DEBUG("Booking Trk::Track Info...");
 
  NTupleFilePtr file1(m_ntupleSvc.get(), m_ntupleName);
  std::string nt0id = m_ntupleName + "/TrkTrack";
  std::string comments = "Trk::Track Information";
 
  NTuplePtr nt0(m_ntupleSvc.get(), nt0id);
  if (nt0) {
    ATH_MSG_DEBUG("Ntuple is already booked");
  } else {
    ATH_MSG_DEBUG("Attempting to book general ntuple");
    nt0 = m_ntupleSvc->book(nt0id, CLID_ColumnWiseTuple, comments);
 
    if (nt0) {
      StatusCode sc;
      // nt0->addItem("event", m_nt_event); // event number
      sc = nt0->addItem("nTracks", m_nt_ntracks, 0, maxTracks); // number of tracks
      if (m_doTruth) sc = nt0->addItem("mc_nTracks", m_nt_nmctracks, 0, maxTracks); // number of mc tracks
 
      // ----------------------------------------------------------------------
      // Trk::Track parameters
      sc = nt0->addItem("Trk_d0", m_nt_ntracks, m_nt_Trk_d0);
      sc = nt0->addItem("Trk_z0", m_nt_ntracks, m_nt_Trk_z0);
      sc = nt0->addItem("Trk_phi0", m_nt_ntracks, m_nt_Trk_phi0);
      sc = nt0->addItem("Trk_theta0", m_nt_ntracks, m_nt_Trk_theta0);
      sc = nt0->addItem("Trk_qoverp", m_nt_ntracks, m_nt_Trk_qoverp);
      sc = nt0->addItem("Trk_pt", m_nt_ntracks, m_nt_Trk_pt);
      // ----------------------------------------------------------------------
 
      // ----------------------------------------------------------------------
      // Trk::Track hits...
      sc = nt0->addItem("Trk_nHits", m_nt_ntracks, m_nt_Trk_nHits);
      sc = nt0->addItem("Trk_nhitsPixels", m_nt_ntracks, m_nt_Trk_nhitspix);
      sc = nt0->addItem("Trk_nhitsSCT", m_nt_ntracks, m_nt_Trk_nhitssct);
      sc = nt0->addItem("Trk_nhitsTRT", m_nt_ntracks, m_nt_Trk_nhitstrt);
 
      sc = nt0->addItem("Trk_nsharedPixels", m_nt_ntracks, m_nt_Trk_nsharedPixels);
      sc = nt0->addItem("Trk_nsharedSCT", m_nt_ntracks, m_nt_Trk_nsharedSCT);
      sc = nt0->addItem("Trk_nshared", m_nt_ntracks, m_nt_Trk_nshared);
 
      sc = nt0->addItem("Trk_nholesPixels", m_nt_ntracks, m_nt_Trk_nholesPixels);
      sc = nt0->addItem("Trk_nholesSCT", m_nt_ntracks, m_nt_Trk_nholesSCT);
      sc = nt0->addItem("Trk_nholes", m_nt_ntracks, m_nt_Trk_nholes);
 
      sc = nt0->addItem("Trk_chi2", m_nt_ntracks, m_nt_Trk_chi2);
      sc = nt0->addItem("Trk_ndof", m_nt_ntracks, m_nt_Trk_ndof);
      sc = nt0->addItem("Trk_chi2Prob", m_nt_ntracks, m_nt_Trk_chi2Prob);
      // ----------------------------------------------------------------------
 
      if (m_doTruth) {
        // ----------------------------------------------------------------------
        sc = nt0->addItem("mc_TrkIsTruth", m_nt_ntracks, m_nt_mc_trkistruth);
 
        // generated particle parameters
        sc = nt0->addItem("mc_Trk_genParticlePt", m_nt_ntracks, m_nt_mc_Trk_genParticlePt);
        sc = nt0->addItem("mc_Trk_genParticleEta", m_nt_ntracks, m_nt_mc_Trk_genParticleEta);
        sc = nt0->addItem("mc_Trk_genParticlePhi", m_nt_ntracks, m_nt_mc_Trk_genParticlePhi);
 
        // MonteCarlo Track parameters
        sc = nt0->addItem("mc_Trk_d0", m_nt_ntracks, m_nt_mc_Trk_d0);
        sc = nt0->addItem("mc_Trk_z0", m_nt_ntracks, m_nt_mc_Trk_z0);
        sc = nt0->addItem("mc_Trk_phi0", m_nt_ntracks, m_nt_mc_Trk_phi0);
        sc = nt0->addItem("mc_Trk_theta", m_nt_ntracks, m_nt_mc_Trk_theta0);
        sc = nt0->addItem("mc_Trk_eta", m_nt_ntracks, m_nt_mc_Trk_eta);
        sc = nt0->addItem("mc_Trk_qoverp", m_nt_ntracks, m_nt_mc_Trk_qoverp);
        sc = nt0->addItem("mc_Trk_qoverpt", m_nt_ntracks, m_nt_mc_Trk_qoverpt);
        sc = nt0->addItem("mc_Trk_pt", m_nt_ntracks, m_nt_mc_Trk_pt);
        sc = nt0->addItem("mc_Trk_charge", m_nt_ntracks, m_nt_mc_Trk_charge);
        sc = nt0->addItem("mc_Trk_prob", m_nt_ntracks, m_nt_mc_Trk_prob);
        sc = nt0->addItem("mc_Trk_pdg", m_nt_ntracks, m_nt_mc_Trk_pdg);
 
        sc = nt0->addItem("mc_Trk_vtxX", m_nt_ntracks, m_nt_mc_Trk_vtxX);
        sc = nt0->addItem("mc_Trk_vtxY", m_nt_ntracks, m_nt_mc_Trk_vtxY);
        sc = nt0->addItem("mc_Trk_vtxZ", m_nt_ntracks, m_nt_mc_Trk_vtxZ);
        // ----------------------------------------------------------------------
      }
 
      if (sc.isFailure()) ATH_MSG_FATAL("Failed ntupleSvc()");
      else ATH_MSG_DEBUG("Ntuple " << nt0id << " has been booked successfully! ");
    } else {
      ATH_MSG_ERROR("Error booking ntuple");
    }
  }
 
  // return;
}

bookUpNtuple()

void InDetAlignFillTrack::bookUpNtuple ( )

private

Definition at line 579 of file InDetAlignFillTrack.cxx.

                                       {
  ATH_MSG_DEBUG("Booking Up Trk::Track Info...");
 
  std::string nt1id = m_ntupleName + "/TrkTrack_Up";
  std::string comments = "Trk::UpTrack Information";
 
  NTuplePtr nt1(m_ntupleSvc.get(), nt1id);
  if (nt1) {
    ATH_MSG_DEBUG("Ntuple is already booked");
  } else {
    ATH_MSG_DEBUG("Attempting to book general ntuple");
    nt1 = m_ntupleSvc->book(nt1id, CLID_ColumnWiseTuple, comments);
 
    if (nt1) {
      StatusCode sc;
      // nt1->addItem("event", m_nt_event); // event number
      sc = nt1->addItem("nTracks_Up", m_nt_nUptracks, 0, maxTracks); // number of tracks
 
      // ----------------------------------------------------------------------
      // Trk::Track parameters
      sc = nt1->addItem("Trk_d0_Up", m_nt_nUptracks, m_nt_Trk_d0_Up);
      sc = nt1->addItem("Trk_z0_Up", m_nt_nUptracks, m_nt_Trk_z0_Up);
      sc = nt1->addItem("Trk_phi0_Up", m_nt_nUptracks, m_nt_Trk_phi0_Up);
      sc = nt1->addItem("Trk_theta0_Up", m_nt_nUptracks, m_nt_Trk_theta0_Up);
      sc = nt1->addItem("Trk_qoverp_Up", m_nt_nUptracks, m_nt_Trk_qoverp_Up);
      sc = nt1->addItem("Trk_pt_Up", m_nt_nUptracks, m_nt_Trk_pt_Up);
      // ----------------------------------------------------------------------
 
      // ----------------------------------------------------------------------
      // Trk::Track hits...
      sc = nt1->addItem("Trk_nHits_Up", m_nt_nUptracks, m_nt_Trk_nHits_Up);
      sc = nt1->addItem("Trk_nhitsPixels_Up", m_nt_nUptracks, m_nt_Trk_nhitspix_Up);
      sc = nt1->addItem("Trk_nhitsSCT_Up", m_nt_nUptracks, m_nt_Trk_nhitssct_Up);
      sc = nt1->addItem("Trk_nhitsTRT_Up", m_nt_nUptracks, m_nt_Trk_nhitstrt_Up);
 
      sc = nt1->addItem("Trk_nsharedPixels_Up", m_nt_nUptracks, m_nt_Trk_nsharedPixels_Up);
      sc = nt1->addItem("Trk_nsharedSCT_Up", m_nt_nUptracks, m_nt_Trk_nsharedSCT_Up);
      sc = nt1->addItem("Trk_nshared_Up", m_nt_nUptracks, m_nt_Trk_nshared_Up);
 
      sc = nt1->addItem("Trk_nholesPixels_Up", m_nt_nUptracks, m_nt_Trk_nholesPixels_Up);
      sc = nt1->addItem("Trk_nholesSCT_Up", m_nt_nUptracks, m_nt_Trk_nholesSCT_Up);
      sc = nt1->addItem("Trk_nholes_Up", m_nt_nUptracks, m_nt_Trk_nholes_Up);
 
      sc = nt1->addItem("Trk_chi2_Up", m_nt_nUptracks, m_nt_Trk_chi2_Up);
      sc = nt1->addItem("Trk_ndof_Up", m_nt_nUptracks, m_nt_Trk_ndof_Up);
      sc = nt1->addItem("Trk_chi2Prob_Up", m_nt_nUptracks, m_nt_Trk_chi2Prob_Up);
      // ----------------------------------------------------------------------
 
      if (sc.isFailure()) ATH_MSG_FATAL("Failed ntupleSvc()");
      else ATH_MSG_DEBUG("Ntuple " << nt1id << " has been booked successfully! ");
    } else {
      ATH_MSG_ERROR("Error booking ntuple");
    }
  }
}

dumpMatching()

StatusCode InDetAlignFillTrack::dumpMatching ( const TrackCollection * tracksUpper, const TrackCollection * tracksLower )

private

Definition at line 1029 of file InDetAlignFillTrack.cxx.

                                                                                 {
  ATH_MSG_DEBUG("In dumpMatching()");
 
  int nTracksUpper = 0;
 
  // looping over the upper barrel tracks
  TrackCollection::const_iterator trackItrUpper = tracksUpper->begin();
  TrackCollection::const_iterator trackItrUpperE = tracksUpper->end();
  for (; trackItrUpper != trackItrUpperE; ++trackItrUpper) {
    const Trk::Track* trackUpper = *trackItrUpper;
    if (trackUpper == nullptr) {
      ATH_MSG_DEBUG("No associated Trk::Track object found for track " << nTracksUpper);
      continue;
    }
 
    const Trk::Perigee* measUpperPer = trackUpper->perigeeParameters();
 
    // Get the track parameters from the Upper Track
    float d0Up = measUpperPer->parameters()[Trk::d0];
    float phi0Up = measUpperPer->parameters()[Trk::phi0];
    float eta0Up = measUpperPer->eta();
    float z0Up = measUpperPer->parameters()[Trk::z0];
    float thetaUp = measUpperPer->parameters()[Trk::theta];
    float qOverPtUp = measUpperPer->parameters()[Trk::qOverP] * 1000 / std::sin(thetaUp);
    float chargeUp = measUpperPer->charge();
    float ptUp = measUpperPer->pT() / 1000.;
 
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG) << nTracksUpper << ". UpTrack -> Track Parameters:" << endmsg;
      msg(MSG::DEBUG) << "     d0, z0, phi0, theta, q/p" << d0Up << ", " << z0Up << ", "
                      << phi0Up << ", " << thetaUp << ", " << qOverPtUp << endmsg;
    }
 
    int nTracksLower = 0;
 
    bool matchFound = false;
    float Matched_Low_d0 = -999;
    float Matched_Low_phi0 = -999;
    //**
    float Matched_Low_theta = -999;
    float Matched_Low_eta0 = -999;
    float Matched_Low_z0 = -999;
    float Matched_Low_qOverPt = -999;
    float Matched_Low_charge = -999;
    float Matched_Low_pt = -999;
 
    // looping over the lower barrel tracks
    DataVector<Trk::Track>::const_iterator trackItrLower = tracksLower->begin();
    DataVector<Trk::Track>::const_iterator trackItrLowerE = tracksLower->end();
    for (; trackItrLower != trackItrLowerE; ++trackItrLower) { //looping over Lower tracks
      const Trk::Track* trackLower = *trackItrLower;
      if (trackLower == nullptr) {
        ATH_MSG_DEBUG("No associated Trk::Track object found for track " << nTracksLower);
        continue;
      }
 
      const Trk::Perigee* measLowerPer = trackLower->perigeeParameters();
 
      float d0Low = measLowerPer->parameters()[Trk::d0];
      float phi0Low = measLowerPer->parameters()[Trk::phi0];
      float eta0Low = measLowerPer->eta();
      float z0Low = measLowerPer->parameters()[Trk::z0];
      float thetaLow = measLowerPer->parameters()[Trk::theta];
      float qOverPtLow = measLowerPer->parameters()[Trk::qOverP] * 1000 / std::sin(thetaLow);
      float chargeLow = measLowerPer->charge();
      float ptLow = measLowerPer->pT() / 1000.;
 
      //selecting Lower track that is closest to Upper in eta-phi
      float dphi2 = (phi0Up - phi0Low) * (phi0Up - phi0Low);
 
      //For TRT only tracks we will ignore the delta eta
      // and just require a delta phi match
      float deta2 = (eta0Up - eta0Low) * (eta0Up - eta0Low);
 
      // look for a matching track within a cone
      float dR = std::sqrt(dphi2 + deta2);
      ATH_MSG_DEBUG("dR (sqrt(dphi+deta2): " << dR);
      ATH_MSG_DEBUG("minmdR (sqrt(dphi+deta2): " << m_mindR);
      if (dR < m_mindR) {
        //  m_mindR = dR;
        Matched_Low_d0 = d0Low;
        Matched_Low_phi0 = phi0Low;
        //**
        Matched_Low_theta = thetaLow;
        Matched_Low_eta0 = eta0Low;
        Matched_Low_z0 = z0Low;
        Matched_Low_qOverPt = qOverPtLow;
        Matched_Low_charge = chargeLow;
        Matched_Low_pt = ptLow;
 
        if (dR < m_matchedRcut) {
          if (msgLvl(MSG::DEBUG)) {
            msg(MSG::DEBUG) << nTracksLower << ". LowTrack -> Track Parameters:" << endmsg;
            msg(MSG::DEBUG) << "     d0, z0, phi0, theta, q/p: " << d0Low << ", " << z0Low << ", "
                            << phi0Low << ", " << thetaLow << ", " << qOverPtLow << endmsg;
          }
 
          matchFound = true;
        }
      } else {
        ATH_MSG_DEBUG("No matching low track found!!");
      }
      nTracksLower++;
    } //looping over lower tracks
 
    if (matchFound) {
      ATH_MSG_DEBUG("Match found!");
      m_nt_matchingTrk = 1;
      m_nt_Trk_delta_d0[nTracksUpper] = d0Up - Matched_Low_d0;
      m_nt_Trk_delta_phi0[nTracksUpper] = phi0Up - Matched_Low_phi0;
      //**
      m_nt_Trk_delta_theta0[nTracksUpper] = thetaUp - Matched_Low_theta;
      m_nt_Trk_delta_eta[nTracksUpper] = eta0Up - Matched_Low_eta0;
      m_nt_Trk_delta_z0[nTracksUpper] = z0Up - Matched_Low_z0;
      m_nt_Trk_delta_qoverpt[nTracksUpper] = qOverPtUp - Matched_Low_qOverPt;
      m_nt_Trk_delta_pt[nTracksUpper] = ptUp - Matched_Low_pt;
      m_nt_Trk_delta_charge[nTracksUpper] = chargeUp - Matched_Low_charge;
    } // end match found
 
 
    nTracksUpper++;
  } //looping over upper tracks
 
  return StatusCode::SUCCESS;
}

dumpPerigee()

void InDetAlignFillTrack::dumpPerigee ( const Trk::TrackParameters * generatedTrackPerigee, int index )

private

Definition at line 988 of file InDetAlignFillTrack.cxx.

                                                 {
  ATH_MSG_VERBOSE( "In dumpPerigee()" );
 
  float d0 = generatedTrackPerigee->parameters()[Trk::d0];
  float z0 = generatedTrackPerigee->parameters()[Trk::z0];
  float phi0 = generatedTrackPerigee->parameters()[Trk::phi0];
  float theta = generatedTrackPerigee->parameters()[Trk::theta];
  float eta = generatedTrackPerigee->eta();
  float charge = generatedTrackPerigee->charge();
  float qoverp = generatedTrackPerigee->parameters()[Trk::qOverP];
  float qoverpt = generatedTrackPerigee->parameters()[Trk::qOverP] / (std::sin(theta));
  float pt = (1 / qoverpt) * (charge);
  // int pdg = genParticle->pdg_id();
 
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << " - Extrapolated genParticle perigee parameters "
                    << "(d0, z0, phi0, theta, q/p)" << endmsg;
    msg(MSG::DEBUG) << " " << d0 << ", " << z0 << ", "
                    << phi0 << ", " << theta << ", " << qoverp << endmsg;
 
    msg(MSG::DEBUG) << "  p = " << std::abs(1.0 / qoverp) / CLHEP::GeV << " CLHEP::GeV/c, "
                    << " pT = " << pt / CLHEP::GeV << " CLHEP::GeV/c" << endmsg;
  }
 
  m_nt_mc_Trk_d0[index] = d0;
  m_nt_mc_Trk_z0[index] = z0;
  m_nt_mc_Trk_phi0[index] = phi0;
  m_nt_mc_Trk_theta0[index] = theta;
  m_nt_mc_Trk_eta[index] = eta;
  m_nt_mc_Trk_qoverp[index] = qoverp;
  m_nt_mc_Trk_qoverpt[index] = qoverpt;
  m_nt_mc_Trk_pt[index] = pt;
  m_nt_mc_Trk_charge[index] = charge;
 
  return;
}

dumpTrack()

void InDetAlignFillTrack::dumpTrack ( int itrk, const Trk::Track * trk, const std::string & TrkColName )

private

Definition at line 769 of file InDetAlignFillTrack.cxx.

                                                                 {
  ATH_MSG_VERBOSE("In dump" << TrkColName << "Track()");
 
  const Trk::Perigee* aMeasPer = trk->perigeeParameters();
 
  if (aMeasPer == nullptr) {
    ATH_MSG_ERROR("Could not get Trk::MeasuredPerigee");
  } else {
    double d0 = aMeasPer->parameters()[Trk::d0];
    double z0 = aMeasPer->parameters()[Trk::z0];
    double phi0 = aMeasPer->parameters()[Trk::phi0];
    double theta = aMeasPer->parameters()[Trk::theta];
    double qOverP = aMeasPer->parameters()[Trk::qOverP];
 
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG) << itrk << ". " << TrkColName
                      << " Track Parameters (d0, z0, phi0, theta, q/p)" << endmsg;
      msg(MSG::DEBUG) << " " << d0 << ", " << z0 << ", "
                      << phi0 << ", " << theta << ", " << qOverP << endmsg;
    }
 
    float transverseMomentum = std::sqrt((aMeasPer->momentum().x()) * (aMeasPer->momentum().x())
                                    + (aMeasPer->momentum().y()) * (aMeasPer->momentum().y()));
 
    ATH_MSG_DEBUG("  p = " << aMeasPer->momentum().mag() / CLHEP::GeV << " CLHEP::GeV/c, "
                           << " pT = " << transverseMomentum / CLHEP::GeV << " CLHEP::GeV/c");
 
    // number of hits
    int nHits = (*trk).measurementsOnTrack()->size();
    ATH_MSG_DEBUG(" - number of hits : " << nHits);
    if (nHits != 0) {
      if (TrkColName == "Up") m_totalUphits += nHits;
      else if (TrkColName == "Low") m_totalLowhits += nHits;
      else m_totalhits += nHits;
    }
 
    // number of hits, shared hits and holes
    int nhitspix = 0, nhitssct = 0, nhitstrt = 0;
    int nshared = 0, nshpix = 0, nshsct = 0;
    int nholes = 0, nhpix = 0, nhsct = 0;
 
    xAOD::TrackParticle* trackPart = m_particleCreator->createParticle(*trk);
    uint8_t iSummaryValue(0); // Dummy counter to retrieve summary values
 
    if (not trackPart) ATH_MSG_ERROR("Could not get xAOD::TrackParticle");
 
    else {
      // hits
      nhitspix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHits) ? iSummaryValue : 0;
      nhitssct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHits) ? iSummaryValue : 0;
      nhitstrt = trackPart->summaryValue(iSummaryValue, xAOD::numberOfTRTHits) ? iSummaryValue : 0;
 
      if (msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << "   -- number of Pixel hits : " << nhitspix << endmsg;
        msg(MSG::DEBUG) << "   -- number of SCT hits : " << nhitssct << endmsg;
        msg(MSG::DEBUG) << "   -- number of TRT hits : " << nhitstrt << endmsg;
      }
 
      if (nhitspix != 0) {
        if (TrkColName == "Up") m_totalUpPixhits += nhitspix;
        else if (TrkColName == "Low") m_totalLowPixhits += nhitspix;
        else m_totalPixhits += nhitspix;
      }
      if (nhitssct != 0) {
        if (TrkColName == "Up") m_totalUpSCThits += nhitssct;
        else if (TrkColName == "Low") m_totalLowSCThits += nhitssct;
        else m_totalSCThits += nhitssct;
      }
      if (nhitstrt != 0) {
        if (TrkColName == "Up") m_totalUpTRThits += nhitstrt;
        else if (TrkColName == "Low") m_totalLowTRThits += nhitstrt;
        else m_totalTRThits += nhitstrt;
      }
 
      // shared hits
      nshpix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelSharedHits) ? iSummaryValue : 0;
      nshsct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTSharedHits) ? iSummaryValue : 0;
      nshared = nshpix + nshsct;
 
      if (nshpix < 0) nshpix = 0;
      if (nshsct < 0) nshsct = 0;
      if (nshared < 0) nshared = 0;
 
      if (msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << " - number of shared hits : " << nshared << endmsg;
        msg(MSG::DEBUG) << "  -- number of Pixel shared hits : " << nshpix << endmsg;
        msg(MSG::DEBUG) << "  -- number of SCT shared hits : " << nshsct << endmsg;
      }
 
      // holes
      nhpix = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHoles) ? iSummaryValue : 0;
      nhsct = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHoles) ? iSummaryValue : 0;
      nholes = nhpix + nhsct;
 
      if (nhpix < 0) nhpix = 0;
      if (nhsct < 0) nhsct = 0;
      if (nholes < 0) nholes = 0;
 
      if (msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << " - number of Pixel holes : " << nhpix << endmsg;
        msg(MSG::DEBUG) << "  -- number of SCT holes : " << nhsct << endmsg;
        msg(MSG::DEBUG) << "  -- number of holes : " << nholes << endmsg;
      }
    }
 
    // get fit quality and chi2 probability of track
    // chi2Prob = TMath::Prob(chi2,DoF) ROOT function
    double chi2Prob = 0.;
    const Trk::FitQuality* fitQual = (*trk).fitQuality();
    if (fitQual == nullptr) {
      ATH_MSG_ERROR("No fit quality assigned to the track");
      chi2Prob = -1e12; // return big value
    } else {
      if (fitQual->chiSquared() > 0. && fitQual->numberDoF() > 0) {
        Genfun::CumulativeChiSquare probabilityFunction(fitQual->numberDoF());
        chi2Prob = 1 - probabilityFunction(fitQual->chiSquared());
 
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << "  - chi2             : " << fitQual->chiSquared() << endmsg;
          msg(MSG::DEBUG) << "  - ndof             : " << fitQual->numberDoF() << endmsg;
          msg(MSG::DEBUG) << "  - chi2 propability : " << chi2Prob << endmsg;
        }
      }
    }
    // Fill ntuple
    if (TrkColName == "Up") {
      m_nt_Trk_d0_Up[itrk] = d0;
      m_nt_Trk_z0_Up[itrk] = z0;
      m_nt_Trk_phi0_Up[itrk] = phi0;
      m_nt_Trk_theta0_Up[itrk] = theta;
      m_nt_Trk_qoverp_Up[itrk] = qOverP;
      m_nt_Trk_pt_Up[itrk] = transverseMomentum;
 
      m_nt_Trk_nHits_Up[itrk] = nHits;
      m_nt_Trk_nhitspix_Up[itrk] = nhitspix;
      m_nt_Trk_nhitssct_Up[itrk] = nhitssct;
      m_nt_Trk_nhitstrt_Up[itrk] = nhitstrt;
 
      m_nt_Trk_nsharedPixels_Up[itrk] = nshpix;
      m_nt_Trk_nsharedSCT_Up[itrk] = nshsct;
      m_nt_Trk_nshared_Up[itrk] = nshared;
 
      m_nt_Trk_nholesPixels_Up[itrk] = nhpix;
      m_nt_Trk_nholesSCT_Up[itrk] = nhsct;
      m_nt_Trk_nholes_Up[itrk] = nholes;
      if (fitQual) {
        m_nt_Trk_chi2_Up[itrk] = fitQual->chiSquared();
        m_nt_Trk_ndof_Up[itrk] = fitQual->numberDoF();
      } else {
        m_nt_Trk_chi2_Up[itrk] = 0;
        m_nt_Trk_ndof_Up[itrk] = 0;
      }
      m_nt_Trk_chi2Prob_Up[itrk] = chi2Prob;
    } else if (TrkColName == "Low") {
      m_nt_Trk_d0_Low[itrk] = d0;
      m_nt_Trk_z0_Low[itrk] = z0;
      m_nt_Trk_phi0_Low[itrk] = phi0;
      m_nt_Trk_theta0_Low[itrk] = theta;
      m_nt_Trk_qoverp_Low[itrk] = qOverP;
      m_nt_Trk_pt_Low[itrk] = transverseMomentum;
 
      m_nt_Trk_nHits_Low[itrk] = nHits;
      m_nt_Trk_nhitspix_Low[itrk] = nhitspix;
      m_nt_Trk_nhitssct_Low[itrk] = nhitssct;
      m_nt_Trk_nhitstrt_Low[itrk] = nhitstrt;
 
      m_nt_Trk_nsharedPixels_Low[itrk] = nshpix;
      m_nt_Trk_nsharedSCT_Low[itrk] = nshsct;
      m_nt_Trk_nshared_Low[itrk] = nshared;
 
      m_nt_Trk_nholesPixels_Low[itrk] = nhpix;
      m_nt_Trk_nholesSCT_Low[itrk] = nhsct;
      m_nt_Trk_nholes_Low[itrk] = nholes;
      if (fitQual) {
        m_nt_Trk_chi2_Low[itrk] = fitQual->chiSquared();
        m_nt_Trk_ndof_Low[itrk] = fitQual->numberDoF();
      } else {
        m_nt_Trk_chi2_Low[itrk] = 0;
        m_nt_Trk_ndof_Low[itrk] = 0;
      }
      m_nt_Trk_chi2Prob_Low[itrk] = chi2Prob;
    } else {
      m_nt_Trk_d0[itrk] = d0;
      m_nt_Trk_z0[itrk] = z0;
      m_nt_Trk_phi0[itrk] = phi0;
      m_nt_Trk_theta0[itrk] = theta;
      m_nt_Trk_qoverp[itrk] = qOverP;
      m_nt_Trk_pt[itrk] = transverseMomentum;
 
      m_nt_Trk_nHits[itrk] = nHits;
      m_nt_Trk_nhitspix[itrk] = nhitspix;
      m_nt_Trk_nhitssct[itrk] = nhitssct;
      m_nt_Trk_nhitstrt[itrk] = nhitstrt;
 
      m_nt_Trk_nsharedPixels[itrk] = nshpix;
      m_nt_Trk_nsharedSCT[itrk] = nshsct;
      m_nt_Trk_nshared[itrk] = nshared;
 
      m_nt_Trk_nholesPixels[itrk] = nhpix;
      m_nt_Trk_nholesSCT[itrk] = nhsct;
      m_nt_Trk_nholes[itrk] = nholes;
      if (fitQual) {
        m_nt_Trk_chi2[itrk] = fitQual->chiSquared();
        m_nt_Trk_ndof[itrk] = fitQual->numberDoF();
      } else {
        m_nt_Trk_chi2[itrk] = 0;
        m_nt_Trk_ndof[itrk] = 0;
      }
      m_nt_Trk_chi2Prob[itrk] = chi2Prob;
    }
  }
 
  return;
}

dumpTrackCol() [1/2]

int InDetAlignFillTrack::dumpTrackCol ( const TrackCollection * tracks )

private

Definition at line 740 of file InDetAlignFillTrack.cxx.

                                                                   {
  return dumpTrackCol(tracks, "");
}

dumpTrackCol() [2/2]

int InDetAlignFillTrack::dumpTrackCol ( const TrackCollection * tracks, const std::string & TrkColName )

private

Definition at line 747 of file InDetAlignFillTrack.cxx.

                                                                   {
  ATH_MSG_DEBUG("In dump" << TrkColName << "TrackCol()");
 
  int itrk = 0;
 
  TrackCollection::const_iterator trackItr = tracks->begin();
  TrackCollection::const_iterator trackItrE = tracks->end();
 
  //looping over tracks
  for (; trackItr != trackItrE && itrk < maxTracks; ++trackItr) {
    if (*trackItr != nullptr) dumpTrack(itrk, (*trackItr), TrkColName);
 
    itrk++;
  }
 
  return itrk;
}

FillTrack()

StatusCode InDetAlignFillTrack::FillTrack ( )

overridevirtual

Definition at line 131 of file InDetAlignFillTrack.cxx.

                                          {
  ATH_MSG_DEBUG("In FillTrack()");
  ATH_MSG_DEBUG(" event " << m_events);
  StatusCode sc;
  
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TrackCollection* tracks;// = new TrackCollection;
  const TrackCollection* Uptracks;// = new TrackCollection;
  const TrackCollection* Lowtracks;// = new TrackCollection;
 
  // retrieve all tracks from TDS
  ATH_CHECK(evtStore()->retrieve(tracks, m_inputCol));
 
  // retrieve all Up tracks from TDS
  if (m_inputUpCol != "") {
    ATH_CHECK(evtStore()->retrieve(Uptracks, m_inputUpCol));
  }
 
  // retrieve all Low tracks from TDS
  if (m_inputLowCol != "") {
    ATH_CHECK(evtStore()->retrieve(Lowtracks, m_inputLowCol));
  }
 
  m_nt_ntracks = tracks->size();
  ATH_MSG_DEBUG("Retrieved Track Collection size: " << tracks->size());
 
  if (m_inputUpCol != "") {
    m_nt_nUptracks = Uptracks->size();
    ATH_MSG_DEBUG("Retrieved Up Track Collection size: " << Uptracks->size());
  }
 
  if (m_inputLowCol != "") {
    m_nt_nLowtracks = Lowtracks->size();
    ATH_MSG_DEBUG("Retrieved Low Track Collection size: " << Lowtracks->size());
  }
 
  ATH_MSG_DEBUG("Printing input track collection");
  m_totaltrks += dumpTrackCol(tracks);
  if (m_inputUpCol != "") m_totalUptrks += dumpTrackCol(Uptracks, "Up");
  if (m_inputLowCol != "") m_totalLowtrks += dumpTrackCol(Lowtracks, "Low");
 
  // matching
  if (m_doMatching && m_inputUpCol != "" && m_inputLowCol != "")
    if (StatusCode::SUCCESS != dumpMatching(Uptracks, Lowtracks)) {
      ATH_MSG_ERROR("dumpMatching failure");
      return StatusCode::FAILURE;
    }
 
 
  // if truth is available...
  if (m_doTruth) {
    int nTracks = 0;
 
    const TrackTruthCollection* truthCol = nullptr;
 
    // retrieve all track truth collection from TDS
    if (StatusCode::SUCCESS != evtStore()->retrieve(truthCol, m_TruthTrkCol)) {
      ATH_MSG_ERROR("Cannot find " << m_inputCol);
      return StatusCode::FAILURE;
    } else {
      if (!truthCol) {
        ATH_MSG_ERROR( "Failure retrieving " << m_TruthTrkCol );
        return StatusCode::FAILURE;
      }
 
      if (msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << "Collection with name " << m_TruthTrkCol << " found in StoreGate" << endmsg;
        msg(MSG::DEBUG) << "Retrieved " << truthCol->size() << " truth tracks from StoreGate" << endmsg;
      }
 
      m_nt_nmctracks = truthCol->size();
 
      TrackCollection::const_iterator trackItr = tracks->begin();
      TrackCollection::const_iterator trackItrE = tracks->end();
 
      //looping over tracks
      for (; trackItr != trackItrE && nTracks < maxTracks; ++trackItr) {
        const Trk::Track* track = *trackItr;
        if (track == nullptr) {
          ATH_MSG_WARNING("No associated Trk::Track object found for track "
                          << nTracks);
          continue;
        }
        //Coverity fix: 14309: useless check. Commented out
        //if (truthCol) {
 
        // the key for the truth std::map is an ElementLink<TrackCollection> object
        // comprises a pointer to the track and reconstructed track collection
        ElementLink<TrackCollection> trackLink;
        trackLink.setElement(const_cast<Trk::Track*>(track));
        trackLink.setStorableObject(*tracks);
        const ElementLink<TrackCollection> trackLink2 = trackLink;
 
        // trying to find the std::map entry for this reconstructed track
        TrackTruthCollection::const_iterator found = truthCol->find(trackLink2);
 
        if (found != truthCol->end()) {
          // getting the TrackTruth object - the map element
          TrackTruth trkTruth = found->second;
          ATH_MSG_DEBUG("got trkTruth");
 
          // probability of the reco<->truth match
          float trkTruthProb = trkTruth.probability();
 
          const HepMcParticleLink& HMPL = trkTruth.particleLink();
 
          if (HMPL.isValid()) {
#ifdef HEPMC3
            HepMC::ConstGenParticlePtr genParticle = HMPL.scptr();
#else
            const HepMC::GenParticle* genParticle = HMPL.cptr();
#endif
 
            double charge = 1.0;
            if (genParticle->pdg_id() < 0) charge = -charge;
 
            Amg::Vector3D productionVertex(genParticle->production_vertex()->position().x(),
                                           genParticle->production_vertex()->position().y(),
                                           genParticle->production_vertex()->position().z());
 
            if (msgLvl(MSG::DEBUG)) {
              msg(MSG::DEBUG) << nTracks << ". Generated Particle " <<  genParticle << endmsg;
            }
 
            float genPt = std::sqrt((genParticle->momentum().x()) * (genParticle->momentum().x())
                               + (genParticle->momentum().y()) * (genParticle->momentum().y()));
 
            ATH_MSG_DEBUG("   * pt " << genPt / CLHEP::GeV << " CLHEP::GeV/c"
                                     << ", p " << genParticle->momentum().e() / CLHEP::GeV << " CLHEP::GeV/c"
                                     << ", eta " << genParticle->momentum().eta()
                                     << ", phi " << genParticle->momentum().phi() << " CLHEP::rad");
 
            m_nt_mc_trkistruth[nTracks] = 1;
            m_nt_mc_Trk_pdg[nTracks] = genParticle->pdg_id();
            m_nt_mc_Trk_prob[nTracks] = trkTruthProb;
            float pX = genParticle->momentum().px();
            float pY = genParticle->momentum().py();
            float genParticlePt = std::sqrt((pX * pX) + (pY * pY));
            m_nt_mc_Trk_genParticlePt[nTracks] = genParticlePt;
            m_nt_mc_Trk_genParticleEta[nTracks] = genParticle->momentum().eta();
            m_nt_mc_Trk_genParticlePhi[nTracks] = genParticle->momentum().phi();
 
            if (genParticle->pdg_id() == 0) ATH_MSG_WARNING("Particle with PDG 0!");
            else if (!genParticle->production_vertex()) ATH_MSG_WARNING(
                "No GenVertex (generator level) production vertex found!");
            else {
              // currently cannot configure the TruthToTrack tool properly
 
              const Trk::TrackParameters* generatedTrackPerigee = nullptr;
 
              //using a tool to produce perigee track parameters from generated parameters
              generatedTrackPerigee = m_truthToTrack->makePerigeeParameters(genParticle);
 
              if (!generatedTrackPerigee) {
                if (msgLvl(MSG::DEBUG)) {
                  msg(MSG::DEBUG) << "Unable to extrapolate genParticle to perigee!" << endmsg;
                  msg(MSG::DEBUG) << "Trying to extrapolate directly to exclude material effects!" << endmsg;
                }
 
                const TrackRecordCollection* recordCollection = nullptr;
 
                sc = evtStore()->retrieve(recordCollection, "CaloEntryLayer");
                if (sc == StatusCode::FAILURE) {
                  ATH_MSG_ERROR("Could not get track record!");
                  return sc;
                }
                ATH_MSG_DEBUG("reading from track record, size = "
                              << recordCollection->size());
 
                int nmctracks = 0;
 
                for (TrackRecordCollection::const_iterator record = recordCollection->begin();
                     record != recordCollection->end(); ++record) {
                  if (std::abs((*record).GetPDGCode()) != 13) continue;
                  HepGeom::Point3D<double> productionVertex = (*record).GetPosition();
                  double charge = (*record).GetPDGCode() > 0 ? -1.0 : 1.0;
                  
 
                  Amg::Vector3D direction((*record).GetMomentum().x(),
                                          (*record).GetMomentum().y(),
                                          (*record).GetMomentum().z());
 
                  double momentum = direction.mag();
                  if (momentum < 500) continue;
                  double genPar_qOverP = 1. / direction.mag();
                  direction *= genPar_qOverP;
                  if (charge < 0) genPar_qOverP = -genPar_qOverP;
 
 
                  double genPar_phi = direction.phi();
                  if (genPar_phi < 0.) genPar_phi = genPar_phi + 2.0*M_PI;
 
                  ATH_MSG_DEBUG("Production vertex (x,y,z): ("
                                << productionVertex.x() << ", "
                                << productionVertex.y() << ", "
                                << productionVertex.z() << ")");
 
                  double genPar_theta = direction.theta();
 
                  // Create a planar surface and transform the vertex information to a TrackParameters object
                  Amg::Transform3D globalSurfaceCentre;
                  globalSurfaceCentre.setIdentity();
                  globalSurfaceCentre *= Amg::Translation3D(productionVertex.x(),
                                                             productionVertex.y(), productionVertex.z());
 
                  Trk::PlaneSurface planeSurface(globalSurfaceCentre, 5., 5.);
 
                  const Amg::Vector3D productionVertexAsGlobalPosition(productionVertex.x(),
                                                                       productionVertex.y(),
                                                                       productionVertex.z());
 
                  const Trk::AtaPlane* productionVertexTrackParams
                    = new Trk::AtaPlane(productionVertexAsGlobalPosition,
                                        genPar_phi, genPar_theta, genPar_qOverP,
                                        planeSurface);
 
                  // Create a new perigee surface
                  Trk::PerigeeSurface perigeeSurface;
 
                  if (!tracks->empty()) perigeeSurface = ((**tracks->begin()).perigeeParameters()->associatedSurface());
 
 
                  const Amg::Vector3D& perigeeGlobalPosition = perigeeSurface.center();
 
                  ATH_MSG_DEBUG("Surface global centre (x,y,z): ("
                                << perigeeGlobalPosition.x() << ", "
                                << perigeeGlobalPosition.y() << ", "
                                << perigeeGlobalPosition.z() << ")");
 
                  // Extrapolate the TrackParameters object to the perigee
 
                  // ( Establish the distance between perigee and generated vertex.
                  // If less than tolerance don't bother with the propagation )
                  const Amg::Vector3D difference = productionVertexAsGlobalPosition - perigeeGlobalPosition;
 
                  double distance = std::sqrt(difference.x() * difference.x() + difference.y() * difference.y());
                  ATH_MSG_DEBUG("Distance between perigee point and generated vertex: "
                                << distance / CLHEP::m << " m");
 
                  const Trk::TrackParameters* generatedTrackPerigee = nullptr;
 
                  // Extrapolate directly to exclude material effects!
                  if (distance > 1.e-4) {
                    ATH_MSG_DEBUG("Distance between perigee and generated vertex exceeds tolerance ("
                                  << 1.e-4 << " mm)... Extrapolating!");
 
                    generatedTrackPerigee = m_extrapolator->extrapolateDirectly(ctx,
                                                                                *productionVertexTrackParams,
                                                                                perigeeSurface,
                                                                                Trk::anyDirection,
                                                                                false,
                                                                                Trk::nonInteracting).release();
                    if (!generatedTrackPerigee) continue;
                  } else {
                    ATH_MSG_DEBUG("Distance between perigee and generated vertex is less than tolerance ("
                                  << 1.e-4 << " CLHEP::mm)... " << "No propagation to perigee required");
 
                    // Clone the parameters from the AtaPlane object on to perigee
                    generatedTrackPerigee = new Trk::Perigee(0., 0.,
                                                             genPar_phi, genPar_theta, genPar_qOverP,
                                                             Trk::PerigeeSurface(productionVertexAsGlobalPosition));
                  }
 
                  dumpPerigee(generatedTrackPerigee, nmctracks);
                  m_nt_mc_Trk_vtxX[nmctracks] = productionVertex.x();
                  m_nt_mc_Trk_vtxY[nmctracks] = productionVertex.y();
                  m_nt_mc_Trk_vtxZ[nmctracks] = productionVertex.z();
 
                  delete productionVertexTrackParams;
                  delete generatedTrackPerigee;
 
                  nmctracks++;
                }
              }
 
              if (generatedTrackPerigee) {
                dumpPerigee(generatedTrackPerigee, nTracks);
                m_nt_mc_Trk_vtxX[nTracks] = genParticle->production_vertex()->position().x();
                m_nt_mc_Trk_vtxY[nTracks] = genParticle->production_vertex()->position().y();
                m_nt_mc_Trk_vtxZ[nTracks] = genParticle->production_vertex()->position().z();
 
                delete generatedTrackPerigee;
              }
            }
          }
          m_nt_mc_trkistruth[nTracks] = 0;
        }
        //} // if (truthCol)  commented out for coverity 14309
 
        nTracks++;
      }
    }
  } // end if m_doTruth
 
  // Store TrkTrack branch
  std::string nt0id = m_ntupleName + "/TrkTrack";
  sc = m_ntupleSvc->writeRecord(nt0id);
  if (sc.isFailure()) ATH_MSG_ERROR("Could not write " << nt0id << "!");
 
  if (m_inputUpCol != "") {
    // Store TrkTrack_Up branch
    std::string nt1id = m_ntupleName + "/TrkTrack_Up";
    sc = m_ntupleSvc->writeRecord(nt1id);
    if (sc.isFailure()) ATH_MSG_ERROR("Could not write " << nt1id << "!");
  }
 
  if (m_inputLowCol != "") {
    // Store TrkTrack_Low branch
    std::string nt2id = m_ntupleName + "/TrkTrack_Low";
    sc = m_ntupleSvc->writeRecord(nt2id);
    if (sc.isFailure()) ATH_MSG_ERROR("Could not write " << nt2id << "!");
  }
 
  if (m_doMatching && m_inputUpCol != "" && m_inputLowCol != "") {
    // Store Matching Up/Low TrkTracks branch
    std::string nt3id = m_ntupleName + "/TrkTrack_Matching";
    sc = m_ntupleSvc->writeRecord(nt3id);
    if (sc.isFailure()) ATH_MSG_ERROR("Could not write " << nt3id << "!");
  }
 
 
  m_events++;
 
  // check for negative values
  if (m_totaltrks < 0) m_totaltrks = 0;
  if (m_totalhits < 0) m_totalhits = 0;
  if (m_totalPixhits < 0) m_totalPixhits = 0;
  if (m_totalSCThits < 0) m_totalSCThits = 0;
  if (m_totalTRThits < 0) m_totalTRThits = 0;
 
  if (m_inputUpCol != "") {
    if (m_totalUptrks < 0) m_totalUptrks = 0;
    if (m_totalUphits < 0) m_totalUphits = 0;
    if (m_totalUpPixhits < 0) m_totalUpPixhits = 0;
    if (m_totalUpSCThits < 0) m_totalUpSCThits = 0;
    if (m_totalUpTRThits < 0) m_totalUpTRThits = 0;
  }
 
  if (m_inputLowCol != "") {
    if (m_totalLowtrks < 0) m_totalLowtrks = 0;
    if (m_totalLowhits < 0) m_totalLowhits = 0;
    if (m_totalLowPixhits < 0) m_totalLowPixhits = 0;
    if (m_totalLowSCThits < 0) m_totalLowSCThits = 0;
    if (m_totalLowTRThits < 0) m_totalLowTRThits = 0;
  }
 
  if (m_events < 0) m_events = 0;
  // no deletion because StoreGate owns these pointers.
  //delete tracks;
  //delete Uptracks;
  //delete Lowtracks;
  return StatusCode::SUCCESS;
}

finalize()

StatusCode InDetAlignFillTrack::finalize ( )

overridevirtual

Definition at line 87 of file InDetAlignFillTrack.cxx.

                                         {
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << "Finalize() of FillTrack" << endmsg;
 
    msg(MSG::DEBUG) << "________________________________________________________" << endmsg;
    msg(MSG::DEBUG) << endmsg;
    msg(MSG::DEBUG) << " InDetAlignFillTrack Summary: " << endmsg;
    msg(MSG::DEBUG) << " - " << m_events << " events" << endmsg;
    msg(MSG::DEBUG) << " - " << m_totaltrks << " tracks" << endmsg;
    msg(MSG::DEBUG) << " - " << m_totalhits << " hits" << endmsg;
    msg(MSG::DEBUG) << "  - " << m_totalPixhits << " Pixel hits" << endmsg;
    msg(MSG::DEBUG) << "  - " << m_totalSCThits << " SCT hits" << endmsg;
    msg(MSG::DEBUG) << "  - " << m_totalTRThits << " TRT hits" << endmsg;
    msg(MSG::DEBUG) << "________________________________________________________" << endmsg;
 
    if (m_inputUpCol != "") {
      msg(MSG::DEBUG) << " Up Track Summary: " << endmsg;
      msg(MSG::DEBUG) << " - " << m_totalUptrks << " tracks" << endmsg;
      msg(MSG::DEBUG) << " - " << m_totalUphits << " hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalUpPixhits << " Pixel hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalUpSCThits << " SCT hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalUpTRThits << " TRT hits" << endmsg;
      msg(MSG::DEBUG) << "________________________________________________________" << endmsg;
    }
 
    if (m_inputLowCol != "") {
      msg(MSG::DEBUG) << " Low Track Summary: " << endmsg;
      msg(MSG::DEBUG) << " - " << m_totalLowtrks << " tracks" << endmsg;
      msg(MSG::DEBUG) << " - " << m_totalLowhits << " hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalLowPixhits << " Pixel hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalLowSCThits << " SCT hits" << endmsg;
      msg(MSG::DEBUG) << "  - " << m_totalLowTRThits << " TRT hits" << endmsg;
      msg(MSG::DEBUG) << "________________________________________________________" << endmsg;
    }
 
    msg(MSG::DEBUG) << endmsg;
  }
 
  return StatusCode::SUCCESS;
}

GetTrkHits()

virtual int InDetAlignFillTrack::GetTrkHits ( ) const

inlineoverridevirtual

Definition at line 49 of file InDetAlignFillTrack.h.

{ return m_totalhits; }

GetTrkPixHits()

virtual int InDetAlignFillTrack::GetTrkPixHits ( ) const

inlineoverridevirtual

Definition at line 50 of file InDetAlignFillTrack.h.

{ return m_totalPixhits; }

GetTrks()

virtual int InDetAlignFillTrack::GetTrks ( ) const

inlineoverridevirtual

Definition at line 48 of file InDetAlignFillTrack.h.

{ return m_totaltrks; }

GetTrkSCTHits()

virtual int InDetAlignFillTrack::GetTrkSCTHits ( ) const

inlineoverridevirtual

Definition at line 51 of file InDetAlignFillTrack.h.

{ return m_totalSCThits; }

GetTrkTRTHits()

virtual int InDetAlignFillTrack::GetTrkTRTHits ( ) const

inlineoverridevirtual

Definition at line 52 of file InDetAlignFillTrack.h.

{ return m_totalTRThits; }

initialize()

StatusCode InDetAlignFillTrack::initialize ( )

overridevirtual

Definition at line 62 of file InDetAlignFillTrack.cxx.

                                           {
  ATH_MSG_DEBUG("Initialize() of FillTrack");
  // retrieve the NTuple Service
  ATH_CHECK(m_ntupleSvc.retrieve());
  // get TrackParticleCreatorTool
  ATH_CHECK(m_particleCreator.retrieve());
  // if Truth...
  if (m_doTruth) {
    // Get TruthToTrack
    ATH_CHECK(m_truthToTrack.retrieve());
    // Get Extrapolator Tool
    ATH_CHECK(m_extrapolator.retrieve());
  }
  // Book Ntuple
  bookNtuple();
  if (!m_inputUpCol.empty()) bookUpNtuple();
  if (!m_inputLowCol.empty()) bookLowNtuple();
  if (m_doMatching && !m_inputUpCol.empty() && !m_inputLowCol.empty()) bookMatchingNtuple();
  ATH_MSG_DEBUG("Initialize() of FillTrack successful");
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_doMatching

BooleanProperty InDetAlignFillTrack::m_doMatching {this,"doMatching",true}

private

switch on/off the matching information

Definition at line 79 of file InDetAlignFillTrack.h.

{this,"doMatching",true};  

m_doTruth

BooleanProperty InDetAlignFillTrack::m_doTruth {this,"doTruth",false}

private

switch on/off the truth information

Definition at line 71 of file InDetAlignFillTrack.h.

{this,"doTruth",false};       

m_events

int InDetAlignFillTrack::m_events {0}

private

Definition at line 102 of file InDetAlignFillTrack.h.

{0};

m_extrapolator

ToolHandle< Trk::IExtrapolator > InDetAlignFillTrack::m_extrapolator

private

Initial value:

{this
    , "ExtrapolationTool"
    , "Trk::Extrapolator/CosmicsExtrapolator"
    , "tool to extrapolate tracks"}

Definition at line 110 of file InDetAlignFillTrack.h.

                                                {this
    , "ExtrapolationTool"
    , "Trk::Extrapolator/CosmicsExtrapolator"
    , "tool to extrapolate tracks"};

m_inputCol

StringProperty InDetAlignFillTrack::m_inputCol {this,"InputTrkCol","Tracks"}

private

Definition at line 74 of file InDetAlignFillTrack.h.

{this,"InputTrkCol","Tracks"};

m_inputLowCol

StringProperty InDetAlignFillTrack::m_inputLowCol {this,"InputLowTrkCol",""}

private

Definition at line 76 of file InDetAlignFillTrack.h.

{this,"InputLowTrkCol",""};

m_inputUpCol

StringProperty InDetAlignFillTrack::m_inputUpCol {this,"InputUpTrkCol",""}

private

Definition at line 75 of file InDetAlignFillTrack.h.

{this,"InputUpTrkCol",""};

m_matchedRcut

FloatProperty InDetAlignFillTrack::m_matchedRcut {this,"dRCut",100.}

private

Definition at line 80 of file InDetAlignFillTrack.h.

{this,"dRCut",100.};

m_mindR

FloatProperty InDetAlignFillTrack::m_mindR {this,"minimumdR",10000.}

private

Definition at line 81 of file InDetAlignFillTrack.h.

{this,"minimumdR",10000.};

m_nt_matchingTrk

NTuple::Item<long> InDetAlignFillTrack::m_nt_matchingTrk

private

matching tracks

Definition at line 124 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_charge

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_charge

private

MonteCarlo charge parameter.

Definition at line 230 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_d0

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_d0

private

MonteCarlo d0 parameter.

Definition at line 221 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_eta

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_eta

private

MonteCarlo eta parameter.

Definition at line 225 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_genParticleEta

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_genParticleEta

private

generated eta

Definition at line 217 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_genParticlePhi

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_genParticlePhi

private

generated phi

Definition at line 218 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_genParticlePt

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_genParticlePt

private

generated pt

Definition at line 216 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_pdg

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_pdg

private

MonteCarlo pdg parameter.

Definition at line 232 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_phi0

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_phi0

private

MonteCarlo phi0 parameter.

Definition at line 223 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_prob

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_prob

private

MonteCarlo prob parameter.

Definition at line 231 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_pt

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_pt

private

MonteCarlo pt parameter.

Definition at line 229 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_qoverp

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_qoverp

private

MonteCarlo q/p parameter.

Definition at line 226 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_qoverpt

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_qoverpt

private

MonteCarlo q/pt parameter.

Definition at line 227 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_theta0

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_theta0

private

MonteCarlo theta0 parameter.

Definition at line 224 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_vtxX

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_vtxX

private

MonteCarlo Vertex.X parameter.

Definition at line 234 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_vtxY

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_vtxY

private

MonteCarlo Vertex.Y parameter.

Definition at line 235 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_vtxZ

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_vtxZ

private

MonteCarlo Vertex.Z parameter.

Definition at line 236 of file InDetAlignFillTrack.h.

m_nt_mc_Trk_z0

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_Trk_z0

private

MonteCarlo z0 parameter.

Definition at line 222 of file InDetAlignFillTrack.h.

m_nt_mc_trkistruth

NTuple::Array<float> InDetAlignFillTrack::m_nt_mc_trkistruth

private

Has the Track an associated truth track?

Definition at line 213 of file InDetAlignFillTrack.h.

m_nt_nLowtracks

NTuple::Item<long> InDetAlignFillTrack::m_nt_nLowtracks

private

number of Low tracks

Definition at line 122 of file InDetAlignFillTrack.h.

m_nt_nmctracks

NTuple::Item<long> InDetAlignFillTrack::m_nt_nmctracks

private

number of mc tracks

Definition at line 123 of file InDetAlignFillTrack.h.

m_nt_ntracks

NTuple::Item<long> InDetAlignFillTrack::m_nt_ntracks

private

number of tracks

Definition at line 120 of file InDetAlignFillTrack.h.

m_nt_nUptracks

NTuple::Item<long> InDetAlignFillTrack::m_nt_nUptracks

private

number of Up tracks

Definition at line 121 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2

private

number of chi2

Definition at line 149 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2_Low

private

number of chi2 (Low track)

Definition at line 207 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2_Up

private

number of chi2 (Up track)

Definition at line 178 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2Prob

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2Prob

private

number of chi2 probability

Definition at line 151 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2Prob_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2Prob_Low

private

number of chi2 probability (Low track)

Definition at line 209 of file InDetAlignFillTrack.h.

m_nt_Trk_chi2Prob_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_chi2Prob_Up

private

number of chi2 probability (Up track)

Definition at line 180 of file InDetAlignFillTrack.h.

m_nt_Trk_d0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_d0

private

d0 parameter

Definition at line 127 of file InDetAlignFillTrack.h.

m_nt_Trk_d0_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_d0_Low

private

d0 parameter (Low track)

Definition at line 185 of file InDetAlignFillTrack.h.

m_nt_Trk_d0_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_d0_Up

private

d0 parameter (Up track)

Definition at line 156 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_charge

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_charge

private

charge parameter

Definition at line 250 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_d0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_d0

private

d0 parameter

Definition at line 242 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_eta

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_eta

private

eta parameter

Definition at line 247 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_phi0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_phi0

private

phi0 parameter

Definition at line 244 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_pt

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_pt

private

pt parameter

Definition at line 249 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_qoverpt

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_qoverpt

private

q/pt parameter

Definition at line 248 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_theta0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_theta0

private

theta parameter

Definition at line 246 of file InDetAlignFillTrack.h.

m_nt_Trk_delta_z0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_delta_z0

private

z0 parameter

Definition at line 243 of file InDetAlignFillTrack.h.

m_nt_Trk_ndof

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_ndof

private

number of ndof

Definition at line 150 of file InDetAlignFillTrack.h.

m_nt_Trk_ndof_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_ndof_Low

private

number of ndof (Low track)

Definition at line 208 of file InDetAlignFillTrack.h.

m_nt_Trk_ndof_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_ndof_Up

private

number of ndof (Up track)

Definition at line 179 of file InDetAlignFillTrack.h.

m_nt_Trk_nHits

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nHits

private

number of hits

Definition at line 136 of file InDetAlignFillTrack.h.

m_nt_Trk_nHits_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nHits_Low

private

number of hits (Low track)

Definition at line 194 of file InDetAlignFillTrack.h.

m_nt_Trk_nHits_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nHits_Up

private

number of hits (Up track)

Definition at line 165 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitspix

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitspix

private

number of Pixel hits

Definition at line 137 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitspix_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitspix_Low

private

number of Pixel hits (Low track)

Definition at line 195 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitspix_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitspix_Up

private

number of Pixel hits (Up track)

Definition at line 166 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitssct

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitssct

private

number of SCT hits

Definition at line 138 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitssct_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitssct_Low

private

number of SCT hits (Low track)

Definition at line 196 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitssct_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitssct_Up

private

number of SCT hits (Up track)

Definition at line 167 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitstrt

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitstrt

private

number of TRT hits

Definition at line 139 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitstrt_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitstrt_Low

private

number of TRT hits (Low track)

Definition at line 197 of file InDetAlignFillTrack.h.

m_nt_Trk_nhitstrt_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nhitstrt_Up

private

number of TRT hits (Up track)

Definition at line 168 of file InDetAlignFillTrack.h.

m_nt_Trk_nholes

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholes

private

number of holes

Definition at line 147 of file InDetAlignFillTrack.h.

m_nt_Trk_nholes_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholes_Low

private

number of holes (Low track)

Definition at line 205 of file InDetAlignFillTrack.h.

m_nt_Trk_nholes_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholes_Up

private

number of holes (Up track)

Definition at line 176 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesPixels

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesPixels

private

number of Pixel holes

Definition at line 145 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesPixels_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesPixels_Low

private

number of Pixel holes (Low track)

Definition at line 203 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesPixels_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesPixels_Up

private

number of Pixel holes (Up track)

Definition at line 174 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesSCT

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesSCT

private

number of SCT holes

Definition at line 146 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesSCT_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesSCT_Low

private

number of SCT holes (Low track)

Definition at line 204 of file InDetAlignFillTrack.h.

m_nt_Trk_nholesSCT_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nholesSCT_Up

private

number of SCT holes (Up track)

Definition at line 175 of file InDetAlignFillTrack.h.

m_nt_Trk_nshared

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nshared

private

number of shared hits

Definition at line 143 of file InDetAlignFillTrack.h.

m_nt_Trk_nshared_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nshared_Low

private

number of shared hits (Low track)

Definition at line 201 of file InDetAlignFillTrack.h.

m_nt_Trk_nshared_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nshared_Up

private

number of shared hits (Up track)

Definition at line 172 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedPixels

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedPixels

private

number of Pixel shared hits

Definition at line 141 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedPixels_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedPixels_Low

private

number of Pixel shared hits (Low track)

Definition at line 199 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedPixels_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedPixels_Up

private

number of Pixel shared hits (Up track)

Definition at line 170 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedSCT

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedSCT

private

number of SCT shared hits

Definition at line 142 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedSCT_Low

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedSCT_Low

private

number of SCT shared hits (Low track)

Definition at line 200 of file InDetAlignFillTrack.h.

m_nt_Trk_nsharedSCT_Up

NTuple::Array<long> InDetAlignFillTrack::m_nt_Trk_nsharedSCT_Up

private

number of SCT shared hits (Up track)

Definition at line 171 of file InDetAlignFillTrack.h.

m_nt_Trk_phi0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_phi0

private

phi0 parameter

Definition at line 129 of file InDetAlignFillTrack.h.

m_nt_Trk_phi0_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_phi0_Low

private

phi0 parameter (Low track)

Definition at line 187 of file InDetAlignFillTrack.h.

m_nt_Trk_phi0_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_phi0_Up

private

phi0 parameter (Up track)

Definition at line 158 of file InDetAlignFillTrack.h.

m_nt_Trk_pt

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_pt

private

pt parameter

Definition at line 132 of file InDetAlignFillTrack.h.

m_nt_Trk_pt_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_pt_Low

private

pt parameter (Low track)

Definition at line 190 of file InDetAlignFillTrack.h.

m_nt_Trk_pt_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_pt_Up

private

pt parameter (Up track)

Definition at line 161 of file InDetAlignFillTrack.h.

m_nt_Trk_qoverp

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_qoverp

private

q/p parameter

Definition at line 131 of file InDetAlignFillTrack.h.

m_nt_Trk_qoverp_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_qoverp_Low

private

q/p parameter (Low track)

Definition at line 189 of file InDetAlignFillTrack.h.

m_nt_Trk_qoverp_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_qoverp_Up

private

q/p parameter (Up track)

Definition at line 160 of file InDetAlignFillTrack.h.

m_nt_Trk_theta0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_theta0

private

theta0 parameter

Definition at line 130 of file InDetAlignFillTrack.h.

m_nt_Trk_theta0_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_theta0_Low

private

theta0 parameter (Low track)

Definition at line 188 of file InDetAlignFillTrack.h.

m_nt_Trk_theta0_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_theta0_Up

private

theta0 parameter (Up track)

Definition at line 159 of file InDetAlignFillTrack.h.

m_nt_Trk_z0

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_z0

private

z0 parameter

Definition at line 128 of file InDetAlignFillTrack.h.

m_nt_Trk_z0_Low

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_z0_Low

private

z0 parameter (Low track)

Definition at line 186 of file InDetAlignFillTrack.h.

m_nt_Trk_z0_Up

NTuple::Array<float> InDetAlignFillTrack::m_nt_Trk_z0_Up

private

z0 parameter (Up track)

Definition at line 157 of file InDetAlignFillTrack.h.

m_ntupleName

StringProperty InDetAlignFillTrack::m_ntupleName {this,"NtupleName","/NTUPLES/GLOBFILE"}

private

Definition at line 84 of file InDetAlignFillTrack.h.

{this,"NtupleName","/NTUPLES/GLOBFILE"};

m_ntupleSvc

ServiceHandle<INTupleSvc> InDetAlignFillTrack::m_ntupleSvc {this,"NTupleSvc","NTupleSvc"}

private

Definition at line 55 of file InDetAlignFillTrack.h.

{this,"NTupleSvc","NTupleSvc"};

m_particleCreator

ToolHandle<Trk::ITrackParticleCreatorTool> InDetAlignFillTrack::m_particleCreator

private

Initial value:

{this
    , "TrackParticleCreatorTool"
    , "Trk::TrackParticleCreatorTool/TrackParticleCreatorTool"
    , "tool to build TrackParticle"}

Definition at line 115 of file InDetAlignFillTrack.h.

                                                             {this
    , "TrackParticleCreatorTool"
    , "Trk::TrackParticleCreatorTool/TrackParticleCreatorTool"
    , "tool to build TrackParticle"};

m_totalhits

int InDetAlignFillTrack::m_totalhits {0}

private

Definition at line 88 of file InDetAlignFillTrack.h.

{0};

m_totalLowhits

int InDetAlignFillTrack::m_totalLowhits {0}

private

Definition at line 98 of file InDetAlignFillTrack.h.

{0};

m_totalLowPixhits

int InDetAlignFillTrack::m_totalLowPixhits {0}

private

Definition at line 99 of file InDetAlignFillTrack.h.

{0};

m_totalLowSCThits

int InDetAlignFillTrack::m_totalLowSCThits {0}

private

Definition at line 100 of file InDetAlignFillTrack.h.

{0};

m_totalLowtrks

int InDetAlignFillTrack::m_totalLowtrks {0}

private

Definition at line 97 of file InDetAlignFillTrack.h.

{0};

m_totalLowTRThits

int InDetAlignFillTrack::m_totalLowTRThits {0}

private

Definition at line 101 of file InDetAlignFillTrack.h.

{0};

m_totalPixhits

int InDetAlignFillTrack::m_totalPixhits {0}

private

Definition at line 89 of file InDetAlignFillTrack.h.

{0};

m_totalSCThits

int InDetAlignFillTrack::m_totalSCThits {0}

private

Definition at line 90 of file InDetAlignFillTrack.h.

{0};

m_totaltrks

int InDetAlignFillTrack::m_totaltrks {0}

private

Definition at line 87 of file InDetAlignFillTrack.h.

{0};

m_totalTRThits

int InDetAlignFillTrack::m_totalTRThits {0}

private

Definition at line 91 of file InDetAlignFillTrack.h.

{0};

m_totalUphits

int InDetAlignFillTrack::m_totalUphits {0}

private

Definition at line 93 of file InDetAlignFillTrack.h.

{0};

m_totalUpPixhits

int InDetAlignFillTrack::m_totalUpPixhits {0}

private

Definition at line 94 of file InDetAlignFillTrack.h.

{0};

m_totalUpSCThits

int InDetAlignFillTrack::m_totalUpSCThits {0}

private

Definition at line 95 of file InDetAlignFillTrack.h.

{0};

m_totalUptrks

int InDetAlignFillTrack::m_totalUptrks {0}

private

Definition at line 92 of file InDetAlignFillTrack.h.

{0};

m_totalUpTRThits

int InDetAlignFillTrack::m_totalUpTRThits {0}

private

Definition at line 96 of file InDetAlignFillTrack.h.

{0};

m_truthToTrack

ToolHandle< Trk::ITruthToTrack > InDetAlignFillTrack::m_truthToTrack

private

Initial value:

{this
    , "TruthToTrackTool"
    , "Trk::TruthToTrack"
    , "tool to produce perigee track parameters from generated parameters"}

Definition at line 105 of file InDetAlignFillTrack.h.

                                                {this
    , "TruthToTrackTool"
    , "Trk::TruthToTrack"
    , "tool to produce perigee track parameters from generated parameters"};

m_TruthTrkCol

StringProperty InDetAlignFillTrack::m_TruthTrkCol {this,"TruthTrkCol","TrackTruthCollection"}

private

Definition at line 72 of file InDetAlignFillTrack.h.

{this,"TruthTrkCol","TrackTruthCollection"};

---

The documentation for this class was generated from the following files:

• InDetAlignFillTrack.h
• InDetAlignFillTrack.cxx