MdtRdoToPrepDataToolMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONMdtRdoToPrepDataToolMT_H
#define MUONMdtRdoToPrepDataToolMT_H
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
 
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
 
#include "MdtCalibInterfaces/IMdtCalibrationTool.h"
#include "MuonCnvToolInterfaces/IMuonRawDataProviderTool.h"
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
#include "MuonMDT_CnvTools/IMDT_RDO_Decoder.h"
 
#include "MuonCablingData/MuonMDT_CablingMap.h"
#include "MuonCablingData/TwinTubeMap.h"
 
#include "MuonPrepRawData/MuonPrepDataCollection_Cache.h"
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonRDO/MdtCsmContainer.h"
 
#include "xAODMuonPrepData/MdtDriftCircleContainer.h"
#include "xAODMuonPrepData/MdtTwinDriftCircleContainer.h"
 
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
 
class MdtDigit;
 
namespace Muon {
 
    class MdtRdoToPrepDataToolMT : public extends<AthAlgTool, IMuonRdoToPrepDataTool> {
    public:
        using base_class::base_class;

        virtual ~MdtRdoToPrepDataToolMT() = default;

        virtual StatusCode initialize() override;

        virtual StatusCode decode(const EventContext& ctx, const std::vector<IdentifierHash>& idVect) const override;
        virtual StatusCode provideEmptyContainer(const EventContext& ctx) const override;
        // new decode method for Rob based readout
        virtual StatusCode decode(const EventContext& ctx, const std::vector<uint32_t>& robIds) const override;
 
    protected:
        void printPrepDataImpl(const Muon::MdtPrepDataContainer* mdtPrepDataContainer) const;

        Muon::MdtDriftCircleStatus getMdtTwinPosition(const MdtDigit& prompt_digit, const MdtDigit& twin_digit, double& radius,
                                                      double& errRadius, double& zTwin, double& errZTwin, bool& twinIsPrompt) const;
 

        struct ConvCache {
            ConvCache(const Muon::IMuonIdHelperSvc* idHelperSvc);
            MdtPrepDataCollection* createCollection(const Identifier& id);
            StatusCode finalize(MsgStream& msg);
 
            Muon::MdtPrepDataContainer* legacyPrd{nullptr};
            xAOD::MdtDriftCircleContainer* xAODPrd{nullptr};
            xAOD::MdtTwinDriftCircleContainer* xAODTwinPrd{nullptr};
 
            const Muon::IMuonIdHelperSvc* m_idHelperSvc{nullptr};
            const MuonGM::MuonDetectorManager* legacyDetMgr{nullptr};
            const MuonGMR4::MuonDetectorManager* r4DetMgr{nullptr};
            const ActsTrk::GeometryContext* gctx{nullptr};
            const TwinTubeMap* twinTubeMap{nullptr};

            bool isValid{false};
            std::vector<std::unique_ptr<MdtPrepDataCollection>> addedCols{};
        };
 
        StatusCode processCsm(const EventContext& ctx, ConvCache& mdtPrepDataContainer, 
                              const MdtCsm* rdoColl) const;
 
        StatusCode processCsmTwin(const EventContext& ctx, 
                                  ConvCache& mdtPrepDataContainer,  
                                  const MdtCsm* rdoColll) const;
        
        std::unique_ptr<MdtPrepData> createPrepData(const MdtCalibInput& calibInput,
                                                    const MdtCalibOutput& calibOutput,
                                                    ConvCache& cache) const;
        ConvCache setupMdtPrepDataContainer(const EventContext& ctx) const;
        
        const MdtCsmContainer* getRdoContainer(const EventContext& ctx) const;
 
        void processPRDHashes(const EventContext& ctx, ConvCache& mdtPrepDataContainer,
                                const std::vector<IdentifierHash>& chamberHashInRobs) const;
 
        bool handlePRDHash(const EventContext& ctx, ConvCache& mdtPrepDataContainer, 
                           IdentifierHash rdoHash) const;
 
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

        ToolHandle<IMdtCalibrationTool> m_calibrationTool{this, "CalibrationTool", "MdtCalibrationTool"};
 
        
        Gaudi::Property<bool> m_useNewGeo{this, "UseR4DetMgr", false,
                                         "Switch between the legacy and the new geometry"};
 
        const MuonGMR4::MuonDetectorManager* m_detMgrR4{nullptr};
        SG::ReadHandleKey<ActsTrk::GeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "Stored alignment"};
 

        SG::WriteHandleKey<Muon::MdtPrepDataContainer> m_mdtPrepDataContainerKey{this, "OutputCollection", "MDT_DriftCircles"};
 
        SG::ReadHandleKey<MdtCsmContainer> m_rdoContainerKey{this, "RDOContainer", "MDTCSM"};
        

        Gaudi::Property<int>  m_adcCut{this, "AdcCut", 50, 
                                        "Minimal cut on the adc to convert it into a prepdata object"};
        Gaudi::Property<bool> m_calibratePrepData{this, "CalibratePrepData", true};  
        Gaudi::Property<bool> m_decodeData{this, "DecodeData", true};  
        bool m_sortPrepData = false;                                   
 
        ToolHandle<Muon::IMDT_RDO_Decoder> m_mdtDecoder{this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"};
 
        bool m_BMGpresent{false};
        int m_BMGid{-1};
 
        // + TWIN TUBE
        Gaudi::Property<bool> m_useTwin{this, "UseTwin", true};
        Gaudi::Property<bool> m_discardSecondaryHitTwin{this, "DiscardSecondaryHitTwin", false};
 
        // - TWIN TUBE
        SG::ReadCondHandleKey<TwinTubeMap> m_twinTubeKey{this, "TwinTubeKey", "MdtTwinTubeMap"};
 
        std::unordered_set<Identifier> m_DeadChannels{};
        void initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl);
 
        SG::ReadCondHandleKey<MuonMDT_CablingMap> m_readKey{this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"};
 
        SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                         "Key of input MuonDetectorManager condition data"};

        SG::UpdateHandleKey<MdtPrepDataCollection_Cache> m_prdContainerCacheKey{this, "MdtPrdContainerCacheKey", "",
                                                                                "Optional external cache for the MDT PRD container"};
 
        // xAOD PRDs
        SG::WriteHandleKey<xAOD::MdtDriftCircleContainer> m_xAODKey{this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};
        SG::WriteHandleKey<xAOD::MdtTwinDriftCircleContainer> m_xAODTwinKey{this, "xAODTwinKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};
 
    };
}  // namespace Muon
 
#endif