util Namespace Reference

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

Namespaces
	details
	fhicl
	flags
	Classes and functions to manage bit masks and flags.
	manip
	pre_std
	quantities
	Types of variables with a unit.
	ROOT

Classes
class	Binner
	Helper class binning values in a range. More...
class	FastAndPoorGauss
	Translates a number u uniformly distributed between 0 and 1 into a Gaussian distributed one z. More...
class	GaussianTransformer
	Transforms a standard normal number into one on a different normal distribution. More...
class	UniformSequence
	Samples the interval [ 0, 1 ] in sequence, cyclically. More...
class	NonRandomCounter
	Fast random engine which returns sequential numbers. More...
class	RandFastGauss
	Normal distribution focussing on speed. More...
class	SampledFunction
	Precomputed discrete sampling of a given function. More...
struct	identity
	Substitute for C++20 std::identity. More...
class	RegexDataProductSelector
	Matches products by regex on process, module label and instance name. More...
struct	ArtHandleTrackerInterface
	Interface to facilitate the use of util::ArtHandleTracker specializations. More...
class	ArtHandleTrackerManager
	Manages handle trackers for an easy call of removeCachedProduct(). More...
class	LocalArtHandleTrackerManager
	Variant of util::ArtHandleTrackerManager in local scope. More...
struct	addIndent
	Stream modifier that makes it "indented". More...
struct	PathPointInfo_t
	Data returned by findMiddlePointInPath(). More...
class	NormalDistribution
struct	collection_value_type
	Trait of value contained in the template 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_reference_type
	Trait of a type that can be used to reference the collection Coll. More...
struct	collection_from_reference_type
	Trait with the type of collection referenced by collRef. More...
class	count_iterator
	An iterator dereferencing to a counter value. More...
struct	self_type
	Trait returning the very same type as in the template argument. 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	find_next_type
	Trait: index of the first occurrence of T among the specified Types, starting from the one with index StartFrom. More...
struct	is_any_of
	Trait: whether T is among the specified Types. 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_character_type
	Trait: whether type T is a character type. More...
struct	is_string_type
	Trait: whether type T is a character string type. More...
struct	is_basic_string_type
	Trait: whether type T is a STL string type. More...
struct	is_basic_string_view_type
	Trait: whether type T is a std::string_view type. More...
struct	with_const_as
	Trait with type Base, plus the constantness as in Key. More...
struct	strip_referenceness_type
	Trait with type T stripped of all known reference types. More...
struct	reference_addresser
	Functor applying the proper referenced_address() function. More...
struct	lvalue_reference_into_wrapper_type
	Trait with type T into std::reference_wrapper if reference. More...
struct	is_STLarray< std::array< T, N > >
struct	AddressTaker
	Functor returning the address in memory of the operand. More...
struct	Dereferencer
	Functor dereferencing the operand. More...
struct	KeepByPositionFilterTag
	Tag for filters. More...
class	PositionInVolumeFilter
	Use to keep particles with at least part of trajectory in a volume. More...
struct	span_base
	Non-templated base class for span. More...
struct	span
	Simple class with a begin and an end. More...
class	UBDaqID
class	DatabaseUtil
class	GeometryUtilities
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...
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	LArFFT
class	LArFFTW
class	LArFFTWPlan
class	PxHitConverter
class	PxPoint
class	PxHit
class	PxLine
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	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...
class	SignalShaper
class	SignalShaping
struct	TensorIndicesBasicTypes
	Types for TensorIndices class. More...
class	TensorIndices
	Converts a tensor element specification into a linear index. More...
class	TensorIndices< 1U >
struct	count_type_in_tuple
	Holds whether the Target type is element of the specified std::tuple. More...
struct	extract_to_tuple_type
	Returns type TargetClass<U...> from a SrcTuple<T...>. More...
struct	index_of_extracted_type
	Returns the index of the element in Tuple with the specified type. More...
