MuonCalibEvent_E.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MuonCalibEvent_E_h
#define MuonCalibEvent_E_h
 
#include <vector>
 
#include "MuonCalibEventBase/MuonCalibEvent.h"
#include "MuonCalibExtraTreeEvent/MuonCalibCaloHit.h"
#include "MuonCalibExtraTreeEvent/MuonCalibMUCTPI.h"
#include "MuonCalibExtraTreeEvent/MuonCalibRpcSectorLogic.h"
#include "MuonCalibExtraTreeEvent/MuonCalibTrack_E.h"
#include "MuonCalibExtraTreeEvent/MuonCalibTriggerInfo.h"
namespace MuonCalib {

 
    class MuonCalibEvent_E : public MuonCalibEvent {
    public:
        using MuonCalibTrkPtr = std::shared_ptr<const MuonCalibTrack_E>;
        using MuCTPiPtr = std::shared_ptr<const MuonCalibMUCTPI>;
        using TrigInfoPtr = std::shared_ptr<const MuonCalibTriggerInfo>;
        using RpcSectorLogicPtr = std::shared_ptr<const MuonCalibRpcSectorLogic>;
        using RpcCoinPtr = std::shared_ptr<const MuonCalibRawRpcCoin>;
        using RpcTrigHitPtr = std::shared_ptr<const MuonCalibRawRpcTriggerHit>;
        using CaloHitPtr = std::shared_ptr<const MuonCalibCaloHit>;

        typedef std::vector<MuonCalibTrkPtr> PhiPatVec;
 
        typedef std::vector<MuonCalibTrkPtr> TrackVec;
 
        typedef std::vector<TrigInfoPtr> CtpVec;
 
        typedef std::vector<MuCTPiPtr> MUCTPIVec;
        typedef std::vector<RpcSectorLogicPtr> RpcSLVec;
 
        typedef std::vector<RpcCoinPtr> RpcCoinVec;
        typedef std::vector<RpcTrigHitPtr> RawRpcTrigVec;
        typedef std::vector<CaloHitPtr> MBTSVec;
        typedef std::vector<CaloHitPtr> L1CaloVec;
 
        MuonCalibEvent_E() = default;                                
        MuonCalibEvent_E(const MuonCalibEvent& event);               
        MuonCalibEvent_E(const MuonCalibEvent_E& event);             
        MuonCalibEvent_E& operator=(const MuonCalibEvent_E& right);  
        ~MuonCalibEvent_E() = default;                               
 
        void addPattern(MuonCalibTrack_E* pat);                   
        void addTrack(MuonCalibTrack_E* track);                   
        void addCtp(MuonCalibTriggerInfo* trig);                  
        void addMUCTPI(MuonCalibMUCTPI* mctp);                    
        void addRpcSL(MuonCalibRpcSectorLogic* rpcsl);            
        void addRpcCoin(MuonCalibRawRpcCoin* rpcco);              
        void addRawRpcTrigHit(MuonCalibRawRpcTriggerHit* rpctr);  
        void addMBTS(MuonCalibCaloHit* hit);                      
        void addL1Calo(MuonCalibCaloHit* hit);                    
 
        void addPattern(const MuonCalibTrkPtr& pat);        
        void addTrack(const MuonCalibTrkPtr& track);        
        void addCtp(const TrigInfoPtr& trig);               
        void addMUCTPI(const MuCTPiPtr& mctp);              
        void addRpcSL(const RpcSectorLogicPtr& rpcsl);      
        void addRpcCoin(const RpcCoinPtr& rpcco);           
        void addRawRpcTrigHit(const RpcTrigHitPtr& rpctr);  
        void addMBTS(const CaloHitPtr& hit);                
        void addL1Calo(const CaloHitPtr& hit);              
 
        unsigned int nrPhiPat() const;         
        unsigned int nrTracks() const;         
        unsigned int nrCtp() const;            
        unsigned int nrMUCTPI() const;         
        unsigned int nrRpcSL() const;          
        unsigned int nrRpcCoin() const;        
        unsigned int nrRawRpcTrigHit() const;  
        unsigned int nrMBTS() const;           
        unsigned int nrL1Calo() const;         

        const PhiPatVec& phiPat() const;
        PhiPatVec& phiPat();

        const TrackVec& tracks() const;
        TrackVec& tracks();

        const CtpVec& ctp() const;
        CtpVec& ctp();

        const MUCTPIVec& MUCTPI() const;
        MUCTPIVec& MUCTPI();
 
        const RpcSLVec& RpcSL() const;
        RpcSLVec& RpcSL();
 
        const RpcCoinVec& RpcCoin() const;
        RpcCoinVec& RpcCoin();
 
        const RawRpcTrigVec& rawRpcTrig() const;
        RawRpcTrigVec& rawRpcTrig();
 
        const MBTSVec& MBTS() const;
        MBTSVec& MBTS();
        const L1CaloVec& L1Calo() const;
        L1CaloVec& L1Calo();
 
    private:
        void copy(const MuonCalibEvent_E& other);
 
        PhiPatVec m_phiPats;    
        TrackVec m_tracks;      
        CtpVec m_ctp;           
        MUCTPIVec m_mctpi;      
        RpcSLVec m_rpcsl;       
        RpcCoinVec m_rpcco;     
        RawRpcTrigVec m_rpctr;  
        MBTSVec m_mbts;         
        L1CaloVec m_l1calo;     
    };
}  // namespace MuonCalib
 
#endif  // MuonCalibEvent_E_h