CDCRLWireHitTriple.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/CDCRLWireHitPair.h>
#include <tracking/trackingUtilities/eventdata/hits/CDCRLWireHit.h>
 
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <cdc/topology/EStereoKind.h>
#include <cdc/topology/ISuperLayer.h>
 
#include <iosfwd>
#include <cassert>
 
namespace Belle2 {
  namespace CDC {
    class CDCWire;
  }
  namespace TrackingUtilities {
    class CDCWireHit;

    class CDCRLWireHitTriple {
    public:
      class Shape {
 
      public:
        Shape();

        Shape(const short startToMiddleCellDistance,
              const short middleToEndCellDistance,
              const short oClockDelta);

        short getStartToMiddleCellDistance() const;

        short getMiddleToEndCellDistance() const;

        short getCellExtend() const;

        short getOClockDelta() const;

        bool isValid() const;
 
      private:
        char m_startToMiddleCellDistance;

        char m_middleToEndCellDistance;

        short m_oClockDelta;
      };

      CDCRLWireHitTriple() = default;

      CDCRLWireHitTriple(const CDCRLWireHit& startRLWireHit,
                         const CDCRLWireHit& middleRLWireHit,
                         const CDCRLWireHit& endRLWireHit,
                         int iCluster = 0);

      CDCRLWireHitTriple reversed() const;

      void reverse();

      CDCRLWireHitTriple getAlias() const;

      bool operator==(const CDCRLWireHitTriple& other) const
      {
        return getStartRLWireHit() == other.getStartRLWireHit() and
               getRearRLWireHitPair() == other.getRearRLWireHitPair();
      }
 

      bool operator< (const CDCRLWireHitTriple& other) const
      {
        return getICluster() < other.getICluster() or
               (getICluster() == other.getICluster() and
                (getStartRLWireHit() <  other.getStartRLWireHit() or
                 (getStartRLWireHit() == other.getStartRLWireHit() and
                  getRearRLWireHitPair() < other.getRearRLWireHitPair())));
      }

      friend bool operator< (const CDCRLWireHitTriple& rlWireHitTriple,
                             const CDCRLWireHitPair& rlWireHitPair)
      {
        return rlWireHitTriple.getICluster() < rlWireHitPair.getICluster() or
               (rlWireHitTriple.getICluster() == rlWireHitPair.getICluster() and
                (rlWireHitTriple.getStartRLWireHit() < rlWireHitPair.getFromRLWireHit() or
                 (rlWireHitTriple.getStartRLWireHit() == rlWireHitPair.getFromRLWireHit() and
                  rlWireHitTriple.getMiddleRLWireHit() < rlWireHitPair.getToRLWireHit())));
      }

      friend bool operator< (const CDCRLWireHitPair& rlWireHitPair,
                             const CDCRLWireHitTriple& rlWireHitTriple)
      {
        return rlWireHitPair.getICluster() < rlWireHitTriple.getICluster() or
               (rlWireHitPair.getICluster() == rlWireHitTriple.getICluster() and
                (rlWireHitPair.getFromRLWireHit() < rlWireHitTriple.getStartRLWireHit() or
                 (rlWireHitPair.getFromRLWireHit() == rlWireHitTriple.getStartRLWireHit() and
                  rlWireHitPair.getToRLWireHit() < rlWireHitTriple.getMiddleRLWireHit())));
      }

      Shape getShape() const;

      CDC::ISuperLayer getISuperLayer() const
      {
        assert(getStartRLWireHit().getISuperLayer() == getRearRLWireHitPair().getISuperLayer());
        return getStartRLWireHit().getISuperLayer();
      }

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

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

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

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

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

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

      ERightLeft getStartRLInfo() const
      {
        return getStartRLWireHit().getRLInfo();
      }

      ERightLeft getMiddleRLInfo() const
      {
        return getMiddleRLWireHit().getRLInfo();
      }

      ERightLeft getEndRLInfo() const
      {
        return getEndRLWireHit().getRLInfo();
      }

      const CDCWireHit& getStartWireHit() const
      {
        return getStartRLWireHit().getWireHit();
      }

      const CDCWireHit& getMiddleWireHit() const
      {
        return getMiddleRLWireHit().getWireHit();
      }

      const CDCWireHit& getEndWireHit() const
      {
        return getEndRLWireHit().getWireHit();
      }

      bool hasWireHit(const CDCWireHit& wirehit) const
      {
        return getStartRLWireHit().hasWireHit(wirehit) or
               getRearRLWireHitPair().hasWireHit(wirehit);
      }

      CDCRLWireHit& getStartRLWireHit()
      {
        return m_startRLWireHit;
      }

      CDCRLWireHit& getMiddleRLWireHit()
      {
        return getRearRLWireHitPair().getFromRLWireHit();
      }

      CDCRLWireHit& getEndRLWireHit()
      {
        return getRearRLWireHitPair().getToRLWireHit();
      }

      const CDCRLWireHit& getStartRLWireHit() const
      {
        return m_startRLWireHit;
      }

      const CDCRLWireHit& getMiddleRLWireHit() const
      {
        return getRearRLWireHitPair().getFromRLWireHit();
      }

      const CDCRLWireHit& getEndRLWireHit() const
      {
        return getRearRLWireHitPair().getToRLWireHit();
      }

      CDCRLWireHitPair& getRearRLWireHitPair()
      {
        return m_rearRLWireHitPair;
      }

      const CDCRLWireHitPair& getRearRLWireHitPair() const
      {
        return m_rearRLWireHitPair;
      }

      void setStartRLWireHit(const CDCRLWireHit& startRLWireHit)
      {
        m_startRLWireHit = startRLWireHit;
      }

      void setMiddleRLWireHit(const CDCRLWireHit& middleRLWireHit)
      {
        m_rearRLWireHitPair.setFromRLWireHit(middleRLWireHit);
      }

      void setEndRLWireHit(const CDCRLWireHit& endRLWireHit)
      {
        m_rearRLWireHitPair.setToRLWireHit(endRLWireHit);
      }

      void setStartRLInfo(const ERightLeft startRLInfo)
      {
        m_startRLWireHit.setRLInfo(startRLInfo);
      }

      void setMiddleRLInfo(const ERightLeft middleRLInfo)
      {
        getRearRLWireHitPair().setFromRLInfo(middleRLInfo);
      }

      void setEndRLInfo(const ERightLeft endRLInfo)
      {
        getRearRLWireHitPair().setToRLInfo(endRLInfo);
      }

      int getICluster() const
      {
        return m_rearRLWireHitPair.getICluster();
      }

      void setICluster(int iCluster)
      {
        m_rearRLWireHitPair.setICluster(iCluster);
      }
 
    protected:
      CDCRLWireHit m_startRLWireHit;

      CDCRLWireHitPair m_rearRLWireHitPair;
    };
 
    std::ostream& operator<<(std::ostream& output, const CDCRLWireHitTriple& rlWireHitTriple);
  }
}