Trk::EnergyLossExtrapolationValidation Class Reference

#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. More...
	~EnergyLossExtrapolationValidation ()
	Default Destructor. More...
StatusCode	initialize ()
	standard Athena-Algorithm method More...
StatusCode	execute ()
	standard Athena-Algorithm method More...
StatusCode	finalize ()
	standard Athena-Algorithm method More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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 More...

Private Attributes
const TrackingVolume *	m_highestVolume
	the highest volume More...
ToolHandle< IExtrapolator >	m_extrapolator
	The Extrapolator to be retrieved. More...
Rndm::Numbers *	m_gaussDist
	Random Number setup. More...
Rndm::Numbers *	m_flatDist
bool	m_materialCollectionValidation
	use the material collection (extrapolateM) More...
TTree *	m_validationTree
	Root Validation Tree. More...
TTree *	m_validationRunTree
	Root Run Stats Tree. More...
std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out More...
std::string	m_validationTreeName
	validation tree name - to be accessed by this from root More...
std::string	m_validationTreeDescription
	validation tree description - second argument in TTree More...
std::string	m_validationRunTreeFolder
	stream/folder to for the second TTree to be written out More...
std::string	m_validationRunTreeName
	run stats tree name - to be accessed by this from root More...
std::string	m_validationRunTreeDescription
	run stats tree description - second argument in TTree More...
double	m_maximumR
	maximum R of the highest More...
double	m_maximumZ
	maximum halfZ of the highest tracking volume More...
size_t	m_cylinders
	number of cylinder layers More...
bool	m_onion
	strictly hierarchical ordering (onion-like) More...
float	m_momentum
	momentum value More...
bool	m_usePt
	use pt instead of p More...
float	m_minEta
	Minimal eta value. More...
float	m_maxEta
	Maximal eta value. More...
size_t	m_events
	total number of recorded events More...
int	m_totalRecordedLayers
	total number of recorded layers More...
float	m_avgRecordedLayers
	average recorded layers per event More...
int	m_pdg
	PDG code corresponding to m_particleType. More...
int	m_particleType
	the particle type for the extrapolation More...
size_t	m_entries
	effective number of used entries (recorded layers) in this event More...
float	m_energy [TRKEXALGS_MAXPARAMETERS]
	energy More...
float	m_energyLoss [TRKEXALGS_MAXPARAMETERS]
	energy loss More...
float	m_parameterX0 [TRKEXALGS_MAXPARAMETERS]
	thickness in X0 More...
float	m_radius [TRKEXALGS_MAXPARAMETERS]
	position radius More...
float	m_positionX [TRKEXALGS_MAXPARAMETERS]
	position X More...
float	m_positionY [TRKEXALGS_MAXPARAMETERS]
	position Y More...
float	m_positionZ [TRKEXALGS_MAXPARAMETERS]
	position Z More...
float	m_parameterPhi [TRKEXALGS_MAXPARAMETERS]
	phi More...
float	m_parameterEta [TRKEXALGS_MAXPARAMETERS]
	eta More...
float	m_parameterTheta [TRKEXALGS_MAXPARAMETERS]
	theta More...
float	m_parameterQoverP [TRKEXALGS_MAXPARAMETERS]
	qOverP More...
float	m_parameterP [TRKEXALGS_MAXPARAMETERS]
	P. More...
size_t	m_layer [TRKEXALGS_MAXPARAMETERS]
	layer id More...
size_t	m_triesForward
	extrapolation events forward More...
size_t	m_breaksForward
	extrapolation breaks forward More...
size_t	m_triesBack
	extrapolation events backward More...
size_t	m_breaksBack
	extrapolation breaks backward More...
size_t	m_collectedLayerForward
	collected material layers forward More...
size_t	m_collectedLayerBack
	collected material layers backward More...
float	m_cylinderR [TRKEXALGS_MAXPARAMETERS]
	radius of cylinder layers (for ROOT tree) More...
float	m_cylinderZ [TRKEXALGS_MAXPARAMETERS]
	length of cylinder layers (for ROOT tree) More...
DataVector< const Trk::CylinderSurface > *	m_theCylinders
DataVector< const Trk::DiscSurface > *	m_theDiscs1
DataVector< const Trk::DiscSurface > *	m_theDiscs2
std::vector< float >	m_cylinderVR
	radius of cylinder layers (vector from jobOptions) More...
