Classes
class	AmplitudeComponent

class	StaticAmplitudeComponent

class	RecalculableAmplitudeComponent

class	BlattWeisskopf
	Class implementing BlattWeisskopf barrier factors. More...

class	BreitWigner
	Class for Breit-Wigner resonance shape. More...

class	CachedValue
	Class for managing cached values inside a DataPoint. More...

class	RealCachedValue
	Class for managing a single real cached value inside a #DataPoint. More...

class	ComplexCachedValue
	Class for managing a complex cached value inside a #DataPoint. More...

class	FourVectorCachedValue
	Class for managing a four-vector cached value inside a #DataPoint. More...

struct	CompensatedSum
	Struct to calculate a compensated sum using the Kahan summation algorithm. More...

class	DataAccessor
	Abstract base class for all objects accessing DataPoint's. More...

class	DataIterator
	Class for iterating over a DataPartition. More...

class	DataPartition
	Class defining a partition of the DataSet. More...

class	DataPartitionWeave
	Partition that iterates from begin to end jumping a specified spacing every increase. More...

class	DataPartitionBlock
	A contiguous block of data. More...

class	DataPoint
	Class for holding data and cached values per data point for fast calculation. More...

class	DataSet
	Class holding a set of DataPoint objects. More...

class	DecayChannel
	Class implementing a decay channel. More...

class	DecayingParticle

class	DecayTree
	Class holding vectors of fixed and free amplitudes that define a decay tree. More...

class	DecayTreeVectorIntegral
	Stores integral components for a vector of decay trees. More...

class	filter_decay_tree
	helper base class for functor classes that can filter DecayTree's More...

class	filter_free_amplitude
	helper base class for functor classes that can filter FreeAmplitude's More...

class	filter_decay_channel
	helper base class for functor classes that can filter DecayChannel's More...

class	filter_spin_amplitude
	helper base class for functor classes that can filter SpinAmplitude's More...

class	filter_particle
	helper base class for filtering Particle's More...

class	filter_decaying_particle
	helper base class for filtering DecayingParticle's More...

class	filter_resonance
	helper base class for filtering Resonance's More...

class	filter_mass_shape
	helper base class for filtering MassShape's More...

class	has_decay_channel
	Functor class for filtering by decay channel. More...

class	has_spin_amplitude
	Functor class for filtering by spin amplitude. More...

class	to
	Functor class for filtering by particle content. More...

class	exactly_to
	Functor class for filtering by exact particle content. More...

class	l_equals
	Functor object for filtering by orbital angular momentum. More...

class	m_equals
	Functor object for filtering by spin projection. More...

class	is_named
	Functor class for filtering objects that have a #name() function. More...

class	has_decay_tree
	Functor class for checking if DecayingParticle has specified DecayTree. More...

class	has_free_amplitude
	Functor class for checking whether objects have a particular free amplitude. More...

class	from
	Functor object for filtering by parent particle. More...

class	has_mass
	Functors return true if particle is a final state particle or if a mass shape can be found that inherits from MassShapeWithNominalMass. More...

class	FinalStateParticle
	Class representing a final-state particle. More...

class	Flatte
	Class for Flatte resonance shape. More...

struct	FlatteChannel
	Stores information on channel used in calculating Flatte mass shape. More...

class	FourMomenta
	Stores and gives access to four-momenta and invariant masses. More...

class	FourVector
	Four-Vector handling. More...

class	FreeAmplitude
	Stores complex free amplitude for the particular decay of a particle. More...

class	HelicityAngles
	Calculates, stores and gives access to helicity angles. More...

class	HelicitySpinAmplitude
	Class implementing a canonical spin amplitude, i.e. with defined relative angular momentum. More...

class	HelicityFormalism
	Caches HelicitySpinAmplitude's. More...

class	ImportanceSampler
	Calculates DecayTreeVectorIntegral using importance sampling. More...

class	IntegralElement
	Holds the values of a component of an integral. More...

class	Integrator
	Integrates a model. More...

class	MassAxes
	ParticleCombinationVector specialized to contain axes for defining a phase-space coordinate. More...

class	MassShape
	Abstract base class for all mass shapes. More...

class	MassShapeWithNominalMass
	Class for MassShape that gets its nominal mass from its owning resonance. More...

class	Matrix

class	MeasuredBreakupMomenta
	Calculates, stores and gives access to breakup momenta (using measured masses) More...

class	Model
	Class implementing a PWA model. More...

class	ModelIntegral
	Stores integral of a full model. More...

class	ParameterBase
	Class holding basic properties of a parameter, but not a value! More...

class	Parameter
	Template class holding also a value for a parameter. More...

class	RealParameter

class	ComplexParameter

class	ComplexComponentParameter
	Abstract base allowing access to the components of a ComplexParameter as a RealParameter. More...

class	RealComponentParameter
	RealParameter accessing real component of ComplexParameter. More...

class	ImaginaryComponentParameter
	ImaginaryParameter accessing imaginary component of ComplexParameter. More...

class	Particle
	Abstract Particle base class. More...

class	ParticleCombination
	Stores combinations of particle indices. More...

class	ParticleCombinationCache
	Caches list of ParticleCombination's. More...

struct	ParticleTableEntry
	Data container for storing particle information in database. More...

class	ParticleFactory
	Factory class for easy creation of Particle objects from PDG codes. More...

class	PDLIterator

class	PhaseSpaceFactor

class	PhaseSpaceFactorFactory

class	PoleMass
	Class for pole-mass resonance shape. More...

class	QuantumNumbers
	Quantum numbers of a Particle. More...

class	RecalculableDataAccessor

class	RelativisticBreitWigner
	Class for Relativistic Breit-Wigner resonance shape. More...

class	RequiresHelicityAngles
	Base class to be inherited from to denote that an object requires a model calculate helicity angles. More...

class	RequiresMeasuredBreakupMomenta

class	Resonance
	Class for a particle that will decay and has a mass shape. More...

class	SpinAmplitude
	Abstract base class implementing a spin amplitude. More...

class	SpinAmplitudeCache
	Caches SpinAmplitudes. More...

class	StaticDataAccessor
	Base class for all data accessors that will only write to DataPoint once at initial data loading. More...

class	StatusManager

class	TwoBodyPhaseSpaceFactor

class	TwoBodyPhaseSpaceFactorFactory

class	UnitSpinAmplitude
	Implements a spin amplitude that always returns Complex_1. More...

class	VectorIterator
	Iterator for Vector class. More...

class	VectorExpression
	Class for holding vector expressions. More...

class	Vector
	N-dimensional column vector. More...

class	VectorAddition
	Expression for addition of two VectorExpressions. More...

class	VectorSubtraction
	Expression for subtraction of two VectorExpressions. More...

class	Wave
	Class for description of intensity in a set of quantum numbers. More...

class	WeakPtrCache
	Template for a cache of weak_ptr's to objects. More...

class	ZemachSpinAmplitude
	Class implementing Zemach tensors. More...

class	ZemachFormalism
	Caches ZemachSpinAmplitude's. More...

Enumerations
enum	CalculationStatus : bool { calculated = true, uncalculated = false }

enum	VariableStatus : int { changed = -1, fixed = 0, unchanged = +1 }

Functions
const double	squared_barrier_factor (unsigned l, double z)

bool	operator== (const CachedValue::Status &S, const CalculationStatus &s)
	equality operator for checking the CalculationStatus

bool	operator!= (const CachedValue::Status &S, const CalculationStatus &s)
	inequality operator for checking the CalculationStatus

bool	operator== (const CachedValue::Status &S, const VariableStatus &s)
	equality operator for checking the VariableStatus

bool	operator!= (const CachedValue::Status &S, const VariableStatus &s)
	inequality operator for checking the VariableStatus

