CDCSegmentPair.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014 - 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/trajectories/CDCTrajectory3D.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
 
#include <tracking/trackFindingCDC/ca/AutomatonCell.h>
 
#include <tracking/trackFindingCDC/numerics/EForwardBackward.h>
 
#include <cassert>
#include <cstddef>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCSegment2D;
    class CDCTrajectory2D;
    class CDCTrajectorySZ;
 
    class CDCSegmentPair {
    public:
      CDCSegmentPair();
 
      CDCSegmentPair(const CDCSegment2D* fromSegment, const CDCSegment2D* toSegment);
 
      CDCSegmentPair(const CDCSegment2D* fromSegment,
                     const CDCSegment2D* toSegment,
                     const CDCTrajectory3D& trajectory3D);
 
      bool operator==(CDCSegmentPair const& rhs) const
      {
        return getFromSegment() == rhs.getFromSegment() and getToSegment() == rhs.getToSegment();
      }
 
      bool operator<(CDCSegmentPair const& rhs) const
      {
        return (getFromSegment() < rhs.getFromSegment() or
                (getFromSegment() == rhs.getFromSegment() and getToSegment() < rhs.getToSegment()));
      }
 
      friend bool operator<(const CDCSegmentPair& segmentPair, const CDCSegment2D* segment)
      {
        return segmentPair.getFromSegment() < segment;
      }
 
      friend bool operator<(const CDCSegment2D* segment, const CDCSegmentPair& segmentPair)
      {
        return segment < segmentPair.getFromSegment();
      }
 
      bool checkSegmentsNonNullptr() const
      {
        return getFromSegment() != nullptr and getToSegment() != nullptr;
      }
 
      bool checkSegmentsStereoKinds() const
      {
        return (getFromStereoKind() == EStereoKind::c_Axial) xor
               (getToStereoKind() == EStereoKind::c_Axial);
      }
 
      bool checkSegments() const
      {
        return checkSegmentsNonNullptr() and checkSegmentsStereoKinds();
      }
 
      EStereoKind getFromStereoKind() const;
 
      EStereoKind getToStereoKind() const;
 
      ISuperLayer getFromISuperLayer() const;
 
      ISuperLayer getToISuperLayer() const;
 
      std::size_t size() const;
 
      const CDCSegment2D* getFromSegment() const
      {
        return m_fromSegment;
      }
 
      void setFromSegment(const CDCSegment2D* fromSegment)
      {
        setSegments(fromSegment, getToSegment());
      }
 
      const CDCSegment2D* getToSegment() const
      {
        return m_toSegment;
      }
 
      void setToSegment(const CDCSegment2D* toSegment)
      {
        setSegments(getFromSegment(), toSegment);
      }
 
      const CDCSegment2D* getStereoSegment() const
      {
        return getFromStereoKind() != EStereoKind::c_Axial ? getFromSegment() : getToSegment();
      }
 
      const CDCSegment2D* getAxialSegment() const
      {
        return getFromStereoKind() == EStereoKind::c_Axial ? getFromSegment() : getToSegment();
      }
 
      void setSegments(const CDCSegment2D* fromSegment, const CDCSegment2D* toSegment)
      {
        m_fromSegment = fromSegment;
        m_toSegment = toSegment;
        assert(checkSegmentsNonNullptr());
        assert(checkSegmentsStereoKinds());
      }
 
      double computeDeltaPhiAtSuperLayerBound() const;
 
      double computeFromIsBeforeTo() const
      {
        return computeFromIsBeforeToFitless();
      }
 
      double computeToIsAfterFrom() const
      {
        return computeToIsAfterFromFitless();
      }
 
      double computeIsCoaligned() const
      {
        return computeIsCoalignedFitless();
      }
 
      double computeFromIsBeforeToFitless() const;
 
      double computeToIsAfterFromFitless() const;
 
      double computeIsCoalignedFitless() const;
 
 
      EForwardBackward isCoaligned(const CDCTrajectory2D& trajectory2D) const;
 
      void setTrajectory3D(const CDCTrajectory3D& trajectory3D) const
      {
        m_trajectory3D = trajectory3D;
      }
 
      CDCTrajectory3D& getTrajectory3D() const
      {
        return m_trajectory3D;
      }
 
      CDCTrajectory2D getTrajectory2D() const;
 
      CDCTrajectorySZ getTrajectorySZ() const;
 
      void clearTrajectory3D() const
      {
        getTrajectory3D().clear();
      }
 
      void unsetAndForwardMaskedFlag() const;
 
      void setAndForwardMaskedFlag() const;
 
      void receiveMaskedFlag() const;
 
      AutomatonCell& getAutomatonCell() const
      {
        return m_automatonCell;
      }
 
    private:
      const CDCSegment2D* m_fromSegment;
 
      const CDCSegment2D* m_toSegment;
 
      mutable CDCTrajectory3D m_trajectory3D;
 
      mutable AutomatonCell m_automatonCell;
    };
  }
}