#include <GeantFollowerHelper.h>

Inheritance diagram for Trk::GeantFollowerHelper:

Collaboration diagram for Trk::GeantFollowerHelper:

Classes
struct	TreeData
	Ntuple variables : initial parameters Split this out into a separate, dynamically-allocated block. More...

Public Member Functions
	GeantFollowerHelper (const std::string &, const std::string &, const IInterface *)

virtual	~GeantFollowerHelper ()

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual void	beginEvent () override

virtual void	trackParticle (const G4ThreeVector &pos, const G4ThreeVector &mom, int pdg, double charge, float t, float X0) override

virtual void	endEvent () override

Static Public Attributes
static constexpr int	MAXPROBES {50000}

Private Attributes
ToolHandle< IExtrapolator >	m_extrapolator

bool	m_extrapolateDirectly

bool	m_extrapolateIncrementally

const TrackParameters *	m_parameterCache

float	m_tX0Cache

std::string	m_validationTreeName
	validation tree name - to be acessed by this from root More...

std::string	m_validationTreeDescription
	validation tree description - second argument in TTree More...

std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out More...

TTree *	m_validationTree
	Root Validation Tree. More...

std::unique_ptr< TreeData >	m_treeData

Detailed Description

Definition at line 24 of file GeantFollowerHelper.h.

Constructor & Destructor Documentation

◆ GeantFollowerHelper()

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

Definition at line 24 of file GeantFollowerHelper.cxx.

                                                                                                        :
   base_class(t,n,p),
   m_extrapolator(""),
   m_extrapolateDirectly(true),
   m_extrapolateIncrementally(true),
   m_parameterCache(nullptr),
   m_tX0Cache(0.),
   m_validationTreeName("G4Follower_"+n),
   m_validationTreeDescription("Output of the G4Follower_"),
   m_validationTreeFolder("/val/G4Follower_"+n),
   m_validationTree(nullptr)
 {
   // properties
   declareProperty("Extrapolator",                   m_extrapolator);
   declareProperty("ExtrapolateDirectly",            m_extrapolateDirectly);
   declareProperty("ExtrapolateIncrementally",       m_extrapolateIncrementally);
 }

◆ ~GeantFollowerHelper()

Trk::GeantFollowerHelper::~GeantFollowerHelper ( )

virtualdefault

Member Function Documentation

◆ beginEvent()

void Trk::GeantFollowerHelper::beginEvent ( )

overridevirtual

Definition at line 113 of file GeantFollowerHelper.cxx.

 {
   m_treeData->m_t_x        = 0.;
   m_treeData->m_t_y        = 0.;
   m_treeData->m_t_z        = 0.;
   m_treeData->m_t_theta    = 0.;
   m_treeData->m_t_eta      = 0.;
   m_treeData->m_t_phi      = 0.;
   m_treeData->m_t_p        = 0.;
   m_treeData->m_t_charge   = 0.;
   m_treeData->m_t_pdg      = 0;
   m_treeData->m_g4_steps   = 0;
   m_tX0Cache   = 0.;
 }

◆ endEvent()

void Trk::GeantFollowerHelper::endEvent ( )

overridevirtual

Definition at line 215 of file GeantFollowerHelper.cxx.

 {
   // fill the validation tree
   m_validationTree->Fill();
   delete m_parameterCache;
 }

◆ finalize()

StatusCode Trk::GeantFollowerHelper::finalize ( )

overridevirtual

