CDCObservations2D.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/fitting/EFitPos.h>
#include <tracking/trackFindingCDC/fitting/EFitVariance.h>
 
#include <tracking/trackingUtilities/numerics/ESign.h>
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/EForwardBackward.h>
 
#include <Math/Vector2D.h>
 
#include <vector>
#include <iterator>
 
namespace Belle2 {
  namespace CDC {
    class CDCWire;
  }
 
  namespace TrackingUtilities {
    class CDCRLWireHit;
    class CDCTrajectory2D;
    class CDCWireHit;
    class CDCTrack;
    class CDCRecoHit3D;
    class CDCRecoHit2D;
    class CDCRLWireHitPair;
    class CDCRLWireHitTriple;
    class CDCFacet;
    class CDCWireHitSegment;
    class CDCSegment2D;
    class CDCSegment3D;
    class CDCAxialSegmentPair;
  }
  namespace TrackFindingCDC {

    class CDCObservations2D {
 
    public:
      explicit CDCObservations2D(EFitPos fitPos = EFitPos::c_RecoPos,
                                 EFitVariance fitVariance = EFitVariance::c_Proper)
        : m_fitPos(fitPos)
        , m_fitVariance(fitVariance)
      {
      }
 
    public:
      static double getPseudoDriftLengthVariance(double driftLength,
                                                 double driftLengthVariance)
      {
        return driftLength * driftLength + driftLengthVariance;
      }

      static double getPseudoDriftLengthVariance(const TrackingUtilities::CDCWireHit& wireHit);

      std::size_t size() const
      {
        return m_observations.size() / 4;
      }

      double* data()
      {
        return m_observations.data();
      }

      bool empty() const
      {
        return m_observations.empty();
      }

      void clear()
      {
        m_observations.clear();
      }

      void reserve(std::size_t nObservations)
      {
        m_observations.reserve(nObservations * 4);
      }

      double getX(int iObservation) const
      {
        return m_observations[iObservation * 4];
      }

      double getY(int iObservation) const
      {
        return m_observations[iObservation * 4 + 1];
      }

      double getDriftLength(int iObservation) const
      {
        return m_observations[iObservation * 4 + 2];
      }

      double getWeight(int iObservation) const
      {
        return m_observations[iObservation * 4 + 3];
      }

      std::size_t fill(double x, double y, double signedRadius = 0.0, double weight = 1.0);

      std::size_t fill(const ROOT::Math::XYVector& pos2D, double signedRadius = 0.0, double weight = 1.0);

      std::size_t append(const TrackingUtilities::CDCWireHit& wireHit,
                         TrackingUtilities::ERightLeft rlInfo = TrackingUtilities::ERightLeft::c_Unknown);

      std::size_t append(const TrackingUtilities::CDCWireHit* wireHit,
                         TrackingUtilities::ERightLeft rlInfo = TrackingUtilities::ERightLeft::c_Unknown);

      std::size_t append(const TrackingUtilities::CDCRLWireHit& rlWireHit);

      std::size_t append(const TrackingUtilities::CDCRLWireHitPair& rlWireHitPair);

      std::size_t append(const TrackingUtilities::CDCRLWireHitTriple& rlWireHitTriple);

      std::size_t append(const TrackingUtilities::CDCFacet& facet);

      std::size_t append(const TrackingUtilities::CDCRecoHit2D& recoHit2D);

      std::size_t append(const TrackingUtilities::CDCRecoHit3D& recoHit3D);

      std::size_t appendRange(const TrackingUtilities::CDCSegment2D& segment2D);

      std::size_t appendRange(const TrackingUtilities::CDCSegment3D& segment3D);

      std::size_t appendRange(const TrackingUtilities::CDCAxialSegmentPair& axialSegmentPair);

      std::size_t appendRange(const TrackingUtilities::CDCTrack& track);

      std::size_t appendRange(const std::vector<const CDC::CDCWire*>& wires);

      std::size_t appendRange(const TrackingUtilities::CDCWireHitSegment& wireHits);

      template<class ARange>
      std::size_t appendRange(const ARange& range)
      {
        std::size_t nAppendedHits = 0;
        using std::begin;
        using std::end;
        for (const auto& item : range) {
          nAppendedHits += append(item);
        }
        return nAppendedHits;
      }

      ROOT::Math::XYVector getFrontPos2D() const
      {
        return empty() ? ROOT::Math::XYVector() : ROOT::Math::XYVector(getX(0), getY(0));
      }

      ROOT::Math::XYVector getBackPos2D() const
      {
        return empty() ? ROOT::Math::XYVector() : ROOT::Math::XYVector(getX(size() - 1), getY(size() - 1));
      }

      double getTotalPerpS(const TrackingUtilities::CDCTrajectory2D& trajectory2D) const;

      bool isForwardTrajectory(const TrackingUtilities::CDCTrajectory2D& trajectory2D) const
      {
        return getTotalPerpS(trajectory2D) > 0.0;
      }

      TrackingUtilities::EForwardBackward isCoaligned(const TrackingUtilities::CDCTrajectory2D& trajectory2D) const
      {
        return static_cast<TrackingUtilities::EForwardBackward>(TrackingUtilities::sign(getTotalPerpS(trajectory2D)));
      }

      ROOT::Math::XYVector getCentralPoint() const;

      void passiveMoveBy(const ROOT::Math::XYVector& origin);

      ROOT::Math::XYVector centralize();

      std::size_t getNObservationsWithDriftRadius() const;
 
    public:
      EFitPos getFitPos() const
      {
        return m_fitPos;
      }

      void setFitPos(EFitPos fitPos)
      {
        m_fitPos = fitPos;
      }

      void setFitVariance(EFitVariance fitVariance)
      {
        m_fitVariance = fitVariance;
      }
 
    private:
      std::vector<double> m_observations;

      EFitPos m_fitPos;

      EFitVariance m_fitVariance;
 
    };
 
  }
}