MuonCalibTruthCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
//*********************************************************//
// Class to store MuonCalibTruth classes in                 //
//*********************************************************//
 
#ifndef MuonCalibTruthCollection_h
#define MuonCalibTruthCollection_h
 
#include <iostream>
#include <memory>
#include <vector>
 
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "MuonCalibEventBase/MuonCalibCscTruthHit.h"
#include "MuonCalibEventBase/MuonCalibMdtTruthHit.h"
#include "MuonCalibEventBase/MuonCalibRpcTruthHit.h"
#include "MuonCalibEventBase/MuonCalibTgcTruthHit.h"
#include "MuonCalibEventBase/MuonCalibTruth.h"
 
namespace MuonCalib {
 
    class MuonCalibTruthCollection {
    public:
        using TruthPtr = std::shared_ptr<const MuonCalibTruth>;
        using TruthVec = std::vector<TruthPtr>;
 
        using TruthMdtPtr = std::shared_ptr<const MuonCalibMdtTruthHit>;
        using MdtTruthVec = std::vector<TruthMdtPtr>;
 
        using TruthRpcPtr = std::shared_ptr<const MuonCalibRpcTruthHit>;
        using RpcTruthVec = std::vector<TruthRpcPtr>;
        using TruthTgcPtr = std::shared_ptr<const MuonCalibTgcTruthHit>;
        using TgcTruthVec = std::vector<TruthTgcPtr>;
 
        using TruthCscPtr = std::shared_ptr<const MuonCalibCscTruthHit>;
        using CscTruthVec = std::vector<TruthCscPtr>;
 
        MuonCalibTruthCollection() = default;  
        MuonCalibTruthCollection(TruthVec truthVec) :
            m_truthVec(std::move(truthVec)){};  
        ~MuonCalibTruthCollection() = default;  
        MuonCalibTruthCollection(const MuonCalibTruthCollection& truthCollection);  
 
        MuonCalibTruthCollection& operator=(const MuonCalibTruthCollection& rhs);  
 
        int numberOfTruth() const;  
 
        void addTruth(MuonCalibTruth* truth);
        void addTruth(MuonCalibMdtTruthHit* mdtTruth);
        void addTruth(MuonCalibRpcTruthHit* rpcTruth);
        void addTruth(MuonCalibTgcTruthHit* tgcTruth);
        void addTruth(MuonCalibCscTruthHit* cscTruth);
 
        void addTruth(const TruthPtr& truth);
        void addTruth(const TruthMdtPtr& mdtTruth);
        void addTruth(const TruthRpcPtr& rpcTruth);
        void addTruth(const TruthTgcPtr& tgcTruth);
        void addTruth(const TruthCscPtr& cscTruth);
 
        TruthVec& TruthContainer();
        const TruthVec& TruthContainer() const;
 
        MdtTruthVec& MdtContainer();
        const MdtTruthVec& MdtContainer() const;
 
        RpcTruthVec& RpcContainer();
        const RpcTruthVec& RpcContainer() const;
 
        CscTruthVec& CscContainer();
        const CscTruthVec& CscContainer() const;
 
        TgcTruthVec& TgcContainer();
        const TgcTruthVec& TgcContainer() const;
 
    private:
        TruthVec m_truthVec;        
        MdtTruthVec m_mdtTruthVec;  
        RpcTruthVec m_rpcTruthVec;  
        TgcTruthVec m_tgcTruthVec;  
        CscTruthVec m_cscTruthVec;  
        void copy(const MuonCalibTruthCollection& other);
    };
 
}  // end namespace MuonCalib
 
#endif