LArSoft utility namespace. More...

Namespaces
	details
	LArSoft utility implementation details.

	simple_geo
	Simple class definitions for geometry concepts.

Classes
struct	assns_has_metadata
	Trait: `value` true if `Assns` (association or its node) has metadata. More...

struct	assns_iterator_type
	Trait: `type` is iterator of `Assns`. More...

struct	assns_iterator_type< art::Assns< L, R, D > >

struct	assns_iterator_type< art::Assns< L, R, void > >

struct	assns_metadata_type
	Trait: `type` is metadata in `Assns` (association or its node). More...

struct	assns_metadata_type< art::Assns< L, R, D > >

struct	assns_metadata_type< art::AssnsNode< L, R, D > >

struct	assns_metadata_type< proxy::details::AssnsNode< ArtAssnsIterValue > >

struct	assns_metadata_type< std::pair< art::Ptr< L >, art::Ptr< R > > >

struct	assns_traits
	Data types for the specified association type (or its node). More...

struct	assns_traits< art::Assns< L, R, D > >

struct	assns_traits< art::AssnsNode< L, R, D > >

struct	assns_traits< std::pair< art::Ptr< L >, art::Ptr< R > > >

class	ChiSquareAccumulator
	Computes a χ² from expectation function and data points. More...

struct	dereferenced_type
	Class defining the dereferenced type of the specified type. More...

class	GaussianFit
	"Fast" Gaussian fit More...

struct	identity
	A unary functor returning its own argument (any type) More...

class	LinearFit
	Performs a linear regression of data. More...

class	MinMaxCollector
	Keeps track of the minimum and maximum value we observed. More...

class	QuadraticFit
	Performs a second-degree fit of data. More...

struct	RealComparisons
	Provides simple real number checks. More...

class	StatCollector
	Collects statistics on a single quantity (weighted) More...

class	StatCollector2D
	Collects statistics on two homogeneous quantities (weighted) More...

struct	Vector2DComparison
	Class comparing 2D vectors. More...

struct	Vector3DComparison
	Class comparing 2D vectors. More...

Typedefs
using	HitToWire = details::FindAllP< recob::Hit, recob::Wire >
	Query object connecting a hit to a wire. More...

template<typename Assns >
using	assns_metadata_t = typename assns_metadata_type< Assns >::type
	Trait: type of metadata in `Assns` (association or its node). More...

template<typename Assns >
using	assns_iterator_t = typename assns_iterator_type< Assns >::type
	Trait: type of iterator of `Assns`. More...

Functions
bool	PointWithinSegments (double A_start_x, double A_start_y, double A_end_x, double A_end_y, double B_start_x, double B_start_y, double B_end_x, double B_end_y, double x, double y)
	Returns whether x and y are within both specified ranges (A and B). More...

template<typename RealType >
auto	makeVector2DComparison (RealType threshold)
	Creates a `Vector2DComparison` from a `RealComparisons` object. More...

template<typename RealType >
auto	makeVector2DComparison (lar::util::RealComparisons< RealType > const &comp)
	Creates a `Vector2DComparison` from a `RealComparisons` object. More...

template<typename RealType >
auto	makeVector3DComparison (RealType threshold)
	Creates a `Vector3DComparison` from a `RealComparisons` object. More...

template<typename RealType >
auto	makeVector3DComparison (lar::util::RealComparisons< RealType > const &comp)
	Creates a `Vector3DComparison` from a `RealComparisons` object. More...

double	TrackProjectedLength (recob::Track const &track, geo::View_t view)
	Returns the length of the projection of a track on a view. More...

double	TrackPitchInView (recob::Track const &track, geo::View_t view, size_t trajectory_point=0U)
	Returns the projected length of track on a wire pitch step [cm]. More...

template<typename F >
auto	makeChiSquareAccumulator (F &&e)
	Creates a `ChiSquareAccumulator` object with the specified function. More...

template<typename T , typename F >
auto	makeChiSquareAccumulator (F &&e)
	Creates a `ChiSquareAccumulator` object with the specified function. More...

template<typename T >
details::dereference_class< T, details::has_dereference_class< T >::value >::reference_type	dereference (T &v)
	Returns the value pointed by the argument, or the argument itself. More...

