PhiHoughTransformAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONR4_MUONPATTERNRECOGNITIONALGS_PHIHOUGHTRANSFORMALG__H
#define MUONR4_MUONPATTERNRECOGNITIONALGS_PHIHOUGHTRANSFORMALG__H
 
 
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
 
#include <MuonSpacePoint/SpacePointContainer.h>
#include <MuonPatternEvent/MuonPatternContainer.h>
#include <MuonPatternEvent/HoughEventData.h>
 
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPatternEvent/MuonHoughDefs.h"
 
// muon includes
 
 
namespace MuonR4{
    
    class PhiHoughTransformAlg: public AthReentrantAlgorithm{
        public:
            PhiHoughTransformAlg(const std::string& name, ISvcLocator* pSvcLocator);
            virtual ~PhiHoughTransformAlg() = default;
            virtual StatusCode initialize() override;
            virtual StatusCode execute(const EventContext& ctx) const override;
 
        private:
            
            template <class ContainerType> StatusCode retrieveContainer(const EventContext& ctx,
                                                                        const SG::ReadHandleKey<ContainerType>& key,
                                                                        const ContainerType* & contToPush) const;
 
            StatusCode prepareHoughPlane(HoughEventData & data) const; 
 
            StatusCode preProcessMaximum(const ActsGeometryContext& gctx,
                                         const MuonR4::HoughMaximum & maximum,
                                         HoughEventData & data) const; 
 
            std::unique_ptr<SegmentSeed> recoverSinglePhiMax(HoughEventData & data, const MuonR4::HoughMaximum & maximum) const; 
            
            std::vector<MuonR4::ActsPeakFinderForMuon::Maximum> findRankedSegmentSeeds (HoughEventData & data, const MuonR4::HoughMaximum & maximum) const; 
 
            int countIncompatibleEtaHits(const MuonR4::ActsPeakFinderForMuon::Maximum & phiMaximum, const MuonR4::HoughMaximum &  etaMaximum) const; 
            
            std::unique_ptr<SegmentSeed> buildSegmentSeed(const HoughMaximum & etaMax,  
                                                          const MuonR4::ActsPeakFinderForMuon::Maximum & phiMax) const; 
 
            // read handle key for the input maxima (from a previous eta-transform)
            SG::ReadHandleKey<EtaHoughMaxContainer> m_maxima{this, "ReadKey", "MuonHoughStationMaxima"};
            // write handle key for the output segment seeds 
            SG::WriteHandleKey<SegmentSeedContainer> m_segmentSeeds{this, "WriteKey", "MuonHoughStationSegmentSeeds"};
 
            // access to the ACTS geometry context 
            SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
            // steers the target resolution in tan(phi) 
            DoubleProperty m_targetResoTanPhi{this, "ResolutionTargetTanAngle", 0.04};
            // steers the target resolution in the x-axis intercept
            DoubleProperty m_targetResoIntercept{this, "ResolutionTargetIntercept", 30.};
            // minimum search window half width, tan(phi) 
            // - in multiples of the target resolution
            DoubleProperty m_minSigmasSearchTanPhi{this, "minSigmasSearchTanPhi", 1.};
            // minimum search window half width, intercept 
            // - in multiples of the target resolution
            DoubleProperty m_minSigmasSearchIntercept{this, "minSigmasSearchIntercept", 1.};
            
            // number of accumulator bins in tan(phi)
            // target resolution in the angle
            IntegerProperty m_nBinsTanPhi{this, "nBinsTanAngle", 5};
            // number of accumulator bins in the x-axis intercept
            IntegerProperty m_nBinsIntercept{this, "nBinsIntercept", 10};
            // maximum number of eta measurements allowed to be discarded by 
            // a valid phi-extension
            IntegerProperty m_maxEtaHolesOnMax{this, "maxEtaHoles", 1};
            // flag to steer whether to recover maxima with a single phi measurement
            // using a beam spot projection. Should not be used in splashes or cosmics. 
            BooleanProperty m_recoverSinglePhiWithBS{this, "recoverSinglePhiHitsWithBS", true};
            // Flag to steer whether space points shall be downweighted according to their instance
            // multiplicity of the phi measurement such that it effectively contributes with weight 1
            BooleanProperty m_downWeightMultiplePrd{this, "downWeightPrdMultiplicity", false};
    };
}
 
 
#endif