#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
std::string	m_validationTreeDescription
	validation tree description - second argument in TTree
std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out
TTree *	m_validationTree
	Root Validation Tree.
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 23 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 112 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 214 of file GeantFollowerHelper.cxx.

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

◆ finalize()

StatusCode Trk::GeantFollowerHelper::finalize ( )

overridevirtual

Definition at line 107 of file GeantFollowerHelper.cxx.

{
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Trk::GeantFollowerHelper::initialize ( )

overridevirtual

Definition at line 47 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
  SmartIF<ITHistSvc> tHistSvc{Gaudi::svcLocator()->service("THistSvc")};
  if ( !tHistSvc ) {
    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 127 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();
  auto trkParameters = m_extrapolateDirectly ?
    m_extrapolator->extrapolateDirectly(ctx,
                                        *m_parameterCache,
                                        destinationSurface,
                                        Trk::alongMomentum,false):
    m_extrapolator->extrapolate(ctx,
                                *m_parameterCache,
                                destinationSurface,
                                Trk::alongMomentum,false);
  // 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.release();
  }
  // 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

int Trk::GeantFollowerHelper::MAXPROBES {50000}

staticconstexpr

Definition at line 29 of file GeantFollowerHelper.h.

29{50000};

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