CDCRecoHit2D.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
 
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/ERotation.h>
 
#include <tracking/trackFindingCDC/geometry/Vector2D.h>
 
#include <iosfwd>
 
namespace Belle2 {
  class CDCSimHit;
  class CDCHit;
 
  namespace TrackFindingCDC {
    class CDCTrajectory2D;
    class CDCWireHit;
    class CDCWire;
    class Vector3D;
 
    class CDCRecoHit2D  {
 
    public:
      CDCRecoHit2D() = default;
 
      CDCRecoHit2D(const CDCRLWireHit& rlWireHit,
                   const Vector2D& recoDisp2D);
 
      explicit CDCRecoHit2D(const CDCRLWireHit& rlWireHit);
 
      static CDCRecoHit2D average(const CDCRecoHit2D& recoHit1,
                                  const CDCRecoHit2D& recoHit2);
 
      static CDCRecoHit2D average(const CDCRecoHit2D& recoHit1,
                                  const CDCRecoHit2D& recoHit2,
                                  const CDCRecoHit2D& recoHit3);
 
      static CDCRecoHit2D
      fromRecoPos2D(const CDCRLWireHit& rlWireHit, const Vector2D& recoPos2D, bool snap = true);
 
      void reverse();
 
      CDCRecoHit2D reversed() const;
 
      CDCRecoHit2D getAlias() const;
 
      static CDCRecoHit2D fromSimHit(const CDCWireHit* wireHit, const CDCSimHit& simHit);
 
 
      operator const Belle2::CDCHit* () const
      { return static_cast<const CDCHit*>(getRLWireHit()); }
 
 
      bool operator==(const CDCRecoHit2D& other) const
      {
        return getRLWireHit() == other.getRLWireHit() and
               getRecoDisp2D() == other.getRecoDisp2D();
      }
 
      bool operator<(const CDCRecoHit2D& other) const
      {
        return getRLWireHit() <  other.getRLWireHit() or (
                 getRLWireHit() == other.getRLWireHit() and
                 getRecoDisp2D() < other.getRecoDisp2D());
      }
 
      friend bool operator<(const CDCRecoHit2D& recoHit2D, const CDCWire& wire)
      { return recoHit2D.getRLWireHit() < wire; }
 
      friend bool operator<(const CDCWire& wire, const CDCRecoHit2D& recoHit2D)
      { return wire < recoHit2D.getRLWireHit(); }
 
      friend bool operator<(const CDCRecoHit2D& recoHit2D, const CDCWireHit& wireHit)
      { return recoHit2D.getRLWireHit() < wireHit; }
 
      friend bool operator<(const CDCWireHit& wireHit, const CDCRecoHit2D& recoHit2D)
      { return wireHit < recoHit2D.getRLWireHit(); }
 
      EStereoKind getStereoKind() const
      {
        return getRLWireHit().getStereoKind();
      }
 
      bool isAxial() const
      {
        return getRLWireHit().isAxial();
      }
 
      ISuperLayer getISuperLayer() const
      {
        return getRLWireHit().getISuperLayer();
      }
 
      const CDCWire& getWire() const
      {
        return getRLWireHit().getWire();
      }
 
      const Vector2D& getRefPos2D() const
      {
        return getRLWireHit().getRefPos2D();
      }
 
      bool isOnWire(const CDCWire& wire) const
      {
        return getRLWireHit().isOnWire(wire);
      }
 
      const CDCWireHit& getWireHit() const
      {
        return getRLWireHit().getWireHit();
      }
 
      bool hasWireHit(const CDCWireHit& wireHit) const
      {
        return getRLWireHit().hasWireHit(wireHit);
      }
 
      ERightLeft getRLInfo() const
      {
        return getRLWireHit().getRLInfo();
      }
 
      void setRLInfo(ERightLeft& rlInfo)
      {
        m_rlWireHit.setRLInfo(rlInfo);
      }
 
      double getRefDriftLength() const
      {
        return getRLWireHit().getRefDriftLength();
      }
 
      void setRefDriftLength(double driftLength, bool snapRecoPos);
 
      double getSignedRefDriftLength() const
      {
        return getRLWireHit().getSignedRefDriftLength();
      }
 
      double getRefDriftLengthVariance() const
      {
        return getRLWireHit().getRefDriftLengthVariance();
      }
 
      Vector2D getRecoPos2D() const
      {
        return getRecoDisp2D() + getRefPos2D();
      }
 
      void setRecoPos2D(const Vector2D& recoPos2D)
      {
        m_recoDisp2D = recoPos2D - getRefPos2D();
      }
 
      const Vector2D& getRecoDisp2D() const
      {
        return m_recoDisp2D;
      }
 
      Vector2D getFlightDirection2D() const
      {
        ERotation rotation = static_cast<ERotation>(-getRLInfo());
        return getRecoDisp2D().orthogonal(rotation);
      }
 
      double getAlpha() const
      {
        return getRecoPos2D().angleWith(getFlightDirection2D());
      }
 
      void snapToDriftCircle(bool switchSide = false);
 
      Vector3D reconstruct3D(const CDCTrajectory2D& trajectory2D, const double z = 0) const;
 
      const CDCRLWireHit& getRLWireHit() const
      {
        return m_rlWireHit;
      }
 
      void setRLWireHit(const CDCRLWireHit& rlWireHit)
      {
        m_rlWireHit = rlWireHit;
      }
 
    private:
      CDCRLWireHit m_rlWireHit;
 
      Vector2D m_recoDisp2D;
    };
 
 
    std::ostream& operator<<(std::ostream& output, const CDCRecoHit2D& recohit);
  }
}