Definition at line 108 of file GeantFollowerHelper.cxx.

 {
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode Trk::GeantFollowerHelper::initialize ( )

overridevirtual

Definition at line 48 of file GeantFollowerHelper.cxx.

 {
   m_treeData = std::make_unique<TreeData>();
  
   if (m_extrapolator.retrieve().isFailure()){
     ATH_MSG_ERROR("Could not retrieve Extrapolator " << m_extrapolator << " . Abort.");
     return StatusCode::FAILURE;
   }
  
   // create the new Tree
   m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
  
   m_validationTree->Branch("InitX",        &m_treeData->m_t_x,       "initX/F");
   m_validationTree->Branch("InitY",        &m_treeData->m_t_y,       "initY/F");
   m_validationTree->Branch("InitZ",        &m_treeData->m_t_z,       "initZ/F");
   m_validationTree->Branch("InitTheta",    &m_treeData->m_t_theta,   "initTheta/F");
   m_validationTree->Branch("InitEta",      &m_treeData->m_t_eta,     "initEta/F");
   m_validationTree->Branch("InitPhi",      &m_treeData->m_t_phi,     "initPhi/F");
   m_validationTree->Branch("InitP",        &m_treeData->m_t_p,       "initP/F");
   m_validationTree->Branch("InitPdg",      &m_treeData->m_t_pdg,     "initPdg/I");
   m_validationTree->Branch("InitCharge",   &m_treeData->m_t_charge,  "initQ/F");
  
   m_validationTree->Branch("G4Steps",      &m_treeData->m_g4_steps, "g4steps/I");
   m_validationTree->Branch("G4StepP",      m_treeData->m_g4_p,      "g4stepP[g4steps]/F");
   m_validationTree->Branch("G4StepEta",    m_treeData->m_g4_eta,    "g4stepEta[g4steps]/F");
   m_validationTree->Branch("G4StepTheta",  m_treeData->m_g4_theta,  "g4stepTheta[g4steps]/F");
   m_validationTree->Branch("G4StepPhi",    m_treeData->m_g4_phi,    "g4stepPhi[g4steps]/F");
   m_validationTree->Branch("G4StepX",      m_treeData->m_g4_x,      "g4stepX[g4steps]/F");
   m_validationTree->Branch("G4StepY",      m_treeData->m_g4_y,      "g4stepY[g4steps]/F");
   m_validationTree->Branch("G4StepZ",      m_treeData->m_g4_z,      "g4stepZ[g4steps]/F");
   m_validationTree->Branch("G4AccumTX0",   m_treeData->m_g4_tX0,    "g4stepAccTX0[g4steps]/F");
   m_validationTree->Branch("G4StepT",      m_treeData->m_g4_t,      "g4stepTX[g4steps]/F");
   m_validationTree->Branch("G4StepX0",     m_treeData->m_g4_X0,     "g4stepX0[g4steps]/F");
  
   m_validationTree->Branch("TrkStepStatus",m_treeData->m_trk_status, "trkstepStatus[g4steps]/I");
   m_validationTree->Branch("TrkStepP",     m_treeData->m_trk_p,      "trkstepP[g4steps]/F");
   m_validationTree->Branch("TrkStepEta",   m_treeData->m_trk_eta,    "trkstepEta[g4steps]/F");
   m_validationTree->Branch("TrkStepTheta", m_treeData->m_trk_theta,  "trkstepTheta[g4steps]/F");
   m_validationTree->Branch("TrkStepPhi",   m_treeData->m_trk_phi,    "trkstepPhi[g4steps]/F");
   m_validationTree->Branch("TrkStepX",     m_treeData->m_trk_x,      "trkstepX[g4steps]/F");
   m_validationTree->Branch("TrkStepY",     m_treeData->m_trk_y,      "trkstepY[g4steps]/F");
   m_validationTree->Branch("TrkStepZ",     m_treeData->m_trk_z,      "trkstepZ[g4steps]/F");
   m_validationTree->Branch("TrkStepLocX",  m_treeData->m_trk_lx,     "trkstepLX[g4steps]/F");
   m_validationTree->Branch("TrkStepLocY",  m_treeData->m_trk_ly,     "trkstepLY[g4steps]/F");
  
   // now register the Tree
   ITHistSvc* tHistSvc = nullptr;
   if (service("THistSvc",tHistSvc).isFailure()){
     ATH_MSG_ERROR( "Could not find Hist Service -> Switching ValidationMode Off !" );
     delete m_validationTree; m_validationTree = nullptr;
   }
   if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
     ATH_MSG_ERROR( "Could not register the validation Tree -> Switching ValidationMode Off !" );
     delete m_validationTree; m_validationTree = nullptr;
   }
  
   ATH_MSG_INFO("initialize() successful" );
   return StatusCode::SUCCESS;
 }

