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