struct	has_extracted_type
	Trait holding whether an element in Tuple type contains Target. More...
struct	has_duplicate_extracted_types
	Traits holding whether elements of Tuple have duplicate types. More...
struct	count_extracted_types
	Counts the elements of a tuple-like type containing a Target type. More...
struct	TaggedType
	A type with a specified tag. More...
struct	add_tag
struct	remove_tag
	Trait holding the type contained in a TaggedType (or the type itself). More...
struct	remove_tag< TaggedType< T, Tag > >
struct	TagN
	Tag class parametrized by a sequence of numbers. More...
struct	TagExtractor
	Extracts the tag from a type. More...
struct	count_type_in_tuple< Target, std::tuple< T...> >
class	UtilException
class	LArPropTest
struct	MappedContainerBase
	Non-template base class for MappedContainer. More...
class	MappedContainer
	A meta-container providing transparent mapping on top of another. More...
class	MultipleChoiceSelectionBase
	Base class of util::MultipleChoiceSelection with basics independent of the option type. More...
class	MultipleChoiceSelection
	Helper to select one among multiple choices via strings. More...
class	LazyVector
	A contiguous data container expanded on write. More...
class	SumSecondFunction
class	VectorMap
class	EventChangeTracker_t
	Detects the presence of a new event. More...
class	DataProductChangeTracker_t
	Detects the presence of a new event or data product. More...
class	PlaneDataChangeTracker_t
	Detects the presence of a new event, data product or wire plane. More...
class	GaussianEliminationAlg
class	FileSpec
class	FileCatalogMetadataSBN
class	MetadataSBN
class	SignalShapingServiceSBND

Typedefs
template<typename Handle >
using	ArtHandleData_t = typename Handle::element_type::value_type
	Type of data in a art handle to vector data product. More...
template<typename T >
using	DataProductPointerMap_t = details::DataProductPointerMap_t< T >
	Type of map for data product pointers to art pointers. More...
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_t >	UBChannelMap_t
typedef std::map < UBLArSoftCh_t, UBDaqID >	UBChannelReverseMap_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	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 T >
std::ostream &	operator<< (std::ostream &, Binner< T > const &)
template<typename Event >
art::InputTag	inputTagOf (Event const &event, art::ProductID const &productID)
	Reads and returns the input tag of the producer of productID. More...
template<typename Event , typename Handle >
std::enable_if_t < std::is_void_v< std::void_t < typename Handle::HandleTag > >, art::InputTag >	inputTagOf (Event const &event, Handle const &handle)
	Reads and returns the input tag of the product with the specified handle. More...
template<typename Event , typename T >
art::InputTag	inputTagOf (Event const &event, art::Ptr< T > const &ptr)
	Reads and returns the input tag of the product ptr points to. More...
template<typename Coll , typename KeyOp , typename CmpOp , typename RefOp , typename KeySortOp >
auto	clusterBy (Coll const &objs, KeyOp keyFunc, CmpOp sameGroup, RefOp objRef, KeySortOp keySort)
	Performs a simple clustering. More...
template<typename Coll , typename KeyOp , typename CmpOp , typename KeySortOp >
auto	clusterBy (Coll const &objs, KeyOp keyFunc, CmpOp sameGroup, KeySortOp keySort)
	A version of clusterBy() storing a copy of each object as "reference". More...
template<typename BIter , typename EIter , typename Key , typename Sorter = std::less<void>>
auto	sortBy (BIter begin, EIter end, Key key, Sorter sorter={})
	Returns a vectors to pointers to coll elements, sorted by key. More...
template<typename Coll , typename Key , typename Sorter = std::less<void>>
auto	sortCollBy (Coll &coll, Key key, Sorter sorter={})
	Returns a vectors to pointers to coll elements, sorted by key. More...
template<typename Handle >
DataProductPointerMap_t < ArtHandleData_t< Handle > >	mapDataProductPointers (art::Event const &event, Handle const &handle)
	Creates a map from address of data product element to art pointer to it. More...
