Trk::LayerMaterialRecord Class Reference

Helper Class to record the material during the GeantinoNtupleMappingProcess. More...

#include <LayerMaterialRecord.h>

Collaboration diagram for Trk::LayerMaterialRecord:

Public Member Functions
	LayerMaterialRecord ()
	Default Constructor.
	LayerMaterialRecord (double tlayer, const BinUtility *binutils, double minFraction, MaterialAssociationType assoc=EffectiveNumAtoms)
	Constructor.
	LayerMaterialRecord (const LayerMaterialRecord &lmr)
	Constructor.
	~LayerMaterialRecord ()
	Destructor.
LayerMaterialRecord &	operator= (const LayerMaterialRecord &lmr)
	Assignment operator.
void	associateGeantinoHit (const Amg::Vector3D &pos, double s, const Trk::Material &mat)
	adding the information about the Geantino hit
void	associateEmptyHit (const Amg::Vector3D &pos)
	adding the information about an empty hit scaling- particle crossed layer, but no mapping information
AssociatedMaterial *	finalizeEvent (const Trk::Layer &lay, bool fullHit=false)
	finalize the Event
void	finalizeRun (bool recordElements=true)
	finalize the Run
const MaterialPropertiesMatrix &	associatedLayerMaterial () const
	return method for the LayerMaterial
const std::vector< std::vector< unsigned int > > &	binCounts () const
	return method for the events used for this
const Trk::BinUtility *	binUtility () const
	return the BinUtility

Private Member Functions
void	clearMaterial ()
	copy from another vector
void	copyMaterial (const MaterialPropertiesMatrix &mat)

Private Attributes
double	m_layerThickness
	record the layerThickness
BinUtility *	m_binUtility
	record the BinnedArray
int	m_bins0
	number of bins in coordinate 1
int	m_bins1
	number of bins in coordinate 2
double	m_minFraction
	minimum element fraction to be recorded
int	m_steps
Amg::Vector3D	m_pos
	event related information
bool	m_emptyHitCase
double	m_s
double	m_s_in_x0
double	m_s_in_l0
double	m_a
double	m_z
double	m_rho
std::map< unsigned int, double >	m_elements
MaterialAssociationType	m_assoc
	type of hit association
std::vector< std::vector< unsigned int > >	m_run_events
std::vector< std::vector< Amg::Vector3D > >	m_run_pos
std::vector< std::vector< double > >	m_run_s
std::vector< std::vector< double > >	m_run_s_in_x0
std::vector< std::vector< double > >	m_run_s_in_l0
std::vector< std::vector< double > >	m_run_a
std::vector< std::vector< double > >	m_run_z
std::vector< std::vector< double > >	m_run_rho
std::vector< std::vector< std::map< unsigned int, double > > >	m_run_elements
	the final material properties
MaterialPropertiesMatrix	m_associatedLayerMaterial
	clear the material -> calls delete

Detailed Description

Helper Class to record the material during the GeantinoNtupleMappingProcess.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 45 of file LayerMaterialRecord.h.

Constructor & Destructor Documentation

LayerMaterialRecord() [1/3]

Trk::LayerMaterialRecord::LayerMaterialRecord

(

)

Default Constructor.

Definition at line 22 of file LayerMaterialRecord.cxx.

    : m_layerThickness(0.),
      m_binUtility(nullptr),
      m_bins0(0),
      m_bins1(0),
      m_minFraction(0.),
      m_steps(0),
      m_pos(Amg::Vector3D(0., 0., 0.)),
      m_emptyHitCase(false),
      m_s(0.),
      m_s_in_x0(0.),
      m_s_in_l0(0.),
      m_a(0.),
      m_z(0.),
      m_rho(0.),
      m_assoc(Trk::EffectiveNumAtoms) {
  // m_pos = Amg::Vector3D(0.,0.,0.);
}

LayerMaterialRecord() [2/3]

Trk::LayerMaterialRecord::LayerMaterialRecord	(	double	tlayer,
		const BinUtility *	binutils,
		double	minFraction,
		Trk::MaterialAssociationType	assoc = EffectiveNumAtoms )

Constructor.

