MuonBlueprintNodeBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSMUONDETECTOR_MUONBLUEPRINTNODEBUILDER_H
#define ACTSMUONDETECTOR_MUONBLUEPRINTNODEBUILDER_H
 
#include <AthenaBaseComps/AthAlgTool.h>
 
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <MuonStationIndex/MuonStationIndex.h>
#include <ActsGeometryInterfaces/IBlueprintNodeBuilder.h>
 
#include "Acts/Utilities/BoundFactory.hpp"
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/Surface.hpp"
 
 
 
 
namespace MuonGMR4 {
  class Chamber;
}
 
namespace Acts {
  class GeometryContext;
  class StaticBlueprintNode;
  class MaterialDesignatorBlueprintNode;
 
}  // namespace Acts
 
 
namespace ActsTrk {
 

class MuonBlueprintNodeBuilder : public extends<AthAlgTool, IBlueprintNodeBuilder> {
public:
  using blueprintNodePtr = std::shared_ptr<Acts::BlueprintNode>;
  using staticNodePtr = std::shared_ptr<Acts::StaticBlueprintNode>;
  using materialNodePtr = std::shared_ptr<Acts::MaterialDesignatorBlueprintNode>;
  using surfacePtr = std::shared_ptr<Acts::Surface>;
  using BluePrintSurfPairs_t = std::pair<std::vector<blueprintNodePtr>, std::vector<surfacePtr>>;
  using MuonChamberSet = MuonGMR4::MuonDetectorManager::MuonChamberSet;
  using MuonSectorSet = MuonGMR4::MuonDetectorManager::MuonSectorSet;
  using StIdx = Muon::MuonStationIndex::StIndex;
  using DetIdx = Muon::MuonStationIndex::DetectorRegionIndex;
  using LayIdx = Muon::MuonStationIndex::LayerIndex;
  using ChIdx = Muon::MuonStationIndex::ChIndex;
  using DetLayIdx_t = std::pair<DetIdx, LayIdx>;
  using EnvelopeSet_t = std::variant<MuonChamberSet, MuonSectorSet>;
  /*** @brief Subdivide the envelopes according to their station index  */
  using EnvelopesPerStIdx_t = std::unordered_map<StIdx, EnvelopeSet_t>;
 
  enum class EndcapSide: std::uint8_t {
      A,
      C,
      Both
  };
  StatusCode initialize() override;
  using base_class::base_class;
  
  std::shared_ptr<Acts::BlueprintNode> buildBlueprintNode(const Acts::GeometryContext& gctx,
                                              std::shared_ptr<Acts::BlueprintNode>&& childNode) override;
                                
private:
  const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
  Gaudi::Property<bool> m_useSectors{this, "UseSectors", false}; 
  Gaudi::Property<bool> m_alignableVolumes{this, "AlignableVolumes", true};
  Gaudi::Property<bool> m_isRun4{this, "run4Layout", false};
  Gaudi::Property<bool> m_assignActiveMaterial{this, "AssignActiveMaterial", true};
  Gaudi::Property<bool> m_buildPassiveVolumes{this, "BuildPassiveVolumes", false};
  Gaudi::Property<bool> m_assignEmptyMaterial{this, "AssignEmptyPassiveMaterial", false};
  Gaudi::Property<std::size_t> m_nPhiBinsBI{this, "nPhiBinsBI", 16};
  Gaudi::Property<std::size_t> m_nZBinsBI{this, "nZBinsBI", 12};
  Gaudi::Property<std::size_t> m_nPhiBinsBM{this, "nPhiBinsBM", 16};
  Gaudi::Property<std::size_t> m_nZBinsBM{this, "nZBinsBM", 12};
  Gaudi::Property<std::size_t> m_nPhiBinsBO{this, "nPhiBinsBO", 16};
  Gaudi::Property<std::size_t> m_nZBinsBO{this, "nZBinsBO", 12};
  Gaudi::Property<std::size_t> m_nRBinsEI1{this, "nRBinsEIbNSW", 4};
  Gaudi::Property<std::size_t> m_nPhiBinsEI1{this, "nPhiBinsEIbNSW", 16};
  Gaudi::Property<std::size_t> m_nRBinsEI2{this, "nRBinsEIaNSW", 4};
  Gaudi::Property<std::size_t> m_nPhiBinsEI2{this, "nPhiBinsEIaNSW", 16};

  Gaudi::Property<std::size_t> m_nRBinsEM1{this, "nRBinsEMbBW", 16};
  Gaudi::Property<std::size_t> m_nPhiBinsEM1{this, "nPhiBinsEMbBW", 16};
  Gaudi::Property<std::size_t> m_nRBinsEM2{this, "nRBinsEMaBW", 5};
  Gaudi::Property<std::size_t> m_nPhiBinsEM2{this, "nPhiBinsEMaBW", 16};

  std::shared_ptr<Acts::ISurfaceMaterial> preparePassiveMaterial(const Acts::SurfaceBounds& bounds,
                                                          const std::size_t nBins1,
                                                          const std::size_t nBins2) const;
 
  std::pair<std::size_t, std::size_t> getMaterialBins(const Muon::MuonStationIndex::ChIndex chIdx) const;
 
  
    template<typename T>
    BluePrintSurfPairs_t getSensitiveElements(const ActsTrk::GeometryContext& gctx,
                                              const T& element,
                                              const Acts::GeometryIdentifier& chId,
                                              Acts::VolumeBoundFactory& boundsFactory) const
      requires(std::is_same_v<T, MuonGMR4::Chamber> ||
               std::is_same_v<T, MuonGMR4::SpectrometerSector>);

  template <typename ElementSet_t>
   std::vector<surfacePtr> getPassiveMaterialSurfaces(const Acts::GeometryContext& gctx,
                                                     const std::unordered_map<unsigned int, ElementSet_t>& elementsPerStation) const;
    
  
    template<typename T>    
    std::shared_ptr<const Acts::ISurfaceMaterial>
    getActiveMaterial(const T& element) const
      requires (std::is_same_v<T, MuonGMR4::Chamber> ||
              std::is_same_v<T, MuonGMR4::SpectrometerSector>);

  template<typename T>
  bool isElementInTheStation(const T& element, 
                             const std::vector<StIdx>& stationNames, 
                             const EndcapSide side) const
       requires(std::is_same_v<T, MuonGMR4::Chamber> ||
                std::is_same_v<T, MuonGMR4::SpectrometerSector>);

  staticNodePtr buildMuonNode(const Acts::GeometryContext& gctx,
                              const EnvelopeSet_t& elements,
                              const std::string& name,
                              const Acts::GeometryIdentifier& id,
                              Acts::VolumeBoundFactory& boundsFactory,
                              const std::vector<ChIdx>& passiveStationIds = {}) const;

  std::variant<staticNodePtr, materialNodePtr> buildChamberNode(const blueprintNodePtr& chamberNode) const;

  template<typename T>
  std::variant<staticNodePtr, materialNodePtr> buildChamberNode(const T& element, 
                                                                std::unique_ptr<Acts::TrackingVolume>& vol,
                                                                const std::vector<blueprintNodePtr>& innerStructure) const;

  bool isBIS78(const MuonGMR4::MuonReadoutElement* element) const;
};
 
} //namespace ActsTrk
 
#endif