MuonCalibSegment.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// MuonCalibSegment.h
//   Header file for class MuonCalibSegment
 
#ifndef MUONCALIB_MUONCALIBSEGMENT_H
#define MUONCALIB_MUONCALIBSEGMENT_H
 
// stl includes
#include <iostream>
#include <memory>
#include <vector>
 
#include "GeoPrimitives/GeoPrimitives.h"
#include "MuonCalibEventBase/CscCalibHitBase.h"
#include "MuonCalibEventBase/MdtCalibHitBase.h"
#include "MuonCalibEventBase/RpcCalibHitBase.h"
#include "MuonCalibEventBase/TgcCalibHitBase.h"
 
namespace MuonCalib {
    class MuonCalibSegment {
    public:
        /* typedefs */
 
        using MdtHitPtr = std::shared_ptr<MdtCalibHitBase>;
        using MdtHitVec = std::vector<MdtHitPtr>;
 
        using CscHitPtr = std::shared_ptr<const CscCalibHitBase>;
        using CscHitVec = std::vector<CscHitPtr>;
 
        using RpcHitPtr = std::shared_ptr<const RpcCalibHitBase>;
        using RpcHitVec = std::vector<RpcHitPtr>;
 
        using TgcHitPtr = std::shared_ptr<const TgcCalibHitBase>;
        using TgcHitVec = std::vector<TgcHitPtr>;
 
    public:
        MuonCalibSegment(
            double chi2, const Amg::Vector3D& pos, const Amg::Vector3D& dir, const Amg::Transform3D& locToGlo,
            unsigned int qualityFlag = 0);  
        MuonCalibSegment& operator=(const MuonCalibSegment& seg);  
        MuonCalibSegment(const MuonCalibSegment& seg);             
        virtual ~MuonCalibSegment();                               
 
        /* set routines */
        void set(double chi2, const Amg::Vector3D& pos, const Amg::Vector3D& dir);
        void setSegment(const Amg::Vector3D& pos, const Amg::Vector3D& dir);
        void setErrors(double error_dy0, double error_dtheta);  
 
        void setAuthor(int author);   
        void setFittedT0(double t0);  
 
        /* member access */
 
        /* number of hits in segment */
        unsigned int hitsOnTrack() const;  
        unsigned int closeHits() const;    
 
        unsigned int mdtHitsOnTrack() const;  
        unsigned int mdtCloseHits() const;    
 
        unsigned int cscHitsOnTrack() const;  
        unsigned int cscCloseHits() const;    
 
        unsigned int rpcHitsOnTrack() const;  
        unsigned int rpcCloseHits() const;    
 
        unsigned int tgcHitsOnTrack() const;  
        unsigned int tgcCloseHits() const;    
 
        unsigned int hitsPerML(int ML) const;  
        unsigned int missedHits() const;       
        unsigned int deltaHits() const;        
        unsigned int emptyTubes() const;       
        unsigned int outOfTimeHits() const;    
 
        /* hit vectors */
        const MdtHitVec& mdtHOT() const;    
        const MdtHitVec& mdtClose() const;  
 
        const CscHitVec& cscHOT() const;    
        const CscHitVec& cscClose() const;  
 
        const RpcHitVec& rpcHOT() const;    
        const RpcHitVec& rpcClose() const;  
 
        const TgcHitVec& tgcHOT() const;    
        const TgcHitVec& tgcClose() const;  
 
        MdtHitVec& mdtHOT();    
        MdtHitVec& mdtClose();  
 
        CscHitVec& cscHOT();    
        CscHitVec& cscClose();  
 
        RpcHitVec& rpcHOT();    
        RpcHitVec& rpcClose();  
 
        TgcHitVec& tgcHOT();    
        TgcHitVec& tgcClose();  
 
        /* member access */
        double chi2() const;                     
        double error_dy0() const;                
        double error_dtheta() const;             
        bool hasFittedT0() const;                
        double fittedT0() const;                 
        const Amg::Vector3D& position() const;   
        const Amg::Vector3D& direction() const;  
 
        const Amg::Transform3D& localToGlobal() const;
        Amg::Vector3D globalPosition() const;   
        Amg::Vector3D globalDirection() const;  
 
        int author() const;                
        unsigned int qualityFlag() const;  
 
        /* methodes to add XxxCalibHitBase's */
        void addHitOnTrack(MdtCalibHitBase* hit);  
        void addCloseHit(MdtCalibHitBase* hit);    
 
        void addHitOnTrack(CscCalibHitBase* hit);  
        void addCloseHit(CscCalibHitBase* hit);    
 
        void addHitOnTrack(RpcCalibHitBase* hit);  
        void addCloseHit(RpcCalibHitBase* hit);    
 
        void addHitOnTrack(TgcCalibHitBase* hit);  
        void addCloseHit(TgcCalibHitBase* hit);    
 
        void addHitOnTrack(const MdtHitPtr& hit);  
        void addCloseHit(const MdtHitPtr& hit);    
 
        void addHitOnTrack(const CscHitPtr& hit);  
        void addCloseHit(const CscHitPtr& hit);    
 
        void addHitOnTrack(const RpcHitPtr& hit);  
        void addCloseHit(const RpcHitPtr& hit);    
 
        void addHitOnTrack(const TgcHitPtr& hit);  
        void addCloseHit(const TgcHitPtr& hit);    
 
        void refineMdtSelection(const std::vector<unsigned int>& new_selection);  
        std::ostream& dump(std::ostream& stream) const;
 
    private:
        static constexpr double s_dummy_ctor_dbl{-99999.};
        void copy(const MuonCalibSegment& other);
        MdtHitVec m_mdtHitsOnTrack;  
        MdtHitVec m_mdtCloseHits;    
 
        CscHitVec m_cscHitsOnTrack;  
        CscHitVec m_cscCloseHits;    
 
        RpcHitVec m_rpcHitsOnTrack;  
        RpcHitVec m_rpcCloseHits;    
 
        TgcHitVec m_tgcHitsOnTrack;  
        TgcHitVec m_tgcCloseHits;    
 
        /* local track parameters in chamber coordinates */
        double m_chi2{FLT_MAX};                      
        double m_dy0{FLT_MAX};                       
        double m_dtheta{FLT_MAX};                    
        Amg::Vector3D m_localPosition{0., 0., 0.};   
        Amg::Vector3D m_localDirection{0., 0., 0.};  
        Amg::Transform3D m_localToGlobal{};          
        double m_fittedT0{s_dummy_ctor_dbl};         
        unsigned int m_qualityFlag{0};               
        int m_author{-1};                            
    };
 
}  // namespace MuonCalib
 
std::ostream& operator<<(std::ostream& stream, const MuonCalib::MuonCalibSegment& seg);
 
#endif