template<typename T >
details::make_pointer_class< T, details::has_dereference_class< T >::value >::pointer_type	make_pointer (T &v)
	Returns a pointer to the value of argument, or the argument itself. More...


bool	ValueInRange (double value, double min, double max)
	Returns whether a value is within the specified range. More...


template<typename A , typename B >
constexpr auto	absDiff (A const &a, B const &b)
	Returns the absolute value of the difference between two values. More...

Variables
template<typename Assns >
constexpr bool	assns_has_metadata_v = assns_has_metadata<Assns>::value
	Trait: true if `Assns` (association or its node) has metadata. More...

Detailed Description

LArSoft utility namespace.

LArSoft utilities namespace.

Typedef Documentation

using lar::util::HitToWire = typedef details::FindAllP<recob::Hit, recob::Wire>

Query object connecting a hit to a wire.

Once upon a time, recob::Hit had a art::Ptr<recob::Wire> in it, and life was easy. When it was discovered that art pointers in data products were evil, they were banned from recob::Hit. As always, evil turns out to be convenient. This query object tries to provide in an efficient way a connection between a hit and the wire that has generated it.

This object expects

Example of usage: let hit_ptr be a valid art::Ptr<recob::Hit>. Then

HitToWire HtoW(evt);
art::Ptr<recob::Wire> wire_ptr = HtoW[hit_ptr];

If the association label is known, it can be used to selectively load that association:

HitToWire HtoW(evt, AssociationInputTag);
art::Ptr<recob::Wire> wire_ptr = HtoW[hit_ptr];

that has little advantage (in fact, it is possibly slower) respect to using art::FindOneP.

Definition at line 54 of file HitUtils.h.

Function Documentation

template<typename A , typename B >

constexpr auto lar::util::absDiff	(	A const &	a,
		B const &	b
	)

Returns the absolute value of the difference between two values.

Template Parameters

A	type of the first value
B	type of the second value (must actually be as `A`)

Parameters

a	the first value
b	the second value

Returns: the difference between the largest and the smallest of a and b

The pecularity of this implementation is that it always avoids taking the difference between the smallest and the largest of a and b. An equivalent implementation is:

return std::max(a, b) - std::min(a, b);

It still assumes that the difference is representable in A; for example, this assumption will fail for int types with a a very large number and b a very small (i.e. negative) number.

Requirements:

A and B must be the same type

Definition at line 69 of file NumericUtils.h.

Referenced by cluster::ClusterCrawlerAlg::AddHit(), cluster::ClusterCrawlerAlg::ClusterHitsOK(), cluster::DBScan3DAlg::init(), AcceptFindNeighbors::isNear(), calo::Calorimetry::produce(), pma::ProjectionMatchingAlg::selectInitialHits(), and cluster::ClusterCrawlerAlg::Vtx3ClusterMatch().

   {
     static_assert(std::is_same<std::decay_t<A>, std::decay_t<B>>{},
                   "Arguments of util::absDiff() have to be of the same type.");
     return (b > a) ? (b - a) : (a - b);
   }

template<typename T >

details::dereference_class<T, details::has_dereference_class<T>::value>::reference_type lar::util::dereference ( T & v )

inline

Returns the value pointed by the argument, or the argument itself.

Template Parameters

T	the type of the argument

Parameters

v	the value to be dereferenced

Returns: the value v points to, if any, or v itself

This function allows the use of the same template code to process both pointers and pointed values. For example:

template <typename T>
std::vector<int> extract_int(std::vector<T> const& from) {
  std::vector<int> v;
  v.reserve(from.size());
  std::transform(from.begin(), from.end(), std::back_inserter(v),
    util::dereference);
  return v;
}

int value = 10;
std::vector<int> v(10, value);
std::vector<int*> v_ptr(10, &value);

extract_int(v);
extract_int(v_ptr);

shows that the same function can be used on vectors of integers and of their pointers.

Definition at line 241 of file Dereference.h.

Referenced by util::PxHitConverter::ToPxHit().

     {
       return details::dereference_class<T, details::has_dereference_class<T>::value>()(v);
     }

template<typename T >

details::make_pointer_class<T, details::has_dereference_class<T>::value>::pointer_type lar::util::make_pointer ( T & v )

