LArSoft  v08_35_01
Liquid Argon Software toolkit - http://larsoft.org/
util Namespace Reference

Namespace for general, non-LArSoft-specific utilities. More...

Namespaces

 details
 
 flags
 Classes and functions to manage bit masks and flags.
 
 manip
 
 pre_std
 
 quantities
 

Classes

struct  add_tag
 
struct  AddressTaker
 Functor returning the address in memory of the operand. More...
 
struct  always_false_type
 A std::false_type with a template argument. More...
 
struct  always_true_type
 A std::true_type with a template argument. More...
 
struct  collection_from_reference_type
 Trait with the type of collection referenced by collRef. More...
 
struct  collection_reference_type
 Trait of a type that can be used to reference the collection Coll. More...
 
struct  collection_value_access_type
 Trait of type obtained by access to element of collection Coll. More...
 
struct  collection_value_constant_access_type
 Trait of type obtained by constant access to element of collection Coll. More...
 
struct  collection_value_type
 Trait of value contained in the template collection Coll. More...
 
struct  count_extracted_types
 Counts the elements of a tuple-like type containing a Target type. More...
 
class  count_iterator
 An iterator dereferencing to a counter value. More...
 
struct  count_type_in_tuple
 Holds whether the Target type is element of the specified std::tuple. More...
 
struct  count_type_in_tuple< Target, std::tuple< T... > >
 
class  DatabaseUtil
 
class  DataProductChangeTracker_t
 Detects the presence of a new event or data product. More...
 
struct  Dereferencer
 Functor dereferencing the operand. More...
 
class  DetectorPropertiesServiceArgoNeuT
 
class  EventChangeTracker_t
 Detects the presence of a new event. More...
 
struct  extract_to_tuple_type
 Returns type TargetClass<U...> from a SrcTuple<T...>. More...
 
struct  find_next_type
 Trait: index of the first occurrence of T among the specified Types, starting from the one with index StartFrom. More...
 
class  GaussianEliminationAlg
 
class  GeometryUtilities
 
class  GridContainerBase1D
 Base class for a container of data arranged on a 1D-grid. More...
 
class  GridContainerBase2D
 Base class for a container of data arranged on a 2D-grid. More...
 
class  GridContainerBase3D
 Base class for a container of data arranged on a 3D-grid. More...
 
class  GridContainerIndicesBase1D
 Index manager for a container of data arranged on a >=1-dim grid. More...
 
class  GridContainerIndicesBase2D
 Index manager for a container of data arranged on a >=2-dim grid. More...
 
class  GridContainerIndicesBase3D
 Index manager for a container of data arranged on a >=3-dim grid. More...
 
struct  has_duplicate_extracted_types
 Traits holding whether elements of Tuple have duplicate types. More...
 
struct  has_extracted_type
 Trait holding whether an element in Tuple type contains Target. More...
 
struct  index_of_extracted_type
 Returns the index of the element in Tuple with the specified type. More...
 
struct  is_any_of
 Trait: whether T is among the specified Types. More...
 
struct  is_character_type
 Trait: whether type T is a character type. More...
 
struct  is_instance_of
 Trait describing whether T is a template instance of Template. More...
 
struct  is_STLarray
 Identifies whether the specified type is a STL array. More...
 
struct  is_STLarray< std::array< T, N > >
 
struct  is_string_type
 Trait: whether type T is a character string type. More...
 
struct  KeepByPositionFilterTag
 Tag for filters. More...
 
class  LArFFT
 
class  LArFFTW
 
class  LArFFTWPlan
 
class  LArPropertiesServiceArgoNeuT
 Properties related to liquid argon environment in the detector. More...
 
class  LazyVector
 A contiguous data container expanded on write. More...
 
struct  lvalue_reference_into_wrapper_type
 Trait with type T into std::reference_wrapper if reference. More...
 
class  MappedContainer
 A meta-container providing transparent mapping on top of another. More...
 
struct  MappedContainerBase
 Non-template base class for MappedContainer. More...
 
class  NormalDistribution
 
class  PlaneDataChangeTracker_t
 Detects the presence of a new event, data product or wire plane. More...
 
class  PositionInVolumeFilter
 Use to keep particles with at least part of trajectory in a volume. More...
 
class  PxHit
 
class  PxHitConverter
 
class  PxLine
 
class  PxPoint
 
class  Range
 represents a "Range" w/ notion of ordering. A range is defined by a pair of "start" and "end" values. This is stored in std::pair
attribute util::Range::_window. This attribute is protected so that the start/end cannot
be changed w/o a check that start is always less than end. Note the specialization
requires a template class T to have less operator implemented.
More...
 
struct  RangeForWrapperTag
 Tag marking the use of RangeForWrapperBox. More...
 
struct  reference_addresser
 Functor applying the proper referenced_address() function. More...
 
struct  remove_tag
 Trait holding the type contained in a TaggedType (or the type itself). More...
 
struct  remove_tag< TaggedType< T, Tag > >
 
struct  self_type
 Trait returning the very same type as in the template argument. More...
 
class  SignalShaping
 
struct  span
 Simple class with a begin and an end. More...
 
struct  span_base
 Non-templated base class for span. More...
 
struct  strip_referenceness_type
 Trait with type T stripped of all known reference types. More...
 
class  SumSecondFunction
 
struct  TagExtractor
 Extracts the tag from a type. More...
 
struct  TaggedType
 A type with a specified tag. More...
 
struct  TagN
 Tag class parametrized by a sequence of numbers. More...
 
class  TensorIndices
 Converts a tensor element specification into a linear index. More...
 
class  TensorIndices< 1U >
 
struct  TensorIndicesBasicTypes
 Types for TensorIndices class. More...
 
class  UBDaqID
 
class  UniqueRangeSet
 std::set of util::Range, which does not allow any overlap in contained element. std::set<Range> w/ modified insert/emplace function. Original std::set does not allow
modification of element. I assume what we're interested in is "find if the range already \n exists, and merge if it exists". The insert function does that by recursively looking up
overlapping elements w.r.t. input argument of insert function.
More...
 
class  UtilException
 
class  VectorMap
 
struct  with_const_as
 Trait with type Base, plus the constantness as in Key. More...
 

Typedefs

template<typename Coll >
using collection_value_t = typename collection_value_type< Coll >::type
 Type contained in the collection Coll. More...
 
template<typename Coll >
using collection_value_access_t = typename collection_value_access_type< Coll >::type
 Type obtained by constant access to element of collection Coll. More...
 
template<typename Coll >
using collection_value_constant_access_t = typename collection_value_constant_access_type< Coll >::type
 Type obtained by constant access to element of collection Coll. More...
 
template<typename Coll >
using collection_reference_t = typename collection_reference_type< Coll >::type
 The type contained in util::collection_reference_type trait. More...
 
template<typename Cont >
using collection_from_reference_t = typename collection_from_reference_type< Cont >::type
 Type contained in util::collection_from_reference_type trait. More...
 
template<typename T >
using self_t = typename self_type< T >::type
 The very same type as in the template argument. More...
 
using type_traits = std::bool_constant< Value >
 
template<typename A , typename B >
using is_not_same = std::negation< std::is_same< A, B >>
 The negation of std::is_same. More...
 
template<typename T , typename... Types>
using find_type = find_next_type< T, 0U, Types... >
 Trait: index of the first occurrence of T among the specified Types. More...
 
template<typename T >
using is_reference_wrapper = is_instance_of< std::reference_wrapper, T >
 Identifies whether the specified type is a std::reference_wrapper. More...
 
template<typename T >
using is_unique_ptr = is_instance_of< std::unique_ptr, T >
 Identifies whether the specified type is a std::unique_ptr. More...
 
template<typename Base , typename Key >
using with_const_as_t = typename with_const_as< Base, Key >::type
 The type Base, plus the constantness as in Key. More...
 
template<typename T >
using strip_referenceness_t = typename strip_referenceness_type< T >::type
 The type T stripped of all known reference types. More...
 
template<typename T >
using lvalue_reference_into_wrapper_t = typename lvalue_reference_into_wrapper_type< T >::type
 The type T stripped of all known reference types. More...
 
typedef int UBLArSoftCh_t
 
typedef std::map< UBDaqID, UBLArSoftCh_tUBChannelMap_t
 
typedef std::map< UBLArSoftCh_t, UBDaqIDUBChannelReverseMap_t
 
using GridContainer2DIndices = GridContainerIndicesBase2D<>
 Index manager for a container of data arranged on a 2D grid. More...
 
using GridContainer3DIndices = GridContainerIndicesBase3D<>
 Index manager for a container of data arranged on a 3D grid. More...
 
template<typename DATUM >
using GridContainer2D = GridContainerBase2D< DATUM, GridContainer2DIndices >
 Container allowing 2D indexing. More...
 
template<typename DATUM >
using GridContainer3D = GridContainerBase3D< DATUM, GridContainer3DIndices >
 Container allowing 3D indexing. More...
 
using LArPropertiesArgoNeuT = LArPropertiesServiceArgoNeuT
 type of provider name following LArSoft name convention More...
 
using MatrixIndices = TensorIndices< 2U >
 Type for indexing a 2D-tensor (matrix) More...
 
template<typename SrcTuple , template< typename T, typename... > class Extractor, template< typename... > class TargetClass = std::tuple>
using extract_to_tuple_type_t = typename extract_to_tuple_type< SrcTuple, Extractor, TargetClass >::type
 Direct access to the type in extract_to_tuple_type. More...
 
template<typename Tuple , template< typename... > class TargetClass = std::tuple>
using to_tuple = extract_to_tuple_type< Tuple, self_type, TargetClass >
 
template<typename Tuple , template< typename... > class TargetClass = std::tuple>
using to_tuple_t = typename to_tuple< Tuple, TargetClass >::type
 Direct access to the type in to_tuple. More...
 
template<typename Target , typename Tuple >
using index_of_type = index_of_extracted_type< self_type, Target, Tuple >
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
using type_with_extracted_type = std::tuple_element< index_of_extracted_type_v< Extractor, Target, Tuple >, Tuple >
 Returns the element type in Tuple with the specified type. More...
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
using type_with_extracted_type_t = typename type_with_extracted_type< Extractor, Target, Tuple >::type
 Direct access to the value in type_with_extracted_type. More...
 
template<typename Target , typename Tuple >
using has_type = has_extracted_type< self_type, Target, Tuple >
 
template<typename Tuple >
using has_duplicate_types = has_duplicate_extracted_types< self_type, Tuple >
 
template<typename Target , typename Tuple >
using count_types = count_extracted_types< self_type, Target, Tuple >
 
template<typename T , typename Tag >
using add_tag_t = typename add_tag< T, Tag >::type
 
template<typename Tagged >
using remove_tag_t = typename remove_tag< Tagged >::type
 Direct access to the type contained in remove_tag. More...
 
template<typename Tagged >
using tag_of = TagExtractor< Tagged >
 Trait holding the tag of Tagged as type. More...
 
template<typename Tagged >
using tag_of_t = typename tag_of< Tagged >::type
 Direct access to the type in tag_of. More...
 
template<typename SrcTuple >
using extract_tags = extract_to_tuple_type< SrcTuple, TagExtractor >
 Returns a tuple with all the tags from SrcTuple. More...
 
template<typename SrcTuple >
using extract_tags_t = typename extract_tags< SrcTuple >::type
 Direct access to the type in extract_tags. More...
 
template<typename Tag , typename Tuple >
using index_of_tag = index_of_extracted_type< TagExtractor, Tag, Tuple >
 Trait holding the index of the element of Tuple with tag Tag. More...
 
template<typename Tag , typename Tuple >
using type_with_tag = type_with_extracted_type< TagExtractor, Tag, Tuple >
 Trait holding the type of the element of Tuple with tag Tag. More...
 
template<typename Tag , typename Tuple >
using type_with_tag_t = typename type_with_tag< Tag, Tuple >::type
 Direct access to the value in type_with_tag. More...
 
template<typename Tag , typename Tuple >
using has_tag = has_extracted_type< TagExtractor, Tag, Tuple >
 Trait informing if there are elements in Tuple with tag Tag. More...
 
template<typename Tag , typename Tuple >
using count_tags = count_extracted_types< TagExtractor, Tag, Tuple >
 Trait counting the elements in Tuple with tag Tag. More...
 
template<typename Tuple >
using has_duplicate_tags = has_duplicate_extracted_types< TagExtractor, Tuple >
 Trait reporting if multiple elements in Tuple have the same tag. More...
 

Functions

template<typename Coll >
auto make_collection_reference (Coll &&coll)
 Returns an object referencing to the data contained in coll. More...
 
template<typename CollRef >
decltype(auto) collection_from_reference (CollRef &collRef)
 Returns the object referenced by collRef as a C++ reference. More...
 
template<typename Coll , typename Extractor >
decltype(auto) makeValueIndex (Coll const &coll, Extractor getter)
 Returns a map of value to index. More...
 
template<typename Coll >
auto makeValueIndex (Coll const &coll)
 
template<typename Ref >
auto referenced_address (Ref &&ref)
 Returns the address of the referenced object. More...
 
template<typename T >
auto lvalue_reference_into_wrapper (T &&obj)
 Converts a l-value reference object into a std::reference_wrapper. More...
 
decltype(auto) takeAddress ()
 Returns a functor that returns the address of its argument. More...
 
decltype(auto) dereference ()
 Returns a functor that returns *ptr of its argument ptr. More...
 
template<typename Coll >
auto makePointerVector (Coll &coll)
 Creates a STL vector with pointers to data from another collection. More...
 
template<typename Coll , typename PtrColl >
void MoveFromPointers (Coll &dest, PtrColl &src)
 Moves the content from a collection of pointers to one of data. More...
 
template<typename Coll , typename Sorter >
void SortByPointers (Coll &coll, Sorter sorter)
 Applies sorting indirectly, minimizing data copy. More...
 
template<typename Coll , typename Sorter >
void SortUniquePointers (Coll &coll, Sorter &&sorter)
 Sorts a vector of unique pointers using a C pointer sorter. More...
 
template<typename IterB , typename IterE , typename Adaptor >
 span (IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
 
template<typename T = double>
constexpr T pi ()
 Returns the constant pi (up to 35 decimal digits of precision) More...
 
template<typename T >
constexpr T DegreesToRadians (T angle)
 Converts the argument angle from degrees into radians. More...
 
template<typename T >
constexpr T RadiansToDegrees (T angle)
 Converts the argument angle from radians into degrees ( $ \pi \rightarrow 180 $) More...
 
template<typename Stream , typename Left , typename Right , typename Data >
void DumpAssociationsIntro (Stream &&out, art::Assns< Left, Right, Data > const &assns)
 Dumps a short introduction about specified association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, art::Ptr< U > const &b, art::Assns< U, T > &assn, std::string a_instance, size_t index=UINT_MAX)
 Creates a single one-to-one association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, art::Ptr< U > const &b, art::Assns< U, T > &assn, size_t index=UINT_MAX)
 Creates a single one-to-one association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, art::Ptr< T > const &a, art::Ptr< U > const &b, art::Assns< U, T > &assn)
 Creates a single one-to-one association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, art::PtrVector< U > const &b, art::Assns< T, U > &assn, size_t index=UINT_MAX)
 Creates a single one-to-many association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, art::Ptr< T > const &a, std::vector< art::Ptr< U >> const &b, art::Assns< T, U > &assn)
 Creates a single one-to-many association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, std::vector< art::Ptr< U >> const &b, art::Assns< T, U > &assn, size_t index=UINT_MAX)
 Creates a single one-to-many association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, std::vector< U > const &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t index=UINT_MAX)
 Creates a single one-to-many association. More...
 
template<class PRODUCER , class T , class U >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, std::vector< U > const &b, art::Assns< T, U > &assn, std::vector< size_t > const &indices, size_t index=UINT_MAX)
 Creates a single one-to-many association. More...
 
template<typename PRODUCER , typename T , typename U , typename Iter >
bool CreateAssn (PRODUCER const &prod, art::Event &evt, art::Assns< T, U > &assn, size_t first_index, Iter from_second_index, Iter to_second_index)
 Creates a single one-to-many association. More...
 
template<class T , class U >
std::vector< const U * > FindUNotAssociatedToT (art::Handle< U > b, art::Event const &evt, std::string const &label)
 
template<class T , class U >
std::vector< art::Ptr< U > > FindUNotAssociatedToTP (art::Handle< U > b, art::Event const &evt, std::string const &label)
 