Definition at line 41 of file LayerMaterialRecord.cxx.

    : m_layerThickness(thickness),
      m_binUtility(binutils ? binutils->clone() : nullptr),
      m_bins0(binutils ? (binutils->max(0) + 1) : 1),
      m_bins1(binutils && binutils->dimensions() > 1 ? (binutils->max(1) + 1)
                                                     : 1),
      m_minFraction(minfraction),
      m_steps(0),
      m_pos(Amg::Vector3D(0., 0., 0.)),
      m_emptyHitCase(false),
      m_s(0.),
      m_s_in_x0(0.),
      m_s_in_l0(0.),
      m_a(0.),
      m_z(0.),
      m_rho(0.),
      m_assoc(assoc) {
  // initialize for the run
  const auto zeroedVectorDbl = std::vector<double>(m_bins0, 0.);
  const auto zeroedVectorUInt = std::vector<unsigned int>(m_bins0, 0);
  const auto zeroedVectorVector3D = std::vector<Amg::Vector3D>(m_bins0, m_pos);
  using Element_t = std::map<unsigned int, double>;
  const auto zeroedVectorElements =
      std::vector<Element_t>(m_bins0, Element_t());
  for (int ibin = 0; ibin < m_bins1; ++ibin) {
    // run-related parameters
    m_run_pos.push_back(zeroedVectorVector3D);
    m_run_events.push_back(zeroedVectorUInt);
    m_run_s.push_back(zeroedVectorDbl);
    m_run_s_in_x0.push_back(zeroedVectorDbl);
    m_run_s_in_l0.push_back(zeroedVectorDbl);
    m_run_a.push_back(zeroedVectorDbl);
    m_run_z.push_back(zeroedVectorDbl);
    m_run_rho.push_back(zeroedVectorDbl);
    m_run_elements.push_back(zeroedVectorElements);
  }
}

LayerMaterialRecord() [3/3]

Trk::LayerMaterialRecord::LayerMaterialRecord

(

const LayerMaterialRecord &

lmr

)

Constructor.

Definition at line 81 of file LayerMaterialRecord.cxx.

    : m_layerThickness(lmr.m_layerThickness),
      m_binUtility(lmr.m_binUtility ? lmr.m_binUtility->clone() : nullptr),
      m_bins0(lmr.m_bins0),
      m_bins1(lmr.m_bins1),
      m_minFraction(lmr.m_minFraction),
      m_steps(lmr.m_steps),
      m_pos(Amg::Vector3D(0., 0., 0.)),
      m_emptyHitCase(lmr.m_emptyHitCase),
      m_s(lmr.m_s),
      m_s_in_x0(lmr.m_s_in_x0),
      m_s_in_l0(lmr.m_s_in_l0),
      m_a(lmr.m_a),
      m_z(lmr.m_z),
      m_rho(lmr.m_rho),
      m_elements(lmr.m_elements),
      m_assoc(lmr.m_assoc),
      m_run_events(lmr.m_run_events),
      m_run_pos(lmr.m_run_pos),
      m_run_s(lmr.m_run_s),
      m_run_s_in_x0(lmr.m_run_s_in_x0),
      m_run_s_in_l0(lmr.m_run_s_in_l0),
      m_run_a(lmr.m_run_a),
      m_run_z(lmr.m_run_z),
      m_run_rho(lmr.m_run_rho),
      m_run_elements(lmr.m_run_elements) {
  copyMaterial(lmr.m_associatedLayerMaterial);
}

~LayerMaterialRecord()

Trk::LayerMaterialRecord::~LayerMaterialRecord

(

)

Destructor.

Definition at line 147 of file LayerMaterialRecord.cxx.

                                             {
  // don't delete the material -> its given to the outside world
  delete m_binUtility;
}

Member Function Documentation

associatedLayerMaterial()

const MaterialPropertiesMatrix & Trk::LayerMaterialRecord::associatedLayerMaterial ( ) const

inline

return method for the LayerMaterial

Definition at line 132 of file LayerMaterialRecord.h.

                                                   {
  return m_associatedLayerMaterial;
}

associateEmptyHit()

void Trk::LayerMaterialRecord::associateEmptyHit

(

const Amg::Vector3D &

pos

)

adding the information about an empty hit scaling- particle crossed layer, but no mapping information

Definition at line 186 of file LayerMaterialRecord.cxx.

                                                                     {
  // just remember that you had an empty hit
  m_emptyHitCase = true;
  // take the position to increase the event counter by one
  m_pos = pos;
}

associateGeantinoHit()

void Trk::LayerMaterialRecord::associateGeantinoHit	(	const Amg::Vector3D &	pos,
		double	s,
		const Trk::Material &	mat )

