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/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
 
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCWireHit;
    class CDCWire;
    class WireNeighborKind;
 
    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();
      }
 
      WireNeighborKind getNeighborKind() const;
 
      ISuperLayer getISuperLayer() const
      {
        ISuperLayer result = getFromRLWireHit().getISuperLayer();
        return result == getToRLWireHit().getISuperLayer() ? result : ISuperLayerUtil::c_Invalid;
      }
 
      EStereoKind getStereoKind() const
      {
        return ISuperLayerUtil::getStereoKind(getISuperLayer());
      }
 
      bool isAxial() const
      {
        return getStereoKind() == EStereoKind::c_Axial;
      }
 
      const CDCWire& getFromWire() const
      {
        return getFromRLWireHit().getWire();
      }
 
      const CDCWire& getToWire() const
      {
        return getToRLWireHit().getWire();
      }
 
      bool hasWire(const 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;
    };
  }
}