template<class T , class U >
std::vector< size_t > GetAssociatedVectorOneI (art::Handle< art::Assns< T, U > > h, art::Handle< std::vector< T > > index_p)
 
template<class T , class U >
std::vector< const U * > GetAssociatedVectorOneP (art::Handle< art::Assns< T, U > > h, art::Handle< std::vector< T > > index_p)
 
template<class T , class U >
std::vector< std::vector< size_t > > GetAssociatedVectorManyI (art::Handle< art::Assns< T, U > > h, art::Handle< std::vector< T > > index_p)
 
template<class T , class U >
std::vector< std::vector< const U * > > GetAssociatedVectorManyP (art::Handle< art::Assns< T, U > > h, art::Handle< std::vector< T > > index_p)
 
template<typename Range , typename Pred >
auto filterRangeFor (Range &&range, Pred &&pred) -> decltype(auto)
 Provides iteration only through elements passing a condition. More...
 
template<class A , class F >
void for_each_associated_group (A const &assns, F &func)
 Helper functions to access associations in order. More...
 
template<class A >
auto associated_groups (A const &assns)
 Helper functions to access associations in order. More...
 
template<class A >
auto associated_groups_with_left (A const &assns)
 Helper functions to access associations in order, also with key. More...
 
template<typename Groups >
auto groupByIndex (Groups &&groups, std::size_t index) -> decltype(auto)
 Returns the group within groups with the specified index. More...
 
template<typename Coll , typename KeyOf >
std::vector< size_t > MakeIndex (Coll const &data, KeyOf key_of=KeyOf())
 Creates a map of indices from an existing collection. More...
 
template<typename Coll , typename KeyOf >
auto MakeMap (Coll const &data, KeyOf key_of=KeyOf()) -> std::vector< decltype(key_of(*(data.begin()))) const * >
 Creates a map of objects from an existing collection. More...
 
template<typename Range >
auto wrapRangeFor (Range &&range) -> decltype(auto)
 Wraps an object for use in a range-for loop. More...
 
template<typename Range >
auto operator| (Range &&range, RangeForWrapperTag) -> decltype(auto)
 Transforms a range so that it can be used in a range-for loop. More...
 
template<unsigned int RANK1, unsigned int RANK2, typename = std::enable_if_t<(RANK1 != RANK2), bool>>
bool operator== (TensorIndices< RANK1 > const &a, TensorIndices< RANK2 > const &b)
 Comparison operator with tensors of different rank. More...
 
template<unsigned int RANK1, unsigned int RANK2, typename = std::enable_if_t<(RANK1 != RANK2), bool>>
bool operator!= (TensorIndices< RANK1 > const &a, TensorIndices< RANK2 > const &b)
 Comparison operator with tensors of different rank. More...
 
template<typename... DIMS>
auto makeTensorIndices (DIMS...dims)
 Instantiates a TensorIndices class with the specified dimensions. More...
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
auto getByExtractedType (Tuple const &data) -> decltype(auto)
 Returns the value of the element containing the specified type. More...
 
template<typename Tag , typename T >
auto makeTagged (T &obj) -> decltype(auto)
 "Converts" obj to an object with tag Tag. More...
 
template<typename Tag , typename T >
auto makeTagged (T const &obj) -> decltype(auto)
 "Converts" obj to an object with tag Tag. More...
 
template<typename Tag , typename T >
auto makeTagged (T const &&obj) -> decltype(auto)
 "Converts" obj to an object with tag Tag. More...
 
template<typename Tag , typename T >
auto makeTagged (T &&obj) -> decltype(auto)
 "Converts" obj to an object with tag Tag. More...
 
template<typename Tagged >
auto removeTag (Tagged &tagged) -> decltype(auto)
 "Converts" a tagged type back to its original type. More...
 
template<typename Tagged >
auto removeTag (Tagged const &tagged) -> decltype(auto)
 "Converts" a tagged type back to its original type. More...
 
template<typename Tagged >
auto removeTag (Tagged const &&tagged) -> decltype(auto)
 "Converts" a tagged type back to its original type. More...
 
template<typename Tagged >
auto removeTag (Tagged &&tagged) -> decltype(auto)
 "Converts" a tagged type back to its original type. More...
 
template<typename Tag , typename Tuple >
auto getByTag (Tuple const &data) -> decltype(auto)
 Returns the object with the specified tag. More...
 
template<typename Cont , typename Mapping >
auto mapContainer (Cont cont, Mapping mapping)
 Returns a container-like object mapping the content of cont. More...
 
