MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/src/GeoModelMdtTest.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONGEOMODELTESTR4_GEOMODELMDTTEST_H
#define MUONGEOMODELTESTR4_GEOMODELMDTTEST_H
 
#include <AthenaBaseComps/AthHistogramAlgorithm.h>
#include <StoreGate/ReadHandleKey.h>
#include <StoreGate/ReadCondHandleKey.h>
 
 
#include <set>
#include <MuonIdHelpers/IMuonIdHelperSvc.h>
#include <ActsGeometryInterfaces/GeometryContext.h>
#include <MuonTesterTree/MuonTesterTree.h>
#include <MuonTesterTree/IdentifierBranch.h>
#include <MuonTesterTree/ThreeVectorBranch.h>
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <MuonTesterTree/CoordTransformBranch.h>
#include <MuonCablingData/MuonMDT_CablingMap.h>
#include <MuonRecToolInterfacesR4/IRootVisualizationService.h>
 
namespace MuonGMR4{
 
class GeoModelMdtTest : public AthHistogramAlgorithm{
    public:
        using AthHistogramAlgorithm::AthHistogramAlgorithm;
       
        ~GeoModelMdtTest() = default;
 
        StatusCode execute(const EventContext& ctx) override;
        StatusCode initialize() override;
        StatusCode finalize() override;
 
        unsigned int cardinality() const override final { return 1; }
 
    private:
      StatusCode visualizeTubeStaggering(const EventContext& ctx,
                                  const ActsTrk::GeometryContext& gctx) const;
 

      void visualizeTubeLayer(const EventContext& ctx,
                              const MuonGMR4::MdtReadoutElement& reEle,
                              const unsigned layer) const;
      void dumpReadoutSideXML() const;

      ServiceHandle<MuonValR4::IRootVisualizationService> m_visualSvc{this, "VisualSvc", "MuonValR4::RootVisualizationService"};
      MuonValR4::IRootVisualizationService::ClientToken m_clientTokenLayerVis{};
      MuonValR4::IRootVisualizationService::ClientToken m_clientTokenStaggeringVis{};
 
      ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "IdHelperSvc", 
                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
      ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
      
      SG::ReadCondHandleKey<MuonMDT_CablingMap> m_cablingKey{this, "CablingKey", "MuonMDT_CablingMap", 
                                                            "Key of output MDT cabling map"};

      std::set<Identifier> m_testStations{};
  
      Gaudi::Property<std::vector<std::string>> m_selectStat{this, "TestStations", {}};
      Gaudi::Property<std::vector<std::string>> m_excludeStat{this, "ExcludeStations", {}};
      
      const MuonDetectorManager* m_detMgr{nullptr};
 
      Gaudi::Property<std::string> m_swapRead{this, "ReadoutSideXML", ""};
 
      StatusCode dumpToTree(const EventContext& ctx,
                            const ActsTrk::GeometryContext& gctx, const MdtReadoutElement* readoutEle);
     
      MuonVal::MuonTesterTree m_tree{"MdtGeoModelTree", "GEOMODELTESTER"};

      MuonVal::ScalarBranch<unsigned short>& m_stIndex{m_tree.newScalar<unsigned short>("stationIndex")};
      MuonVal::ScalarBranch<short>& m_stEta{m_tree.newScalar<short>("stationEta")};
      MuonVal::ScalarBranch<short>& m_stPhi{m_tree.newScalar<short>("stationPhi")};
      MuonVal::ScalarBranch<short>& m_stML{m_tree.newScalar<short>("stationMultiLayer")};
      MuonVal::ScalarBranch<std::string>& m_chamberDesign{m_tree.newScalar<std::string>("chamberDesign")};
 
      MuonVal::ScalarBranch<double>& m_tubeRad{m_tree.newScalar<double>("tubeRadius")};
      MuonVal::ScalarBranch<double>& m_tubePitch{m_tree.newScalar<double>("tubePitch")};
 

      MuonVal::CoordTransformBranch m_readoutTransform{m_tree, "GeoModelTransform"};  
      MuonVal::CoordTransformBranch m_alignableNode {m_tree, "AlignableNode"};
      MuonVal::ScalarBranch<unsigned short>& m_numTubes{m_tree.newScalar<unsigned short>("numTubes")};
      MuonVal::ScalarBranch<unsigned short>& m_numLayers{m_tree.newScalar<unsigned short>("numLayers")};

      MuonVal::VectorBranch<unsigned short>& m_tubeLay{m_tree.newVector<unsigned short>("tubeLayer")};
      MuonVal::VectorBranch<unsigned short>& m_tubeNum{m_tree.newVector<unsigned short>("tubeNumber")};

      MuonVal::CoordSystemsBranch m_tubeTransform{m_tree, "tubeTransform"};     
 
      MuonVal::VectorBranch<double>& m_tubeLength{m_tree.newVector<double>("tubeLength")};
      MuonVal::VectorBranch<double>& m_activeTubeLength{m_tree.newVector<double>("activeTubeLength")};
      MuonVal::VectorBranch<double>& m_wireLength{m_tree.newVector<double>("wireLength")};
      MuonVal::VectorBranch<uint8_t>& m_cablingCSM{m_tree.newVector<uint8_t>("tubeOnlCSM")};
      MuonVal::VectorBranch<uint8_t>& m_cablingMROD{m_tree.newVector<uint8_t>("tubeOnlMROD")};
      MuonVal::VectorBranch<uint8_t>& m_cablingTdcId{m_tree.newVector<uint8_t>("tubeOnlTdcId")};
      MuonVal::VectorBranch<uint8_t>& m_cablingTdcCh{m_tree.newVector<uint8_t>("tubeOnlTdcCh")};

      MuonVal::ThreeVectorBranch m_roPos{m_tree, "readOutPos"};
      MuonVal::ThreeVectorBranch m_tubePosInCh{m_tree, "chamberTubePos"};
      Gaudi::Property<bool> m_visualTubes{this, "visualizeTubes", true};
      Gaudi::Property<bool> m_visualStaggering{this, "visualizeStaggering", true};
};
 
}
#endif