std::string	to_string (const CachedValue::Status &S)
	streaming operator for CachedValue::Status

std::string	to_string (const CalculationStatus &c)

template<typename T , size_t N>
std::string	to_string (const CoordinateSystem< T, N > &C)

template<typename T , size_t N>
const CoordinateSystem< T, N >	unit (const CoordinateSystem< T, N > &C)

template<typename T , size_t N>
const CoordinateSystem< T, N >	operator* (const SquareMatrix< T, N > &M, const CoordinateSystem< T, N > &C)

void	remove_expired (DataAccessorSet &S)
	remove expired elements of set

const DataIterator	operator+ (DataIterator lhs, DataIterator::difference_type n)
	addition operator

const DataIterator	operator+ (DataIterator::difference_type n, const DataIterator &rhs)
	addition operator

const DataIterator	operator- (const DataIterator &lhs, DataIterator::difference_type n)
	subraction operator

const bool	operator<= (const DataIterator &lhs, const DataIterator &rhs)
	less-than-or-equal operator

const bool	operator>= (const DataIterator &lhs, const DataIterator &rhs)
	greater-than-or-equal operator

const bool	operator!= (const DataIterator &lhs, const DataIterator &rhs)
	inequality operator

const int	charge (const DecayChannel &dc)

std::string	to_string (const DecayChannel &dc)
	convert to string

std::ostream &	operator<< (std::ostream &os, const DecayChannel &dc)
	<< operator

std::string	to_string (const DecayTreeVectorMap &m_dtv_map)
	convert to (multiline) string

DecayTreeSet	decay_trees (const DecayingParticle &dp)

template<typename Last , typename... Predicates>
DecayTreeSet	decay_trees (const DecayingParticle &dp, Last p, Predicates...P)

template<typename Last , typename... Predicates>
DecayTreeSet::value_type	decay_tree (const DecayingParticle &dp, Last p, Predicates...P)

FreeAmplitudeSet	free_amplitudes (const DecayingParticle &dp)

template<typename Last , typename... UnaryPredicates>
FreeAmplitudeSet	free_amplitudes (const DecayingParticle &dp, Last p, UnaryPredicates...P)

template<typename Last , typename... UnaryPredicates>
FreeAmplitudeSet::value_type	free_amplitude (const DecayingParticle &dp, Last p, UnaryPredicates...P)

ParticleSet	particles (DecayingParticle &dp)

template<typename Last , typename... UnaryPredicates>
DecayChannelSet	decay_channels (const DecayingParticle &dp, Last p, UnaryPredicates...P)

template<typename Last , typename... UnaryPredicates>
DecayChannelSet::value_type	decay_channel (const DecayingParticle &dp, Last p, UnaryPredicates...P)

std::string	to_string (const DecayTree &dt, std::string offset="")
	convert to (multiline) string

std::string	to_string (const DecayTreeVector &dtv)
	convert to (mutliline string)

bool	operator== (const DecayTree &lhs, const DecayTree &rhs)
	equality operator

unsigned	depth (const DecayTree &DT)

const std::complex< double >	amplitude (const DecayTree &dt, const DataPoint &d)

const std::complex< double >	amplitude (const DecayTree &dt, const DataPoint &d, const std::shared_ptr< ParticleCombination > &pc)

const std::complex< double >	amplitude (const DecayTreeVector &dtv, const DataPoint &d)

const double	intensity (const DecayTreeVector &dtv, const DataPoint &d)

FreeAmplitudeSet	free_amplitudes (const DecayTree &DT)

FreeAmplitudeSet	free_amplitudes (const DecayTreeVector &DTV)

const bool	has_changed (const std::shared_ptr< DecayTree > &dt)

const DecayTreeVector	select_changed (const DecayTreeVector &dtv)

const RealIntegralElement	integral (const DecayTreeVectorIntegral &dtvi)

const ComplexIntegralElementMatrix	cached_integrals (const DecayTreeVectorIntegral &dtvi)

const ComplexIntegralElementMatrix	integrals (const DecayTreeVectorIntegral &dtvi)

const RealIntegralElementVector	diagonal_integrals (const DecayTreeVectorIntegral &dtvi)

const RealIntegralElementVector	fit_fractions (const DecayTreeVectorIntegral &dtvi)

template<typename container >
container::value_type	lone_elt (container &C)

template<typename container >
container::value_type	lone_elt (container &&C)

template<typename T , typename Last , typename... UnaryPredicates>
std::set< std::shared_ptr< T > >	filter (const std::set< std::shared_ptr< T > > &S, Last p, UnaryPredicates...P)

template<typename T >
const std::set < std::shared_ptr< T > > &	filter (const std::set< std::shared_ptr< T > > &S)

template<class F , typename T >
const bool	by_ptr (const F &f, const std::shared_ptr< T > &ptr)

template<class F , typename T >
const bool	by_ptr (const F &f, const T *ptr)

bool	valid_final_state (const std::shared_ptr< ParticleCombination > &pc, const FinalStateParticleVector &FSPs)

std::vector< FourVector< double > >	calculate_four_momenta (double initial_mass, const FinalStateParticleVector &FPSs, const MassAxes &axes, const std::vector< double > &squared_masses)

std::vector< FourVector< double > >	calculate_four_momenta (double initial_mass, const Model &M, const MassAxes &axes, const std::vector< double > &squared_masses)

template<typename T >
constexpr ThreeVector< T >	vect (const FourVector< T > &V) noexcept

template<typename T >
constexpr ThreeVector< T >	boost (const FourVector< T > &V)

template<typename T >
constexpr FourVector< T >	operator- (const FourVector< T > &V)

template<typename T >
const std::vector< FourVector < T > >	operator- (const std::vector< FourVector< T > > &V)

template<typename T >
constexpr FourVector< T >	operator* (const FourMatrix< T > &R, const FourVector< T > &V)
	multiply a 4x4 matrix times a FourVector

template<typename T >
const std::vector< FourVector < T > >	operator* (const FourMatrix< T > &R, const std::vector< FourVector< T > > &V)
	multiply a 4x4 matrix times each of a vector of FourVector's

template<typename T >
constexpr FourVector< T >	operator* (const ThreeMatrix< T > &R, const FourVector< T > &V)
	apply a three-rotation to a FourVector (rotating only the spatial components)

template<typename T >
const std::vector< FourVector < T > >	operator* (const ThreeMatrix< T > &R, const std::vector< FourVector< T > > &V)
	multiply a 3x3 matrix times the spacial components of each of a vector of FourVector's

template<typename T >
const CoordinateSystem< T, 3 >	helicityFrame (const FourVector< T > &V, const CoordinateSystem< T, 3 > &C)

std::string	to_string (const FreeAmplitude &fa)
	convert to string

template<typename T >
CoordinateSystem< T, 3 >	helicityFrame (const ThreeVector< T > &V, const CoordinateSystem< T, 3 > &C)

template<typename T >
const IntegralElement< T >	operator+ (IntegralElement< T > A, const IntegralElement< T > &B)

template<typename T >
const IntegralElement< T >	operator- (IntegralElement< T > A, const IntegralElement< T > &B)

template<typename T >
const IntegralElement< T >	operator* (IntegralElement< T > A, const IntegralElement< T > &B)

template<typename T >
const IntegralElement< T >	operator/ (IntegralElement< T > A, const IntegralElement< T > &B)

template<typename T >
std::string	to_string (const IntegralElement< T > &a)

void	disableLogs (el::Level lvl)

void	plainLogs (el::Level lvl)

template<typename T >
const FourMatrix< T >	lorentzTransformation (const ThreeMatrix< T > &R)