adding the information about the Geantino hit

Definition at line 152 of file LayerMaterialRecord.cxx.

                                                                            {
  m_steps++;
 
  m_s += s;
  // path association method
  m_pos += pos;
  // path lenght updates
  m_s_in_x0 += s / mat.X0;
  m_s_in_l0 += s / mat.L0;
  // effective rho, A, Z weithed by pathlength through it
  m_rho += mat.rho * s;
  m_a += mat.A * s * mat.rho;
  m_z += mat.Z * s * mat.rho;
 
  // record the composition - since this is mainly for hadronic interactions :
  // weight by s/L0
  MaterialComposition* mComposition = mat.composition;
  if (mComposition) {
    for (auto& it : (*mComposition)) {
      // element identification
      unsigned int Z = uchar2uint(it.first);
      double fraction = uchar2dfrac(it.second);
      // record the elements, let's weight the fractions in s/mat.L0
      auto eIter = m_elements.find(Z);
      if (eIter == m_elements.end())
        m_elements[Z] = fraction * s / mat.L0;
      else
        m_elements[Z] += fraction * s / mat.L0;
    }
  }
}

binCounts()

const std::vector< std::vector< unsigned int > > & Trk::LayerMaterialRecord::binCounts ( ) const

inline

return method for the events used for this

Definition at line 137 of file LayerMaterialRecord.h.

                                     {
  return m_run_events;
}

binUtility()

const Trk::BinUtility * Trk::LayerMaterialRecord::binUtility ( ) const

inline

return the BinUtility

Definition at line 141 of file LayerMaterialRecord.h.

                                                                  {
  return m_binUtility;
}

clearMaterial()

void Trk::LayerMaterialRecord::clearMaterial ( )

private

copy from another vector

Definition at line 365 of file LayerMaterialRecord.cxx.

                                           {
  Trk::MaterialPropertiesMatrix::iterator matMatrixIter =
      m_associatedLayerMaterial.begin();
  Trk::MaterialPropertiesMatrix::iterator matMatrixIterEnd =
      m_associatedLayerMaterial.end();
  for (; matMatrixIter != matMatrixIterEnd; ++matMatrixIter) {
    // loop over the subsets
    std::vector<const Trk::MaterialProperties*>::iterator matIter =
        (*matMatrixIter).begin();
    std::vector<const Trk::MaterialProperties*>::iterator matIterEnd =
        (*matMatrixIter).end();
    for (; matIter != matIterEnd; ++matIter) delete (*matIter);
  }
  m_associatedLayerMaterial.clear();
}

copyMaterial()

void Trk::LayerMaterialRecord::copyMaterial ( const MaterialPropertiesMatrix & mat )

private

Definition at line 381 of file LayerMaterialRecord.cxx.

                                                    {
  // clear the vector
  m_associatedLayerMaterial.clear();
 
  Trk::MaterialPropertiesMatrix::const_iterator matMatrixIter =
      materialMatrix.begin();
  Trk::MaterialPropertiesMatrix::const_iterator matMatrixIterEnd =
      materialMatrix.end();
  for (; matMatrixIter != matMatrixIterEnd; ++matMatrixIter) {
    Trk::MaterialPropertiesVector matProp;
    // loop over the subsets
    std::vector<const Trk::MaterialProperties*>::const_iterator matIter =
        (*matMatrixIter).begin();
    std::vector<const Trk::MaterialProperties*>::const_iterator matIterEnd =
        (*matMatrixIter).end();
    for (; matIter != matIterEnd; ++matIter) {
      // test it
      matProp.push_back(((*matIter) ? (*matIter)->clone() : nullptr));
    }
    // and now push back the vector
    m_associatedLayerMaterial.push_back(std::move(matProp));
  }
}

finalizeEvent()

Trk::AssociatedMaterial * Trk::LayerMaterialRecord::finalizeEvent	(	const Trk::Layer &	lay,
		bool	fullHit = false )

finalize the Event

Constructor with explicit arguments

