pma Namespace Reference

Classes
class	Element3D
class	Hit3D
class	Node3D
class	Segment3D
class	Track3D
class	TrkCandidate
class	TrkCandidateColl
class	VtxCandidate
class	SortedObjectBase
class	SortedBranchBase
struct	bTrajectory3DOrderLess
struct	bTrajectory3DDistLess
struct	bTrack3DLonger
class	bSegmentProjLess
class	bDistCenterLess2D
class	bDistCenterLess3D
class	PMAlgCosmicTagger
class	PMAlgStitching
class	PMAlgTrackingBase
class	PMAlgFitter
class	PMAlgTracker
class	PMAlgVertexing
class	ProjectionMatchingAlg

Typedefs
typedef std::map< unsigned int, std::vector< art::Ptr < recob::Hit > > >	view_hitmap
typedef std::map< unsigned int, view_hitmap >	tpc_view_hitmap
typedef std::map< unsigned int, tpc_view_hitmap >	cryo_tpc_view_hitmap
typedef ROOT::Math::DisplacementVector2D < ROOT::Math::Cartesian2D < double > >	Vector2D
typedef recob::tracking::Vector_t	Vector3D
typedef std::map< size_t, std::vector< double > >	dedx_map
typedef std::map< size_t, pma::TrkCandidateColl >	tpc_track_map

Functions
double	Dist2 (const TVector2 &v1, const TVector2 &v2)
double	Dist2 (const Vector2D &v1, const Vector2D &v2)
template<typename T , typename U >
double	Dist2 (const T &v1, const U &v2)
size_t	GetHitsCount (const std::vector< pma::Hit3D * > &hits, unsigned int view)
double	GetSummedADC (const std::vector< pma::Hit3D * > &hits, unsigned int view=geo::kUnknown)
double	GetSummedAmpl (const std::vector< pma::Hit3D * > &hits, unsigned int view=geo::kUnknown)
double	GetHitsRadius3D (const std::vector< pma::Hit3D * > &hits, bool exact=false)
double	GetHitsRadius2D (const std::vector< pma::Hit3D * > &hits, bool exact=false)
double	GetSegmentProjVector (const TVector2 &p, const TVector2 &p0, const TVector2 &p1)
double	GetSegmentProjVector (const Vector2D &p, const Vector2D &p0, const Vector2D &p1)
double	GetSegmentProjVector (const TVector3 &p, const TVector3 &p0, const TVector3 &p1)
double	GetSegmentProjVector (const Vector3D &p, const Vector3D &p0, const Vector3D &p1)
TVector2	GetProjectionToSegment (const TVector2 &p, const TVector2 &p0, const TVector2 &p1)
TVector3	GetProjectionToSegment (const TVector3 &p, const TVector3 &p0, const TVector3 &p1)
double	SolveLeastSquares3D (const std::vector< std::pair< TVector3, TVector3 >> &lines, TVector3 &result)
TVector2	GetProjectionToPlane (const TVector3 &p, unsigned int plane, unsigned int tpc, unsigned int cryo)
TVector2	GetVectorProjectionToPlane (const TVector3 &v, unsigned int plane, unsigned int tpc, unsigned int cryo)
TVector2	WireDriftToCm (detinfo::DetectorPropertiesData const &detProp, unsigned int wire, float drift, unsigned int plane, unsigned int tpc, unsigned int cryo)
TVector2	CmToWireDrift (detinfo::DetectorPropertiesData const &detProp, float xw, float yd, unsigned int plane, unsigned int tpc, unsigned int cryo)
recob::Track	convertFrom (const pma::Track3D &src, unsigned int tidx, int pdg=0)

Typedef Documentation

typedef std::map<unsigned int, tpc_view_hitmap> pma::cryo_tpc_view_hitmap

Definition at line 28 of file PmaTrkCandidate.h.

typedef std::map<size_t, std::vector<double> > pma::dedx_map

Definition at line 36 of file larreco/larreco/RecoAlg/PMAlg/Utilities.h.

typedef std::map<size_t, pma::TrkCandidateColl> pma::tpc_track_map

Definition at line 54 of file PMAlgTracking.h.

typedef std::map<unsigned int, view_hitmap> pma::tpc_view_hitmap

Definition at line 27 of file PmaTrkCandidate.h.