std::map < fhicl::ParameterSetID, fhicl::ParameterSet >	readConfigurationFromArtFile (TFile &file)
	Reads and returns the art configuration stored in sourceDir. More...
template<typename Principal >
std::map< std::string, fhicl::ParameterSet >	readConfigurationFromArtPrincipal (Principal const &principal)
	Reads and returns the complete art configuration in the principal. More...
template<typename Stream >
auto	operator<< (Stream &&out, addIndent &&adder)
	Helper function for addIndent (. More...
template<typename FIter , typename LIter >
PathPointInfo_t< FIter >	findMiddlePointInPath (FIter itFirst, LIter itLast, double relTarget=0.5)
	Returns information to identify the middle of the specified path. More...
template<typename FIter , typename LIter >
auto	pathMiddlePoint (FIter itFirst, LIter itLast, double relTarget=0.5)
	Returns the geometric point in the middle of the specified path. More...
template<typename BIter , typename EIter >
double	pathLength (BIter begin, EIter end)
	Returns the total length of the specified path. More...
template<typename BIter , typename EIter >
std::vector< double >	partialPathLengths (BIter begin, EIter end)
	Returns a sequences of partial lengths for the specified path. More...
template<typename Iter , typename SideFunc >
std::pair< Iter, Iter >	findCrossingSegment (Iter begin, Iter end, SideFunc sideOf)
	Returns a path segment with ends on different sides than path ends. More...
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 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 ( ) 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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , class U >
bool	CreateAssn (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 T , typename U , typename Iter >
bool	CreateAssn (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 Producer , typename... Args>
std::enable_if_t < std::is_base_of_v < art::EDProducer, Producer > , bool >	CreateAssn (Producer const &, Args &&...args)
template<typename Producer , typename... Args>
std::enable_if_t < std::is_base_of_v < art::EDProducer, Producer > , bool >	CreateAssnD (Producer const &, Args &&...args)
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)
def	root_env
def	wait
def	write
def	with_input_args
def	filespec
def	get_tobject
def	with_text_args
def	draw_text
def	with_display_args
def	with_io_args
def	with_graphsize_args
def	with_histosize_args
def	resize_graph
def	resize_histo
def	int_pair
def	with_histostyle_args
def	optstat
def	style
def	fillcolors
def	namecolors
def	comma_separated
def	draw_potlabel
def	draw_sbnlabel
def	draw_iclabel
def	draw_sbndlabel
def	legend_position
def	histo_list
def	validate_hists
double	ECCQE (const TVector3 &l_momentum, double l_energy)
double	ContainedLength (const TVector3 &v0, const TVector3 &v1, const std::vector< geo::BoxBoundedGeo > &boxes)
double	MCParticleLength (const simb::MCParticle &particle)
double	MCParticleContainedLength (const simb::MCParticle &particle, const std::vector< geo::BoxBoundedGeo > &active_volumes)
template<typename Stream >
auto	makeIndented (Stream &&out, std::string indent, std::string firstIndent)
	Creates an indented stream wrapper. More...
template<typename Stream >
auto	makeIndented (Stream &&out, std::string const &indent)
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...
Transformed iterations
template<std::size_t... Indices, typename Coll >
decltype(auto)	get_elements (Coll &&coll)
	Range-for loop helper iterating across some of the element of each value in the specified collection. More...
template<std::size_t... Indices, typename Coll >
decltype(auto)	get_const_elements (Coll &&coll)
	Range-for loop helper iterating across the constant values of the specified collection. More...
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...
template<typename T >
void	staticDumpClassName ()
	Helper to determine the type of a variable at compilation time. More...
template<typename T >
void	staticDumpClassName (T)
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...
template<std::size_t I, typename T >
decltype(auto)	get (T &&obj)
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 T , typename U , typename D >
bool	CreateAssnD (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 T , typename U , typename D >
bool	CreateAssnD (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)
Simple mathematical functions
template<typename T >
constexpr auto	abs (T v)
	Returns the absolute value of the argument. More...
template<class T >
T	sqr (T x)
	More efficient square function than pow(x,2) More...
template<class T >
T	cube (T x)
	More efficient cube function than pow(x,3) More...
template<class T >
T	ipow (T x, unsigned int n)
	More efficient exponentiation function than pow(x,n) for small n. More...
double	pythag (double x, double y)
	2D Euclidean distance More...
double	pythag (double x, double y, double z)
	3D Euclidean distance More...
Create and query associations
see https://cdcvs.fnal.gov/redmine/projects/art/wiki/Inter-Product_References for information about using art::Assns
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to 1 association between a new product and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t begin_indx, size_t end_indx, std::string const &instance=std::string())
	Create a 1 to 1 association between each of a series of new products and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn)
	Create a 1 to 1 association between two products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::PtrVector< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a PtrVector already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Ptr< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn)
	Create a 1 to many association between products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a vector of Ptrs already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to many association between new products. More...
