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 Trk::PrepRawDataType prdType() const override {
      return 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