◆ trackParticle()

void Trk::GeantFollowerHelper::trackParticle	(	const G4ThreeVector &	pos,
		const G4ThreeVector &	mom,
		int	pdg,
		double	charge,
		float	t,
		float	X0
	)

overridevirtual

Definition at line 128 of file GeantFollowerHelper.cxx.

 {
   // construct the initial parameters
   Amg::Vector3D npos(pos.x(),pos.y(),pos.z());
   Amg::Vector3D nmom(mom.x(),mom.y(),mom.z());
   if (!m_treeData->m_g4_steps){
     ATH_MSG_INFO("Initial step ... preparing event cache.");
     m_treeData->m_t_x        = pos.x();
     m_treeData->m_t_y        = pos.y();
     m_treeData->m_t_z        = pos.z();
     m_treeData->m_t_theta    = mom.theta();
     m_treeData->m_t_eta      = mom.eta();
     m_treeData->m_t_phi      = mom.phi();
     m_treeData->m_t_p        = mom.mag();
     m_treeData->m_t_charge   = charge;
     m_treeData->m_t_pdg      = pdg;
     m_treeData->m_g4_steps   = -1;
     m_tX0Cache   = 0.;
     m_parameterCache = new Trk::CurvilinearParameters(npos, nmom, charge);
     return;
   }
  
   // jumping over inital step
   m_treeData->m_g4_steps = (m_treeData->m_g4_steps == -1) ? 0 : m_treeData->m_g4_steps;
  
   if (!m_parameterCache){
     ATH_MSG_WARNING("No Parameters available. Bailing out.");
     return;
   }
  
   if ( m_treeData->m_g4_steps >= MAXPROBES) {
     ATH_MSG_WARNING("Maximum number of " << MAXPROBES << " reached, step is ignored.");
     return;
   }
   // parameters of the G4 step point
   Trk::CurvilinearParameters* g4Parameters = new Trk::CurvilinearParameters(npos, nmom, m_treeData->m_t_charge);
   // destination surface
   const Trk::PlaneSurface& destinationSurface = g4Parameters->associatedSurface();
   // extrapolate to the destination surface
   const EventContext& ctx = Gaudi::Hive::currentContext();
   const Trk::TrackParameters* trkParameters = m_extrapolateDirectly ?
     m_extrapolator->extrapolateDirectly(ctx,
                                         *m_parameterCache,
                                         destinationSurface,
                                         Trk::alongMomentum,false).release() :
     m_extrapolator->extrapolate(ctx,
                                 *m_parameterCache,
                                 destinationSurface,
                                 Trk::alongMomentum,false).release();
   // fill the geant information and the trk information
   m_treeData->m_g4_p[m_treeData->m_g4_steps]       =  mom.mag();
   m_treeData->m_g4_eta[m_treeData->m_g4_steps]     =  mom.eta();
   m_treeData->m_g4_theta[m_treeData->m_g4_steps]   =  mom.theta();
   m_treeData->m_g4_phi[m_treeData->m_g4_steps]     =  mom.phi();
   m_treeData->m_g4_x[m_treeData->m_g4_steps]       =  pos.x();
   m_treeData->m_g4_y[m_treeData->m_g4_steps]       =  pos.y();
   m_treeData->m_g4_z[m_treeData->m_g4_steps]       =  pos.z();
   float tX0 = X0 > 10e-5 ? t/X0 : 0.;
   m_tX0Cache              += tX0;
   m_treeData->m_g4_tX0[m_treeData->m_g4_steps]     = m_tX0Cache;
   m_treeData->m_g4_t[m_treeData->m_g4_steps]       = t;
   m_treeData->m_g4_X0[m_treeData->m_g4_steps]      = X0;
  
   m_treeData->m_trk_status[m_treeData->m_g4_steps] = trkParameters ? 1 : 0;
   m_treeData->m_trk_p[m_treeData->m_g4_steps]      = trkParameters ? trkParameters->momentum().mag()      : 0.;
   m_treeData->m_trk_eta[m_treeData->m_g4_steps]    = trkParameters ? trkParameters->momentum().eta()      : 0.;
   m_treeData->m_trk_theta[m_treeData->m_g4_steps]  = trkParameters ? trkParameters->momentum().theta()    : 0.;
   m_treeData->m_trk_phi[m_treeData->m_g4_steps]    = trkParameters ? trkParameters->momentum().phi()      : 0.;
   m_treeData->m_trk_x[m_treeData->m_g4_steps]      = trkParameters ? trkParameters->position().x()        : 0.;
   m_treeData->m_trk_y[m_treeData->m_g4_steps]      = trkParameters ? trkParameters->position().y()        : 0.;
   m_treeData->m_trk_z[m_treeData->m_g4_steps]      = trkParameters ? trkParameters->position().z()        : 0.;
   m_treeData->m_trk_lx[m_treeData->m_g4_steps]     = trkParameters ? trkParameters->parameters()[Trk::locX] : 0.;
   m_treeData->m_trk_ly[m_treeData->m_g4_steps]     = trkParameters ? trkParameters->parameters()[Trk::locY] : 0.;
  
   // update the parameters if needed/configured
   if (m_extrapolateIncrementally && trkParameters) {
     delete m_parameterCache;
     m_parameterCache = trkParameters;
   }
   // delete cache and increment
   delete g4Parameters;
   ++m_treeData->m_g4_steps;
 }

