MMPrepData.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONPREPRAWDATA_MMPREPDATA_H
#define MUONPREPRAWDATA_MMPREPDATA_H
 
// Base classes
#include "MuonPrepRawData/MuonCluster.h"
#include "TrkSurfaces/Surface.h"
#include "MuonReadoutGeometry/MMReadoutElement.h"
#include "MuonPrepRawData/NswClusteringUtils.h"
 
#include <vector>
 
 
namespace Muon {
 
 
 
  class MMPrepData final: public MuonCluster {
 
    // Public methods:
  public:
 
    MMPrepData() = default;
    MMPrepData(const MMPrepData &) = delete;
    MMPrepData &operator=(const MMPrepData &) = delete;
    MMPrepData(MMPrepData &&) noexcept = default;
    MMPrepData &operator=(MMPrepData &&) noexcept = default;
 
 
    MMPrepData( const Identifier& RDOId,
        const IdentifierHash &idDE,
        Amg::Vector2D&& locpos,
        std::vector<Identifier>&& rdoList,
        Amg::MatrixX&& locErrMat,
        const MuonGM::MMReadoutElement* detEl,
        const short int time,
        const int charge,
        const float driftDist,
        std::vector<uint16_t>&& stripNumbers,
        std::vector<short int>&& stripTimes,
        std::vector<int>&& stripCharges );
 
    MMPrepData( const Identifier& RDOId,
        const IdentifierHash &idDE,
        Amg::Vector2D&& locpos,
        std::vector<Identifier>&& rdoList,
        Amg::MatrixX&& locErrMat,
        const MuonGM::MMReadoutElement* detEl,
        const short int time,
        const int charge,
        const float driftDist );
 
    MMPrepData( const Identifier& RDOId,
        const IdentifierHash &idDE,
        Amg::Vector2D&& locpos,
        std::vector<Identifier>&& rdoList,
        Amg::MatrixX&& locErrMat,
        const MuonGM::MMReadoutElement* detEl,
        const short int time,
        const int charge );
 
    MMPrepData( const Identifier& RDOId,
        const IdentifierHash &idDE,
        Amg::Vector2D&& locpos,
        std::vector<Identifier>&& rdoList,
        Amg::MatrixX&& locErrMat,
        const MuonGM::MMReadoutElement* detEl);
 
    virtual ~MMPrepData() = default;
 
    void setMicroTPC(float angle, float chisqProb);
 
    void setDriftDist(std::vector<float>&& driftDist,
                      std::vector<AmgVector(2)>&& driftDistErrors);
 
    // setter functions for the EventTPConverters
    void setDriftDist(std::vector<float>&& driftDist,
                      std::vector<float>&& stripDriftErrors_0_0,
                      std::vector<float>&& stripDriftErrors_1_1);
 
    virtual const Amg::Vector3D& globalPosition() const override final;
 
    virtual const MuonGM::MMReadoutElement* detectorElement() const override final;
 
    virtual bool type(Trk::PrepRawDataType type) const override final
    {
      return type == Trk::PrepRawDataType::MMPrepData;
    }
 
    short int time() const;
 
    int charge() const;
 
    float driftDist() const;
 
    float angle() const;
 
    float chisqProb() const;
 
    const std::vector<uint16_t>& stripNumbers() const;
 
    const std::vector<short int>& stripTimes() const;
 
    const std::vector<int>& stripCharges() const;
 
    const std::vector<float>& stripDriftDist() const;
 
    const std::vector<AmgVector(2)>& stripDriftErrors() const;
 
    // getter functions for the EventTPConverters
    std::vector<float> stripDriftErrors_0_0() const;
    std::vector<float> stripDriftErrors_1_1() const;
 
    virtual MsgStream&    dump( MsgStream&    stream) const override final;
 
    virtual std::ostream& dump( std::ostream& stream) const override final;
 
 
    enum class Author: short{
      RDOTOPRDConverter = -1,
      SimpleClusterBuilder,
      ClusterTimeProjectionClusterBuilder,
      uTPCClusterBuilder,
      nAuthorsPRD
    };
 
    enum class Quality: uint8_t{
       unKnown = 0,
    };
 
    Quality quality() const { return m_quality; }
    void setQuality(const Quality q)  { m_quality = q; }
 
 
    Author author() const;
    void setAuthor(Author author);
 
  private:
 
    const MuonGM::MMReadoutElement* m_detEl{nullptr};
 
    short int m_time{0};
 
    int m_charge{0};
 
    float m_driftDist{0.f};
 
    float m_angle{0.f};
    float m_chisqProb{0.f};
 
    std::vector<uint16_t> m_stripNumbers{};
    std::vector<short int> m_stripTimes{};
    std::vector<int> m_stripCharges{};
    std::vector<float> m_stripDriftDist{};
    std::vector<AmgVector(2)>  m_stripDriftErrors{};
    Author m_author{Author::nAuthorsPRD};
    Quality m_quality{Quality::unKnown};
 
  };
 
  inline const MuonGM::MMReadoutElement* MMPrepData::detectorElement() const
  {
    return m_detEl;
  }
  // return globalPosition:
  inline const Amg::Vector3D& MMPrepData::globalPosition() const
  {
    if (!m_globalPosition) {
      m_globalPosition.set(std::make_unique<Amg::Vector3D>(
        m_detEl->surface(identify())
          .Trk::Surface::localToGlobal(localPosition())));
    }
    if (not m_globalPosition) throw Trk::PrepRawDataUndefinedVariable();
    return *m_globalPosition;
  }
 
  inline short int MMPrepData::time() const
  {
    return m_time;
  }
 
  inline int MMPrepData::charge() const
  {
    return m_charge;
  }
 
  inline float MMPrepData::driftDist() const
  {
    return m_driftDist;
  }
 
  inline float MMPrepData::angle() const
  {
    return m_angle;
  }
 
  inline float MMPrepData::chisqProb() const
  {
    return m_chisqProb;
  }
 
  inline const std::vector<uint16_t>& MMPrepData::stripNumbers() const
  {
    return m_stripNumbers;
  }
 
  inline const std::vector<short int>& MMPrepData::stripTimes() const
  {
    return m_stripTimes;
  }
 
  inline const std::vector<int>& MMPrepData::stripCharges() const
  {
    return m_stripCharges;
  }
 
  inline const std::vector<float>& MMPrepData::stripDriftDist() const
  {
    return m_stripDriftDist;
  }
 
  inline const std::vector<AmgVector(2)>& MMPrepData::stripDriftErrors() const
  {
    return m_stripDriftErrors;
  }
 
  inline MMPrepData::Author MMPrepData::author() const {
    return m_author;
  }
 
}
 
#endif // MUONPREPRAWDATA_MMREPDATA_H