std::vector< float >	m_cylinderVZ
	length of cylinder layers (vector from jobOptions) More...
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
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 60 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 33 of file EnergyLossExtrapolationValidation.cxx.

: AthAlgorithm(name,pSvcLocator),
  m_highestVolume(nullptr),
  m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
  m_gaussDist(nullptr),
  m_flatDist(nullptr),
  m_materialCollectionValidation(false),
  m_validationTree(nullptr),
  m_validationRunTree(nullptr),
  m_validationTreeFolder("/val/EventTreeTG"),
  m_validationTreeName("EventTreeTG"),
  m_validationTreeDescription("Event output of the EnergyLossExtrapolationValidation Algorithm"),
  m_validationRunTreeFolder("/val/RunTreeTG"),
  m_validationRunTreeName("RunTreeTG"),
  m_validationRunTreeDescription("Run stats of the EnergyLossExtrapolationValidation Algorithm"),
  m_maximumR(0.),
  m_maximumZ(0.),
  m_cylinders(6),
  m_onion(true),
  m_momentum(10.*Gaudi::Units::GeV),
  m_usePt(true),
  m_minEta(-3.),
  m_maxEta(3.),
  m_events(0),
  m_totalRecordedLayers(0),
  m_avgRecordedLayers(0.),
  m_pdg(0),
  m_particleType(2),
  m_entries(0),
  m_energy{},         
    m_energyLoss{},     
    m_parameterX0{},    
    m_radius{},         
    m_positionX{},      
    m_positionY{},      
    m_positionZ{},      
    m_parameterPhi{},   
    m_parameterEta{},   
    m_parameterTheta{}, 
    m_parameterQoverP{},
    m_parameterP{},     
    m_layer{},          
  m_triesForward(0),
  m_breaksForward(0),
  m_triesBack(0),
  m_breaksBack(0),
  m_collectedLayerForward(0),
  m_collectedLayerBack(0),
  m_cylinderR{},
  m_cylinderZ{},
  m_theCylinders(nullptr),
  m_theDiscs1(nullptr),
  m_theDiscs2(nullptr)
{
    // used algorithms and alg tools
    declareProperty("Extrapolator"              , m_extrapolator);
    declareProperty("UseMaterialCollection"     , m_materialCollectionValidation);
    // TTree handling
    declareProperty("ValidationTreeName"        , m_validationTreeName);
    declareProperty("ValidationRunTreeName"     , m_validationRunTreeName);
    declareProperty("ValidationTreeDescription" , m_validationTreeDescription);
    declareProperty("ValidationRunTreeDescription" , m_validationRunTreeDescription);
    declareProperty("ValidationTreeFolder"      , m_validationTreeFolder);
    declareProperty("ValidationRunTreeFolder"   , m_validationRunTreeFolder);
 
    declareProperty("StartPerigeeMinEta"        , m_minEta);
    declareProperty("StartPerigeeMaxEta"        , m_maxEta);
    declareProperty("StartPerigeeUsePt"         , m_usePt);
    declareProperty("StartPerigeeMomentum"      , m_momentum);
 
    declareProperty("ValidationCylinders"       , m_cylinders);
    declareProperty("ValidationCylinderR"       , m_cylinderVR);
    declareProperty("ValidationCylinderZ"       , m_cylinderVZ);
    declareProperty("StrictOnionMode"           , m_onion);
 
    declareProperty("ParticleType"              , m_particleType);
 
}

~EnergyLossExtrapolationValidation()

Trk::EnergyLossExtrapolationValidation::~EnergyLossExtrapolationValidation

(

)

Default Destructor.

Definition at line 114 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 551 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Trk::EnergyLossExtrapolationValidation::execute

(

)

standard Athena-Algorithm method

