InDetMaterialManager.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETMATERIALMANAGER_H
#define INDETMATERIALMANAGER_H
 
#include "AthenaBaseComps/AthMessaging.h"
#include "RDBAccessSvc/IRDBAccessSvc.h"
#include "GeoModelKernel/GeoIntrusivePtr.h"
#include "GeoModelKernel/GeoMaterial.h"
 
#include <string>
#include <string_view>
#include <map>
 
class GeoElement;
class StoredMaterialManager;
class StoreGateSvc;
 
namespace InDetDD
{
  class AthenaComps;
}

 
 
class InDetMaterialManager : public AthMessaging
{
 
public:
 
  InDetMaterialManager(const std::string & managerName, StoreGateSvc* detStore);
  InDetMaterialManager(const std::string & managerName, StoreGateSvc* detStore,
               const IRDBRecordset_ptr& weightTable,
               const std::string & space = "",
               bool extraFunctionality = false);
  InDetMaterialManager(const std::string & managerName, StoreGateSvc* detStore,
               const IRDBRecordset_ptr& weightTable,
               const IRDBRecordset_ptr& compositionTable,
               const std::string & space = "");
  InDetMaterialManager(const std::string & managerName, 
               InDetDD::AthenaComps *);
  ~InDetMaterialManager();
 
  void addWeightTable(const IRDBRecordset_ptr& weightTable, const std::string & space = "");
  void addWeightMaterial(const std::string& materialName, const std::string& materialBase, double weight, int linearWeightFlag);
  void addCompositionTable(const IRDBRecordset_ptr& compositionTable, const std::string & space = "");
  void addScalingTable(const IRDBRecordset_ptr& scalingTable);
 
 
  bool hasMaterial(const std::string &materialName) const;

  const GeoMaterial* getMaterial(std::string_view materialName);

  const GeoElement* getElement(const std::string & elementName);

  const GeoMaterial* getMaterial(std::string_view  origMaterialName, 
                 double density, 
                 std::string_view newName = {});
 
  // Creates a new material based on origMaterialName but with denisty scaled 
  // by scaleFactor. If no newName then will add the string containing the scale 
  // factor. Eg if scale 12.345678 "Silicon" -> "Silicon12_3456" 
  // If the scale factor is 1 and there is no newName then it just returns the
  // original material.
  // scaleFactor must be between 0.001 and 1000.
  const GeoMaterial* getMaterialScaled(const std::string & origMaterialName, 
                       double scaleFactor, 
                       const std::string & newName = "");

  const GeoMaterial * getMaterialForVolume(std::string_view materialName, 
                       double volume, 
                       std::string_view newName = {});
 
  // Similar to getMaterialForVolume but if weight table uses linear weight, then determine weight 
  // using length. First looks in special table of material compositions which can specify several
  // components and their count. 
  const GeoMaterial * getMaterialForVolumeLength(const std::string & materialName, 
                         double volume, 
                         double length, 
                         const std::string & newName = "");
 
  // As above but rather than using the special table of material compositions, the compositions is specified
  // in the arguments as a vector of materials and multiplictive factors.
  const GeoMaterial * getMaterialForVolumeLength(const std::string & name,
                         const std::vector<std::string> & materialComponents, 
                         const std::vector<double>& factors, 
                         double volume, 
                         double length);
  
  // As above but only one material making up the composition.
  const GeoMaterial * getMaterialForVolumeLength(const std::string & name,
                         const std::string & materialComponent, 
                         double factor, 
                         double volume, 
                         double length);
 
  // Define composite material : function used to create dynamically a new composite material by adding
  //            a defined volume of glue/grease to an already existing material  (IBL stave)
  const GeoMaterial * getCompositeMaterialForVolume(const std::string & newMatName,
                            const double volumeTot,
                            const double volume1, const std::string & matName1,
                            const double volume2, const std::string & matName2
                            );
 
