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/trackingUtilities/eventdata/hits/CDCRecoHit3D.h>
 
#include <tracking/trackingUtilities/eventdata/trajectories/CDCTrajectory3D.h>
 
#include <cdc/topology/ISuperLayer.h>
 
#include <tracking/trackingUtilities/ca/AutomatonCell.h>
 
#include <tracking/trackingUtilities/ca/Path.h>
 
#include <tracking/trackingUtilities/utilities/MayBePtr.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackingUtilities {
    class CDCWireHit;
    class CDCSegment2D;
    class CDCSegment3D;
    class CDCSegmentPair;
    class CDCSegmentTriple;

    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;

      CDC::ISuperLayer getStartISuperLayer() const
      {
        return front().getISuperLayer();
      }

      CDC::ISuperLayer getEndISuperLayer() const
      {
        return back().getISuperLayer();
      }

      const ROOT::Math::XYZVector& getStartRecoPos3D() const
      {
        return front().getRecoPos3D();
      }

      const ROOT::Math::XYZVector& 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;

      float m_qualityIndicator = NAN;

      bool m_hasMatchingSegment = false;
    };
  }
}