CDCRecoHit3D.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/geometry/Vector3D.h>
#include <tracking/trackFindingCDC/geometry/Vector2D.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>
 
namespace Belle2 {
  class CDCSimHit;
  class CDCHit;
 
  namespace TrackFindingCDC {
    // Forward declaration.
    class CDCTrajectory3D;
    class CDCTrajectory2D;
    class CDCTrajectorySZ;
    class CDCRecoHit2D;
    class CDCWireHit;
    class CDCWire;
 
    class CDCRecoHit3D  {
    public:
      CDCRecoHit3D() = default;
 
      CDCRecoHit3D(const CDCRLWireHit& rlWireHit, const Vector3D& recoPos3D, double arcLength2D = 0);
 
      static CDCRecoHit3D fromSimHit(const CDCWireHit* wireHit, const CDCSimHit& simHit);
 
      static CDCRecoHit3D reconstruct(const CDCRecoHit2D& recoHit2D,
                                      const CDCTrajectory2D& trajectory2D);
 
      static CDCRecoHit3D reconstruct(const CDCRLWireHit& rlWireHit,
                                      const CDCTrajectory2D& trajectory2D);
 
      static CDCRecoHit3D reconstruct(const CDCWireHit* wireHit,
                                      ERightLeft rlInfo,
                                      const CDCTrajectory2D& trajectory2D);
 
      static CDCRecoHit3D reconstructNearest(const CDCWireHit* axialWireHit,
                                             const CDCTrajectory2D& trajectory2D);
 
      static CDCRecoHit3D reconstruct(const CDCRecoHit2D& recoHit,
                                      const CDCTrajectory3D& trajectory3D);
 
      static CDCRecoHit3D reconstruct(const CDCRecoHit2D& recoHit2D,
                                      const CDCTrajectory2D& trajectory2D,
                                      const CDCTrajectorySZ& trajectorySZ);
 
    public:
      static CDCRecoHit3D average(const CDCRecoHit3D& first,
                                  const CDCRecoHit3D& second);
 
      void reverse();
 
      CDCRecoHit3D reversed() const;
 
      operator const Belle2::CDCHit* () const
      {
        return static_cast<const CDCHit*>(getRLWireHit());
      }
 
      bool operator==(const CDCRecoHit3D& other) const
      {
        return getRLWireHit() == other.getRLWireHit() and
               getRLInfo() == other.getRLInfo() and
               getRecoPos3D() == other.getRecoPos3D();
      }
 
      bool operator<(const CDCRecoHit3D& other) const
      {
        return (getRLWireHit() < other.getRLWireHit() or
                (getRLWireHit() == other.getRLWireHit() and
                 getRecoPos3D() < other.getRecoPos3D()));
      }
 
      friend bool operator<(const CDCRecoHit3D& recoHit3D, const CDCWire& wire)
      {
        return recoHit3D.getRLWireHit() < wire;
      }
 
      friend bool operator<(const CDCWire& wire, const CDCRecoHit3D& recoHit3D)
      {
        return wire < recoHit3D.getRLWireHit();
      }
 
      friend bool operator<(const CDCRecoHit3D& recoHit3D, const CDCWireHit& wireHit)
      {
        return recoHit3D.getRLWireHit() < wireHit;
      }
 
      friend bool operator<(const CDCWireHit& wireHit, const CDCRecoHit3D& recoHit3D)
      {
        return wireHit < recoHit3D.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();
      }
 
      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);
      }
 
      const CDCRLWireHit& getRLWireHit() const
      {
        return m_rlWireHit;
      }
 
      void setRLWireHit(const CDCRLWireHit& rlWireHit)
      {
        m_rlWireHit = rlWireHit;
      }
 
      ERightLeft getRLInfo() const
      {
        return getRLWireHit().getRLInfo();
      }
 
      void setRLInfo(ERightLeft rlInfo)
      {
        m_rlWireHit.setRLInfo(rlInfo);
      }
 
      const Vector2D& getRefPos2D() const
      {
        return getRLWireHit().getRefPos2D();
      }
 
      const Vector3D& getRecoPos3D() const
      {
        return m_recoPos3D;
      }
 
      void setRecoPos3D(const Vector3D& recoPos3D)
      {
        m_recoPos3D = recoPos3D;
      }
 
      const Vector2D& getRecoPos2D() const
      {
        return getRecoPos3D().xy();
      }
 
      double getRecoZ() const
      {
        return getRecoPos3D().z();
      }
 
      Vector2D getRecoDisp2D() const;
 
      Vector2D getFlightDirection2D() const
      {
        ERotation rotation = static_cast<ERotation>(-getRLInfo());
        return getRecoDisp2D().orthogonal(rotation);
      }
 
      double getAlpha() const
      {
        return getRecoPos2D().angleWith(getFlightDirection2D());
      }
 
      CDCRecoHit2D getRecoHit2D() const;
 
      CDCRecoHit2D stereoProjectToRef() const;
 
      Vector2D getRecoWirePos2D() const;
 
      void snapToDriftCircle(bool switchSide = false);
 
      double getSignedRecoDriftLength() const
      {
        return getRLWireHit().getSignedRefDriftLength();
      }
 
      void setRecoDriftLength(double driftLength, bool snapRecoPos);
 
      double getRecoDriftLengthVariance() const
      {
        return getRLWireHit().getRefDriftLengthVariance();
      }
 
      void shiftArcLength2D(double arcLength2DOffSet)
      {
        m_arcLength2D += arcLength2DOffSet;
      }
 
      double getArcLength2D() const
      {
        return m_arcLength2D;
      }
 
      void setArcLength2D(const double arcLength2D)
      {
        m_arcLength2D = arcLength2D;
      }
 
      bool isInCellZBounds(const double factor = 1) const;
 
    private:
      CDCRLWireHit m_rlWireHit;
 
      Vector3D m_recoPos3D;
 
      double m_arcLength2D = 0;
    };
  }
}