RpcPrepData.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// RpcPrepPdata.h
//   Header file for class RpcPrepData
// (c) ATLAS Detector software
// Class to implement Cluster for Muon - RPC
// Version 1.0 03/30/2005 Ketevi A. Assamagan
 
#ifndef MUONPREPRAWDATA_RPCPREPDATA_H
#define MUONPREPRAWDATA_RPCPREPDATA_H
 
// Base classes
#include "MuonPrepRawData/MuonCluster.h"
#include "TrkSurfaces/Surface.h"
#include "MuonReadoutGeometry/RpcReadoutElement.h"
 
class RpcPrepDataContainerCnv;
 
namespace Muon
{
 
    class RpcRdoToPrepDataToolMT;
    class RpcPrepDataContainerCnv_p1;
    class RpcPrepDataContainerCnv_p2;
 
class RpcPrepData :   public MuonCluster
{
 
    friend class Muon::RpcRdoToPrepDataToolMT;
 
    // Public methods:
public:
 
    friend class ::RpcPrepDataContainerCnv;
    friend class Muon::RpcPrepDataContainerCnv_p1;
    friend class Muon::RpcPrepDataContainerCnv_p2;
 
    RpcPrepData() = default;
    RpcPrepData(const RpcPrepData &) = default;
    RpcPrepData(RpcPrepData &&) noexcept = default;
    RpcPrepData &operator=(const RpcPrepData &) = default;
    RpcPrepData &operator=(RpcPrepData &&) noexcept = default;
 
 
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 const std::vector<Identifier>& rdoList,
                 const Amg::MatrixX& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const int triggerInfo,
                 const int ambiguityFlag);
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 std::vector<Identifier>&& rdoList,
                 Amg::MatrixX&& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const int triggerInfo,
                 const int ambiguityFlag);
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 const std::vector<Identifier>& rdoList,
                 const Amg::MatrixX& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const float timeOverThresh,
                 const int triggerInfo,
                 const int ambiguityFlag);
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 std::vector<Identifier>&& rdoList,
                 Amg::MatrixX&& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const float timeOverThresh,
                 const int triggerInfo,
                 const int ambiguityFlag);
 
 
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 const std::vector<Identifier>& rdoList,
                 const Amg::MatrixX& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const int ambiguityFlag);
    RpcPrepData( const Identifier& RDOId,
                 const IdentifierHash &idDE,
                 const Amg::Vector2D& locpos,
                 std::vector<Identifier>&& rdoList,
                 Amg::MatrixX&& locErrMat,
                 const MuonGM::RpcReadoutElement* detEl,
                 const float time,
                 const int ambiguityFlag);
 
 
 
 
    virtual ~RpcPrepData() = default;
 
    float time() const;
 
    virtual const Amg::Vector3D& globalPosition() const override;
 
    virtual const MuonGM::RpcReadoutElement* detectorElement() const override final;
 
    virtual bool type(Trk::PrepRawDataType type) const override final
    {
      return type == Trk::PrepRawDataType::RpcPrepData;
    }
 
    int triggerInfo() const;
 
    int ambiguityFlag() const;
 
    float timeOverThreshold() const;
 
    virtual MsgStream&    dump( MsgStream&    stream) const override;
 
    virtual std::ostream& dump( std::ostream& stream) const override;
 
private:
 
    const MuonGM::RpcReadoutElement* m_detEl{nullptr};
 
    float m_time{0.f};
 
    float m_timeOverThreshold{-1.f};
 
    int m_triggerInfo{0};
    int m_ambiguityFlag{0};
 
   
 
};
 
// Inline methods:
 
inline float RpcPrepData::time() const
{
    return m_time;
}
 
inline const MuonGM::RpcReadoutElement* RpcPrepData::detectorElement() const
{
    return m_detEl;
}
 
inline int RpcPrepData::triggerInfo() const
{
    return m_triggerInfo;
}
 
inline int RpcPrepData::ambiguityFlag() const
{
    return m_ambiguityFlag;
}
inline float RpcPrepData::timeOverThreshold() const { return m_timeOverThreshold; }
 
inline const Amg::Vector3D& RpcPrepData::globalPosition() const
   {
      if (!m_globalPosition) {
        m_globalPosition.set(std::make_unique<const Amg::Vector3D>(
          m_detEl->surface(identify())
            .Trk::Surface::localToGlobal(localPosition())));
      }
      return *m_globalPosition;
    }
}
 
#endif // MUONPREPRAWDATA_RPCPREPDATA_H