Namespaces
namespace	ARM128d

namespace	AVX2d

namespace	AVX2f

namespace	AVX512d

namespace	detail

namespace	fcn

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

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	ComplexParameter

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	Coupling

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	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	MinuitParameterLink

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	Parameter
	Free parameter for expression. More...

class	ParameterTransfer

class	PartialWidthConstraint

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

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 &)

	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)

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)

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

template<typename arg_type>
rad 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< Parameter >	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) class MinuitParameter

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

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

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)

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)

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 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 int sgn=1, 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

	deg

template<class TYPE, class KEY_TYPE>
Factory< TYPE, KEY_TYPE > *	Factory< TYPE, KEY_TYPE >::gImpl = nullptr

	Dirac

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.0010.0010.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 47 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 33 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 46 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 35 of file MetaUtils.h.

Enumeration Type Documentation

◆ Alignment

enum AmpGen::Alignment

Enumerator
SoA
AoS

Definition at line 13 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 45 of file Complex.h.

◆ acosh()

Expression AmpGen::acosh ( const Expression & x )

◆ AddCPConjugate()

void AmpGen::AddCPConjugate ( MinuitParameterSet & )

◆ all_combinations()

template<typename T>

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

Definition at line 174 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 169 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 497 of file Expression.h.

◆ conj()

template<typename real_t>

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

inline

Definition at line 47 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/4]

AmpGen::declare_enum	(	coordinateType	,
		cartesian	,
		polar	)

◆ declare_enum() [2/4]

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

Definition at line 13 of file MinuitParameter.h.

◆ declare_enum() [3/4]

AmpGen::declare_enum	(	spinFormalism	,
		Covariant	,
		Canonical	)

◆ declare_enum() [4/4]

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

◆ 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 67 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 39 of file MetaUtils.h.

◆ Gamma4Vec()

Tensor AmpGen::Gamma4Vec ( )

◆ gamma_twiddle()

Tensor AmpGen::gamma_twiddle ( const Tensor & P )

◆ 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 int	sgn = 1,
		TransformCache *	cacheptr = nullptr )

◆ 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 44 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 82 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 13 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 49 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 35 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 71 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 50 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 109 of file integrate_fp.h.

◆ is()

template<class T>

bool AmpGen::is ( const Expression & expression )

Definition at line 494 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 46 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<typename return_type>

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

Definition at line 87 of file Utilities.h.

◆ lexical_cast() [2/9]

template<>

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

◆ lexical_cast() [3/9]

template<>

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

◆ lexical_cast() [4/9]

template<>

std::string 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<>

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

◆ lexical_cast() [7/9]

template<>

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

◆ lexical_cast() [8/9]

template<>

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

◆ lexical_cast() [9/9]

template<>

long int 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 78 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 )

Definition at line 359 of file DecayChainStack.h.

◆ 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 213 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 222 of file CompiledExpression.h.

◆ make_likelihood()

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

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

Definition at line 158 of file SumPDF.h.

◆ make_pdf() [1/2]

template<class FCN>

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

Definition at line 195 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:195

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 151 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 204 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 43 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 96 of file Utilities.h.

◆ nCr()

template<typename T>

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

Definition at line 46 of file Utilities.h.

◆ norm()

template<typename real_t>

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

inline

Definition at line 46 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 60 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 52 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 453 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 56 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 462 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 58 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 50 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 449 of file Expression.h.

◆ operator+() [5/9]

template<typename T>

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

Definition at line 35 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 54 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 458 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 59 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 51 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 62 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 451 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 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 460 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 61 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 53 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 455 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 57 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 464 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/13]

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

◆ operator<<() [2/13]

template<typename real_t>

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

inline

Definition at line 83 of file Complex.h.

◆ operator<<() [3/13]

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

◆ operator<<() [4/13]

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

◆ operator<<() [5/13]

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

◆ operator<<() [6/13]

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

◆ operator<<() [7/13]

template<typename T>

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

Definition at line 156 of file NamedParameter.h.

◆ operator<<() [8/13]

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

◆ operator<<() [9/13]

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

◆ operator<<() [10/13]

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

◆ operator<<() [11/13]

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

◆ operator<<() [12/13]

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

◆ operator<<() [13/13]

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

◆ operator<=()

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

◆ operator==() [1/4]

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

◆ operator==() [2/4]

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

◆ operator==() [3/4]

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

◆ operator==() [4/4]

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

◆ 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 167 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 153 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 133 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 194 of file Utilities.h.

◆ parameterVector()

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

◆ paramVector()

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

◆ parse()

template<class T>

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

Definition at line 27 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 115 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 30 of file ProfileClock.h.

◆ Profile2()

template<int N, class FCN>

double AmpGen::Profile2 ( const FCN & fcn )

Definition at line 59 of file ProfileClock.h.

◆ ProfileWithStat()

template<int N, class FCN>

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

Definition at line 38 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 42 of file Complex.h.

◆ real() [2/2]

template<typename real_t>

real_t AmpGen::real ( const real_t & arg )

inline

Definition at line 43 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>

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

Definition at line 26 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 72 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_string()

template<class T>

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

Definition at line 28 of file enum.h.

◆ trim()

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

◆ type_string() [1/2]

template<class TYPE>

std::string AmpGen::type_string ( )

Definition at line 18 of file MetaUtils.h.

◆ type_string() [2/2]

template<class TYPE>

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

Definition at line 28 of file MetaUtils.h.

◆ unpack()

template<typename... types>

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

Definition at line 36 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 41 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 25 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

◆ deg

AmpGen::deg

Definition at line 24 of file ExpressionParser.h.

◆ Dirac

AmpGen::Dirac

Definition at line 100 of file Particle.h.

◆ eV

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

static

Definition at line 11 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 51 of file Factory.h.

◆ fs

const double AmpGen::fs = 0.001*0.001

static

Definition at line 17 of file Units.h.

◆ Gamma

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

extern

◆ GeV

const double AmpGen::GeV = 1

static

Definition at line 8 of file Units.h.

◆ I

const Expression AmpGen::I

extern

◆ KeV

const double AmpGen::KeV = 0.001*0.001

static

Definition at line 10 of file Units.h.

◆ MeV

const double AmpGen::MeV = 0.001

static

Definition at line 9 of file Units.h.

◆ mm

const double AmpGen::mm = 1.0

static

Definition at line 19 of file Units.h.

◆ ms

const double AmpGen::ms = 1000*1000

static

Definition at line 13 of file Units.h.

◆ nm

const double AmpGen::nm = 0.001*0.001

static

Definition at line 21 of file Units.h.

◆ ns

const double AmpGen::ns = 1

static

Definition at line 15 of file Units.h.

◆ ps

const double AmpGen::ps = 0.001

static

Definition at line 16 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 7 of file Units.h.

◆ um

const double AmpGen::um = 0.001

static

Definition at line 20 of file Units.h.

◆ us

const double AmpGen::us = 1000

static

Definition at line 14 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/4]

◆ declare_enum() [2/4]

◆ declare_enum() [3/4]

◆ declare_enum() [4/4]

◆ dot()

◆ editDistance()

◆ exp()

◆ expandGlobals()

◆ fileExists()

◆ find_next_of()

◆ findAll()

◆ findIndex()

◆ findIndices()

◆ FNV1a_hash()

◆ for_each()

◆ Gamma4Vec()