CDCAxialSegmentPair.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/segments/CDCAxialSegment2D.h>
 
#include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
#include <tracking/trackFindingCDC/ca/AutomatonCell.h>
 
#include <tracking/trackFindingCDC/numerics/EForwardBackward.h>
 
#include <tuple>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCSegment2D;
 
    class CDCAxialSegmentPair  {
 
    public:
      CDCAxialSegmentPair();
 
      CDCAxialSegmentPair(const CDCAxialSegment2D* startSegment,
                          const CDCAxialSegment2D* endSegment);
 
      CDCAxialSegmentPair(const CDCAxialSegment2D* startSegment,
                          const CDCAxialSegment2D* endSegment,
                          const CDCTrajectory2D& trajectory2D);
 
      bool operator==(CDCAxialSegmentPair const& rhs) const
      {
        return
          std::tie(m_startSegment, m_endSegment) ==
          std::tie(rhs.m_startSegment, rhs.m_endSegment);
      }
 
      bool operator<(CDCAxialSegmentPair const& rhs) const
      {
        return
          std::tie(m_startSegment, m_endSegment) <
          std::tie(rhs.m_startSegment, rhs.m_endSegment);
      }
 
      friend bool
      operator<(CDCAxialSegmentPair const& segmentPair, const CDCAxialSegment2D* axialSegment)
      {
        return segmentPair.getStartSegment() < axialSegment;
      }
 
      friend bool
      operator<(const CDCAxialSegment2D* axialSegment, CDCAxialSegmentPair const& segmentPair)
      {
        return axialSegment < segmentPair.getStartSegment();
      }
 
      bool checkSegments() const
      {
        return not(m_startSegment == nullptr or m_endSegment == nullptr);
      }
 
      ISuperLayer getStartISuperLayer() const;
 
      ISuperLayer getEndISuperLayer() const;
 
      const CDCAxialSegment2D* getStartSegment() const
      {
        return m_startSegment;
      }
 
      void setStartSegment(const CDCAxialSegment2D* startSegment)
      {
        m_startSegment = startSegment;
      }
 
      const CDCAxialSegment2D* getEndSegment() const
      {
        return m_endSegment;
      }
 
      void setEndSegment(const CDCAxialSegment2D* endSegment)
      {
        m_endSegment = endSegment;
      }
 
      void setSegments(const CDCSegment2D* startSegment, const CDCSegment2D* endSegment)
      {
        m_startSegment = startSegment;
        m_endSegment = endSegment;
        checkSegments();
      }
 
      CDCTrajectory2D& getTrajectory2D() const
      {
        return m_trajectory2D;
      }
 
      void setTrajectory2D(const CDCTrajectory2D& trajectory2D) const
      { m_trajectory2D =  trajectory2D; }
 
      void clearTrajectory2D() const
      { getTrajectory2D().clear(); }
 
 
      void unsetAndForwardMaskedFlag() const;
 
      void setAndForwardMaskedFlag() const;
 
      void receiveMaskedFlag() const;
 
 
      EForwardBackward isCoaligned(const CDCTrajectory2D& trajectory2D) const;
 
      AutomatonCell& getAutomatonCell() const
      {
        return m_automatonCell;
      }
 
    private:
      const CDCAxialSegment2D* m_startSegment;
 
      const CDCAxialSegment2D* m_endSegment;
 
      mutable CDCTrajectory2D m_trajectory2D;
 
      mutable AutomatonCell m_automatonCell;
    };
  }
}