Definition at line 270 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;
        }
        // get the numbers
        m_maximumR = cylBounds->outerRadius();
        m_maximumZ = cylBounds->halflengthZ();
    }
 
 
    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_parameterQoverP[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,
          (Trk::ParticleHypothesis)m_particleType).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,
                                (Trk::ParticleHypothesis)m_particleType);
 
        // 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
            std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter    =  collectedMaterial->begin();
            std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIterEnd =  collectedMaterial->end();
            for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
                newX0 += (*tsosIter)->materialEffectsOnTrack() ? (*tsosIter)->materialEffectsOnTrack()->thicknessInX0() : 0;
                delete(*tsosIter);
            }
            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,
              (Trk::ParticleHypothesis)m_particleType).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,
                                                               (Trk::ParticleHypothesis)m_particleType);
 
            // 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
                std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter    =  collectedMaterial->begin();
                std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIterEnd =  collectedMaterial->end();
                for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
                    newX0 += (*tsosIter)->materialEffectsOnTrack() ? (*tsosIter)->materialEffectsOnTrack()->thicknessInX0() : 0;
                    delete(*tsosIter);
                }
                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,
                (Trk::ParticleHypothesis)m_particleType).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,
                                                                   (Trk::ParticleHypothesis)m_particleType);
 
                // 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
                    std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIter    =  collectedMaterial->begin();
                    std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosIterEnd =  collectedMaterial->end();
                    for ( ; tsosIter != tsosIterEnd; ++tsosIter) {
                        newX0 += (*tsosIter)->materialEffectsOnTrack() ? (*tsosIter)->materialEffectsOnTrack()->thicknessInX0() : 0;
                        delete(*tsosIter);
                    }
                    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 243 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 : " << double(m_breaksForward)/double(m_triesForward)
            << " (" << m_breaksForward << "/" << m_triesForward << ")" );
    ATH_MSG_INFO( "finalize() =  - breaks bwd : " << double(m_breaksBack)/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 ? (float)m_totalRecordedLayers / (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

sroe; original line was: if (m_onion && lay>0 && (m_cylinderR[lay] < m_cylinderR[lay-1] || m_cylinderR[lay] < m_cylinderR[lay-1])) { but the two sides of the 'or' are equal

Definition at line 129 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.c_str(), m_validationTreeDescription.c_str());
    m_validationRunTree = new TTree(m_validationRunTreeName.c_str(), m_validationRunTreeDescription.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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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, PyAthena::Alg, and AthHistogramAlgorithm.

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

private

average recorded layers per event

Definition at line 120 of file EnergyLossExtrapolationValidation.h.

m_breaksBack

size_t Trk::EnergyLossExtrapolationValidation::m_breaksBack

private

extrapolation breaks backward

Definition at line 147 of file EnergyLossExtrapolationValidation.h.

m_breaksForward

size_t Trk::EnergyLossExtrapolationValidation::m_breaksForward

private

extrapolation breaks forward

Definition at line 145 of file EnergyLossExtrapolationValidation.h.

m_collectedLayerBack

size_t Trk::EnergyLossExtrapolationValidation::m_collectedLayerBack

private

collected material layers backward

Definition at line 150 of file EnergyLossExtrapolationValidation.h.

m_collectedLayerForward

size_t Trk::EnergyLossExtrapolationValidation::m_collectedLayerForward

private

collected material layers forward

Definition at line 149 of file EnergyLossExtrapolationValidation.h.

m_cylinderR

float Trk::EnergyLossExtrapolationValidation::m_cylinderR[TRKEXALGS_MAXPARAMETERS]

private

radius of cylinder layers (for ROOT tree)

Definition at line 154 of file EnergyLossExtrapolationValidation.h.

m_cylinders

size_t Trk::EnergyLossExtrapolationValidation::m_cylinders

private

number of cylinder layers

Definition at line 111 of file EnergyLossExtrapolationValidation.h.

m_cylinderVR

std::vector<float> Trk::EnergyLossExtrapolationValidation::m_cylinderVR

private

radius of cylinder layers (vector from jobOptions)

Definition at line 159 of file EnergyLossExtrapolationValidation.h.

m_cylinderVZ

std::vector<float> Trk::EnergyLossExtrapolationValidation::m_cylinderVZ

private

length of cylinder layers (vector from jobOptions)

Definition at line 160 of file EnergyLossExtrapolationValidation.h.

m_cylinderZ

float Trk::EnergyLossExtrapolationValidation::m_cylinderZ[TRKEXALGS_MAXPARAMETERS]

private

length of cylinder layers (for ROOT tree)

Definition at line 155 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 127 of file EnergyLossExtrapolationValidation.h.

m_energyLoss

float Trk::EnergyLossExtrapolationValidation::m_energyLoss[TRKEXALGS_MAXPARAMETERS]

private

energy loss

Definition at line 128 of file EnergyLossExtrapolationValidation.h.

m_entries

size_t Trk::EnergyLossExtrapolationValidation::m_entries

private

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

Definition at line 126 of file EnergyLossExtrapolationValidation.h.

m_events

size_t Trk::EnergyLossExtrapolationValidation::m_events

private

total number of recorded events

Definition at line 118 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

private

The Extrapolator to be retrieved.

Definition at line 89 of file EnergyLossExtrapolationValidation.h.

m_flatDist

Rndm::Numbers* Trk::EnergyLossExtrapolationValidation::m_flatDist

private

Definition at line 93 of file EnergyLossExtrapolationValidation.h.

m_gaussDist

Rndm::Numbers* Trk::EnergyLossExtrapolationValidation::m_gaussDist

private

Random Number setup.

Definition at line 92 of file EnergyLossExtrapolationValidation.h.

m_highestVolume

const TrackingVolume* Trk::EnergyLossExtrapolationValidation::m_highestVolume

private

the highest volume

Definition at line 86 of file EnergyLossExtrapolationValidation.h.

m_layer

size_t Trk::EnergyLossExtrapolationValidation::m_layer[TRKEXALGS_MAXPARAMETERS]

private

layer id

Definition at line 141 of file EnergyLossExtrapolationValidation.h.

m_materialCollectionValidation

bool Trk::EnergyLossExtrapolationValidation::m_materialCollectionValidation

private

use the material collection (extrapolateM)

Definition at line 95 of file EnergyLossExtrapolationValidation.h.

m_maxEta

float Trk::EnergyLossExtrapolationValidation::m_maxEta

private

Maximal eta value.

Definition at line 116 of file EnergyLossExtrapolationValidation.h.

m_maximumR

double Trk::EnergyLossExtrapolationValidation::m_maximumR

private

maximum R of the highest

Definition at line 107 of file EnergyLossExtrapolationValidation.h.

m_maximumZ

double Trk::EnergyLossExtrapolationValidation::m_maximumZ

private

maximum halfZ of the highest tracking volume

Definition at line 108 of file EnergyLossExtrapolationValidation.h.

m_minEta

float Trk::EnergyLossExtrapolationValidation::m_minEta

private

Minimal eta value.

Definition at line 115 of file EnergyLossExtrapolationValidation.h.

m_momentum

float Trk::EnergyLossExtrapolationValidation::m_momentum

private

momentum value

Definition at line 113 of file EnergyLossExtrapolationValidation.h.

m_onion

bool Trk::EnergyLossExtrapolationValidation::m_onion

private

strictly hierarchical ordering (onion-like)

Definition at line 112 of file EnergyLossExtrapolationValidation.h.

m_parameterEta

float Trk::EnergyLossExtrapolationValidation::m_parameterEta[TRKEXALGS_MAXPARAMETERS]

private

eta

Definition at line 137 of file EnergyLossExtrapolationValidation.h.

m_parameterP

float Trk::EnergyLossExtrapolationValidation::m_parameterP[TRKEXALGS_MAXPARAMETERS]

private

P.

Definition at line 140 of file EnergyLossExtrapolationValidation.h.

m_parameterPhi

float Trk::EnergyLossExtrapolationValidation::m_parameterPhi[TRKEXALGS_MAXPARAMETERS]

private

phi

Definition at line 136 of file EnergyLossExtrapolationValidation.h.

m_parameterQoverP

float Trk::EnergyLossExtrapolationValidation::m_parameterQoverP[TRKEXALGS_MAXPARAMETERS]

private

qOverP

Definition at line 139 of file EnergyLossExtrapolationValidation.h.

m_parameterTheta

float Trk::EnergyLossExtrapolationValidation::m_parameterTheta[TRKEXALGS_MAXPARAMETERS]

private

theta

Definition at line 138 of file EnergyLossExtrapolationValidation.h.

m_parameterX0

float Trk::EnergyLossExtrapolationValidation::m_parameterX0[TRKEXALGS_MAXPARAMETERS]

private

thickness in X0

Definition at line 129 of file EnergyLossExtrapolationValidation.h.

m_particleType

int Trk::EnergyLossExtrapolationValidation::m_particleType

private

the particle type for the extrapolation

Definition at line 123 of file EnergyLossExtrapolationValidation.h.

m_pdg

int Trk::EnergyLossExtrapolationValidation::m_pdg

private

PDG code corresponding to m_particleType.

Definition at line 122 of file EnergyLossExtrapolationValidation.h.

m_positionX

float Trk::EnergyLossExtrapolationValidation::m_positionX[TRKEXALGS_MAXPARAMETERS]

private

position X

Definition at line 133 of file EnergyLossExtrapolationValidation.h.

m_positionY

float Trk::EnergyLossExtrapolationValidation::m_positionY[TRKEXALGS_MAXPARAMETERS]

private

position Y

Definition at line 134 of file EnergyLossExtrapolationValidation.h.

m_positionZ

float Trk::EnergyLossExtrapolationValidation::m_positionZ[TRKEXALGS_MAXPARAMETERS]

private

position Z

Definition at line 135 of file EnergyLossExtrapolationValidation.h.

m_radius

float Trk::EnergyLossExtrapolationValidation::m_radius[TRKEXALGS_MAXPARAMETERS]

private

position radius

Definition at line 130 of file EnergyLossExtrapolationValidation.h.

m_theCylinders

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

private

Definition at line 156 of file EnergyLossExtrapolationValidation.h.

m_theDiscs1

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

private

Definition at line 157 of file EnergyLossExtrapolationValidation.h.

m_theDiscs2

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

private

Definition at line 158 of file EnergyLossExtrapolationValidation.h.

m_totalRecordedLayers

int Trk::EnergyLossExtrapolationValidation::m_totalRecordedLayers

private

total number of recorded layers

Definition at line 119 of file EnergyLossExtrapolationValidation.h.

m_triesBack

size_t Trk::EnergyLossExtrapolationValidation::m_triesBack

private

extrapolation events backward

Definition at line 146 of file EnergyLossExtrapolationValidation.h.

m_triesForward

size_t Trk::EnergyLossExtrapolationValidation::m_triesForward

private

extrapolation events forward

Definition at line 144 of file EnergyLossExtrapolationValidation.h.

m_usePt

bool Trk::EnergyLossExtrapolationValidation::m_usePt

private

use pt instead of p

Definition at line 114 of file EnergyLossExtrapolationValidation.h.

m_validationRunTree

TTree* Trk::EnergyLossExtrapolationValidation::m_validationRunTree

private

Root Run Stats Tree.

Definition at line 98 of file EnergyLossExtrapolationValidation.h.

m_validationRunTreeDescription

std::string Trk::EnergyLossExtrapolationValidation::m_validationRunTreeDescription

private

run stats tree description - second argument in TTree

Definition at line 105 of file EnergyLossExtrapolationValidation.h.

m_validationRunTreeFolder

std::string Trk::EnergyLossExtrapolationValidation::m_validationRunTreeFolder

private

stream/folder to for the second TTree to be written out

Definition at line 103 of file EnergyLossExtrapolationValidation.h.

m_validationRunTreeName

std::string Trk::EnergyLossExtrapolationValidation::m_validationRunTreeName

private

run stats tree name - to be accessed by this from root

Definition at line 104 of file EnergyLossExtrapolationValidation.h.

m_validationTree

TTree* Trk::EnergyLossExtrapolationValidation::m_validationTree

private

Root Validation Tree.

Definition at line 97 of file EnergyLossExtrapolationValidation.h.

m_validationTreeDescription

std::string Trk::EnergyLossExtrapolationValidation::m_validationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 102 of file EnergyLossExtrapolationValidation.h.

m_validationTreeFolder

std::string Trk::EnergyLossExtrapolationValidation::m_validationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 100 of file EnergyLossExtrapolationValidation.h.

m_validationTreeName

std::string Trk::EnergyLossExtrapolationValidation::m_validationTreeName

private

validation tree name - to be accessed by this from root

Definition at line 101 of file EnergyLossExtrapolationValidation.h.

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