inline

Returns a pointer to the value of argument, or the argument itself.

Template Parameters

T	the type of the argument

Parameters

v	the value to be taken the pointer of

Returns: a pointer to v, or v itself if it is already a C pointer

This function allows the use of the same template code to process both pointers and pointed values. For example:

template <typename T>
std::vector<int*> extract_int(std::vector<T> const& from) {
  std::vector<int*> v;
  v.reserve(from.size());
  std::transform(from.begin(), from.end(), std::back_inserter(v),
    util::make_pointer);
  return v;
}

int value = 10;
std::vector<int> v(10, value);
std::vector<int*> v_ptr(10, &value);

extract_int(v);
extract_int(v_ptr);

shows that the same function can be used on vectors of integers and of their pointers.

Definition at line 279 of file Dereference.h.

Referenced by cluster::ClusterParamsImportWrapper< Algo >::ImportHits().

     {
       return details::make_pointer_class<T, details::has_dereference_class<T>::value>()(v);
     }

template<typename F >

auto lar::util::makeChiSquareAccumulator ( F && e )

Creates a ChiSquareAccumulator object with the specified function.

Template Parameters

F	type of function (deduced from `e`)

Parameters

e	expectation function

Returns: a ChiSquareAccumulator<F> instance with specified expectation

Example of usage:

auto zero = [](double){ return 0.0; }; // expectation function

auto chiSquare = lar::util::makeChiSquareAccumulator(zero);

declare chiSquare in a way equivalent to: lar::util::ChiSquareAccumulator<decltype(zero)> chiSquare(zero).

Definition at line 163 of file ChiSquareAccumulator.h.

References e.

     {
       return lar::util::ChiSquareAccumulator<F>(std::forward<F>(e));
     }

template<typename T , typename F >

auto lar::util::makeChiSquareAccumulator ( F && e )

Creates a ChiSquareAccumulator object with the specified function.

Template Parameters

T	type of data (default: `double`)
F	type of function (deduced from `e`)

Parameters

e	expectation function

Returns: a ChiSquareAccumulator<F,T> instance with specified expectation

Example of usage:

auto zero = [](float){ return 0.0F; }; // expectation function

auto chiSquare = lar::util::makeChiSquareAccumulator<float>(zero);

declare chiSquare in a way equivalent to: lar::util::ChiSquareAccumulator<decltype(zero), float> chiSquare(zero).

Definition at line 184 of file ChiSquareAccumulator.h.

References e.

     {
       return lar::util::ChiSquareAccumulator<F, T>(std::forward<F>(e));
     }

template<typename RealType >

auto lar::util::makeVector2DComparison ( RealType threshold )

Creates a Vector2DComparison from a RealComparisons object.

Definition at line 178 of file RealComparisons.h.

References lar::util::RealComparisons< RealType >::threshold.

     {
       return Vector2DComparison<RealType>(threshold);
     }

template<typename RealType >

auto lar::util::makeVector2DComparison ( lar::util::RealComparisons< RealType > const & comp )

Creates a Vector2DComparison from a RealComparisons object.

Definition at line 185 of file RealComparisons.h.

     {
       return Vector2DComparison<RealType>(comp);
     }

template<typename RealType >

auto lar::util::makeVector3DComparison ( RealType threshold )

Creates a Vector3DComparison from a RealComparisons object.

Definition at line 252 of file RealComparisons.h.

References lar::util::RealComparisons< RealType >::threshold.

Referenced by checkTPCcoords(), groupTPCsByDriftDir(), geo::TPCGeo::UpdateAfterSorting(), and geo::PlaneGeo::UpdateWireDir().

     {
       return Vector3DComparison<RealType>(threshold);
     }

template<typename RealType >

auto lar::util::makeVector3DComparison ( lar::util::RealComparisons< RealType > const & comp )

Creates a Vector3DComparison from a RealComparisons object.

Definition at line 259 of file RealComparisons.h.

     {
       return Vector3DComparison<RealType>(comp);
     }

bool lar::util::PointWithinSegments	(	double	A_start_x,
		double	A_start_y,
		double	A_end_x,
		double	A_end_y,
		double	B_start_x,
		double	B_start_y,
		double	B_end_x,
		double	B_end_y,
		double	x,
		double	y
	)