template<class T , class U >
static bool	CreateAssn (art::EDProducer const &prod, art::Event &evt, art::Assns< T, U > &assn, std::vector< T > &a, std::vector< U > &b, size_t indxb=UINT_MAX, size_t indxa=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to 1 between new products. More...
template<class T , class U >
static std::vector< const U * >	FindUNotAssociatedToT (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static std::vector< art::Ptr< U > >	FindUNotAssociatedToTP (art::Handle< U > b, art::Event const &evt, std::string const &label)
	Return all objects of type U that are not associated to objects of type T. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to 1 association between a new product and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t begin_indx, size_t end_indx, std::string const &instance=std::string())
	Create a 1 to 1 association between each of a series of new products and one already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Ptr< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn)
	Create a 1 to 1 association between two products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, art::PtrVector< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a PtrVector already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Ptr< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn)
	Create a 1 to many association between products already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, std::vector< art::Ptr< U > > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
	Create a 1 to many association between a new product and a vector of Ptrs already in the event. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, std::vector< T > &a, std::vector< U > &b, art::Assns< T, U > &assn, size_t startU, size_t endU, size_t indx=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to many association between new products. More...
template<class T , class U >
static bool	CreateAssn (art::EDFilter const &prod, art::Event &evt, art::Assns< T, U > &assn, std::vector< T > &a, std::vector< U > &b, size_t indxb=UINT_MAX, size_t indxa=UINT_MAX, std::string const &instancea=std::string(), std::string const &instanceb=std::string())
	Create a 1 to 1 between new products. More...

Variables
template<typename XType , typename Func , typename UntilFunc >
	SampledFunction< XType, XType >
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...
template<typename T >
constexpr bool	is_basic_string_type_v = is_basic_string_type<T>::value
template<typename T >
constexpr bool	is_basic_string_view_type_v = is_basic_string_view_type<T>::value
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
constexpr 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 is given by the voxel energy deposition, but have to convert it to MeV/cm from GeV/voxel width electric field: in kV/cm 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 is given by the voxel energy deposition, but have to convert it to MeV/cm from GeV/voxel width electric field: 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 Handle >

using util::ArtHandleData_t = typedef typename Handle::element_type::value_type

Type of data in a art handle to vector data product.

Definition at line 42 of file DataProductPointerMap.h.

template<typename T >

using util::DataProductPointerMap_t = typedef details::DataProductPointerMap_t<T>

Type of map for data product pointers to art pointers.

Definition at line 46 of file DataProductPointerMap.h.

template<typename DATUM >

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

Container allowing 2D indexing.

Template Parameters

DATUM

type 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.

using util::GridContainer2DIndices = typedef GridContainerIndicesBase2D<>

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

DATUM

type 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.