template<typename T >
const FourMatrix< T >	lorentzTransformation (const FourVector< T > &V)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const ThreeVector< T > &V)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const std::vector< FourVector< T > > &fourVecs)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const ThreeMatrix< T > &R, const FourVector< T > &V)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const ThreeMatrix< T > &R, const ThreeVector< T > &V)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const FourVector< T > &V, const ThreeMatrix< T > R)

template<typename T >
constexpr FourMatrix< T >	lorentzTransformation (const ThreeVector< T > &V, const ThreeMatrix< T > &R)

std::string	to_string (const MassAxes &A)
	convert to string

const MassRange	mass_range (double isp_mass, const std::shared_ptr< ParticleCombination > &pc, const FinalStateParticleVector &FSPs)

const std::vector< MassRange >	mass_range (double isp_mass, const MassAxes &A, const FinalStateParticleVector &FSPs)

const MassRange	squared (MassRange mr)

const std::vector< MassRange >	squared (std::vector< MassRange > mr)

constexpr bool	is_odd (int val)
	Math Utilities. More...

constexpr bool	is_even (int val)

template<typename T >
std::enable_if< std::is_signed < T >::value, T >::type constexpr	signum (const T &val)
	extracts sign from value

constexpr int	pow_negative_one (int exponent)
	optimized function for (-1)^n

template<typename T , size_t R, size_t C>
std::string	to_string (const Matrix< T, R, C > &M)

template<typename T , size_t N>
const SquareMatrix< T, N >	zeroMatrix ()
	zero square matrix

template<typename T , size_t R, size_t C>
const Matrix< T, R, C >	zeroMatrix ()
	zero matrix

template<typename T , size_t N>
const SquareMatrix< T, N >	unitMatrix ()
	unit matrix

template<typename T , size_t N>
const SquareMatrix< T, N >	diagonalMatrix (std::array< T, N > d)
	diagonal matrix

template<typename T , size_t N>
const SquareMatrix< T, N >	symmetricMatrix (std::initializer_list< T > elements)

template<typename T , size_t R, size_t C>
const Matrix< T, C, R >	transpose (const Matrix< T, R, C > &M)
	transpose a matrix

template<typename T , size_t R, size_t C>
const Matrix< T, C, R >	operator- (const Matrix< T, R, C > &M)
	unary minus

template<typename T , size_t R, size_t K, size_t C>
std::enable_if< (R!=1) or(C!=1), Matrix< T, R, C > >::type const	operator* (const Matrix< T, R, K > &A, const Matrix< T, K, C > &B)
	matrix multiplication

template<typename T1 , typename T2 , size_t R, size_t K, size_t C>
auto	operator* (const Matrix< T1, R, K > &A, const Matrix< T2, K, C > &B) -> const typename std::enable_if< (R!=1) or(C!=1), Matrix< typename std::remove_cv< decltype(operator*(A[0][0], B[0][0]))>::type, R, C > >::type

template<typename T , size_t K>
const T	operator* (const Matrix< T, 1, K > &A, const Matrix< T, K, 1 > &B)
	matrix multiplication yielding single value

template<typename T , size_t R, size_t C>
Matrix< T, R, C > &	operator*= (Matrix< T, R, C > &M, const T &c)
	assignment by multiplication by a single element

template<typename T1 , typename T2 , size_t R, size_t C>
Matrix< T2, R, C > &	operator*= (Matrix< T2, R, C > &M, const T1 &c)
	assignment by multiplication by a single element with different template types

template<typename T , size_t R, size_t C>
const Matrix< T, R, C >	operator* (const T &c, const Matrix< T, R, C > &M)
	multiplication by a single element

template<typename T1 , typename T2 , size_t R, size_t C>
const Matrix< T2, R, C >	operator* (const T1 &c, const Matrix< T2, R, C > &M)
	multiplication by a single element with different template types

template<typename T1 , typename T2 , size_t R, size_t C>
const Matrix< T2, R, C >	operator* (const Matrix< T1, R, C > &M, const T2 &c)
	multiplication by a single element with different template types

template<typename T , size_t R, size_t C>
Matrix< T, R, C > &	operator+= (Matrix< T, R, C > &lhs, const Matrix< T, R, C > &rhs)
	addition assignment

template<typename T , size_t R, size_t C>
const Matrix< T, R, C >	operator+ (const Matrix< T, R, C > &lhs, const Matrix< T, R, C > &rhs)
	addition

template<typename T , size_t R, size_t C>
Matrix< T, R, C > &	operator-= (Matrix< T, R, C > &lhs, const Matrix< T, R, C > &rhs)
	subtraction assignment

template<typename T , size_t R, size_t C>
const Matrix< T, R, C >	operator- (const Matrix< T, R, C > &lhs, const Matrix< T, R, C > &rhs)
	subtraction

template<typename T , size_t N>
const SquareMatrix< T, N-1 >	minor_matrix (const SquareMatrix< T, N > &M, size_t r, size_t c)

template<typename T , size_t N>
const T	minor_det (const SquareMatrix< T, N > &M, size_t r, size_t c)

template<typename T , size_t N>
const T	cofactor (const SquareMatrix< T, N > &M, size_t r, size_t c)

template<typename T , size_t N>
const T	det (SquareMatrix< T, N > M)

template<typename T , size_t M, size_t N>
const SquareMatrix< T, M >	diagonal_minor (const SquareMatrix< T, N > m, std::vector< size_t > indices)
	diagonal minor matrix

template<typename T , size_t N>
const T	trace (const SquareMatrix< T, N > &M)
	trace

constexpr double	squared_breakup_momentum (double m2_R, double m_a, double m_b)

std::string	to_string (const AdmixtureMap &mix)

const bool	decays_to_full_final_state (const Particle &p)

std::vector< std::shared_ptr < DecayingParticle > >	full_final_state_isp (const Model &M)

const double	intensity (const InitialStateParticleMap::value_type &isp_mix, const DataPoint &d)

const double	intensity (const InitialStateParticleMap &isp_map, const DataPoint &d)

const double	sum_of_log_intensity (const Model &M, DataPartition &D, double ped=0)

const double	sum_of_log_intensity (const Model &M, DataPartitionVector &DP, double ped=0)

FreeAmplitudeSet	free_amplitudes (const Model &M)

template<typename Last , typename... UnaryPredicates>
FreeAmplitudeSet	free_amplitudes (const Model &M, Last p, UnaryPredicates...P)

template<typename Last , typename... UnaryPredicates>
FreeAmplitudeSet::value_type	free_amplitude (const Model &M, Last p, UnaryPredicates...P)

ParticleSet	particles (const Model &M)

template<typename Last , typename... UnaryPredicates>
ParticleSet	particles (const Model &M, Last p, UnaryPredicates...P)

template<typename Last , typename... UnaryPredicates>
ParticleSet::value_type	particle (const Model &M, Last p, UnaryPredicates...P)

const RealIntegralElement	integral (const ModelIntegral &MI)

template<typename IterType >
constexpr VariableStatus	variable_status (IterType first, IterType last)

template<typename T >
std::string	to_string (const Parameter< T > &P)

const size_t	size (const ParameterVector &V)

template<class InputIt >
std::vector< double > ::const_iterator	set_value (ParameterBase &P, InputIt first)

template<class InputIt >
void	set_values (ParameterVector::iterator first_par, ParameterVector::iterator last_par, InputIt first_val, InputIt last_val)
	set values in ParameterVector from iterators

void	set_values (ParameterVector &pars, const std::vector< double > &vals)
	set values in ParameterVector from values in vector<double>

const SpinVector	spins (const ParticleVector &v)

std::string	to_string (const Particle &p)
	convert to string

std::string	to_string (const ParticleVector &p)
	convert to string

std::ostream &	operator<< (std::ostream &os, const Particle &p)
	streamer

bool	disjoint (const ParticleCombinationVector &pcv)