Returns whether x and y are within both specified ranges (A and B).

Definition at line 16 of file NumericUtils.cxx.

References e.

Referenced by geo::GeometryCore::ChannelsIntersect(), and geo::IntersectSegments().

   {
     constexpr RealComparisons<double> coordIs{1e-8};
     return coordIs.withinSorted(x, A_start_x, A_end_x) &&
            coordIs.withinSorted(y, A_start_y, A_end_y) &&
            coordIs.withinSorted(x, B_start_x, B_end_x) &&
            coordIs.withinSorted(y, B_start_y, B_end_y);
   }

double lar::util::TrackPitchInView	(	recob::Track const &	track,
		geo::View_t	view,
		size_t	trajectory_point = `0U`
	)

Returns the projected length of track on a wire pitch step [cm].

Parameters

track	the track to be projected on a view
view	the view for track projection
trajectory_point	at which point of the track to look for the pitch (default: `0`)

Returns: wire pitch along the track direction at its specified point [cm]

Exceptions

cet::exception	(category `"TrackPitchInView"`) if the `trajectory_point` index is not valid in `track`
cet::exception	(category `"Geometry"`) if the point is in no TPC
cet::exception	(category `"TPCGeo"`) if the `view` is unknown, not available or otherwise invalid
cet::exception	(category `"Track"`) if the track projection on the wire plane is parallel to the wires (< 0.01%)

This function returns the distance covered by the track between two wires, projected on the wire plane. The direction of the track is the one at the specified trajectory point (the first one by default). That direction is projected on the wire plane with the specified view within the TPC that contains that point.

The returned value is the distance, in centimeters, between two consecutive wires on that projected direction. This is always a positive number, regardless the direction of the track, and never smaller than the wire pitch on the projection wire plane.

Definition at line 75 of file TrackUtils.cxx.

References util::abs(), d, recob::tracking::TrajectoryPoint_t::direction(), e, geo::PlaneGeo::GetWireDirection(), geo::PlaneGeo::ID(), geo::PlaneGeo::InterWireProjectedDistance(), recob::Track::NumberTrajectoryPoints(), recob::tracking::TrajectoryPoint_t::position, proj, geo::PlaneGeo::Projection(), recob::Track::TrajectoryPoint(), geo::PlaneGeo::ViewName(), geo::PlaneGeo::WirePitch(), and lar::util::RealComparisons< RealType >::zero().

Referenced by calo::TrackCalorimetryAlg::AnalyzeHit(), shower::EMShowerAlg::FinddEdx_(), and calo::Calorimetry::produce().

 {
   /*
     * The plan:
     * 1. find the wire plane we are talking about
     *    (in the right TPC and with the right view)
     * 2. ask the plane the answer
     *
     */
 
   if (trajectory_point >= track.NumberTrajectoryPoints()) {
     cet::exception("TrackPitchInView")
       << "ERROR: Asking for trajectory point #" << trajectory_point
       << " when trajectory vector size is of size " << track.NumberTrajectoryPoints() << ".\n";
   }
   recob::Track::TrajectoryPoint_t const& point = track.TrajectoryPoint(trajectory_point);
 
   // this throws if the position is not in any TPC,
   // or if there is no view with specified plane
   auto const& geom = *(lar::providerFrom<geo::Geometry>());
   geo::PlaneGeo const& plane = geom.PositionToTPC(point.position).Plane(view);
 
 #if 0 // this can be enabled after `geo::PlaneGeo::InterWireProjectedDistance()` becomes available in larcorealg
   double const d = plane.InterWireProjectedDistance(point.direction());
 
   // do we prefer to just return the value and let the caller check it?
   if (d > 50.0 * plane.WirePitch()) { // after many pitches track would scatter
     throw cet::exception("Track") << "track at point #" << trajectory_point
                                   << " is almost parallel to the wires in view "
                                   << geo::PlaneGeo::ViewName(view) << " (wire direction is "
                                   << plane.GetWireDirection() << "; track direction is "
                                   << point.direction() << ").\n";
   }
   return d;
 
 #else  // !0
   //
   // 2. project the direction of the track on that plane
   //
   // this is the projection of the direction of the track on the wire plane;
   // it is 2D and its second component ("Y()") is on wire coordinate direction;
   // remember that the projection modulus is smaller than 1 because it is
   // the 3D direction versor, deprived of its drift direction component
   auto const& proj = plane.Projection(point.direction());
 
   if (lar::util::RealComparisons(1e-4).zero(proj.Y())) {
     throw cet::exception("Track") << "track at point #" << trajectory_point
                                   << " is almost parallel to the wires in view "
                                   << geo::PlaneGeo::ViewName(view) << " (wire direction is "
                                   << plane.GetWireDirection() << "; track direction is "
                                   << point.direction() << ", its projection on plane " << plane.ID()
                                   << " is " << proj << ").\n";
   }
 
   //
   // 3. scale that projection so that it covers a wire pitch worth in the wire
   //    coordinate direction;
   //    WirePitch() is what gives this vector a physical size [cm]
   //
   return proj.R() / std::abs(proj.Y()) * plane.WirePitch();
 #endif // ?0
 
 } // lar::util::TrackPitchInView()

