AssociatedMaterial.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// AssociatedMaterial.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_ASSOCIATEDMATERIAL_H
#define TRKGEOMETRY_ASSOCIATEDMATERIAL_H
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Trk includes
#include "TrkGeometry/MaterialProperties.h"
#include "TrkGeometry/MaterialStep.h"
 
class MsgStream;
 
namespace Trk {
 
class Layer;
class TrackingVolume;
 
class AssociatedMaterial {
 public:
  AssociatedMaterial();
 
  AssociatedMaterial(const Amg::Vector3D& hitpos, float steplength, float X0,
                     float L0, float A, float Z, float rho,
                     float correctionFactor, const Trk::TrackingVolume* tvol,
                     const Trk::Layer* lay);
 
  AssociatedMaterial(const Amg::Vector3D& hitpos, float steplength,
                     const Trk::Material&, float correctionFactor,
                     const Trk::TrackingVolume* tvol, const Trk::Layer* lay);
 
  AssociatedMaterial(const Amg::Vector3D& hitpos,
                     const Trk::MaterialProperties*, float correctionFactor,
                     const Trk::TrackingVolume* tvol, const Trk::Layer* lay);
 
  AssociatedMaterial(const Trk::MaterialStep*, float correctionFactor,
                     const Trk::TrackingVolume* tvol, const Trk::Layer* lay);
 
  AssociatedMaterial(const Amg::Vector3D& hitpos,
                     const Trk::TrackingVolume* tvol, const Trk::Layer* lay);
 
  AssociatedMaterial(const AssociatedMaterial& am);
 
  AssociatedMaterial(AssociatedMaterial&& am) noexcept;
 
  ~AssociatedMaterial();
 
  AssociatedMaterial& operator=(const AssociatedMaterial& am);
 
  AssociatedMaterial& operator=(AssociatedMaterial&& am) noexcept;
 
  const Trk::MaterialProperties* materialProperties() const;
 
  const Trk::MaterialStep* materialStep() const;
 
  const Amg::Vector3D& materialPosition() const;
 
  double correctionFactor() const;
 
  const Trk::TrackingVolume* associatedTrackingVolume() const;
 
  const Trk::Layer* associatedLayer() const;
 
  double steplength() const;
 
  double steplengthInX0() const;
 
  double steplengthInL0() const;
 
  double x0() const;
  double l0() const;
  double A() const;
  double Z() const;
  double rho() const;
 
  MsgStream& dump(MsgStream& sl) const;
 
  std::ostream& dump(std::ostream& sl) const;
 
 private:
  Amg::Vector3D m_materialPosition;
  float m_correctionFactor;
  const Trk::MaterialProperties* m_materialProperties;
  const Trk::MaterialStep* m_materialStep;
  const Trk::TrackingVolume* m_trackingVolume;
  const Trk::Layer* m_layer;
  bool m_cleanup;
};
 
inline const Trk::MaterialProperties* AssociatedMaterial::materialProperties()
    const {
  return m_materialProperties;
}
 
inline const Trk::MaterialStep* AssociatedMaterial::materialStep() const {
  return m_materialStep;
}
 
inline const Amg::Vector3D& AssociatedMaterial::materialPosition() const {
  return m_materialPosition;
}
 
inline double AssociatedMaterial::correctionFactor() const {
  return m_correctionFactor;
}
 
inline const Trk::TrackingVolume* AssociatedMaterial::associatedTrackingVolume()
    const {
  return m_trackingVolume;
}
 
inline const Trk::Layer* AssociatedMaterial::associatedLayer() const {
  return m_layer;
}
 
inline double AssociatedMaterial::x0() const {
  if (m_materialProperties) return m_materialProperties->x0();
  if (m_materialStep) return m_materialStep->x0();
  return 0.;
}
 
inline double AssociatedMaterial::steplength() const {
  if (m_materialProperties) return m_correctionFactor;
  if (m_materialStep) return m_materialStep->steplength();
  return 0.;
}
 
inline double AssociatedMaterial::steplengthInX0() const {
  if (m_materialProperties)
    return m_materialProperties->thicknessInX0() * m_correctionFactor;
  if (m_materialStep) return m_materialStep->steplengthInX0();
  return 0.;
}
 
inline double AssociatedMaterial::steplengthInL0() const {
  if (m_materialProperties)
    return m_materialProperties->thicknessInL0() * m_correctionFactor;
  if (m_materialStep) return m_materialStep->steplengthInL0();
  return 0.;
}
 
inline double AssociatedMaterial::l0() const {
  if (m_materialProperties) return m_materialProperties->l0();
  if (m_materialStep) return m_materialStep->l0();
  return 0.;
}
 
inline double AssociatedMaterial::A() const {
  if (m_materialProperties) return m_materialProperties->averageA();
  if (m_materialStep) return m_materialStep->A();
  return 0.;
}
 
inline double AssociatedMaterial::Z() const {
  if (m_materialProperties) return m_materialProperties->averageZ();
  if (m_materialStep) return m_materialStep->Z();
  return 0.;
}
 
inline double AssociatedMaterial::rho() const {
  if (m_materialProperties) return m_materialProperties->averageRho();
  if (m_materialStep) return m_materialStep->rho();
  return 0.;
}
 
MsgStream& operator<<(MsgStream& sl, const AssociatedMaterial& mstep);
std::ostream& operator<<(std::ostream& sl, const AssociatedMaterial& mstep);
 
}  // namespace Trk
 
#endif