typedef ROOT::Math::DisplacementVector2D<ROOT::Math::Cartesian2D<double> > pma::Vector2D

Definition at line 33 of file larreco/larreco/RecoAlg/PMAlg/Utilities.h.

typedef recob::tracking::Vector_t pma::Vector3D

Definition at line 34 of file larreco/larreco/RecoAlg/PMAlg/Utilities.h.

typedef std::map<unsigned int, std::vector<art::Ptr<recob::Hit> > > pma::view_hitmap

Definition at line 26 of file PmaTrkCandidate.h.

Function Documentation

TVector2 pma::CmToWireDrift	(	detinfo::DetectorPropertiesData const &	detProp,
		float	xw,
		float	yd,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 310 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  art::ServiceHandle<geo::Geometry const> geom;
  return TVector2(xw / geom->TPC(tpc, cryo).Plane(plane).WirePitch(),
                  detProp.ConvertXToTicks(yd, plane, tpc, cryo));
}

recob::Track pma::convertFrom	(	const pma::Track3D &	src,
		unsigned int	tidx,
		int	pdg = 0
	)

Definition at line 25 of file PMAlgTracking.cxx.

{
  std::vector<Point_t> positions;
  positions.reserve(src.size());
  std::vector<Vector_t> momenta;
  momenta.reserve(src.size());
  std::vector<recob::TrajectoryPointFlags> outFlags;
  outFlags.reserve(src.size());

  for (size_t i = 0, h = 0; i < src.size(); i++)
    if (src[i]->IsEnabled()) {
      auto const& point3d = src[i]->Point3D();
      positions.emplace_back(point3d.X(), point3d.Y(), point3d.Z());
      momenta.push_back(src.GetDirection3D(i));
      outFlags.emplace_back(h++, recob::TrajectoryPointFlags::makeMask());
    }

  int ndof = 0;
  float totChi2 = 0;

  SMatrixSym55 covStart, covEnd;
  return recob::Track(
    recob::TrackTrajectory(std::move(positions), std::move(momenta), std::move(outFlags), false),
    pdg,
    totChi2,
    ndof,
    covStart,
    covEnd,
    tidx);
}

double pma::Dist2	(	const TVector2 &	v1,
		const TVector2 &	v2
	)

Definition at line 40 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  double const dx = v1.X() - v2.X(), dy = v1.Y() - v2.Y();
  return cet::sum_of_squares(dx, dy);
}

double pma::Dist2	(	const Vector2D &	v1,
		const Vector2D &	v2
	)

Definition at line 46 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  double const dx = v1.X() - v2.X(), dy = v1.Y() - v2.Y();
  return cet::sum_of_squares(dx, dy);
}

template<typename T , typename U >

double pma::Dist2	(	const T &	v1,
		const U &	v2
	)

Definition at line 52 of file larreco/larreco/RecoAlg/PMAlg/Utilities.h.

  {
    double dx = v1.X() - v2.X(), dy = v1.Y() - v2.Y(), dz = v1.Z() - v2.Z();
    return dx * dx + dy * dy + dz * dz;
  }

size_t pma::GetHitsCount	(	const std::vector< pma::Hit3D * > &	hits,
		unsigned int	view
	)

Definition at line 53 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  if (view == geo::kUnknown) { return hits.size(); }
  return ranges::count_if(hits, [view](auto hit) { return view == hit->View2D(); });
}

double pma::GetHitsRadius2D	(	const std::vector< pma::Hit3D * > &	hits,
		bool	exact = false
	)

Definition at line 101 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  if (hits.empty()) return 0.0;

  if (!exact && (hits.size() < 5)) return 0.0;

  using namespace ranges;
  auto to_2d_point = [](auto hit) -> decltype(auto) { return hit->Point2D(); };
  auto const mean_point =
    accumulate(hits | views::transform(to_2d_point), TVector2{}) * (1. / hits.size());

  auto to_dist2_from_mean = [&mean_point](auto hit) {
    return pma::Dist2(hit->Point2D(), mean_point);
  };
  auto const max_r2 = max(hits | views::transform(to_dist2_from_mean));
  return sqrt(max_r2);
}

double pma::GetHitsRadius3D	(	const std::vector< pma::Hit3D * > &	hits,
		bool	exact = false
	)