double lar::util::TrackProjectedLength	(	recob::Track const &	track,
		geo::View_t	view
	)

Returns the length of the projection of a track on a view.

Parameters

track	the track to be projected on a view
view	the view to project the track on

Returns: length of the projection, in centimetres

Todo:: CAREFUL: using view to determine projected length does not work for DUNE. Need to think more about this.

Todo:: is this right, or should it be dist*cosgamma???

Definition at line 33 of file TrackUtils.cxx.

References util::abs(), recob::Track::DirectionAtPoint(), larg4::dist(), geo::kUnknown, recob::Track::LocationAtPoint(), and recob::Track::NumberTrajectoryPoints().

 {
 
   if (view == geo::kUnknown) {
     throw cet::exception("TrackProjectedLength") << "cannot provide projected length for "
                                                  << "unknown view\n";
   }
   double length = 0.;
 
   auto const* geom = lar::providerFrom<geo::Geometry>();
   double angleToVert = 0.;
   for (auto const& plane : geom->Iterate<geo::PlaneGeo>(geo::CryostatID{0})) {
     if (plane.View() == view) {
       angleToVert = plane.Wire(0).ThetaZ(false) - 0.5 * ::util::pi<>();
       break;
     }
   }
 
   // now loop over all points in the trajectory and add the contribution to the
   // to the desired view
 
   for (size_t p = 1; p < track.NumberTrajectoryPoints(); ++p) {
     const auto& pos_cur = track.LocationAtPoint(p);
     const auto& pos_prev = track.LocationAtPoint(p - 1);
     double dist =
       std::sqrt(std::pow(pos_cur.x() - pos_prev.x(), 2) + std::pow(pos_cur.y() - pos_prev.y(), 2) +
                 std::pow(pos_cur.z() - pos_prev.z(), 2));
 
     // (sin(angleToVert),cos(angleToVert)) is the direction perpendicular to wire
     // fDir[p-1] is the direction between the two relevant points
     const auto& dir_prev = track.DirectionAtPoint(p - 1);
     double cosgamma =
       std::abs(std::sin(angleToVert) * dir_prev.Y() + std::cos(angleToVert) * dir_prev.Z());
 
     length += dist / cosgamma;
   } // end loop over distances between trajectory points
 
   return length;
 } // lar::util::TrackProjectedLength()

bool lar::util::ValueInRange	(	double	value,
		double	min,
		double	max
	)

Returns whether a value is within the specified range.

Parameters

value	the value to be tested
min	the lower boundary
max	the upper boundary

Returns: whether the value is within range

If min is larger than max, they are swapped. A tolerance of 10^-6 (absolute) is used.

Todo:

Use wiggle instead of 10^-6

resort source code for a bit of speed up

Definition at line 7 of file NumericUtils.cxx.

References util::abs(), and e.

Referenced by apa::APAGeometryAlg::LineSegChanIntersect().

   {
     if (min > max) std::swap(min, max); //protect against funny business due to wire angles
     if (std::abs(value - min) < 1e-6 || std::abs(value - max) < 1e-6) return true;
     return (value >= min) && (value <= max);
   }

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation