Namespaces
namespace	ARM128d
namespace	AVX2d
namespace	AVX2f
namespace	AVX512d
namespace	detail
namespace	fcn
namespace	Helicity
namespace	integrate_fp_constants
namespace	Lineshape
	Namespace that contains all lineshapes, i.e.
namespace	PlotOptions
namespace	utils
namespace	Vertex
	Namespace that contains the base class for vertices, Vertex::Base, as well as the implementations of specific spin couplings and some helper functions such as the orbital operators.

Classes
class	Abs
	Unary expression that returns \(\|z\|\). More...
class	ACos
	Unary expression that returns \(\cos^{-1}(z)\). More...
class	AmplitudeRules
class	And
	Binary expression that returns \(l \wedge r\). More...
struct	ApplicationOptions
	default More...
class	Argument
	Structure to pass "named" parameters to functions. More...
class	ArgumentPack
	Container for a set of arguments Contains a set of arguments packed from a variadic constructor, that can then be unpacked in the call site of the function where the named arguments are required, as per the description in Argument. More...
class	Array
	Expression for a fixed size array of values. More...
class	ASin
	Unary expression that returns \(\sin^{-1}(z)\). More...
class	ASTResolver
	(Internal) class to aide in the resolution of the dependencies of expression trees. More...
class	ATan
	Unary expression that returns \(\tan^{-1}(z)\). More...
class	ATan2
class	Bilinears
class	BinDT
class	CacheTransfer
class	Chi2Estimator
class	CoherentSum
	A coherent sum of amplitudes. More...
class	CompiledExpression
class	CompiledExpression< ret_type(arg_types...)>
class	CompiledExpressionBase
	Base class for compiled expressions, i.e. More...
class	CompilerWrapper
struct	Complex
class	ComplexVariable
class	Configurable
class	ConfigurableBase
class	Conj
	Unary expression that returns \(z^{*}\). More...
class	Constant
	Class to contain a constant (which can contain a complex value). More...
class	Cos
	Unary expression that returns \(\cos(z)\). More...
class	CouplingConstant
class	DalitzIntegrator
	Class for doing 2D integrals using the Square Dalitz Plot (SQDP) method. More...
class	DecayChainStack
class	DecayChainStackBase
class	DiscreteDistribution
class	Divide
	Binary expression that returns \(l / r\). More...
class	DynamicContainer
	Template class for a DynamicContainer, containing a temporary buffer of objects and a generator function that refreshes the buffer once the current buffer is exhausted. More...
class	DynamicFCN
	Wrapper to give templated interface to a function contained in a dynamically linked library. More...
class	DynamicFCN< RETURN_TYPE(IN_TYPES...)>
class	Equal
class	Event
	Encapsulates the final state particles of a single event. More...
class	EventList
class	EventListSIMD
class	EventType
	Deals with final state configuration of events, specifically dealing with the ordering of particles in trees. More...
class	Exp
	Unary expression that returns \(e^x\). More...
class	Expression
	Wrapper class for shared_ptrs to virtual expressions for use in conjunction with operators to build expression trees. More...
class	ExpressionPack
	A group of expressions packed into a single expression. More...
class	ExpressionParameter
class	ExpressionParser
class	ExtendLikelihoodBase
class	Factory
	Static factory to construct classes from a hierarchy based on a key (normally std::string). More...
class	FastDT
class	FitFraction
struct	FitFractionCalculator
class	FitResult
class	Fmod
	Binary expression that returns the fractional part of \( l \mathrm{mod} r \). More...
struct	Function
class	FunctionCache
class	GaussErrorPropagator
class	GaussianConstraint
class	Generator
class	GreaterThan
	Binary expression that returns \(l > r\). More...
class	GreaterThanEqualTo
	Binary expression that returns \(l > r\). More...
class	HelicityCosine
	Functor to compute the angle between set of particles {1} and {2} in the rest frame of set {3}. More...
class	IArgument
	Virtual base class for arguments Named arguments to functions (python-style) are given a virtual base class such that they can be stored into an argument pack. More...
class	IBinaryExpression
	Base class for binary expressions, i.e. More...
class	IExpression
	Virtual base class for other expression tree components. More...
class	Imag
	Unary expression that returns the imaginary part of \(z\). More...
class	IncoherentSum
	An incoherent sum of resonances, traditionally considered as an approximate background model. More...
struct	integral
class	Integrator
class	ISqrt
	Unary expression that uses inverse sqrt (faster than dividing by sqrt). More...
class	IUnaryExpression
	Base class for unary expressions, i.e. More...
class	KahanSum
	Implements Kahan summation for better precision with (repeated) floating point addition. More...
struct	KeyedFunctors
struct	KeyedFunctors< return_type(arg_types...)>
class	LambdaExpression
	Parameter that the value of which is given by some arbitrary C++ function. More...
class	LambdaTransfer
class	LASSO
class	LessThan
	Binary expression that returns \(l < r\). More...
class	LessThanEqualTo
	Binary expression that returns \(l < r\). More...
class	LGamma
	Unary expression that returns \(\log\left\|\Gamma(x)\right\|\). More...