Definition at line 193 of file LayerMaterialRecord.cxx.

                                       {
  Trk::AssociatedMaterial* fullHitMaterial = nullptr;
  // empty hit scaling
  if (m_emptyHitCase) {
    // averge the hit positions
    int rBin0 = m_binUtility ? m_binUtility->bin(m_pos, 0) : 0;
    int rBin1 = (m_binUtility && m_binUtility->dimensions() > 1)
                    ? m_binUtility->bin(m_pos, 1)
                    : 0;
    // simply increas the event counter
    m_run_events[rBin1][rBin0]++;
    // material hit collection
  } else if (m_steps) {
    // only if there was a single step in the event
    Amg::Vector3D hitPosition(m_pos * 1. / (m_steps));
    // get the correction factor depending on the layer type
    double corrFactorInv = fabs(1. / lay.surfaceRepresentation().pathCorrection(
                                         hitPosition, hitPosition));
    // averge the hit positions
    int rBin0 = m_binUtility ? m_binUtility->bin(hitPosition, 0) : 0;
    int rBin1 = (m_binUtility && m_binUtility->dimensions() > 1)
                    ? m_binUtility->bin(hitPosition, 1)
                    : 0;
 
    // event averaging
    m_run_events[rBin1][rBin0]++;
    m_run_s[rBin1][rBin0] += m_s;
    m_run_pos[rBin1][rBin0] += hitPosition;
    m_run_s_in_x0[rBin1][rBin0] += m_s_in_x0 * corrFactorInv;
    m_run_s_in_l0[rBin1][rBin0] += m_s_in_l0 * corrFactorInv;
    // a & z are normalised to rho
    m_run_a[rBin1][rBin0] += m_a / m_rho;
    m_run_z[rBin1][rBin0] += m_z / m_rho;
    // rho is normalised to the layer thickness times corection factor
    m_run_rho[rBin1][rBin0] += m_rho * corrFactorInv / m_layerThickness;  // ST
 
    // add to the run element table
    for (auto& eIter : m_elements) {
      // first normalize the element fraction
      double nef = eIter.second * corrFactorInv / m_s_in_l0;
      if (m_run_elements[rBin1][rBin0].find(eIter.first) ==
          m_run_elements[rBin1][rBin0].end())
        m_run_elements[rBin1][rBin0][eIter.first] = nef;
      else
        m_run_elements[rBin1][rBin0][eIter.first] += nef;
    }
 
    // just for validation purpose
    if (fullHit) {
      // average the material for the per event validation
      double eventNorm = 1. / double(m_run_events[rBin1][rBin0]);
 
      // normalize the value by number of recorded events - each event counts
      // the same
      double a = m_run_a[rBin1][rBin0] * eventNorm;
      double z = m_run_z[rBin1][rBin0] * eventNorm;
      double rho = m_run_rho[rBin1][rBin0] * eventNorm;
 
      // the average s/X0 and s/L0 is the average over all events corrected by
      // the incident angle
      double s_in_x0 = m_run_s_in_x0[rBin1][rBin0] * eventNorm;
      double s_in_l0 = m_run_s_in_l0[rBin1][rBin0] * eventNorm;
 
      // condense to the layer thickness
      double x0 = m_layerThickness / s_in_x0;
      double l0 = m_layerThickness / s_in_l0;

      fullHitMaterial = new Trk::AssociatedMaterial(
          hitPosition, m_run_s[rBin1][rBin0] * eventNorm, x0, l0, a, z, rho,
          corrFactorInv, lay.enclosingTrackingVolume(), &lay);
    }
  }
 
  // reset event variables
  m_emptyHitCase = false;
  m_steps = 0;
  m_pos = Amg::Vector3D(0., 0., 0.);
  m_s = 0.;
  m_s_in_x0 = 0.;
  m_s_in_l0 = 0.;
  m_a = 0.;
  m_z = 0.;
  m_rho = 0.;
  m_elements.clear();
 
  return fullHitMaterial;
}

finalizeRun()

void Trk::LayerMaterialRecord::finalizeRun

(

bool

recordElements = true

)

finalize the Run

