Trk::EnergyLossExtrapolationValidation Class Reference

The EnergyLossExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to specific reference surfaces within the ATLAS Detector (user defined cylinder tubes which can be placed e.g. More...

#include <EnergyLossExtrapolationValidation.h>

Inheritance diagram for Trk::EnergyLossExtrapolationValidation:

Collaboration diagram for Trk::EnergyLossExtrapolationValidation:

Public Member Functions
	EnergyLossExtrapolationValidation (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
	~EnergyLossExtrapolationValidation ()
	Default Destructor.
StatusCode	initialize ()
	standard Athena-Algorithm method
StatusCode	execute ()
	standard Athena-Algorithm method
StatusCode	finalize ()
	standard Athena-Algorithm method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Static Private Member Functions
static std::unique_ptr< Amg::Transform3D >	createTransform (double x, double y, double z, double phi=0., double theta=0., double alphaZ=0.)
	private helper method to create a Transform

Private Attributes
const TrackingVolume *	m_highestVolume = nullptr
	the highest volume
ToolHandle< IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}
	The Extrapolator to be retrieved.
Rndm::Numbers *	m_gaussDist = nullptr
	Random Number setup.
Rndm::Numbers *	m_flatDist = nullptr
BooleanProperty	m_materialCollectionValidation
TTree *	m_validationTree = nullptr
	Root Validation Tree.
TTree *	m_validationRunTree = nullptr
	Root Run Stats Tree.
StringProperty	m_validationTreeFolder
StringProperty	m_validationTreeName
StringProperty	m_validationTreeDescription
StringProperty	m_validationRunTreeFolder
StringProperty	m_validationRunTreeName
StringProperty	m_validationRunTreeDescription
UnsignedIntegerProperty	m_cylinders
BooleanProperty	m_onion
FloatProperty	m_momentum
BooleanProperty	m_usePt
FloatProperty	m_minEta {this, "StartPerigeeMinEta", -3.}
FloatProperty	m_maxEta {this, "StartPerigeeMaxEta", 3.}
size_t	m_events = 0
	total number of recorded events
int	m_totalRecordedLayers = 0
	total number of recorded layers
float	m_avgRecordedLayers = 0
	average recorded layers per event
int	m_pdg = 0
	PDG code corresponding to m_particleType.
IntegerProperty	m_particleType
size_t	m_entries = 0
	effective number of used entries (recorded layers) in this event
float	m_energy [TRKEXALGS_MAXPARAMETERS] {}
	energy
float	m_energyLoss [TRKEXALGS_MAXPARAMETERS] {}
	energy loss
float	m_parameterX0 [TRKEXALGS_MAXPARAMETERS] {}
	thickness in X0
float	m_radius [TRKEXALGS_MAXPARAMETERS] {}
	position radius
float	m_positionX [TRKEXALGS_MAXPARAMETERS] {}
	position X
float	m_positionY [TRKEXALGS_MAXPARAMETERS] {}
	position Y
float	m_positionZ [TRKEXALGS_MAXPARAMETERS] {}
	position Z
float	m_parameterPhi [TRKEXALGS_MAXPARAMETERS] {}
	phi
float	m_parameterEta [TRKEXALGS_MAXPARAMETERS] {}
	eta
float	m_parameterTheta [TRKEXALGS_MAXPARAMETERS] {}
	theta
float	m_parameterQoverP [TRKEXALGS_MAXPARAMETERS] {}
	qOverP
float	m_parameterP [TRKEXALGS_MAXPARAMETERS] {}
	P.
size_t	m_layer [TRKEXALGS_MAXPARAMETERS] {}
	layer id
size_t	m_triesForward = 0
	extrapolation events forward
size_t	m_breaksForward = 0
	extrapolation breaks forward
size_t	m_triesBack = 0
	extrapolation events backward
size_t	m_breaksBack = 0
	extrapolation breaks backward
size_t	m_collectedLayerForward = 0
	collected material layers forward
size_t	m_collectedLayerBack = 0
	collected material layers backward
float	m_cylinderR [TRKEXALGS_MAXPARAMETERS] {}
	radius of cylinder layers (for ROOT tree)
float	m_cylinderZ [TRKEXALGS_MAXPARAMETERS] {}
	length of cylinder layers (for ROOT tree)
DataVector< const Trk::CylinderSurface > *	m_theCylinders = nullptr
DataVector< const Trk::DiscSurface > *	m_theDiscs1 = nullptr
DataVector< const Trk::DiscSurface > *	m_theDiscs2 = nullptr
FloatArrayProperty	m_cylinderVR
FloatArrayProperty	m_cylinderVZ
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

The EnergyLossExtrapolationValidation Algorithm runs a number of n test extrapolations from randomly distributed Track Parameters to specific reference surfaces within the ATLAS Detector (user defined cylinder tubes which can be placed e.g.

around Beam Pipe, Pixel, SCT, TRT, Calorimeter, Muon System, or have completely arbitrary dimensions).

In the jobOptions one can toggle these surfaces for

• a) the Inner Detector via DetFlags.ID_setOn() / DetFlags.ID_setOff()
• b) the Calorimeter via DetFlags.Calo_setOn() / DetFlags.Calo_setOff()
• c) the Muon System via DetFlags.Muon_setOn() / DetFlags.Calo_setOff()

The code of ExtrapolationValidation (by Andreas Salzburger) has been reused and adjusted for this algorithm.