template<typename Cont , typename Mapping , typename Container , typename Reference >
MappedContainer< Cont, Mapping >::template IteratorBase< Container, Reference > operator+ (typename MappedContainer< Cont, Mapping >::template IteratorBase< Container, Reference >::difference_type n, typename MappedContainer< Cont, Mapping >::template IteratorBase< Container, Reference > const &it)
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator== (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator< (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator!= (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 Based on operator==. More...
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator> (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 Based on operator<. More...
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator<= (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 Based on operator<. More...
 
template<typename _Key , typename _Tp , typename _Compare >
bool operator>= (const VectorMap< _Key, _Tp, _Compare > &__x, const VectorMap< _Key, _Tp, _Compare > &__y)
 Based on operator<. More...
 
template<typename _Key , typename _Tp , typename _Compare >
void swap (VectorMap< _Key, _Tp, _Compare > &__x, VectorMap< _Key, _Tp, _Compare > &__y)
 See VectorMap::swap(). More...
 
std::ostream & operator<< (std::ostream &out, EventChangeTracker_t const &trk)
 
std::ostream & operator<< (std::ostream &out, DataProductChangeTracker_t const &trk)
 
std::ostream & operator<< (std::ostream &out, PlaneDataChangeTracker_t const &trk)
 
Counted iterations
template<typename T >
auto counter (T begin, T end)
 Returns an object to iterate values from begin to end in a range-for loop. More...
 
template<typename T >
auto counter (T end)
 
template<typename T = std::size_t>
auto infinite_counter (T begin=T{})
 Version of util::counter() starting at begin and never ending. More...
 
Enumerated iterations
template<std::size_t Lead, typename... Iterables>
auto enumerate (Iterables &&...iterables)
 Range-for loop helper tracking the number of iteration. More...
 
template<typename... Iterables>
auto enumerate (Iterables &&...iterables)
 This version of enumerate implicitly uses the first iterable as lead. More...
 
template<typename T >
void staticDumpClassName ()
 Helper to determine the type of a variable at compilation time. More...
 
template<typename T >
void staticDumpClassName (T)
 Helper to determine the type of a variable at compilation time. 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...
 
Span helper functions
template<typename BIter , typename EIter >
auto make_span (BIter begin, EIter end)
 Creates a span from specified iterators (can use constructor instead). More...
 
template<typename Cont >
auto make_span (Cont &cont)
 Creates a span from a container type. More...
 
template<typename Cont >
auto make_const_span (Cont &cont)
 Creates a span with constant iterator access from a container type. More...
 
Adapted span helper functions
template<typename BIter , typename EIter , typename Adaptor >
auto make_adapted_span (BIter begin, EIter end, Adaptor &&adaptor)
 
template<typename Cont , typename Adaptor >
auto make_adapted_span (Cont &cont, Adaptor &&adaptor)
 Creates a span from specified collection via an adaptor. More...
 
template<typename Cont , typename Adaptor >
auto make_adapted_const_span (Cont &cont, Adaptor &&adaptor)
 Creates constant iteration span from specified collection via an adaptor. More...
 
Transformed span helper functions
template<typename BIter , typename EIter , typename Op >
auto make_transformed_span (BIter begin, EIter end, Op &&op)
 
template<typename Cont , typename Op >
auto make_transformed_span (Cont &cont, Op &&op)
 Creates a span from specified collection via an adaptor. More...
 
template<typename Cont , typename Op >
auto make_transformed_const_span (Cont &cont, Op &&op)
 
C++ standard library customization for user-defined classes.
template<typename T >
decltype(auto) constexpr to_string (T &&obj)
 ADL-aware version of std::to_string. More...
 
template<typename T >
decltype(auto) constexpr begin (T &&obj)
 ADL-aware version of std::begin. More...
 
template<typename T >
decltype(auto) constexpr end (T &&obj)
 ADL-aware version of std::end. More...
 
template<typename T >
decltype(auto) constexpr cbegin (T &&obj)
 ADL-aware version of std::cbegin. More...
 
template<typename T >
decltype(auto) constexpr cend (T &&obj)
 ADL-aware version of std::cend. More...
 
template<typename T >
decltype(auto) constexpr size (T &&obj)
 ADL-aware version of std::size. More...
 
template<typename T >
decltype(auto) constexpr empty (T &&obj)
 ADL-aware version of std::empty. More...
 
Transformed iterations
template<typename Coll >
decltype(auto) values (Coll &&coll)
 Range-for loop helper iterating across the values of the specified collection. More...
 
template<typename Coll >
decltype(auto) const_values (Coll &&coll)
 Range-for loop helper iterating across the constant values of the specified collection. More...
 
Parallel iterations
template<std::size_t Lead, typename... Iterables>
auto zip (Iterables &&...iterables)
 Range-for loop helper iterating across many collections at the same time. More...
 
template<typename... Iterables>
auto zip (Iterables &&...iterables)
 Version of zip() with first iterator implicitly leading the iteration. More...
 
template<typename PRODUCER , typename T , typename U , typename D >
bool CreateAssnD (PRODUCER const &prod, art::Event &evt, art::Assns< T, U, D > &assn, size_t first_index, size_t second_index, typename art::Assns< T, U, D >::data_t &&data)
 Creates a single one-to-one association with associated data. More...
 
template<typename PRODUCER , typename T , typename U , typename D >
bool CreateAssnD (PRODUCER const &prod, art::Event &evt, art::Assns< T, U, D > &assn, size_t first_index, size_t second_index, typename art::Assns< T, U, D >::data_t const &data)
 Creates a single one-to-one association with associated data. More...
 
simple mathematical functions
template<typename T >
constexpr auto abs (T v)
 Returns the absolute value of the argument. More...
 

Variables

template<typename >
constexpr bool always_false_v = false
 A templated constant, always false. More...
 
template<typename >
constexpr bool always_true_v = true
 A template constant always true. More...
 
template<typename T , std::size_t StartFrom, typename... Types>
constexpr std::size_t find_next_type_v = find_next_type<T, StartFrom, Types...>::value
 
template<typename T , typename... Types>
constexpr std::size_t find_type_v = find_type<T, Types...>::value
 
template<typename T , typename... Types>
constexpr bool is_any_of_v = is_any_of<T, Types...>::value
 Whether T is among the specified Types (see util::is_any_of). More...
 
template<typename T , typename U >
constexpr auto is_same_decay_v = std::is_same_v<std::decay_t<T>, std::decay_t<U>>
 Whether T and U are the same type, after being applied std::decay. More...
 
template<template< typename... > typename Template, typename T >
constexpr bool is_instance_of_v = is_instance_of<Template, T>::value
 
template<typename T >
constexpr bool is_STLarray_v = is_STLarray<T>::value
 A constant describing whether the specified type is a STL array. More...
 
template<typename T >
constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value
 A constant describing whether the specified type is a std::reference_wrapper. More...
 
template<typename T >
constexpr bool is_unique_ptr_v = is_unique_ptr<T>::value
 A constant describing whether the specified type is a std::unique_ptr. More...
 
template<typename T >
constexpr bool is_character_type_v = is_character_type<T>::value
 Whether type T is a character type (see util::is_character_type). More...
 
template<typename T >
constexpr bool is_string_type_v = is_string_type<T>::value
 Whether type T is a character string type (see util::is_string_type). More...
 
constexpr double kGeVToElectrons = 4.237e7
 23.6eV per ion pair, 1e9 eV/GeV More...
 
constexpr double kc = 29.9792458
 Speed of light in vacuum in LArSoft units [cm/ns]. More...
 
constexpr double kMeterToCentimeter = 1.e2
 1 m = 100 cm More...
 
constexpr double kCentimeterToMeter = 1./kMeterToCentimeter
 
constexpr double kMeterToKilometer = 1.e-3
 1000 m = 1 km More...
 
constexpr double kKilometerToMeter = 1./kMeterToKilometer
 
constexpr double keVToMeV = 1.e-6
 1e6 eV = 1 MeV More...
 
constexpr double kMeVToeV = 1./keVToMeV
 
constexpr double kBogusD = -999.
 obviously bogus double value More...
 
constexpr int kBogusI = -999
 obviously bogus integer value More...
 
constexpr float kBogusF = -999.
 obviously bogus float value More...
 
constexpr double quietCompiler = kBogusD*kBogusI*kBogusF*kRecombA*kRecombk*kGeVToElectrons
 
const double kINVALID_DOUBLE = std::numeric_limits<Double_t>::max()
 
constexpr RangeForWrapperTag range_for
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
constexpr std::size_t index_of_extracted_type_v = index_of_extracted_type<Extractor, Target, Tuple>()
 Direct access to the value in index_of_extracted_type. More...
 
template<typename Target , typename Tuple >
constexpr std::size_t index_of_type_v = index_of_type<Target, Tuple>()
 Direct access to the value in index_of_type. More...
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
constexpr bool has_extracted_type_v = has_extracted_type<Extractor, Target, Tuple>()
 Direct access to the value in has_extracted_type. More...
 
template<typename Target , typename Tuple >
constexpr bool has_type_v = has_type<Target, Tuple>()
 Direct access to the value in has_type. More...
 
template<template< typename T, typename... > class Extractor, typename Tuple >
constexpr bool has_duplicate_extracted_types_v = has_duplicate_extracted_types<Extractor, Tuple>()
 Direct access to the value in has_duplicate_extracted_types. More...
 
template<typename Tuple >
constexpr bool has_duplicate_types_v = has_duplicate_types<Tuple>()
 Direct access to the value in has_duplicate_types. More...
 
template<template< typename T, typename... > class Extractor, typename Target , typename Tuple >
constexpr unsigned int count_extracted_types_v = count_extracted_types<Extractor, Target, Tuple>()
 Direct access to the value in count_extracted_types. More...
 
template<typename Target , typename Tuple >
constexpr unsigned int count_types_v = count_types<Target, Tuple>()
 Direct access to the value in count_extracted_types. More...
 
template<typename Tag , typename Tuple >
constexpr std::size_t index_of_tag_v = index_of_tag<Tag, Tuple>()
 Direct access to the value in index_of_tag. More...
 
template<typename Tag , typename Tuple >
constexpr bool has_tag_v = has_tag<Tag, Tuple>()
 Direct access to the value in has_tag. More...
 
template<typename Tag , typename Tuple >
constexpr unsigned int count_tags_v = count_tags<Tag, Tuple>()
 Direct access to the value in count_tags. More...
 
template<typename Tuple >
constexpr bool has_duplicate_tags_v = has_duplicate_tags<Tuple>()
 Direct access to the value in has_duplicate_tags. More...
 
const float SQRT_TWO_PI = 2.506628
 
Recombination factor coefficients (NIM).
See also
sim::ISCalculationSeparate::CalculateIonizationAndScintillation()

Recombination factor coefficients come from Nucl.Instrum.Meth.A523:275-286,2004

  • $ dE/dx $ is given by the voxel energy deposition, but have to convert it to MeV/cm from GeV/voxel width
  • electric field: $ E $ in kV/cm
  • $ R = A/(1 + (dE/dx)*k/E) $
  • $ A = 0.800 \pm 0.003 $
  • $ k = 0.0486 $ needs to be scaled with Electric field
constexpr double kRecombA = 0.800
 A constant. More...
 
constexpr double kRecombk = 0.0486
 
Recombination factor coefficients (modified box, ArguNeuT JINST).
See also
sim::ISCalculationSeparate::CalculateIonizationAndScintillation()

Recombination factor coefficients come from Nucl.Instrum.Meth.A523:275-286,2004

  • $ dE/dx $ is given by the voxel energy deposition, but have to convert it to MeV/cm from GeV/voxel width
  • electric field: $ E $ in kV/cm
  • kModBoxB needs to be scaled with the electric field.
constexpr double kModBoxA = 0.930
 Modified Box Alpha. More...
 
constexpr double kModBoxB = 0.212
 Modified Box Beta in g/(MeV cm²)*kV/cm. More...
 
template<typename Target , typename... T>
using count_type_in_list = details::count_type_in_list_impl< Target, T... >
 Returns how many of the types in T exactly match Target. More...
 
template<std::size_t N, typename... T>
using typelist_element_type = std::tuple_element< N, std::tuple< T... >>
 Returns the N type of the type list. More...
 
template<std::size_t N, typename... T>
using typelist_element_t = typename typelist_element_type< N, T... >::type
 Direct access to the value in typelist_element_type. More...
 
template<typename Target , typename... T>
using type_is_in = details::type_is_in_impl< Target, T... >
 Holds whether the Target type is among the ones in the T pack. More...
 
template<typename Target , typename... T>
constexpr unsigned int count_type_in_list_v = count_type_in_list<Target, T...>()
 Direct access to the value in count_type_in_list. More...
 
template<typename Target , typename... T>
constexpr bool type_is_in_v = type_is_in<Target, T...>()
 Direct access to the value in type_is_in. More...
 

Detailed Description

Namespace for general, non-LArSoft-specific utilities.

Namespace for general, not LArSoft-specific utilities.

General LArSoft Utilities.

Generic namespace of utility functions generally independent of LArSoft.

Some physical constants are also included here. As a reminder, the "standard" units in LArSoft are:

  • energy: GeV
  • time: ns
  • space: cm

SumSecondFunction 28-Jul-2009 William Seligman selig.nosp@m.man@.nosp@m.nevis.nosp@m..col.nosp@m.umbia.nosp@m..edu When using STL, maps, and the std::accumulate function, there's one function I keep coding over and over again: accumulate the second member of a pair.

To save myself time (and others who know and use STL), here's a complete STL-compatible implementation of that function. To use it, assume you have an object:

std::map<K,V> myMap;

To sum all the V's in the map:

V sum = std::accumulate( myMap.begin(),myMap.end(),V(),SumSecondFunction<K,V>() );

(Yes, I know there are other, better ways to do this, if one has access to BOOST. Unfortunately, we're not supposed to use BOOST in LArSoft, since as of Jul-2009 it's not universally installed on FNAL machines.)

VectorMap 17-Apr-2008 William Seligman selig.nosp@m.man@.nosp@m.nevis.nosp@m..col.nosp@m.umbia.nosp@m..edu

This class is an implementation of a concept discussion in "Effective STL" by Scott Meyers:

STL maps are useful because their contents are always sorted, so they're effective for fast searches. However, in almost every other respect vectors are superior: They take up less space, and they use random-access iterators.

This class implements "sorted vector maps," that is, an STL-style map implemented as a sorted STL vector of pairs. I've done my best to implement all aspects of the std::map interface in this class, with some additions; if you've defined the following:

VectorMap<key_type, data_type> svm;

  • svm(i) will return the "i-th" value in the map; that is, "i" is a numeric index instead of a key. (Note the use of parenthesis instead of square brackets.) This is a boon to physicists, most of whom couldn't tell an iterator from a hole in the wall.
  • svm.Key(i) will return the "i-th" key in the map.
  • svm.Data(i) will return the same result as svm(i).
  • svm[key_type] will now return the corresponding data_type in both const and non-const contexts. However, if you ask for svm[key] and the key isn't in the map, and you're in a const context, the routine will throw an out-of-range exception.

INCREDIBLY IMPORTANT NOTE: The "key type" of a VectorMap cannot be a "const" type (unlike maps); it won't even compile. When you do an insert, the underlying vector has to move things around within its list, and it uses the assignment operator=() (or "vector{i+1)=vector(i)" if you like). You can't do that if either the key or the data is const.

As with a map, there's no way to insert items at a specific location in a VectorMap. The insertion methods (including operator[]) all operate on a sorted sequence according to the key. Because of this, insertions take a long time.

However, for our processing, this doesn't matter much; for almost all our maps, we typically have:

  • Initialization, where the time doesn't matter (e.g., tracks in a Monte Carlo).
  • Access, where efficient or "simple" access to the map's contents are important. In general, we access a map many, many more times that we create one.
  • After we create/initialize a map, we never change its contents.

For this usage, a sorted vector is generally superior to a map.

This class just implements the equivalent of an STL map, not a multimap, set, nor a multiset. If there's a need, I may create additional classes.

Is there any map feature that's not implemented? Yes:

  • equal_range in a const context (which causes some weird ROOT dictionary problem); this isn't likely to be used for a map anyway (multimaps or multisets would be a different story).

Advanced implementation note: Depending on the application, it might be possible to speed up this class by using "lazy evaluation"; that is, we wouldn't actually sort the vector until the user actually tries to access its contents. I'm not going to do this, because:

A) I don't think my programming skills are up to the task.

B) In the primary application for which I plan to use this class (Monte-Carlo particle tracks), we're performing at least one search after every insert; lazy evaluation wouldn't be much of a speed improvement.

Feb-2011 WGS: VectorMap mostly looks like a map, but there are some memory-management issues that relate to it being a vector. Include the vector-based routines reserve() and capacity().

Title: GaussianEliminationAlg Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that solves system of linear equations via Gaussian Elimination. Intended for use with RFFHitFitter

Typedef Documentation

template<typename DATUM >
using util::GridContainer2D = typedef GridContainerBase2D<DATUM, GridContainer2DIndices>

Container allowing 2D indexing.

Template Parameters
DATUMtype of contained data
See also
GridContainer2DIndices

This is an alias for GridContainerBase2D, with a proper index manager. See the documentation of GridContainerBase2D.

Definition at line 267 of file GridContainers.h.

Index manager for a container of data arranged on a 2D grid.

Definition at line 181 of file GridContainerIndices.h.

template<typename DATUM >
using util::GridContainer3D = typedef GridContainerBase3D<DATUM, GridContainer3DIndices>

Container allowing 3D indexing.

Template Parameters
DATUMtype of contained data
See also
GridContainer3DIndices

This is an alias for GridContainerBase3D, with a proper index manager. See the documentation of GridContainerBase3D.

Definition at line 279 of file GridContainers.h.

Index manager for a container of data arranged on a 3D grid.

Definition at line 184 of file GridContainerIndices.h.

type of provider name following LArSoft name convention

Definition at line 235 of file LArPropertiesServiceArgoNeuT.h.

using util::MatrixIndices = typedef TensorIndices<2U>

Type for indexing a 2D-tensor (matrix)

Definition at line 550 of file TensorIndices.h.

Definition at line 48 of file DatabaseUtil.h.

Definition at line 49 of file DatabaseUtil.h.

typedef int util::UBLArSoftCh_t

Definition at line 46 of file DatabaseUtil.h.

Function Documentation

template<typename T >
constexpr auto util::abs ( v)

Returns the absolute value of the argument.

Template Parameters
Ttype of the argument
Parameters
vvalue to be processed
Returns
the absolute value of v

If the value v is negative, its opposite is returned. Note that this implementation does not work with data types that are not comparable (like std::complex).

Requirements

  • constexpr construction of a T value from the literal 0
  • operator- (T) constexpr
  • operator< (T, T) constexpr convertible to bool

Definition at line 40 of file constexpr_math.h.

Referenced by raw::ADCStickyCodeCheck(), cluster::ClusterCrawlerAlg::AddHit(), tca::AddHits(), opdet::AddHitToFlash(), cluster::ClusterCrawlerAlg::AddLAHit(), sim::OpDetBacktrackerRecord::AddScintillationPhotons(), tca::AddTjsInsideEnvelope(), shower::TCShowerElectronLikelihood::analyze(), shower::TCShowerTemplateMaker::analyze(), cluster::ClusterAna::analyze(), pfpf::PFPAna::analyze(), cluster::DBclusterAna::analyze(), NuShowerEff::analyze(), trkf::SeedAna::analyze(), trkf::TrackAna::analyze(), tca::AnalyzeRotPos(), trkf::TrackAna::anaStitch(), cluster::ClusterCrawlerAlg::AngleFactor(), trkf::TrackStatePropagator::apply_mcs(), sim::ParticleList::at(), tca::AttachToAnyVertex(), cmtool::CBAlgoAngleAlign::Bool(), cmtool::CBAlgoStartInCone::Bool(), cmtool::CBAlgoTrackSeparate::Bool(), cmtool::CBAlgoAngleCompat::Bool(), cmtool::CBAlgoAngleIncompat::Bool(), cmtool::CBAlgoAngleSeparate::Bool(), cmtool::CBAlgoOutOfConeSeparate::Bool(), cmtool::CBAlgoCenterOfMass::Bool(), dbsPoint::bounds(), tca::BraggSplit(), lar_cluster3d::ConvexHullPathFinder::breakClusterAtBigGap(), lar_cluster3d::VoronoiPathFinder::breakIntoTinyBits(), lar_cluster3d::ClusterPathFinder::buildConvexHull(), lar_cluster3d::VoronoiPathFinder::buildConvexHull(), lar_cluster3d::ConvexHullPathFinder::buildConvexHull(), lar_cluster3d::MSTPathFinder::buildConvexHull(), lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps(), trkf::KalmanFilterAlg::buildTrack(), lar_cluster3d::ClusterPathFinder::buildVoronoiDiagram(), lar_cluster3d::VoronoiPathFinder::buildVoronoiDiagram(), larg4::ISCalcNESTLAr::CalcIonAndScint(), util::SignalShaping::CalculateDeconvKernel(), ShowerRecoTools::ShowerStandardCalodEdx::CalculateElement(), NestAlg::CalculateIonizationAndScintillation(), DUNE::NeutrinoShowerEff::checkCNNtrkshw(), opdet::FlashHypothesisCollection::CheckFrac(), tca::ChgFracBetween(), tca::ChkChgAsymmetry(), cluster::ClusterCrawlerAlg::ChkClusterDS(), cluster::ClusterCrawlerAlg::ChkClusterNearbyHits(), cluster::ClusterCrawlerAlg::ChkMerge(), cluster::ClusterCrawlerAlg::ChkMerge12(), cluster::ClusterCrawlerAlg::ChkSignal(), tca::ChkStop(), tca::ChkStopEndPts(), cluster::ClusterCrawlerAlg::ChkVertex(), lar_cluster3d::ClusterMergeAlg::closestApproach(), evd::RecoBaseDrawer::Cluster2D(), cluster::ClusterCrawlerAlg::ClusterLoop(), cluster::ClusterCrawlerAlg::ClusterVertex(), nnet::TrainingDataAlg::collectVtxFlags(), opdet::FlashUtilities::CompareByError(), opdet::FlashUtilities::CompareByFraction(), trkf::SpacePointAlg::compatible(), tca::CompatibleMerge(), tca::CompleteIncomplete3DVerticesInGaps(), pma::Track3D::CompleteMissingWires(), voronoi2d::EventUtilities::computeArcVal(), voronoi2d::EventUtilities::computeBreak(), voronoi2d::VoronoiDiagram::computeCircleCenter2(), voronoi2d::VoronoiDiagram::computeCircleCenter3(), geo::TPCGeo::ComputeDriftDistance(), geo::GeometryCore::ComputeThirdPlaneSlope(), evgb::GENIEHelper::ConfigGeomScan(), lar_cluster3d::kdTree::consistentPairs(), opdet::ConstructFlash(), cluster::ClusterCrawlerAlg::CrawlUS(), cluster::ClusterCrawlerAlg::CrawlVtxChk(), cluster::ClusterCrawlerAlg::CrawlVtxChk2(), t0::DirectHitParticleAssns::CreateHitParticleAssociations(), hit::RFFHitFitter::CreateMergeVector(), lar_pandora::LArPandoraInput::CreatePandoraMCLinks2D(), sppt::SpacePointAlg_TimeSort::createSpacePoints(), RunAction::CriticalEnergy(), tca::dEdx(), trkf::Propagator::dedx_prop(), tca::DefineHitPos(), tca::DeltaAngle(), recob::MCSFitResult::deltaLogLikelihood(), geo::TPCGeo::DetectDriftDirection(), geo::PlaneGeo::DetectGeometryDirections(), detectGlobalDriftDir(), phot::PhotonMappingXMirrorTransformations::detectorToLibrary(), trkf::TrackKalmanFitter::doFitWork(), evdb_tool::SpacePoint3DDrawerHitAsymmetry::Draw(), evd::Ortho3DPad::Draw(), evd::RecoBaseDrawer::Draw2DSlopeEndPoints(), evd_tool::ProtoDUNEDrawer::DrawAxes(), evd_tool::StandardDrawer::DrawAxes(), evd_tool::ProtoDUNEDrawer::DrawGrids(), evd_tool::StandardDrawer::DrawGrids(), larg4::LArVoxelReadout::DriftIonizationElectrons(), tca::ElectronLikelihood(), fhicl::detail::encode(), lar::util::GaussianFit< T >::EncodeValue(), cluster::ClusterCrawlerAlg::EndKinkAngle(), tca::EndMerge(), cluster::EndPointAlg::EndPoint(), geo::details::ActiveAreaCalculator::equal(), sim::ParticleList::erase(), tca::ExpectedHitsRMS(), trkf::KalmanFilterAlg::extendTrack(), cluster::HoughBaseAlg::FastTransform(), trkf::VertexFitAlg::fcnVtxPos(), trkf::CCTrackMaker::FillEndMatch(), evgen::NDKGen::FillHistograms(), evgen::GENIEGen::FillHistograms(), microboone::CosmicRemovalAna::FillMCInfo(), cheat::RecoCheckAna::FillResults(), simfilter::FilterCryostatNus::filter(), simfilter::FilterGenInTime::filter(), sim::ParticleList::find(), vertex::FeatureVertexFinder::Find2dClusterVertexCandidates(), tca::Find2DVertices(), tca::Find3DVertices(), vertex::FeatureVertexFinder::Find3dVtxFrom2dClusterVtxCand(), trkf::TrackMomentumCalculator::find_angle(), lar_cluster3d::MinSpanTreeAlg::FindBestPathInCluster(), lar_cluster3d::MSTPathFinder::FindBestPathInCluster(), cluster::BlurredClusteringAlg::FindBlurringParameters(), evd::TWQProjectionView::FindEndPoint(), tca::FindHammerVertices(), trkf::StitchAlg::FindHeadsAndTails(), reco_tool::CandHitMorphological::findHitCandidates(), ShowerRecoTools::Shower2DLinearRegressionTrackHitFinder::FindInitialTrackHits(), shower::EMShowerAlg::FindInitialTrackHits(), evd::TWQProjectionView::FindLineLength(), tca::FindParent(), reco_tool::PeakFitterMrqdt::findPeakParameters(), cluster::ClusterCrawlerAlg::FindStarVertices(), tca::FindUseHits(), cluster::ClusterCrawlerAlg::FindVertices(), tca::FitChg(), trkf::KalmanFilterAlg::fitMomentumMS(), hit::CCHitFinderAlg::FitNG(), tca::FitTraj(), tca::FixTrajBegin(), cmtool::CFAlgoStartTimeCompat::Float(), tca::Forecast(), MedicalBeam::GenerateBeamDirection(), util::GeometryUtilities::Get2Dangle(), util::GeometryUtilities::Get2DPitchDistance(), util::GeometryUtilities::Get2DPitchDistanceWSlope(), util::GeometryUtilities::Get3DSpecialCaseTheta(), vertex::FeatureVertexFinder::Get3dVertexCandidates(), opreco::OpticalRecoAna::get_MC_particle_list(), lar_content::ShowerGrowingAlgorithm::GetAllVertexSeedCandidates(), larg4::SimpleWireplaneAction::GetAttenuationFraction(), larg4::OverlaidWireplanesAction::GetAttenuationFraction(), geo::WireGeo::GetCenter(), voronoi2d::VoronoiDiagram::getConvexHull(), trkf::TrackMomentumCalculator::getDeltaThetaij_(), util::GaussianEliminationAlg::GetDistance(), lar_pandora::LArPandoraEvent::GetFilteredParticlesByPdgCode(), lar_pandora::ConsolidatedPFParticleAnalysisTemplate::GetFinalStatePFParticleVectors(), tca::GetHitMultiplet(), cluster::ClusterCrawlerAlg::GetHitRange(), trkf::SurfYZPlane::getMomentum(), trkf::SurfYZLine::getMomentum(), trkf::SurfXYZPlane::getMomentum(), sim::PhotonVoxelDef::GetNeighboringVoxelIDsImpl(), lar_content::ShowerGrowingAlgorithm::GetNextSeedCandidate(), lar_content::ShowerGrowingAlgorithm::GetSeedAssociationList(), trkf::TrackMomentumCalculator::getSegTracks_(), shower::TCShowerElectronLikelihood::getShowerProfile(), cluster::DBScanAlg::getSimilarity(), cluster::DBScanAlg::getSimilarity2(), trkf::TrackMomentumCalculator::GetTrackMomentum(), util::NormalDistribution::getValue(), larg4::OpFastScintillation::getVISTime(), phot::PDFastSimPAR::getVISTime(), shower::TCShowerAlg::goodHit(), tca::GottaKink(), lar_cluster3d::SpacePointHit3DBuilder::Hit3DBuilder(), cosmic::BeamFlashTrackMatchTaggerAlg::InDetector(), hit::DisambigCheater::InitHitToWids(), tca::InShowerProb(), tca::InShowerProbTrans(), geo::GeometryCore::IntersectSegments(), lar::sparse_vector< float >::is_equal(), lar::sparse_vector< float >::is_zero(), lar_content::CheatingClusterCharacterisationAlgorithm::IsClearTrack(), lar_content::CheatingPfoCharacterisationAlgorithm::IsClearTrack(), lar_content::SvmPfoCharacterisationAlgorithm::IsClearTrack(), tca::IsCloseToVertex(), nnet::TrainingDataAlg::isElectronEnd(), trkf::SurfYZPlane::isEqual(), trkf::SurfYZLine::isEqual(), trkf::SurfXYZPlane::isEqual(), geo::WireGeo::isHorizontal(), nnet::TrainingDataAlg::isMuonDecaying(), AcceptFindNeighbors::isNear(), lar_content::LArMCParticleHelper::IsNeutrino(), lar_content::LArPfoHelper::IsNeutrino(), lar_pandora::LArPandoraHelper::IsNeutrino(), trkf::SurfYZPlane::isParallel(), trkf::SurfYZLine::isParallel(), trkf::SurfXYZPlane::isParallel(), geo::WireGeo::isParallelTo(), lar_content::LArPfoHelper::IsShower(), lar_pandora::LArPandoraHelper::IsShower(), lar_content::LArPfoHelper::IsTrack(), lar_pandora::LArPandoraHelper::IsTrack(), trkf::SurfYZLine::isTrackValid(), geo::WireGeo::isVertical(), lar_content::LArMCParticleHelper::IsVisible(), lar_pandora::LArPandoraHelper::IsVisible(), simfilter::FilterGenInTime::KeepParticle(), trkf::KHitWireLine::KHitWireLine(), trkf::KHitWireX::KHitWireX(), cluster::ClusterCrawlerAlg::KillGarbageClusters(), cluster::ClusterCrawlerAlg::LACrawlUS(), corner::CornerFinderAlg::line_integral(), lar_cluster3d::ClusterMergeAlg::linearClusters(), tca::LineLineIntersect(), sim::ParticleList::lower_bound(), lar_cluster3d::ConvexHullPathFinder::makeCandidateCluster(), lar_cluster3d::VoronoiPathFinder::makeCandidateCluster(), trkf::CCTrackMaker::MakeClusterChains(), tca::MakeHaloTj(), lar_cluster3d::StandardHit3DBuilder::makeHitTriplet(), shower::EMShowerAlg::MakeShower(), shower::TCShowerAlg::makeShowers(), trkf::SpacePointAlg::makeSpacePoints(), trkf::KTrack::Mass(), trkf::TrackState::mass(), trkf::TrajectoryMCSFitter::mass(), tca::Match3DFOM(), tca::Match3Planes(), opreco::OpticalRecoAna::match_flashes_to_particles(), tca::TruthMatcher::MatchAndSum(), tca::MaxChargeAsymmetry(), vertex::FeatureVertexFinder::MergeAndSort3dVtxCandidate(), cluster::ClusterCrawlerAlg::MergeHits(), cluster::ClusterCrawlerAlg::MergeOverlap(), tca::MoveTPToWire(), trkf::TrackMomentumCalculator::my_mcs_llhd(), apa::APAGeometryAlg::NearestWireIDOnChan(), trkf::InteractPlane::noise(), evd::RawDataDrawer::BoxDrawer::Operate(), evd::RawDataDrawer::RoIextractorClass::Operate(), compare_to_value::operator()(), compare_to_range::operator()(), geo::WireIDIntersection::operator<(), larg4::OpFastScintillation::OpFastScintillation(), pma::PMAlgCosmicTagger::outOfDriftWindow(), tca::ParentFOM(), cluster::BlurredClusteringAlg::PassesTimeCut(), lar_content::LArMCParticleHelper::PassMCParticleChecks(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), tca::PDGCodeIndex(), geo::TPCGeo::PlanePitch(), trkf::CCTrackMaker::PlnMatch(), tca::PointInsideEnvelope(), tca::PointPull(), larg4::MuNuclearSplittingProcess::PostStepDoIt(), larg4::MuNuclearSplittingProcessXSecBias::PostStepDoIt(), trkf::KETrack::Print(), trkf::KHit< N >::Print(), tca::PrintAll(), cluster::ClusterCrawlerAlg::PrintClusters(), DUNE::NeutrinoShowerEff::processEff(), evgen::NueAr40CCGenerator::ProcessOneNeutrino(), shwf::ShowerCheater::produce(), evgen::CosmicsGen::produce(), trkf::TrackCheater::produce(), caldata::CalWire::produce(), cluster::DBCluster3D::produce(), caldata::CalWireT962::produce(), trkf::SpacePts::produce(), trkf::TrackKalmanCheater::produce(), trkf::Track3Dreco::produce(), cluster::TrajCluster::produce(), calo::ShowerCalorimetry::produce(), vertex::VertexFinder2D::produce(), detsim::DriftElectronstoPlane::produce(), calo::Calorimetry::produce(), trkf::Track3DKalmanSPS::produce(), detsim::SimDriftElectrons::produce(), trkf::PMAlgTrackMaker::produce(), trkf::TrackStatePropagator::propagateToPlane(), trkf::Track3DKalmanHitAlg::qualityCutsOnSeedTrack(), evd::RawDataDrawer::QueueDrawingBoxes(), larg4::LArVoxelReadout::RecoverOffPlaneDeposit(), larg4::Rectangle_SolidAngle(), simb::MCFlux::ReDecay(), cluster::ClusterCrawlerAlg::RefineVertexClusters(), geo::vect::extra::roundValue0(), geo::vect::extra::roundValue01(), lar_content::ShowerTensorVisualizationTool::Run(), tca::SaveCRInfo(), nnet::TrainingDataAlg::setEventData(), detsim::SimWire::SetFieldResponse(), evd::TWQProjectionView::SetMouseZoomRegion(), simb::MCTruth::SetNeutrino(), lar_content::NeutrinoPropertiesAlgorithm::SetNeutrinoId(), tca::SetSection(), shower::TCShowerTemplateMaker::showerProfile(), shower::TCShowerTemplateMaker::showerProfileTrue(), tca::SignalAtTp(), tca::SignalAtTpInSlc(), evd::RecoBaseDrawer::Slice2D(), evd::RecoBaseDrawer::Slice3D(), cluster::LineMerger::SlopeCompatibility(), geo::sortPlaneStandard(), geo::sortWireStandard(), tca::StartChgVec(), tca::StepAway(), larg4::G4BadIdeaAction::SteppingAction(), tca::StitchPFPs(), trkf::CCTrackMaker::StoreTrack(), hit::CCHitFinderAlg::StudyHits(), lar_content::SvmPfoCharacterisationAlgorithm::SvmPfoCharacterisationAlgorithm(), trkf::Track3DKalmanHitAlg::testSeedSlope(), geo::OpDetGeo::ThetaZ(), apa::APAGeometryAlg::ThreeChanPos(), geo::TPCGeo::TPCGeo(), tca::TPNearVertex(), trkf::CosmicTrackerAlg::Track3D(), cheat::PhotonBackTracker::TrackIDToMCTruth(), cheat::ParticleInventory::TrackIdToMCTruth_P(), cheat::PhotonBackTracker::TrackIDToMotherParticle(), cheat::ParticleInventory::TrackIdToMotherParticle_P(), cheat::BackTracker::TrackIdToSimIDEs_Ps(), cheat::PhotonBackTracker::TrackIDToSimSDP(), cheat::PhotonBackTracker::TrackIdToSimSDPs_Ps(), lar::util::TrackPitchInView(), lar::util::TrackProjectedLength(), trkf::CosmicTrackerAlg::TrackTrajectory(), tca::TrajClosestApproach(), tca::TrajHitsOK(), tca::TrajTrajDOCA(), cluster::HoughBaseAlg::Transform(), tca::TrimEndPts(), shower::TCShowerAnalysis::truthMatcher(), DUNE::NeutrinoShowerEff::truthMatcher(), trkf::KalmanFilterAlg::updateMomentum(), geo::PlaneGeo::UpdateOrientation(), geo::TPCGeo::UpdatePlaneCache(), tca::UpdateShower(), tca::UpdateTjChgProperties(), geo::PlaneGeo::UpdateView(), tca::UpdateVxEnvironment(), sim::ParticleList::upper_bound(), geo::GeometryCore::ValueInRange(), trkf::Propagator::vec_prop(), larg4::OpFastScintillation::VISHits(), phot::PDFastSimPAR::VISHits(), geo::GeometryCore::VolumeName(), cluster::ClusterCrawlerAlg::Vtx3ClusterSplit(), cluster::ClusterCrawlerAlg::VtxConstraint(), tca::VtxHitsSwap(), larg4::OpFastScintillation::VUVHits(), phot::PDFastSimPAR::VUVHits(), geo::GeometryCore::WireEndPoints(), geo::WireGeo::WirePitch(), lar::util::RealComparisons< geo::Length_t >::zero(), and raw::ZeroSuppression().

40 { return (-T(0) < v)? v: -v; }
template<typename A , typename B >
constexpr auto util::absDiff ( A const &  a,
B const &  b 
)

Returns the absolute value of the difference between two values.

Template Parameters
Atype of the first value
Btype of the second value (must actually be as A)
Parameters
athe first value
bthe 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 43 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().

44  {
45  static_assert(
46  std::is_same<std::decay_t<A>, std::decay_t<B>>(),
47  "Arguments of util::absDiff() have to be of the same type."
48  );
49  return (b > a)? (b - a): (a - b);
50  }
template<class A >
auto util::associated_groups ( A const &  assns)

Helper functions to access associations in order.

Template Parameters
Atype of association being read
Parameters
assnsthe association being read
See also
for_each_associated_group()

This function provides a functionality equivalent to art::for_each_group(), but it grants the caller additional control on the external loop and on the function.

Example: assuming that a module with input tag stored in fTrackTag has created associations of each track to its hits, the total charge for each track can be extracted by:

auto assns = art::getValidHandle<art::Assns<recob::Track, recob::Hit>>
(fTrackTag);
std::vector<double> totalCharge;
for (auto const& hits: util::associated_groups(*assns)) {
double total = 0.;
total += hit->Integral();
totalCharge.push_back(total);
} // for

A number of important points need to be realised about this example:

  • the requirements of this function on its input association are the same as for art::for_each_group()
  • we can code the action on each group of hits directly in a loop, if like in this case the code is succinct
  • again, there is one outer loop iteration for every track;
  • the value of hits is an object representing a range of art pointers (art::Ptr<recob::Hit>) which can be navigated with the begin()/end() free functions, or in a range-for loop;
  • on each iteration, the information of which track the hits are associated to is not available; if that is also needed, use util::associated_groups_with_left() instead.

Definition at line 94 of file ForEachAssociatedGroup.h.

References a1, a2, range_for, and values().

Referenced by TrackProducerFromTrack::produce(), TrackProducerFromTrackTrajectory::produce(), and TrackProducerFromPFParticle::produce().

94  {
95  return assns |
96  ranges::view::all |
97  ranges::view::group_by([](auto a1, auto a2) { return a1.first == a2.first;}) |
98  ranges::view::transform([] (auto pairs) {return pairs | ranges::view::values | util::range_for;}) |
100  ;
101  } // associated_groups()
#define a2
constexpr RangeForWrapperTag range_for
decltype(auto) values(Coll &&coll)
Range-for loop helper iterating across the values of the specified collection.
#define a1
template<class A >
auto util::associated_groups_with_left ( A const &  assns)

Helper functions to access associations in order, also with key.

Template Parameters
Atype of association being read
Parameters
assnsthe association being read
See also
for_each_associated_group()

This function provides a functionality equivalent to art::for_each_group_with_left(), but it grants the caller additional control on the external loop and on the function.

Example: assuming that a module with input tag stored in fTrackTag has created associations of each track to its hits, the total charge for each track can be extracted by:

auto assns = art::getValidHandle<art::Assns<recob::Track, recob::Hit>>
(fTrackTag);
std::map<int, double> totalCharge;
for (auto const& trackWithHits: util::associated_groups_with_left(*assns))
{
art::Ptr<recob::Track> const& track = trackWithHits.first;
auto const& hits = trackWithHits.second;
if (totalCharge.count(track->ID()) > 0) {
<< "Multiple tracks have ID " << track->ID() << "!\n";
}
double& total = totalCharge[track->ID()];
total = 0.0;
total += hit->Integral();
} // for

A number of important points need to be realised about this example:

  • the requirements of this function on its input association are the same as for art::for_each_group_with_left()
  • we can code the action on each group of hits directly in a loop, if like in this case the code is succinct
  • again, there is one outer loop iteration for every track;
  • the value of hits is an object representing a range of art pointers (art::Ptr<recob::Hit>) which can be navigated with the begin()/end() free functions, or in a range-for loop.

Definition at line 152 of file ForEachAssociatedGroup.h.

References a1, a2, range_for, and values().

152  {
153  return assns
154  | ranges::view::all
155  | ranges::view::group_by([](auto a1, auto a2) { return a1.first == a2.first;})
156  | ranges::view::transform([] (auto pairs)
157  {
158  return std::make_pair(
159  pairs.front().first, // assuming they're all the same, pick first
161  );
162  })
164  ;
165  } // associated_groups_with_left()
#define a2
constexpr RangeForWrapperTag range_for
decltype(auto) values(Coll &&coll)
Range-for loop helper iterating across the values of the specified collection.
#define a1
template<typename Coll >
decltype(auto) util::const_values ( Coll &&  coll)

Range-for loop helper iterating across the constant values of the specified collection.

See also
util::values()

This function is equivalent to util::values() but the values are extracted as if the specified collection were constant.

template<typename T >
auto util::counter ( begin,
end 
)

Returns an object to iterate values from begin to end in a range-for loop.

Template Parameters
Ttype of counter value
Returns
a control object for range-for loop
See also
util::count_iterator

An example of usage:

std::vector<std::size_t> data;
for (auto i: util::counter(4, 8)) {
data.push_back(i);
}

will insert in data the numbers from 4 to 7, just like:

for (std::size_t i = 4; i < 8; ++i) {
data.push_back(i);
}

would.

Definition at line 285 of file counter.h.

References util::count_iterator< T >::count_iterator(), and span().

Referenced by opdet::SimPhotonCounterAlg::AddSimPhotonCollection(), opdet::SimPhotonCounterAlg::AddSimPhotonsVector(), lar::details::bulk_allocator::ReferenceCounter::AddUser(), NestAlg::CalculateIonizationAndScintillation(), ShowerRecoTools::ShowerDirectionCheater::CalculateRMS(), opdet::SimPhotonCounterAlg::ClearCounters(), lar::details::bulk_allocator::ReferenceCounter::Count(), counter(), trkf::KGTrack::fillHits(), trkf::SeedFinderAlgorithm::FindSeedAtEnd(), larg4::OpFastScintillation::getVISTime(), phot::PDFastSimPAR::getVISTime(), lar::details::bulk_allocator::ReferenceCounter::hasUsers(), calo::TrackCalorimetryAlg::IsInvertedTrack(), lar::CountersMap< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::CounterKey_t::Key(), art::detail::IPRHelper< ProdA, ProdB, Data, DATACOLL, EVENT >::operator()(), pmtana::AlgoSiPM::RecoPulse(), pmtana::AlgoThreshold::RecoPulse(), lar::details::bulk_allocator::ReferenceCounter::RemoveUser(), ShowerRecoTools::ShowerDirectionCheater::RMSShowerGradient(), hit::HitAnaAlg::ROIInfo(), lar_content::TransverseTensorVisualizationTool::Run(), and lar_content::ShowerTensorVisualizationTool::Run().

286  { return util::span(count_iterator(begin), count_iterator(end)); }
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:72
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:67
template<typename T >
auto util::counter ( end)

Version of util::counter() starting at default-constructed T (usually some form of 0).

Definition at line 184 of file counter.h.

References counter(), end(), and infinite_counter().

184 { return counter(T{}, end); }
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:72
auto counter(T end)
Definition: counter.h:184
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
art::Ptr< U > const &  b,
art::Assns< U, T > &  assn,
std::string  a_instance,
size_t  index = UINT_MAX 
)

Creates a single one-to-one association.

Template Parameters
Ttype of the new object to associate
Utype of the object already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bart::Ptr to the (new) object to be associated to the one in a
assnreference to association object where the new one will be put
a_instancename of the instance that will be used for a in evt
indexindex of the element in a to be associated with b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

As example of usage: create a wire/raw digit association. This code should live in the art::EDProduce::produce() method. The raw::RawDigit product was created already by a DigitModuleLabel module. The code is supposed to produce one recob::Wire for each existing raw::RawDigit, and contextually associate the new wire to the source digit. We are also assuming that there might be different RawDigit sets produced by the same producer: we identify the one we care of by the string spill_name and we create wires and associations with the same label for convenience.

// this is the original list of digits, thawed from the event
art::Handle< std::vector<raw::RawDigit>> digitVecHandle;
evt.getByLabel(DigitModuleLabel, spill_name, digitVecHandle);

// the collection of wires that will be written as data product
std::unique_ptr<std::vector<recob::Wire>> wirecol(new std::vector<recob::Wire>);
// ... and an association set
std::unique_ptr<art::Assns<raw::RawDigit,recob::Wire>> WireDigitAssn
  (new art::Assns<raw::RawDigit,recob::Wire>);

for(size_t iDigit = 0; iDigit < digitVecHandle->size(); ++iDigit) {
  // turn the digit into a art::Ptr:
  art::Ptr<raw::RawDigit> digit_ptr(digitVecHandle, iDigit);

  // store the wire in its final position in the data product;
  // the new wire is currently the last of the list
  wirecol->push_back(std::move(wire));

  // add an association between the last object in wirecol
  // (that we just inserted) and digit_ptr
  if (!util::CreateAssn(*this, evt, *wirecol, digit_ptr, *WireDigitAssn, spill_name)) {
    throw art::Exception(art::errors::ProductRegistrationFailure)
      << "Can't associate wire #" << (wirecol->size() - 1)
      << " with raw digit #" << digit_ptr.key();
  } // if failed to add association

} // for digits

evt.put(std::move(wirecol), spill_name);
evt.put(std::move(WireDigitAssn), spill_name);

Definition at line 603 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), e, and tca::evt.

Referenced by cluster::ClusterMergeHelper::AppendResult(), CreateAssn(), lar_cluster3d::Cluster3D::findTrackSeeds(), lar_cluster3d::Cluster3D::ArtOutputHandler::makeClusterHitAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makeEdgeSpacePointAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makePFPartClusterAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makePFPartEdgeAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makePFPartPCAAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makePFPartSeedAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makePFPartSpacePointAssns(), lar_cluster3d::Cluster3D::ArtOutputHandler::makeSpacePointHitAssns(), pid::Chi2ParticleID::produce(), cosmic::TrackPFParticleMatch::produce(), lar_pandora::LArPandoraTrackCreation::produce(), vertex::VertexCheater::produce(), lar_pandora::LArPandoraShowerCreation::produce(), cosmic::CosmicClusterTagger::produce(), shwf::ShowerCheater::produce(), trk::TrackContainmentTagger::produce(), cosmic::CosmicTrackTagger::produce(), event::EventCheater::produce(), trkf::SpacePointCheater::produce(), trkf::SpacePointFinder::produce(), trkf::TCTrack::produce(), cluster::LineCluster::produce(), tss::TrackShowerHits::produce(), sppt::TTSpacePointFinder::produce(), cluster::ClusterCheater::produce(), cluster::ClusterCrawler::produce(), opdet::OpFlashFinder::produce(), trkf::TrackCheater::produce(), cosmic::CosmicPFParticleTagger::produce(), trkf::TrackStitcher::produce(), cluster::DBcluster::produce(), shwf::ShowerFinder::produce(), cluster::LineMerger::produce(), cosmic::BeamFlashTrackMatchTagger::produce(), vertex::PrimaryVertexFinder::produce(), cluster::EndPointModule::produce(), cluster::HoughLineFinder::produce(), caldata::CalWire::produce(), cluster::DBCluster3D::produce(), caldata::CalWireT962::produce(), calo::TrackCalorimetry::produce(), ShowerReco3D::produce(), cluster::BlurredClustering::produce(), shower::TCShower::produce(), trkf::SpacePts::produce(), trkf::TrackKalmanCheater::produce(), trkf::Track3Dreco::produce(), cosmic::CosmicPCAxisTagger::produce(), cluster::TrajCluster::produce(), trkf::CCTrackMaker::produce(), calo::ShowerCalorimetry::produce(), ems::EMShower3D::produce(), shwf::ShowerReco::produce(), cluster::SmallClusterFinder::produce(), trkf::Track3DKalman::produce(), shower::EMShower::produce(), vertex::VertexFinder2D::produce(), lbne::PhotonCounterT0Matching::produce(), evgen::GENIEGen::produce(), evd::GraphCluster::produce(), t0::MCTruthT0Matching::produce(), calo::Calorimetry::produce(), trkf::PMAlgTrajFitter::produce(), trkf::Track3DKalmanSPS::produce(), trkf::PMAlgTrackMaker::produce(), trkf::CosmicTracker::produce(), evgen::MarleyTimeGen::produce(), mvapid::MVAAlg::RunPID(), and lar_pandora::LArPandoraEvent::WriteAssociation().

612 {
613  if (index == UINT_MAX) index = a.size()-1;
614 
615  try{
616  assn.addSingle(b, art::PtrMaker<T>{evt, a_instance}(index));
617  return true;
618  }
619  catch(cet::exception &e){
620  mf::LogWarning("AssociationUtil")
621  << "unable to create requested art:Assns, exception thrown: " << e;
622  return false;
623  }
624 
625 } // util::CreateAssn() [01]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
TCEvent evt
Definition: DataStructs.cxx:7
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
art::Ptr< U > const &  b,
art::Assns< U, T > &  assn,
size_t  index = UINT_MAX 
)
inline

