MuonEtaHoughTransformAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONR4__HOUGHTRANSFORMALG__H
#define MUONR4__HOUGHTRANSFORMALG__H
 
#include "MuonPatternEvent/StationHoughMaxContainer.h"
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "xAODMuonPrepData/MdtDriftCircleContainer.h"
#include <xAODMuonPrepData/RpcStripContainer.h>
#include <xAODMuonPrepData/TgcStripContainer.h>
#include <MuonSpacePoint/MuonSpacePointContainer.h>
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPatternEvent/MuonHoughDefs.h"
#include "Gaudi/Property.h"
 
// muon includes
 
 
namespace MuonR4{
    
    class MuonEtaHoughTransformAlg: public AthReentrantAlgorithm{
        public:
                MuonEtaHoughTransformAlg(const std::string& name, ISvcLocator* pSvcLocator);
                virtual ~MuonEtaHoughTransformAlg() = default;
                virtual StatusCode initialize() override;
                virtual StatusCode execute(const EventContext& ctx) const override;
 
        private:
            
            using HoughSetupForBucket = MuonHoughEventData::HoughSetupForBucket;
            template <class ContainerType> StatusCode retrieveContainer(const EventContext& ctx,
                                                                        const SG::ReadHandleKey<ContainerType>& key,
                                                                        const ContainerType* & contToPush) const;
 
            StatusCode preProcess(MuonHoughEventData & data, 
                                  const MuonSpacePointContainer & spacePoints ) const; 
 
            StatusCode prepareHoughPlane(MuonHoughEventData & data) const; 
            
            StatusCode processBucket(MuonHoughEventData & data, 
                                     HoughSetupForBucket& currentBucket) const; 
 
            void fillFromSpacePoint(MuonHoughEventData & data, 
                                    const MuonR4::HoughHitType & SP) const; 
            
            void extendWithPhiHits(std::vector<HoughHitType> & hitList, HoughSetupForBucket& bucket) const ;  
 
            // target resolution in the angle
            DoubleProperty m_targetResoTanTheta{this, "ResolutionTargetTanTheta", 0.02};
            // target resolution in the y intercept
            DoubleProperty m_targetResoIntercept{this, "ResolutionTargetIntercept", 10.};
            // minimum search window half width, tan(theta) 
            // - in multiples of the target resolution
            DoubleProperty m_minSigmasSearchTanTheta{this, "minSigmasSearchTanTheta", 3.};
            // minimum search window half width, intercept 
            // - in multiples of the target resolution
            DoubleProperty m_minSigmasSearchIntercept{this, "minSigmasSearchIntercept", 3.};
            // number of accumulator bins for the angle 
            IntegerProperty m_nBinsTanTheta{this, "nBinsTanTheta", 20};
            // number of accumulator bins for the intercept 
            IntegerProperty m_nBinsIntercept{this, "nBinsIntercept", 200};
 
            // input space points from SG
            SG::ReadHandleKey<MuonR4::MuonSpacePointContainer> m_spacePointKey{this, "SpacePointContainer", "MuonSpacePoints"};
            
            // output maxima for downstram processing
            SG::WriteHandleKey<StationHoughMaxContainer> m_maxima{this, "StationHoughMaxContainer", "MuonHoughStationMaxima"};
 
            // ACTS geometry context
            SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
    };
}
 
 
#endif