  // Define a new material composition.
  const GeoMaterial * getMaterial(const std::string & name,
                  const std::vector<std::string> & materialComponents, 
                  const std::vector<double> & fractWeights, 
                  double density);
 

  void addMaterial(GeoMaterial *material);
 
 
private:
 
  class MaterialByWeight  {
  public:
    MaterialByWeight() : weight(0), linearWeightFlag(false) {} 
    MaterialByWeight(const std::string & name_in, double weight_in, bool linearWeightFlag_in) 
      : name(name_in), weight(weight_in), linearWeightFlag(linearWeightFlag_in) {}
    MaterialByWeight(double weight_in) 
      : weight(weight_in), linearWeightFlag(false) {}
    std::string name;
    double weight;
    bool linearWeightFlag;
  };
 
  class MaterialComponent {
  public:
    MaterialComponent() : factor(1), actualLength(-1) {}
    MaterialComponent(const std::string & name_in, double factor_in = 1, bool actualLength_in = -1) 
      :  name(name_in), factor(factor_in), actualLength(actualLength_in) {}
    std::string name;
    double factor;
    double actualLength;
  };

  class MaterialDef {
  public:
    MaterialDef();
    MaterialDef(const std::string & name, double density);
    void addComponent(const std::string & compName, double fraction);
    void setCreated() {m_created = true;}
    unsigned int numComponents() const {return m_components.size();}
    bool isCreated() const {return m_created;}
    const std::string & name() const {return m_name;}
    double density() const {return m_density;}
    const std::string & compName(unsigned int i) const {return m_components[i];}
    double fraction(unsigned int i) const {return m_fractions[i];}
    double totalFraction() const;
 
  private:
    std::string m_name;
    double m_density;
    std::vector<std::string> m_components;
    std::vector<double> m_fractions;
    bool m_created;
  };
  
  
  StoredMaterialManager * retrieveManager(const StoreGateSvc* detStore);
  const GeoMaterial* getAdditionalMaterial(std::string_view materialName) const; 
  bool compareDensity(double d1, double d2) const;
 
  // Internal versions. The public versions allow materials to be have extra scaling.
  const GeoMaterial* getMaterialInternal(std::string_view materialName);
  const GeoMaterial* getMaterialInternal(std::string_view origMaterialName, 
                     double density, 
                     std::string_view newName = {});
  const GeoMaterial* getMaterialScaledInternal(const std::string & origMaterialName, 
                           double scaleFactor, 
                           const std::string & newName = "");
  const GeoMaterial * getMaterialInternal(const std::string & name,
                      const std::vector<std::string> & materialComponents, 
                      const std::vector<double> & fractWeights, 
                      double density);
 
  // Methods to return material with extra scaling.
  const GeoMaterial * extraScaledMaterial(std::string_view materialName, 
                      std::string_view newName, 
                      const GeoMaterial * origMaterial);
 
  const GeoMaterial * extraScaledMaterial(std::string_view materialName, 
                      const GeoMaterial * origMaterial);
 
  void createMaterial(const MaterialDef & material);
  double getExtraScaleFactor(std::string_view materialName);
 
  StoredMaterialManager *m_materialManager;
  std::string m_managerName;
 
  using MaterialStore = std::map<std::string, GeoIntrusivePtr<const GeoMaterial>, std::less<>>;
  MaterialStore m_store;
 
  typedef std::map<std::string, MaterialByWeight, std::less<> > MaterialWeightMap;
  MaterialWeightMap m_weightMap;
 
  typedef std::map<std::string, MaterialComponent, std::less<> > MaterialCompositionMap;
  MaterialCompositionMap m_matCompositionMap;
 
  typedef std::map<std::string, double, std::less<> > ExtraScaleFactorMap;
  ExtraScaleFactorMap m_scalingMap;
 
  // Has linear weight flag.
  bool m_extraFunctionality;
 
};
 
 
#endif // INDETMATERIALMANAGER_H