pma Namespace Reference

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

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 25 of file PmaTrkCandidate.h.

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

Definition at line 33 of file Utilities.h.

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

Definition at line 48 of file PMAlgTracking.h.

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

Definition at line 24 of file PmaTrkCandidate.h.

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

Definition at line 30 of file Utilities.h.

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

Definition at line 31 of file Utilities.h.

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

Definition at line 23 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 307 of file 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 37 of file 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 43 of file 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 49 of file 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 50 of file 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 98 of file 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 79 of file 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 270 of file 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 149 of file 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 157 of file 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 117 of file 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 125 of file 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 133 of file 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 141 of file 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 57 of file 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 68 of file 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 281 of file 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 165 of file 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 294 of file Utilities.cxx.

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