MuonDigitizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONDIGITIZATIONR4_MUONDIGITIZATIONTOOL_H
#define MUONDIGITIZATIONR4_MUONDIGITIZATIONTOOL_H
 
#include "PileUpTools/PileUpMergeSvc.h"
#include "PileUpTools/PileUpToolBase.h"
 
 
#include "CLHEP/Random/RandomEngine.h"
#include "AthenaKernel/IAthRNGSvc.h"
 
 
#include "xAODMuonSimHit/MuonSimHitContainer.h"
#include "xAODMuonSimHit/MuonSimHitAuxContainer.h"
 
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "ActsGeometryInterfaces/ActsGeometryContext.h"
 
#include "Acts/Utilities/PointerTraits.hpp"
#include "HitManagement/TimedHitPtr.h"
 
 
 
namespace MuonR4 {
     static_assert(Acts::PointerConcept<TimedHitPtr<xAOD::MuonSimHit>>);
     class MuonDigitizationTool: public PileUpToolBase {
        public:
            using PileUpToolBase::PileUpToolBase;
 
            StatusCode initialize() override;
 
 
            StatusCode processBunchXing(int bunchXing, 
                                        SubEventIterator bSubEvents, 
                                        SubEventIterator eSubEvents) override final;
 
            StatusCode mergeEvent(const EventContext& ctx) override final;
 
            StatusCode prepareEvent(const EventContext& ctx, 
                                    const unsigned int /*nInputEvents*/) override final;
 
  
            StatusCode processAllSubEvents(const EventContext& ctx) override final;
            StatusCode processAllSubEvents(const EventContext& ctx) const;
        
        protected:
            CLHEP::HepRandomEngine* getRandomEngine(const EventContext&ctx) const;
            
            using TimedHit = TimedHitPtr<xAOD::MuonSimHit>;
            using TimedHits = std::vector<TimedHitPtr<xAOD::MuonSimHit>>;
 
            virtual StatusCode digitize(const EventContext& ctx,
                                        const TimedHits& hitsToDigit,
                                        xAOD::MuonSimHitContainer* sdoContainer) const = 0;
            
            xAOD::MuonSimHit* addSDO(const TimedHit& hit, xAOD::MuonSimHitContainer* sdoContainer) const;
 
            const ActsGeometryContext& getGeoCtx(const EventContext& ctx) const;
 
            template <class DetType> using OutDigitCache_t = std::vector<std::unique_ptr<DetType>>;
            
            template <class DigitColl> 
                      DigitColl* fetchCollection(const Identifier& hitId,
                                                 OutDigitCache_t<DigitColl>& digitCache) const;
            template <class DigitCont, class DigitColl> 
                    StatusCode writeDigitContainer(const EventContext& ctx,
                                                   const SG::WriteHandleKey<DigitCont>& key,
                                                   OutDigitCache_t<DigitColl>&& digitCache,
                                                   unsigned int hashMax) const;
 
            static double hitTime(const TimedHit& hit);
            using DeadTimeMap = std::unordered_map<Identifier, double>;
            static bool passDeadTime(const Identifier& channelId,
                                     const double hitTime, 
                                     const double deadTimeWindow,
                                     DeadTimeMap& deadTimeMap);
 
            const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
 
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", 
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
        private:
            using PileUpHits = PileUpMergeSvc::TimedList<xAOD::MuonSimHitContainer>::type;
            
            StatusCode fillTimedHits(PileUpHits&& hitColl, TimedHits& timedHits) const;
            
            SG::ReadHandleKey<xAOD::MuonSimHitContainer> m_simHitKey{this, "SimHitKey", ""};
 
            SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", 
                                                               "Geometry context"};
 
            ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};
 
            Gaudi::Property<std::string> m_streamName{this, "StreamName", ""};
 
            ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  // Random number service
 
            SG::WriteHandleKey<xAOD::MuonSimHitContainer> m_sdoKey{this, "OutputSDOName", ""};
 
            Gaudi::Property<bool> m_onlyUseContainerName{this, "OnlyUseContainerName", false,
                                                         "Don't use the ReadHandleKey directly. Just extract the container name from it."};
 
            Gaudi::Property<bool> m_includePileUpTruth{this, "IncludePileUpTruth", true, "Include pile-up truth info"};
 
            std::string m_inputObjectName{""};
 
            TimedHits m_timedHits{};
            using SimHitLocalCopy = std::pair<std::unique_ptr<xAOD::MuonSimHitContainer>,
                                              std::unique_ptr<xAOD::MuonSimHitAuxContainer>>;
            std::vector<SimHitLocalCopy> m_simHits{};
 
 
};
 
}
#include "MuonDigitizationR4/MuonDigitizationTool.icc"
#endif