Creates a single one-to-one association.

Template Parameters
Ttype of the new object to associate
Utype of the object already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bart::Ptr to the (new) object to be associated to the one in a
assnreference to association object where the new one will be put
indexindex of the element in a to be associated with b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

The instance name of the product a will be in is assumed empty. Example of usage:

// this is the original list of digits, thawed from the event
art::Handle< std::vector<raw::RawDigit>> digitVecHandle;
evt.getByLabel(DigitModuleLabel, digitVecHandle);

// the collection of wires that will be written as data product
std::unique_ptr<std::vector<recob::Wire>> wirecol(new std::vector<recob::Wire>);
// ... and an association set
std::unique_ptr<art::Assns<raw::RawDigit,recob::Wire>> WireDigitAssn
  (new art::Assns<raw::RawDigit,recob::Wire>);

for(size_t iDigit = 0; iDigit < digitVecHandle->size(); ++iDigit) {
  // turn the digit into a art::Ptr:
  art::Ptr<raw::RawDigit> digit_ptr(digitVecHandle, iDigit);

  // store the wire in its final position in the data product;
  // the new wire is currently the last of the list
  wirecol->push_back(std::move(wire));

  // add an association between the last object in wirecol
  // (that we just inserted) and digit_ptr
  if (!util::CreateAssn(*this, evt, *wirecol, digit_ptr, *WireDigitAssn)) {
    throw art::Exception(art::errors::ProductRegistrationFailure)
      << "Can't associate wire #" << (wirecol->size() - 1)
      << " with raw digit #" << digit_ptr.key();
  } // if failed to add association

} // for digits