Definition at line 82 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  if (hits.empty()) return 0.0;

  if (!exact && (hits.size() < 5)) return 0.0;

  using namespace ranges;
  auto to_3d_point = [](auto hit) -> decltype(auto) { return hit->Point3D(); };
  auto const mean_point =
    accumulate(hits | views::transform(to_3d_point), TVector3{}) * (1. / hits.size());

  auto to_dist2_from_mean = [&mean_point](auto hit) {
    return pma::Dist2(hit->Point3D(), mean_point);
  };
  auto const max_r2 = max(hits | views::transform(to_dist2_from_mean));
  return sqrt(max_r2);
}

TVector2 pma::GetProjectionToPlane	(	const TVector3 &	p,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 273 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  art::ServiceHandle<geo::Geometry const> geom;

  return TVector2(geom->TPC(tpc, cryo).Plane(plane).PlaneCoordinate(p), p.X());
}

TVector2 pma::GetProjectionToSegment	(	const TVector2 &	p,
		const TVector2 &	p0,
		const TVector2 &	p1
	)

Definition at line 152 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  TVector2 const v1(p1 - p0);
  double const b = GetSegmentProjVector(p, p0, p1);
  return p0 + v1 * b;
}

TVector3 pma::GetProjectionToSegment	(	const TVector3 &	p,
		const TVector3 &	p0,
		const TVector3 &	p1
	)

Definition at line 160 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  TVector3 const v1(p1 - p0);
  double const b = GetSegmentProjVector(p, p0, p1);
  return p0 + v1 * b;
}

double pma::GetSegmentProjVector	(	const TVector2 &	p,
		const TVector2 &	p0,
		const TVector2 &	p1
	)

Definition at line 120 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  TVector2 const v0(p - p0);
  TVector2 const v1(p1 - p0);
  return v0 * v1 / v1.Mod2();
}

double pma::GetSegmentProjVector	(	const Vector2D &	p,
		const Vector2D &	p0,
		const Vector2D &	p1
	)

Definition at line 128 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  pma::Vector2D const v0(p - p0);
  pma::Vector2D const v1(p1 - p0);
  return v0.Dot(v1) / v1.Mag2();
}

double pma::GetSegmentProjVector	(	const TVector3 &	p,
		const TVector3 &	p0,
		const TVector3 &	p1
	)

Definition at line 136 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  TVector3 const v0(p - p0);
  TVector3 const v1(p1 - p0);
  return v0.Dot(v1) / v1.Mag2();
}

double pma::GetSegmentProjVector	(	const Vector3D &	p,
		const Vector3D &	p0,
		const Vector3D &	p1
	)

Definition at line 144 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  pma::Vector3D const v0(p - p0);
  pma::Vector3D const v1(p1 - p0);
  return v0.Dot(v1) / v1.Mag2();
}

double pma::GetSummedADC	(	const std::vector< pma::Hit3D * > &	hits,
		unsigned int	view = geo::kUnknown
	)

Definition at line 60 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  using namespace ranges;
  auto to_summed_adc = [](auto hit) { return hit->SummedADC(); };
  if (view == geo::kUnknown) { return accumulate(hits | views::transform(to_summed_adc), 0.); }
  return accumulate(hits | views::filter([view](auto hit) { return view == hit->View2D(); }) |
                      views::transform(to_summed_adc),
                    0.);
}

double pma::GetSummedAmpl	(	const std::vector< pma::Hit3D * > &	hits,
		unsigned int	view = geo::kUnknown
	)

Definition at line 71 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  using namespace ranges;
  auto to_amplitude = [](auto hit) { return hit->GetAmplitude(); };
  if (view == geo::kUnknown) { return accumulate(hits | views::transform(to_amplitude), 0.); }
  return accumulate(hits | views::filter([view](auto hit) { return view == hit->View2D(); }) |
                      views::transform(to_amplitude),
                    0.);
}

TVector2 pma::GetVectorProjectionToPlane	(	const TVector3 &	v,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 284 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  TVector3 v0_3d(0., 0., 0.);
  TVector2 v0_2d = GetProjectionToPlane(v0_3d, plane, tpc, cryo);
  TVector2 v1_2d = GetProjectionToPlane(v, plane, tpc, cryo);

  return v1_2d - v0_2d;
}