const bool	is_final_state_particle_combination (const ParticleCombination &pc)

const ParticleCombination &	origin (const ParticleCombination &pc)

const bool	is_initial_state_particle_combination (const ParticleCombination &pc, const Model &m)

const bool	is_from_initial_state_particle_combination (const ParticleCombination &pc, const Model &m)

void	prune_particle_combinations (ParticleCombinationSet &PCs)
	only keep particleCombinations with the highest number of indices in their top-most parent

std::string	indices_string (const ParticleCombination &pc, std::string before="(", std::string after=")")
	Get indices listed as string.

std::string	to_string (const ParticleCombination &pc)
	convert ParticleCombination to string

std::string	to_string_with_parent (const ParticleCombination &pc)
	convert ParticleCombination with top-most parent to string

std::ostream &	operator<< (std::ostream &os, const ParticleCombination &PC)
	streamer

const bool	operator!= (const PDLIterator &lhs, const PDLIterator &rhs)
	inequality operator

ParticleFactory	read_pdl_file (const std::string &filename)

std::vector< std::vector < size_t > >	combinations (size_t N, size_t n, const std::vector< std::vector< size_t > > &C=std::vector< std::vector< size_t > >())

template<typename T , size_t N>
T	delta (const SquareMatrix< T, N > &M, size_t l)

template<typename T , size_t N>
bool	check_deltas (const SquareMatrix< T, N > &M)

template<class Generator >
const std::vector< FourVector < double > >	phsp (const Model &M, double initial_mass, const MassAxes &A, const std::vector< MassRange > &R2, Generator &g, unsigned max_attempts)

bool	operator== (const QuantumNumbers &lhs, const QuantumNumbers &rhs)
	equality operator

bool	operator!= (const QuantumNumbers &lhs, const QuantumNumbers &rhs)
	inequality operator

std::string	to_string (const QuantumNumbers &Q)
	convert to string

std::string	debug_string (const QuantumNumbers &Q)
	convert to string

std::ostream &	operator<< (std::ostream &os, const QuantumNumbers &Q)
	Overload << operator.

template<typename T >
const ThreeMatrix< T >	rotation (const ThreeVector< T > &V, const T &theta)

template<typename T >
const ThreeMatrix< T >	eulerRotationZXZ (const CoordinateSystem< T, 3 > &C, const T &alpha, const T &beta, const T &gamma)

template<typename T >
const ThreeMatrix< T >	eulerRotationZYZ (const CoordinateSystem< T, 3 > &C, const T &alpha, const T &beta, const T &gamma)

std::string	spin_to_string (int twoJ)
	convert 2*J to string (e.g. 1/2, 1, 3/2, etc.)

std::string	to_string (const SpinVector &two_j)
	convert SpinVector to string

std::string	to_string (const SpinProjectionVector &two_m)
	convert SpinVector to string

constexpr bool	triangle (unsigned two_a, unsigned two_b, unsigned two_c)

constexpr bool	conserves (unsigned two_J, unsigned two_j1, unsigned two_j2, int l)

const SpinProjectionVector	projections (unsigned two_j)

const std::vector < SpinProjectionVector >	projections (const SpinVector &two_J)

std::string	to_string (const SpinAmplitude &sa)
	convert to string

std::ostream &	operator<< (std::ostream &os, const SpinAmplitude &sa)
	<< operator

std::string	to_string (const SpinAmplitudeVector &saV)
	convert to string

void	remove_expired (StaticDataAccessorVector &S)
	remove expired elements of set

template<typename T >
constexpr ThreeVector< T >	cross (const ThreeVector< T > &A, const ThreeVector< T > &B) noexcept

template<typename T >
constexpr SquareMatrix< T, 3 >	skewSymmetric (const ThreeVector< T > V) noexcept
	skew symmetric matrix formed from a 3 vector

std::string	to_string (const VariableStatus &s)

template<typename T , size_t N>
const VectorIterator< T, N >	operator+ (VectorIterator< T, N > a, typename VectorIterator< T, N >::difference_type n)
	addition operator

template<typename T , size_t N>
const VectorIterator< T, N >	operator+ (typename VectorIterator< T, N >::difference_type n, VectorIterator< T, N > a)
	addition operator

template<typename T , size_t N>
const VectorIterator< T, N >	operator- (VectorIterator< T, N > a, typename VectorIterator< T, N >::difference_type n)
	subtraction operator

template<typename T , size_t N>
bool	operator>= (VectorIterator< T, N > a, VectorIterator< T, N > b)
	greater-than-or-equal operator

template<typename T , size_t N>
bool	operator<= (VectorIterator< T, N > a, VectorIterator< T, N > b)
	less-than-or-equal operator

template<typename T , size_t N, typename E1 , typename E2 >
constexpr VectorAddition< T, N, E1, E2 >	operator+ (const VectorExpression< T, N, E1 > &a, const VectorExpression< T, N, E2 > &b)
	addition of two vectors

template<typename T , size_t N, typename E1 , typename E2 >
constexpr VectorSubtraction< T, N, E1, E2 >	operator- (const VectorExpression< T, N, E1 > &a, const VectorExpression< T, N, E2 > &b)
	subtraction of two vectors

template<typename T , size_t N>
std::string	to_string (const Vector< T, N > &V)

template<typename T , size_t N>
std::ostream &	operator<< (std::ostream &os, const Vector< T, N > &V)
	streamer

template<typename T , size_t N>
Vector< T, N > &	operator+= (Vector< T, N > &A, const Vector< T, N > &B)
	addition assignment

template<typename T , size_t N>
constexpr Vector< T, N >	operator- (const Vector< T, N > &V)
	unary minus

template<typename T , size_t N>
Vector< T, N > &	operator-= (Vector< T, N > &A, const Vector< T, N > &B)
	subtraction assignment

template<typename T , size_t N>
Vector< T, N > &	operator*= (Vector< T, N > &A, const T &B)
	(assignment) multiplication by a single element

template<typename T , size_t N>
const Vector< T, N >	operator* (const Vector< T, N > &A, const T &c)
	multiplication: #Vector<T> * T

template<typename T , size_t N>
constexpr Vector< T, N >	operator* (const T &c, const Vector< T, N > &A)
	multiplication: T * #Vector<T>

template<typename T , size_t N>
Vector< T, N > &	operator/= (Vector< T, N > &A, const T &B)
	(assignment) division by a single element

template<typename T , size_t N>
const Vector< T, N >	operator/ (const Vector< T, N > &A, const T &c)
	division: #Vector<T> / T

template<typename T , size_t N>
constexpr T	abs (const Vector< T, N > &A)

template<typename T , size_t N>
const Vector< T, N >	unit (const Vector< T, N > &V)

template<typename T , size_t R, size_t C>
const Vector< T, R >	operator* (const Matrix< T, R, C > &M, const Vector< T, C > &V)
	Matrix * Vector.

template<typename T1 , typename T2 , size_t R, size_t C>
auto	operator* (const Matrix< T1, R, C > &M, const Vector< T2, C > &V) -> const Vector< typename std::remove_cv< decltype(operator*(M[0][0], V[0]))>::type, R >
	Matrix * Vector with different template types.

template<typename T , size_t N>
const SquareMatrix< T, N >	outer (const Vector< T, N > &A, const Vector< T, N > &B)
	outer product

template<class T >
std::ostream &	operator<< (std::ostream &os, const WeakPtrCache< T > &C)
	streamer

const double	dFunction (unsigned twoJ, int twoM, int twoN, double beta)

const std::complex< double >	DFunction (unsigned twoJ, int twoM, int twoN, double alpha, double beta, double gamma)
	Wigner D-function $D^{J}_{M N}(\alpha, \beta, \gamma)$ .

const DataIterator::difference_type	operator- (const DataIterator &lhs, const DataIterator &rhs)