class	LinearErrorPropagator
	Propagates uncertainties on functors using either a MinuitParameterSet (thus assuming a diagonal covariance matrix) or with a set of parameters and a covariance matrix (i.e. More...
class	Log
	Unary expression that returns \(\log(x)\). More...
struct	LS
class	MatrixElement
class	MinuitExpression
class	MinuitParameter
class	MinuitParameterSet
class	MinuitProxy
class	MomentumTransfer
	Functor to calculate the linear momemtum between particles {1} and {2} in the rest frame of {1} + {2}. More...
class	NamedParameter
	A parameter with value specified by the user at runtime, either in an options file or via the command line. More...
class	NonlinearErrorPropagator
class	Norm
	Unary expression that returns \(\|z\|^2\). More...
class	NormalOrderedExpression
class	OptionsParser
class	Or
	Binary expression that returns \(l \wedge r\). More...
class	Pade
class	ParameterTransfer
class	Particle
	Describes a particle, its decay process and subsequent decay products, which are also Particles. More...
class	ParticleProperties
	Class that contains the PDG properties (mass, width, charges, etc.) for a single particle species,. More...
class	ParticlePropertiesList
class	PDFWrapper
class	PhaseSpace
	Phase-space generator taken from the ROOT routine, from Rene Brun and Valerio Filippini, which was originally based on the GENBOD routine of CERNLIB with modifications such that unweighted events are generated, which saves a large amount of CPU. More...
class	PolarisedSum
struct	poleConfig
class	Pow
	Binary expression that returns \( l^{r} \). More...
class	Product
	Binary expression that returns \(l\times r\). More...
struct	ProfileClock
class	ProgressBar
class	Projection
class	Projection2D
class	Property
	Properties are configurable characteristics of objects that will at some point inherit from a base class. More...
class	QuarkContent
class	QuarkState
class	Real
	Unary expression that returns the real part of \(z\). More...
class	RecursivePhaseSpace
	Generator of events with more complex topologies. More...
class	scatter_iterator
class	SimFit
class	Sin
	Unary expression that returns \(\sin(z)\). More...
struct	SmallVector
class	Spline
class	SplineTransfer
class	Sqrt
	Unary expression that returns \(\sqrt{x}\). More...
class	Store
class	Sub
	Binary expression that returns \(l-r\). More...
struct	SubTree
class	Sum
	Binary expression that returns \(l+r\). More...
class	SumPDF
	A pdf that contains one or more terms. More...
class	Tan
	Unary expression that returns \(\tan(z)\). More...
class	Tensor
class	TensorExpression
class	TensorProxy
	Utility class that wraps a tensor and a set of indices such that tensor operations can be performed. More...
class	Ternary
	Evaluates the ternary operator. More...
class	ThreadPool
class	ThreeBodyCalculator
class	TotalCoupling
class	Transform
class	TransformSequence
class	TreePhaseSpace
	Generator of events where the phase space is decomposed into a series of subtrees. More...
class	TreeReader
class	Variable
	Free parameter for expression. More...

Typedefs
typedef std::pair< std::string, Expression >	DebugSymbol
typedef std::vector< DebugSymbol >	DebugSymbols
template<int N, typename... args>
using	nthType = typename std::tuple_element<N, std::tuple<args...>>::type
template<typename... args>
using	zeroType = typename detail::zeroType<args...>::type
using	real_v = AVX::real_v
using	complex_v = AVX::complex_v
typedef double	real_t
typedef std::complex< real_t >	complex_t
using	TransformCache = std::map<std::string, TransformSequence>

Enumerations
enum	Strategy { linear , quadratic , cubic , quartic }
enum	Alignment { SoA , AoS }

Functions
void	AddCPConjugate (MinuitParameterSet &, const std::vector< std::string > &={})
	DECLARE_ARGUMENT (MaxDepth, size_t)
	DECLARE_ARGUMENT (MinEvents, size_t)
	DECLARE_ARGUMENT (Dim, size_t)
	DECLARE_ARGUMENT (Functor, std::function< std::vector< real_t >(const Event &)>)
	DECLARE_ARGUMENT (File, std::string)
	DECLARE_ARGUMENT (disableBatch, bool)
	DECLARE_ARGUMENT (includeParameters, bool)
	DECLARE_ARGUMENT (includePythonBindings, bool)
template<typename return_type>
CompiledExpression< void(return_type , const double , const double *)>	make_rto_expression (const Expression &expression, const std::string &name)
template<typename return_type>
CompiledExpression< return_type(const double , const double )>	make_expression (const Expression &expression, const std::string &name)
template<typename return_type, typename arg1 = double, typename arg2 = double, typename... arg_types>
CompiledExpression< return_type(const arg1 , const arg2 )>	make_expression (const Expression &expression, const std::string &name, const arg_types &...args)
std::string	programatic_name (std::string s)
std::ostream &	operator<< (std::ostream &os, const CompiledExpressionBase &expression)
std::string	get_cpp_version ()
template<typename real_t>
real_t	real (const Complex< real_t > &arg)
template<typename real_t>
real_t	real (const real_t &arg)
template<typename real_t>
real_t	imag (const Complex< real_t > &arg)
template<typename real_t>
real_t	abs (const Complex< real_t > &v)
template<typename real_t>
real_t	norm (const Complex< real_t > &v)
template<typename real_t>
Complex< real_t >	conj (const Complex< real_t > &arg)
template<typename real_t, typename R2_t>
Complex< real_t >	operator+ (const Complex< real_t > &lhs, const R2_t &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator- (const Complex< real_t > &lhs, const R2_t &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator* (const Complex< real_t > &lhs, const R2_t &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator/ (const Complex< real_t > &lhs, const R2_t &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator+ (const R2_t &lhs, const Complex< real_t > &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator- (const R2_t &lhs, const Complex< real_t > &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator* (const R2_t &lhs, const Complex< real_t > &rhs)
template<typename real_t, typename R2_t>
Complex< real_t >	operator/ (const R2_t &lhs, const Complex< real_t > &rhs)
template<typename real_t>
Complex< real_t >	operator+ (const Complex< real_t > &lhs, const Complex< real_t > &rhs)
template<typename real_t>
Complex< real_t >	operator- (const Complex< real_t > &lhs, const Complex< real_t > &rhs)
template<typename real_t>
Complex< real_t >	operator* (const Complex< real_t > &lhs, const Complex< real_t > &rhs)
template<typename real_t>
Complex< real_t >	operator/ (const Complex< real_t > &lhs, const Complex< real_t > &rhs)
template<typename real_t>
Complex< real_t >	operator- (const Complex< real_t > &x)
template<typename real_t>
Complex< real_t >	exp (const Complex< real_t > &v)
template<typename real_t>
Complex< real_t >	sqrt (const Complex< real_t > &v)
template<typename real_t>
Complex< real_t >	log (const Complex< real_t > &v)
template<typename real_t>
std::ostream &	operator<< (std::ostream &os, const Complex< real_t > &obj)
Expression	phaseSpace (const Expression &s, const Particle &p, const size_t &l)
DecayChainStackBase *	make_decay_chain_stack (const Particle &particle, bool aggressiveOptimisation=false)
template<class T>
T	parse (const std::string &word)
template<class T>
std::string	to_string (const T &enumItem)
	DECLARE_ARGUMENT (Branches, std::vector< std::string >)
	DECLARE_ARGUMENT (ExtraBranches, std::vector< std::string >)
	Branch names containing kinematic information.
	DECLARE_ARGUMENT (IdBranches, std::vector< std::string >)
	additional information about the event to include
	DECLARE_ARGUMENT (EntryList, std::vector< size_t >)
	Branches containing PID information, used if the names of particles are incorrect (looking at you, DTF).
	DECLARE_ARGUMENT (GetGenPdf, bool)
	DECLARE_ARGUMENT (Filter, std::string)
	DECLARE_ARGUMENT (WeightBranch, std::string)
	DECLARE_ARGUMENT (ApplySym, bool)
	DECLARE_ARGUMENT (WeightFunction, std::function< double(const Event &)>)
	DECLARE_ARGUMENT (InputUnits, AmpGen::Units)
std::ostream &	operator<< (std::ostream &os, const EventType &type)
unsigned	python__EventType__dim (const char *eventType)
Expression	operator< (const Expression &A, const Expression &B)
Expression	operator> (const Expression &A, const Expression &B)
Expression	operator<= (const Expression &A, const Expression &B)
Expression	operator>= (const Expression &A, const Expression &B)
Expression	operator+ (const Expression &A, const Expression &B)
Expression	operator- (const Expression &A, const Expression &B)
Expression	operator* (const Expression &A, const Expression &B)
Expression	operator/ (const Expression &A, const Expression &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator+ (const Expression &A, const T &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator- (const Expression &A, const T &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator* (const Expression &A, const T &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator/ (const Expression &A, const T &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator+ (const T &A, const Expression &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator- (const T &A, const Expression &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator* (const T &A, const Expression &B)
template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>
Expression	operator/ (const T &A, const Expression &B)
Expression	operator&& (const Expression &A, const Expression &B)
Expression	operator\|\| (const Expression &A, const Expression &B)
Expression	operator== (const Expression &A, const Expression &B)
Expression	operator== (const Expression &A, const double &B)
Expression	operator== (const double &A, const Expression &B)
std::ostream &	operator<< (std::ostream &os, const Expression &expression)
template<class T>
bool	is (const Expression &expression)
template<class T>
T	cast (const Expression &expression)
Expression	make_cse (const Expression &A, bool simplify=false)
	declare_enum (coordinateType, cartesian, polar)
	declare_enum (angType, deg, rad)
template<typename arg_type>
void	set_tuple_from_expression (arg_type &arg, const Expression &expr)
template<typename... types>
std::tuple< types... >	unpack (const Expression &expression)
bool	operator< (const FitFraction &lhs, const FitFraction &rhs)
bool	operator> (const FitFraction &lhs, const FitFraction &rhs)
bool	operator== (const FitFraction &lhs, const FitFraction &rhs)
std::ostream &	operator<< (std::ostream &os, const FitFraction &obj)
template<class FCN>
PDFWrapper< FCN >	make_pdf (const FCN &fcn)
void	python__generate (const char eventType, double out, const unsigned int size)
	@function PyGenerate
template<typename T>
KahanSum< T >	operator+ (const KahanSum< T > &l, const T &var)
template<typename T>
T	KahanBabushkaKleinSum (const std::vector< T > &container)
double	acoplanarity (const Event &evt)
	The extent to which a four body decay occurs within a single decay frame.
double	PHI (const Event &evt)
double	phi (const Event &evt, int i, int j, int k, int w)
std::vector< double >	rotate (const std::vector< double > &input, const std::vector< double > &n, const double &v)
void	boost (Event &evt, const std::tuple< double, double, double > &n, const double &v)
void	rotate (Event &evt, const std::tuple< double, double, double > &n, const double &v)
void	rotateBasis (Event &evt, const TVector3 &p1, const TVector3 &p2, const TVector3 &p3)
double	dotProduct (const TLorentzVector &p1, const TLorentzVector &p2, const TLorentzVector &pX)
	Helper function to calculate the (space-like) dot product between vectors p1 and p2 in the rest frame of pX.
TLorentzVector	pFromEvent (const Event &evt, const unsigned &ref)
	Helper function to extract a TLorentzVector of the ith decay product from an AmpGen::Event.
TLorentzVector	pFromEvent (const Event &evt, const std::vector< unsigned > &ref)
	Helper function to extract a TLorentzVector of the sum of {2} decay product from an AmpGen::Event.
Tensor	constructKMatrix (const Expression &s, const unsigned &nChannels, const std::vector< poleConfig > &poleConfigs)
Expression	phsp_twoBody (const Expression &s, const double &m0, const double &m1)
Expression	phsp_fourPi (const Expression &s)
Expression	phsp_FOCUS (const Expression &s, const double &m0, const double &m1)
Expression	gFromGamma (const Expression &m, const Expression &gamma, const Expression &rho)
std::vector< Variable >	paramVector (const std::string &name, const unsigned int &nParam)
Tensor	getPropagator (const Tensor &kMatrix, const std::vector< Expression > &phaseSpace, DebugSymbols *db=nullptr)
Expression	Q2 (const Expression &Msq, const Expression &M1sq, const Expression &M2sq)
Expression	kFactor (const Expression &mass, const Expression &width, std::vector< std::pair< std::string, Expression > > *dbexpressions=nullptr)
Expression	BlattWeisskopf_Norm (const Expression &z, const Expression &z0, unsigned int L)
Expression	BL (const Expression &s, const Expression &s0, const Expression &s1, const Expression &s2, const Expression &radius, const unsigned int &L)
Expression	BlattWeisskopf (const Expression &z, unsigned int L)
Expression	pol (const AmpGen::Expression &X, const std::vector< Expression > &p)
std::vector< Expression >	parameterVector (const std::string &name, const size_t &nParam)
Expression	width (const Expression &s, const Expression &s1, const Expression &s2, const Expression &mass, const Expression &width, const Expression &radius, unsigned int L, DebugSymbols *dbexpressions=nullptr)
std::vector< size_t >	processIndex (const std::vector< MatrixElement > &tm, const std::string &label)
size_t	findIndex (const std::vector< MatrixElement > &tm, const std::string &decayDescriptor)
std::vector< size_t >	findIndices (const std::vector< MatrixElement > &tm, const std::string &decayDescriptor)
template<class TYPE>
std::string	type_string ()
	Utility classes for compile-time metaprogramming, such as identifying the types of arguments for generating source code, compile-time unrolling of tuples and loops, and identifying if a class can be constructed in different ways.
template<class TYPE>
std::string	type_string (const TYPE &)
template<std::size_t I = 0, typename FuncT, typename... Tp>
std::enable_if_t< I==sizeof...(Tp), void >	for_each (std::tuple< Tp... > &, FuncT)
	declare_enum (Flag, Free, Hide, Fix, CompileTimeConstant, Blind)
std::ostream &	operator<< (std::ostream &os, const MinuitParameter &)
std::ostream &	operator<< (std::ostream &os, const MinuitProxy &)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const NamedParameter< T > &np)
template<typename... T>
std::string	optionalHelpString (const std::string &header, const T &...args)
template<typename function_type>
double	integrate_1d (const function_type &fcn, const double &min, const double &max, gsl_integration_workspace *ws=nullptr)
template<typename function_type>
double	integrate_1d_inf (const function_type &fcn, gsl_integration_workspace *ws=nullptr)
template<typename function_type>
double	integrate_1d_cauchy (const function_type &fcn, const double &x0, const double &min, const double &max, gsl_integration_workspace *ws=nullptr)
template<unsigned dim, typename fcn>
std::tuple< double, double, unsigned >	integrate_fp (const fcn &F, const std::array< double, dim > &ctr, const std::array< double, dim > &wth)
template<unsigned dim, typename fcn>
double	integrate (const fcn &F, const std::array< double, dim > xmin, const std::array< double, dim > &xmax)
	declare_enum (spinFormalism, Covariant, Canonical)
	declare_enum (spinBasis, Dirac, Weyl)
std::ostream &	operator<< (std::ostream &os, const Particle &particle)
std::ostream &	operator<< (std::ostream &out, const AmpGen::ParticleProperties &pp)
std::ostream &	operator<< (std::ostream &out, const ParticlePropertiesList &ppl)
	make_enum (spaceType, spin, flavour)
template<int N, class FCN>
double	Profile (const FCN &fcn, const std::string &name="")
template<int N, class FCN>
double	ProfileWithStat (const FCN &fcn, const std::string &name="")
template<int N, class FCN>
double	Profile2 (const FCN &fcn)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const Property< T > &np)
template<typename... T>
std::string	helpStringOptions (const std::string &header, const T &...args)
template<typename T>
bool	operator== (const T &val, const Property< T > &prop)
std::ostream &	operator<< (std::ostream &st, const QuarkState &qc)
std::ostream &	operator<< (std::ostream &st, const QuarkContent &qc)
template<unsigned dim, unsigned width, typename fcn>
std::tuple< double, double, unsigned >	integrate_fp (const fcn &F, const std::array< double, dim > &ctr, const std::array< double, dim > &wth)
template<unsigned dim, typename fcn>
std::tuple< double, double, unsigned >	integrate_fp_scalar (const fcn &F, const std::array< double, dim > &ctr, const std::array< double, dim > &wth)
template<unsigned simd_size, bool modifiable = false, class store_type>
auto	make_scatter_iterator (const unsigned &pos, store_type *store)
Expression	Simplify (const Expression &expression)
Expression	getSpline (const std::string &name, const Expression &x, const std::string &arrayName, DebugSymbols *dbexpressions=nullptr, const bool &continueSpline=false)
template<class eventListType = EventList, class... pdfTypes>
auto	make_pdf (pdfTypes &&...pdfs)
	@function make_pdf
template<class eventListType = EventList, class... pdfTypes>
auto	make_likelihood (eventListType &events, pdfTypes &&...pdfs)
Tensor	operator+ (const Tensor &, const Tensor &)
Tensor	operator- (const Tensor &, const Tensor &)
Tensor	operator/ (const Tensor &, const Expression &)
Tensor	operator* (const Expression &, const Tensor &)
Tensor	operator* (const Tensor &, const Expression &)
Tensor	operator/ (const Tensor &, const double &)
Tensor	operator* (const double &, const Tensor &)
Tensor	operator* (const Tensor &, const double &)
TensorProxy	operator* (const TensorProxy &, const TensorProxy &)
TensorProxy	operator+ (const TensorProxy &, const TensorProxy &)
TensorProxy	operator- (const TensorProxy &, const TensorProxy &)
TensorProxy	operator/ (const TensorProxy &, const Expression &)
TensorProxy	operator* (const Expression &, const TensorProxy &)
TensorProxy	operator* (const TensorProxy &, const Expression &)
TensorProxy	operator/ (const TensorProxy &, const double &)
TensorProxy	operator* (const double &, const TensorProxy &)
TensorProxy	operator* (const TensorProxy &, const double &)
Tensor	Identity (const unsigned &rank=4)
const Tensor	LeviCivita (const unsigned &rank=4)
Expression	dot (const Tensor &A, const Tensor &B)
std::ostream &	operator<< (std::ostream &out, const Tensor::Index &index)
Expression	cosh (const Expression &x)
Expression	sinh (const Expression &x)
Expression	tanh (const Expression &x)
Expression	acosh (const Expression &x)
Expression	asinh (const Expression &x)
Expression	atanh (const Expression &x)
	declare_enum (Units, TeV, GeV, MeV, KeV, eV, ms, us, ns, ps, fs)
double	to_double (const Units &unit)
template<typename iterator_type, typename functor_type>
std::string	vectorToString (iterator_type begin, iterator_type end, const std::string &delim, functor_type fcn)
template<typename tuple_t>
std::string	tupleToString (const tuple_t &tuple, const std::string &delim)
template<typename container_type, typename vtype = typename container_type::value_type, typename functor_type = std::function<vtype(const vtype &)>>
std::string	vectorToString (const container_type &obj, const std::string &delim="", const functor_type &f=[](const auto &arg) { return arg;})
template<typename T>
std::vector< std::vector< T > >	nCr (const T &n, const T &r)
std::vector< std::string >	vectorFromFile (const std::string &filename, const char ignoreLinesThatBeginWith='#')
std::vector< std::string >	split (const std::string &, char, bool=true)
std::vector< std::string >	split (const std::string &, const std::vector< char > &, bool=false)
std::vector< size_t >	findAll (const std::string &input, const std::string &ch)
std::map< size_t, std::string >	vecFindAll (const std::string &input, const std::vector< std::string > &vCh)
size_t	find_next_of (const std::string &input, const std::vector< std::string > &patterns, const size_t &begin=0)
std::string	replaceAll (const std::string &input, const std::string &toReplace, const std::string &replaceWith)
std::string	replaceAll (const std::string &input, const std::vector< std::pair< std::string, std::string > > &rules)
unsigned int	FNV1a_hash (const std::string &toHash)
std::vector< std::string >	getItems (const std::string &tree, const std::vector< std::string > &brackets={"{", "}"}, const std::string &seperator=",")
void	swapChars (std::string &arg, const char a, const char b)
unsigned int	editDistance (const std::string &s1, const std::string &s2)
std::string	round (const double &number, const unsigned int &nsf)
std::string	numberWithError (const double &number, const double &error, const unsigned int &nDigits)
template<typename return_type>
return_type	lexical_cast (const std::string &word, bool &status)
template<class... ARGS>
std::string	mysprintf (const std::string &format, ARGS &&...args)
template<>
double	lexical_cast (const std::string &word, bool &status)
template<>
unsigned int	lexical_cast (const std::string &word, bool &status)
template<>
std::string	lexical_cast (const std::string &word, bool &status)
template<>
float	lexical_cast (const std::string &word, bool &status)
template<>
bool	lexical_cast (const std::string &word, bool &status)
template<>
int	lexical_cast (const std::string &word, bool &status)
template<>
unsigned long int	lexical_cast (const std::string &word, bool &status)
template<>
long int	lexical_cast (const std::string &word, bool &status)
template<typename functor_type>
void	processFile (const std::string &filename, functor_type &&toDo, const char ignoreLinesThatBeginWith='#')
std::pair< size_t, int >	minSwaps (const std::vector< size_t > &indices, const std::vector< int > &exchangeParities)
template<class iterator, class comparator>
void	parallel_sort (iterator begin, iterator end, const comparator &comp, const size_t &grainsize)
template<class iterator, class initial_value, class functor>
initial_value	parallel_accumulate (iterator begin, iterator end, const initial_value &init, const functor &f)
template<typename return_type, typename contained_type>
std::function< return_type(const contained_type &)>	arrayToFunctor (const std::vector< return_type > &values)
template<typename T>
std::vector< std::vector< T > >	all_combinations (const std::vector< std::vector< T > > &elements)
template<class iterator>
void	parallel_sort (iterator begin, iterator end, const size_t &grainsize)
bool	stringMatchesWildcard (const std::string &input, const std::string &wildcard_string, const char wildcard_character=' *')
bool	isDir (const std::string &fname)
bool	fileExists (const std::string &name)
std::vector< std::string >	getListOfFiles (const std::string &directory, const std::string &patternString="")
void	printSplash ()
void	printReleaseNotes (const std::string &fname)
std::string	ltrim (std::string s)
std::string	rtrim (std::string s)
std::string	trim (const std::string &s)
std::string	expandGlobals (std::string path)
std::ostream &	bold_on (std::ostream &)
std::ostream &	bold_off (std::ostream &)
std::ostream &	italic_on (std::ostream &)
std::ostream &	italic_off (std::ostream &)
Tensor	Orbital_PWave (const Tensor &p, const Tensor &q)
	Helper function that computes the \(L=1\) orbital momentum operator.
Tensor	Orbital_DWave (const Tensor &p, const Tensor &q)
	Helper function that computes the \(L=2\) orbital momentum operator.
Tensor	Spin1Projector (const Tensor &p)
	Helper function that computes the projection operator onto a spin one state.
Tensor	Spin2Projector (const Tensor &p)
	Helper function that computes the projection operator onto a spin one state.
Tensor	Spin1hProjector (const Tensor &B)
	Helper function that projects a spinor.
Tensor	Spin3hProjector (const Tensor &A)
Tensor	Spin1hbProjector (const Tensor &B)
Tensor	Spin3hbProjector (const Tensor &A)
Tensor	gamma_twiddle (const Tensor &P)
Tensor	Gamma4Vec ()
Tensor	Bar (const Tensor &P)
Tensor	slash (const Tensor &P)
Expression	wigner_d (const Expression &cb, const double &j, const double &m, const double &n)
Expression	wigner_D (const std::pair< Expression, Expression > &P, const double &J, const double &lA, const double &lB, DebugSymbols *db)
double	CG (const double &j1, const double &m1, const double &j2, const double &m2, const double &J, const double &M)
	Calculates the Clebsch-Gordan coefficient for (j1 m1 j2 m2 \| J M), the expansion coefficients in.
TransformSequence	wickTransform (const Tensor &P, const Particle &p, const int &ve=1, DebugSymbols *db=nullptr)
	Generates a wick transform sequence that aligns tensor P (four-vector) to the +/- ve z-axis, then boosts to the rest frame.
Expression	helicityAmplitude (const Particle &particle, const TransformSequence &parentFrame, const double &Mz, DebugSymbols *db, const Helicity::Flags &flags=Helicity::Flags(), const int sgn=1, std::shared_ptr< TransformCache > cacheptr=nullptr)
Tensor	basisSpinor (const int &polState, const int &id)
Tensor	basisVector (const int &polState)
std::vector< LS >	calculate_recoupling_constants (const double &J, const double &M, const double &L, const double &S, const double &j1, const double &j2)

Variables
const Expression	I
const Expression	Z
const std::array< Tensor, 5 >	Gamma
const std::array< Tensor, 3 >	Sigma
const std::array< Tensor, 3 >	Sigma4
const std::array< Tensor, 3 >	SO3
const std::array< Tensor, 8 >	SU3
template<class TYPE, class KEY_TYPE>
Factory< TYPE, KEY_TYPE > *	Factory< TYPE, KEY_TYPE >::gImpl = nullptr
static const double	TeV = 1000
static const double	GeV = 1
static const double	MeV = 0.001
static const double	KeV = 0.001 * 0.001
static const double	eV = 0.001 * 0.001 * 0.001
static const double	ms = 1000 * 1000
static const double	us = 1000
static const double	ns = 1
static const double	ps = 0.001
static const double	fs = 0.001 * 0.001
static const double	mm = 1.0
static const double	um = 0.001
static const double	nm = 0.001 * 0.001

Class Documentation

◆ AmpGen::CompiledExpression

class AmpGen::CompiledExpression

◆ AmpGen::DynamicFCN

class AmpGen::DynamicFCN

◆ AmpGen::KeyedFunctors

struct AmpGen::KeyedFunctors

◆ AmpGen::LS

struct AmpGen::LS

Class Members
double	cg1 = {0}
double	cg2 = {0}
double	factor = {1}
double	m1 = {0}
double	m2 = {0}
double	p = {0}

Typedef Documentation

◆ complex_t

typedef std::complex<real_t> AmpGen::complex_t

Definition at line 7 of file Types.h.

◆ complex_v

using AmpGen::complex_v = AVX::complex_v

Definition at line 48 of file utils.h.

◆ DebugSymbol

typedef std::pair<std::string, Expression> AmpGen::DebugSymbol

Definition at line 110 of file Expression.h.

◆ DebugSymbols

typedef std::vector<DebugSymbol> AmpGen::DebugSymbols

Definition at line 111 of file Expression.h.

◆ nthType

template<int N, typename... args>

using AmpGen::nthType = typename std::tuple_element<N, std::tuple<args...>>::type

Definition at line 32 of file MetaUtils.h.

◆ real_t

typedef double AmpGen::real_t

Definition at line 6 of file Types.h.

◆ real_v

using AmpGen::real_v = AVX::real_v

Definition at line 47 of file utils.h.

◆ TransformCache

using AmpGen::TransformCache = std::map<std::string, TransformSequence>

Definition at line 10 of file Wigner.h.

◆ zeroType

template<typename... args>

using AmpGen::zeroType = typename detail::zeroType<args...>::type

Definition at line 34 of file MetaUtils.h.

Enumeration Type Documentation

◆ Alignment

enum AmpGen::Alignment

Enumerator
SoA
AoS

Definition at line 12 of file Store.h.

◆ Strategy

enum AmpGen::Strategy

Enumerator
linear
quadratic
cubic
quartic

Definition at line 10 of file Pade.h.

Function Documentation

◆ abs()

template<typename real_t>

real_t AmpGen::abs ( const Complex< real_t > & v )

inline

Definition at line 39 of file Complex.h.

◆ acosh()

Expression AmpGen::acosh ( const Expression & x )

◆ AddCPConjugate()

void AmpGen::AddCPConjugate	(	MinuitParameterSet &	,
		const std::vector< std::string > &	= {} )

◆ all_combinations()

template<typename T>

std::vector< std::vector< T > > AmpGen::all_combinations ( const std::vector< std::vector< T > > & elements )

Definition at line 150 of file Utilities.h.

◆ arrayToFunctor()

template<typename return_type, typename contained_type>

std::function< return_type(const contained_type &)> AmpGen::arrayToFunctor ( const std::vector< return_type > & values )

Definition at line 146 of file Utilities.h.

◆ asinh()

Expression AmpGen::asinh ( const Expression & x )

◆ atanh()

Expression AmpGen::atanh ( const Expression & x )

◆ Bar()

Tensor AmpGen::Bar ( const Tensor & P )

◆ basisSpinor()

Tensor AmpGen::basisSpinor	(	const int &	polState,
		const int &	id )

◆ basisVector()

Tensor AmpGen::basisVector ( const int & polState )

◆ BL()

Expression AmpGen::BL	(	const Expression &	s,
		const Expression &	s0,
		const Expression &	s1,
		const Expression &	s2,
		const Expression &	radius,
		const unsigned int &	L )

◆ BlattWeisskopf()

Expression AmpGen::BlattWeisskopf	(	const Expression &	z,
		unsigned int	L )

◆ BlattWeisskopf_Norm()

Expression AmpGen::BlattWeisskopf_Norm	(	const Expression &	z,
		const Expression &	z0,
		unsigned int	L )

◆ bold_off()

std::ostream & AmpGen::bold_off ( std::ostream & )

◆ bold_on()

std::ostream & AmpGen::bold_on ( std::ostream & )

◆ boost()

void AmpGen::boost	(	Event &	evt,
		const std::tuple< double, double, double > &	n,
		const double &	v )

◆ calculate_recoupling_constants()

std::vector< LS > AmpGen::calculate_recoupling_constants	(	const double &	J,
		const double &	M,
		const double &	L,
		const double &	S,
		const double &	j1,
		const double &	j2 )

◆ cast()

template<class T>

T AmpGen::cast ( const Expression & expression )

Definition at line 486 of file Expression.h.

◆ conj()

template<typename real_t>

Complex< real_t > AmpGen::conj ( const Complex< real_t > & arg )

inline

Definition at line 41 of file Complex.h.

◆ constructKMatrix()

Tensor AmpGen::constructKMatrix	(	const Expression &	s,
		const unsigned &	nChannels,
		const std::vector< poleConfig > &	poleConfigs )

◆ cosh()

Expression AmpGen::cosh ( const Expression & x )

◆ DECLARE_ARGUMENT() [1/18]

AmpGen::DECLARE_ARGUMENT	(	ApplySym	,
		bool	)

◆ DECLARE_ARGUMENT() [2/18]

AmpGen::DECLARE_ARGUMENT	(	Branches	,
		std::vector< std::string >	)

◆ DECLARE_ARGUMENT() [3/18]

AmpGen::DECLARE_ARGUMENT	(	Dim	,
		size_t	)

◆ DECLARE_ARGUMENT() [4/18]

AmpGen::DECLARE_ARGUMENT	(	disableBatch	,
		bool	)

◆ DECLARE_ARGUMENT() [5/18]

AmpGen::DECLARE_ARGUMENT	(	EntryList	,
		std::vector< size_t >	)

◆ DECLARE_ARGUMENT() [6/18]

AmpGen::DECLARE_ARGUMENT	(	ExtraBranches	,
		std::vector< std::string >	)

◆ DECLARE_ARGUMENT() [7/18]

AmpGen::DECLARE_ARGUMENT	(	File	,
		std::string	)

◆ DECLARE_ARGUMENT() [8/18]

AmpGen::DECLARE_ARGUMENT	(	Filter	,
		std::string	)

◆ DECLARE_ARGUMENT() [9/18]

AmpGen::DECLARE_ARGUMENT	(	Functor	,
		std::function< std::vector< real_t >(const Event &)>	)

◆ DECLARE_ARGUMENT() [10/18]

AmpGen::DECLARE_ARGUMENT	(	GetGenPdf	,
		bool	)

◆ DECLARE_ARGUMENT() [11/18]

AmpGen::DECLARE_ARGUMENT	(	IdBranches	,
		std::vector< std::string >	)

◆ DECLARE_ARGUMENT() [12/18]

AmpGen::DECLARE_ARGUMENT	(	includeParameters	,
		bool	)

◆ DECLARE_ARGUMENT() [13/18]

AmpGen::DECLARE_ARGUMENT	(	includePythonBindings	,
		bool	)

◆ DECLARE_ARGUMENT() [14/18]

AmpGen::DECLARE_ARGUMENT	(	InputUnits	,
		AmpGen::Units	)

◆ DECLARE_ARGUMENT() [15/18]

AmpGen::DECLARE_ARGUMENT	(	MaxDepth	,
		size_t	)

◆ DECLARE_ARGUMENT() [16/18]

AmpGen::DECLARE_ARGUMENT	(	MinEvents	,
		size_t	)

◆ DECLARE_ARGUMENT() [17/18]

AmpGen::DECLARE_ARGUMENT	(	WeightBranch	,
		std::string	)

◆ DECLARE_ARGUMENT() [18/18]

AmpGen::DECLARE_ARGUMENT	(	WeightFunction	,
		std::function< double(const Event &)>	)

◆ declare_enum() [1/6]

AmpGen::declare_enum	(	angType	,
		deg	,
		rad	)

◆ declare_enum() [2/6]

AmpGen::declare_enum	(	coordinateType	,
		cartesian	,
		polar	)

◆ declare_enum() [3/6]

AmpGen::declare_enum	(	Flag	,
		Free	,
		Hide	,
		Fix	,
		CompileTimeConstant	,
		Blind	)

◆ declare_enum() [4/6]

AmpGen::declare_enum	(	spinBasis	,
		Dirac	,
		Weyl	)

◆ declare_enum() [5/6]

AmpGen::declare_enum	(	spinFormalism	,
		Covariant	,
		Canonical	)

◆ declare_enum() [6/6]

AmpGen::declare_enum	(	Units	,
		TeV	,
		GeV	,
		MeV	,
		KeV	,
		eV	,
		ms	,
		us	,
		ns	,
		ps	,
		fs	)

◆ dot()

Expression AmpGen::dot	(	const Tensor &	A,
		const Tensor &	B )

◆ editDistance()

unsigned int AmpGen::editDistance	(	const std::string &	s1,
		const std::string &	s2 )

◆ exp()

template<typename real_t>

Complex< real_t > AmpGen::exp ( const Complex< real_t > & v )

inline

Definition at line 96 of file Complex.h.

◆ expandGlobals()

std::string AmpGen::expandGlobals ( std::string path )

◆ fileExists()

bool AmpGen::fileExists ( const std::string & name )

◆ find_next_of()

size_t AmpGen::find_next_of	(	const std::string &	input,
		const std::vector< std::string > &	patterns,
		const size_t &	begin = 0 )

◆ findAll()

std::vector< size_t > AmpGen::findAll	(	const std::string &	input,
		const std::string &	ch )

◆ findIndex()

size_t AmpGen::findIndex	(	const std::vector< MatrixElement > &	tm,
		const std::string &	decayDescriptor )

◆ findIndices()

std::vector< size_t > AmpGen::findIndices	(	const std::vector< MatrixElement > &	tm,
		const std::string &	decayDescriptor )

◆ FNV1a_hash()

unsigned int AmpGen::FNV1a_hash ( const std::string & toHash )

◆ for_each()

template<std::size_t I = 0, typename FuncT, typename... Tp>

std::enable_if_t< I==sizeof...(Tp), void > AmpGen::for_each	(	std::tuple< Tp... > &	,
		FuncT	)

Definition at line 36 of file MetaUtils.h.

◆ Gamma4Vec()

Tensor AmpGen::Gamma4Vec ( )

◆ gamma_twiddle()

Tensor AmpGen::gamma_twiddle ( const Tensor & P )

◆ get_cpp_version()

std::string AmpGen::get_cpp_version ( )

◆ getItems()

std::vector< std::string > AmpGen::getItems	(	const std::string &	tree,
		const std::vector< std::string > &	brackets = {"{", "}"},
		const std::string &	seperator = "," )

◆ getListOfFiles()

std::vector< std::string > AmpGen::getListOfFiles	(	const std::string &	directory,
		const std::string &	patternString = "" )

◆ getPropagator()

Tensor AmpGen::getPropagator	(	const Tensor &	kMatrix,
		const std::vector< Expression > &	phaseSpace,
		DebugSymbols *	db = nullptr )

◆ getSpline()

Expression AmpGen::getSpline	(	const std::string &	name,
		const Expression &	x,
		const std::string &	arrayName,
		DebugSymbols *	dbexpressions = nullptr,
		const bool &	continueSpline = false )

◆ gFromGamma()

Expression AmpGen::gFromGamma	(	const Expression &	m,
		const Expression &	gamma,
		const Expression &	rho )

◆ helicityAmplitude()

Expression AmpGen::helicityAmplitude	(	const Particle &	particle,
		const TransformSequence &	parentFrame,
		const double &	Mz,
		DebugSymbols *	db,
		const Helicity::Flags &	flags = Helicity::Flags(),
		const int	sgn = 1,
		std::shared_ptr< TransformCache >	cacheptr = nullptr )

◆ helpStringOptions()

template<typename... T>

std::string AmpGen::helpStringOptions	(	const std::string &	header,
		const T &...	args )

Definition at line 138 of file Property.h.

◆ Identity()

Tensor AmpGen::Identity ( const unsigned & rank = 4 )

◆ imag()

template<typename real_t>

real_t AmpGen::imag ( const Complex< real_t > & arg )

inline

Definition at line 38 of file Complex.h.

◆ integrate()

template<unsigned dim, typename fcn>

double AmpGen::integrate	(	const fcn &	F,
		const std::array< double, dim >	xmin,
		const std::array< double, dim > &	xmax )

number of function calls

Definition at line 75 of file NumericalIntegration.h.

◆ integrate_1d()

template<typename function_type>

double AmpGen::integrate_1d	(	const function_type &	fcn,
		const double &	min,
		const double &	max,
		gsl_integration_workspace *	ws = nullptr )

Definition at line 14 of file NumericalIntegration.h.

◆ integrate_1d_cauchy()

template<typename function_type>

double AmpGen::integrate_1d_cauchy	(	const function_type &	fcn,
		const double &	x0,
		const double &	min,
		const double &	max,
		gsl_integration_workspace *	ws = nullptr )

Definition at line 46 of file NumericalIntegration.h.

◆ integrate_1d_inf()

template<typename function_type>

double AmpGen::integrate_1d_inf	(	const function_type &	fcn,
		gsl_integration_workspace *	ws = nullptr )

Definition at line 32 of file NumericalIntegration.h.

◆ integrate_fp() [1/2]

template<unsigned dim, typename fcn>

std::tuple< double, double, unsigned > AmpGen::integrate_fp	(	const fcn &	F,
		const std::array< double, dim > &	ctr,
		const std::array< double, dim > &	wth )

Definition at line 68 of file NumericalIntegration.h.

◆ integrate_fp() [2/2]

template<unsigned dim, unsigned width, typename fcn>

std::tuple< double, double, unsigned > AmpGen::integrate_fp	(	const fcn &	F,
		const std::array< double, dim > &	ctr,
		const std::array< double, dim > &	wth )

Definition at line 41 of file integrate_fp.h.

◆ integrate_fp_scalar()

template<unsigned dim, typename fcn>

std::tuple< double, double, unsigned > AmpGen::integrate_fp_scalar	(	const fcn &	F,
		const std::array< double, dim > &	ctr,
		const std::array< double, dim > &	wth )

Definition at line 93 of file integrate_fp.h.

◆ is()

template<class T>

bool AmpGen::is ( const Expression & expression )

Definition at line 485 of file Expression.h.

◆ isDir()

bool AmpGen::isDir ( const std::string & fname )

◆ italic_off()

std::ostream & AmpGen::italic_off ( std::ostream & )

◆ italic_on()

std::ostream & AmpGen::italic_on ( std::ostream & )

◆ KahanBabushkaKleinSum()

template<typename T>

T AmpGen::KahanBabushkaKleinSum ( const std::vector< T > & container )

Definition at line 37 of file KahanSum.h.

◆ kFactor()

Expression AmpGen::kFactor	(	const Expression &	mass,
		const Expression &	width,
		std::vector< std::pair< std::string, Expression > > *	dbexpressions = nullptr )

◆ LeviCivita()

const Tensor AmpGen::LeviCivita ( const unsigned & rank = 4 )

◆ lexical_cast() [1/9]

template<>

long int AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [2/9]

template<>

unsigned long int AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [3/9]

template<>

int AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [4/9]

template<>

bool AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [5/9]

template<>

float AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [6/9]

template<>

std::string AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [7/9]

template<>

unsigned int AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [8/9]

template<>

double AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ lexical_cast() [9/9]

template<typename return_type>

return_type AmpGen::lexical_cast	(	const std::string &	word,
		bool &	status )

◆ log()

template<typename real_t>

Complex< real_t > AmpGen::log ( const Complex< real_t > & v )

inline

Definition at line 104 of file Complex.h.

◆ ltrim()

std::string AmpGen::ltrim ( std::string s )

◆ make_cse()

Expression AmpGen::make_cse	(	const Expression &	A,
		bool	simplify = false )

◆ make_decay_chain_stack()

DecayChainStackBase * AmpGen::make_decay_chain_stack	(	const Particle &	particle,
		bool	aggressiveOptimisation = false )

Definition at line 337 of file DecayChainStack.h.

◆ make_enum()

AmpGen::make_enum	(	spaceType	,
		spin	,
		flavour	)

◆ make_expression() [1/2]

template<typename return_type>

CompiledExpression< return_type(const double , const double )> AmpGen::make_expression	(	const Expression &	expression,
		const std::string &	name )

Definition at line 183 of file CompiledExpression.h.

◆ make_expression() [2/2]

template<typename return_type, typename arg1 = double, typename arg2 = double, typename... arg_types>

CompiledExpression< return_type(const arg1 , const arg2 )> AmpGen::make_expression	(	const Expression &	expression,
		const std::string &	name,
		const arg_types &...	args )

Definition at line 190 of file CompiledExpression.h.

◆ make_likelihood()

template<class eventListType = EventList, class... pdfTypes>

auto AmpGen::make_likelihood	(	eventListType &	events,
		pdfTypes &&...	pdfs )

Definition at line 139 of file SumPDF.h.

◆ make_pdf() [1/2]

template<class FCN>

PDFWrapper< FCN > AmpGen::make_pdf ( const FCN & fcn )

Definition at line 173 of file Generator.h.

◆ make_pdf() [2/2]

template<class eventListType = EventList, class... pdfTypes>

auto AmpGen::make_pdf ( pdfTypes &&... pdfs )

Usage is

auto pdf = make_pdf( signal, bkg1, ... );

AmpGen::make_pdf

PDFWrapper< FCN > make_pdf(const FCN &fcn)

Definition Generator.h:173

which returns a PDF that is the sum of the signal and bkg1 etc. The sum is also equipped with a likelihood, which can be used by setting the data for the PDF. Therefore, named SumPDF, it is useful to use this function to get a likelihood for a PDF containing a single term (i.e. signal or background only).

Definition at line 134 of file SumPDF.h.

◆ make_rto_expression()

template<typename return_type>

CompiledExpression< void(return_type , const double , const double *)> AmpGen::make_rto_expression	(	const Expression &	expression,
		const std::string &	name )

Definition at line 175 of file CompiledExpression.h.

◆ make_scatter_iterator()

template<unsigned simd_size, bool modifiable = false, class store_type>

auto AmpGen::make_scatter_iterator	(	const unsigned &	pos,
		store_type *	store )

Definition at line 34 of file iterator.h.

◆ minSwaps()

std::pair< size_t, int > AmpGen::minSwaps	(	const std::vector< size_t > &	indices,
		const std::vector< int > &	exchangeParities )

◆ mysprintf()

template<class... ARGS>

std::string AmpGen::mysprintf	(	const std::string &	format,
		ARGS &&...	args )

Definition at line 91 of file Utilities.h.

◆ nCr()

template<typename T>

std::vector< std::vector< T > > AmpGen::nCr	(	const T &	n,
		const T &	r )

Definition at line 43 of file Utilities.h.

◆ norm()

template<typename real_t>

real_t AmpGen::norm ( const Complex< real_t > & v )

inline

Definition at line 40 of file Complex.h.

◆ numberWithError()

std::string AmpGen::numberWithError	(	const double &	number,
		const double &	error,
		const unsigned int &	nDigits )

◆ operator&&()

Expression AmpGen::operator&&	(	const Expression &	A,
		const Expression &	B )

◆ operator*() [1/15]

template<typename real_t>

Complex< real_t > AmpGen::operator*	(	const Complex< real_t > &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 73 of file Complex.h.

◆ operator*() [2/15]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator*	(	const Complex< real_t > &	lhs,
		const R2_t &	rhs )

inline

Definition at line 49 of file Complex.h.

◆ operator*() [3/15]

Tensor AmpGen::operator*	(	const double &	,
		const Tensor &	)

◆ operator*() [4/15]

TensorProxy AmpGen::operator*	(	const double &	,
		const TensorProxy &	)

◆ operator*() [5/15]

Tensor AmpGen::operator*	(	const Expression &	,
		const Tensor &	)

◆ operator*() [6/15]

TensorProxy AmpGen::operator*	(	const Expression &	,
		const TensorProxy &	)

◆ operator*() [7/15]

Expression AmpGen::operator*	(	const Expression &	A,
		const Expression &	B )

◆ operator*() [8/15]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator*	(	const Expression &	A,
		const T &	B )

Definition at line 449 of file Expression.h.

◆ operator*() [9/15]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator*	(	const R2_t &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 61 of file Complex.h.

◆ operator*() [10/15]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator*	(	const T &	A,
		const Expression &	B )

Definition at line 454 of file Expression.h.

◆ operator*() [11/15]

Tensor AmpGen::operator*	(	const Tensor &	,
		const double &	)

◆ operator*() [12/15]

Tensor AmpGen::operator*	(	const Tensor &	,
		const Expression &	)

◆ operator*() [13/15]

TensorProxy AmpGen::operator*	(	const TensorProxy &	,
		const double &	)

◆ operator*() [14/15]

TensorProxy AmpGen::operator*	(	const TensorProxy &	,
		const Expression &	)

◆ operator*() [15/15]

TensorProxy AmpGen::operator*	(	const TensorProxy &	,
		const TensorProxy &	)

◆ operator+() [1/9]

template<typename real_t>

Complex< real_t > AmpGen::operator+	(	const Complex< real_t > &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 67 of file Complex.h.

◆ operator+() [2/9]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator+	(	const Complex< real_t > &	lhs,
		const R2_t &	rhs )

inline

Definition at line 43 of file Complex.h.

◆ operator+() [3/9]

Expression AmpGen::operator+	(	const Expression &	A,
		const Expression &	B )

◆ operator+() [4/9]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator+	(	const Expression &	A,
		const T &	B )

Definition at line 447 of file Expression.h.

◆ operator+() [5/9]

template<typename T>

KahanSum< T > AmpGen::operator+	(	const KahanSum< T > &	l,
		const T &	var )

Definition at line 28 of file KahanSum.h.

◆ operator+() [6/9]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator+	(	const R2_t &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 55 of file Complex.h.

◆ operator+() [7/9]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator+	(	const T &	A,
		const Expression &	B )

Definition at line 452 of file Expression.h.

◆ operator+() [8/9]

Tensor AmpGen::operator+	(	const Tensor &	,
		const Tensor &	)

◆ operator+() [9/9]

TensorProxy AmpGen::operator+	(	const TensorProxy &	,
		const TensorProxy &	)

◆ operator-() [1/9]

template<typename real_t>

Complex< real_t > AmpGen::operator-	(	const Complex< real_t > &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 70 of file Complex.h.

◆ operator-() [2/9]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator-	(	const Complex< real_t > &	lhs,
		const R2_t &	rhs )

inline

Definition at line 46 of file Complex.h.

◆ operator-() [3/9]

template<typename real_t>

Complex< real_t > AmpGen::operator- ( const Complex< real_t > & x )

inline

Definition at line 79 of file Complex.h.

◆ operator-() [4/9]

Expression AmpGen::operator-	(	const Expression &	A,
		const Expression &	B )

◆ operator-() [5/9]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator-	(	const Expression &	A,
		const T &	B )

Definition at line 448 of file Expression.h.

◆ operator-() [6/9]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator-	(	const R2_t &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 58 of file Complex.h.

◆ operator-() [7/9]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator-	(	const T &	A,
		const Expression &	B )

Definition at line 453 of file Expression.h.

◆ operator-() [8/9]

Tensor AmpGen::operator-	(	const Tensor &	,
		const Tensor &	)

◆ operator-() [9/9]

TensorProxy AmpGen::operator-	(	const TensorProxy &	,
		const TensorProxy &	)

◆ operator/() [1/10]

template<typename real_t>

Complex< real_t > AmpGen::operator/	(	const Complex< real_t > &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 76 of file Complex.h.

◆ operator/() [2/10]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator/	(	const Complex< real_t > &	lhs,
		const R2_t &	rhs )

inline

Definition at line 52 of file Complex.h.

◆ operator/() [3/10]

Expression AmpGen::operator/	(	const Expression &	A,
		const Expression &	B )

◆ operator/() [4/10]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator/	(	const Expression &	A,
		const T &	B )

Definition at line 450 of file Expression.h.

◆ operator/() [5/10]

template<typename real_t, typename R2_t>

Complex< real_t > AmpGen::operator/	(	const R2_t &	lhs,
		const Complex< real_t > &	rhs )

inline

Definition at line 64 of file Complex.h.

◆ operator/() [6/10]

template<class T, typename std::enable_if_t< hasConstructor< Constant, T >()>>

Expression AmpGen::operator/	(	const T &	A,
		const Expression &	B )

Definition at line 455 of file Expression.h.

◆ operator/() [7/10]

Tensor AmpGen::operator/	(	const Tensor &	,
		const double &	)

◆ operator/() [8/10]

Tensor AmpGen::operator/	(	const Tensor &	,
		const Expression &	)

◆ operator/() [9/10]

TensorProxy AmpGen::operator/	(	const TensorProxy &	,
		const double &	)

◆ operator/() [10/10]

TensorProxy AmpGen::operator/	(	const TensorProxy &	,
		const Expression &	)

◆ operator<() [1/2]

Expression AmpGen::operator<	(	const Expression &	A,
		const Expression &	B )

◆ operator<() [2/2]

bool AmpGen::operator<	(	const FitFraction &	lhs,
		const FitFraction &	rhs )

◆ operator<<() [1/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const CompiledExpressionBase &	expression )

◆ operator<<() [2/15]

template<typename real_t>

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const Complex< real_t > &	obj )

inline

Definition at line 105 of file Complex.h.

◆ operator<<() [3/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const EventType &	type )

◆ operator<<() [4/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const Expression &	expression )

◆ operator<<() [5/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const FitFraction &	obj )

◆ operator<<() [6/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const MinuitParameter &	)

◆ operator<<() [7/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const MinuitProxy &	)

◆ operator<<() [8/15]

template<typename T>

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const NamedParameter< T > &	np )

Definition at line 133 of file NamedParameter.h.

◆ operator<<() [9/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const Particle &	particle )

◆ operator<<() [10/15]

template<typename T>

std::ostream & AmpGen::operator<<	(	std::ostream &	os,
		const Property< T > &	np )

Definition at line 128 of file Property.h.

◆ operator<<() [11/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	out,
		const AmpGen::ParticleProperties &	pp )

◆ operator<<() [12/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	out,
		const ParticlePropertiesList &	ppl )

◆ operator<<() [13/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	out,
		const Tensor::Index &	index )

◆ operator<<() [14/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	st,
		const QuarkContent &	qc )

◆ operator<<() [15/15]

std::ostream & AmpGen::operator<<	(	std::ostream &	st,
		const QuarkState &	qc )

◆ operator<=()

Expression AmpGen::operator<=	(	const Expression &	A,
		const Expression &	B )

◆ operator==() [1/5]

Expression AmpGen::operator==	(	const double &	A,
		const Expression &	B )

◆ operator==() [2/5]

Expression AmpGen::operator==	(	const Expression &	A,
		const double &	B )

◆ operator==() [3/5]

Expression AmpGen::operator==	(	const Expression &	A,
		const Expression &	B )

◆ operator==() [4/5]

bool AmpGen::operator==	(	const FitFraction &	lhs,
		const FitFraction &	rhs )

◆ operator==() [5/5]

template<typename T>

bool AmpGen::operator==	(	const T &	val,
		const Property< T > &	prop )

Definition at line 125 of file Property.h.

◆ operator>() [1/2]

Expression AmpGen::operator>	(	const Expression &	A,
		const Expression &	B )

◆ operator>() [2/2]

bool AmpGen::operator>	(	const FitFraction &	lhs,
		const FitFraction &	rhs )

◆ operator>=()

Expression AmpGen::operator>=	(	const Expression &	A,
		const Expression &	B )

◆ operator||()

Expression AmpGen::operator\|\|	(	const Expression &	A,
		const Expression &	B )

◆ optionalHelpString()

template<typename... T>

std::string AmpGen::optionalHelpString	(	const std::string &	header,
		const T &...	args )

Definition at line 143 of file NamedParameter.h.

◆ parallel_accumulate()

template<class iterator, class initial_value, class functor>

initial_value AmpGen::parallel_accumulate	(	iterator	begin,
		iterator	end,
		const initial_value &	init,
		const functor &	f )

Definition at line 136 of file Utilities.h.

◆ parallel_sort() [1/2]

template<class iterator, class comparator>

void AmpGen::parallel_sort	(	iterator	begin,
		iterator	end,
		const comparator &	comp,
		const size_t &	grainsize )

Definition at line 122 of file Utilities.h.

◆ parallel_sort() [2/2]

template<class iterator>

void AmpGen::parallel_sort	(	iterator	begin,
		iterator	end,
		const size_t &	grainsize )

Definition at line 165 of file Utilities.h.

◆ parameterVector()

std::vector< Expression > AmpGen::parameterVector	(	const std::string &	name,
		const size_t &	nParam )

◆ paramVector()

std::vector< Variable > AmpGen::paramVector	(	const std::string &	name,
		const unsigned int &	nParam )

◆ parse()

template<class T>

T AmpGen::parse ( const std::string & word )

Definition at line 39 of file enum.h.

◆ phaseSpace()

Expression AmpGen::phaseSpace	(	const Expression &	s,
		const Particle &	p,
		const size_t &	l )

◆ PHI()

double AmpGen::PHI ( const Event & evt )

◆ phi()

double AmpGen::phi	(	const Event &	evt,
		int	i,
		int	j,
		int	k,
		int	w )

◆ phsp_FOCUS()

Expression AmpGen::phsp_FOCUS	(	const Expression &	s,
		const double &	m0,
		const double &	m1 )

◆ phsp_fourPi()

Expression AmpGen::phsp_fourPi ( const Expression & s )

◆ phsp_twoBody()

Expression AmpGen::phsp_twoBody	(	const Expression &	s,
		const double &	m0,
		const double &	m1 )

◆ pol()

Expression AmpGen::pol	(	const AmpGen::Expression &	X,
		const std::vector< Expression > &	p )

◆ printReleaseNotes()

void AmpGen::printReleaseNotes ( const std::string & fname )

◆ printSplash()

void AmpGen::printSplash ( )

◆ processFile()

template<typename functor_type>

void AmpGen::processFile	(	const std::string &	filename,
		functor_type &&	toDo,
		const char	ignoreLinesThatBeginWith = '#' )

Definition at line 107 of file Utilities.h.

◆ processIndex()

std::vector< size_t > AmpGen::processIndex	(	const std::vector< MatrixElement > &	tm,
		const std::string &	label )

◆ Profile()

template<int N, class FCN>

double AmpGen::Profile	(	const FCN &	fcn,
		const std::string &	name = "" )

Definition at line 27 of file ProfileClock.h.

◆ Profile2()

template<int N, class FCN>

double AmpGen::Profile2 ( const FCN & fcn )

Definition at line 54 of file ProfileClock.h.

◆ ProfileWithStat()

template<int N, class FCN>

double AmpGen::ProfileWithStat	(	const FCN &	fcn,
		const std::string &	name = "" )

Definition at line 34 of file ProfileClock.h.

◆ programatic_name()

std::string AmpGen::programatic_name ( std::string s )

◆ pythonEventTypedim()

unsigned AmpGen::python__EventType__dim ( const char * eventType )

◆ python__generate()

void AmpGen::python__generate	(	const char *	eventType,
		double *	out,
		const unsigned int	size )

Wrapper around the a phase space generator from a stringy event type to be used with python / numpy.

◆ Q2()

Expression AmpGen::Q2	(	const Expression &	Msq,
		const Expression &	M1sq,
		const Expression &	M2sq )

◆ real() [1/2]

template<typename real_t>

real_t AmpGen::real ( const Complex< real_t > & arg )

inline

Definition at line 36 of file Complex.h.

◆ real() [2/2]

template<typename real_t>

real_t AmpGen::real ( const real_t & arg )

inline

Definition at line 37 of file Complex.h.

◆ replaceAll() [1/2]

std::string AmpGen::replaceAll	(	const std::string &	input,
		const std::string &	toReplace,
		const std::string &	replaceWith )

◆ replaceAll() [2/2]

std::string AmpGen::replaceAll	(	const std::string &	input,
		const std::vector< std::pair< std::string, std::string > > &	rules )

◆ rotate() [1/2]

std::vector< double > AmpGen::rotate	(	const std::vector< double > &	input,
		const std::vector< double > &	n,
		const double &	v )

◆ rotate() [2/2]

void AmpGen::rotate	(	Event &	evt,
		const std::tuple< double, double, double > &	n,
		const double &	v )

◆ rotateBasis()

void AmpGen::rotateBasis	(	Event &	evt,
		const TVector3 &	p1,
		const TVector3 &	p2,
		const TVector3 &	p3 )

◆ round()

std::string AmpGen::round	(	const double &	number,
		const unsigned int &	nsf )

◆ rtrim()

std::string AmpGen::rtrim ( std::string s )

◆ set_tuple_from_expression()

template<typename arg_type>

void AmpGen::set_tuple_from_expression	(	arg_type &	arg,
		const Expression &	expr )

Definition at line 25 of file ExpressionParser.h.

◆ Simplify()

Expression AmpGen::Simplify ( const Expression & expression )

◆ sinh()

Expression AmpGen::sinh ( const Expression & x )

◆ slash()

Tensor AmpGen::slash ( const Tensor & P )

◆ Spin1hbProjector()

Tensor AmpGen::Spin1hbProjector ( const Tensor & B )

◆ Spin3hbProjector()

Tensor AmpGen::Spin3hbProjector ( const Tensor & A )

◆ Spin3hProjector()

Tensor AmpGen::Spin3hProjector ( const Tensor & A )

◆ split() [1/2]

std::vector< std::string > AmpGen::split	(	const std::string &	,
		char	,
		bool	= true )

◆ split() [2/2]

std::vector< std::string > AmpGen::split	(	const std::string &	,
		const std::vector< char > &	,
		bool	= false )

◆ sqrt()

template<typename real_t>

Complex< real_t > AmpGen::sqrt ( const Complex< real_t > & v )

inline

Definition at line 100 of file Complex.h.

◆ stringMatchesWildcard()

bool AmpGen::stringMatchesWildcard	(	const std::string &	input,
		const std::string &	wildcard_string,
		const char	wildcard_character = ' *' )

◆ swapChars()

void AmpGen::swapChars	(	std::string &	arg,
		const char	a,
		const char	b )

◆ tanh()

Expression AmpGen::tanh ( const Expression & x )

◆ to_double()

double AmpGen::to_double ( const Units & unit )

◆ to_string()

template<class T>

std::string AmpGen::to_string ( const T & enumItem )

Definition at line 40 of file enum.h.

◆ trim()

std::string AmpGen::trim ( const std::string & s )

◆ tupleToString()

template<typename tuple_t>

std::string AmpGen::tupleToString	(	const tuple_t &	tuple,
		const std::string &	delim )

Definition at line 32 of file Utilities.h.

◆ type_string() [1/2]

template<class TYPE>

std::string AmpGen::type_string ( )

Definition at line 17 of file MetaUtils.h.

◆ type_string() [2/2]

template<class TYPE>

std::string AmpGen::type_string ( const TYPE & )

Definition at line 25 of file MetaUtils.h.

◆ unpack()

template<typename... types>

std::tuple< types... > AmpGen::unpack ( const Expression & expression )

Definition at line 40 of file ExpressionParser.h.

◆ vecFindAll()

std::map< size_t, std::string > AmpGen::vecFindAll	(	const std::string &	input,
		const std::vector< std::string > &	vCh )

◆ vectorFromFile()

std::vector< std::string > AmpGen::vectorFromFile	(	const std::string &	filename,
		const char	ignoreLinesThatBeginWith = '#' )

◆ vectorToString() [1/2]

template<typename container_type, typename vtype = typename container_type::value_type, typename functor_type = std::function<vtype(const vtype &)>>

std::string AmpGen::vectorToString	(	const container_type &	obj,
		const std::string &	delim = "",
		const functor_type &	f = [](const auto &arg) { return arg; } )

Definition at line 39 of file Utilities.h.

◆ vectorToString() [2/2]

template<typename iterator_type, typename functor_type>

std::string AmpGen::vectorToString	(	iterator_type	begin,
		iterator_type	end,
		const std::string &	delim,
		functor_type	fcn )

Definition at line 24 of file Utilities.h.

◆ width()

Expression AmpGen::width	(	const Expression &	s,
		const Expression &	s1,
		const Expression &	s2,
		const Expression &	mass,
		const Expression &	width,
		const Expression &	radius,
		unsigned int	L,
		DebugSymbols *	dbexpressions = nullptr )

◆ wigner_D()

Expression AmpGen::wigner_D	(	const std::pair< Expression, Expression > &	P,
		const double &	J,
		const double &	lA,
		const double &	lB,
		DebugSymbols *	db )

◆ wigner_d()

Expression AmpGen::wigner_d	(	const Expression &	cb,
		const double &	j,
		const double &	m,
		const double &	n )

Variable Documentation

◆ eV

const double AmpGen::eV = 0.001 * 0.001 * 0.001

static

Definition at line 10 of file Units.h.

◆ Factory< TYPE, KEY_TYPE >::gImpl

template<class TYPE, class KEY_TYPE>

Factory<TYPE, KEY_TYPE>* AmpGen::Factory< TYPE, KEY_TYPE >::gImpl = nullptr

Definition at line 43 of file Factory.h.

◆ fs

const double AmpGen::fs = 0.001 * 0.001

static

Definition at line 16 of file Units.h.

◆ Gamma

const std::array<Tensor, 5> AmpGen::Gamma

extern

◆ GeV

const double AmpGen::GeV = 1

static

Definition at line 7 of file Units.h.

◆ I

const Expression AmpGen::I

extern

◆ KeV

const double AmpGen::KeV = 0.001 * 0.001

static

Definition at line 9 of file Units.h.

◆ MeV

const double AmpGen::MeV = 0.001

static

Definition at line 8 of file Units.h.

◆ mm

const double AmpGen::mm = 1.0

static

Definition at line 18 of file Units.h.

◆ ms

const double AmpGen::ms = 1000 * 1000

static

Definition at line 12 of file Units.h.

◆ nm

const double AmpGen::nm = 0.001 * 0.001

static

Definition at line 20 of file Units.h.

◆ ns

const double AmpGen::ns = 1

static

Definition at line 14 of file Units.h.

◆ ps

const double AmpGen::ps = 0.001

static

Definition at line 15 of file Units.h.

◆ Sigma

const std::array<Tensor, 3> AmpGen::Sigma

extern

◆ Sigma4

const std::array<Tensor, 3> AmpGen::Sigma4

extern

◆ SO3

const std::array<Tensor, 3> AmpGen::SO3

extern

◆ SU3

const std::array<Tensor, 8> AmpGen::SU3

extern

◆ TeV

const double AmpGen::TeV = 1000

static

Definition at line 6 of file Units.h.

◆ um

const double AmpGen::um = 0.001

static

Definition at line 19 of file Units.h.

◆ us

const double AmpGen::us = 1000

static

Definition at line 13 of file Units.h.

◆ Z

const Expression AmpGen::Z

extern

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Class Documentation

◆ AmpGen::CompiledExpression

◆ AmpGen::DynamicFCN

◆ AmpGen::KeyedFunctors

◆ AmpGen::LS

Typedef Documentation

◆ complex_t

◆ complex_v

◆ DebugSymbol

◆ DebugSymbols

◆ nthType

◆ real_t

◆ real_v

◆ TransformCache

◆ zeroType

Enumeration Type Documentation

◆ Alignment

◆ Strategy

Function Documentation

◆ abs()

◆ acosh()

◆ AddCPConjugate()

◆ all_combinations()

◆ arrayToFunctor()

◆ asinh()

◆ atanh()

◆ Bar()

◆ basisSpinor()

◆ basisVector()

◆ BL()

◆ BlattWeisskopf()

◆ BlattWeisskopf_Norm()

◆ bold_off()

◆ bold_on()

◆ boost()

◆ calculate_recoupling_constants()

◆ cast()

◆ conj()

◆ constructKMatrix()

◆ cosh()

◆ DECLARE_ARGUMENT() [1/18]

◆ DECLARE_ARGUMENT() [2/18]

◆ DECLARE_ARGUMENT() [3/18]

◆ DECLARE_ARGUMENT() [4/18]

◆ DECLARE_ARGUMENT() [5/18]

◆ DECLARE_ARGUMENT() [6/18]

◆ DECLARE_ARGUMENT() [7/18]

◆ DECLARE_ARGUMENT() [8/18]

◆ DECLARE_ARGUMENT() [9/18]

◆ DECLARE_ARGUMENT() [10/18]

◆ DECLARE_ARGUMENT() [11/18]

◆ DECLARE_ARGUMENT() [12/18]

◆ DECLARE_ARGUMENT() [13/18]

◆ DECLARE_ARGUMENT() [14/18]

◆ DECLARE_ARGUMENT() [15/18]

◆ DECLARE_ARGUMENT() [16/18]

◆ DECLARE_ARGUMENT() [17/18]

◆ DECLARE_ARGUMENT() [18/18]

◆ declare_enum() [1/6]

◆ declare_enum() [2/6]

◆ declare_enum() [3/6]

◆ declare_enum() [4/6]

◆ declare_enum() [5/6]

◆ declare_enum() [6/6]

◆ dot()

◆ editDistance()

◆ exp()

◆ expandGlobals()

◆ fileExists()

◆ find_next_of()

◆ findAll()

◆ findIndex()

◆ findIndices()

◆ FNV1a_hash()