Author

Wolfgang Lukas <Wolfgang.Lukas -at- cern.ch>

Definition at line 61 of file EnergyLossExtrapolationValidation.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EnergyLossExtrapolationValidation()

Trk::EnergyLossExtrapolationValidation::EnergyLossExtrapolationValidation	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Athena-Algorithm Constructor.

Definition at line 30 of file EnergyLossExtrapolationValidation.cxx.

  : AthAlgorithm(name,pSvcLocator) {}

~EnergyLossExtrapolationValidation()

Trk::EnergyLossExtrapolationValidation::~EnergyLossExtrapolationValidation

(

)

Default Destructor.

Definition at line 35 of file EnergyLossExtrapolationValidation.cxx.

{
  // clear random number generators
  delete m_gaussDist;
  delete m_flatDist;
  // clear data vectors
  delete m_theCylinders;
  delete m_theDiscs1;
  delete m_theDiscs2;
 
}

Member Function Documentation

createTransform()

std::unique_ptr< Amg::Transform3D > Trk::EnergyLossExtrapolationValidation::createTransform ( double x, double y, double z, double phi = 0., double theta = 0., double alphaZ = 0. )

staticprivate

private helper method to create a Transform

Definition at line 460 of file EnergyLossExtrapolationValidation.cxx.