Definition at line 283 of file LayerMaterialRecord.cxx.

                                                            {
  m_associatedLayerMaterial.reserve(m_bins1);
 
  for (int ibin1 = 0; ibin1 < m_bins1; ++ibin1) {
    // create the vector first
    Trk::MaterialPropertiesVector matVector;
    matVector.reserve(m_bins0);
    // loop over local 1 bins
    for (int ibin0 = 0; ibin0 < m_bins0; ++ibin0) {
      Trk::MaterialProperties* binMaterial = nullptr;
      if (m_run_events[ibin1][ibin0]) {
        // The event norm
        double eventNorm = 1. / double(m_run_events[ibin1][ibin0]);
 
        // normalize the value by number of recorded events - each event counts
        // the same
        m_run_a[ibin1][ibin0] *= eventNorm;
        m_run_z[ibin1][ibin0] *= eventNorm;
        m_run_rho[ibin1][ibin0] *= eventNorm;
 
        // the average s/X0 and s/L0 is the average over all events corrected by
        // the incident angle
        m_run_s_in_x0[ibin1][ibin0] *= eventNorm;
        m_run_s_in_l0[ibin1][ibin0] *= eventNorm;
 
        // condense to the layer thickness
        double x0 = m_layerThickness / m_run_s_in_x0[ibin1][ibin0];
        double l0 = m_layerThickness / m_run_s_in_l0[ibin1][ibin0];
 
        // prepare the material composition
        Trk::MaterialComposition* matComposition = nullptr;
        if (recordElements) {
          // pre-loop to get a sample
          double preTotalFraction = 0.;
          std::map<unsigned int, double> binElements =
              m_run_elements[ibin1][ibin0];
          for (auto& peIter : binElements) {
            // normalize the fraction to the number of events
            peIter.second *= eventNorm;
            preTotalFraction += peIter.second;
          }
          if (preTotalFraction == 0.) [[unlikely]]{
            throw std::runtime_error("Trk::LayerMaterialRecord::finalizeRun: preTotalFraction is zero.");
          }
          // first loop to sort rescale
          std::map<double, unsigned int> probabilityOrdered;
          double totalFraction = 0.;
          for (auto& eIter : binElements) {
            // get the fraction
            double eFraction = eIter.second / preTotalFraction;
            if (eFraction < m_minFraction) continue;
            probabilityOrdered[eIter.second] = eIter.first;
            totalFraction += eIter.second;
          }
          if (totalFraction == 0.) [[unlikely]]{
            throw std::runtime_error("Trk::LayerMaterialRecord::finalizeRun: totalFraction is zero.");
          }
          // second loop to fill the element fractions
          std::vector<Trk::ElementFraction> elementFractions;
          elementFractions.reserve(binElements.size());
          for (auto& poEl : probabilityOrdered) {
            double fracEl = poEl.first / totalFraction;
            unsigned int fracEluChar = fracEl * UCHAR_MAX;
            elementFractions.emplace_back(poEl.second, fracEluChar);
          }
          // reverse the order to have the one with the highest fraction first
          std::reverse(elementFractions.begin(), elementFractions.end());
          matComposition = new Trk::MaterialComposition(elementFractions);
        }
 
        Trk::Material material(x0, l0, m_run_a[ibin1][ibin0],
                               m_run_z[ibin1][ibin0], m_run_rho[ibin1][ibin0],
                               0., matComposition);
 
        binMaterial = new Trk::MaterialProperties(material, m_layerThickness);
      }
      matVector.push_back(binMaterial);
    }
    m_associatedLayerMaterial.push_back(std::move(matVector));
  }
}

operator=()

Trk::LayerMaterialRecord & Trk::LayerMaterialRecord::operator=

(

const LayerMaterialRecord &

lmr

)

Assignment operator.

Definition at line 111 of file LayerMaterialRecord.cxx.

                                       {
  if (this != &lmr) {
    m_layerThickness = lmr.m_layerThickness;
    delete m_binUtility;
    m_binUtility = lmr.m_binUtility ? lmr.m_binUtility->clone() : nullptr;
    m_bins0 = lmr.m_bins0;
    m_bins1 = lmr.m_bins1;
    m_minFraction = lmr.m_minFraction;
    m_assoc = lmr.m_assoc;
    m_steps = lmr.m_steps;
    m_pos = lmr.m_pos;
    m_emptyHitCase = lmr.m_emptyHitCase;
    m_s = lmr.m_s;
    m_s_in_x0 = lmr.m_s_in_x0;
    m_s_in_l0 = lmr.m_s_in_l0;
    m_a = lmr.m_a;
    m_z = lmr.m_z;
    m_rho = lmr.m_rho;
    m_elements = lmr.m_elements;
    m_run_events = lmr.m_run_events;
    m_run_s = lmr.m_run_s;
    m_run_s_in_x0 = lmr.m_run_s_in_x0;
    m_run_s_in_l0 = lmr.m_run_s_in_l0;
    m_run_pos = lmr.m_run_pos;
    m_run_a = lmr.m_run_a;
    m_run_z = lmr.m_run_z;
    m_run_rho = lmr.m_run_rho;
    m_run_elements = lmr.m_run_elements;
    // deal with the material
    clearMaterial();
    copyMaterial(lmr.m_associatedLayerMaterial);
  }
  return (*this);
}