evt.put(std::move(wirecol));
evt.put(std::move(WireDigitAssn));

Definition at line 213 of file AssociationUtil.h.

References CreateAssn(), CreateAssnD(), tca::evt, FindUNotAssociatedToT(), FindUNotAssociatedToTP(), GetAssociatedVectorManyI(), GetAssociatedVectorManyP(), GetAssociatedVectorOneI(), GetAssociatedVectorOneP(), geo::vect::indices(), and lar::dump::vector().

219  { return CreateAssn(prod, evt, a, b, assn, std::string(), index); }
bool CreateAssn(PRODUCER const &prod, art::Event &evt, art::Assns< T, U > &assn, size_t first_index, Iter from_second_index, Iter to_second_index)
Creates a single one-to-many association.
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
art::Ptr< T > const &  a,
art::Ptr< U > const &  b,
art::Assns< U, T > &  assn 
)

Creates a single one-to-one association.

Template Parameters
Ttype of one object to associate
Utype of the other object to associate
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
aart::Ptr to the first object in the association
bart::Ptr to the object to be associated to the one in a
assnreference to association object where the new one will be put
Returns
whether the operation was successful (can it ever fail??)

This is the simplest way ever. Neither the event not the producer references are used.

Definition at line 631 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

637  {
638 
639  try{
640  assn.addSingle(b, a);
641  }
642  catch(cet::exception &e){
643  mf::LogWarning("AssociationUtil")
644  << "unable to create requested art:Assns, exception thrown: " << e;
645  return false;
646  }
647 
648  return true;
649 } // util::CreateAssn() [03]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
art::PtrVector< U > const &  b,
art::Assns< T, U > &  assn,
size_t  index = UINT_MAX 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bart::PtrVector to the (new) objects to be associated to the one in a
assnreference to association object where the new one will be put
indexindex of the element in a to be associated with all the ones in b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Definition at line 655 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

662  {
663  if(index == UINT_MAX) index = a.size() - 1;
664 
665  try{
666  auto const aptr = art::PtrMaker<T>{evt}(index);
667  for(art::Ptr<U> const& b_item: b) assn.addSingle(aptr, b_item);
668  }
669  catch(cet::exception &e){
670  mf::LogWarning("AssociationUtil")
671  << "unable to create requested art:Assns, exception thrown: " << e;
672  return false;
673  }
674 
675  return true;
676 } // util::CreateAssn() [04]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
Definition: fwd.h:29
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
art::Ptr< T > const &  a,
std::vector< art::Ptr< U >> const &  b,
art::Assns< T, U > &  assn 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
aart::Ptr to the item to be associated with many
bvector to art::Ptr to the (new) objects to be associated to a
assnreference to association object where the new one will be put
Returns
whether the operation was successful (can it ever fail??)

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Definition at line 681 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

687  {
688 
689  try{
690  for (art::Ptr<U> const& b_item: b) assn.addSingle(a, b_item);
691  }
692  catch(cet::exception const& e){
693  mf::LogWarning("AssociationUtil")
694  << "unable to create requested art:Assns, exception thrown: " << e;
695  return false;
696  }
697 
698  return true;
699 } // util::CreateAssn() [05]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
Definition: fwd.h:29
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
std::vector< art::Ptr< U >> const &  b,
art::Assns< T, U > &  assn,
size_t  index = UINT_MAX 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bvector to art::Ptr to the (new) objects to be associated to the one in a
assnreference to association object where the new one will be put
indexindex of the element in a to be associated with all the ones in b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Definition at line 704 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

711  {
712 
713  if (index == UINT_MAX) index = a.size() - 1;
714 
715  try{
716  auto const aptr = art::PtrMaker<T>{evt}(index);
717  for (art::Ptr<U> const& b_item: b) assn.addSingle(aptr, b_item);
718  }
719  catch(cet::exception &e){
720  mf::LogWarning("AssociationUtil")
721  << "unable to create requested art:Assns, exception thrown: " << e;
722  return false;
723  }
724 
725  return true;
726 } // util::CreateAssn() [06]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
Definition: fwd.h:29
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
std::vector< U > const &  b,
art::Assns< T, U > &  assn,
size_t  startU,
size_t  endU,
size_t  index = UINT_MAX 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bvector of the (new) objects to be associated to the one in a
assnreference to association object where the new one will be put
startUindex in b of the first element to be associated to the one in a
endUindex in b after the last element to be associated to the one in a
indexindex of the element in a to be associated with all the ones in b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

Use this when the objects in b are not yet stored in the event and are in a std::vector collection instead.

The method gets the product id for those as well as for the element in a. Also specify the range of entries to use from the std::vector collection of U objects.

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Definition at line 731 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

740  {
741 
742  if(index == UINT_MAX) index = a.size() - 1;
743 
744  try{
745  auto const aptr = art::PtrMaker<T>{evt}(index);
746  art::PtrMaker<U> const make_bptr{evt};
747  for(size_t i = startU; i < endU; ++i){
748  assn.addSingle(aptr, make_bptr(i));
749  }
750  }
751  catch(cet::exception &e){
752  mf::LogWarning("AssociationUtil")
753  << "unable to create requested art:Assns, exception thrown: " << e;
754  return false;
755  }
756 
757  return true;
758 } // util::CreateAssn() [07]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<class PRODUCER , class T , class U >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
std::vector< T > const &  a,
std::vector< U > const &  b,
art::Assns< T, U > &  assn,
std::vector< size_t > const &  indices,
size_t  index = UINT_MAX 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
avector of data products that are in, or will be put into, evt
bvector of the (new) objects to be associated to the one in a
assnreference to association object where the new one will be put
indicesindices of the elements in b to be associated to the one in a
indexindex of the element in a to be associated with all the ones in b (default: the last element)
Returns
whether the operation was successful (can it ever fail??)

Use this when the objects in b are not yet stored in the event and are in a std::vector collection instead.

The method gets the product id for those as well as for the element in a. Also specify the entries to use from the std::vector collection of U objects.

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Definition at line 763 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

771  {
772 
773  if(index == UINT_MAX) index = a.size() - 1;
774 
775  try{
776  auto const aptr = art::PtrMaker<T>{evt}(index);
777  art::PtrMaker<U> const make_bptr{evt};
778  for(size_t index: indices){
779  assn.addSingle(aptr, make_bptr(index));
780  }
781  }
782  catch(cet::exception &e){
783  mf::LogWarning("AssociationUtil")
784  << "unable to create requested art:Assns, exception thrown: " << e;
785  return false;
786  }
787 
788  return true;
789 } // util::CreateAssn() [07a]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename PRODUCER , typename T , typename U , typename Iter >
bool util::CreateAssn ( PRODUCER const &  prod,
art::Event evt,
art::Assns< T, U > &  assn,
size_t  first_index,
Iter  from_second_index,
Iter  to_second_index 
)

Creates a single one-to-many association.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Iteriterator to size_t-compatible elements
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
assnreference to association object where the new one will be put
first_indexindex of the object of type T to be associated to all the others
from_second_indexiterator pointing to the first of the indices of U type objects to be associated to the one of the first type
to_second_indexiterator pointing after the last of the indices of U type objects to be associated to the one of the first type
Returns
whether the operation was successful (can it ever fail??)

A "one-to-many" association is actually a number of one-to-one associations. If you want to keep the information of the order of the many, you may have to use an association with a data member (the third template parameter that we pretent not to exist).

Use this if the objects that have to be associated to the one of type T are sparse, spread across a to-be-data-product, but you have a list of the indices in the data product of the elements to associate to the one of type T. In other words, given that you have a data product "a" of type std::vector<T> and a data product "b" of type std::vector<U>, this method creates an association betweena[first_index]and b[*(from_second_index)], another between a[first_index] and b[*(from_second_index + 1)], etc.

The surprising concept here is that you don't need to specify neither of the collections of T or U elements. The data product is uniquely defined by its type, producer, process and product label. Here we assume that the type of the products are std::vector<T> and std::vector<U>, and that the products have empty product labels, and that the producer is prod for both of them.

Definition at line 794 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