using util::GridContainer3DIndices = typedef GridContainerIndicesBase3D<>

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

Definition at line 184 of file GridContainerIndices.h.

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

Type for indexing a 2D-tensor (matrix)

Definition at line 551 of file TensorIndices.h.

typedef std::map< UBDaqID, UBLArSoftCh_t > util::UBChannelMap_t

Definition at line 48 of file DatabaseUtil.h.

typedef std::map< UBLArSoftCh_t, UBDaqID > util::UBChannelReverseMap_t

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

(

T

v

)

Returns the absolute value of the argument.

Template Parameters

T	type of the argument

Parameters

v	value 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.

{ 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

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

Parameters

a	the first value
b	the second value

Returns

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

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

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

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

Requirements:

• A and B must be the same type

Definition at line 43 of file NumericUtils.h.

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

template<class A >

auto util::associated_groups

(

A const &

assns

)

Helper functions to access associations in order.

Template Parameters

A	type of association being read

Parameters

assns

the 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.;
  for (art::Ptr<recob::Hit> const& hit: hits)
    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.

                                          {
     return assns |
            ranges::views::all |
            ranges::views::group_by([](auto a1, auto a2) { return a1.first == a2.first;}) |
            ranges::views::transform([] (auto pairs) {return pairs | ranges::views::values | util::range_for;}) |
            util::range_for
            ;
  } // associated_groups()

template<class A >

auto util::associated_groups_with_left

(

A const &

assns

)

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

Template Parameters

A	type of association being read

Parameters

assns

the 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) {
    throw art::Exception(art::errors::LogicError)
      << "Multiple tracks have ID " << track->ID() << "!\n";
  }

  double& total = totalCharge[track->ID()];
  total = 0.0;
  for (art::Ptr<recob::Hit> const& hit: hits)
    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.

                                                    {
     return assns
        | ranges::views::all
        | ranges::views::group_by([](auto a1, auto a2) { return a1.first == a2.first;})
        | ranges::views::transform([] (auto pairs)
           {
             return std::make_pair(
               pairs.front().first, // assuming they're all the same, pick first
               pairs | ranges::views::values | util::range_for
               );
           })
        | util::range_for
        ;
  } // associated_groups_with_left()

template<typename Coll , typename KeyOp , typename CmpOp , typename RefOp , typename KeySortOp >

auto util::clusterBy	(	Coll const &	objs,
		KeyOp	keyFunc,
		CmpOp	sameGroup,
		RefOp	objRef,
		KeySortOp	keySort
	)

Performs a simple clustering.

Template Parameters

Coll	type of collection of objects to cluster
KeyOp	type of operation extracting the relevant key for clustering
CmpOp	type of operation determining if object belongs to a cluster
RefOp	type of operation extracting the object to store in cluster
KeySortOp	type of operation sorting the clustering keys

Parameters

coll	collection of objects to cluster
keyFunc	operation extracting the relevant key for clustering
sameGroup	operation determining if an object belongs to a cluster
objRef	operation extracting the object to store in the cluster
keySort	operation sorting the clustering keys

Returns

a STL vector of clusters of object "references"

The algorithm clusters objects whose key is compatible. The key must be sortable (keySort). Each cluster is assigned a key value, and all the unclustered objects whose key (keyFunc) is compatible (sameGroup) with that cluster key are added to that cluster. The objects from coll are considered in order of key value, with the order being defined by keySort. Each cluster contains a derivative of the original object (objRef), which may be for example a pointer to the original object, a copy of it, or in fact anything objRef returns.

The return value is in the form of a std::vector in which each element represents a cluster. Each of these clusters is a std::vector of the derivative objects.

Requirements

