| CAmpGen::AmplitudeRules | |
| CAmpGen::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 |
| CAmpGen::ASTResolver | (Internal) class to aide in the resolution of the dependencies of expression trees |
| CAmpGen::Lineshape::Base | |
| CAmpGen::Lineshape::BW | Simple two-body Breit-Wigner lineshape that describes relatively narrow, isolated resonances that couple to a single channel / orbital configuration |
| CAmpGen::Lineshape::Bugg | |
| CAmpGen::Lineshape::CoupledChannel | Description of a resonance that decays to multiple two and three-body final states |
| CAmpGen::Lineshape::DecaySpline | |
| CAmpGen::Lineshape::EtaDalitz | Empirical Dalitz plot distribution for \( \eta \rightarrow \pi^{+}\pi^{-}\pi^{0} \) |
| CAmpGen::Lineshape::ExpFF | Exponential form-factor of type \( e^{ - q^2 R^2 } \) |
| CAmpGen::Lineshape::FOCUS | K matrix amplitudes used for I=1/2 and I=3/2 in the description of the \( K\pi \) S-wave in the analysis of \( D^{+}\rightarrow
K^{-}\pi^{+}\pi^{+}\) https://arxiv.org/abs/0705.2248 |
| CAmpGen::Lineshape::Flatte | Lineshape to describe resonances with coupled channels such as \(f_{0}(980)^{0} / a_{0}(980) \) |
| CAmpGen::Lineshape::FormFactor | |
| CAmpGen::Lineshape::FormFactorSpline | |
| CAmpGen::Lineshape::GLASS | Generalised description of the \( K\pi\) S-wave, taken from BABAR / BELLE analysis of \( D^{0} \to K_{S}^{0} \pi^{+} \pi^{-} \) https://journals.aps.org/prd/pdf/10.1103/PhysRevD.98.112012 |
| CAmpGen::Lineshape::GSpline | Lineshape with an arbitrary running width determined from a spline |
| CAmpGen::Lineshape::Gaussian | Gaussian shape for (relatively) long lived states that are limited by experimental resolution, rather than natural width |
| CAmpGen::Lineshape::GenericKmatrix | Implementation of a generic K-matrix |
| CAmpGen::Lineshape::GounarisSakurai | Gounaris-Sakurai lineshape models dispersive corrections to the \(I=1,J=1\) \(\pi\pi\) propagator |
| CAmpGen::Lineshape::InelasticSpline | |
| CAmpGen::Lineshape::Isotensor | |
| CAmpGen::Lineshape::LASS | Description of the \( K\pi \) S-wave, based on the fits to scattering data |
| CAmpGen::Lineshape::MIPWA | Model-Independent Partial Wave parameterisation using cubic splines |
| CAmpGen::Lineshape::NonRelBW | Nonrelativistic Breit-Wigner lineshape |
| CAmpGen::Lineshape::None | |
| CAmpGen::Lineshape::PALANO | I=1/2 and I=3/2 K Matrices used in the description of the \( K\pi\) S-wave in the analysis of \(\eta_{c}\rightarrow K^{+} K^{-} \pi^{0}\) https://arxiv.org/abs/1701.04881 |
| CAmpGen::Lineshape::Photon | |
| CAmpGen::Lineshape::Poly | Polynominal shape \( \mathcal{A}(s) = \sqrt{ \sum_{ij} c_{ij} s^{i} (s^\prime)^{j} } \) where the sum is to lineshapeModifier::Degree, and the free parameters of the shape are lineshapeModifier_cij |
| CAmpGen::Lineshape::PolyNR | Polynominal shape \( \mathcal{A}(s) = \sum^n_i c_i s^{i} \) where the sum is to lineshapeModifier::Degree, and the free parameters of the shape are lineshapeModifier_ci |
| CAmpGen::Lineshape::SBW | Breit-Wigner lineshape with fixed width |
| CAmpGen::Lineshape::TD | (Linear) time dependence |
| CAmpGen::Lineshape::kMatrixSimple | Simple and flexible K matrix that implements a variable number of scalar channels and poles |
| CAmpGen::Vertex::Base | Base class for all spin vertices |
| CAmpGen::Vertex::F_FS_P | |
| CAmpGen::Vertex::F_FS_P1 | |
| CAmpGen::Vertex::F_FS_S | |
| CAmpGen::Vertex::F_FS_S1 | |
| CAmpGen::Vertex::F_FS_SL | |
| CAmpGen::Vertex::F_FS_SR | |
| CAmpGen::Vertex::F_RS_D | |
| CAmpGen::Vertex::F_RS_P | |
| CAmpGen::Vertex::F_RS_P1 | |
| CAmpGen::Vertex::F_TF_P | |
| CAmpGen::Vertex::F_VF_D | |
| CAmpGen::Vertex::F_VF_D1 | |
| CAmpGen::Vertex::F_VF_P | |
| CAmpGen::Vertex::F_VF_P1 | |
| CAmpGen::Vertex::F_VF_P2 | |
| CAmpGen::Vertex::F_VF_P3 | |
| CAmpGen::Vertex::F_VF_S | |
| CAmpGen::Vertex::F_VF_S1 | |
| CAmpGen::Vertex::F_VF_SL | |
| CAmpGen::Vertex::F_VF_SR | |
| CAmpGen::Vertex::R_FS_D | |
| CAmpGen::Vertex::R_FS_P | |
| CAmpGen::Vertex::S_SS_S | \( S = S_1 S_2 \) |
| CAmpGen::Vertex::S_TS_D | \( S = T^{\mu\nu} L_{\mu\nu}\) |
| CAmpGen::Vertex::S_TT_S | \( S = T_1^{\mu\nu} T_{2\mu\nu}\) |
| CAmpGen::Vertex::S_TV_D | \( S = \varepsilon_{\mu\nu\alpha\beta} T^{\mu\gamma} L_{\gamma}^{\nu} P^{\alpha} V^{\beta} \) |
| CAmpGen::Vertex::S_TV_P | \( S = L^{\mu} T_{\mu\nu} V^{\nu} \) |
| CAmpGen::Vertex::S_TV_rm | |
| CAmpGen::Vertex::S_TV_rp | |
| CAmpGen::Vertex::S_VS_P | \( S = L_{\mu} V_1^{\mu} S_2 \) |
| CAmpGen::Vertex::S_VV_D | \( S = L_{\mu\nu} V_1^\mu V_2^\nu \) |
| CAmpGen::Vertex::S_VV_P | \( S = \varepsilon_{\alpha\beta\mu\nu} P^{\alpha} L^{\beta} V_1^{\mu} V_2^{\nu} \) |
| CAmpGen::Vertex::S_VV_S | \( S = g_{\mu\nu} V_1^\mu V_2^{\nu} \) |
| CAmpGen::Vertex::S_VV_S1 | \( S = S_{\mu\nu} V_1^\mu V_2^{\nu} \) |
| CAmpGen::Vertex::S_VV_rm | |
| CAmpGen::Vertex::S_VV_rp | |
| CAmpGen::Vertex::S_fF_S | |
| CAmpGen::Vertex::S_fF_S1 | |
| CAmpGen::Vertex::T_SS_D | |
| CAmpGen::Vertex::T_TS_D | |
| CAmpGen::Vertex::T_TS_S | |
| CAmpGen::Vertex::T_VS_D | |
| CAmpGen::Vertex::T_VS_P | |
| CAmpGen::Vertex::V_SS_P | \( V^{\mu} = L^{\mu} S_1 S_2 \) |
| CAmpGen::Vertex::V_TS_D | |
| CAmpGen::Vertex::V_TS_P | |
| CAmpGen::Vertex::V_VS_D | |
| CAmpGen::Vertex::V_VS_P | |
| CAmpGen::Vertex::V_VS_S | \( V^{\mu} = S^{\mu\nu} V_{1\nu} S_2 \) |
| CAmpGen::Vertex::V_VV_P | |
| CAmpGen::Vertex::V_VV_P1 | |
| CAmpGen::Vertex::V_VV_P2 | |
| CAmpGen::Vertex::V_VV_S | |
| CAmpGen::Vertex::V_fF_PL | |
| CAmpGen::Vertex::V_fF_PR | |
| CAmpGen::Vertex::V_fF_S | |
| CAmpGen::Vertex::V_fF_S1 | |
| CAmpGen::Vertex::f_Tf_P | |
| CAmpGen::Vertex::f_Vf_D | |
| CAmpGen::Vertex::f_Vf_D1 | |
| CAmpGen::Vertex::f_Vf_P | |
| CAmpGen::Vertex::f_Vf_P1 | |
| CAmpGen::Vertex::f_Vf_P2 | |
| CAmpGen::Vertex::f_Vf_P3 | |
| CAmpGen::Vertex::f_Vf_S | |
| CAmpGen::Vertex::f_Vf_S1 | |
| CAmpGen::Vertex::f_Vf_SL | |
| CAmpGen::Vertex::f_Vf_SR | |
| CAmpGen::Vertex::f_fS_P | |
| CAmpGen::Vertex::f_fS_P1 | |
| CAmpGen::Vertex::f_fS_S | |
| CAmpGen::Vertex::f_fS_S1 | |
| CAmpGen::Vertex::f_fS_SL | |
| CAmpGen::Vertex::f_fS_SR | |
| CAmpGen::Vertex::f_rS_D | |
| CAmpGen::Vertex::f_rS_P | |
| CAmpGen::Vertex::f_rS_P1 | |
| CAmpGen::Vertex::r_fS_D | |
| CAmpGen::Vertex::r_fS_P | |
| CAmpGen::Bilinears | |
| CAmpGen::BinDT | |
| CAmpGen::CacheTransfer | |
| CAmpGen::LambdaTransfer | |
| CAmpGen::ParameterTransfer | |
| CAmpGen::SplineTransfer | |
| CAmpGen::Chi2Estimator | |
| CAmpGen::CompiledExpression< ret_type, arg_types > | |
| CAmpGen::CompiledExpression< void(complex_v *, const size_t *, const real_t *, const real_v *)> | |
| CAmpGen::MatrixElement | |
| CAmpGen::CompiledExpressionBase | Base class for compiled expressions, i.e |
| CAmpGen::CompiledExpression< ret_type(arg_types...)> | |
| CAmpGen::Complex< real_t > | |
| CAmpGen::ConfigurableBase | |
| CAmpGen::Configurable< ApplicationOptions > | |
| CAmpGen::ApplicationOptions | Default |
| CAmpGen::Configurable< CoherentSum > | |
| CAmpGen::CoherentSum | A coherent sum of amplitudes |
| CAmpGen::IncoherentSum | An incoherent sum of resonances, traditionally considered as an approximate background model |
| CAmpGen::Configurable< CompilerWrapper > | |
| CAmpGen::CompilerWrapper | |
| CAmpGen::Configurable< CouplingConstant > | |
| CAmpGen::CouplingConstant | |
| CAmpGen::Configurable< EventType > | |
| CAmpGen::EventType | Deals with final state configuration of events, specifically dealing with the ordering of particles in trees |
| CAmpGen::Configurable< Particle > | |
| CAmpGen::Particle | Describes a particle, its decay process and subsequent decay products, which are also Particles |
| CAmpGen::Configurable< PolarisedSum > | |
| CAmpGen::PolarisedSum | |
| CAmpGen::Configurable< TreePhaseSpace > | |
| CAmpGen::TreePhaseSpace | Generator of events where the phase space is decomposed into a series of subtrees |
| CAmpGen::Configurable< T > | |
| CAmpGen::DalitzIntegrator | Class for doing 2D integrals using the Square Dalitz Plot (SQDP) method |
| CAmpGen::DecayChainStackBase | |
| CAmpGen::DecayChainStack< N > | |
| CAmpGen::DiscreteDistribution | |
| CAmpGen::DynamicContainer< TYPE, CONTAINER_TYPE > | 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 |
| CAmpGen::DynamicFCN< RETURN_TYPE, IN_TYPES > | Wrapper to give templated interface to a function contained in a dynamically linked library |
| CAmpGen::DynamicFCN< RETURN_TYPE(IN_TYPES...)> | |
| CAmpGen::Event | Encapsulates the final state particles of a single event |
| CAmpGen::EventList | |
| CAmpGen::EventListSIMD | |
| CAmpGen::Expression | Wrapper class for shared_ptrs to virtual expressions for use in conjunction with operators to build expression trees |
| CAmpGen::ExpressionParser | |
| CAmpGen::ExtendLikelihoodBase | |
| CAmpGen::GaussianConstraint | |
| CAmpGen::LASSO | |
| CAmpGen::Factory< TYPE, KEY_TYPE > | Static factory to construct classes from a hierarchy based on a key (normally std::string) |
| CAmpGen::Factory< Lineshape::Base > | |
| CAmpGen::Lineshape::Factory | |
| CAmpGen::Factory< Vertex::Base > | |
| CAmpGen::Vertex::Factory | |
| Cstd::false_type | |
| CAmpGen::utils::is_complex_type< AmpGen::Complex< T > > | |
| CAmpGen::utils::is_std__complex< std::complex< T > > | |
| CAmpGen::detail::debug_type< T > | |
| CAmpGen::utils::is_complex_type< T > | |
| CAmpGen::utils::is_std__complex< typename > | |
| CAmpGen::utils::is_vector_type< T > | |
| CAmpGen::FastDT | |
| CAmpGen::FitFractionCalculator< pdf_type >::fcalc | |
| CAmpGen::FitFraction | |
| CAmpGen::FitFractionCalculator< pdf_type > | |
| CAmpGen::FitResult | |
| CAmpGen::Helicity::Flags | |
| CAmpGen::GaussErrorPropagator | |
| CAmpGen::Generator< phaseSpace_t > | |
| CAmpGen::HelicityCosine | Functor to compute the angle between set of particles {1} and {2} in the rest frame of set {3} |
| CAmpGen::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 |
| CAmpGen::Argument< TYPE > | Structure to pass "named" parameters to functions |
| CAmpGen::IExpression | Virtual base class for other expression tree components |
| CAmpGen::Array | Expression for a fixed size array of values |
| CAmpGen::ComplexVariable | |
| CAmpGen::Constant | Class to contain a constant (which can contain a complex value) |
| CAmpGen::ExpressionPack | A group of expressions packed into a single expression |
| CAmpGen::ExpressionParameter | |
| CAmpGen::Function | |
| CAmpGen::IBinaryExpression | Base class for binary expressions, i.e |
| CAmpGen::ATan2 | |
| CAmpGen::And | Binary expression that returns \(l \wedge r\) |
| CAmpGen::Divide | Binary expression that returns \(l / r\) |
| CAmpGen::Equal | |
| CAmpGen::Fmod | Binary expression that returns the fractional part of \( l \mathrm{mod} r \) |
| CAmpGen::GreaterThan | Binary expression that returns \(l > r\) |
| CAmpGen::GreaterThanEqualTo | Binary expression that returns \(l > r\) |
| CAmpGen::LessThan | Binary expression that returns \(l < r\) |
| CAmpGen::LessThanEqualTo | Binary expression that returns \(l < r\) |
| CAmpGen::Or | Binary expression that returns \(l \wedge r\) |
| CAmpGen::Pow | Binary expression that returns \( l^{r} \) |
| CAmpGen::Product | Binary expression that returns \(l\times r\) |
| CAmpGen::Sub | Binary expression that returns \(l-r\) |
| CAmpGen::Sum | Binary expression that returns \(l+r\) |
| CAmpGen::IUnaryExpression | Base class for unary expressions, i.e |
| CAmpGen::ACos | Unary expression that returns \(\cos^{-1}(z)\) |
| CAmpGen::ASin | Unary expression that returns \(\sin^{-1}(z)\) |
| CAmpGen::ATan | Unary expression that returns \(\tan^{-1}(z)\) |
| CAmpGen::Abs | Unary expression that returns \(|z|\) |
| CAmpGen::Conj | Unary expression that returns \(z^{*}\) |
| CAmpGen::Cos | Unary expression that returns \(\cos(z)\) |
| CAmpGen::Exp | Unary expression that returns \(e^x\) |
| CAmpGen::ISqrt | Unary expression that uses inverse sqrt (faster than dividing by sqrt) |
| CAmpGen::Imag | Unary expression that returns the imaginary part of \(z\) |
| CAmpGen::LGamma | Unary expression that returns \(\log\left|\Gamma(x)\right|\) |
| CAmpGen::Log | Unary expression that returns \(\log(x)\) |
| CAmpGen::Norm | Unary expression that returns \(|z|^2\) |
| CAmpGen::Real | Unary expression that returns the real part of \(z\) |
| CAmpGen::Sin | Unary expression that returns \(\sin(z)\) |
| CAmpGen::Sqrt | Unary expression that returns \(\sqrt{x}\) |
| CAmpGen::Tan | Unary expression that returns \(\tan(z)\) |
| CAmpGen::LambdaExpression | Parameter that the value of which is given by some arbitrary C++ function |
| CAmpGen::Spline | |
| CAmpGen::SubTree | |
| CAmpGen::TensorExpression | |
| CAmpGen::Ternary | Evaluates the ternary operator |
| CAmpGen::Variable | Free parameter for expression |
| CAmpGen::Tensor::Index | |
| CAmpGen::BinDT::INode | |
| CAmpGen::BinDT::Decision | |
| CAmpGen::BinDT::EndNode | |
| CAmpGen::ARM128d::int_v | |
| CAmpGen::integral< dim > | |
| CAmpGen::Integrator | |
| CAmpGen::DynamicContainer< TYPE, CONTAINER_TYPE >::Iterator | |
| CAmpGen::KahanSum< T > | Implements Kahan summation for better precision with (repeated) floating point addition |
| CAmpGen::KeyedFunctors< return_type, arg_types > | |
| CAmpGen::KeyedFunctors< return_type(arg_types...)> | |
| CAmpGen::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 |
| CAmpGen::LS | |
| CAmpGen::MinuitParameter | |
| CAmpGen::MinuitExpression | |
| CAmpGen::MinuitParameterSet | |
| CAmpGen::MinuitProxy | |
| CAmpGen::MomentumTransfer | Functor to calculate the linear momemtum between particles {1} and {2} in the rest frame of {1} + {2} |
| CAmpGen::NamedParameter< T > | A parameter with value specified by the user at runtime, either in an options file or via the command line |
| CAmpGen::FastDT::Node | |
| CAmpGen::NonlinearErrorPropagator | |
| CAmpGen::NormalOrderedExpression | |
| CAmpGen::OptionsParser | |
| CAmpGen::Pade< N, T > | |
| CAmpGen::ParticleProperties | Class that contains the PDG properties (mass, width, charges, etc.) for a single particle species, |
| CAmpGen::ParticlePropertiesList | |
| CAmpGen::PDFWrapper< FCN > | |
| CAmpGen::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 |
| CAmpGen::poleConfig | |
| CAmpGen::ProfileClock | |
| CAmpGen::ProgressBar | |
| CAmpGen::Projection | |
| CAmpGen::Projection2D | |
| CAmpGen::Property< value_t > | Properties are configurable characteristics of objects that will at some point inherit from a base class |
| CAmpGen::TreeReader::Proxy< OutputType > | |
| CAmpGen::QuarkContent | |
| CAmpGen::QuarkState | |
| CAmpGen::ARM128d::real_v | |
| CAmpGen::AVX2d::real_v | |
| CAmpGen::AVX2f::real_v | |
| CAmpGen::AVX512d::real_v | |
| CAmpGen::RecursivePhaseSpace | Generator of events with more complex topologies |
| CAmpGen::scatter_iterator< stored_type, store_type, simd_size, modifiable > | |
| CAmpGen::SimFit | |
| CAmpGen::utils::size< T > | |
| CAmpGen::detail::size_of< T > | |
| CAmpGen::detail::size_of< void > | |
| CAmpGen::SmallVector< type, max_size > | |
| CAmpGen::Store< stored_type, align > | |
| CAmpGen::Store< complex_v, align > | |
| CAmpGen::FunctionCache< AmpGen::EventList, complex_v, Alignment::AoS > | |
| CAmpGen::FunctionCache< AmpGen::EventList, complex_v, Alignment::SoA > | |
| CAmpGen::Store< real_v, align > | |
| CAmpGen::FunctionCache< AmpGen::FunctionCache< AmpGen::EventList, complex_v, Alignment::AoS >, real_v, Alignment::AoS > | |
| CAmpGen::Store< stored_type, SoA > | |
| CAmpGen::FunctionCache< input_type, stored_type, align > | |
| CAmpGen::SumPDF< eventListType, pdfTypes > | A pdf that contains one or more terms |
| CAmpGen::Tensor | |
| CAmpGen::TensorProxy | Utility class that wraps a tensor and a set of indices such that tensor operations can be performed |
| CAmpGen::NormalOrderedExpression::Term | |
| CAmpGen::ThreadPool | |
| CAmpGen::ThreeBodyCalculator | |
| CAmpGen::TotalCoupling | |
| CAmpGen::Transform | |
| CAmpGen::TransformSequence | |
| CAmpGen::TreeReader | |
| Cstd::true_type | |
| CAmpGen::utils::is_complex_type< AmpGen::Complex< T > > | |
| CAmpGen::utils::is_std__complex< std::complex< T > > | |
| Cstd::vector< T > | STL class |
| CAmpGen::Tensor::Dim | |
| CAmpGen::detail::zeroType< T, args > | |
1.17.0