{
 
    if (phi!=0. && theta != 0.){
        // create the Start Surface
        Amg::Vector3D surfacePosition(x,y,z);
        // z direction
        Amg::Vector3D surfaceZdirection(cos(phi)*sin(theta),
                sin(phi)*sin(theta),
                cos(theta));
        // the global z axis
        Amg::Vector3D zAxis(0.,0.,1.);
        // the y direction
        Amg::Vector3D surfaceYdirection(zAxis.cross(surfaceZdirection));
        // the x direction
        Amg::Vector3D surfaceXdirection(surfaceYdirection.cross(surfaceZdirection));
        // the rotation
        Amg::RotationMatrix3D surfaceRotation;
        surfaceRotation.col(0) = surfaceXdirection;
        surfaceRotation.col(1) = surfaceYdirection;
        surfaceRotation.col(2) = surfaceZdirection;
        // return it
        if (alphaZ==0.){
            return std::make_unique<Amg::Transform3D>(surfaceRotation, surfacePosition);
        }
        Amg::Transform3D nominalTransform(surfaceRotation, surfacePosition);
        return std::make_unique<Amg::Transform3D>(nominalTransform*Amg::AngleAxis3D(alphaZ,zAxis));
 
    }
 
    return std::make_unique<Amg::Transform3D>(Amg::Translation3D(x,y,z));
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Trk::EnergyLossExtrapolationValidation::execute

(

)

standard Athena-Algorithm method

Definition at line 189 of file EnergyLossExtrapolationValidation.cxx.

{
    const EventContext& ctx = Gaudi::Hive::currentContext();
    // get the overall dimensions
    if (!m_highestVolume){
        // get TrackingGeometry and highest volume
        const Trk::TrackingGeometry* trackingGeometry = m_extrapolator->trackingGeometry();
        m_highestVolume = trackingGeometry ? trackingGeometry->highestTrackingVolume() : nullptr;
        const Trk::CylinderVolumeBounds* cylBounds = m_highestVolume ?
                dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_highestVolume->volumeBounds())) : nullptr;
        // bail out
        if (!cylBounds){
            ATH_MSG_WARNING( "execute() No highest TrackingVolume / no VolumeBounds ... pretty useless!" );
            return StatusCode::SUCCESS;
        }
    }
 
 
    m_entries      = 0;
    for (size_t par=0; par<TRKEXALGS_MAXPARAMETERS; ++par) {
        // -----------> start parameters
 
        m_parameterP[par]        = 0.;
        m_energy[par]            = 0.;
        m_energyLoss[par]        = 0.;
        m_parameterX0[par]       = 0.;
        m_radius[par]            = 0.;
        m_positionX[par]         = 0.;
        m_positionY[par]         = 0.;
        m_positionZ[par]         = 0.;
        m_parameterEta[par]      = 0.;
        m_parameterPhi[par]      = 0.;
        m_parameterTheta[par]    = 0.;
        m_layer[par]             = 0;
    }
 
    // the local start parameters
    // are adopted for planar and straight line surfaces
    m_parameterPhi[0]   = M_PI * (2 * m_flatDist->shoot() - 1);
    m_parameterEta[0]   = m_minEta + m_flatDist->shoot()*(m_maxEta-m_minEta);
    m_parameterTheta[0] = 2.*std::atan(std::exp(-m_parameterEta[0]));
 
    double charge = -1.;
    m_parameterP[0] = m_momentum;
    // convert transverse momentum (pt) to momentum (p) if flag is set: p = pt/sin(theta)
    if (m_usePt)
        m_parameterP[0] /= std::sin(m_parameterTheta[0]);
    m_parameterQoverP[0] = charge/m_parameterP[0];
 
    double mass = Trk::ParticleMasses::mass[m_particleType];
 
    double energy1 = sqrt(m_parameterP[0]*m_parameterP[0] + mass*mass);
 
    double newX0 = 0;
 
    const Trk::PerigeeSurface perigeeSurface;
    // the initial perigee with random numbers
    Trk::Perigee startParameters(0, // m_parameterLoc1[0],
                                 0, // m_parameterLoc2[0],
                                 m_parameterPhi[0],
                                 m_parameterTheta[0],
                                 m_parameterQoverP[0],
                 perigeeSurface);
 
    ATH_MSG_VERBOSE( "execute() Start Parameters : " << startParameters );
    ATH_MSG_DEBUG( "execute() Start Parameters : [phi,eta] = [ " << startParameters.momentum().phi() << ", " << startParameters.eta() << " ]" );
 
    // --------------- propagate to find an intersection ---------------------
 
    // fill the TrackParameters vector with extrapolation from startParameters to dummy cylinder surface
    const Trk::TrackParameters* lastParameters = nullptr;
    const Trk::TrackParameters* newParameters = nullptr;
 
    if (!m_materialCollectionValidation) {
 
        lastParameters = m_extrapolator->extrapolate(
          ctx,
          startParameters,
          *(m_theCylinders->at(0)),
          Trk::alongMomentum,
          true,
          static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
 
    } else { // material collection validation
 
        // get the vector of TrackStateOnSurfaces back
        const std::vector<const Trk::TrackStateOnSurface*>* collectedMaterial =
                              m_extrapolator->extrapolateM(
                                ctx,
                                startParameters,
                                *(m_theCylinders->at(0)),
                                Trk::alongMomentum,
                                true,
                                static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
 
        // get the last one and clone it
        if (collectedMaterial && !collectedMaterial->empty()) {
            // get the last track state on surface & clone the destination parameters
            const Trk::TrackStateOnSurface* destinationState = collectedMaterial->back();
            lastParameters = destinationState->trackParameters() ? destinationState->trackParameters()->clone() : nullptr;
            m_collectedLayerForward += collectedMaterial->size();
            // delete the layers / cleanup
            for (const auto* tsos : *collectedMaterial) {
                newX0 += tsos->materialEffectsOnTrack() ? tsos->materialEffectsOnTrack()->thicknessInX0() : 0;
                delete tsos;
            }
            ATH_MSG_VERBOSE( "execute() newX0 = " << newX0 );
        }
    }
 
 
    for (size_t lay = 1; lay<m_cylinders+1; ++lay) {
 
        if (!m_onion) newX0 = 0;
 
        if (m_onion) {
            // safety check
            if (!lastParameters) {
                ATH_MSG_WARNING( "execute() Layer " << lay << ": start parameters for cylinder NOT found - skip event !" );
                break;
            }
            ATH_MSG_VERBOSE( "execute() Layer " << lay << ": start parameters for cylinder found: " << *lastParameters );
        }
 
        // trying to extrapolate to cylinder barrel
        newParameters = nullptr;
        if (!m_materialCollectionValidation) {
 
            newParameters = m_extrapolator->extrapolate(
              ctx,
              m_onion ? *lastParameters : startParameters,
              *(m_theCylinders->at(lay)),
              Trk::alongMomentum,
              true,
              static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
 
        } else { // material collection validation
 
            // get the vector of TrackStateOnSurfaces back
            const std::vector<const Trk::TrackStateOnSurface*>* collectedMaterial =
                                  m_extrapolator->extrapolateM(ctx,
                                                               m_onion ? *lastParameters : startParameters,
                                                               *(m_theCylinders->at(lay)),
                                                               Trk::alongMomentum,
                                                               true,
                                                               static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
 
            // get the last one and clone it
            if (collectedMaterial && !collectedMaterial->empty()){
                // get the last track state on surface & clone the destination parameters
                const Trk::TrackStateOnSurface* destinationState = collectedMaterial->back();
                newParameters = destinationState->trackParameters() ? destinationState->trackParameters()->clone() : nullptr;
                if (m_onion)
                    m_collectedLayerForward += collectedMaterial->size();
                else
                    m_collectedLayerForward  = collectedMaterial->size(); // TODO: shouldn't there be something else here?
                // delete the layers / cleanup
                for (const auto* tsos : *collectedMaterial) {
                    newX0 += tsos->materialEffectsOnTrack() ? tsos->materialEffectsOnTrack()->thicknessInX0() : 0;
                    delete tsos;
                }
                ATH_MSG_VERBOSE( "execute() newX0 = " << newX0 );
            }
        }
 
        // no intersection with cylinder barrel, now trying disc endcaps
        if (!newParameters) {
 
            if (!m_materialCollectionValidation) {
 
              newParameters = m_extrapolator->extrapolate(
                ctx,
                m_onion ? *lastParameters : startParameters,
                (m_parameterEta[0] < 0) ? *(m_theDiscs1->at(lay))
                                        : *(m_theDiscs2->at(lay)),
                Trk::alongMomentum,
                true,
                static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
 
            } else { // material collection validation
 
                // get the vector of TrackStateOnSurfaces back
                const std::vector<const Trk::TrackStateOnSurface*>* collectedMaterial =
                                      m_extrapolator->extrapolateM(ctx,
                                                                   m_onion ? *lastParameters : startParameters,
                                                                   (m_parameterEta[0] < 0) ? *(m_theDiscs1->at(lay)) : *(m_theDiscs2->at(lay)),
                                                                   Trk::alongMomentum,
                                                                   true,
                                                                   static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
 
                // get the last one and clone it
                if (collectedMaterial && !collectedMaterial->empty()){
                    // get the last track state on surface & clone the destination parameters
                    const Trk::TrackStateOnSurface* destinationState = collectedMaterial->back();
                    newParameters = destinationState->trackParameters() ? destinationState->trackParameters()->clone() : nullptr;
                    if (m_onion)
                        m_collectedLayerForward += collectedMaterial->size();
                    else
                        m_collectedLayerForward  = collectedMaterial->size(); // TODO: shouldn't there be something else here?
                    // delete the layers / cleanup
                    for (const auto* tsos : *collectedMaterial) {
                        newX0 += tsos->materialEffectsOnTrack() ? tsos->materialEffectsOnTrack()->thicknessInX0() : 0;
                        delete tsos;
                    }
                    ATH_MSG_VERBOSE( "execute() newX0 = " << newX0 );
                }
            }
        }
 
        // still no intersection
        if (!newParameters) {
            ATH_MSG_WARNING( "execute() Layer " << lay << " intersection did not work !" );
        }
 
        else if (m_highestVolume && newParameters && !(m_highestVolume->inside(newParameters->position()))) {
          ATH_MSG_WARNING( "execute() Layer " << lay << " intersection is outside the known world !" );
        }
 
        else {
 
          // get the current surface intersection position
          const Amg::Vector3D& newPosition = newParameters->position();
          ATH_MSG_VERBOSE( "execute() Track Parameters at layer " << lay << ": " << *newParameters );
          ATH_MSG_DEBUG( "execute() Track Parameters at layer " << lay << ": [r,z] = [ " << newPosition.perp() << ", " << newPosition.z() );
 
          // record the surface parameters
          ++m_triesForward;
          ++m_entries;
          m_parameterPhi[m_entries]    = newParameters->parameters()[Trk::phi];
          m_parameterEta[m_entries]    = newParameters->momentum().eta();
          m_parameterTheta[m_entries]  = newParameters->parameters()[Trk::theta];
          m_parameterP[m_entries]      = newParameters->momentum().mag();
          m_parameterX0[m_entries]     = (float)newX0;
          ATH_MSG_DEBUG( "execute() Layer " << lay << ": cumulated X0 = " << m_parameterX0[m_entries] );
 
          // get the current energy and calculate energy loss
          m_energy[m_entries] = sqrt(m_parameterP[m_entries]*m_parameterP[m_entries] + mass*mass);
          m_energyLoss[m_entries]      = energy1-m_energy[m_entries];
          ATH_MSG_DEBUG( "execute() Layer " << lay << ": cumulated Energy Loss = " << m_energyLoss[m_entries] );
 
          // record the current layer ID
          m_layer[m_entries]           = lay;
          // record the current position
          m_radius[m_entries]          = newPosition.perp();
          m_positionX[m_entries]       = newPosition.x();
          m_positionY[m_entries]       = newPosition.y();
          m_positionZ[m_entries]       = newPosition.z();
 
        }
 
        lastParameters = newParameters;
 
    }
 
 
    m_totalRecordedLayers += m_entries;
    ++m_events;
    // increase m_entries once more before the fill (to account for the "start layer" at index 0 with initial track parameters)
    ++m_entries;
 
    // fill the event tree
    if (m_validationTree)
      m_validationTree->Fill();
 
    // memory cleanup
    ATH_MSG_DEBUG( "execute() deleting DataVector parameters ... " );
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode Trk::EnergyLossExtrapolationValidation::finalize

(

)

standard Athena-Algorithm method

Definition at line 162 of file EnergyLossExtrapolationValidation.cxx.

{
  // Code entered here will be executed once at the end of the program run.
  ATH_MSG_INFO( "finalize() ================== Output Statistics =========================" );
  ATH_MSG_INFO( "finalize() = Navigation : " );
  ATH_MSG_INFO( "finalize() =  - breaks fwd : " << static_cast<double>(m_breaksForward)/static_cast<double>(m_triesForward)
        << " (" << m_breaksForward << "/" << m_triesForward << ")" );
  ATH_MSG_INFO( "finalize() =  - breaks bwd : " << static_cast<double>(m_breaksBack)/static_cast<double>(m_triesBack)
        << " (" << m_breaksBack << "/" << m_triesBack << ")" );
  if (m_materialCollectionValidation){
    ATH_MSG_INFO( "finalize() = Material collection : " );
    ATH_MSG_INFO( "finalize() =  - layer collected fwd : " << m_collectedLayerForward );
    ATH_MSG_INFO( "finalize() =  - layer collected bwd : " << m_collectedLayerBack  );
  }
  ATH_MSG_INFO( "finalize() ==============================================================" );
 
  m_avgRecordedLayers = m_events ? static_cast<float>(m_totalRecordedLayers) / static_cast<float>(m_events) : 0;
  ++m_cylinders;
  if (m_validationRunTree)
    m_validationRunTree->Fill();
  --m_cylinders;
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode Trk::EnergyLossExtrapolationValidation::initialize

(

)

standard Athena-Algorithm method

Definition at line 50 of file EnergyLossExtrapolationValidation.cxx.

{
    // Code entered here will be executed once at program start.
    ATH_MSG_INFO( "initialize()" );
    ATH_MSG_DEBUG( "initialize() m_materialCollectionValidation = " << m_materialCollectionValidation );
 
    // Get Extrapolator from ToolService
    if (m_extrapolator.retrieve().isFailure()) {
        ATH_MSG_FATAL( "initialize() Could not retrieve Tool " << m_extrapolator << ". Exiting." );
        return StatusCode::FAILURE;
    }
 
    // create the new Trees
    m_validationTree = new TTree(m_validationTreeName.value().c_str(),
                     m_validationTreeDescription.value().c_str());
    m_validationRunTree = new TTree(m_validationRunTreeName.value().c_str(),
                    m_validationRunTreeDescription.value().c_str());
 
    // the branches for the parameters
    m_validationTree->Branch("Entries",    &m_entries,         "entries/i");
    m_validationTree->Branch("Energy",      m_energy,          "energy[entries]/F");
    m_validationTree->Branch("EnergyLoss",  m_energyLoss,      "eLoss[entries]/F");
    m_validationTree->Branch("tInX0",       m_parameterX0,     "tinX0[entries]/F");
    m_validationTree->Branch("Radius",      m_radius,          "radius[entries]/F");
    m_validationTree->Branch("PosX",        m_positionX,       "posX[entries]/F");
    m_validationTree->Branch("PosY",        m_positionY,       "posY[entries]/F");
    m_validationTree->Branch("PosZ",        m_positionZ,       "posZ[entries]/F");
    m_validationTree->Branch("Eta",         m_parameterEta,    "eta[entries]/F");
    m_validationTree->Branch("Phi",         m_parameterPhi,    "phi[entries]/F");
    m_validationTree->Branch("Layer",       m_layer,           "layer[entries]/i");
 
    m_validationRunTree->Branch("Layers",  &m_cylinders,       "layers/i");
    m_validationRunTree->Branch("CylR",     m_cylinderR,       "cylR[layers]/F");
    m_validationRunTree->Branch("CylZ",     m_cylinderZ,       "cylZ[layers]/F");
    m_validationRunTree->Branch("Momentum",&m_momentum,        "momentum/F");
    m_validationRunTree->Branch("UsePt",   &m_usePt,           "usePt/O");
    m_validationRunTree->Branch("MinEta",  &m_minEta,          "minEta/F");
    m_validationRunTree->Branch("MaxEta",  &m_maxEta,          "maxEta/F");
    m_validationRunTree->Branch("PDG",     &m_pdg,             "pdg/I");
  m_validationRunTree->Branch("Events",  &m_events,          "events/i");
  m_validationRunTree->Branch("AvgRecordedLayers", &m_avgRecordedLayers, "avgRecLayers/F");
 
    // now register the Trees
    SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
    if (!tHistSvc){
        ATH_MSG_ERROR( "initialize() Could not find Hist Service -> Switching ValidationMode Off !" );
        delete m_validationTree; m_validationTree = nullptr;
        delete m_validationRunTree; m_validationRunTree = nullptr;
    }
    if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()
            || (tHistSvc->regTree(m_validationRunTreeFolder, m_validationRunTree)).isFailure() ) {
        ATH_MSG_ERROR( "initialize() Could not register the validation Trees -> Switching ValidationMode Off !" );
        delete m_validationTree; m_validationTree = nullptr;
        delete m_validationRunTree; m_validationRunTree = nullptr;
    }
 
    // initialize the random number generators
    ATH_MSG_INFO( "initialize() RandomService = " << randSvc()->name() );
    m_gaussDist = new Rndm::Numbers(randSvc(), Rndm::Gauss(0.,1.));
    m_flatDist  = new Rndm::Numbers(randSvc(), Rndm::Flat(0.,1.));
 
    // initialize cylinders if they are not set in jobOptions
    double const s_cylInitR[TRKEXALGS_MAXPARAMETERS] = { 0.5, 34.5,  250,  550, 1120, 4250, 13000, 0, 0, 0 };
    double const s_cylInitZ[TRKEXALGS_MAXPARAMETERS] = { 100, 10e6,  680, 2820, 3120, 6500, 22000, 0, 0, 0 };
 
    // output of vector from jobOptions
    ATH_MSG_INFO( "initialize() cylinder dimensions vector from jobOptions :" );
    for (size_t lay=0; lay<m_cylinders+1; ++lay) {
        ATH_MSG_INFO( "initialize() m_cylinderVR[" << lay << "] = " << m_cylinderVR[lay] << "\t ... m_cylinderVZ[" << lay << "] = " << m_cylinderVZ[lay] );
    }
    // transform vector (from jobOptions) into array (for ROOT tree)
    ATH_MSG_INFO( "initialize() cylinder dimensions array for algorithm and ROOT tree :" );
    for (size_t lay=0; lay<m_cylinders+1; ++lay) {
        m_cylinderR[lay] = m_cylinderVR[lay] > 0 ? m_cylinderVR[lay] : s_cylInitR[lay];
        m_cylinderZ[lay] = m_cylinderVZ[lay] > 0 ? m_cylinderVZ[lay] : s_cylInitZ[lay];
        // in "strict onion mode", constrain m_cylinders if the values don't make sense
        if (m_onion && lay>0 && (m_cylinderR[lay] < m_cylinderR[lay-1])) {
            ATH_MSG_WARNING( "initialize() layer " << lay << "dimensions are smaller than those of layer " << lay-1 << " - constraining m_cylinders to " << lay-1 );
            ATH_MSG_INFO( "initialize() cutting off here :" );
            ATH_MSG_INFO( "initialize() m_cylinderR[" << lay << "] = " << m_cylinderR[lay] << "\t ... m_cylinderZ[" << lay << "] = " << m_cylinderZ[lay] );
            m_cylinders = lay-1;
            break;
        }
    ATH_MSG_INFO( "initialize() m_cylinderR[" << lay << "] = " << m_cylinderR[lay] << "\t ... m_cylinderZ[" << lay << "] = " << m_cylinderZ[lay] );
    }
 
    // fill data vector with cylinders once (in order not to create them every time)
    m_theCylinders = new DataVector<const Trk::CylinderSurface>();
    m_theDiscs1 = new DataVector<const Trk::DiscSurface>();
    m_theDiscs2 = new DataVector<const Trk::DiscSurface>();
    for (size_t lay=0; lay<m_cylinders+1; ++lay) {
        m_theCylinders->push_back(new Trk::CylinderSurface(Amg::Transform3D(), m_cylinderR[lay], m_cylinderZ[lay]));
          ATH_MSG_INFO( "initialize() Cylinder " << lay << ": " << *m_theCylinders->at(lay) );
      m_theDiscs1->push_back(new Trk::DiscSurface(*createTransform(0.,0.,-m_cylinderZ[lay]), 0., m_cylinderR[lay]));
      ATH_MSG_INFO( "initialize() Disc1 " << lay << ": " << *m_theDiscs1->at(lay) );
      m_theDiscs2->push_back(new Trk::DiscSurface(*createTransform(0.,0., m_cylinderZ[lay]), 0., m_cylinderR[lay]));
      ATH_MSG_INFO( "initialize() Disc2 " << lay << ": " << *m_theDiscs2->at(lay) );
    }
 
    if      (m_particleType==0) m_pdg = 999; // geantino
    else if (m_particleType==1) m_pdg =  11; // electron
    else if (m_particleType==2) m_pdg =  13; // muon-
    else if (m_particleType==3) m_pdg = 211; // pion+
    else if (m_particleType==4) m_pdg = 321; // kaon+
    ATH_MSG_INFO( "initialize() ParticleType = " << m_particleType << " ... PDG = " << m_pdg );
 
    ATH_MSG_INFO( "initialize() successful" );
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_avgRecordedLayers

float Trk::EnergyLossExtrapolationValidation::m_avgRecordedLayers = 0

private

average recorded layers per event

Definition at line 138 of file EnergyLossExtrapolationValidation.h.

m_breaksBack

size_t Trk::EnergyLossExtrapolationValidation::m_breaksBack = 0

private

extrapolation breaks backward

Definition at line 164 of file EnergyLossExtrapolationValidation.h.

m_breaksForward

size_t Trk::EnergyLossExtrapolationValidation::m_breaksForward = 0

private

extrapolation breaks forward

Definition at line 162 of file EnergyLossExtrapolationValidation.h.

m_collectedLayerBack

size_t Trk::EnergyLossExtrapolationValidation::m_collectedLayerBack = 0

private

collected material layers backward

Definition at line 167 of file EnergyLossExtrapolationValidation.h.

m_collectedLayerForward

size_t Trk::EnergyLossExtrapolationValidation::m_collectedLayerForward = 0

private

collected material layers forward

Definition at line 166 of file EnergyLossExtrapolationValidation.h.

m_cylinderR

float Trk::EnergyLossExtrapolationValidation::m_cylinderR[TRKEXALGS_MAXPARAMETERS] {}

private

radius of cylinder layers (for ROOT tree)

Definition at line 171 of file EnergyLossExtrapolationValidation.h.

{};   

m_cylinders

UnsignedIntegerProperty Trk::EnergyLossExtrapolationValidation::m_cylinders

private

Initial value:

{this, "ValidationCylinders", 6,
    "number of cylinder layers"}

Definition at line 125 of file EnergyLossExtrapolationValidation.h.

                                         {this, "ValidationCylinders", 6,
    "number of cylinder layers"};

m_cylinderVR

FloatArrayProperty Trk::EnergyLossExtrapolationValidation::m_cylinderVR

private

Initial value:

{this, "ValidationCylinderR", {},
    "radius of cylinder layers"}

Definition at line 176 of file EnergyLossExtrapolationValidation.h.

                                     {this, "ValidationCylinderR", {},
    "radius of cylinder layers"};

m_cylinderVZ

FloatArrayProperty Trk::EnergyLossExtrapolationValidation::m_cylinderVZ

private

Initial value:

{this, "ValidationCylinderZ", {},
    "length of cylinder layers"}

Definition at line 178 of file EnergyLossExtrapolationValidation.h.

                                     {this, "ValidationCylinderZ", {},
    "length of cylinder layers"};

m_cylinderZ

float Trk::EnergyLossExtrapolationValidation::m_cylinderZ[TRKEXALGS_MAXPARAMETERS] {}

private

length of cylinder layers (for ROOT tree)

Definition at line 172 of file EnergyLossExtrapolationValidation.h.

{};   

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_energy

float Trk::EnergyLossExtrapolationValidation::m_energy[TRKEXALGS_MAXPARAMETERS] {}

private

energy

Definition at line 146 of file EnergyLossExtrapolationValidation.h.

{};           

m_energyLoss

float Trk::EnergyLossExtrapolationValidation::m_energyLoss[TRKEXALGS_MAXPARAMETERS] {}

private

energy loss

Definition at line 147 of file EnergyLossExtrapolationValidation.h.

{};       

m_entries

size_t Trk::EnergyLossExtrapolationValidation::m_entries = 0

private

effective number of used entries (recorded layers) in this event

Definition at line 145 of file EnergyLossExtrapolationValidation.h.

m_events

size_t Trk::EnergyLossExtrapolationValidation::m_events = 0

private

total number of recorded events

Definition at line 136 of file EnergyLossExtrapolationValidation.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_extrapolator

ToolHandle<IExtrapolator> Trk::EnergyLossExtrapolationValidation::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}

private

The Extrapolator to be retrieved.

Definition at line 90 of file EnergyLossExtrapolationValidation.h.

{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};

m_flatDist

Rndm::Numbers* Trk::EnergyLossExtrapolationValidation::m_flatDist = nullptr

private

Definition at line 95 of file EnergyLossExtrapolationValidation.h.

m_gaussDist

Rndm::Numbers* Trk::EnergyLossExtrapolationValidation::m_gaussDist = nullptr

private

Random Number setup.

Definition at line 94 of file EnergyLossExtrapolationValidation.h.

m_highestVolume

const TrackingVolume* Trk::EnergyLossExtrapolationValidation::m_highestVolume = nullptr

private

the highest volume

Definition at line 87 of file EnergyLossExtrapolationValidation.h.

m_layer

size_t Trk::EnergyLossExtrapolationValidation::m_layer[TRKEXALGS_MAXPARAMETERS] {}

private

layer id

Definition at line 158 of file EnergyLossExtrapolationValidation.h.

{};            

m_materialCollectionValidation

BooleanProperty Trk::EnergyLossExtrapolationValidation::m_materialCollectionValidation

private

Initial value:

{this, "UseMaterialCollection", false,
     "use the material collection (extrapolateM)"}

Definition at line 97 of file EnergyLossExtrapolationValidation.h.

    {this, "UseMaterialCollection", false,
     "use the material collection (extrapolateM)"};

m_maxEta

FloatProperty Trk::EnergyLossExtrapolationValidation::m_maxEta {this, "StartPerigeeMaxEta", 3.}

private

Definition at line 134 of file EnergyLossExtrapolationValidation.h.

{this, "StartPerigeeMaxEta", 3.};

m_minEta

FloatProperty Trk::EnergyLossExtrapolationValidation::m_minEta {this, "StartPerigeeMinEta", -3.}

private

Definition at line 133 of file EnergyLossExtrapolationValidation.h.

{this, "StartPerigeeMinEta", -3.};

m_momentum

FloatProperty Trk::EnergyLossExtrapolationValidation::m_momentum

private

Initial value:

{this, "StartPerigeeMomentum",
    10.*Gaudi::Units::GeV}

Definition at line 129 of file EnergyLossExtrapolationValidation.h.

                              {this, "StartPerigeeMomentum",
    10.*Gaudi::Units::GeV};

m_onion

BooleanProperty Trk::EnergyLossExtrapolationValidation::m_onion

private

Initial value:

{this, "StrictOnionMode", true,
    "strictly hierarchical ordering (onion-like)"}

Definition at line 127 of file EnergyLossExtrapolationValidation.h.

                             {this, "StrictOnionMode", true,
    "strictly hierarchical ordering (onion-like)"};

m_parameterEta

float Trk::EnergyLossExtrapolationValidation::m_parameterEta[TRKEXALGS_MAXPARAMETERS] {}

private

eta

Definition at line 154 of file EnergyLossExtrapolationValidation.h.

{};     

m_parameterP

float Trk::EnergyLossExtrapolationValidation::m_parameterP[TRKEXALGS_MAXPARAMETERS] {}

private

P.

Definition at line 157 of file EnergyLossExtrapolationValidation.h.

{};       

m_parameterPhi

float Trk::EnergyLossExtrapolationValidation::m_parameterPhi[TRKEXALGS_MAXPARAMETERS] {}

private

phi

Definition at line 153 of file EnergyLossExtrapolationValidation.h.

{};     

m_parameterQoverP

float Trk::EnergyLossExtrapolationValidation::m_parameterQoverP[TRKEXALGS_MAXPARAMETERS] {}

private

qOverP

Definition at line 156 of file EnergyLossExtrapolationValidation.h.

{};  

m_parameterTheta

float Trk::EnergyLossExtrapolationValidation::m_parameterTheta[TRKEXALGS_MAXPARAMETERS] {}

private

theta

Definition at line 155 of file EnergyLossExtrapolationValidation.h.

{};   

m_parameterX0

float Trk::EnergyLossExtrapolationValidation::m_parameterX0[TRKEXALGS_MAXPARAMETERS] {}

private

thickness in X0

Definition at line 148 of file EnergyLossExtrapolationValidation.h.

{};      

m_particleType

IntegerProperty Trk::EnergyLossExtrapolationValidation::m_particleType

private

Initial value:

{this, "ParticleType", 2,
    "the particle type for the extrapolation"}

Definition at line 141 of file EnergyLossExtrapolationValidation.h.

                                    {this, "ParticleType", 2,
    "the particle type for the extrapolation"};

m_pdg

int Trk::EnergyLossExtrapolationValidation::m_pdg = 0

private

PDG code corresponding to m_particleType.

Definition at line 140 of file EnergyLossExtrapolationValidation.h.

m_positionX

float Trk::EnergyLossExtrapolationValidation::m_positionX[TRKEXALGS_MAXPARAMETERS] {}

private

position X

Definition at line 150 of file EnergyLossExtrapolationValidation.h.

{};        

m_positionY

float Trk::EnergyLossExtrapolationValidation::m_positionY[TRKEXALGS_MAXPARAMETERS] {}

private

position Y

Definition at line 151 of file EnergyLossExtrapolationValidation.h.

{};        

m_positionZ

float Trk::EnergyLossExtrapolationValidation::m_positionZ[TRKEXALGS_MAXPARAMETERS] {}

private

position Z

Definition at line 152 of file EnergyLossExtrapolationValidation.h.

{};        

m_radius

float Trk::EnergyLossExtrapolationValidation::m_radius[TRKEXALGS_MAXPARAMETERS] {}

private

position radius

Definition at line 149 of file EnergyLossExtrapolationValidation.h.

{};           

m_theCylinders

DataVector<const Trk::CylinderSurface>* Trk::EnergyLossExtrapolationValidation::m_theCylinders = nullptr

private

Definition at line 173 of file EnergyLossExtrapolationValidation.h.

m_theDiscs1

DataVector<const Trk::DiscSurface>* Trk::EnergyLossExtrapolationValidation::m_theDiscs1 = nullptr

private

Definition at line 174 of file EnergyLossExtrapolationValidation.h.

m_theDiscs2

DataVector<const Trk::DiscSurface>* Trk::EnergyLossExtrapolationValidation::m_theDiscs2 = nullptr

private

Definition at line 175 of file EnergyLossExtrapolationValidation.h.

m_totalRecordedLayers

int Trk::EnergyLossExtrapolationValidation::m_totalRecordedLayers = 0

private

total number of recorded layers

Definition at line 137 of file EnergyLossExtrapolationValidation.h.

m_triesBack

size_t Trk::EnergyLossExtrapolationValidation::m_triesBack = 0

private

extrapolation events backward

Definition at line 163 of file EnergyLossExtrapolationValidation.h.

m_triesForward

size_t Trk::EnergyLossExtrapolationValidation::m_triesForward = 0

private

extrapolation events forward

Definition at line 161 of file EnergyLossExtrapolationValidation.h.

m_usePt

BooleanProperty Trk::EnergyLossExtrapolationValidation::m_usePt

private

Initial value:

{this, "StartPerigeeUsePt", true,
    "use pt instead of p"}

Definition at line 131 of file EnergyLossExtrapolationValidation.h.

                             {this, "StartPerigeeUsePt", true,
    "use pt instead of p"};

m_validationRunTree

TTree* Trk::EnergyLossExtrapolationValidation::m_validationRunTree = nullptr

private

Root Run Stats Tree.

Definition at line 102 of file EnergyLossExtrapolationValidation.h.

m_validationRunTreeDescription

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationRunTreeDescription

private

Initial value:

{this, "ValidationRunTreeDescription",
     "Run stats of the EnergyLossExtrapolationValidation Algorithm",
     "run stats tree description - second argument in TTree"}

Definition at line 120 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationRunTreeDescription",
     "Run stats of the EnergyLossExtrapolationValidation Algorithm",
     "run stats tree description - second argument in TTree"};

m_validationRunTreeFolder

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationRunTreeFolder

private

Initial value:

{this, "ValidationRunTreeFolder", "/val/RunTreeTG",
     "stream/folder to for the second TTree to be written out"}

Definition at line 114 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationRunTreeFolder", "/val/RunTreeTG",
     "stream/folder to for the second TTree to be written out"};

m_validationRunTreeName

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationRunTreeName

private

Initial value:

{this, "ValidationRunTreeName", "RunTreeTG",
     "run stats tree name - to be accessed by this from root"}

Definition at line 117 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationRunTreeName", "RunTreeTG",
     "run stats tree name - to be accessed by this from root"};

m_validationTree

TTree* Trk::EnergyLossExtrapolationValidation::m_validationTree = nullptr

private

Root Validation Tree.

Definition at line 101 of file EnergyLossExtrapolationValidation.h.

m_validationTreeDescription

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationTreeDescription

private

Initial value:

{this, "ValidationTreeDescription",
     "Event output of the EnergyLossExtrapolationValidation Algorithm",
     "validation tree description - second argument in TTree"}

Definition at line 110 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationTreeDescription",
     "Event output of the EnergyLossExtrapolationValidation Algorithm",
     "validation tree description - second argument in TTree"};

m_validationTreeFolder

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationTreeFolder

private

Initial value:

{this, "ValidationTreeFolder", "/val/EventTreeTG",
     "stream/folder to for the TTree to be written out"}

Definition at line 104 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationTreeFolder", "/val/EventTreeTG",
     "stream/folder to for the TTree to be written out"};

m_validationTreeName

StringProperty Trk::EnergyLossExtrapolationValidation::m_validationTreeName

private

Initial value:

{this, "ValidationTreeName", "EventTreeTG",
     "validation tree name - to be accessed by this from root"}

Definition at line 107 of file EnergyLossExtrapolationValidation.h.

    {this, "ValidationTreeName", "EventTreeTG",
     "validation tree name - to be accessed by this from root"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• EnergyLossExtrapolationValidation.h
• EnergyLossExtrapolationValidation.cxx