CDCSegmentTriple.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/eventdata/segments/CDCStereoSegment2D.h>
#include <tracking/trackFindingCDC/eventdata/segments/CDCAxialSegment2D.h>
 
#include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory3D.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
#include <tracking/trackFindingCDC/ca/AutomatonCell.h>
 
#include <tuple>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCAxialSegmentPair;
    class CDCTrajectorySZ;
    class CDCTrajectory2D;
 
    class CDCSegmentTriple {
    public:
 
      CDCSegmentTriple();
 
      CDCSegmentTriple(const CDCAxialSegment2D* startSegment,
                       const CDCAxialSegment2D* endSegment);
 
      explicit CDCSegmentTriple(const CDCAxialSegmentPair& segmentPair);
 
      CDCSegmentTriple(const CDCAxialSegment2D* startSegment,
                       const CDCStereoSegment2D* middleSegment,
                       const CDCAxialSegment2D* endSegment);
 
      CDCSegmentTriple(const CDCAxialSegment2D* startSegment,
                       const CDCStereoSegment2D* middleSegment,
                       const CDCAxialSegment2D* endSegment,
                       const CDCTrajectory3D& trajectory3D);
 
      bool operator==(CDCSegmentTriple const& rhs) const
      {
        return
          std::tie(m_startSegment, m_middleSegment, m_endSegment) ==
          std::tie(rhs.m_startSegment, rhs.m_middleSegment, rhs.m_endSegment);
      }
 
      bool operator<(CDCSegmentTriple const& rhs) const
      {
        return
          std::tie(m_startSegment, m_middleSegment, m_endSegment) <
          std::tie(rhs.m_startSegment, rhs.m_middleSegment, rhs.m_endSegment);
      }
 
      friend bool operator<(CDCSegmentTriple const& segmentTriple, const CDCAxialSegment2D* axialSegment)
      {
        return segmentTriple.getStartSegment() < axialSegment;
      }
 
      friend bool operator<(const CDCAxialSegment2D* axialSegment, CDCSegmentTriple const& segmentTriple)
      {
        return axialSegment < segmentTriple.getStartSegment();
      }
 
      bool checkSegments() const
      {
        return not(getStartSegment() == nullptr) and not(m_middleSegment == nullptr) and
               not(m_endSegment == nullptr);
      }
 
      ISuperLayer getStartISuperLayer() const;
 
      ISuperLayer getMiddleISuperLayer() const;
 
      ISuperLayer getEndISuperLayer() const;
 
      const CDCAxialSegment2D* getStartSegment() const
      {
        return m_startSegment;
      }
 
      void setStartSegment(const CDCAxialSegment2D* startSegment)
      {
        m_startSegment = startSegment;
      }
 
      const CDCStereoSegment2D* getMiddleSegment()  const
      {
        return m_middleSegment;
      }
 
      void setMiddleSegment(const CDCStereoSegment2D* middleSegment)
      {
        m_middleSegment = middleSegment;
      }
 
      const CDCAxialSegment2D* getEndSegment() const
      {
        return m_endSegment;
      }
 
      void setEndSegment(const CDCAxialSegment2D* endSegment)
      {
        m_endSegment = endSegment;
      }
 
      CDCTrajectorySZ getTrajectorySZ() const;
 
      CDCTrajectory2D getTrajectory2D() const;
 
      const CDCTrajectory3D& getTrajectory3D() const
      {
        return m_trajectory3D;
      }
 
      void setTrajectory3D(const CDCTrajectory3D& trajectory3D) const
      {
        m_trajectory3D = trajectory3D;
      }
 
      void clearTrajectory3D() const
      {
        m_trajectory3D.clear();
      }
 
      void unsetAndForwardMaskedFlag() const;
 
      void setAndForwardMaskedFlag() const;
 
      void receiveMaskedFlag() const;
 
      AutomatonCell& getAutomatonCell() const
      {
        return m_automatonCell;
      }
 
    private:
      const CDCAxialSegment2D* m_startSegment;
 
      const CDCStereoSegment2D* m_middleSegment;
 
      const CDCAxialSegment2D* m_endSegment;
 
      mutable CDCTrajectory3D m_trajectory3D;
 
      mutable AutomatonCell m_automatonCell;
    };
  }
}