BinnedMaterial.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// Material.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_BINNEDMATERIAL_H
#define TRKGEOMETRY_BINNEDMATERIAL_H
 
#include <climits>
#include <iomanip>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
#include "TrkDetDescrUtils/CompactBinnedArray.h"
#include "TrkDetDescrUtils/CompactBinnedArray1D.h"
#include "TrkDetDescrUtils/CompactBinnedArray2D.h"
#include "TrkGeometry/Material.h"
 
namespace Trk {
 
typedef std::pair<const Material*, int> IdentifiedMaterial;
 
class BinUtility;
 
class BinnedMaterial final: public Material {
 public:
  BinnedMaterial() = default;
 
  BinnedMaterial(
      float iX0, float iL0, float iA, float iZ, float iRho,
      const CompactBinnedArray<const IdentifiedMaterial>* binMat = nullptr)
      : Material(iX0, iL0, iA, iZ, iRho), m_matBins(binMat) {}
 
  BinnedMaterial(const Material* mat, BinUtility*& bu,
                 const std::vector<size_t>& index,
                 const std::vector<IdentifiedMaterial>& detailedMat);
 
  BinnedMaterial(const Material* mat, BinUtility*& bu,
                 std::vector<Trk::BinUtility*>& bVec,
                 const std::vector<std::vector<size_t> >& index,
                 const std::vector<IdentifiedMaterial>& detailedMat);
 
  BinnedMaterial(const BinnedMaterial& amc);
 
  virtual ~BinnedMaterial() = default;
 
  BinnedMaterial& operator=(const BinnedMaterial& amc);
 
  const Trk::BinUtility* layerBinUtility(const Amg::Vector3D& position) const;
 
  size_t layerBin(const Amg::Vector3D& position) const;
 
  const IdentifiedMaterial* material(const Amg::Vector3D& position) const;
  const IdentifiedMaterial* materialNext(const Amg::Vector3D& pos,
                                         const Amg::Vector3D& dir,
                                         bool layOnly) const;
 
 private:
  std::vector<const Trk::IdentifiedMaterial*> ptrs() const;
  std::vector<IdentifiedMaterial> m_matVec;
  using binsPtr_t =
      std::unique_ptr<const CompactBinnedArray<const IdentifiedMaterial> >;
  binsPtr_t m_matBins;
};
 
}  // namespace Trk
 
inline const Trk::BinUtility* Trk::BinnedMaterial::layerBinUtility(
    const Amg::Vector3D& position) const {
  return m_matBins ? m_matBins->layerBinUtility(position) : nullptr;
}
 
inline size_t Trk::BinnedMaterial::layerBin(
    const Amg::Vector3D& position) const {
  return m_matBins ? m_matBins->layerBin(position) : 0;
}
 
#endif