MuonCalibRawHitCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MuonCalibEventBase_MuonCalibRawHitCollection_h
#define MuonCalibEventBase_MuonCalibRawHitCollection_h
 
#include <iostream>
#include <memory>
#include <vector>
 
#include "MuonCalibEventBase/MuonCalibRawCscHit.h"
#include "MuonCalibEventBase/MuonCalibRawMdtHit.h"
#include "MuonCalibEventBase/MuonCalibRawRpcHit.h"
#include "MuonCalibEventBase/MuonCalibRawTgcHit.h"
 
namespace MuonCalib {
 
    class MuonCalibRawTgcCoin;

 
    class MuonCalibRawHitCollection {
    public:
        using MdtCalibRawHitPtr = std::shared_ptr<MuonCalibRawMdtHit>;
        using MuonCalibRawMdtHitVec = std::vector<MdtCalibRawHitPtr>;

        using RpcCalibRawHitPtr = std::shared_ptr<const MuonCalibRawRpcHit>;
        using MuonCalibRawRpcHitVec = std::vector<RpcCalibRawHitPtr>;
 
        using TgcCalibRawHitPtr = std::shared_ptr<const MuonCalibRawTgcHit>;
        using MuonCalibRawTgcHitVec = std::vector<TgcCalibRawHitPtr>;
 
        using TgcCoinRawPtr = std::shared_ptr<const MuonCalibRawTgcCoin>;
        using MuonCalibRawTgcCoinVec = std::vector<TgcCoinRawPtr>;
 
        using CscCalibRawHitPtr = std::shared_ptr<const MuonCalibRawCscHit>;
        using MuonCalibRawCscHitVec = std::vector<CscCalibRawHitPtr>;
 
        MuonCalibRawHitCollection() = default;                                                  //<! default constructor
        ~MuonCalibRawHitCollection() = default;                                                 
        MuonCalibRawHitCollection(const MuonCalibRawHitCollection& MuonCalibRawHitCollection);  
        MuonCalibRawHitCollection& operator=(const MuonCalibRawHitCollection& rhs);             

        MuonCalibRawHitCollection(MuonCalibRawMdtHitVec rawMdtHitVec, MuonCalibRawRpcHitVec rawRpcHitVec,
                                  MuonCalibRawTgcHitVec rawTgcHitVec, MuonCalibRawTgcCoinVec rawTgcCoinVec,
                                  MuonCalibRawCscHitVec rawCscHitVec);

        // Mdt containers
        const MuonCalibRawMdtHitVec& MdtContainer() const;
        MuonCalibRawMdtHitVec& MdtContainer();
 
        const MuonCalibRawRpcHitVec& RpcContainer() const;
        MuonCalibRawRpcHitVec& RpcContainer();
 
        const MuonCalibRawTgcHitVec& TgcContainer() const;
        MuonCalibRawTgcHitVec& TgcContainer();
 
        const MuonCalibRawCscHitVec& CscContainer() const;
        MuonCalibRawCscHitVec& CscContainer();
 
        const MuonCalibRawTgcCoinVec& TgcCoinContainer() const;
        MuonCalibRawTgcCoinVec& TgcCoinContainer();

        int numberOfMuonCalibRawMdtHits() const;
        int numberOfMuonCalibRawRpcHits() const;
        int numberOfMuonCalibRawTgcHits() const;
        int numberOfMuonCalibRawTgcCoins() const;
        int numberOfMuonCalibRawCscHits() const;

        void addMuonCalibRawHit(MuonCalibRawMdtHit* rawHit);
        void addMuonCalibRawHit(const MdtCalibRawHitPtr& rawHit);

        void addMuonCalibRawHit(MuonCalibRawRpcHit* rawHit);
        void addMuonCalibRawHit(const RpcCalibRawHitPtr& rawHit);

        void addMuonCalibRawHit(MuonCalibRawTgcHit* rawHit);
        void addMuonCalibRawHit(const TgcCalibRawHitPtr& rawHit);

        void addMuonCalibRawHit(MuonCalibRawTgcCoin* rawHit);
        void addMuonCalibRawHit(const TgcCoinRawPtr& rawHit);

        void addMuonCalibRawHit(MuonCalibRawCscHit* rawHit);
        void addMuonCalibRawHit(const CscCalibRawHitPtr& rawHit);
 
    private:
        void copy(const MuonCalibRawHitCollection& other);
 
        MuonCalibRawMdtHitVec m_rawMdtHitVec;    
        MuonCalibRawRpcHitVec m_rawRpcHitVec;    
        MuonCalibRawTgcHitVec m_rawTgcHitVec;    
        MuonCalibRawTgcCoinVec m_rawTgcCoinVec;  
        MuonCalibRawCscHitVec m_rawCscHitVec;    
    };
 
}  // namespace MuonCalib
 
#endif