PmaElement3D.h

Go to the documentation of this file.

#ifndef PmaElement3D_h
#define PmaElement3D_h

#include <cmath>
#include <vector>

#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larreco/RecoAlg/PMAlg/Utilities.h"

class TVector2;
#include "TVector3.h"

namespace pma {
  class Element3D;
  class Hit3D;
  class Track3D;
}

class pma::Element3D {
public:
  virtual ~Element3D();

  int TPC(void) const { return fTPC; }
  int Cryo(void) const { return fCryo; }

  virtual double GetDistance2To(const TVector3& p3d) const = 0;

  virtual double GetDistance2To(const TVector2& p2d, unsigned int view) const = 0;

  virtual pma::Vector3D GetDirection3D(void) const = 0;

  virtual TVector3 GetUnconstrainedProj3D(const TVector2& p2d, unsigned int view) const = 0;

  virtual void SetProjection(pma::Hit3D& h) const = 0;

  virtual double Length2(void) const = 0;
  double Length(void) const { return sqrt(Length2()); }

  const std::vector<pma::Hit3D*>& Hits(void) const { return fAssignedHits; }

  bool HasHit(const pma::Hit3D* h) const
  {
    for (const auto a : fAssignedHits) {
      if (h == a) return true;
    }
    return false;
  }

  pma::Hit3D& Hit(size_t index) { return *(fAssignedHits[index]); }
  void RemoveHitAt(size_t index)
  {
    if (index < fAssignedHits.size()) fAssignedHits.erase(fAssignedHits.begin() + index);
  }
  void AddHit(pma::Hit3D* h)
  {
    fAssignedHits.push_back(h);
    SetProjection(*h);
  }

  size_t NHits(void) const { return fAssignedHits.size(); }
  size_t NEnabledHits(unsigned int view = geo::kUnknown) const;
  size_t NPrecalcEnabledHits(void) const { return fNThisHitsEnabledAll; }

  TVector3 const& ReferencePoint(size_t index) const { return *(fAssignedPoints[index]); }
  size_t NPoints(void) const { return fAssignedPoints.size(); }
  void AddPoint(TVector3* p) { fAssignedPoints.push_back(p); }

  virtual void ClearAssigned(pma::Track3D* trk = 0);

  void UpdateHitParams(void);
  void UpdateProjection(void)
  {
    for (auto h : fAssignedHits)
      SetProjection(*h);
  }
  void SortHits(void);

  double SumDist2(void) const;
  double SumDist2(unsigned int view) const;
  double SumHitsQ(unsigned int view) const { return fSumHitsQ[view]; }
  unsigned int NHits(unsigned int view) const { return fNHits[view]; }
  unsigned int NThisHits(unsigned int view) const { return fNThisHits[view]; }

  double HitsRadius3D(unsigned int view) const;

  bool IsFrozen(void) const { return fFrozen; }
  void SetFrozen(bool state) { fFrozen = state; }

  bool SelectRndHits(size_t nmax_per_view);
  bool SelectAllHits(void);

  static float OptFactor(unsigned int view) { return fOptFactors[view]; }
  static void SetOptFactor(unsigned int view, float value) { fOptFactors[view] = value; }

protected:
  Element3D(void); // Element3D is only a common base for nodes and segments
  int fTPC, fCryo; // -1 if out of any TPC or cryostat

  virtual double SumDist2Hits(void) const = 0;

  bool fFrozen;
  std::vector<pma::Hit3D*> fAssignedHits; // 2D hits
  std::vector<TVector3*> fAssignedPoints; // 3D peculiar points reconstructed elsewhere
  size_t fNThisHits[3];
  size_t fNThisHitsEnabledAll;
  size_t fNHits[3];
  double fSumHitsQ[3];
  double fHitsRadius;

  static float fOptFactors[3]; // impact factors of data from various 2D views
};

#endif