CDCTrack.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/CDCRecoHit3D.h>
 
#include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory3D.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
#include <tracking/trackFindingCDC/ca/AutomatonCell.h>
 
#include <tracking/trackFindingCDC/ca/Path.h>
 
#include <tracking/trackFindingCDC/utilities/MayBePtr.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCSegment2D;
    class CDCSegment3D;
    class CDCSegmentPair;
    class CDCSegmentTriple;
 
    class CDCWireHit;
    class Vector2D;
    class Vector3D;
 
    class CDCTrack : public std::vector<CDCRecoHit3D> {
    public:
 
      CDCTrack() = default;
 
      explicit CDCTrack(const std::vector<CDCRecoHit3D>& recoHits3D);
 
      explicit CDCTrack(const CDCSegment2D& segment);
 
      static CDCTrack condense(const Path<const CDCTrack>& trackPath);
 
      static CDCTrack condense(const Path<const CDCSegmentTriple>& segmentTriplePath);
 
      static CDCTrack condense(const Path<const CDCSegmentPair>& segmentPairPath);
 
      bool operator<(const CDCTrack& track __attribute__((unused))) const
      {
        return false;
      }
 
      std::vector<CDCSegment3D> splitIntoSegments() const;
 
      ISuperLayer getStartISuperLayer() const
      {
        return front().getISuperLayer();
      }
 
      ISuperLayer getEndISuperLayer() const
      {
        return back().getISuperLayer();
      }
 
      const Vector3D& getStartRecoPos3D() const
      {
        return front().getRecoPos3D();
      }
 
      const Vector3D& getEndRecoPos3D() const
      {
        return back().getRecoPos3D();
      }
 
      void setStartTrajectory3D(const CDCTrajectory3D& startTrajectory3D)
      {
        m_startTrajectory3D = startTrajectory3D;
      }
 
      void setEndTrajectory3D(const CDCTrajectory3D& endTrajectory3D)
      {
        m_endTrajectory3D = endTrajectory3D;
      }
 
      const CDCTrajectory3D& getStartTrajectory3D() const
      {
        return m_startTrajectory3D;
      }
 
      const CDCTrajectory3D& getEndTrajectory3D() const
      {
        return m_endTrajectory3D;
      }
 
      AutomatonCell& getAutomatonCell() const
      {
        return m_automatonCell;
      }
 
      AutomatonCell* operator->() const
      {
        return &m_automatonCell;
      }
 
      void unsetAndForwardMaskedFlag() const;
 
      void setAndForwardMaskedFlag() const;
 
      void receiveMaskedFlag() const;
 
      void forwardTakenFlag(bool takenFlag = true) const;
 
 
      void sortByArcLength2D();
 
      void shiftToPositiveArcLengths2D(bool doForAllTracks = false);
 
      void reverse();
 
      CDCTrack reversed() const;
 
      MayBePtr<const CDCRecoHit3D> find(const CDCWireHit& wireHit) const;
 
      void setHasMatchingSegment(bool hasMatchingSegment = true)
      {
        m_hasMatchingSegment = hasMatchingSegment;
      }
 
      bool getHasMatchingSegment() const
      {
        return m_hasMatchingSegment;
      }
 
      float getQualityIndicator() const
      {
        return m_qualityIndicator;
      }
 
      void setQualityIndicator(const float qualityIndicator)
      {
        m_qualityIndicator = qualityIndicator;
      }
 
    private:
      mutable AutomatonCell m_automatonCell;
 
      CDCTrajectory3D m_startTrajectory3D;
 
      CDCTrajectory3D m_endTrajectory3D;
 
      bool m_hasMatchingSegment = false;
 
      float m_qualityIndicator = NAN;
    };
  }
}