Member Data Documentation

◆ m_extrapolateDirectly

bool Trk::GeantFollowerHelper::m_extrapolateDirectly

private

Definition at line 50 of file GeantFollowerHelper.h.

◆ m_extrapolateIncrementally

bool Trk::GeantFollowerHelper::m_extrapolateIncrementally

private

Definition at line 51 of file GeantFollowerHelper.h.

◆ m_extrapolator

ToolHandle<IExtrapolator> Trk::GeantFollowerHelper::m_extrapolator

private

Definition at line 49 of file GeantFollowerHelper.h.

◆ m_parameterCache

const TrackParameters* Trk::GeantFollowerHelper::m_parameterCache

private

Definition at line 53 of file GeantFollowerHelper.h.

◆ m_treeData

std::unique_ptr<TreeData> Trk::GeantFollowerHelper::m_treeData

private

Definition at line 100 of file GeantFollowerHelper.h.

◆ m_tX0Cache

float Trk::GeantFollowerHelper::m_tX0Cache

private

Definition at line 54 of file GeantFollowerHelper.h.

◆ m_validationTree

TTree* Trk::GeantFollowerHelper::m_validationTree

private

Root Validation Tree.

Definition at line 61 of file GeantFollowerHelper.h.

◆ m_validationTreeDescription

std::string Trk::GeantFollowerHelper::m_validationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 58 of file GeantFollowerHelper.h.

◆ m_validationTreeFolder

std::string Trk::GeantFollowerHelper::m_validationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 59 of file GeantFollowerHelper.h.

◆ m_validationTreeName

std::string Trk::GeantFollowerHelper::m_validationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 57 of file GeantFollowerHelper.h.

◆ MAXPROBES

constexpr int Trk::GeantFollowerHelper::MAXPROBES {50000}

staticconstexpr

Definition at line 29 of file GeantFollowerHelper.h.

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

Classes

Public Member Functions

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GeantFollowerHelper()

◆ ~GeantFollowerHelper()

Member Function Documentation

◆ beginEvent()

◆ endEvent()

◆ finalize()

◆ initialize()

◆ trackParticle()

Member Data Documentation

◆ m_extrapolateDirectly

◆ m_extrapolateIncrementally

◆ m_extrapolator

◆ m_parameterCache

◆ m_treeData

◆ m_tX0Cache

◆ m_validationTree

◆ m_validationTreeDescription

◆ m_validationTreeFolder

◆ m_validationTreeName

◆ MAXPROBES