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/trackFindingCDC/eventdata/hits/CDCRLWireHitPair.h>
#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>
 
#include <iosfwd>
#include <cassert>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCWireHit;
    class CDCWire;
 
    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;
 
      ISuperLayer getISuperLayer() const
      {
        assert(getStartRLWireHit().getISuperLayer() == getRearRLWireHitPair().getISuperLayer());
        return getStartRLWireHit().getISuperLayer();
      }
 
      EStereoKind getStereoKind() const
      {
        return ISuperLayerUtil::getStereoKind(getISuperLayer());
      }
 
      bool isAxial() const
      {
        return getStereoKind() == EStereoKind::c_Axial;
      }
 
      const CDCWire& getStartWire() const
      {
        return getStartRLWireHit().getWire();
      }
 
      const CDCWire& getMiddleWire() const
      {
        return getMiddleRLWireHit().getWire();
      }
 
      const CDCWire& getEndWire() const
      {
        return getEndRLWireHit().getWire();
      }
 
      bool hasWire(const 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);
  }
}