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/trackFindingCDC/geometry/Vector2D.h>
 
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/EForwardBackward.h>
 
#include <vector>
#include <iterator>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class CDCTrajectory2D;
    class CDCWire;
    class CDCWireHit;
    class CDCRLWireHit;
    class CDCRLWireHitPair;
    class CDCRLWireHitTriple;
    class CDCFacet;
    class CDCRecoHit2D;
    class CDCRecoHit3D;
    class CDCWireHitSegment;
    class CDCSegment2D;
    class CDCSegment3D;
    class CDCAxialSegmentPair;
    class CDCTrack;
 
    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 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 Vector2D& pos2D, double signedRadius = 0.0, double weight = 1.0);
 
      std::size_t append(const CDCWireHit& wireHit, ERightLeft rlInfo = ERightLeft::c_Unknown);
 
      std::size_t append(const CDCWireHit* wireHit, ERightLeft rlInfo = ERightLeft::c_Unknown);
 
      std::size_t append(const CDCRLWireHit& rlWireHit);
 
      std::size_t append(const CDCRLWireHitPair& rlWireHitPair);
 
      std::size_t append(const CDCRLWireHitTriple& rlWireHitTriple);
 
      std::size_t append(const CDCFacet& facet);
 
      std::size_t append(const CDCRecoHit2D& recoHit2D);
 
      std::size_t append(const CDCRecoHit3D& recoHit3D);
 
      std::size_t appendRange(const CDCSegment2D& segment2D);
 
      std::size_t appendRange(const CDCSegment3D& segment3D);
 
      std::size_t appendRange(const CDCAxialSegmentPair& axialSegmentPair);
 
      std::size_t appendRange(const CDCTrack& track);
 
      std::size_t appendRange(const std::vector<const CDCWire*>& wires);
 
      std::size_t appendRange(const 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;
      }
 
      Vector2D getFrontPos2D() const
      {
        return empty() ? Vector2D() : Vector2D(getX(0), getY(0));
      }
 
      Vector2D getBackPos2D() const
      {
        return empty() ? Vector2D() : Vector2D(getX(size() - 1), getY(size() - 1));
      }
 
      double getTotalPerpS(const CDCTrajectory2D& trajectory2D) const;
 
      bool isForwardTrajectory(const CDCTrajectory2D& trajectory2D) const
      {
        return getTotalPerpS(trajectory2D) > 0.0;
      }
 
      EForwardBackward isCoaligned(const CDCTrajectory2D& trajectory2D) const
      {
        return static_cast<EForwardBackward>(sign(getTotalPerpS(trajectory2D)));
      }
 
      Vector2D getCentralPoint() const;
 
      void passiveMoveBy(const Vector2D& origin);
 
      Vector2D 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;
 
    };
 
  }
}