MuonSpectrometer/MuonReconstruction/MuonRecUtils/MuonLayerHough/MuonLayerHough/Hit.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONHOUGH_HIT_H
#define MUONHOUGH_HIT_H
 
#include <functional>
#include <map>
#include <memory>
 
#include "CxxUtils/fpcompare.h"
#include "MuonStationIndex/MuonStationIndex.h"
 
namespace Trk {
    class PrepRawData;
}
namespace Muon {
    class TgcClusterObj3D;
}
 
namespace MuonHough {
    static constexpr int UNINITIALIZED = -99999;
    class HitDebugInfo {
    public:
        HitDebugInfo() = default;
 
        HitDebugInfo(int type_, int sector_, Muon::MuonStationIndex::DetectorRegionIndex region_, Muon::MuonStationIndex::LayerIndex layer_,
                     int sublayer_);
 
        int type{UNINITIALIZED};    
        int sector{UNINITIALIZED};  
        Muon::MuonStationIndex::DetectorRegionIndex region{
            Muon::MuonStationIndex::DetectorRegionUnknown};                              
        Muon::MuonStationIndex::LayerIndex layer{Muon::MuonStationIndex::LayerUnknown};  
        int sublayer{UNINITIALIZED};                                                     
        int pdgId{UNINITIALIZED};                                                        
        int barcode{UNINITIALIZED};                                                      
        int muonIndex{UNINITIALIZED};                                                    
        int clusterSize{UNINITIALIZED};                                                  
        int clusterLayers{UNINITIALIZED};                                                
        bool isEtaPhi{false};                                                            
        bool trigConfirm{false};                                                         
        int binpos{UNINITIALIZED};    
        int bintheta{UNINITIALIZED};  
        float time{UNINITIALIZED};    
        float r{UNINITIALIZED};       
        float ph{UNINITIALIZED};      
        float phn{UNINITIALIZED};     
        float ph1{UNINITIALIZED};     
        float ph2{UNINITIALIZED};     
        float rot{UNINITIALIZED};     
    };
 
    class Hit {
    public:
        Hit(int layer_, float x_, float ymin_, float ymax_, float w_, HitDebugInfo* d_ = nullptr, const Trk::PrepRawData* prd_ = nullptr,
            const Muon::TgcClusterObj3D* tgc_ = nullptr);
 
        ~Hit();
 
        Hit(const Hit& h_);
        Hit(Hit&& h_) noexcept = default;
 
        Hit& operator=(const Hit& h_);
 
        int layer{UNINITIALIZED};   
        float x{UNINITIALIZED};     
        float ymin{UNINITIALIZED};  
        float ymax{UNINITIALIZED};  
        float w{UNINITIALIZED};     
 
        const HitDebugInfo* debugInfo() const { return m_debug.get(); }
        HitDebugInfo* debugInfo() { return m_debug.get(); }
 
        const Trk::PrepRawData* prd{nullptr};
        const Muon::TgcClusterObj3D* tgc{nullptr};
 
    private:
        std::unique_ptr<HitDebugInfo> m_debug{nullptr};  
 
        void copy(const Hit& hit);
    };
 
    struct PhiHit {
        PhiHit(int layer_, float r_, float phimin_, float phimax_, float w_, HitDebugInfo* d_ = 0, const Trk::PrepRawData* prd_ = 0,
               const Muon::TgcClusterObj3D* tgc_ = 0);
 
        ~PhiHit();
 
        PhiHit(const PhiHit& h_);
        PhiHit(PhiHit&& h_) noexcept = default;
 
        PhiHit& operator=(const PhiHit& h_);
 
        int layer{UNINITIALIZED};     
        float r{UNINITIALIZED};       
        float phimin{UNINITIALIZED};  
        float phimax{UNINITIALIZED};  
        float w{UNINITIALIZED};       
 
        const HitDebugInfo* debugInfo() const { return m_debug.get(); }
        HitDebugInfo* debugInfo() { return m_debug.get(); }
 
        const Trk::PrepRawData* prd{nullptr};
        const Muon::TgcClusterObj3D* tgc{nullptr};
 
    private:
        std::unique_ptr<HitDebugInfo> m_debug{nullptr};  
 
        void copy(const PhiHit& hit);
    };
 
    struct MuonDebugInfo {
        int pdgId{UNINITIALIZED};      
        int barcode{UNINITIALIZED};    
        int muonIndex{UNINITIALIZED};  
        float pt{UNINITIALIZED};       
        float eta{UNINITIALIZED};      
        float phi{UNINITIALIZED};      
 
        // number of reconstructed hits
        int nmdts{0};
        int nrpcs{0};
        int ntgcs{0};
        int ncscs{0};
        int nmms{0};
        int nstgcs{0};
 
        // number of true hits
        int ntmdts{0};
        int ntrpcs{0};
        int nttgcs{0};
        int ntcscs{0};
        int ntmms{0};
        int ntstgcs{0};
    };
 
    struct SegDebugInfo {
        float sposx{UNINITIALIZED};
        float sposy{UNINITIALIZED};
        float sposz{UNINITIALIZED};
        float sdirx{UNINITIALIZED};
        float sdiry{UNINITIALIZED};
        float sdirz{UNINITIALIZED};
        int snPrecHits{0};
        int snTrigHits{0};
        int sSector{0};
        int sChIndex{0};
    };
 
    struct SortHitsPerLayer {
        bool operator()(const Hit& hit1, const Hit& hit2) const {
            return compare(hit1.ymin, hit2.ymin, hit1.layer, hit2.layer, hit1.debugInfo(), hit2.debugInfo());
        }
 
        bool operator()(const PhiHit& hit1, const PhiHit& hit2) const {
            return compare(hit1.phimin, hit2.phimin, hit1.layer, hit2.layer, hit1.debugInfo(), hit2.debugInfo());
        }
 
        bool compare(float val1, float val2, int lay1, int lay2, const HitDebugInfo* db1, const HitDebugInfo* db2) const {
            if (db1 && db2) {
                if (db1->sector != db2->sector) return db1->sector < db2->sector;
                if (db1->region != db2->region) return db1->region < db2->region;
                if (db1->type != db2->type) return db1->type < db2->type;
                if (db1->layer != db2->layer) return db1->layer < db2->layer;
                if (db1->sublayer != db2->sublayer) return db1->sublayer < db2->sublayer;
            } else {
                if (lay1 != lay2) return lay1 < lay2;
            }
            return CxxUtils::fpcompare::less(val1, val2);
        }
 
        bool operator()(const Hit* hit1, const Hit* hit2) const { return operator()(*hit1, *hit2); }
        bool operator()(const PhiHit* hit1, const PhiHit* hit2) const { return operator()(*hit1, *hit2); }
   
        bool operator()(const std::shared_ptr<Hit>& hit1, const std::shared_ptr<Hit>& hit2) const { return operator()(*hit1, *hit2); }
        bool operator()(const std::shared_ptr<PhiHit>& hit1, const std::shared_ptr<PhiHit>& hit2) const { return operator()(*hit1, *hit2); }
   
    };
 
}  // namespace MuonHough
 
#endif