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/trackingUtilities/eventdata/hits/CDCRLWireHit.h>
 
#include <cdc/topology/EStereoKind.h>
#include <cdc/topology/ISuperLayer.h>
 
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/ERotation.h>
 
#include <tracking/trackingUtilities/geometry/Vector2D.h>
 
#include <iosfwd>
 
namespace Belle2 {
  class CDCSimHit;
  class CDCHit;
 
  namespace CDC {
    class CDCWire;
  }
 
  namespace TrackingUtilities {
    class CDCTrajectory2D;
    class CDCWireHit;
    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 CDC::CDCWire& wire)
      { return recoHit2D.getRLWireHit() < wire; }

      friend bool operator<(const CDC::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(); }

      CDC::EStereoKind getStereoKind() const
      {
        return getRLWireHit().getStereoKind();
      }

      bool isAxial() const
      {
        return getRLWireHit().isAxial();
      }

      CDC::ISuperLayer getISuperLayer() const
      {
        return getRLWireHit().getISuperLayer();
      }

      const CDC::CDCWire& getWire() const
      {
        return getRLWireHit().getWire();
      }

      const ROOT::Math::XYVector& getRefPos2D() const
      {
        return getRLWireHit().getRefPos2D();
      }

      bool isOnWire(const CDC::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);
  }
}