Member Data Documentation

m_a

double Trk::LayerMaterialRecord::m_a

private

Definition at line 104 of file LayerMaterialRecord.h.

m_assoc

MaterialAssociationType Trk::LayerMaterialRecord::m_assoc

private

type of hit association

run related information - normalized per event

Definition at line 108 of file LayerMaterialRecord.h.

m_associatedLayerMaterial

MaterialPropertiesMatrix Trk::LayerMaterialRecord::m_associatedLayerMaterial

private

clear the material -> calls delete

Definition at line 123 of file LayerMaterialRecord.h.

m_bins0

int Trk::LayerMaterialRecord::m_bins0

private

number of bins in coordinate 1

Definition at line 91 of file LayerMaterialRecord.h.

m_bins1

int Trk::LayerMaterialRecord::m_bins1

private

number of bins in coordinate 2

Definition at line 92 of file LayerMaterialRecord.h.

m_binUtility

BinUtility* Trk::LayerMaterialRecord::m_binUtility

private

record the BinnedArray

Definition at line 90 of file LayerMaterialRecord.h.

m_elements

std::map<unsigned int, double> Trk::LayerMaterialRecord::m_elements

private

Definition at line 107 of file LayerMaterialRecord.h.

m_emptyHitCase

bool Trk::LayerMaterialRecord::m_emptyHitCase

private

Definition at line 100 of file LayerMaterialRecord.h.

m_layerThickness

double Trk::LayerMaterialRecord::m_layerThickness

private

record the layerThickness

Definition at line 89 of file LayerMaterialRecord.h.

m_minFraction

double Trk::LayerMaterialRecord::m_minFraction

private

minimum element fraction to be recorded

event normalizers

Definition at line 93 of file LayerMaterialRecord.h.

m_pos

Amg::Vector3D Trk::LayerMaterialRecord::m_pos

private

event related information

Definition at line 97 of file LayerMaterialRecord.h.

m_rho

double Trk::LayerMaterialRecord::m_rho

private

Definition at line 106 of file LayerMaterialRecord.h.

m_run_a

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_a

private

Definition at line 116 of file LayerMaterialRecord.h.

m_run_elements

std::vector<std::vector<std::map<unsigned int, double> > > Trk::LayerMaterialRecord::m_run_elements

private

the final material properties

Definition at line 120 of file LayerMaterialRecord.h.

m_run_events

std::vector<std::vector<unsigned int> > Trk::LayerMaterialRecord::m_run_events

private

Definition at line 111 of file LayerMaterialRecord.h.

m_run_pos

std::vector<std::vector<Amg::Vector3D> > Trk::LayerMaterialRecord::m_run_pos

private

Definition at line 112 of file LayerMaterialRecord.h.

m_run_rho

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_rho

private

Definition at line 118 of file LayerMaterialRecord.h.

m_run_s

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_s

private

Definition at line 113 of file LayerMaterialRecord.h.

m_run_s_in_l0

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_s_in_l0

private

Definition at line 115 of file LayerMaterialRecord.h.

m_run_s_in_x0

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_s_in_x0

private

Definition at line 114 of file LayerMaterialRecord.h.

m_run_z

std::vector<std::vector<double> > Trk::LayerMaterialRecord::m_run_z

private

Definition at line 117 of file LayerMaterialRecord.h.

m_s

double Trk::LayerMaterialRecord::m_s

private

Definition at line 101 of file LayerMaterialRecord.h.

m_s_in_l0

double Trk::LayerMaterialRecord::m_s_in_l0

private

Definition at line 103 of file LayerMaterialRecord.h.

m_s_in_x0

double Trk::LayerMaterialRecord::m_s_in_x0

private

Definition at line 102 of file LayerMaterialRecord.h.

m_steps

int Trk::LayerMaterialRecord::m_steps

private

Definition at line 96 of file LayerMaterialRecord.h.

m_z

double Trk::LayerMaterialRecord::m_z

private

Definition at line 105 of file LayerMaterialRecord.h.

---

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

• LayerMaterialRecord.h
• LayerMaterialRecord.cxx