801  {
802 
803  try{
804  // we declare here that we want to associate the element first_index of the
805  // (only) data product of type std::vector<T> with other objects.
806  // This is the pointer to that element:
807  auto const first_ptr = art::PtrMaker<T>{evt}(first_index);
808 
809  // we are going to associate that element in a with a number of elements
810  // of the only data product of type std::vector<U>
811  art::PtrMaker<U> const make_second_ptr{evt};
812  for (; from_second_index != to_second_index; ++from_second_index) {
813  assn.addSingle(first_ptr, make_second_ptr(*from_second_index));
814  } // while
815  }
816  catch(cet::exception &e){
817  mf::LogWarning("AssociationUtil")
818  << "unable to create requested art:Assns, exception thrown: " << e;
819  return false;
820  }
821 
822  return true;
823 } // util::CreateAssn() [08]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename PRODUCER , typename T , typename U , typename D >
bool util::CreateAssnD ( PRODUCER const &  prod,
art::Event evt,
art::Assns< T, U, D > &  assn,
size_t  first_index,
size_t  second_index,
typename art::Assns< T, U, D >::data_t &&  data 
)

Creates a single one-to-one association with associated data.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Dtype of the "metadata" coupled to this pair association
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
assnreference to association object where the new one will be put
first_indexindex of the object of type T to be associated
second_indexindex of the object of type U to be associated
data"metadata" to be store in this association
Returns
whether the operation was successful (can it ever fail??)

Use this if you want some metadata to travel together with the association. An example may be the order of the second element within a list:

size_t a_index = 2;
std::vector<size_t> b_indices{ 6, 9, 18, 12 };
for (size_t i = 0; i < b_indices.size(); ++i)
  CreateAssn(prod, evt, assn, a_index, b_index[i], i);

In this way, the association between the element #2 of "a" (a vector that is not specified – nor needed – in this snippet of code) and the element #18 will be remembered as being the third (metadata value of 2). In this example metadata is of type size_t the association would be declared as art::Assn<A, B, size_t>. A FindMany query of that association might look like:

art::Handle<std::vector<A>> a_list; // read this from the event

art::FindMany<B, size_t> Query(a_list, event, ModuleLabel);

// search for the last of the objects associated to the third element:
size_t a_index = 2; // this means third element

std::vector<size_t const*> const& metadata = Query.data(a_index);
size_t largest_index = 0, last_item = 0;
for (size_t iB = 0; iB < metadata.size(); ++iB) {
  if (largest_index >= *(metadata[iB])) continue;
  largest_index = *(metadata[iB]);
  last_item = iB;
} // for iB
B const& lastB = Query.at(last_item);

In alternative, the elements and their metadata can be fetched simultaneously with:

std::vector<art::Ptr<B>> const& Bs;
std::vector<size_t const*> const& metadata;

size_t a_index = 2; // this means third element
size_t nMatches = Query.get(a_index, Bs, metadata);

Definition at line 829 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

Referenced by CreateAssn(), cluster::LineCluster::produce(), cluster::ClusterCrawler::produce(), and cluster::TrajCluster::produce().

836  {
837 
838  try{
839  // we declare here that we want to associate the element first_index of the
840  // (only) data product of type std::vector<T> with the other object
841  auto const first_ptr = art::PtrMaker<T>{evt}(first_index);
842 
843  // the same to associate the element second_index of the (only)
844  // data product of type std::vector<U> with the first object.
845  auto const second_ptr = art::PtrMaker<U>{evt}(second_index);
846 
847  assn.addSingle(first_ptr, second_ptr, std::move(data));
848  }
849  catch(cet::exception &e){
850  mf::LogWarning("AssociationUtil")
851  << "unable to create requested art:Assns, exception thrown: " << e;
852  return false;
853  }
854 
855  return true;
856 } // util::CreateAssnD() [01a]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename PRODUCER , typename T , typename U , typename D >
bool util::CreateAssnD ( PRODUCER const &  prod,
art::Event evt,
art::Assns< T, U, D > &  assn,
size_t  first_index,
size_t  second_index,
typename art::Assns< T, U, D >::data_t const &  data 
)

Creates a single one-to-one association with associated data.

Template Parameters
Ttype of the new object to associate
Utype of the many objects already in the data product or art::Ptr
Dtype of the "metadata" coupled to this pair association
Parameters
prodreference to the producer that will write the vector a
evtreference to the current event
assnreference to association object where the new one will be put
first_indexindex of the object of type T to be associated
second_indexindex of the object of type U to be associated
data"metadata" to be store in this association
Returns
whether the operation was successful (can it ever fail??)

Use this if you want some metadata to travel together with the association. An example may be the order of the second element within a list:

size_t a_index = 2;
std::vector<size_t> b_indices{ 6, 9, 18, 12 };
for (size_t i = 0; i < b_indices.size(); ++i)
  CreateAssn(prod, evt, assn, a_index, b_index[i], i);

In this way, the association between the element #2 of "a" (a vector that is not specified – nor needed – in this snippet of code) and the element #18 will be remembered as being the third (metadata value of 2). In this example metadata is of type size_t the association would be declared as art::Assn<A, B, size_t>. A FindMany query of that association might look like:

art::Handle<std::vector<A>> a_list; // read this from the event

art::FindMany<B, size_t> Query(a_list, event, ModuleLabel);

// search for the last of the objects associated to the third element:
size_t a_index = 2; // this means third element

std::vector<size_t const*> const& metadata = Query.data(a_index);
size_t largest_index = 0, last_item = 0;
for (size_t iB = 0; iB < metadata.size(); ++iB) {
  if (largest_index >= *(metadata[iB])) continue;
  largest_index = *(metadata[iB]);
  last_item = iB;
} // for iB
B const& lastB = Query.at(last_item);

In alternative, the elements and their metadata can be fetched simultaneously with:

std::vector<art::Ptr<B>> const& Bs;
std::vector<size_t const*> const& metadata;

size_t a_index = 2; // this means third element
size_t nMatches = Query.get(a_index, Bs, metadata);

Definition at line 859 of file AssociationUtil.h.

References art::Assns< L, R, D >::addSingle(), and e.

