CDCRLWireHitPair.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 <cdc/topology/EStereoKind.h>
#include <cdc/topology/ISuperLayer.h>
 
namespace Belle2 {
 
  namespace CDC {
    class CDCWire;
    class WireNeighborKind;
 
  }
 
  namespace TrackingUtilities {
    class CDCWireHit;
    class CDCRLWireHitPair {
    public:
      CDCRLWireHitPair() = default;

      CDCRLWireHitPair(const CDCRLWireHit& fromRLWireHit,
                       const CDCRLWireHit& toRLWireHit,
                       int iCluster = 0);

      CDCRLWireHitPair reversed() const;

      void reverse();

      CDCRLWireHitPair getAlias() const;

      bool operator==(const CDCRLWireHitPair& other) const
      {
        return getFromRLWireHit() == other.getFromRLWireHit() and
               getToRLWireHit() == other.getToRLWireHit();
      }

      bool operator<(const CDCRLWireHitPair& other) const
      {
        return getICluster() < other.getICluster() or
               (getICluster() == other.getICluster() and
                (getFromRLWireHit() < other.getFromRLWireHit() or
                 (getFromRLWireHit() == other.getFromRLWireHit() and
                  getToRLWireHit() < other.getToRLWireHit())));
      }

      friend bool operator<(const CDCRLWireHitPair& rlWireHitPair, const CDCWireHit& wireHit)
      {
        return rlWireHitPair.getFromRLWireHit() < wireHit;
      }

      friend bool operator<(const CDCWireHit& wireHit, const CDCRLWireHitPair& rlWireHitPair)
      {
        return wireHit < rlWireHitPair.getFromRLWireHit();
      }

      CDC::WireNeighborKind getNeighborKind() const;

      CDC::ISuperLayer getISuperLayer() const
      {
        CDC::ISuperLayer result = getFromRLWireHit().getISuperLayer();
        return result == getToRLWireHit().getISuperLayer() ? result : CDC::ISuperLayerUtil::c_Invalid;
      }

      CDC::EStereoKind getStereoKind() const
      {
        return CDC::ISuperLayerUtil::getStereoKind(getISuperLayer());
      }

      bool isAxial() const
      {
        return getStereoKind() == CDC::EStereoKind::c_Axial;
      }

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

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

      bool hasWire(const CDC::CDCWire& wire) const
      {
        return getFromRLWireHit().isOnWire(wire) or getToRLWireHit().isOnWire(wire);
      }

      const CDCWireHit& getFromWireHit() const
      {
        return getFromRLWireHit().getWireHit();
      }

      const CDCWireHit& getToWireHit() const
      {
        return getToRLWireHit().getWireHit();
      }

      bool hasWireHit(const CDCWireHit& wirehit) const
      {
        return getFromRLWireHit().hasWireHit(wirehit) or getToRLWireHit().hasWireHit(wirehit);
      }

      ERightLeft getFromRLInfo() const
      {
        return getFromRLWireHit().getRLInfo();
      }

      ERightLeft getToRLInfo() const
      {
        return getToRLWireHit().getRLInfo();
      }

      CDCRLWireHit& getFromRLWireHit()
      {
        return m_fromRLWireHit;
      }

      CDCRLWireHit& getToRLWireHit()
      {
        return m_toRLWireHit;
      }

      const CDCRLWireHit& getFromRLWireHit() const
      {
        return m_fromRLWireHit;
      }

      const CDCRLWireHit& getToRLWireHit() const
      {
        return m_toRLWireHit;
      }

      void setFromRLWireHit(const CDCRLWireHit& fromRLWireHit)
      {
        m_fromRLWireHit = fromRLWireHit;
      }

      void setToRLWireHit(const CDCRLWireHit& toRLWireHit)
      {
        m_toRLWireHit = toRLWireHit;
      }

      void setFromRLInfo(ERightLeft fromRLInfo);

      void setToRLInfo(ERightLeft toRLInfo);

      int getICluster() const
      {
        return m_iCluster;
      }

      void setICluster(int iCluster)
      {
        m_iCluster = iCluster;
      }
 
    protected:
      CDCRLWireHit m_fromRLWireHit;

      CDCRLWireHit m_toRLWireHit;

      int m_iCluster = -1;
    };
  }
}