double pma::SolveLeastSquares3D	(	const std::vector< std::pair< TVector3, TVector3 >> &	lines,
		TVector3 &	result
	)

Definition at line 168 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  // RS: please, ask me if you need examples/explanation of formulas as they
  // are not easy to derive from the code solely; I have Mathcad sources that
  // were used to test the solving method, weighting, etc.

  result.SetXYZ(0., 0., 0.);
  if (lines.size() < 2) {
    mf::LogError("pma::SolveLeastSquares3D") << "Need min. two lines.";
    return -1.0;
  }

  double m;
  std::vector<TVectorT<double>> U, P;
  for (size_t v = 0; v < lines.size(); v++) {
    TVector3 point = lines[v].first;
    TVector3 dir = lines[v].second;
    dir -= point;
    m = dir.Mag();
    if (m > 0.0) {
      dir *= 1.0 / m;

      P.push_back(TVectorT<double>(3));
      P.back()[0] = point.X();
      P.back()[1] = point.Y();
      P.back()[2] = point.Z();

      U.push_back(TVectorT<double>(3));
      U.back()[0] = dir.X();
      U.back()[1] = dir.Y();
      U.back()[2] = dir.Z();
    }
    else
      mf::LogWarning("pma::SolveLeastSquares3D") << "Line undefined.";
  }
  if (P.size() < 2) {
    mf::LogError("pma::SolveLeastSquares3D") << "Need min. two lines.";
    return -1.0;
  }

  TVectorT<double> x(3), y(3), w(3);
  TMatrixT<double> A(3, 3);
  double ur, uc, pc;
  double s_uc2[3], s_ur_uc[3];
  double s_p_uc2[3], s_p_ur_uc[3];

  w[0] = 1.0;
  w[1] = 1.0;
  w[2] = 1.0;
  for (size_t r = 0; r < 3; r++) {
    y[r] = 0.0;
    for (size_t c = 0; c < 3; c++) {
      s_uc2[c] = 0.0;
      s_ur_uc[c] = 0.0;
      s_p_uc2[c] = 0.0;
      s_p_ur_uc[c] = 0.0;

      for (size_t v = 0; v < P.size(); v++) {
        //w[1] = fWeights[v]; // to remember that individual coordinates can be supressed...
        //w[2] = fWeights[v];

        ur = U[v][r];
        uc = U[v][c];
        pc = P[v][c];

        s_uc2[c] += w[r] * w[c] * (1 - uc * uc);
        s_p_uc2[c] += w[r] * w[r] * pc * (1 - uc * uc);

        s_ur_uc[c] += w[r] * w[c] * ur * uc;
        s_p_ur_uc[c] += w[r] * w[r] * pc * ur * uc;
      }

      if (r == c) {
        y[r] += s_p_uc2[c];
        A(r, c) = s_uc2[c];
      }
      else {
        y[r] -= s_p_ur_uc[c];
        A(r, c) = -s_ur_uc[c];
      }
    }
  }
  try {
    x = A.InvertFast() * y;
  }
  catch (...) {
    result.SetXYZ(0., 0., 0.);
    return 1.0e12;
  }

  result.SetXYZ(x[0], x[1], x[2]);

  double mse = 0.0;
  for (size_t v = 0; v < lines.size(); v++) {
    TVector3 const pproj = pma::GetProjectionToSegment(result, lines[v].first, lines[v].second);

    double const dx = result.X() - pproj.X(); // dx, dy, dz and the result point can be weighted
    double const dy = result.Y() - pproj.Y(); // here (linearly) by each line uncertainty
    double const dz = result.Z() - pproj.Z();
    mse += cet::sum_of_squares(dx, dy, dz);
  }
  return mse / lines.size();
}

TVector2 pma::WireDriftToCm	(	detinfo::DetectorPropertiesData const &	detProp,
		unsigned int	wire,
		float	drift,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 297 of file larreco/larreco/RecoAlg/PMAlg/Utilities.cxx.

{
  art::ServiceHandle<geo::Geometry const> geom;
  return TVector2(geom->TPC(tpc, cryo).Plane(plane).WirePitch() * wire,
                  detProp.ConvertTicksToX(drift, plane, tpc, cryo));
}