bool	equalStructure (const DataPoint &A, const DataPoint &B)

ParticleSet	particles (const DecayChannel &dc)

bool	is_decaying_particle (const Particle &p)

std::shared_ptr< FreeAmplitude >	free_amplitude (const DecayTree &dt)

bool	is_final_state_particle (const Particle &p)

std::ostream &	print_mp_string (std::ostream &os, unsigned n, unsigned m_p, std::shared_ptr< ParticleCombination > pc, double m, FourVector< double > p, double M=-1)

bool	check_invariant_masses (const MassAxes &axes, const std::vector< double > &squared_masses, const std::vector< FourVector< double > > &fourMomenta)

const FinalStateParticleVector::value_type &	fsp_with_index (const FinalStateParticleVector &FSPs, unsigned i)

RealParameter &	mass_parameter (Particle &p)

const double	sum_of_logs_of_intensities (const Model &M, DataPartition &D, double ped)

AdmixtureMap	admixture_map (const DecayTreeVectorMap &dtvm)

size_t	all_fixed (const AdmixtureMap &mix)

std::ostream &	print_daughters (std::ostream &os, const ParticleCombinationCache &C, std::shared_ptr< ParticleCombination > pc, unsigned ndig, std::string prefix, std::set< unsigned > &used)

const bool	is_resonance (const Particle &p)

bool	equal_zemach (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)

real constants
template<typename T = double>
constexpr T	pi ()
	pi

template<typename T = double>
constexpr T	rad_per_deg ()
	convert degrees to radians

template<typename T >
constexpr T	rad (const T &d)
	convert degrees to radians

template<typename T = double>
constexpr T	deg_per_rad ()
	convert radians to degrees

template<typename T >
constexpr T	deg (const T &r)
	convert radians to degrees

Specifically for 3D systems
template<typename T >
constexpr bool	isRightHanded (const CoordinateSystem< T, 3 > &C)

template<typename T >
constexpr bool	isLeftHanded (const CoordinateSystem< T, 3 > &C)

template<typename T >
constexpr T	phi (const ThreeVector< T > &V, const CoordinateSystem< T, 3 > &C)

template<typename T >
constexpr T	theta (const ThreeVector< T > &V, const CoordinateSystem< T, 3 > &C)

template<typename T >
constexpr std::array< T, 2 >	angles (const ThreeVector< T > &V, const CoordinateSystem< T, 3 > &C)

operations on ComplexIntegralElement
ComplexIntegralElement	conj (const ComplexIntegralElement &Z)

RealIntegralElement	real (const ComplexIntegralElement &Z)

RealIntegralElement	imag (const ComplexIntegralElement &Z)

