CompoundLayerMaterial.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// CompoundLayerMaterial.h, (c) ATLAS Detector software
 
#ifndef TRKGEOMETRY_COMPOUNDLAYERMATERIAL_H
#define TRKGEOMETRY_COMPOUNDLAYERMATERIAL_H
 
// Trk
#include "TrkDetDescrUtils/BinUtility.h"
#include "TrkDetDescrUtils/SharedObject.h"
#include "TrkGeometry/ElementTable.h"
#include "TrkGeometry/LayerMaterialProperties.h"
#include "TrkGeometry/Material.h"
#include "TrkGeometry/MaterialProperties.h"
#include "CxxUtils/CachedUniquePtr.h"
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Gaudi
#include "GaudiKernel/MsgStream.h"
 
class CompoundLayerMaterialCnv_p1;
 
namespace Trk {
 
typedef std::vector<unsigned char> ValueVector;
typedef std::vector<ValueVector> ValueMatrix;
 
struct ValueStore {
  float valueMin;
  float valueStep;
  ValueMatrix valueBinMatrix;
 
  double value(unsigned char ibin0, unsigned char ibin1) const {
    // allows for single entry
    if (valueBinMatrix.empty()) return valueMin;
    // get the entry from the matrix
    unsigned int ibin = static_cast<unsigned int>(
        valueBinMatrix[static_cast<unsigned int>(ibin1)]
                      [static_cast<unsigned int>(ibin0)]);
    if (!ibin) return 0.;
    double value = valueMin + (double(ibin) - 0.5) * valueStep;
    return value;
  }
};
 
class CompoundLayerMaterial final: public LayerMaterialProperties {
 public:
  CompoundLayerMaterial() = default;
 
  CompoundLayerMaterial(
      const Trk::BinUtility& binutility, const ValueStore& thicknessBins,
      const ValueStore& x0Bins, const ValueStore& l0Bins,
      const ValueStore& aBins, const ValueStore& zBins,
      const ValueStore& rhoBins,
      const std::vector<std::vector<MaterialComposition> >& composition,
      bool fComposition = false);
 
  CompoundLayerMaterial(const CompoundLayerMaterial& mprop);
 
  virtual ~CompoundLayerMaterial() override;
 
  virtual CompoundLayerMaterial* clone() const override final;
 
  CompoundLayerMaterial& operator=(const CompoundLayerMaterial& lmp);
 
  virtual CompoundLayerMaterial& operator*=(double scale) override final;
 
  virtual const BinUtility* binUtility() const override final;
 
  virtual void updateBinning(BinUtility* bu) override final;
 
  virtual const MaterialProperties* fullMaterial(
      const Amg::Vector3D& gp) const override final;
 
  virtual const MaterialProperties* material(size_t bin0,
                                             size_t bin1) const override final;
 
  void updateElementTable(const SharedObject<const ElementTable>& set);
 
  const ElementTable* elementTable() const;
 
  virtual MsgStream& dump(MsgStream& sl) const override final;
 
  virtual std::ostream& dump(std::ostream& sl) const override final;
 
 private:
  friend class ::CompoundLayerMaterialCnv_p1;
 
  void resizeMaterialProperties();
 
  using MaterialPropertiesCUP = CxxUtils::CachedUniquePtr<MaterialProperties>;
  std::vector<std::vector<MaterialPropertiesCUP> >
    m_materialProperties;  
 
  BinUtility* m_binUtility{nullptr};    
  ValueStore m_thicknessBins{};  
  ValueStore m_x0Bins{};         
  ValueStore m_l0Bins{};         
  ValueStore m_aBins{};          
  ValueStore m_zBins{};          
  ValueStore m_rhoBins{};        
  std::vector<std::vector<MaterialComposition> >
      m_composition;       
  bool m_fullComposition{false}; 
  SharedObject<const ElementTable>
      m_elementTable;  // the ElementTable (filled/synchronised)
};
 
inline const BinUtility* CompoundLayerMaterial::binUtility() const {
  return m_binUtility;
}
 
inline void CompoundLayerMaterial::updateElementTable(
    const SharedObject<const ElementTable>& set) {
  m_elementTable = set;
}
 
inline void CompoundLayerMaterial::updateBinning(BinUtility* bu) {
  if (bu) {
    delete m_binUtility;
    m_binUtility = bu;
  }
}
 
inline const ElementTable* CompoundLayerMaterial::elementTable() const {
  return m_elementTable.get();
}
 
}  // namespace Trk
 
#endif