• Coll: an iterable collection of objects of type Object_t;
• KeyOp: a functor returning the key of an object, like Key_t keyFunc(Object_t const&);
• KeySortOp: a functor like bool keySort(Key_t a, Key_t b) returning strict ordering between key values a and b;
• CmpOp: a functor like bool keySort(Key_t a, Key_t b) returning if an object with key b should belong to a cluster with key a;
• RefOp: a functor returning the object to store in the cluster starting from an object in the original collection: ObjRef_t objRef(Object_t); note that the result should probably not be a C++ reference since they don't go along well with containers.

Definition at line 118 of file icarusalg/icarusalg/Utilities/SimpleClustering.h.

  {

  /*
   * 1. create a list of object key (`keyFunc`) and object reference (`objRef`)
   * 2. sort that list by key (`keySort`)
   * 3. cluster object references with nearby keys (`sameGroup`)
   *
   * A new cluster is started every time for a new object `sameGroup` return
   * `false` when applied on the key of the first object in the current cluster
   * and the key of the new object.
   *
   */

  //
  // some definitions
  //
  using Object_t = typename Coll::value_type;
  using ObjectRef_t = std::decay_t<decltype(objRef(std::declval<Object_t>()))>;
  using Cluster_t = std::vector<ObjectRef_t>;
  using Clusters_t = std::vector<Cluster_t>;

  auto makeKeyAndObjRef = [keyFunc, objRef](auto&& obj)
    { return std::make_pair(keyFunc(obj), objRef(obj)); };

  using KeyAndObjRef_t = decltype(makeKeyAndObjRef(*(util::begin(objs))));

  //
  // working data: "map" of objects by key
  //
  std::vector<KeyAndObjRef_t> KeysAndObjRefs;
  KeysAndObjRefs.reserve(objs.size());
  std::transform(
    util::begin(objs), util::end(objs), std::back_inserter(KeysAndObjRefs),
    makeKeyAndObjRef
    );

  // sort the map by key
  std::sort(
    util::begin(KeysAndObjRefs), util::end(KeysAndObjRefs),
    details::makeTupleElementOp<0U>(keySort)
    );

  //
  // cluster the objects in the map by key proximity
  //
  Clusters_t clusters;
  if (KeysAndObjRefs.empty()) return clusters;

  auto iKeyAndObjRef = util::begin(KeysAndObjRefs);
  auto const end = util::end(KeysAndObjRefs);

  auto startCluster = [](auto& keyAndObjRef)
    {
      return
        std::make_pair(keyAndObjRef.first, Cluster_t{ keyAndObjRef.second });
    };
  auto addToCluster = [](auto& cluster, auto& keyAndObjRef)
    { cluster.second.push_back(std::move(keyAndObjRef.second)); };

  auto currentCluster = startCluster(*iKeyAndObjRef);
  while(++iKeyAndObjRef != end) {

    if (sameGroup(iKeyAndObjRef->first, currentCluster.first)) {
      addToCluster(currentCluster, *iKeyAndObjRef);
    }
    else {
      clusters.push_back(std::move(currentCluster.second));
      currentCluster = startCluster(*iKeyAndObjRef);
    }

  } // while
  clusters.push_back(std::move(currentCluster.second));

  return clusters;

} // util::clusterBy(Coll, KeyOp, CmpOp, RefOp, KeySortOp)

template<typename Coll , typename KeyOp , typename CmpOp , typename KeySortOp >

auto util::clusterBy	(	Coll const &	objs,
		KeyOp	keyFunc,
		CmpOp	sameGroup,
		KeySortOp	keySort
	)

A version of clusterBy() storing a copy of each object as "reference".

Definition at line 202 of file icarusalg/icarusalg/Utilities/SimpleClustering.h.

{
  return clusterBy(objs,
    std::move(keyFunc), std::move(sameGroup),
    [](auto const& obj){ return obj; },
    std::move(keySort)
    );
} // util::clusterBy(Coll, KeyOp, CmpOp, KeySortOp)

def util.comma_separated

(

inp

)

Definition at line 287 of file util.py.

def comma_separated(inp):
    return inp.split(",")