866  {
867 
868  try{
869  // we declare here that we want to associate the element first_index of the
870  // (only) data product of type std::vector<T> with the other object
871  auto const first_ptr = art::PtrMaker<T>{evt}(first_index);
872 
873  // the same to associate the element second_index of the (only)
874  // data product of type std::vector<U> with the first object.
875  auto const second_ptr = art::PtrMaker<U>{evt}(second_index);
876 
877  assn.addSingle(first_ptr, second_ptr, data);
878  }
879  catch(cet::exception &e){
880  mf::LogWarning("AssociationUtil")
881  << "unable to create requested art:Assns, exception thrown: " << e;
882  return false;
883  }
884 
885  return true;
886 } // util::CreateAssnD() [01b]
void addSingle(Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
Definition: Assns.h:496
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
Float_t e
Definition: plot.C:34
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename T >
constexpr T util::DegreesToRadians ( angle)
inline

Converts the argument angle from degrees into radians.

Definition at line 84 of file PhysicalConstants.h.

Referenced by cluster::LazyClusterParamsAlg::StartAngle(), and cluster::StandardClusterParamsAlg::StartAngle().

84 { return angle / 180 * pi<T>(); }
decltype(auto) util::dereference ( )

Returns a functor that returns *ptr of its argument ptr.

See also
util::Dereferencer

Example:

std::vector<int> values(ptrs.size());
std::transform
(ptrs.cbegin(), ptrs.cend(), values.begin(), util::dereference());

will fill the vector values with the values pointed by the elements in ptrs.

Definition at line 125 of file operations.h.

125 { return Dereferencer(); }
template<typename Stream , typename Left , typename Right , typename Data >
void util::DumpAssociationsIntro ( Stream &&  out,
art::Assns< Left, Right, Data > const &  assns 
)

Dumps a short introduction about specified association.

Template Parameters
Streamtype of output stream
Leftfirst type in the association
Rightsecond type in the association
Datametadata type in the association
Parameters
outoutput stream
assnsthe associations to be dumped

Definition at line 33 of file DumpAssociations.h.

References art::Assns< L, R, D >::size().

34  {
35  out << "Association between '" << cet::demangle_symbol(typeid(Left).name())
36  << "' and '" << cet::demangle_symbol(typeid(Right).name()) << "'";
37  if (std::is_same<Data, void>()) {
38  out << " with '" << cet::demangle_symbol(typeid(Data).name())
39  << "' metadata";
40  }
41  if (assns.size() > 0) {
42  out << " contains " << assns.size() << " relations";
43  }
44  else {
45  out << " is empty";
46  }
47  } // DumpAssociationsIntro<Data>()
size_type size() const
Definition: Assns.h:447
template<std::size_t Lead, typename... Iterables>
auto util::enumerate ( Iterables &&...  iterables)

Range-for loop helper tracking the number of iteration.

Template Parameters
Leadindex of the parameter driving the start and end of the loop
Iterablestype of objects to be iterated together
Parameters
iterablesall iterable objects to be iterated together
Returns
an object suitable for range-for loop

In the range-for loop, at each iteration this object yields a tuple of values, each of the type returned by dereferencing begin(iterable). For example:

constexpr std::size_t N = 4;
std::array<int, N> twice;
std::vector<double> thrice(N + 1);
for (auto&& [i, a, b]: util::enumerate(twice, thrice)) {
a = 2 * i;
b = 3.0 * i;
} // for

In this example, N iterations will be run because that is the size of the first iterable given to enumerate. If a different leading iterable is needed, that has to be specified as an argument. The following loop is completely equivalent to the former one:

for (auto&& [i, b, a]: util::enumerate<1U>(thrice, twice)) {
a = 2 * i;
b = 3.0 * i;
} // for

(the index is zero-based, so 1U refers to the second argument).

Definition at line 69 of file enumerate.h.

References infinite_counter().

Referenced by makeValueIndex().

70  {
71  return zip<Lead + 1>
72  (infinite_counter(), std::forward<Iterables>(iterables)...);
73  }
auto infinite_counter(T begin=T{})
Version of util::counter() starting at begin and never ending.
Definition: counter.h:291
template<typename... Iterables>
auto util::enumerate ( Iterables &&...  iterables)

This version of enumerate implicitly uses the first iterable as lead.

Definition at line 77 of file enumerate.h.

78  { return enumerate<0U>(std::forward<Iterables>(iterables)...); }
template<typename Range , typename Pred >
auto util::filterRangeFor ( Range &&  range,
Pred &&  pred 
) -> decltype(auto)

Provides iteration only through elements passing a condition.

Template Parameters
Rangethe data to be iterated
Predthe type of the predicate to be fulfilled
Parameters
rangethe data to be iterated through
predthe predicate to be tested
Returns
an object suitable to be used in a range-for loop

This adapter makes the range for loop iterate only through the elements of range which fulfil the predicate pred.

This example will print: "0 3 6 9 ":

std::vector<int> data = { 0, 1, 2, 3, 4, 5, 6 ,7, 8, 9 };
for (int v: util::filterRangeFor(data, [](int v){ return v % 3 == 0; })) {
std::cout << v << " ";
} // for
std::cout << std::endl;

Note that pred may be copied (range will not be).

Requirements

  • Range is an object which can itself go through a range-for:

    for (auto&& v: range);

    is valid

  • Pred is a copiable unary function type, whose single argument can be converted from the value type of Range, and whose return value can be converted into a bool vaule

Definition at line 137 of file filterRangeFor.h.

Referenced by proxy::TrackCollectionProxyElement< CollProxy >::selectPoints().

138  {
139  return details::FilterRangeForStruct<Range, Pred>
140  (std::forward<Range>(range), std::forward<Pred>(pred));
141  }
template<class T , class U >
std::vector< const U * > util::FindUNotAssociatedToT ( art::Handle< U >  b,
art::Event const &  evt,
std::string const &  label 
)
inline

Definition at line 892 of file AssociationUtil.h.

References fa(), and art::Ptr< T >::get().

Referenced by CreateAssn().

895 {
896  // Do a FindOne for type T for each object of type U
897  // If the FindOne returns an invalid maybe ref, add the pointer
898  // of object type U to the return vector
899 
900  std::vector<const U*> notAssociated;
901 
902  art::FindOne<T> const fa(b, evt, label);
903 
904  for(size_t u = 0; u < b->size(); ++u){
905  cet::maybe_ref<T const> t(fa.at(u));
906  if( !t.isValid() ){
907  art::Ptr<U> ptr(b, u);
908  notAssociated.push_back(ptr.get());
909  }
910  }
911 
912  return notAssociated;
913 }
TFile fa("Li7.root")
TCEvent evt
Definition: DataStructs.cxx:7
Definition: fwd.h:29
template<class T , class U >
std::vector< art::Ptr< U > > util::FindUNotAssociatedToTP ( art::Handle< U >  b,
art::Event const &  evt,
std::string const &  label 
)
inline

Definition at line 918 of file AssociationUtil.h.

References fa().

Referenced by CreateAssn().

921 {
922  // Do a FindOneP for type T for each object of type U
923  // If the FindOne returns an invalid maybe ref, add the pointer
924  // of object type U to the return vector
925 
926  std::vector< art::Ptr<U> > notAssociated;
927 
928  art::FindOneP<T> const fa(b, evt, label);
929 
930  for(size_t u = 0; u < b->size(); ++u){
931  cet::maybe_ref<T const> t(fa.at(u));
932  if( !t.isValid() ){
933  notAssociated.emplace_back(b, u);
934  }
935  }
936 
937  return notAssociated;
938 }
TFile fa("Li7.root")
TCEvent evt
Definition: DataStructs.cxx:7
template<class A , class F >
void util::for_each_associated_group ( A const &  assns,
F &  func 
)

Helper functions to access associations in order.

Template Parameters
Atype of association being read
Ftype of functor to be called on each associated group
Parameters
assnsthe association being read
funcfunctor to be called on each associated group
See also
associated_groups() art::for_each_group()
Deprecated:
Moved into canvas: art::for_each_group().

Definition at line 49 of file ForEachAssociatedGroup.h.

References art::for_each_group().

50  { art::for_each_group(assns, func); }
void for_each_group(art::Assns< A, B, D > const &assns, F func)
Helper functions to access associations in order.
template<class T , class U >
std::vector< std::vector< size_t > > util::GetAssociatedVectorManyI ( art::Handle< art::Assns< T, U > >  h,
art::Handle< std::vector< T > >  index_p 
)
inline

Definition at line 966 of file AssociationUtil.h.

Referenced by microboone::CosmicRemovalAna::analyze(), CreateAssn(), cosmic::BeamFlashTrackMatchTagger::produce(), and calo::TrackCalorimetry::produce().

968 {
969  std::vector< std::vector<size_t> > associated_indices(index_p->size());
970  for(auto const& pair : *h)
971  associated_indices.at(pair.first.key()).push_back(pair.second.key());
972  return associated_indices;
973 }
template<class T , class U >
std::vector< std::vector< const U * > > util::GetAssociatedVectorManyP ( art::Handle< art::Assns< T, U > >  h,
art::Handle< std::vector< T > >  index_p 
)
inline

Definition at line 977 of file AssociationUtil.h.

Referenced by CreateAssn().

979 {
980  std::vector< std::vector<const U*> > associated_pointers(index_p->size());
981  for(auto const& pair : *h)
982  associated_pointers.at(pair.first.key()).push_back( &(*(pair.second)) );
983  return associated_pointers;
984 }
template<class T , class U >
std::vector< size_t > util::GetAssociatedVectorOneI ( art::Handle< art::Assns< T, U > >  h,
art::Handle< std::vector< T > >  index_p 
)
inline

Definition at line 944 of file AssociationUtil.h.

Referenced by CreateAssn().

946 {
947  std::vector<size_t> associated_index(index_p->size());
948  for(auto const& pair : *h)
949  associated_index.at(pair.first.key()) = pair.second.key();
950  return associated_index;
951 }
template<class T , class U >
std::vector< const U * > util::GetAssociatedVectorOneP ( art::Handle< art::Assns< T, U > >  h,
art::Handle< std::vector< T > >  index_p 
)
inline

Definition at line 955 of file AssociationUtil.h.

Referenced by microboone::CosmicRemovalAna::analyze(), and CreateAssn().

957 {
958  std::vector<const U*> associated_pointer(index_p->size());
959  for(auto const& pair : *h)
960  associated_pointer.at(pair.first.key()) = &(*(pair.second));
961  return associated_pointer;
962 }
template<typename Groups >
auto util::groupByIndex ( Groups &&  groups,
std::size_t  index 
) -> decltype(auto)

Returns the group within groups with the specified index.

Template Parameters
Groupsthe type of collection of groups
Parameters
groupsthe collection of all groups
indexthe index of the group to be accessed
Returns
the group with specified index (may be a reference)
See also
associated_groups()

The groups argument is expected to be the one returned by associated_groups.

Definition at line 180 of file ForEachAssociatedGroup.h.

Referenced by TrackProducerFromPFParticle::produce().

181  { return *(std::next(groups.begin(), index)); }
template<typename T = std::size_t>
auto util::infinite_counter ( begin = T{})

Version of util::counter() starting at begin and never ending.

Template Parameters
Ttype of counter value
Parameters
beginthe count to start from (default-constructed, usually some form of 0, by default)
Returns
a control object for range-for loop

An example of usage:

std::vector<unsigned char> data;
for (auto ch: util::infinite_counter<unsigned char>()) {
if (data.size() >= 512U) break;
data.push_back(ch);
}

This loop runs through the full range of a character (8 bits, supposedly) twice before being broken.

Definition at line 291 of file counter.h.

References util::count_iterator< T >::count_iterator(), and span().

Referenced by counter(), and enumerate().

292 {
293  return util::span
294  (count_iterator(begin), details::infinite_endcount_iterator<T>());
295 } // util::infinite_counter()
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:67
template<typename Cont , typename Adaptor >
auto util::make_adapted_const_span ( Cont &  cont,
Adaptor &&  adaptor 
)

Creates constant iteration span from specified collection via an adaptor.

Definition at line 269 of file span.h.

References util::span_base::get_cbegin(), util::span_base::get_cend(), and make_adapted_span().

270  {
271  return make_adapted_span(
272  span_base::get_cbegin(cont), span_base::get_cend(cont),
273  std::forward<Adaptor>(adaptor)
274  );
275  }
auto make_adapted_span(Cont &cont, Adaptor &&adaptor)
Creates a span from specified collection via an adaptor.
Definition: span.h:258
template<typename BIter , typename EIter , typename Adaptor >
auto util::make_adapted_span ( BIter  begin,
EIter  end,
Adaptor &&  adaptor 
)

Creates a span from specified iterators via an adaptor.

See also
make_adapted_span(Cont&, Adaptor&&)

Definition at line 223 of file span.h.

References span().

Referenced by make_adapted_const_span(), make_adapted_span(), and make_transformed_span().

224  { return util::span(adaptor(begin), adaptor(end)); }
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:72
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:67
template<typename Cont , typename Adaptor >
auto util::make_adapted_span ( Cont &  cont,
Adaptor &&  adaptor 
)

Creates a span from specified collection via an adaptor.

Parameters
contcollection to be iterated through
adapteriterator transformation to be applied on cont
Returns
a util::span object iterating via an adapter to cont
See also
make_adapted_span(BIter, EIter, Adaptor&&), make_adapted_const_span(Cont, Adaptor&&)

This interface is just a little help on using iterator adapters. Note that adapter transforms the iterators of cont, not its values. The adapter needs to be written aside and it's in general not trivial. An example of iterating through a collection of objects (actually, just float for simplicity) stored as unique pointers in a collection:

float accumulate(std::vector<std::unique_ptr<float>> const& v) {
using src_iterator = std::vector<std::unique_ptr<float>>::const_iterator;
float sum = 0.0F;
for (float v: util::make_adapted_span(v, boost::make_indirect_iterator<src_iterator>))
sum += v;
return sum;
} // accumulate()

This example shows the usage of util::make_adapted_span(). In the specific example, it would have been more explicit to use the constant counterpart, util::make_adapted_const_span(). The adaptor helper boost::make_indirect_iterator() is provided in boost/iterator/indirect_iterator.hpp.

Definition at line 258 of file span.h.

References util::span_base::get_begin(), util::span_base::get_end(), and make_adapted_span().

259  {
260  return make_adapted_span(
261  span_base::get_begin(cont), span_base::get_end(cont),
262  std::forward<Adaptor>(adaptor)
263  );
264  }
auto make_adapted_span(Cont &cont, Adaptor &&adaptor)
Creates a span from specified collection via an adaptor.
Definition: span.h:258
template<typename Cont >
auto util::make_const_span ( Cont &  cont)

Creates a span with constant iterator access from a container type.

Definition at line 206 of file span.h.

References util::span_base::get_cbegin(), and util::span_base::get_cend().

207  {
208  return span{ span_base::get_cbegin(cont), span_base::get_cend(cont) };
209  }
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
template<typename BIter , typename EIter >
auto util::make_span ( BIter  begin,
EIter  end 
)

Creates a span from specified iterators (can use constructor instead).

Definition at line 197 of file span.h.

References span().

197 { return util::span(begin, end); }
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:72
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:67
template<typename Cont >
auto util::make_span ( Cont &  cont)

Creates a span from a container type.

Definition at line 201 of file span.h.

References util::span_base::get_begin(), and util::span_base::get_end().

202  { return span{ span_base::get_begin(cont), span_base::get_end(cont) }; }
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
template<typename Cont , typename Op >
auto util::make_transformed_const_span ( Cont &  cont,
Op &&  op 
)

Creates constant iteration span from specified collection via a transformation op.

Definition at line 353 of file span.h.

References make_transformed_span().

354  { return make_transformed_span(std::as_const(cont), std::forward<Op>(op)); }
auto make_transformed_span(Cont &cont, Op &&op)
Creates a span from specified collection via an adaptor.
Definition: span.h:341
template<typename BIter , typename EIter , typename Op >
auto util::make_transformed_span ( BIter  begin,
EIter  end,
Op &&  op 
)

Creates a span from specified iterators via an adaptor.

See also
make_transformed_span(Cont&, Op&&)

Definition at line 294 of file span.h.

References make_adapted_span().

Referenced by util::details::map_values_impl< std::unordered_map< Key, Value, Args... > >::iterate(), make_transformed_const_span(), and make_transformed_span().

295  {
296  auto adaptor
297  = [&op](auto iter){ return boost::make_transform_iterator(iter, op); };
298  return util::make_adapted_span(begin, end, adaptor);
299  }
auto make_adapted_span(BIter begin, EIter end, Adaptor &&adaptor)
Definition: span.h:223
decltype(auto) constexpr end(T &&obj)
ADL-aware version of std::end.
Definition: StdUtils.h:72
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:67
template<typename Cont , typename Op >
auto util::make_transformed_span ( Cont &  cont,
Op &&  op 
)

Creates a span from specified collection via an adaptor.

Parameters
contcollection to be iterated through
adapteriterator transformation to be applied on cont
Returns
a util::span object iterating via an adapter to cont
See also
make_transformed_span(BIter, EIter, Op&&), make_transformed_const_span(Cont, Op&&), make_adapted_span(),

This function transforms as directed by the unary operation op the result of each iteration cycle, so that instead of cont[i], a op(cont[i]) is assigned to the iteration control variable. An example of iterating through a collection of objects (actually, just float for simplicity) stored as unique pointers in a collection:

float accumulate(std::vector<std::unique_ptr<float>> const& v) {
float sum = 0.0F;
for (float v: util::make_transformed_span(v, [](auto& ptr){ return *ptr; }))
sum += v;
return sum;
} // accumulate()

This example shows the usage of util::make_transformed_span(). In the specific example, it would have been more explicit to use the constant counterpart, util::make_transformed_const_span(). Note that in the example the dereference result is copied into v. For have it by reference, the operation op must be properly written:

void scale(std::vector<std::unique_ptr<float>>& v, float factor) {
for (float& v: util::make_transformed_span(v, [](auto& ptr) -> float& { return *ptr; }))
v *= factor;
} // scale()

Definition at line 341 of file span.h.

References util::span_base::get_begin(), util::span_base::get_end(), and make_transformed_span().

342  {
343  return make_transformed_span(
344  span_base::get_begin(cont), span_base::get_end(cont),
345  std::forward<Op>(op)
346  );
347  }
auto make_transformed_span(Cont &cont, Op &&op)
Creates a span from specified collection via an adaptor.
Definition: span.h:341
template<typename Coll , typename KeyOf >
std::vector<size_t> util::MakeIndex ( Coll const &  data,
KeyOf  key_of = KeyOf() 
)

Creates a map of indices from an existing collection.

Template Parameters
Colltype of the collection
KeyOftype of the extractor of the key
Parameters
datathe data collection
key_ofinstance of a functor extracting a key value from a datum
Returns
a vector with indices corresponding to the data keys

This function maps the index of the items in data to an integral key extracted from each item. For example, if the items are wires and the key_of function extracts their channel ID, the resulting vector will contain for each channel ID the index in data of the wire with that channel ID.

The key is converted into a unsigned integer (size_t). If multiple items have the same key, the outcome for that key is undefined. If no items has a specific key, the index of that key is assigned as

, i.e. an index larger than the size of the original data collection.

The returned vector is big enough to accommodate indices corresponding to the keys of all the items in data. It may contain "holes" (that is, some keys that have no corresponding items have a

value). The memory allocated for the vector may be larger than necessary (if that is a problem, std::vector::shrink_to_fit() can be used, but it may create more problems than it solves).

Definition at line 43 of file MakeIndex.h.

References max.

Referenced by recob::HitCollectionAssociator::prepare_associations().

43  {
44 
45  // we start the index with the best guess that all the items will have
46  // a unique key and they are contiguous:
47  // the index would have the same size as the data
48  std::vector<size_t> Index(data.size(), std::numeric_limits<size_t>::max());
49 
50  size_t min_size = 0; // minimum size needed to hold all keys
51 
52  size_t iDatum = 0;
53  for (auto const& datum: data) {
54  size_t key = size_t(key_of(datum));
55  if (key >= min_size) min_size = key + 1;
56  if (Index.size() <= key) {
57  // make room for the entry: double the size
58  Index.resize(
59  std::max(key + 1, Index.size() * 2),
61  );
62  } // if expand index
63  Index[key] = iDatum;
64  ++iDatum;
65  } // for datum
66  Index.resize(min_size);
67  return Index;
68  } // MakeIndex()
Int_t max
Definition: plot.C:27
template<typename Coll , typename KeyOf >
auto util::MakeMap ( Coll const &  data,
KeyOf  key_of = KeyOf() 
) -> std::vector<decltype(key_of(*(data.begin()))) const*>

Creates a map of objects from an existing collection.

Template Parameters
Colltype of the collection
KeyOftype of the extractor of the key
Parameters
datathe data collection
key_ofinstance of a functor extracting a key value from a datum
Returns
a vector with pointers to data corresponding to their keys

This function maps the items in data to an integral key extracted from each of them. For example, if the items are wires and the key_of function extracts their channel ID, the resulting vector will contain for each channel ID the pointer to the wire with that channel ID.

The key is converted into a unsigned integer (size_t). If multiple items have the same key, the outcome for that key is undefined. If no items has a specific key, the index of that key is assigned a null pointer.

The returned vector is big enough to accommodate pointers corresponding to the keys of all the items in data. It may contain "holes" (that is, some keys that have no corresponding items have a null pointer value). The memory allocated for the vector may be larger than necessary (if that is a problem, std::vector::shrink_to_fit() can be used, but it may create more problems than it solves).

Definition at line 99 of file MakeIndex.h.

References max.

101  {
102  using Mapped_t = decltype(key_of(*(data.begin())));
103  using Ptr_t = Mapped_t const*;
104  using Map_t = std::vector<Ptr_t>;
105 
106  // we start the index with the best guess that all the items will have
107  // a unique key and they are contiguous:
108  // the index would have the same size as the data
109  Map_t Index(data.size(), nullptr);
110 
111  size_t min_size = 0; // minimum size needed to hold all keys
112 
113  for (auto const& datum: data) {
114  size_t key = size_t(key_of(datum));
115  if (key >= min_size) min_size = key + 1;
116  if (Index.size() <= key) {
117  // make room for the entry: double the size
118  Index.resize(std::max(key + 1, Index.size() * 2), nullptr);
119  } // if expand index
120  Index[key] = &datum;
121  } // for datum
122  Index.resize(min_size);
123  return Index;
124  } // MakeMap()
Int_t max
Definition: plot.C:27
template<typename Coll >
auto util::makePointerVector ( Coll &  coll)

Creates a STL vector with pointers to data from another collection.

Template Parameters
Colltype of collection of data
Parameters
colldata collection
Returns
a STL vector with pointers to coll data elements, with same order

Definition at line 198 of file SortByPointers.h.

References util::details::PointerVectorMaker< Coll, typename >::make().

Referenced by sim::DumpSimPhotons::DumpElement(), SortByPointers(), and SortUniquePointers().

unique_ptr< InputSource > make(ParameterSet const &conf, InputSourceDescription &desc)
template<typename... DIMS>
auto util::makeTensorIndices ( DIMS...  dims)

Instantiates a TensorIndices class with the specified dimensions.

Template Parameters
DIMStypes for each of the arguments
Parameters
dimssize of each of the dimensions
Returns
a TensorIndices object with properly initialised dimensions

The rank of the tensor is determined by the number of arguments; example:

will initialise a TensorIndices<2> (that's matrix indices), for a 3 x 4 (3 rows, 4 columns) disposition.

Definition at line 542 of file TensorIndices.h.

543  {
544  return TensorIndices<sizeof...(DIMS)>
545  { TensorIndicesBasicTypes::DimSize_t(dims)... };
546  }
template<typename Coll , typename Extractor >
decltype(auto) util::makeValueIndex ( Coll const &  coll,
Extractor  getter 
)

Returns a map of value to index.

Template Parameters
Colltype of container
Extractortype of value extraction function
Parameters
collcontainer to get the map of
getterfunction applied to each element to extract the value for map
Returns
a value-to-index associative container
Exceptions
std::runtime_errorif multiple elements yield the same value

The collection coll is navigated in sequence from begin() to end(), and a map is created where to each key, getter(coll[i]), the index i is associated. The value returned by getter() is copied into the key. Therefore that value needs to satisfy all the requirements of the key of the STL associative container std::map. Duplicate values will trigger an exception.

Requirements

The collection type Coll must have:

  • value_type type defining the content of the container
  • support begin() and end() free functions returning input iterators, that is support a ranged-for loop

Referenced by makeValueIndex(), and SortUniquePointers().

template<typename Coll >
auto util::makeValueIndex ( Coll const &  coll)

Definition at line 61 of file makeValueIndex.h.

References enumerate(), makeValueIndex(), and to_string().

62  { return makeValueIndex(coll, util::pre_std::identity()); }
auto makeValueIndex(Coll const &coll)
Transparent functor that returns its argument just as passed.
template<typename Cont , typename Mapping >
auto util::mapContainer ( Cont  cont,
Mapping  mapping 
)

Returns a container-like object mapping the content of cont.

Template Parameters
Conttype of the original container
Mappingtype of mapping object
Parameters
contthe container
mappingthe mapping to be applied
Returns
a util::MappedContainer object transparently applying the mapping

See util::MappedContainer for the details on the format of the mapping, the ownership of the container and the supported operations.

Definition at line 441 of file MappedContainer.h.

442  { return MappedContainer<Cont, Mapping>(cont, mapping); }
template<typename Coll , typename PtrColl >
void util::MoveFromPointers ( Coll &  dest,
PtrColl &  src 
)

Moves the content from a collection of pointers to one of data.

Template Parameters
Colltype of collection of data
PtrColltype of collection of pointers to data
Parameters
destcollection to be filled
srccollection with the pointers to data to be moved

The data pointed from each pointer in src is moved into dest. The destination collection is cleared first, and Coll must support both clear() and push_back()

Definition at line 61 of file SortByPointers.h.

References util::details::MoveFromPointersImpl< Coll, PtrColl >::move(), SortByPointers(), and SortUniquePointers().

Referenced by SortByPointers().

62  { details::MoveFromPointersImpl<Coll, PtrColl>::move(dest, src); }
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator!= ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Based on operator==.

Definition at line 513 of file VectorMap.h.

515  {
516  return !(__x == __y);
517  }
template<unsigned int RANK1, unsigned int RANK2, typename = std::enable_if_t<(RANK1 != RANK2), bool>>
bool util::operator!= ( TensorIndices< RANK1 > const &  a,
TensorIndices< RANK2 > const &  b 
)

Comparison operator with tensors of different rank.

Definition at line 524 of file TensorIndices.h.

Referenced by util::TensorIndices< DIMS >::operator!=().

525  { return true; }
template<typename Cont , typename Mapping , typename Container , typename Reference >
MappedContainer<Cont, Mapping>::template IteratorBase<Container, Reference> util::operator+ ( typename MappedContainer< Cont, Mapping >::template IteratorBase< Container, Reference >::difference_type  n,
typename MappedContainer< Cont, Mapping >::template IteratorBase< Container, Reference > const &  it 
)

Definition at line 703 of file MappedContainer.h.

References n.

707  { return it + n; }
Char_t n[5]
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator< ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Definition at line 501 of file VectorMap.h.

503  {
504  return std::lexicographical_compare(__x.sortedVectorMap.begin(),
505  __x.sortedVectorMap.end(),
506  __y.sortedVectorMap.begin(),
507  __y.sortedVectorMap.end(),
508  __x.valueCompare);
509  }
std::ostream& util::operator<< ( std::ostream &  out,
EventChangeTracker_t const &  trk 
)
inline

Definition at line 105 of file ChangeTrackers.h.

106  { out << std::string(trk); return out; }
std::ostream& util::operator<< ( std::ostream &  out,
DataProductChangeTracker_t const &  trk 
)
inline

Definition at line 206 of file ChangeTrackers.h.

207  { out << std::string(trk); return out; }
std::ostream& util::operator<< ( std::ostream &  out,
PlaneDataChangeTracker_t const &  trk 
)
inline

Definition at line 319 of file ChangeTrackers.h.

320  { out << std::string(trk); return out; }
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator<= ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Based on operator<.

Definition at line 529 of file VectorMap.h.

531  {
532  return !(__y < __x);
533  }
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator== ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Definition at line 494 of file VectorMap.h.

References util::VectorMap< _Key, _Tp, _Compare >::sortedVectorMap.

496  {
497  return __x.sortedVectorMap == __y.sortedVectorMap;
498  }
template<unsigned int RANK1, unsigned int RANK2, typename = std::enable_if_t<(RANK1 != RANK2), bool>>
bool util::operator== ( TensorIndices< RANK1 > const &  a,
TensorIndices< RANK2 > const &  b 
)

Comparison operator with tensors of different rank.

Definition at line 516 of file TensorIndices.h.

Referenced by util::TensorIndices< DIMS >::operator==().

517  { return false; }
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator> ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Based on operator<.

Definition at line 521 of file VectorMap.h.

523  {
524  return __y < __x;
525  }
template<typename _Key , typename _Tp , typename _Compare >
bool util::operator>= ( const VectorMap< _Key, _Tp, _Compare > &  __x,
const VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

Based on operator<.

Definition at line 537 of file VectorMap.h.

539  {
540  return !(__x < __y);
541  }
template<typename Range >
auto util::operator| ( Range &&  range,
RangeForWrapperTag   
) -> decltype(auto)

Transforms a range so that it can be used in a range-for loop.

Template Parameters
Rangethe type of range to be transformed
Parameters
rangethe range to be transformed
Returns
an equivalent range object to be used in a range-for loop

This is necessary only when the argument provides different types for the begin-of-range and end-of-range iterators. This is also superfluous for compilers adhering to C++ 2017 standard, which accepts iterators of different types by requirement. Example of usage:

Range data; // initialization
for (auto&& value: data | util::range_for) // ...

where data is supposed to gave begin and end iterators of different types.

Definition at line 456 of file RangeForWrapper.h.

References wrapRangeFor().

457  { return wrapRangeFor(std::forward<Range>(range)); }
auto wrapRangeFor(Range &&range) -> decltype(auto)
Wraps an object for use in a range-for loop.
template<typename T >
constexpr T util::RadiansToDegrees ( angle)
inline

Converts the argument angle from radians into degrees ( $ \pi \rightarrow 180 $)

Definition at line 88 of file PhysicalConstants.h.

Referenced by geo::OpDetGeo::ThetaZ(), and geo::WireGeo::ThetaZ().

88 { return angle / pi<T>() * 180; }
template<typename Coll , typename Sorter >
void util::SortByPointers ( Coll &  coll,
Sorter  sorter 
)

Applies sorting indirectly, minimizing data copy.

Template Parameters
Colltype of collection to be sorted
Sortertype of sorter
Parameters
collcollection to be sorted
sorterfunctor sorting a vector of pointers (makePointerVector())

The sorter functor can receive a reference to a vector as the one produced by makePointerVector(coll) (that is, a C++ STL vector of pointers to the value type of Coll), and sort it "in place". The container Comp must implement push_back() call in a std::vector fashion.

The algorithm is equivalent to the following:

  1. create a parallel vector of pointers to the data
  2. sort the data pointers (delegating to sorter)
  3. move the data, sorted, from the original collection to a new one
  4. replace the content of cont with the one from the sorted collection

Single elements are moved from the original collection to a new one.

The data elements of Coll must be moveable, as Coll itself must be.

Note
Use this algorithm only as a last resort, as there are usually better ways to sort collections than this one, which is not even particularly optimized.

Definition at line 204 of file SortByPointers.h.

References makePointerVector(), and MoveFromPointers().

Referenced by MoveFromPointers(), geo::GeometryCore::SortGeometry(), geo::AuxDetGeo::SortSubVolumes(), geo::CryostatGeo::SortSubVolumes(), and geo::PlaneGeo::SortWires().

204  {
205 
206  using coll_t = Coll;
207 
208  //
209  // create the collection of pointers to data
210  //
211  auto ptrs = makePointerVector(coll);
212 
213  //
214  // delegate the sorting by pointers
215  //
216  sorter(ptrs);
217 
218  //
219  // create a sorted collection moving the content from the original one
220  //
221  coll_t sorted;
222  MoveFromPointers(sorted, ptrs);
223 
224  //
225  // replace the old container with the new one
226  //
227  coll = std::move(sorted);
228 
229 } // util::SortByPointers()
auto makePointerVector(Coll &coll)
Creates a STL vector with pointers to data from another collection.
void MoveFromPointers(Coll &dest, PtrColl &src)
Moves the content from a collection of pointers to one of data.
template<typename Coll , typename Sorter >
void util::SortUniquePointers ( Coll &  coll,
Sorter &&  sorter 
)

Sorts a vector of unique pointers using a C pointer sorter.

Template Parameters
Colltype of collection to be sorted
Sortertype of sorter function
Parameters
collcollection to be sorted
sortersorting procedure

This adapter moves the unique pointers around to match a sorted version of source. This is an expensive procedure, implying the creation of a temporary vector and of additional supporting data: avoid it if at all possible.

Definition at line 234 of file SortByPointers.h.

References makePointerVector(), and makeValueIndex().

Referenced by MoveFromPointers().

234  {
235 
236  using Collection_t = Coll;
237  using UPtr_t = typename Collection_t::value_type;
238 
239  static_assert(util::is_unique_ptr_v<UPtr_t>);
240 
241  //
242  // create the collection of pointers to data
243  //
244  auto ptrs = makePointerVector(coll);
245 
246  // data pointer -> index
247  auto const ptrIndex = util::makeValueIndex(ptrs);
248 
249  //
250  // delegate the sorting by pointers
251  //
252  sorter(ptrs);
253 
254  //
255  // create a sorted collection moving the content from the original one
256  //
257  Collection_t sorted;
258  for (auto const& dataPtr: ptrs) {
259  std::size_t const originalIndex = ptrIndex.at(dataPtr);
260  sorted.emplace_back(std::move(coll[originalIndex]));
261  }
262 
263  //
264  // replace the old container with the new one
265  //
266  coll = std::move(sorted);
267 
268 } // util::SortUniquePointers()
auto makePointerVector(Coll &coll)
Creates a STL vector with pointers to data from another collection.
decltype(auto) makeValueIndex(Coll const &coll, Extractor getter)
Returns a map of value to index.
template<typename IterB , typename IterE , typename Adaptor >
util::span ( IterB &&  b,
IterE &&  e,
Adaptor &&  adaptor 
) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
template<typename _Key , typename _Tp , typename _Compare >
void util::swap ( VectorMap< _Key, _Tp, _Compare > &  __x,
VectorMap< _Key, _Tp, _Compare > &  __y 
)
inline

See VectorMap::swap().

Definition at line 545 of file VectorMap.h.

References util::VectorMap< _Key, _Tp, _Compare >::swap().

547  {
548  __x.swap(__y);
549  }
decltype(auto) util::takeAddress ( )

Returns a functor that returns the address of its argument.

See also
util::AddressTaker

Example:

std::vector<int*> ptrs(data.size());
std::transform
(data.begin(), data.end(), ptrs.begin(), util::takeAddress());

will fill the vector ptrs with pointers to the elements of data.

Why bother?

C++ already provides a tool to effectively take an address, std::addressof. The reason for takeAddress() is that std::addressof() is a function, with many overloads, and to use it in a STL algorithm the overload has to be resolved first. For example:

using addressof_t = int const*(*)(int const&);
std::transform(data.cbegin(), data.cend(), std::back_inserter(dataPtr),
((addressof_t) &std::addressof));

One important limit is that the type of the argument (in this case int const&) needs to be known or deduced in a quite precise way, in particular regarding constantness and referenceness. This is unconvenient and convoluted enough that one would rather create a new function, like:

auto takeAddress = [](auto&& ref){ return std::addressof(ref); };
std::vector<int const*> dataPtr;
std::transform(data.cbegin(), data.cend(), std::back_inserter(dataPtr),

This util::takeAddress() operates in a very similar way to the lambda in the last example.

Definition at line 86 of file operations.h.

86 { return AddressTaker(); }
template<typename Coll >
decltype(auto) util::values ( Coll &&  coll)

Range-for loop helper iterating across the values of the specified collection.

Template Parameters
Colltype of the collection to iterate through
Parameters
collthe collection to iterate through
Returns
an object suitable for range-for loop
See also
util::const_values()

This function is in most of cases a no-operation, returning the collection just as it was specified, to be iterated on directly. In case of mapping types, though, a different object is returned and the iteration will happen to the value type of the mapping instead than on the key-value pair.

std::map<int, float> data { { 1, 4.0F }, { 3, 12.0F }, { 2, 8.0F } };
std::vector<float> values;
for (float value: util::values(data))
values.push_back(value);

will result in values vector being of size 3 and with values { 4.0F, 8.0F, 12.0F } (the order is the one of iterating through a std::map).

Referenced by associated_groups(), associated_groups_with_left(), lar::sparse_vector< T >::datarange_t::begin(), lar::sparse_vector< T >::datarange_t::cbegin(), lar::sparse_vector< T >::datarange_t::cend(), util::flags::BitMask< Storage >::clear(), keras::LayerMaxPooling::compute_output(), lar::sparse_vector< T >::datarange_t::datarange_t(), lar::sparse_vector< T >::datarange_t::dump(), evdb::ParameterSetEdit::Edit(), lar::sparse_vector< T >::datarange_t::end(), lar::sparse_vector< T >::datarange_t::extend(), anab::FeatureVector< N >::FeatureVector(), cluster::BlurredClusteringAlg::FindClusters(), art::for_each_group(), art::for_each_group_with_left(), lar::sparse_vector< T >::datarange_t::get_const_iterator(), lar::util::MinMaxCollector< float >::MinMaxCollector(), lar::sparse_vector< T >::datarange_t::move_head(), util::flags::BitMask< Storage >::operator!=(), anab::FeatureVector< N >::operator=(), util::flags::BitMask< Storage >::operator==(), lar::sparse_vector< T >::datarange_t::operator[](), cluster::OverriddenClusterParamsAlg< AlgoBase >::OverrideParameter(), evdb::ParameterSetEditRow::ParameterSetEditRow(), evgen::SingleGen::printVecs(), lar_content::SupportVectorMachine::ReadSupportVector(), lar::sparse_vector< T >::datarange_t::resize(), anab::FeatureVector< N >::set(), anab::FVectorWriter< 4 >::setVector(), and geo::vect::transformCoords().

template<typename Range >
auto util::wrapRangeFor ( Range &&  range) -> decltype(auto)

Wraps an object for use in a range-for loop.

Template Parameters
Rangetype of range object (anything with begin() and end())
Parameters
rangeinstance of the range object to be wrapped

This is necessary only when the argument provides different types for the begin-of-range and end-of-range iterators. This is also superfluous for compilers adhering to C++ 2017 standard, which accepts iterators of different types by requirement. Example of usage:

Range data; // initialization
for (auto&& value: util::wrapRangeFor(data)) // ...

where data is supposed to gave begin and end iterators of different types.

Definition at line 424 of file RangeForWrapper.h.

Referenced by operator|().

425  {
426  return details::WrapRangeForDispatcher<Range>::wrap
427  (std::forward<Range>(range));
428  }
template<std::size_t Lead, typename... Iterables>
auto util::zip ( Iterables &&...  iterables)

Range-for loop helper iterating across many collections at the same time.

Template Parameters
Leadindex of the parameter driving the start and end of the loop
Iterablestype of objects to be iterated together
Parameters
iterablesall iterable objects to be iterated together
Returns
an object suitable for range-for loop
See also
util::enumerate()

In the range-for loop, at each iteration this object yields a tuple of values, each of the type returned by dereferencing begin(iterable). For example:

constexpr std::size_t N = 4;
std::array<int, N> twice;
std::vector<double> thrice(N + 1);
unsigned int i = 0;
for (auto&& [ a, b]: util::zip(twice, thrice)) {
a = 2 * i;
b = 3.0 * i;
++i;
} // for

In this example, N iterations will be run because that is the size of the first iterable given to enumerate. If a different leading iterable is needed, that has to be specified as an argument. The following loop is completely equivalent to the former one:

unsigned int i = 0;
for (auto&& [ b, a]: util::zip<1U>(thrice, twice)) {
a = 2 * i;
b = 3.0 * i;
++i;
} // for

(the index is zero-based, so 1U refers to the second argument).

Range-for loop helper iterating across many collections at the same time.

Definition at line 295 of file zip.h.

References span().

295  {
296 
297  return util::span(
298  details::make_zip_begin_iterator<Lead>(iterables...),
299  details::make_zip_end_iterator<Lead>(iterables...)
300  );
301 
302 } // util::zip()
span(IterB &&b, IterE &&e, Adaptor &&adaptor) -> span< decltype(adaptor(std::forward< IterB >(b))), decltype(adaptor(std::forward< IterE >(e))) >
template<typename... Iterables>
auto util::zip ( Iterables &&...  iterables)

Version of zip() with first iterator implicitly leading the iteration.

Range-for loop helper iterating across many collections at the same time.

Definition at line 80 of file zip.h.

References span().

81  { return zip<0U>(std::forward<Iterables>(iterables)...); }

Variable Documentation

constexpr double util::kc = 29.9792458

Speed of light in vacuum in LArSoft units [cm/ns].

Definition at line 59 of file PhysicalConstants.h.

Referenced by genf::GFEnergyLossBrems::energyLoss(), and genf::GFMaterialEffects::energyLossBrems().

constexpr double util::kCentimeterToMeter = 1./kMeterToCentimeter

Definition at line 64 of file PhysicalConstants.h.

constexpr double util::keVToMeV = 1.e-6

1e6 eV = 1 MeV

Definition at line 68 of file PhysicalConstants.h.

const double util::kINVALID_DOUBLE = std::numeric_limits<Double_t>::max()

Definition at line 28 of file GeometryUtilities.h.

Referenced by util::GeometryUtilities::Get3DaxisN().

constexpr double util::kKilometerToMeter = 1./kMeterToKilometer

Definition at line 66 of file PhysicalConstants.h.

constexpr double util::kMeterToCentimeter = 1.e2

1 m = 100 cm

Definition at line 63 of file PhysicalConstants.h.

constexpr double util::kMeterToKilometer = 1.e-3

1000 m = 1 km

Definition at line 65 of file PhysicalConstants.h.

constexpr double util::kMeVToeV = 1./keVToMeV

Definition at line 69 of file PhysicalConstants.h.

constexpr double util::kModBoxA = 0.930
constexpr double util::kModBoxB = 0.212
constexpr double util::kRecombk = 0.0486
constexpr double util::quietCompiler = kBogusD*kBogusI*kBogusF*kRecombA*kRecombk*kGeVToElectrons

Definition at line 75 of file PhysicalConstants.h.

constexpr RangeForWrapperTag util::range_for

Constant to be used with operator|(Range&&, details::RangeForWrapperTag).

Definition at line 436 of file RangeForWrapper.h.

Referenced by associated_groups(), and associated_groups_with_left().

const float util::SQRT_TWO_PI = 2.506628

Definition at line 18 of file GaussianEliminationAlg.h.