ParticleCombinationEqualTo functions
constexpr bool	equal_always (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination, returning true always

bool	equal_by_shared_pointer (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by shared_ptr only

bool	equal_by_ordered_content (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by indices only

bool	equal_by_orderless_content (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by indices, disregarding order

bool	equal_down (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by checking selves and then all daughters

bool	equal_up (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by checking selves and then parents

bool	equal_up_and_down (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)
	compare shared_ptr's to ParticleCombination by checking selves, daughters, and parents

bool	equal_down_by_orderless_content (const std::shared_ptr< const ParticleCombination > &A, const std::shared_ptr< const ParticleCombination > &B)

Variables
std::shared_ptr < PhaseSpaceFactorFactory >	DefaultPHSPFactory = TwoBodyPhaseSpaceFactorFactory::instance()

Complex constants
complex zero
constexpr auto	Complex_0 = std::complex<double>(0, 0)

constexpr auto	Complex_1 = std::complex<double>(1, 0)
	complex one

constexpr auto	Complex_i = std::complex<double>(0, 1)
	complex i

#ThreeVector constants
constexpr auto	ThreeAxis_X = ThreeVector<double>({1, 0, 0})
	X axis (ThreeVector)

constexpr auto	ThreeAxis_Y = ThreeVector<double>({0, 1, 0})
	Y axis (ThreeVector)

constexpr auto	ThreeAxis_Z = ThreeVector<double>({0, 0, 1})
	Z axis (ThreeVector)

constexpr auto	ThreeAxes = CoordinateSystem<double, 3> {ThreeAxis_X, ThreeAxis_Y, ThreeAxis_Z}
	Standard 3D coordinate system.

constexpr auto	ThreeVector_0 = ThreeVector<double>({0, 0, 0})
	0 as ThreeVector;

#FourVector constants
constexpr auto	FourAxis_T = FourVector<double>({1, 0, 0, 0})
	T axis (FourVector)

constexpr auto	FourAxis_X = FourVector<double>({0, 1, 0, 0})
	X axis (FourVector)

constexpr auto	FourAxis_Y = FourVector<double>({0, 0, 1, 0})
	Y axis (FourVector)

constexpr auto	FourAxis_Z = FourVector<double>({0, 0, 0, 1})
	Z axis (FourVector)

constexpr auto	FourAxes = CoordinateSystem<double, 4>({FourAxis_T, FourAxis_X, FourAxis_Y, FourAxis_Z})
	Standard 4D coordinate system.

constexpr auto	FourVector_0 = FourVector<double>({0, 0, 0, 0})
	0 as FourVector;

Detailed Description

Todo:: Find better place for this

Enumeration Type Documentation

enum VariableStatus : int

strong

Enumerator
changed	Variable is free and has been changed.
fixed	Variable is fixed.
unchanged	Variable is free but has not been changed.

Function Documentation

constexpr T yap::abs ( const Vector< T, N > & A )

Returns: magnitude of #Vector (using associated inner product)

const std::complex<double> yap::amplitude	(	const DecayTree &	dt,
		const DataPoint &	d
	)

inline

Returns: amplitude evaluated for DataPoint over all symmetrizations

Parameters

dt	DecayTree to operate on
d	DataPoint to evaluate on

const std::complex<double> yap::amplitude	(	const DecayTree &	dt,
		const DataPoint &	d,
		const std::shared_ptr< ParticleCombination > &	pc
	)

inline

Returns: amplitude evaluated for DataPoint for particular symmetrization

Parameters

dt	DecayTree to operate on
d	DataPoint to evaluate on
pc	ParticleCombination

const std::complex< double > amplitude	(	const DecayTreeVector &	dtv,
		const DataPoint &	d
	)

Returns: sum of amplitudes of decay trees in a vector

Parameters

dtv	DecayTreeVector to sum over
d	DataPoint to evaluate on

constexpr std::array<T, 2> yap::angles	(	const ThreeVector< T > &	V,
		const CoordinateSystem< T, 3 > &	C
	)

This is the fastest to use if calculating both angles

Returns: azimuthal (0; phi) and polar (1; theta) angles of V in coordinate system C

Parameters

V	ThreeVector to calculate azimuthal angle of
C	Coordinate frame to measure in

constexpr ThreeVector<T> yap::boost ( const FourVector< T > & V )

Returns: boost vector of this #FourVector

const ComplexIntegralElementMatrix cached_integrals ( const DecayTreeVectorIntegral & dtvi )

Returns: matrix of integral components without multiplication by free amplitudes

Parameters

dtvi	DecayTreeVectorIntegral to retrieve values from

std::vector< FourVector< double > > calculate_four_momenta	(	double	initial_mass,
		const FinalStateParticleVector &	FPSs,
		const MassAxes &	axes,
		const std::vector< double > &	squared_masses
	)

Calculate four-momenta for final-state particles for phase-space coordinate.

Parameters

initial_mass	initial mass of decaying system
FSPs	Vector of final state particles
axes	phase-space axes
squared_masses	phase-space coordinate

Todo:: : check sign determination on x component for particles 5 and higher

Todo:: : check sign determination on x component for particles 5 and higher

std::vector< FourVector< double > > calculate_four_momenta	(	double	initial_mass,
		const Model &	M,
		const MassAxes &	axes,
		const std::vector< double > &	squared_masses
	)

Calculate four-momenta for final-state particles for phase-space coordinate And apply rotation into model's coordinate system

Parameters

initial_mass	initial mass of decaying system
M	model to get final state particles and coordinate system from
axes	phase-space axes
squared_masses	phase-space coordinate

const int charge ( const DecayChannel & dc )

Returns: total charge of decay channel

bool yap::check_deltas ( const SquareMatrix< T, N > & M )

checks the four-momenta outer-product matrix for the correct eigenvalue structure; see Byers & Yang, "Physical Regions in Invariant Variables for n Particles and the Phase-Space Volume Element." Rev. Mod. Phys. 36, 595 (1964)

The elements of M are
M[i][j] = P[i] (dot) P[j],
where P[k] is the four-momenta for particle k
alternatively: M[i][j] = 0.5 * (m^2_ij - m^2_i - m^2_j)

const T yap::cofactor	(	const SquareMatrix< T, N > &	M,
		size_t	r,
		size_t	c
	)

cofactor

Parameters

r	row
c	column

std::vector<std::vector<size_t> > yap::combinations	(	size_t	N,
		size_t	n,
		const std::vector< std::vector< size_t > > &	C = `std::vector<std::vector<size_t> >()`
	)

Returns: all combinations of n numbers in range [0, N-1]

Todo:: Find better place to put this function

ComplexIntegralElement yap::conj ( const ComplexIntegralElement & Z )

inline

Returns: conjugate of element

constexpr bool yap::conserves	(	unsigned	two_J,
		unsigned	two_j1,
		unsigned	two_j2,
		int	l
	)

Returns: Whether angular momentum is conserved in J -> j1 + j2 with orbital angular momentum l

Parameters

two_J	2 * spin of initial state
two_j1	2 * spin of first daughter
two_j2	2 * spin of second daughter
l	orbital angular momentum

constexpr ThreeVector<T> yap::cross	(	const ThreeVector< T > &	A,
		const ThreeVector< T > &	B
	)

noexcept

Returns: cross product

DecayChannelSet::value_type yap::decay_channel	(	const DecayingParticle &	dp,
		Last	p,
		UnaryPredicates...	P
	)

Returns: lone DecayChannel of DecayingParticle matching predicates throws if no unique DecayChannel is found

DecayChannelSet yap::decay_channels	(	const DecayingParticle &	dp,
		Last	p,
		UnaryPredicates...	P
	)

Returns: DecayChannel's of DecayingParticle matching predicates

DecayTreeSet::value_type yap::decay_tree	(	const DecayingParticle &	dp,
		Last	p,
		Predicates...	P
	)

Returns: lone DecayTree passing provided predicates

Parameters

p	last predicate to apply in filtering DecayTree's
P...	predicates to apply in filtering DecayTree's throws if no unique DecayTree is found

DecayTreeSet decay_trees ( const DecayingParticle & dp )

Returns: Set of all decay trees in provided DecayingParticle

Todo:: Have it recursively travel down DecayChannels?

DecayTreeSet yap::decay_trees	(	const DecayingParticle &	dp,
		Last	p,
		Predicates...	P
	)

Returns: DecayTreeSet for decays passing provided predicates

Parameters

p	last predicate to apply in filtering DecayTree's
P...	predicates to apply in filtering DecayTree's

const bool decays_to_full_final_state ( const Particle & p )

Returns: whether a particle decays to its model's full final state

T yap::delta	(	const SquareMatrix< T, N > &	M,
		size_t	l
	)

Returns: (-1)^(l-1) * sum of determinants of all l-by-l diagonal minors of a matrix

unsigned depth ( const DecayTree & DT )

Returns: Depth of DecayTree

const T yap::det ( SquareMatrix< T, N > M )

Determinant This algorithm is simple, and should not be used for large matrices

const double dFunction	(	unsigned	twoJ,
		int	twoM,
		int	twoN,
		double	beta
	)

Returns: Wigner d-function $d^{J}_{M N}(\beta)$

Parameters

twoJ	twice the total spin of system
twoM	twice the first spin projection
twoN	twice the second spin projection
beta	rotation angle

const RealIntegralElementVector diagonal_integrals ( const DecayTreeVectorIntegral & dtvi )

Returns: diagonal integrals

Parameters

dtvi	DecayTreeVectorIntegral to retrieve values from

void yap::disableLogs ( el::Level lvl )

inline

disable logging for lvl

Parameters

lvl	(Global, Trace, Debug, Fatal, Error, Warning, Verbose, Info)

bool disjoint ( const ParticleCombinationVector & pcv )

Returns: whether all members of ParticleCombinationVector are non-overlapping with each other

Parameters

pcv	Vector check in

bool equal_down_by_orderless_content	(	const std::shared_ptr< const ParticleCombination > &	A,
		const std::shared_ptr< const ParticleCombination > &	B
	)

compare shared_ptr's to ParticleCombination by checking selves with equal_by_orderless_content and then checking (only) one generation down

const ThreeMatrix<T> yap::eulerRotationZXZ	(	const CoordinateSystem< T, 3 > &	C,
		const T &	alpha,
		const T &	beta,
		const T &	gamma
	)

Returns: a 3D rotation matrix Construct from Euler angles: rotate by alpha around z axis, rotate by beta around x' axis, rotate by gamma around z'' axis

Parameters

C	Coordinate system defining rotation axes
alpha	angle of initial rotation around z axis [rad]
beta	angle of rotation around x' axis [rad]
gamma	angle of final rotation around z'' axis [rad]

const ThreeMatrix<T> yap::eulerRotationZYZ	(	const CoordinateSystem< T, 3 > &	C,
		const T &	alpha,
		const T &	beta,
		const T &	gamma
	)

Returns: a 3D rotation matrix Construct from Euler angles: rotate by alpha around z axis, rotate by beta around y' axis, rotate by gamma around z'' axis

Parameters

C	Coordinate system defining rotation axes
alpha	angle of initial rotation around z axis [rad]
beta	angle of rotation around y' axis [rad]
gamma	angle of final rotation around z'' axis [rad]

const RealIntegralElementVector fit_fractions ( const DecayTreeVectorIntegral & dtvi )

Returns: vector of fit fractions of DecayTree's in DecayTreeVectorIntegral

Parameters

dtvi	DecayTreeVectorIntegral to retrieve values from

FreeAmplitudeSet::value_type yap::free_amplitude	(	const DecayingParticle &	dp,
		Last	p,
		UnaryPredicates...	P
	)

Returns: lone free amplitude in a model from decay trees evaluating to true throws if no unique free amplitude is found

FreeAmplitudeSet::value_type yap::free_amplitude	(	const Model &	M,
		Last	p,
		UnaryPredicates...	P
	)

Returns: lone free amplitude in a model passing predicates throws if unique amplitude is not found

FreeAmplitudeSet free_amplitudes ( const DecayTree & DT )

Returns: set of all free amplitudes in a DecayTree

FreeAmplitudeSet free_amplitudes ( const DecayTreeVector & DTV )

Returns: set of all free amplitudes in a DecayTreeVector

FreeAmplitudeSet free_amplitudes ( const DecayingParticle & dp )

Returns: all the free amplitudes under a decaying particle

FreeAmplitudeSet yap::free_amplitudes	(	const DecayingParticle &	dp,
		Last	p,
		UnaryPredicates...	P
	)

Returns: free amplitude in a model from decay trees evaluating to true

FreeAmplitudeSet free_amplitudes ( const Model & M )

Returns: all free amplitudes in a model

FreeAmplitudeSet yap::free_amplitudes	(	const Model &	M,
		Last	p,
		UnaryPredicates...	P
	)

Returns: free amplitude in a model from decay trees evaluating to true

std::vector< std::shared_ptr< DecayingParticle > > full_final_state_isp ( const Model & M )

Returns: vector of shared_ptr to DecayingParticles inside Model that decay to its full final state, sorted such that the first entries have fixed prefactors

const bool has_changed ( const std::shared_ptr< DecayTree > & dt )

Returns: whether a decay tree has changed

CoordinateSystem<T, 3> yap::helicityFrame	(	const ThreeVector< T > &	V,
		const CoordinateSystem< T, 3 > &	C
	)

Calculate helicity frame of V transformed from C, with z = unit(V), y = C.z X z, x = y X z

Parameters

V	ThreeVector defining new Z direction
C	CoordinateSystem aiding in defining new Y direction

const CoordinateSystem<T, 3> yap::helicityFrame	(	const FourVector< T > &	V,
		const CoordinateSystem< T, 3 > &	C
	)

Calculate helicity frame of V transformed from C, with z = unit(V), y = C.z X z, x = y X z

Parameters

V	Fourector defining new Z direction
C	CoordinateSystem aiding in defining new Y direction

RealIntegralElement yap::imag ( const ComplexIntegralElement & Z )

inline

Returns: RealIntegralElement for imaginary component of ComplexIntegralElement

const RealIntegralElement integral ( const ModelIntegral & MI )

Returns: integral calculated from components

const RealIntegralElement integral ( const DecayTreeVectorIntegral & dtvi )

Returns: integral calculated from components of DecayTreeVectorIntegral

Parameters

dtvi	DecayTreeVectorIntegral to retrieve values from

const ComplexIntegralElementMatrix integrals ( const DecayTreeVectorIntegral & dtvi )

Returns: matrix of integral components with multiplication by free amplitudes

Parameters

dtvi	DecayTreeVectorIntegral to retrieve values from

const double yap::intensity	(	const DecayTreeVector &	dtv,
		const DataPoint &	d
	)

inline

Returns: square of sum of amplitudes of decay trees in a vector

Parameters

dtv	DecayTreeVector to sum over
d	DataPoint to evaluate on

const double intensity	(	const InitialStateParticleMap::value_type &	isp_mix,
		const DataPoint &	d
	)

Returns: intensity for all spin projections of an ISP

const double intensity	(	const InitialStateParticleMap &	isp_map,
		const DataPoint &	d
	)

Returns: intensity for a data point evaluated over isp_map

constexpr bool yap::is_even ( int val )

Returns: whether val is an even number

const bool yap::is_final_state_particle_combination ( const ParticleCombination & pc )

inline

Returns: whether ParticleCombination is for a final state particle

const bool yap::is_from_initial_state_particle_combination	(	const ParticleCombination &	pc,
		const Model &	m
	)

inline

Returns: whether pc is or is from a pc of an initial state particle

const bool is_initial_state_particle_combination	(	const ParticleCombination &	pc,
		const Model &	m
	)

Returns: whether pc is a pc of an initial state particle

constexpr bool yap::is_odd ( int val )

Math Utilities.

Author: Johannes Rauch, Daniel Greenwald

Returns: whether val is an odd number

constexpr bool yap::isLeftHanded ( const CoordinateSystem< T, 3 > & C )

Returns: Whether 3D CoordinateSystem is left handed

Parameters

C	3D CoordinateSystem to check

constexpr bool yap::isRightHanded ( const CoordinateSystem< T, 3 > & C )

Returns: Whether 3D CoordinateSystem is right handed

Parameters

C	3D CoordinateSystem to check

const FourMatrix<T> yap::lorentzTransformation ( const ThreeMatrix< T > & R )

Returns: a 4D Lorentz-transformation matrix for a pure rotation

Parameters

R	#ThreeMatrix defining the rotation

const FourMatrix<T> yap::lorentzTransformation ( const FourVector< T > & V )

Returns: a 4D Lorentz-transformation matrix for a pure boost

Parameters

V	#FourVector of four-momentum defining boost

constexpr FourMatrix<T> yap::lorentzTransformation ( const ThreeVector< T > & V )

Returns: a 4D Lorentz-transformation matrix for a pure boost

Parameters

V	#ThreeVector defining boost

constexpr FourMatrix<T> yap::lorentzTransformation ( const std::vector< FourVector< T > > & fourVecs )

Returns: a 4D Lorentz-transformation matrix for a pure boost

Parameters

fourVecs the sum of these define the boost

constexpr FourMatrix<T> yap::lorentzTransformation	(	const ThreeMatrix< T > &	R,
		const FourVector< T > &	V
	)

Returns: a 4D Lorentz-transformation matrix for a rotation followed by a boost

Parameters

R	#ThreeMatrix defining rotation
V	#FourVector defining boost

constexpr FourMatrix<T> yap::lorentzTransformation	(	const ThreeMatrix< T > &	R,
		const ThreeVector< T > &	V
	)

Returns: a 4D Lorentz-transformation matrix for a rotation followed by a boost

Parameters

R	#ThreeMatrix defining rotation
V	#ThreeVector defining boost

constexpr FourMatrix<T> yap::lorentzTransformation	(	const FourVector< T > &	V,
		const ThreeMatrix< T >	R
	)

Returns: a 4D Lorentz-transformation matrix for a boost followed by a rotation

Parameters

R	#ThreeMatrix defining rotation
V	#FourVector defining boost

constexpr FourMatrix<T> yap::lorentzTransformation	(	const ThreeVector< T > &	V,
		const ThreeMatrix< T > &	R
	)

Returns: a 4D Lorentz-transformation matrix for a boost followed by a rotation

Parameters

R	#ThreeMatrix defining rotation
V	#ThreeVector defining boost

const MassRange mass_range	(	double	isp_mass,
		const std::shared_ptr< ParticleCombination > &	pc,
		const FinalStateParticleVector &	FSPs
	)

Returns: mass range for particle combination inside decay of ISP to FSPs

Parameters

isp_mass	initial-state mass
pc	shared_ptr to ParticleCombination to get mass range for
FSP	FinalStateParticles of the ISP to calculate with

const std::vector< MassRange > mass_range	(	double	isp_mass,
		const MassAxes &	A,
		const FinalStateParticleVector &	FSPs
	)

Returns: mass range for MassAxes inside decay of ISP to FSPs

Parameters

isp_mass	initial-state mass
A	MassAxes to get mass ranges for
FSPs	FinalStateParticles of the ISP to calculate with

const T yap::minor_det	(	const SquareMatrix< T, N > &	M,
		size_t	r,
		size_t	c
	)

Minor

Parameters

r	row
c	column

const SquareMatrix< T, N - 1 > yap::minor_matrix	(	const SquareMatrix< T, N > &	M,
		size_t	r,
		size_t	c
	)

Minor matrix

Parameters

r	row
c	column

const CoordinateSystem<T, N> yap::operator*	(	const SquareMatrix< T, N > &	M,
		const CoordinateSystem< T, N > &	C
	)

multiply a SquareMatrix times each coorindate vector. Useful for rotating coordinate frames

const IntegralElement<T> yap::operator*	(	IntegralElement< T >	A,
		const IntegralElement< T > &	B
	)

inline

Returns: multiplication of two IntegralElements

auto yap::operator*	(	const Matrix< T1, R, K > &	A,
		const Matrix< T2, K, C > &	B
	)		-> const typename std::enable_if < (R != 1) or (C != 1), Matrix<typename std::remove_cv<decltype(operator*(A[0][0], B[0][0]))>::type, R, C> >::type

matrix multiplication with different template types

Template Parameters

T1	element type of matrix A
T2	element type of matrix B
R	number of rows of matrix A
K	number of columns of matrix A, number of rows of matrix B
C	number of columns of matrix B

const IntegralElement<T> yap::operator+	(	IntegralElement< T >	A,
		const IntegralElement< T > &	B
	)

inline

Returns: addition of two IntegralElements

constexpr FourVector<T> yap::operator- ( const FourVector< T > & V )

unary minus for 4-vector, does not change sign of zero'th component

const std::vector<FourVector<T> > yap::operator- ( const std::vector< FourVector< T > > & V )

unary minus for a vector of 4-vectors, does not change sign of zero'th components

const IntegralElement<T> yap::operator-	(	IntegralElement< T >	A,
		const IntegralElement< T > &	B
	)

inline

Returns: subtraction of two IntegralElements

const IntegralElement<T> yap::operator/	(	IntegralElement< T >	A,
		const IntegralElement< T > &	B
	)

inline

Returns: division IntegralElements into another

const ParticleCombination& yap::origin ( const ParticleCombination & pc )

inline

Returns: top of decay tree this ParticleCombination belongs to

ParticleSet::value_type yap::particle	(	const Model &	M,
		Last	p,
		UnaryPredicates...	P
	)

Returns: lone particle in model for which all predicates evaluate true throws if unique particle is not found

ParticleSet particles ( DecayingParticle & dp )

Returns: set of all particles below given DecayingParticle, including itself

ParticleSet particles ( const Model & M )

Returns: set of all particles in model

ParticleSet yap::particles	(	const Model &	M,
		Last	p,
		UnaryPredicates...	P
	)

Returns: Set of particles in model for which all predicates evaluate true

constexpr T yap::phi	(	const ThreeVector< T > &	V,
		const CoordinateSystem< T, 3 > &	C
	)

Returns: azimuthal angle of V in coordinate system C, in [-pi, pi]

Parameters

V	ThreeVector to calculate azimuthal angle of
C	Coordinate frame to measure in

const std::vector<FourVector<double> > yap::phsp	(	const Model &	M,
		double	initial_mass,
		const MassAxes &	A,
		const std::vector< MassRange > &	R2,
		Generator &	g,
		unsigned	max_attempts
	)

Returns: vector of four momenta for daughters uniformly randomly generated in phase space of model

Parameters

M	model to calculate with
initial_mass	Initial mass to decay from
A	mass axes
R2	vector of squared mass ranges of axes
g	random generator to pass to uniform_real_distribution
max_attempts	maximum number of attempts to make to find a point in phase space

void yap::plainLogs ( el::Level lvl )

inline

just print the debug message without any additional info

Parameters

lvl	(Global, Trace, Debug, Fatal, Error, Warning, Verbose, Info)

const SpinProjectionVector yap::projections ( unsigned two_j )

inline

Returns: vector of all spin projections, from -two_j to two_j

Parameters

two_j spin to make projections of

const std::vector<SpinProjectionVector> yap::projections ( const SpinVector & two_J )

inline

Returns: vector of all possible spin projection states of spins in two_J

Parameters

two_J SpinVector of spins to make projections of

RealIntegralElement yap::real ( const ComplexIntegralElement & Z )

inline

Returns: RealIntegralElement for real component of ComplexIntegralElement

const ThreeMatrix<T> yap::rotation	(	const ThreeVector< T > &	V,
		const T &	theta
	)

Returns: a 3D rotation matrix

Parameters

V	vector to rotate about
theta	angle to rotate through

const DecayTreeVector select_changed ( const DecayTreeVector & dtv )

Returns: vector of trees whose data-dependent amplitude variable statuses are VariableStatus::changed

Parameters

vector of trees to check in

std::vector<double>::const_iterator yap::set_value	(	ParameterBase &	P,
		InputIt	first
	)

set value into parameter from iterator, calling parameter's setValue(vector<double>) function

Parameters

P	Parameter to set into
first	Iterator to take values from

const size_t yap::size ( const ParameterVector & V )

inline

Returns: number of real elements in ParameterVector

const SpinVector spins ( const ParticleVector & v )

Returns: SpinVector from ParticleVector

const MassRange squared ( MassRange mr )

Returns: squared masses of mass range

const std::vector< MassRange > squared ( std::vector< MassRange > mr )

Returns: squared masses of vector of mass ranges

const double squared_barrier_factor	(	unsigned	l,
		double	z
	)

squared Blatt-Weisskopf barrier factor;

Parameters

l	Orbital angular momentum
z	squared breakup momentum / squared radius

Warning: approximate result for l >= 8 is not properly tested, nor streamlined!

Todo:: : speed this up. And check how well it approximates.

Todo:: : speed this up. And check how well it approximates.

constexpr double yap::squared_breakup_momentum	(	double	m2_R,
		double	m_a,
		double	m_b
	)

inline

Calculate breakup momentum from parent and daughter masses

Parameters

m2_R	squared mass of parent
m_a	mass of first daughter
m_b	mass of second daughter

const double sum_of_log_intensity	(	const Model &	M,
		DataPartition &	D,
		double	ped = `0`
	)

Returns: The sum of the logs of squared amplitudes evaluated over the data partition

Parameters

M	Model to evaluate
D	DataPartition to evalue over
ped	Pedestal to substract from each term in the sum

const double sum_of_log_intensity	(	const Model &	M,
		DataPartitionVector &	DP,
		double	ped = `0`
	)

Returns: The sum of the logs of squared amplitudes evaluated over the data partitions

Parameters

DP	DataPartitionVector of partitions to use
ped	Pedestal to substract from each term in the sum

const SquareMatrix<T, N> yap::symmetricMatrix ( std::initializer_list< T > elements )

symmetric matrix

Parameters

list	of entries, starting with the diagonal, 1st off diagonal ...

constexpr T yap::theta	(	const ThreeVector< T > &	V,
		const CoordinateSystem< T, 3 > &	C
	)

Returns: polar angle of V in coordinate system C, in [0, pi]

Parameters

V	ThreeVector to calculate azimuthal angle of
C	Coordinate frame to measure in

std::string yap::to_string ( const CoordinateSystem< T, N > & C )

Returns: string

std::string yap::to_string ( const Matrix< T, R, C > & M )

Returns: string

std::string yap::to_string ( const IntegralElement< T > & a )

inline

Returns: string of IntegralElement

std::string yap::to_string ( const Parameter< T > & P )

inline

Returns: string of Parameter

std::string to_string ( const AdmixtureMap & mix )

Returns: string of AdmixtureMap

std::string yap::to_string ( const Vector< T, N > & V )

Returns: string

constexpr bool yap::triangle	(	unsigned	two_a,
		unsigned	two_b,
		unsigned	two_c
	)

Returns: whether three spins fulfill the triangle relationship

Parameters

two_a	2 * spin a
two_b	2 * spin b
two_c	2 * spin c

Returns: $\Delta(abc)$

const CoordinateSystem<T, N> yap::unit ( const CoordinateSystem< T, N > & C )

Returns: CoordinateSystem with vectors of unit norm

Parameters

C	CoordinateSystem to base on

const Vector<T, N> yap::unit ( const Vector< T, N > & V )

Returns: unit vector in direction of vector

Parameters

V	Vector to use for direction of unit vector

bool valid_final_state	(	const std::shared_ptr< ParticleCombination > &	pc,
		const FinalStateParticleVector &	FSPs
	)

Returns: whether pc and FSPs are for the same final state

constexpr VariableStatus yap::variable_status	(	IterType	first,
		IterType	last
	)

Returns: VariableStatus::changed if any element in range is changed; VariableStatus::unchanged otherwise

constexpr ThreeVector<T> yap::vect ( const FourVector< T > & V )

noexcept

Returns: Spatial #ThreeVector inside #FourVector

Classes

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

Function Documentation