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/trackingUtilities/eventdata/hits/CDCRLWireHit.h>
 
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/ERotation.h>
 
#include <cdc/topology/EStereoKind.h>
#include <cdc/topology/ISuperLayer.h>
 
#include <framework/geometry/VectorUtil.h>
#include <tracking/trackingUtilities/geometry/VectorUtil.h>
 
#include <Math/Vector3D.h>
#include <Math/Vector2D.h>
#include <Math/VectorUtil.h>
 
namespace Belle2 {
  class CDCSimHit;
  class CDCHit;
 
  namespace CDC {
    class CDCWire;
  }
 
  namespace TrackingUtilities {
    // Forward declaration.
    class CDCTrajectory3D;
    class CDCTrajectory2D;
    class CDCTrajectorySZ;
    class CDCWireHit;
    class CDCRecoHit2D;

    class CDCRecoHit3D  {
    public:
      CDCRecoHit3D() = default;

      CDCRecoHit3D(const CDCRLWireHit& rlWireHit, const ROOT::Math::XYZVector& 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
                 VectorUtil::smaller(getRecoPos3D(), other.getRecoPos3D())));
      }

      friend bool operator<(const CDCRecoHit3D& recoHit3D, const CDC::CDCWire& wire)
      {
        return recoHit3D.getRLWireHit() < wire;
      }

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

      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();
      }

      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);
      }

      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 ROOT::Math::XYVector& getRefPos2D() const
      {
        return getRLWireHit().getRefPos2D();
      }

      const ROOT::Math::XYZVector& getRecoPos3D() const
      {
        return m_recoPos3D;
      }

      void setRecoPos3D(const ROOT::Math::XYZVector& recoPos3D)
      {
        m_recoPos3D = recoPos3D;
      }

      const ROOT::Math::XYVector getRecoPos2D() const
      {
        return VectorUtil::getXYVector(getRecoPos3D());
      }

      double getRecoZ() const
      {
        return getRecoPos3D().z();
      }

      ROOT::Math::XYVector getRecoDisp2D() const;

      ROOT::Math::XYVector getFlightDirection2D() const
      {
        ERotation rotation = static_cast<ERotation>(-getRLInfo());
        return VectorUtil::Orthogonal(getRecoDisp2D(), rotation);
      }

      double getAlpha() const
      {
        return ROOT::Math::VectorUtil::DeltaPhi(getRecoPos2D(), getFlightDirection2D());
      }

      CDCRecoHit2D getRecoHit2D() const;

      CDCRecoHit2D stereoProjectToRef() const;

      ROOT::Math::XYVector 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;

      ROOT::Math::XYZVector m_recoPos3D;

      double m_arcLength2D = 0;
    };
  }
}