mty Namespace Reference

Namespace of MARTY. More...

Namespaces
	algebra
	Enumeration of types of semi simple Lie algebras. The names being very small, we use a namespace to avoid conflicts.
	filter
	Namespace containing built-in filters in MARTY.
	gauge
	Namespace containing features concerning gauged groups and gauge choices.
	group
	Namespace to avoid name conflicts for groups that can have very simple names. See algebra::Type for the same reason.
	lha
	Namespace containing all lha utilities.
	mssm_input
	Namespace containing all MSSM input parameters that may be modified with LHA files.
	simpli
	Namespace containing the main simplification method for MARTY and all its dependencies.
	sm_input
	Namespace containing SM input parameters, in particular those modifiable with LHA file.
	Topology
	Namespace containing topology utilities for Feynman diagram calculations.

Data Structures
class	AbstractGroup
	Abstract base class for groups. More...
class	AlgebraState
	Class inherited from std::vector<int>, dynkin labels for a state of a semi-simple algebra (see documentation od SemiSimpleAlgebra). More...
class	Amplitude
	Interface class containing the result of an amplitude calculation. More...
class	AmplitudeInitializer
class	BaseVectorBoson
	Base class for vector objects. More...
class	Cache
struct	CallBack
struct	CallBack< void(Args...)>
struct	ColorSpec
class	ConjugationInfo
	Class encapsulating necesarry data to place conjugation matrices in amplitudes when treating Majorana fermions. More...
class	ConjugationList
class	ConjugationSimplifier
class	DiracFermion
	Dirac or Majorana fermion in MARTY. More...
class	DiracSpace
struct	disable_model
class	double_vector
class	double_vector_iterator
class	double_vector_single_view
class	Drawer
class	E6Gauged
class	E7Gauged
class	E8Gauged
struct	enable_model
class	Expander
class	F4Gauged
class	FermionChain
class	FermionCurrent
struct	FermionLine
class	FermionPropStruct
class	FeynmanDiagram
	Class containing a Feynman diagram, symbolic expression and graph included. More...
class	FeynmanIntegral
class	FeynmanRule
	Represents a Feynman rule. More...
class	FeynOptions
	Instances of this class can be given to mty::Model when launching a calculation to customize the output. More...
struct	FeynruleKey
class	FeynruleMomentum
struct	FeynruleTarget
class	FieldStrength
	Field strength object in MARTY. More...
class	Flavor
class	FlavorGroup
class	FlavorIrrep
class	G2Gauged
class	Gauge
class	GaugeBoson
	Gauge boson implementation in MARTY. More...
class	GaugedGroup
class	GaugeIrrep
class	Generator
class	GeneratorElement
class	GeneratorParent
class	GhostBoson
	Ghost boson, created with the vector bosons in non abelian gauge groups. More...
class	GoldstoneBoson
	Goldstone boson class. More...
struct	IndexData
class	Insertion
struct	InsertionRequirement
class	InteractionTerm
	Interaction term (in the Lagrangian) in MARTY. More...
class	Irrep
	Handles the irreducible representation of a given semi-simple algebra. More...
class	IrrepMap
class	iterable_view
class	JSONToHEP
	Reads a file in .json format containing data of a model and returns the corresponding Model object via its only static public function readModel. More...
class	Kinematics
	Stores insertion and momenta data and provides a simple interface to manipulate it. More...
class	Lagrangian
	Interaction lagrangian of a model, allows to get all diagrams for a particular process by expanding it the exponential way. More...
class	Library
class	LoopToolsInitializer
struct	MassBlock
	Helper struct to store mass block data when diagonalizing. More...
class	Model
	Contains all objects in the theory. In particular QuantumField objects, Gauge, Flavor, Particle... More...
class	ModelBuilder
	Class containing all model building features of MARTY. More...
class	ModelData
	The class ModelData contains all the necessary features to store and manipulate the content of a model. No model building (symmetry breaking, replacements etc) or computation are implemented in it. More...
class	MomentumConservater
struct	MSSM_Data
class	MSSM_HEM
class	MSSM_Model
	Base class for MSSM models. If taken as is, represents the unconstrained MSSM with 105 parameters (+SM). More...
class	NMFV_Model
class	NonAbelianGauged
struct	OpInsertion
class	Particle
	This class inherits from std::shared_ptr<QuantumFieldParent> and should be used instead of direct QuantumFieldParent. More...
struct	ParticleInsertion
struct	PartitionPair
struct	PartnerShip
	Structure containing data about fermion ordering. More...
struct	PenguinPatchData
class	PMSSM_data
class	PMSSM_LEM
class	PMSSM_Model
class	PolarizationField
	Representing polarization vectors in equations. Allows to compute polarization sums in cross-sections. Is derived from TensorFieldElement: possess at least one csl::Index (polarization) and one "space-time point" that is the impulsion of the particle. More...
class	Propagator
class	QCD_Model
class	QED_Model
class	QuantumField
	Class deriving from csl::TensorFieldElement, may enter expressions. In contrary to QuantumFieldParent, it is not a inherited from any class. More...
class	QuantumFieldParent
	Base class for parents of QuantumField objects. More...
class	QuantumNumber
	This class represents quantum numbers of a theory, like for example baryon number B, lepton number L etc. More...
class	ScalarBoson
	Scalar boson, spin 0 particles in MARTY. More...
class	SemiSimpleAlgebra
	Abstract base class for all semi-simple Lie algebras. More...
class	SemiSimpleGroup
	Base class for all Semi simple groups, i.e. groups that has a SemiSimpleAlgebra. More...
class	SM_Model
	Standard Model of particle physics. More...
class	SOGauged
class	Spectrum
	Class handling numerical diagonalization for HEP models. More...
class	SpGauged
class	SUGauged
class	SumGaugeIrrep
class	SumIrrep
	Contains a sum of Irrep (irreducible representation) of a given SemiSimpleAlgebra. More...
class	TraceIdentity
class	TwoHDM_Model
class	U1Gauged
class	VectorBoson
	Implementation of vector bosons in AMRTY. More...
class	WeylFermion
	Weyl fermion, two-component Chiral particle. More...
class	Wick
	csl compatible expression representing the operator <> of correlators in quantum field theory. Applies only on QuantumField, and uses WickCalculator to evaluate to expression (applying wick theorem). More...
struct	Wilson
class	WilsonCoefficient
class	WilsonOperator
struct	WilsonSet
struct	Z2_charges
struct	Z2_charges< 1 >
struct	Z2_charges< 2 >
struct	Z2_charges< 3 >
struct	Z2_charges< 4 >

Typedefs
typedef class mty::AbstractGroup	Group
	Abstract base class for groups. More...
template<size_t N>
using	GIndex_t = std::pair< std::array< int, N >, long long int >
using	ComplexType = std::complex< double >
using	RealType = double
using	FieldList = ConjugationInfo::FieldList

Enumerations
enum	DiracCoupling {   S,   P,   L,   R,   V,   A,   VL,   VR,   T,   TA,   TL,   TR }
enum	ColorCoupling {   Id,   Generator,   Crossed,   InvCrossed }
enum	Order {   TreeLevel,   OneLoop }
enum	IntegralType {   None,   A,   B,   C,   D,   E }
enum	IntegralID_E {   ee0 = 0,   ee1 = 3,   ee2 = 6,   ee3 = 9,   ee4 = 12,   ee00 = 15,   ee11 = 18,   ee12 = 21,   ee13 = 24,   ee14 = 27,   ee22 = 30,   ee23 = 33,   ee24 = 36,   ee33 = 39,   ee34 = 42,   ee44 = 45,   ee001 = 48,   ee002 = 51,   ee003 = 54,   ee004 = 57,   ee111 = 60,   ee112 = 63,   ee113 = 66,   ee114 = 69,   ee122 = 72,   ee123 = 75,   ee124 = 78,   ee133 = 81,   ee134 = 84,   ee144 = 87,   ee222 = 90,   ee223 = 93,   ee224 = 96,   ee233 = 99,   ee234 = 102,   ee244 = 105,   ee333 = 108,   ee334 = 111,   ee344 = 114,   ee444 = 117,   ee0000 = 120,   ee0011 = 123,   ee0012 = 126,   ee0013 = 129,   ee0014 = 132,   ee0022 = 135,   ee0023 = 138,   ee0024 = 141,   ee0033 = 144,   ee0034 = 147,   ee0044 = 150,   ee1111 = 153,   ee1112 = 156,   ee1113 = 159,   ee1114 = 162,   ee1122 = 165,   ee1123 = 168,   ee1124 = 171,   ee1133 = 174,   ee1134 = 177,   ee1144 = 180,   ee1222 = 183,   ee1223 = 186,   ee1224 = 189,   ee1233 = 192,   ee1234 = 195,   ee1244 = 198,   ee1333 = 201,   ee1334 = 204,   ee1344 = 207,   ee1444 = 210,   ee2222 = 213,   ee2223 = 216,   ee2224 = 219,   ee2233 = 222,   ee2234 = 225,   ee2244 = 228,   ee2333 = 231,   ee2334 = 234,   ee2344 = 237,   ee2444 = 240,   ee3333 = 243,   ee3334 = 246,   ee3344 = 249,   ee3444 = 252,   ee4444 = 255,   ee00001 = 258,   ee00002 = 261,   ee00003 = 264,   ee00004 = 267,   ee00111 = 270,   ee00112 = 273,   ee00113 = 276,   ee00114 = 279,   ee00122 = 282,   ee00123 = 285,   ee00124 = 288,   ee00133 = 291,   ee00134 = 294,   ee00144 = 297,   ee00222 = 300,   ee00223 = 303,   ee00224 = 306,   ee00233 = 309,   ee00234 = 312,   ee00244 = 315,   ee00333 = 318,   ee00334 = 321,   ee00344 = 324,   ee00444 = 327,   ee11111 = 330,   ee11112 = 333,   ee11113 = 336,   ee11114 = 339,   ee11122 = 342,   ee11123 = 345,   ee11124 = 348,   ee11133 = 351,   ee11134 = 354,   ee11144 = 357,   ee11222 = 360,   ee11223 = 363,   ee11224 = 366,   ee11233 = 369,   ee11234 = 372,   ee11244 = 375,   ee11333 = 378,   ee11334 = 381,   ee11344 = 384,   ee11444 = 387,   ee12222 = 390,   ee12223 = 393,   ee12224 = 396,   ee12233 = 399,   ee12234 = 402,   ee12244 = 405,   ee12333 = 408,   ee12334 = 411,   ee12344 = 414,   ee12444 = 417,   ee13333 = 420,   ee13334 = 423,   ee13344 = 426,   ee13444 = 429,   ee14444 = 432,   ee22222 = 435,   ee22223 = 438,   ee22224 = 441,   ee22233 = 444,   ee22234 = 447,   ee22244 = 450,   ee22333 = 453,   ee22334 = 456,   ee22344 = 459,   ee22444 = 462,   ee23333 = 465,   ee23334 = 468,   ee23344 = 471,   ee23444 = 474,   ee24444 = 477,   ee33333 = 480,   ee33334 = 483,   ee33344 = 486,   ee33444 = 489,   ee34444 = 492,   ee44444 = 495,   eeLAST = 498 }
enum	IntegralID_D {   dd0 = 0,   dd1 = 3,   dd2 = 6,   dd3 = 9,   dd00 = 12,   dd11 = 15,   dd12 = 18,   dd13 = 21,   dd22 = 24,   dd23 = 27,   dd33 = 30,   dd001 = 33,   dd002 = 36,   dd003 = 39,   dd111 = 42,   dd112 = 45,   dd113 = 48,   dd122 = 51,   dd123 = 54,   dd133 = 57,   dd222 = 60,   dd223 = 63,   dd233 = 66,   dd333 = 69,   dd0000 = 72,   dd0011 = 75,   dd0012 = 78,   dd0013 = 81,   dd0022 = 84,   dd0023 = 87,   dd0033 = 90,   dd1111 = 93,   dd1112 = 96,   dd1113 = 99,   dd1122 = 102,   dd1123 = 105,   dd1133 = 108,   dd1222 = 111,   dd1223 = 114,   dd1233 = 117,   dd1333 = 120,   dd2222 = 123,   dd2223 = 126,   dd2233 = 129,   dd2333 = 132,   dd3333 = 135,   dd00001 = 138,   dd00002 = 141,   dd00003 = 144,   dd00111 = 147,   dd00112 = 150,   dd00113 = 153,   dd00122 = 156,   dd00123 = 159,   dd00133 = 162,   dd00222 = 165,   dd00223 = 168,   dd00233 = 171,   dd00333 = 174,   dd11111 = 177,   dd11112 = 180,   dd11113 = 183,   dd11122 = 186,   dd11123 = 189,   dd11133 = 192,   dd11222 = 195,   dd11223 = 198,   dd11233 = 201,   dd11333 = 204,   dd12222 = 207,   dd12223 = 210,   dd12233 = 213,   dd12333 = 216,   dd13333 = 219,   dd22222 = 222,   dd22223 = 225,   dd22233 = 228,   dd22333 = 231,   dd23333 = 234,   dd33333 = 237,   ddLAST = 240 }
enum	IntegralID_C {   cc0 = 0,   cc1 = 3,   cc2 = 6,   cc00 = 9,   cc11 = 12,   cc12 = 15,   cc22 = 18,   cc001 = 21,   cc002 = 24,   cc111 = 27,   cc112 = 30,   cc122 = 33,   cc222 = 36,   cc0000 = 39,   cc0011 = 42,   cc0012 = 45,   cc0022 = 48,   cc1111 = 51,   cc1112 = 54,   cc1122 = 57,   cc1222 = 60,   cc2222 = 63,   ccLAST = 66 }
enum	IntegralID_B {   bb0 = 0,   bb1 = 3,   bb00 = 6,   bb11 = 9,   bb001 = 12,   bb111 = 15,   bbLAST = 18 }
enum	IntegralID_A {   aa0 = 0,   aa00 = 3,   aaLAST = 6 }
enum	DecompositionMode {   Minimal,   BasisProjection,   Matching }
enum	OperatorBasis {   OperatorBasis::Chiral,   OperatorBasis::Standard,   OperatorBasis::None }
	Operator basis for Wilson coefficients. More...
enum	Chirality {   Chirality::Left = 0,   Chirality::Right = 1,   Chirality::None = 2 }
	Chirality for fermions. Either Left or Right for WeylFermion, or None for DiracFermion. More...
enum	ParticleType {   ScalarBoson,   VectorBoson,   FieldStrength,   GhostBoson,   GoldstoneBoson,   WeylFermion,   DiracFermion }

Functions
std::pair< csl::Expr, csl::Expr >	Z2_coef (int charge)
csl::Expr	Z2_mass_coef (csl::Expr const &v1, csl::Expr const &v2, int charge)
template<int t_type>
std::ostream &	operator<< (std::ostream &out, TwoHDM_Model< t_type > const &model)
csl::Expr	bernoulliCombinatorial (size_t i, size_t j)
csl::Expr	bernoulliRecursion (std::vector< csl::Expr > const &B, size_t n)
csl::Expr	bernoulliNumber (size_t i)
std::vector< Wilson >	getMagneticCoupling (DiracCoupling coupling, csl::Index alpha, csl::Index beta)
csl::Expr	getMagneticGenerator (mty::Model const &model, csl::Expr &psi_star, csl::Expr &psi, csl::Expr &A)
std::vector< Wilson >	chromoMagneticOperator (Model const &model, WilsonSet const &wilsons, DiracCoupling coupling)
std::vector< Wilson >	dimension6Operator (Model const &model, WilsonSet const &wilsons, DiracCoupling leftCurrent, DiracCoupling rightCurrent, std::vector< ColorSpec > const &colorCouplings, std::vector< int > fermionOrder={})
std::vector< Wilson >	dimension6Operator (Model const &model, WilsonSet const &wilsons, DiracCoupling leftCurrent, DiracCoupling rightCurrent, std::vector< int > fermionOrder={})
std::vector< Wilson >	dimension6Operator (Model const &model, WilsonSet const &wilsons, DiracCoupling leftCurrent, DiracCoupling rightCurrent, ColorSpec const &colorCoupling, std::vector< int > fermionOrder={})
csl::Tensor	buildCKM (const csl::Space *flavorSpace)
csl::Expr	CalculateFColorTrace (csl::Expr const &expr)
csl::Expr	CalculateTrace (const mty::SemiSimpleGroup *colorGroup, const csl::Expr &expr)
csl::Expr	CalculateColorTrace (csl::Expr const &init)
csl::Expr	slashed_s (csl::Tensor p, const csl::Index &alpha, const csl::Index &beta, const DiracSpace *space=&dirac4)
csl::Expr	bar_s (const csl::Expr &tensor, const DiracSpace *space=&dirac4)
std::vector< FermionCurrent >	parseChains (csl::Expr &product, DiracSpace const *diracSpace, bool findAbrev=false)
std::ostream &	operator<< (std::ostream &out, FermionCurrent::Type type)
std::ostream &	operator<< (std::ostream &out, ConjugationInfo::Type type)
std::ostream &	operator<< (std::ostream &out, ConjugationInfo const &info)
ConjugationInfo::FieldList::iterator	getExternalBegin (ConjugationInfo::FieldList &fields)
ConjugationInfo::FieldList::iterator	getInternalBegin (ConjugationInfo::FieldList &fields)
ConjugationInfo::FieldList::iterator	getBegin (ConjugationInfo::FieldList &fields)
template<class ... Args>
Particle	weylfermion_s (Args &&...args)
	Delegates the construction of a Weyl fermion and returns the result. More...
template<class ... Args>
Particle	diracfermion_s (Args &&...args)
	Delegates the construction of a Dirac fermion and returns the result. More...
bool	ordered (mty::Insertion const &left, mty::Insertion const &right)
std::vector< mty::Insertion const * >	fermionsOf (std::vector< mty::Insertion > const &fields)
std::vector< mty::Insertion * >	fermionsOf (std::vector< mty::Insertion > &fields)
std::vector< int >	defaultFermionOrder (std::vector< mty::Insertion const *> const &fields)
std::vector< int >	defaultFermionOrder (std::vector< mty::Insertion > const &fields)
void	applyFermionOrder (std::vector< mty::Insertion > &insertions, std::vector< int > const &order)
void	applyDefaultFermionOrder (std::vector< mty::Insertion > &insertions)
std::ostream &	operator<< (std::ostream &out, IntegralType type)
void	printLooptoolsId (IntegralType type, int id, std::ostream &out)
void	printLooptoolsId_A (int id, std::ostream &out)
void	printLooptoolsId_B (int id, std::ostream &out)
void	printLooptoolsId_C (int id, std::ostream &out)
void	printLooptoolsId_D (int id, std::ostream &out)
void	printLooptoolsId_E (int id, std::ostream &out)
int	loopToolsBegin (IntegralType type, size_t nIndices)
int	loopToolsIdOf (IntegralType type, std::vector< size_t > const &indices)
int	loopToolsIdOf_A (std::vector< size_t > const &indices)
int	loopToolsIdOf_B (std::vector< size_t > const &indices)
int	loopToolsIdOf_C (std::vector< size_t > const &indices)
int	loopToolsIdOf_D (std::vector< size_t > const &indices)
size_t	nPropagatorForIntegral (IntegralType type)
size_t	nIndicesForIntegral (IntegralType type)
size_t	nArgumentsForIntegral (IntegralType type)
csl::Expr	getDivergentFactor (IntegralType type, int integral_id, std::vector< csl::Expr > const &arguments)
csl::Expr	psquared (csl::Expr const &p)
csl::Expr	psquared (csl::Expr const &p1, csl::Expr const &p2)
csl::Expr	psum (csl::Expr const &p1, csl::Expr const &p2)
csl::Expr	feynmanintegral_s (IntegralType t_type, int t_looptoolsId, std::vector< csl::Expr > const &t_argument)
csl::Expr	feynmanintegral_s (IntegralType t_type, int t_looptoolsId, std::vector< csl::Expr > const &t_argument, std::vector< size_t > const &indices)
template<class IntegralID >
csl::Expr	feynmanintegral_s (IntegralType t_type, IntegralID t_looptoolsId, std::vector< csl::Expr > const &t_argument)
int	fermionicFactor (std::vector< mty::QuantumField > const &fieldProduct)
std::unique_ptr< GaugedGroup >	createGaugedGroup (SemiSimpleGroup *group, Gauge *gauge, std::string nameBoson, bool addGhost=true, const csl::Expr &coupling=CSL_UNDEF)
template<class ... Args>
std::shared_ptr< GeneratorParent >	generator_s (Args &&...args)
template<class ... Args>
csl::Expr	generatorelement_s (Args &&...args)
Particle	ghostboson_s (std::string const &name, std::shared_ptr< VectorBoson > const &t_vectorBoson, bool conjugated=false)
	Creates a ghost boson. More...
Particle	ghostboson_s (std::shared_ptr< VectorBoson > const &t_vectorBoson, bool conjugated=false)
	Creates a ghost boson. More...
Particle	ghostboson_s (std::string const &name, Particle const &t_vectorBoson, bool conjugated=false)
	Creates a ghost boson. More...
Particle	ghostboson_s (Particle const &t_vectorBoson, bool conjugated=false)
	Creates a ghost boson. More...
Particle	goldstoneboson_s (std::string const &name, std::shared_ptr< VectorBoson > const &t_vectorBoson)
	Creates a goldstone boson. More...
Particle	goldstoneboson_s (std::shared_ptr< VectorBoson > const &t_vectorBoson)
	Creates a goldstone boson. More...
Particle	goldstoneboson_s (std::string const &name, Particle const &t_vectorBoson)
	Creates a goldstone boson. More...
Particle	goldstoneboson_s (Particle const &t_vectorBoson)
	Creates a goldstone boson. More...
std::unique_ptr< mty::SemiSimpleGroup >	createGroup (group::Type type, std::string const &name, int dim=-1)
	Dynamically allocates a new group of type type and returns a pointer to it (in a std::unique_ptr). More...
std::unique_ptr< mty::SemiSimpleGroup >	createGroup (group::Type type, int dim=-1)
	Dynamically allocates a new group of type type and returns a pointer to it (in a std::unique_ptr). More...
std::ostream &	operator<< (std::ostream &fout, const AbstractGroup &obj)
	Overload of operator<< for AbstractGroup. Displays the type of the group and its dimension between brackets. More...
group::Type	stringToGroupType (std::string const &name)
	Converts a string to a group type. Allows to read a group::Type in a file. More...
template<class Type , size_t N>
std::array< Type, N >	toArray (std::vector< Type > const &vec)
bool	isIndexZeroSU (std::vector< int > const &rep, size_t p)
bool	isIndexZeroEvenSO (std::vector< int > const &rep, size_t p)
bool	isIndexZeroOddSO (std::vector< int > const &rep, size_t p)
bool	isIndexZeroSp (std::vector< int > const &rep, size_t p)
bool	isIndexZeroE6 (std::vector< int > const &rep, size_t p)
bool	isIndexZeroE7 (std::vector< int > const &rep, size_t p)
bool	isIndexZeroE8 (std::vector< int > const &rep, size_t p)
bool	isIndexZeroF4 (std::vector< int > const &rep, size_t p)
bool	isIndexZeroG2 (std::vector< int > const &rep, size_t p)
csl::Expr	getIndexNorm (algebra::Type algebra, std::vector< int > const &rep, size_t n)
csl::Expr	getSUIndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getEvenSOIndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getOddSOIndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getSpIndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getE6IndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getE7IndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getE8IndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getF4IndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getG2IndexNorm (std::vector< int > const &rep, size_t n)
csl::Expr	getIndex (algebra::Type algebra, std::vector< int > const &rep, size_t n)
csl::Expr	getSUIndex (std::vector< int > const &rep, size_t n)
csl::Expr	getEvenSOIndex (std::vector< int > const &rep, size_t n)
csl::Expr	getOddSOIndex (std::vector< int > const &rep, size_t n)
csl::Expr	getLastEvenSOIndex (std::vector< int > const &rep, size_t n, bool normalize=true)
csl::Expr	getSpIndex (std::vector< int > const &rep, size_t n)
csl::Expr	getE6Index (std::vector< int > const &rep, size_t n)
csl::Expr	getE7Index (std::vector< int > const &rep, size_t n)
csl::Expr	getE8Index (std::vector< int > const &rep, size_t n)
csl::Expr	getF4Index (std::vector< int > const &rep, size_t n)
csl::Expr	getG2Index (std::vector< int > const &rep, size_t n)
Insertion	OnShell (Insertion const &init)
Insertion	OffShell (Insertion const &init)
Insertion	Incoming (Insertion const &init)
Insertion	Outgoing (Insertion const &init)
Insertion	AntiPart (Insertion const &init)
Insertion	Mediator (Insertion const &init)
Insertion	Left (Insertion const &init)
Insertion	Right (Insertion const &init)
std::vector< Insertion >	AntiPart (std::vector< Insertion > const &init)
csl::Expr	GetExpression (Insertion const &init)
std::vector< csl::Expr >	GetExpression (std::vector< Insertion > const &insertions)
std::vector< Insertion >	GetInsertion (std::vector< csl::Expr > const &insertions)
mty::interaction::Type	determineTermType (const InteractionTerm &term)
csl::Expr	getLocalTerm (IntegralType type, std::vector< size_t > const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	getLocalATerm (std::string const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	getLocalBTerm (std::string const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	getLocalCTerm (std::string const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	getLocalDTerm (std::string const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	getLocalETerm (std::string const &indices, std::vector< csl::Expr > const &momentum, std::vector< csl::Expr > const &masses)
csl::Expr	complexToExpr (ComplexType const &complexNumber)
ComplexType	exprToComplexType (csl::Expr const &init)
double	exprToRealType (csl::Expr const &init)
std::vector< ComplexType >	exprToComplexType (std::vector< csl::Expr > const &init)
std::vector< double >	exprToRealType (std::vector< csl::Expr > const &init)
std::optional< std::vector< RealType > >	isReal (std::vector< ComplexType > const &init)
ComplexType	A0i_runtime (int id, std::vector< RealType > const &arguments)
ComplexType	B0i_runtime (int id, std::vector< RealType > const &arguments)
ComplexType	C0i_runtime (int id, std::vector< RealType > const &arguments)
ComplexType	D0i_runtime (int id, std::vector< RealType > const &arguments)
ComplexType	E0i_runtime (int id, std::vector< RealType > const &arguments)
ComplexType	A0i_runtime (int id, std::vector< ComplexType > const &arguments)
ComplexType	B0i_runtime (int id, std::vector< ComplexType > const &arguments)
ComplexType	C0i_runtime (int id, std::vector< ComplexType > const &arguments)
ComplexType	D0i_runtime (int id, std::vector< ComplexType > const &arguments)
ComplexType	E0i_runtime (int id, std::vector< ComplexType > const &arguments)
ComplexType	A0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	B0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	C0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	D0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	E0i_runtime (int id, std::vector< csl::Expr > const &arguments)
__complex128	A0iCq (int id, __complex128 const &m1)
__complex128	B0iCq (int id, __complex128 const &p1, __complex128 const &m1, __complex128 const &m2)
__complex128	C0iCq (int id, __complex128 const &p1, __complex128 const &p2, __complex128 const &p3, __complex128 const &m1, __complex128 const &m2, __complex128 const &m3)
__complex128	D0iCq (int id, __complex128 const &p1, __complex128 const &p2, __complex128 const &p3, __complex128 const &p4, __complex128 const &p5, __complex128 const &p6, __complex128 const &m1, __complex128 const &m2, __complex128 const &m3, __complex128 const &m4)
__complex128	E0iCq (int id, __complex128 const &p1, __complex128 const &p2, __complex128 const &p3, __complex128 const &p4, __complex128 const &p5, __complex128 const &p6, __complex128 const &p7, __complex128 const &p8, __complex128 const &p9, __complex128 const &p10, __complex128 const &m1, __complex128 const &m2, __complex128 const &m3, __complex128 const &m4, __complex128 const &m5)
int	operatorDegeneracy (std::vector< mty::Insertion > const &insertions)
int	matchingFermionSign (std::vector< int > fermionOrder)
int	fermionSign (std::vector< Insertion > const &model, std::vector< Insertion > order)
csl::Tensor	MinkowskiVector (std::string const &name)
	Returns a csl::Tensor, vector in csl::Minkowski space. More...
csl::Index	MinkowskiIndex (std::string const &name="")
	Returns a csl::Index in csl::Minkowki space. More...
std::vector< csl::Index >	DiracIndices (size_t n, std::string const &name="")
	Returns indices in the 4-dimensional Dirac space mty::dirac4. More...
std::vector< csl::Index >	MinkowskiIndices (size_t n, std::string const &name="")
	Returns indices in csl::Minkowki space. More...
csl::Index	DiracIndex (std::string const &name="")
	Returns a csl::Index in the 4-dimensional Dirac space mty::dirac4. More...
template<class GroupType , class FieldType >
csl::Index	GaugeIndex (std::string const &nameIndex, mty::Model const &model, GroupType &&group, FieldType &&part)
	Returns a csl::Index living in the representation of a certain field in a certain group. More...
template<class GroupType >
csl::Index	FlavorIndex (mty::Model const &model, GroupType &&group)
	Returns a csl::Index for a given flavor group. More...
template<class GroupType >
std::vector< csl::Index >	FlavorIndices (size_t nIndices, mty::Model const &model, GroupType &&group)
	Returns indices for a given flavor group. More...
template<class GroupType , class FieldType >
csl::Index	GaugeIndex (mty::Model const &model, GroupType &&group, FieldType &&part)
	Returns a csl::Index living in the representation of a certain field in a certain group. More...
template<class GroupType , class FieldType >
std::vector< csl::Index >	GaugeIndices (size_t nIndices, mty::Model const &model, GroupType &&group, FieldType &&part)
	Returns indices living in the representation of a certain field in a certain group. More...
const csl::Space *	VectorSpace (mty::Model const &model, std::string const &nameGroup, Particle const &part)
	Returns the vector space corresponding to the representation of a given particle in a given group. More...
csl::Index	GenerateIndex (csl::Space const *space, std::string const &name="")
	Generates an index in a given space. More...
csl::Tensor	Delta (const csl::Space *space)
	Returns the Kronecker delta of a given vector space. More...
csl::Tensor	Metric (const csl::Space *space)
	Returns the metric of a given vector space. More...
csl::Tensor	Epsilon (const csl::Space *space)
	Returns the epsilon symbol of a given vector space. More...
csl::Tensor	DiracGamma ()
csl::Tensor	DiracGamma5 ()
csl::Tensor	DiracSigma ()
csl::Tensor	DiracPL ()
csl::Tensor	DiracPR ()
csl::Tensor	DiracProjector (Chirality chir)
	Returns a projector in Dirac 4-dim space depending on a chirality. More...
csl::Tensor	DiracCMatrix ()
template<class GroupType , class FieldType >
mty::Generator	GetGenerator (mty::Model &model, GroupType &&group, FieldType &&field)
	Returns the generator coresponding to the representation of a field in a given group. More...
template<class GroupType , class FieldType >
csl::Space const *	GetVectorSpace (mty::Model &model, GroupType &&group, FieldType &&field)
	Returns the vector space corresponding the the representation of a given field in a given group. More...
Amplitude	SelfEnergy (mty::Order order, mty::Particle &particle, mty::Model &model)
Amplitude	SelfEnergy (mty::Particle &particle, mty::Model &model)
csl::Expr	ComputeSquaredAmplitude (mty::Model &model, Amplitude const &ampl)
std::vector< FeynmanRule >	ComputeFeynmanRules (mty::Model &model)
void	ContractIndices (csl::Expr &init)
void	ContractIndices (std::vector< csl::Expr > &init)
void	Display (std::vector< FeynmanRule > const &rules, std::ostream &out=std::cout)
void	Display (std::vector< csl::Expr > const &amplitudes, std::ostream &out=std::cout, bool simplify=false)
void	Display (mty::Amplitude const &amplitudes, std::ostream &out=std::cout, bool simplify=false)
void	Display (WilsonSet const &wilsons, std::ostream &out=std::cout)
void	Show (std::vector< FeynmanRule > const &rules)
void	Show (std::vector< std::shared_ptr< wick::Graph >> const &diagrams)
void	Show (mty::Amplitude const &diagrams)
void	Show (WilsonSet const &wilsons)
void	Show (std::vector< FeynmanRule > const &rules, size_t first, size_t last)
void	Show (std::vector< std::shared_ptr< wick::Graph >> const &diagrams, size_t first, size_t last)
void	Show (mty::Amplitude const &diagrams, size_t first, size_t last)
void	Show (WilsonSet const &wilsons, size_t first, size_t last)
template<class T >
void	Display (T const &printable, std::ostream &out=std::cout)
void	DisplayAbbreviations (std::ostream &out=std::cout)
void	DisplayAbbreviations (std::string const &name, std::ostream &out=std::cout)
void	ExportPDF (std::string const &nameFiles, std::vector< std::shared_ptr< wick::Graph >> const &graphs)
void	ExportPDF (std::string const &nameFiles, std::vector< FeynmanRule > const &rules)
void	ExportPNG (std::string const &nameFiles, std::vector< std::shared_ptr< wick::Graph >> const &graphs)
void	ExportPNG (std::string const &nameFiles, std::vector< FeynmanRule > const &rules)
template<class ... Args>
void	AddGaugedGroup (mty::Model &model, Args &&...args)
template<class ... Args>
void	AddFlavorGroup (mty::Model &model, Args &&...args)
void	AddParticle (mty::Model &model, mty::Particle &particle, bool initTerms=true)
void	AddTerm (mty::Model &model, csl::Expr const &term, bool addCC=false)
void	AddTerm (mty::Model &model, std::vector< csl::Expr > const &terms, bool addCC=false)
mty::Particle	GetParticle (mty::Model const &model, std::string const &name)
csl::Expr	GetMass (mty::Particle const &particle)
mty::Particle	GenerateSimilarParticle (std::string const &name, mty::Particle const &particle)
mty::Particle	GetFieldStrength (Particle const &particle)
void	PromoteGoldstone (mty::Model &model, mty::Particle &goldstone, mty::Particle &gaugeBoson)
void	PromoteGoldstone (mty::Model &model, char const *goldstone, char const *gaugeBoson)
csl::Expr	GetCoupling (mty::Model const &model, std::string const &nameCoupling)
csl::Tensor	GetYukawa (mty::Model const &model, std::string const &nameCoupling)
void	Rename (mty::Model &model, std::string const &oldName, std::string const &newName)
template<class ... Args>
void	SetMass (Particle &part, Args &&...args)
template<class ... Args>
void	SetWidth (Particle &part, Args &&...args)
void	SetSelfConjugate (Particle &part, bool selfConjugate)
void	SetGroupRep (mty::Particle &part, std::string const &nameGroup, std::vector< int > const &highestWeight)
void	SetGroupRep (mty::Particle &part, std::string const &nameGroup, int charge)
void	SetFlavorRep (mty::Particle &part, std::string const &nameGroup)
void	Init (mty::Model &model)
void	Replaced (mty::Model &model, csl::Expr const &init, csl::Expr const &target)
	Replaces an expression in all kinetic / mass / interactions terms of a model. More...
void	Replaced (mty::Model &model, csl::Tensor &init, csl::Expr const &target)
	Replaces an expression in all kinetic / mass / interactions terms of a model. More...
void	Replaced (mty::Model &model, csl::Tensor &init, csl::Tensor &target)
	Replaces an expression in all kinetic / mass / interactions terms of a model. More...
void	Replaced (mty::Model &model, Particle const &particle, csl::Expr const &newTerm)
	Replaces a particle in all kinetic / mass / interactions terms of a model. More...
void	Rotate (mty::Model &model, std::vector< mty::Particle > const &fields, std::vector< mty::Particle > const &newFields, std::vector< std::vector< csl::Expr >> const &rotation, bool diagonalizeMasses=false)
	Rotates a bunch of fields to another using a given matrix. More...
void	Rotate (mty::Model &model, std::vector< std::string > const &fields, std::vector< std::string > const &newFields, std::vector< std::vector< csl::Expr >> const &rotation, bool diagonalizeMasses=false)
	Rotates a bunch of fields to another using a given matrix. More...
void	DiagonalizeMassMatrices (mty::Model &model)
void	BreakGaugeSymmetry (mty::Model &model, std::string const &brokenGroup, std::vector< Particle > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakGaugeSymmetry (mty::Model &model, std::string const &brokenGroup, std::initializer_list< std::string > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakFlavorSymmetry (mty::Model &model, std::string const &brokenFlavor, std::initializer_list< std::string > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakFlavorSymmetry (mty::Model &model, std::string const &brokenFlavor, std::vector< mty::Particle > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
template<class ... Args>
void	BreakGaugeSymmetry (mty::Model &model, Args &&...args)
template<class ... Args>
void	BreakFlavorSymmetry (mty::Model &model, Args &&...args)
void	Refreshed (mty::Model &model)
void	IntegrateOutParticle (mty::Particle &particle, bool value=true)
std::unique_ptr< mty::SemiSimpleAlgebra >	CreateAlgebra (algebra::Type type, int l=-1)
	Creates a specilization of SemiSimpleAlgebra of type type. More...
mty::Irrep	GetIrrep (mty::SemiSimpleAlgebra const *algebra, std::vector< int > const &labels)
mty::Irrep	GetIrrep (std::unique_ptr< mty::SemiSimpleAlgebra > const &algebra, std::vector< int > const &labels)
mty::Irrep	GetConjugateRep (mty::Irrep const &rep)
mty::SemiSimpleAlgebra const *	GetAlgebraOf (Irrep const &rep)
int	GetDimension (mty::Irrep const &irrep)
bool	ContainsIrrep (mty::SumIrrep const &decomposition, mty::Irrep const &irrep)
bool	ContainsTrivialrep (mty::SumIrrep const &decomposition)
void	SetGaugeChoice (mty::Model &model, std::string const &nameParticle, mty::gauge::Type choice)
	This function changes the gauge fixing parameter for the gauge boson of name nameGroup. Depending on this choice, the propagator of gauge bosons is modified. More...
void	SetGaugeChoice (mty::Particle particle, mty::gauge::Type choice)
	This function changes the gauge choice in model for the gauge boson particle. Depending on this choice, the propagator of gauge bosons is modified. More...
std::string	FindProcessName (std::string const &initName, std::vector< mty::Insertion > const &insertions)
Amplitude	SelfEnergy (mty::Order order, mty::Particle &particle)
Amplitude	SelfEnergy (mty::Particle &particle)
std::vector< FeynmanRule >	ComputeFeynmanRules ()
template<class ... Args>
void	AddGaugedGroup (Args &&...args)
void	AddParticle (mty::Particle &particle, bool initTerms=true)
void	AddTerm (csl::Expr const &term, bool addCC=false)
void	AddTerm (std::vector< csl::Expr > const &terms, bool addCC=false)
mty::Particle	GetParticle (std::string const &name)
void	PromoteGoldstone (mty::Particle &goldstone, mty::Particle &gaugeBoson)
void	PromoteGoldstone (char const *goldstone, char const *gaugeBoson)
csl::Expr	GetCoupling (std::string const &nameCoupling)
csl::Tensor	GetYukawa (std::string const &nameCoupling)
void	Rename (std::string const &oldName, std::string const &newName)
void	Init ()
void	Replaced (csl::Expr const &init, csl::Expr const &target)
void	Replaced (csl::Tensor &init, csl::Expr const &target)
void	Replaced (csl::Tensor &init, csl::Tensor &target)
void	Replaced (Particle const &particle, csl::Expr const &newTerm)
void	Rotate (std::vector< mty::Particle > const &fields, std::vector< mty::Particle > const &newFields, std::vector< std::vector< csl::Expr >> const &rotation, bool diagonalizeMasses=false)
void	Rotate (std::vector< std::string > const &fields, std::vector< std::string > const &newFields, std::vector< std::vector< csl::Expr >> const &rotation, bool diagonalizeMasses=false)
void	DiagonalizeMassMatrices ()
void	BreakGaugeSymmetry (std::string const &brokenGroup, std::vector< Particle > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakGaugeSymmetry (std::string const &brokenGroup, std::initializer_list< std::string > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakFlavorSymmetry (std::string const &brokenFlavor, std::initializer_list< std::string > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	BreakFlavorSymmetry (std::string const &brokenFlavor, std::vector< mty::Particle > const &brokenFields, std::vector< std::vector< std::string >> const &newNames)
void	Refreshed ()
void	SetGaugeChoice (std::string const &nameParticle, gauge::Type choice)
template<typename T , typename U >
bool	IsOfType (std::shared_ptr< const U > const &expr)
template<typename T , typename U >
bool	IsOfType (U const *expr)
template<typename T , typename U >
bool	IsOfType (U const &expr)
template<typename T , typename U >
std::shared_ptr< T >	ConvertToShared (std::shared_ptr< U > const &expr)
template<typename T , typename U >
T *	ConvertToPtr (std::shared_ptr< U > const &expr)
template<typename T , typename U >
const T *	ConvertToPtr (const U *expr)
template<typename T , typename U >
T	ConvertTo (std::shared_ptr< U > const &expr)
template<typename T , typename U >
T &	ConvertTo (std::shared_ptr< U > &expr)
template<typename T , typename U >
T *	ConvertToPtr (U *parent)
std::ostream &	operator<< (std::ostream &out, NMFV_Model::Mixing mixing)
bool	requiresPenguinPatch (Amplitude const &amplitude)
	Tells if a set of wilson coefficients requires the penguin patch implemented in this file. This function must return true for the applyPenguinPatch() function to work (otherwise it raises an error). More...
void	applyPenguinPatch (std::vector< Wilson > &wilsons, Kinematics const &kinematics)
	Applies the patch for the on-shell calculation of penguins with massless vector. More...
csl::Expr	propagator_s (csl::Expr const &impulsion, csl::Expr const &mass, csl::Expr const &width=CSL_0)
csl::Expr	fermionPropStruct_s (csl::Expr const &impulsion, csl::Expr const &mass, csl::Index const &alpha, csl::Index const &beta)
Chirality	operator! (Chirality init)
	Returns the inverse chirality with respect to init. More...
std::ostream &	operator<< (std::ostream &out, Chirality chir)
std::ostream &	operator<< (std::ostream &out, ParticleType type)
template<typename ... Args>
csl::Expr	quantumfield_s (Args &&...args)
	Creates and returns an expression corresponding to a QuantumField. More...
csl::Expr	getMomentumSum (const std::vector< QuantumField > &insertions, const std::vector< csl::Tensor > &impulsions, const csl::Index &index)
	Creates and returns the sum of momentums in a process, taking into account incoming or outgoing particles.std. More...
std::ostream &	operator<< (std::ostream &fout, const mty::QuantumField &field)
	Overload of operator<< for QuantumField. Calls QuantumField::print(). More...
csl::Expr	ScalarKineticTerm (QuantumFieldParent &field, csl::Tensor &X)
csl::Expr	FermionKineticTerm (QuantumFieldParent &field, csl::Tensor &X)
csl::Expr	VectorKineticTerm (QuantumFieldParent &field, csl::Tensor &X)
csl::Expr	GhostKineticTerm (QuantumFieldParent &field, csl::Tensor &X)
csl::Expr	ReplaceXiGauge (csl::Expr const &initalTerm)
csl::Expr	ExponentialFactor (csl::Tensor &X, csl::Tensor &Y, csl::Tensor &P)
csl::Expr	StandardDenominator (csl::Tensor &P, csl::Expr const &mass, csl::Expr const &width, bool external=false)
csl::Expr	StandardDenominator (csl::Tensor &P, csl::Expr const &mass, bool external=false)
csl::Expr	NullPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	ScalarPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	FermionPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	VectorPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	FieldStrengthPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	FieldStrengthSquaredPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	IntegratedScalarPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	IntegratedFermionPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	IntegratedVectorPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	IntegratedFieldStrengthPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	IntegratedFieldStrengthSquaredPropagator (QuantumField const &A, QuantumField const &B, csl::Tensor &P, bool external)
csl::Expr	MajoranaMassTerm (csl::Expr const &mass, QuantumFieldParent *field)
csl::Expr	MajoranaMassTerm (csl::Expr const &mass, QuantumFieldParent *fieldL, QuantumFieldParent *fieldR)
csl::Expr	MassTerm (csl::Expr const &mass, QuantumFieldParent *field)
csl::Expr	MassTerm (csl::Expr const &mass, QuantumFieldParent *fieldL, QuantumFieldParent *fieldR)
csl::Expr	ExternalLeg (QuantumField const &field, const csl::Tensor &impulsion, bool ruleMode=false, bool lockConjugation=false)
csl::Expr	ExternalLeg (QuantumFieldParent &field, csl::Tensor impulsion, csl::Tensor point, std::vector< csl::Index > indices, bool particle, bool incoming, bool onshell, PartnerShip const &partnerShip, bool ruleMode=false, bool lockConjugation=false)
template<class ... Args>
Particle	scalarboson_s (Args &&...args)
	Delegates the construction of a Scalar boson and returns the result. More...
int	getCoxeterNumber (algebra::Type type, int l=0)
std::pair< csl::Expr, csl::Expr >	calculate_C9_C10 ()
std::ostream &	operator<< (std::ostream &out, std::vector< PartitionPair > const &partition)
std::vector< std::vector< PartitionPair > >	evenPartition (size_t n)
std::vector< TraceIdentity >	traceIdentity (algebra::Type type, size_t n)
std::vector< TraceIdentity >	traceIdentity (algebra::Type type, size_t l, size_t n)
std::vector< TraceIdentity >	ATraceIdentity (size_t l, size_t n)
std::vector< TraceIdentity >	BTraceIdentity (size_t l, size_t n)
std::vector< TraceIdentity >	CTraceIdentity (size_t l, size_t n)
std::vector< TraceIdentity >	DTraceIdentity (size_t l, size_t n)
std::vector< TraceIdentity >	E6TraceIdentity (size_t n)
std::vector< TraceIdentity >	E7TraceIdentity (size_t n)
std::vector< TraceIdentity >	E8TraceIdentity (size_t n)
std::vector< TraceIdentity >	F4TraceIdentity (size_t n)
std::vector< TraceIdentity >	G2TraceIdentity (size_t n)
template<class ... Args>
Particle	vectorboson_s (Args &&...args)
	Delegates the construction of a vector boson and returns the result. More...
template<class ... Args>
Particle	gaugeboson_s (Args &&...args)
	Delegates the construction of a gauge boson and returns the result. More...
template<class ... Args>
Particle	fieldstrength_s (Args &&...args)
	Delegates the construction of a field strength and returns the result. More...
csl::Expr	wick_s (const csl::Expr &expr)
	Tries to create a Wick object with argument expr. Applies operator (see Operator::applyOperator()) to eliminate constants (with respect to the Wick object) and returns and resulting csl::Expr. More...
std::vector< Wilson >	copyWilsons (std::vector< Wilson > const &wilsons)
Cache< csl::Expr, csl::Expr >	cachedWilson ([](csl::Expr const &A, csl::Expr const &B) { return(A==B)||csl::hardComparison(A, B);})
void	parseStructures (csl::Expr &arg, std::vector< csl::Expr > &inOperator, csl::IndexStructure &quantumStructure)
std::vector< csl::Expr >	parseStructures (csl::Expr &product)
std::vector< Wilson >	cachedWilsonCalculation (csl::Expr const &product, csl::Expr const &operatorFactor, Wilson res, csl::Expr op, bool standardBasis, bool recursive)
std::vector< Wilson >	sglSimplifyForWilson (csl::Expr const &op, csl::Expr const &operatorFactor, Wilson res, bool standardBasis, bool recursive)
std::vector< Wilson >	parseExpression (csl::Expr const &product, csl::Expr const &operatorFactor=CSL_1, bool standardBasis=false, bool recursive=false)
std::vector< Wilson >	parseSum (csl::Expr const &sum, csl::Expr const &operatorFactor=CSL_1, bool standardBasis=false, bool recursive=false)
void	addWilson (Wilson const &wil, std::vector< Wilson > &wilsons, bool merge=true)
void	addSortedWilson (Wilson const &wil, std::vector< Wilson > &wilsons)
WilsonSet	match (std::vector< csl::Expr > &amplitudes, csl::Expr const &operatorFactor, bool standardBasis=false, bool squaredAfter=false)
csl::Expr	getWilsonCoefficient (WilsonSet const &wilsons, std::vector< Wilson > const &contributions)
csl::Expr	getWilsonCoefficient (WilsonSet const &wilsons, std::vector< csl::Expr > const &contributions)
csl::Expr	getWilsonCoefficient (WilsonSet const &wilsons, Wilson const &contributions)
csl::Expr	getWilsonCoefficient (WilsonSet const &wilsons, csl::Expr const &contributions)
csl::Expr	getWilsonCoefficient (Model const &model, WilsonSet const &wilsons, DiracCoupling coupling)
ostream &	operator<< (ostream &fout, const AlgebraState &state)
static bool	compareFields (QuantumField const &A, QuantumField const &B, [[maybe_unused]] size_t pos)
static mty::QuantumField *	qf (csl::Expr &expr)
static mty::QuantumField	createField (mty::Insertion const &ins, csl::Tensor const &momentum)
static csl::Expr	fermionExpr (OpInsertion const &ins, bool conj)
static std::vector< OpInsertion >	getOpInsertions (Kinematics const &kinematics)
static bool	requirementsSatisfied (std::vector< OpInsertion > const &insertions, std::vector< InsertionRequirement > const &requirements)
static std::vector< Wilson >	buildMagneticOperator (Model const &model, OpInsertion const &leftFermion, OpInsertion const &rightFermion, OpInsertion const &vectorBoson, csl::Tensor momentum, DiracCoupling coupling)
static bool	areSwapped (std::vector< int > const &fermionOrder)
static std::array< OpInsertion, 3 >	getMagneticInsertions (std::vector< OpInsertion > const &insertions, bool swapped)
static void	addMagneticContribution (std::vector< Wilson > &contributions, csl::Expr const &factor, Model const &model, OpInsertion const &leftFermion, OpInsertion const &rightFermion, OpInsertion const &vectorBoson, csl::Tensor momentum, DiracCoupling coupling)
static void	setUpDim6FermionOrder (WilsonSet const &wilsons, std::vector< int > &fermionOrder)
static std::array< csl::Expr, 4 >	getExternalDim6Fermions (std::vector< OpInsertion > const &insertions, std::vector< int > const &fermionOrder)
static std::vector< Wilson >	getDiracCurrent (DiracCoupling current, csl::Index const &a, csl::Index const &b, csl::Index const &mu, csl::Index const &nu)
static std::vector< Wilson >	getDiracCurrent (DiracCoupling c1, DiracCoupling c2, csl::Expr &psi1, csl::Expr &psi2, csl::Expr &psi3, csl::Expr &psi4)
static std::pair< size_t, size_t >	findTwoIdenticalReps (mty::Irrep const &rep1, mty::Irrep const &rep2, mty::Irrep const &rep3, mty::Irrep const &rep4)
static bool	areIdenticalReps (mty::Irrep const &rep1, mty::Irrep const &rep2, mty::Irrep const &rep3, mty::Irrep const &rep4)
csl::Index &	groupIndex (Model const &model, Group const *group, csl::Expr &psi)
static csl::Expr	getTrivialColorCouplings (Model const &model, csl::Expr &psi1, csl::Expr &psi2, csl::Expr &psi3, csl::Expr &psi4)
static ColorCoupling	getColorCoupling (std::vector< ColorSpec > const &colorCouplings, std::string const &group)
static csl::Expr	getColorCoupling (ColorCoupling coupling, csl::Index const &a1, csl::Index const &a2, csl::Index const &a3, csl::Index const &a4, csl::Tensor &T, csl::Index const &A)
static csl::Expr	getGeneralColorCouplings (Model const &model, std::vector< ColorSpec > const &colorCouplings, csl::Expr &psi1, csl::Expr &psi2, csl::Expr &psi3, csl::Expr &psi4)
static csl::Expr	getColorCurrent (Model const &model, std::vector< ColorSpec > const &colorCouplings, csl::Expr &psi1, csl::Expr &psi2, csl::Expr &psi3, csl::Expr &psi4)
static std::set< color::ColorSpace const * >	getColorSpaces (csl::Expr const &expr)
static std::set< color::ColorSpace const * >	getAdjointSpaces (csl::Expr const &expr)
static std::vector< size_t >	getPos_fABC (csl::Expr &prod, color::ColorSpace const *space)
static bool	hasCommonIndex (csl::Expr const &tensorA, csl::Expr const &tensorB)
static bool	isFTrace (csl::Expr const &tensorA, csl::Expr const &tensorB, csl::Expr const &tensorC)
static int	placeCommonIndex (csl::IndexStructure &si, csl::IndexStructure &sj, size_t posIni, size_t posInj)
static csl::Expr	fTrace (csl::Expr const &fi, csl::Expr const &fj, csl::Expr const &fk, mty::GaugedGroup const *group)
static bool	CalculateFColorTrace_impl (csl::Expr &prod, color::ColorSpace const *space)
void	expandAbbreviations (csl::vector_expr &tensors)
void	setDiracTensor4 (const DiracSpace *self)
std::ostream &	operator<< (std::ostream &out, FermionCurrent const &current)
void	removeBosons (FieldList &init)
std::pair< FieldList, FieldList >	separatePartners (FieldList const &init)
bool	compareFields (mty::QuantumField const &A, mty::QuantumField const &B)
FieldList::iterator	getPartner (FieldList::iterator A, FieldList &fieldsA, FieldList &partners)
FieldList::iterator	getNext (QuantumField const *field, FieldList &fields, FieldList &partners, bool recurs=false)
bool	isSameOrder (QuantumField const *first, QuantumField const *second, FieldList const &ruleOrder, [[maybe_unused]] bool ruleMode)
csl::Index	diracIndexOf (QuantumField const *field)
void	testBeginExternalLeg (QuantumField const *ext, std::vector< ConjugationInfo > &info)
void	testEndExternalLeg (QuantumField const *ext, std::vector< ConjugationInfo > &info)
void	testPropagator (QuantumField const *first, QuantumField const *second, csl::Index const &preIndex, csl::Index const &postIndex, FieldList const &initialOrder, std::vector< ConjugationInfo > &info)
void	testVertexFields (QuantumField const *first, QuantumField const *second, csl::Index const &preIndex, csl::Index const &postIndex, FieldList const &ruleOrder, std::vector< ConjugationInfo > &info, bool ruleMode)
void	testFields (QuantumField const *first, QuantumField const *second, csl::Index const &preIndex, csl::Index const &postIndex, FieldList const &, FieldList const &ruleOrder, std::vector< ConjugationInfo > &info, bool ruleMode)
std::vector< FermionLine >	chainFermions (FieldList const &init)
void	f (FieldList const &init, FieldList const &line)
bool	getNextIndexInChain (csl::Index &first, csl::Index &prev, csl::Expr const &expr)
bool	findNextIndexBefore (csl::Index first, csl::Index const &target, csl::Index const &end, csl::Index prev, csl::Expr const &expr)
auto	findWeylSignature (std::string const &name)
std::string	DiracNameOf (std::string const &leftWeylName)
void	applyGoodAdjacentOrder (std::vector< int > &numbers, std::vector< size_t > &indicesLeft, std::vector< mty::Insertion const *> const &fermions)
void	applyGoodNonAdjacentOrder (std::vector< int > &numbers, std::vector< size_t > &indicesLeft, std::vector< mty::Insertion const *> const &fermions)
std::array< int, 5 >	getRank5Indices (int loopToolsId)
csl::Expr	getDivergentFactor (IntegralType type, int integral_id, std::vector< csl::Expr > const &arguments)
void	testError (IntegralType type, std::vector< csl::Expr > const &momentum, size_t nMomentum, std::vector< csl::Expr > const &mass, size_t nMass, std::vector< csl::Index > const &, size_t)
csl::Expr	apply (csl::Expr const &init, csl::Index const &index)
std::vector< std::vector< size_t > >	getMetricIndices (std::vector< size_t > indices)
std::vector< std::vector< size_t > >	getMetricIndices (size_t n)
csl::Expr	mom (csl::Expr init)
csl::Expr	feynmanintegral_s (IntegralType type, int looptoolsId, std::vector< csl::Expr > const &argument, std::vector< size_t > const &indices)
csl::Expr	feynmanintegral_s (IntegralType t_type, int t_looptoolsId, std::vector< csl::Expr > const &t_argument)
std::ostream &	operator<< (std::ostream &out, FeynmanRule const &rule)
bool	compareKey (FeynruleKey const &key, mty::QuantumField const &field)
std::ostream &	operator<< (std::ostream &out, FeynruleMomentum const &mom)
ostream &	operator<< (ostream &fout, const FlavorIrrep &irrep)
ostream &	operator<< (ostream &fout, const Gauge &obj)
ostream &	operator<< (ostream &fout, const GaugeIrrep &irrep)
std::ostream &	operator<< (std::ostream &fout, const SumGaugeIrrep &irrep)
csl::Expr	normalization (mty::gauge::GroupType type)
std::string	getGeneratorName (std::string const &init, std::string const &groupName, std::vector< int > const &labels)
ostream &	operator<< (ostream &fout, const AbstractGroup &obj)
group::Type	stringToGroupType (string const &name)
std::vector< csl::Expr >	getFi_A (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getLi_A (std::vector< csl::Expr > const &f)
std::vector< csl::Expr >	getLi_A (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getFi_B (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getLi_B (std::vector< csl::Expr > const &f)
std::vector< csl::Expr >	getLi_B (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getFi_D (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getLi_D (std::vector< csl::Expr > const &f)
std::vector< csl::Expr >	getLi_D (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getFi_C (std::vector< int > const &dinkin)
std::vector< csl::Expr >	getLi_C (std::vector< csl::Expr > const &f)
std::vector< csl::Expr >	getLi_C (std::vector< int > const &dinkin)
template<size_t N, size_t nReps>
csl::Expr	getIntegerIndex (std::array< int, N > const &t_rep, std::array< GIndex_t< N >, nReps > const &data)
template<size_t N, size_t nReps>
csl::Expr	getRationalIndex (std::array< int, N > const &t_rep, std::array< GIndex_t< N >, nReps > const &data, int denom)
void	abbreviantLINT (csl::Expr &prod)
ostream &	operator<< (ostream &out, InteractionTerm const &term)
template<class Type >
static void	removeIndices (std::vector< Type > &data, std::vector< size_t > indices)
static bool	areIdenticalFields (Insertion const &A, Insertion const &B)
std::ostream &	operator<< (std::ostream &out, Kinematics const &kin)
std::ostream &	operator<< (std::ostream &fout, const Lagrangian &L)
std::string	indicesToString (std::vector< size_t > const &indices)
std::vector< ComplexType >	exprToComplexType (std::vector< csl::Expr > const &init)
std::vector< double >	exprToRealType (std::vector< csl::Expr > const &init)
ComplexType	A0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	B0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	C0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	D0i_runtime (int id, std::vector< csl::Expr > const &arguments)
ComplexType	E0i_runtime (int id, std::vector< csl::Expr > const &arguments)
static std::vector< csl::Expr >	evalForSquare (WilsonSet const &wilsons)
static int	nPermutations (std::vector< int > &fermionOrder)
static int	linkPosition (Kinematics const &M)
std::ostream &	operator<< (std::ostream &out, Model const &obj)
bool	isProjected (csl::Expr const &prod, csl::Expr const &field)
auto	replaceMajorana (csl::Expr &expr, mty::Particle const &xi, mty::Particle Lambda)
static std::vector< csl::Expr >	expandBrokenIndices (csl::Expr const &init, csl::Space const *brokenSpace, std::vector< csl::Space const *> const &newSpace)
void	abbreviate (csl::Expr &prod)
csl::Expr	hc (csl::Expr const &init)
static void	particleNotFound (std::vector< mty::Particle > const &particles, std::string const &name)
std::ostream &	operator<< (std::ostream &out, ModelData const &model)
csl::Index	GaugeIndex (std::string const &nameIndex, mty::Model const &model, std::string const &nameGroup, Particle const &particle)
csl::Index	GaugeIndex (mty::Model const &model, std::string const &nameGroup, Particle const &particle)
std::string	FindProcessName (std::string const &initName, std::vector< Insertion > const &insertions)
std::ostream &	operator<< (std::ostream &out, MSSM_Model const &model)
static void	insertionError ()
static bool	checkInsertionsForPatch (std::vector< mty::Insertion > const &insertions, bool raiseError)
static std::pair< csl::Expr, csl::Expr >	getFermions (csl::Expr const &op)
static std::pair< size_t, size_t >	checkOperators (std::vector< Wilson > const &wilsons, std::vector< csl::Tensor > const &momenta)
static PenguinPatchData	getPenguinData (std::vector< mty::Insertion > const &insertions, size_t iConj, size_t iReg)
static void	orderOperators (std::vector< Wilson > &wilsons, csl::Tensor const &p1, csl::Tensor const &p2)
static void	ensureOperator (Wilson const &model, Wilson &target, csl::Tensor const &p)
static void	ensureOperators (std::vector< Wilson > &wilsons, csl::Tensor const &p1, csl::Tensor const &p2)
static void	applyPenguinPatch_implementation (std::vector< Wilson > &wilsons, PenguinPatchData const &data)
ostream &	operator<< (ostream &fout, const PolarizationField &pol)
Particle	colorTriplet (Model &QCD, std::string const &name)
Particle	colorSextet (Model &QCD, std::string const &name)
vector< const Space * >	getSpaceRepresentations (Gauge *gauge, const GaugeIrrep &irrep)
Index	generateIndex (string name, const Space *space)
csl::Expr	applyDerivative (QuantumField const &A, QuantumField const &B, csl::Expr const &prop)
ostream &	operator<< (ostream &fout, const QuantumFieldParent &obj)
void	AddCustomPropagator (QuantumFieldParent *left, QuantumFieldParent *right, QuantumFieldParent::Propagator_func propagator)
void	AddCustomPropagator (QuantumFieldParent *autoProp, QuantumFieldParent::Propagator_func propagator)
void	projectOnChirality (const QuantumField &field, csl::Expr &expression, csl::Index alpha)
csl::Expr	getMomentumSum (const vector< QuantumField > &insertions, const vector< Tensor > &impulsions, const Index &index)
	Creates and returns the sum of momentums in a process, taking into account incoming or outgoing particles.std. More...
ostream &	operator<< (ostream &fout, const mty::QuantumField &field)
static bool	ReplaceXiGauge_impl (csl::Expr &expr)
csl::Expr	ExternalLeg (QuantumFieldParent &field, csl::Tensor P, csl::Tensor X, vector< Index > indices, bool particle, bool incoming, bool onshell, PartnerShip const &partnerShip, bool ruleMode, bool lockConjugation)
ostream &	operator<< (ostream &fout, const Irrep &irrep)
ostream &	operator<< (ostream &fout, const SumIrrep &s)
std::ostream &	operator<< (std::ostream &fout, const SemiSimpleAlgebra &algebra)
std::ostream &	operator<< (std::ostream &out, TraceIdentity const &identity)
void	parseStructures (csl::Expr &arg, std::vector< csl::Expr > &inOperator, csl::IndexStructure &quantumStructure)
static std::vector< Wilson >	applyFactor (std::vector< Wilson > &&wilsons, csl::Expr const &factor)
WilsonSet	match (std::vector< csl::Expr > &fullAmplitudes, csl::Expr const &operatorFactor, bool standardBasis, bool squaredAfter)

Variables
csl::Tensor	V_CKM
std::shared_ptr< csl::TDerivativeParent >	partialMinko_shared = csl::tderivative_s("d", &csl::Minkowski)
csl::TDerivativeParent &	partialMinko = *partialMinko_shared
constexpr int	loopToolsStep = 3
mty::group::Lorentz *	Lorentz = new mty::group::Lorentz()
	Global variable. Lorentz group in the form of a raw pointer to an AbstractGroup. This variable should be used whereever the Lorentz group is used in the program.
constexpr std::array< GIndex_t< 6 >, 12 >	I2_E6_data
constexpr std::array< GIndex_t< 6 >, 12 >	I5_E6_data
constexpr std::array< GIndex_t< 6 >, 12 >	I6_E6_data
constexpr std::array< GIndex_t< 6 >, 12 >	I8_E6_data
constexpr std::array< GIndex_t< 6 >, 12 >	I9_E6_data
constexpr std::array< GIndex_t< 6 >, 12 >	I12_E6_data
constexpr std::array< GIndex_t< 7 >, 21 >	I2_E7_data
constexpr std::array< GIndex_t< 7 >, 21 >	I6_E7_data
constexpr std::array< GIndex_t< 7 >, 21 >	I8_E7_data
constexpr std::array< GIndex_t< 7 >, 21 >	I10_E7_data
constexpr std::array< GIndex_t< 7 >, 21 >	I12_E7_data
constexpr std::array< GIndex_t< 8 >, 29 >	I2_E8_data
constexpr std::array< GIndex_t< 8 >, 29 >	I8_E8_data
constexpr std::array< GIndex_t< 8 >, 29 >	I12_E8_data
constexpr std::array< GIndex_t< 4 >, 7 >	I2_F4_data
constexpr std::array< GIndex_t< 4 >, 7 >	I6_F4_data
constexpr std::array< GIndex_t< 4 >, 7 >	I8_F4_data
constexpr std::array< GIndex_t< 4 >, 7 >	I12_F4_data
constexpr std::array< GIndex_t< 2 >, 16 >	I2_G2_data
constexpr std::array< GIndex_t< 2 >, 16 >	I6_G2_data
const csl::Expr	FiniteFlag = csl::constant_s("Finite")
LoopToolsInitializer const &	looptoolsInitializer = LoopToolsInitializer::build()
csl::allocator< Propagator >	alloc_propagator
csl::allocator< FermionPropStruct >	alloc_fermionprop
csl::Tensor	defaultSpaceTimePoint
	Default space-time point when not given while defining a QuantumField. More...
static constexpr bool	enableApp = true
static constexpr bool	displayDebug = false
constexpr bool	useExperimental = true

Detailed Description

Namespace of MARTY.

This namespace contains all functions, objects, interfaces of MARTY, or more exactly of the physics part of MARTY. Mathematical objects, for symbolic manipulations, lie in the namespace csl.

Typedef Documentation

Group

typedef class mty::AbstractGroup mty::Group

Abstract base class for groups.

This class is mostly composed of empty virtual functions. It only handles a std::string for the name, and an integer for the dimension of the group. See SemiSimpleGroup to get to group features.

Enumeration Type Documentation

Chirality

enum mty::Chirality

strong

Chirality for fermions. Either Left or Right for WeylFermion, or None for DiracFermion.

Enumerator
Left	Left chirality for WeylFermion.
Right	Rihght chirality for WeylFermion.
None	No chirality for DiracFermion.

OperatorBasis

enum mty::OperatorBasis

strong

Operator basis for Wilson coefficients.

Enumerator
Chiral	Uses projectors \( P_L,P_R \).
Standard	Uses \( 1,\gamma^5 \).
None	Does not force any particular decomposition.

Function Documentation

AddCustomPropagator() [1/2]

void mty::AddCustomPropagator	(	QuantumFieldParent *	left,
		QuantumFieldParent *	right,
		QuantumFieldParent::Propagator_func	propagator
	)

The propagator should of course be consistent, but may be as exotic as possible. See Propagator_func to know the exact structure of what must be given. This function may be useful for example to define the propagator between a left-handed and a right-handed fermion (different particles), or between a vector boson and its field strength...

Parameters

field	Left field in the propagator.
field	Right field in the propagator.
propagator	New propagator.

Warning

In the case of a non symmetric propagator, the user should take into account that in its custom function, the left field will not always be the first argument. The only thing that is ensured is that if there is a complex conjugated field, it will be the second argument.

See also

QuantumFieldParent::propagator, Propagator_func, quantumFieldTheory.h.

AddCustomPropagator() [2/2]

void mty::AddCustomPropagator	(	QuantumFieldParent *	autoProp,
		QuantumFieldParent::Propagator_func	propagator
	)

The propagator should of course be consistent, but may be as exotic as possible. See Propagator_func to know the exact structure of what must be given.

Parameters

field	Field whose propagator is modified.
propagator	New propagator.

See also

QuantumFieldParent::propagator, Propagator_func, quantumFieldTheory.h.

applyPenguinPatch()

void mty::applyPenguinPatch	(	std::vector< Wilson > &	wilsons,
		Kinematics const &	kinematics
	)

Applies the patch for the on-shell calculation of penguins with massless vector.

When the outgoing vector \( A \) of \( \psi\to\psi A \) transition is massless, the calculation of Wilson coefficients requires the on-shell calculation with the inclusion of counter-terms for the corrections of external fermions. As these counter-terms are not taken care of automatically for now, this function applies gauge invariance to recover the correct result, using the fact that the result is redundant and that all quantities can be derived from the result without counter-terms. For box diagrams or penguins with massive vector boson, the calculation suffers from no issue.

Parameters

wilsons	Wilson Operator / Coefficients to correct.
kinematics	Kinematica of the process.

CreateAlgebra()

std::unique_ptr< mty::SemiSimpleAlgebra > mty::CreateAlgebra	(	algebra::Type	type,
		int	l = -1
	)

Creates a specilization of SemiSimpleAlgebra of type type.

For a non exceptional algebra, i.e. different of \( E_6 \), \( E_7 \), \( E_8 \), \( F_4 \), or \( G_2 \); the rank l of the algebra must be given to specify the dimension: \( A_l \) for \( SU(l+1) \), \( B_l \), \( C_l \), \( D_l \). For example, \( A_{N-1} \) being the algebra of \( SU(N) \), the code allowing to get \( SU(5) \) is:

// std::unique_ptr<mty::SemiSimpleAlgebra> may be replaced by 
// the auto keyword here.

std::unique_ptr<mty::SemiSimpleAlgebra> SU_5 
        = createAlgebra(algebra::Type::A, 4);

// Here SU_5 is a non-copyable pointer type.
SU_5;       // is a std::unique_ptr<SemiSimpleAlgebra>: use ->
SU_5.get(); // is a raw pointer SemiSimpleAlgebra*    : use ->
*SU_5;      // is a SemiSimpleAlgebra                 : use .

Note

A std::unique_ptr is not copyable. But the raw pointer inside may be copied. The raw pointer is accessible by u_ptr.get(). See the manual of CSL for more information.

Parameters

type	Element of the enum algebra::Type, specifying the type of the algebra to create.
l	Integer, rank of the algebra for non exceptional algebras.

Returns

A std::unique_ptr to the SemiSimpleAlgebra.

createGroup() [1/2]

unique_ptr< SemiSimpleGroup > mty::createGroup	(	group::Type	type,
		std::string const &	name,
		int	dim = -1
	)

Dynamically allocates a new group of type type and returns a pointer to it (in a std::unique_ptr).

Parameters

type	Type of the group.
name	Name of the group.
dim	Dimension of the group (optional for exceptional algebras).

Returns

A pointer to the dynamically allocated Group.

createGroup() [2/2]

unique_ptr< SemiSimpleGroup > mty::createGroup	(	group::Type	type,
		int	dim = -1
	)

Dynamically allocates a new group of type type and returns a pointer to it (in a std::unique_ptr).

Parameters

type	Type of the group.
dim	Dimension of the group (optional for exceptional algebras).

Returns

A pointer to the dynamically allocated Group.

Delta()

csl::Tensor mty::Delta

(

const csl::Space *

space

)

Returns the Kronecker delta of a given vector space.

The delta may be called next with indices of the corresponding space. For example, taking \( \delta _{ij} \) in a space named E3 would look like:

csl::Space *E3 = ...;
csl::Index i = GenerateIndex(E3, "i");
csl::Index j = GenerateIndex(E3, "j");
csl::Tensor delta = Delta(E3);
csl::Expr kronecker = delta({i, j});

Parameters

space

Vector space from which we want the delta.

Returns

The Kronecker delta of the space.

See also

GenerateIndex, csl::Space, csl::Index, csl::TensorParent, csl::TensorElement.

diracfermion_s()

template<class ... Args>

Particle mty::diracfermion_s ( Args &&...  args )

inline

Delegates the construction of a Dirac fermion and returns the result.

This function can take any argument that the constructors DiracFermion::DiracFermion() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created Dirac fermion.

DiracGamma()

csl::Tensor mty::DiracGamma

(

)

Returns

The Dirac tensor \( \gamma \) in the standard 4-dim Dirac space.

DiracGamma5()

csl::Tensor mty::DiracGamma5

(

)

Returns

The Dirac tensor \( \gamma ^5\) in the standard 4-dim Dirac space.

DiracIndex()

csl::Index mty::DiracIndex

(

std::string const &

name = ""

)

Returns a csl::Index in the 4-dimensional Dirac space mty::dirac4.

If no name is provided, the name will be chosen in the name cycle of mty::dirac4, i.e. one of \( \alpha, \beta, \gamma, \delta, \epsilon \). For example, a dirac index may be created with the following code:

csl::Index alpha = mty::DiracIndex("\\alpha");

or with a name automatically determined:

csl::Index alpha = mty::DiracIndex();

Parameters

name	Name of the index (optional).

Returns

An index living in mty::dirac4 space.

DiracIndices()

std::vector< csl::Index > mty::DiracIndices	(	size_t	n,
		std::string const &	name = ""
	)

Returns indices in the 4-dimensional Dirac space mty::dirac4.

If no name is provided, the name will be chosen in the name cycle of mty::dirac4, i.e. one of \( \alpha, \beta, \gamma, \delta, \epsilon \). For example, a dirac index may be created with the following code:

auto alpha = mty::DiracIndices(10);
// alpha[0], alpha[1] are indices (csl::Index) in Dirac space

Parameters

n	Number of indices to generate.
name	Name of the index (optional).

Returns

n indices living in mty::dirac4 space.

DiracPL()

csl::Tensor mty::DiracPL

(

)

Returns

The Dirac tensor \( P_L \) in the standard 4-dim Dirac space.

DiracPR()

csl::Tensor mty::DiracPR

(

)

Returns

The Dirac tensor \( P_R \) in the standard 4-dim Dirac space.

DiracProjector()

csl::Tensor mty::DiracProjector ( Chirality  chir )

inline

Returns a projector in Dirac 4-dim space depending on a chirality.

Parameters

chir

Chirality

Returns

Left projector \( P_L \) for left chirality.

Right projector \( P_R \) otherwise.

DiracSigma()

csl::Tensor mty::DiracSigma

(

)

Returns

The Dirac tensor \( \sigma \) in the standard 4-dim Dirac space.

Epsilon()

csl::Tensor mty::Epsilon

(

const csl::Space *

space

)

Returns the epsilon symbol of a given vector space.

The epsilon may be called next with indices of the corresponding space. For example, taking \( \epsilon _{ijk} \) in a space named E3 would look like:

csl::Space *E3 = ...;
csl::Index i = GenerateIndex(E3, "i");
csl::Index j = GenerateIndex(E3, "j");
csl::Index k = GenerateIndex(E3, "k");
csl::Tensor eps = Epsilon(E3);
csl::Expr antiSym = eps({i, j, k});

Parameters

space

Vector space from which we want the epsilon symbol.

Returns

The epsilon symbol of the space.

See also

GenerateIndex, csl::Space, csl::Index, csl::TensorParent, csl::TensorElement.

fieldstrength_s()

template<class ... Args>

Particle mty::fieldstrength_s ( Args &&...  args )

inline

Delegates the construction of a field strength and returns the result.

This function can take any argument that the constructors FieldStrength::FieldStrength() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created field strength.

FlavorIndex()

template<class GroupType >

csl::Index mty::FlavorIndex	(	mty::Model const &	model,
		GroupType &&	group
	)

Returns a csl::Index for a given flavor group.

The model must be given to access the flavor group. The group can be given in the form of a std::string, the name of the group. Finally, the field is given as a mty::Particle.

Template Parameters

GroupType

mty::FlavorGroup* or valid type for the function getGroup()

Parameters

model	Model that generated the index.
group	Flavor group.

Returns

An index living in the vector space (csl::Space) of the fundamental representation of the group named group, in the model model.

FlavorIndices()

template<class GroupType >

std::vector<csl::Index> mty::FlavorIndices	(	size_t	nIndices,
		mty::Model const &	model,
		GroupType &&	group
	)

Returns indices for a given flavor group.

The model must be given to access the flavor group. The group can be given in the form of a std::string, the name of the group. Finally, the field is given as a mty::Particle.

Template Parameters

GroupType

mty::FlavorGroup* or valid type for the function getGroup()

Parameters

model	Model that generated the index.
group	Flavor group.

Returns

Indices living in the vector space (csl::Space) of the fundamental representation of the group named group, in the model model.

gaugeboson_s()

template<class ... Args>

Particle mty::gaugeboson_s ( Args &&...  args )

inline

Delegates the construction of a gauge boson and returns the result.

This function can take any argument that the constructors GaugeBoson::GaugeBoson() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created gauge boson.

GaugeIndex() [1/2]

template<class GroupType , class FieldType >

csl::Index mty::GaugeIndex	(	std::string const &	nameIndex,
		mty::Model const &	model,
		GroupType &&	group,
		FieldType &&	part
	)

Returns a csl::Index living in the representation of a certain field in a certain group.

The model must be given to access the gauge group. The group can be given in the form of a std::string, the name of the group. Finally, the field is given as a mty::Particle. For example, for the standard model 'SM' (a mty::Model object), the 'SU3_c' group, one can get an index with the right name in the octet representation of the gluon 'g' with the following code:

csl::Index A = mty::GaugeIndex("A", SM, "SU3_c", g);

Template Parameters

GroupType	mty::Group* or valid type for the function getGroup()
FieldType	mty::Particle or valid type for the function getParticle()

Parameters

nameIndex	Name for the generated index.
model	Model that generated the index.
group	Group.
field	Particle.

Returns

An index named nameIndex living in the vector space (csl::Space) of the representation of part in the group named nameGroup, in the model model.

GaugeIndex() [2/2]

template<class GroupType , class FieldType >

csl::Index mty::GaugeIndex	(	mty::Model const &	model,
		GroupType &&	group,
		FieldType &&	part
	)

Returns a csl::Index living in the representation of a certain field in a certain group.

The model must be given to access the gauge group. The group can be given in the form of a std::string, the name of the group. Finally, the field is given as a mty::Particle. For example, for the standard model 'SM' (a mty::Model object), the 'SU3_c' group, one can get an index with the right name in the octet representation of the gluon 'g' with the following code:

csl::Index A = mty::GaugeIndex("A", SM, "SU3_c", g);

Template Parameters

GroupType	mty::Group* or valid type for the function getGroup()
FieldType	mty::Particle or valid type for the function getParticle()

Parameters

model	Model that generated the index.
group	Group.
field	Particle.

Returns

An index living in the vector space (csl::Space) of the representation of part in the group named nameGroup, in the model model.

GaugeIndices()

template<class GroupType , class FieldType >

std::vector<csl::Index> mty::GaugeIndices	(	size_t	nIndices,
		mty::Model const &	model,
		GroupType &&	group,
		FieldType &&	part
	)

Returns indices living in the representation of a certain field in a certain group.

The model must be given to access the gauge group. The group must be given in the form of a std::string, the name of the group. Finally, the field is given as a mty::Particle. For example, for the standard model 'SM' (a mty::Model object), the 'SU3_c' group, one can get an index with the right name in the octet representation of the gluon 'g' with the following code:

csl::Index A = mty::GaugeIndex("A", SM, "SU3_c", g);

Template Parameters

GroupType	mty::Group* or valid type for the function getGroup()
FieldType	mty::Particle or valid type for the function getParticle()

Parameters

nIndices	Number of indices to generate.
model	Model that generated the index.
group	Group.
field	Particle.

Returns

Indices living in the vector space (csl::Space) of the representation of part in the group named nameGroup, in the model model.

GenerateIndex()

csl::Index mty::GenerateIndex	(	csl::Space const *	space,
		std::string const &	name = ""
	)

Generates an index in a given space.

If the name is not given (optional), the name will be taken in the predefined names for the space.

Parameters

space	Space in which we create an index.
name	Name of the index (optional).

Returns

An index living in space.

See also

csl::Space, csl::Index, csl::TensorParent, csl::TensorElement.

GetGenerator()

template<class GroupType , class FieldType >

mty::Generator mty::GetGenerator	(	mty::Model &	model,
		GroupType &&	group,
		FieldType &&	field
	)

Returns the generator coresponding to the representation of a field in a given group.

Template Parameters

GroupType	mty::Group* or valid type for the function getGroup()
FieldType	mty::Particle or valid type for the function getParticle()

Parameters

group	Group.
field	Particle.

Returns

The generator coresponding to the representation of a field in a given group if it exists.

nullptr else.

getMomentumSum() [1/2]

csl::Expr mty::getMomentumSum	(	const std::vector< QuantumField > &	insertions,
		const std::vector< csl::Tensor > &	impulsions,
		const csl::Index &	index
	)

Creates and returns the sum of momentums in a process, taking into account incoming or outgoing particles.std.

This sum is the one that must be zero if external states are on-shell. In particular, any calculation must yield something like

\[ i\mathcal{T} = (2\pi)^4\delta^{(4)}\left(\sum _{i_{in}}p_i -\sum _{j_{out}}p_j\right)\cdot i\mathcal{M}, \]

where \( i\mathcal{M} \) is the physical amplitude of interest, \( p_i \) represent momentums of incoming particles, \( p_j \) of outgoing ones. Each component of the momentum sum must vanish.

Parameters

insertions	Field insertions of the process.
momentum	Momentum in the process (must be the same size as insertions).
index	Index for the momentum sum.

Returns

The expression of the momentum sum.

getMomentumSum() [2/2]

csl::Expr mty::getMomentumSum	(	const std::vector< QuantumField > &	insertions,
		const std::vector< csl::Tensor > &	impulsions,
		const csl::Index &	index
	)

Creates and returns the sum of momentums in a process, taking into account incoming or outgoing particles.std.

This sum is the one that must be zero if external states are on-shell. In particular, any calculation must yield something like

\[ i\mathcal{T} = (2\pi)^4\delta^{(4)}\left(\sum _{i_{in}}p_i -\sum _{j_{out}}p_j\right)\cdot i\mathcal{M}, \]

where \( i\mathcal{M} \) is the physical amplitude of interest, \( p_i \) represent momentums of incoming particles, \( p_j \) of outgoing ones. Each component of the momentum sum must vanish.

Parameters

insertions	Field insertions of the process.
momentum	Momentum in the process (must be the same size as insertions).
index	Index for the momentum sum.

Returns

The expression of the momentum sum.

GetVectorSpace()

template<class GroupType , class FieldType >

csl::Space const* mty::GetVectorSpace	(	mty::Model &	model,
		GroupType &&	group,
		FieldType &&	field
	)

Returns the vector space corresponding the the representation of a given field in a given group.

Template Parameters

GroupType	Group* or group name.
FieldType	Particle or any type (including a name) that the function ModelData::getParticle() takes.

Parameters

model	Model
group	Group in which we search the representation.
field	Particle from which we take the representation.

Returns

The vector space for the representation of field in group.

ghostboson_s() [1/4]

Particle mty::ghostboson_s	(	std::string const &	name,
		std::shared_ptr< VectorBoson > const &	t_vectorBoson,
		bool	conjugated = false
	)

Creates a ghost boson.

Parameters

name	Name of the Ghost.
t_vectorBoson	Associated vector boson.
conjugated	True if the ghost is a conjugated ghost (i.e. a ghost is already defined, such as c+ and c- for W in the SM)

Returns

The newly created Ghost boson.

ghostboson_s() [2/4]

Particle mty::ghostboson_s	(	std::shared_ptr< VectorBoson > const &	t_vectorBoson,
		bool	conjugated = false
	)

Creates a ghost boson.

The name is determined automatically by the constructor GhostBoson::GhostBoson().

Parameters

t_vectorBoson	Associated vector boson.
conjugated	True if the ghost is a conjugated ghost (i.e. a ghost is already defined, such as c+ and c- for W in the SM)

Returns

The newly created Ghost boson.

ghostboson_s() [3/4]

Particle mty::ghostboson_s	(	std::string const &	name,
		Particle const &	t_vectorBoson,
		bool	conjugated = false
	)

Creates a ghost boson.

Parameters

name	Name of the Ghost.
t_vectorBoson	Associated vector boson, must be of type VectorBoson.
conjugated	True if the ghost is a conjugated ghost (i.e. a ghost is already defined, such as c+ and c- for W in the SM)

Returns

The newly created Ghost boson.

ghostboson_s() [4/4]

Particle mty::ghostboson_s	(	Particle const &	t_vectorBoson,
		bool	conjugated = false
	)

Creates a ghost boson.

The name is determined automatically by the constructor GhostBoson::GhostBoson().

Parameters

t_vectorBoson	Associated vector boson, must be of type VectorBoson.
conjugated	True if the ghost is a conjugated ghost (i.e. a ghost is already defined, such as c+ and c- for W in the SM)

Returns

The newly created Ghost boson.

goldstoneboson_s() [1/4]

Particle mty::goldstoneboson_s	(	std::string const &	name,
		std::shared_ptr< VectorBoson > const &	t_vectorBoson
	)

Creates a goldstone boson.

Parameters

name	Name of the Goldstone boson.
t_vectorBoson	Associated vector boson.

Returns

The newly created Goldstone boson.

goldstoneboson_s() [2/4]

Particle mty::goldstoneboson_s

(

std::shared_ptr< VectorBoson > const &

t_vectorBoson

)

Creates a goldstone boson.

The name is determined automatically by the constructor, see GoldstoneBoson::GoldstoneBoson().

Parameters

t_vectorBoson

Associated vector boson.

Returns

The newly created Goldstone boson.

goldstoneboson_s() [3/4]

Particle mty::goldstoneboson_s	(	std::string const &	name,
		Particle const &	t_vectorBoson
	)

Creates a goldstone boson.

Parameters

name	Name of the Goldstone boson.
t_vectorBoson	Associated vector boson, must be of type VectorBoson.

Returns

The newly created Goldstone boson.

goldstoneboson_s() [4/4]

Particle mty::goldstoneboson_s

(

Particle const &

t_vectorBoson

)

Creates a goldstone boson.

The name is determined automatically by the constructor, see GoldstoneBoson::GoldstoneBoson().

Parameters

t_vectorBoson

Associated vector boson, must be of type VectorBoson.

Returns

The newly created Goldstone boson.

Metric()

csl::Tensor mty::Metric

(

const csl::Space *

space

)

Returns the metric of a given vector space.

The metric may be called next with indices of the corresponding space. For example, taking \( g ^{\mu\nu}g_{\rho\sigma} \) in a (signed) space named Minko would look like:

csl::Space *Minko = ...;
csl::Index mu    = GenerateIndex(Minko, "\\mu");
csl::Index nu    = GenerateIndex(Minko, "\\nu");
csl::Index rho   = GenerateIndex(Minko, "\\rho");
csl::Index sigma = GenerateIndex(Minko, "\\sigma");
csl::Tensor g = Metric(Minko);
csl::Expr metricTerm = g({+mu, +nu}) * g({rho, sigma});

Parameters

space

Vector space from which we want the metric.

Returns

The metric of the space.

See also

GenerateIndex, csl::Space, csl::Index, csl::TensorParent, csl::TensorElement.

MinkowskiIndex()

csl::Index mty::MinkowskiIndex

(

std::string const &

name = ""

)

Returns a csl::Index in csl::Minkowki space.

If no name is provided, the name will be chosen in the name cycle of csl::Minkowski, i.e. one of \( \mu, \nu, \rho, \sigma, \lambda, \tau \). For example, a Minkowski index may be created with the following code:

csl::Index mu = mty::MinkowskiIndex("\\mu");

or with a name automatically determined:

csl::Index mu = mty::MinkowskiIndex();

Parameters

name	Name of the index (optional).

Returns

An index living in csl::Minkowski space.

MinkowskiIndices()

std::vector< csl::Index > mty::MinkowskiIndices	(	size_t	n,
		std::string const &	name = ""
	)

Returns indices in csl::Minkowki space.

If no name is provided, the name will be chosen in the name cycle of csl::Minkowski, i.e. one of \( \mu, \nu, \rho, \sigma, \lambda, \tau \). For example, Minkowski indices may be created with the following code:

auto mu = mty::MinkowskiIndices(10);
// mu[0], mu[1] are indices (csl::Index) in csl::Minkowski space.

Parameters

n	Number of indices to generate.
name	Name of the index (optional).

Returns

n indices living in csl::Minkowski space.

MinkowskiVector()

csl::Tensor mty::MinkowskiVector

(

std::string const &

name

)

Returns a csl::Tensor, vector in csl::Minkowski space.

The vector is by definition a tensor with one index. For example, a Minkowski vector may be created by:

csl::Tensor X = MinkowskiVector("X");

Then, assuming that 'mu' is an object of type csl::Index,

X(mu)

means the tensor with a lowered index \( X_\mu \), and

X(+mu)

means the tensor with index up \( X^\mu \). For more information about tensors and indices see csl::TensorElement and csl::Index.

Parameters

name	Name of the vector.

Returns

An indicial Minkowski vector.

operator!()

Chirality mty::operator!

(

Chirality

init

)

Returns the inverse chirality with respect to init.

Parameters

init	Initial chirality.

Returns

Chirality::Left if init is Chirality::Right.

Chirality::Right if init is Chirality::Left.

Chirality::None if init is Chirality::None.

operator<<() [1/5]

std::ostream& mty::operator<<	(	std::ostream &	out,
		Kinematics const &	kin
	)

Parameters

out	Output stream.
kin	Kinematics object to display.

Returns

The modified stream.

operator<<() [2/5]

std::ostream& mty::operator<<	(	std::ostream &	fout,
		const SemiSimpleAlgebra &	algebra
	)

Parameters

fout	Output flux.
algebra	SemiSimpleAlgebra to display.

Returns

The modified output flux.

operator<<() [3/5]

std::ostream& mty::operator<<	(	std::ostream &	fout,
		const AbstractGroup &	obj
	)

Overload of operator<< for AbstractGroup. Displays the type of the group and its dimension between brackets.

Parameters

fout	Output flux.
obj	Group to display.

Returns

The modified flux.

operator<<() [4/5]

std::ostream& mty::operator<<	(	std::ostream &	out,
		ModelData const &	model
	)

This function prints out the model gauge, the particle content and the Lagrangian (kinetic, mass, and interaction terms).

Parameters

out	Output stream (default is standard stream std::cout).
model	Model to output.

Returns

operator<<() [5/5]

std::ostream& mty::operator<<	(	std::ostream &	fout,
		const mty::QuantumField &	field
	)

Overload of operator<< for QuantumField. Calls QuantumField::print().

Parameters

fout	Output flux.
field	QuantumField to display.

Returns

A reference to fout.

See also

QuantumField::print().

quantumfield_s()

template<typename ... Args>

csl::Expr mty::quantumfield_s

(

Args &&...

args

)

Creates and returns an expression corresponding to a QuantumField.

Template Parameters

Args	Variadic template parameters.

Parameters

args	Variadic function parameters, may be anything. Forwarded to csl::make_shared().

Returns

The expression of the field.

Replaced() [1/4]

void mty::Replaced	(	mty::Model &	model,
		csl::Expr const &	init,
		csl::Expr const &	target
	)

Replaces an expression in all kinetic / mass / interactions terms of a model.

Parameters

model	Model in which we do the replacement.
init	Expression to replace.
target	New expression.

Replaced() [2/4]

void mty::Replaced	(	mty::Model &	model,
		csl::Tensor &	init,
		csl::Expr const &	target
	)

Replaces an expression in all kinetic / mass / interactions terms of a model.

The new expression should have a free index structure corresponding to the tensor that is replaced.

Parameters

model	Model in which we do the replacement.
init	Tensor to replace.
target	New expression.

Replaced() [3/4]

void mty::Replaced	(	mty::Model &	model,
		csl::Tensor &	init,
		csl::Tensor &	target
	)

Replaces an expression in all kinetic / mass / interactions terms of a model.

Parameters

model	Model in which we do the replacement.
init	Tensor to replace.
target	New tensor, should have the same structure as the replaced one.

Replaced() [4/4]

void mty::Replaced	(	mty::Model &	model,
		Particle const &	particle,
		csl::Expr const &	newTerm
	)

Replaces a particle in all kinetic / mass / interactions terms of a model.

Parameters

model	Model in which we do the replacement.
particle	Particle to replace.
newTerm	New expression.

See also

The overload of this function with 4 parameters.

requiresPenguinPatch()

bool mty::requiresPenguinPatch

(

Amplitude const &

amplitude

)

Tells if a set of wilson coefficients requires the penguin patch implemented in this file. This function must return true for the applyPenguinPatch() function to work (otherwise it raises an error).

Parameters

amplitude

Amplitude of the process.

Returns

True if the patch is required.

False otherwise.

Rotate() [1/2]

void mty::Rotate	(	mty::Model &	model,
		std::vector< mty::Particle > const &	fields,
		std::vector< mty::Particle > const &	newFields,
		std::vector< std::vector< csl::Expr >> const &	rotation,
		bool	diagonalizeMasses = false
	)

Rotates a bunch of fields to another using a given matrix.

A useful feature for model building is field rotation. For example when dealing with non trivial mass matrices, one could want to diagonalize them by rotating fields. For example, in a theory with two real scalar fields \( \phi _1(X) \) and \( \phi _2(X) \) with a lagrangian containing

\[ \mathcal{L} \ni -\frac{1}{2}m^2(\phi _1^2 + 2\phi _1\phi _2 + \phi _2^2) - \frac{\lambda}{3!}\phi _1^3, \]

one may want to replace \( \phi _1 \rightarrow (\phi _1+ \phi _2)/\sqrt{2} \) massive field, and \( \phi _2\rightarrow (\phi _1 - \phi _2)/\sqrt{2} \) massless field. The corresponding rotation reads

\[ \left(\begin{array}{c} \phi _1 \\ \phi _2 \end{array}\right) = \frac{1}{\sqrt{2}} \left(\begin{array}{c c} 1 & 1 \\ 1 & -1 \end{array}\right)\cdot \left(\begin{array}{c} \tilde{\phi} _1 \\ \tilde{\phi}_2 \end{array}\right). \]

Applying that rotation in a code would look like (given all fields and the model variables already exist):

Rotate(
        model,
        {phi1, phi2},
        {phi_1_tilde, phi_2_tilde},
        {{1 / csl::sqrt_s(2),  1 / csl::sqrt_s(2)},
         {1 / csl::sqrt_s(2), -1 / csl::sqrt_s(2)}}
         );

The rotation will yield the final lagrangian (getting rid of the tildas):

\[ \mathcal{L} \ni -\frac{1}{2}m^2\phi _1^2 - \frac{\lambda}{12\sqrt{2}}\left(\phi _1^3 + \phi _2^3\right) - \frac{\lambda}{6\sqrt{2}}\left(\phi _1\phi _2^2 + \phi _1^2\phi _2 \right). \]

Parameters

model	Model in which we rotate particles.
fields	Initial fields to rotate.
newFields	New fields after the rotation.
rotation	Rotation matrix.
diagonalizeMasses	Boolean (optional, default = false). If true, all non diagonal mass term between new fields are suppressed after the rotation.

Rotate() [2/2]

void mty::Rotate	(	mty::Model &	model,
		std::vector< std::string > const &	fields,
		std::vector< std::string > const &	newFields,
		std::vector< std::vector< csl::Expr >> const &	rotation,
		bool	diagonalizeMasses = false
	)

Rotates a bunch of fields to another using a given matrix.

Parameters

model	Model in which we rotate particles.
fields	Initial names of the fields to rotate.
newFields	Names of the new fields after the rotation.
rotation	Rotation matrix.
diagonalizeMasses	Boolean (optional, default = false). If true, all non diagonal mass term between new fields are suppressed after the rotation.

See also

The overload of this function taking mty::Particle as parameter instead of names.

scalarboson_s()

template<class ... Args>

Particle mty::scalarboson_s ( Args &&...  args )

inline

Delegates the construction of a Scalar boson and returns the result.

This function can take any argument that the constructors ScalarBoson::ScalarBoson() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created scalar boson.

SetGaugeChoice() [1/2]

void mty::SetGaugeChoice	(	mty::Model &	model,
		std::string const &	nameParticle,
		mty::gauge::Type	choice
	)

This function changes the gauge fixing parameter for the gauge boson of name nameGroup. Depending on this choice, the propagator of gauge bosons is modified.

The propagator of a gauge boson is

\[ -i\frac{g_{\mu\nu} - (1-\xi)\frac{p_\mu p_\nu}{p^2 - \xi M^2}}{p^2-M^2} \]

, with \( M \) the mass of the particle. The Lorentz gauge corresponds to \( \xi=0\), the Feynman gauge to \( \xi=1\), the Unitary gauge to \( \xi=\infty\). Finally the choice NoGauge let \( \xi\) free, for the so-called \(\mathcal{R}_\xi\) gauge. For more information see gauge::Type.

Parameters

model	Model in which the particle is present.
nameParticle	The name of the GaugeBoson to modify.
choice	New gauge fixing choice, element of gauge::Type.

SetGaugeChoice() [2/2]

void mty::SetGaugeChoice	(	mty::Particle	particle,
		mty::gauge::Type	choice
	)

This function changes the gauge choice in model for the gauge boson particle. Depending on this choice, the propagator of gauge bosons is modified.

The propagator of a gauge boson is

\[ -i\frac{g_{\mu\nu} - (1-\xi)\frac{p_\mu p_\nu}{p^2 - \xi M^2}}{p^2-M^2} \]

, with \( M \) the mass of the particle. The Lorentz gauge corresponds to \( \xi=0\), the Feynman gauge to \( \xi=1\), the Unitary gauge to \( \xi=\infty\). Finally the choice NoGauge let \( \xi\) free, for the so-called \(\mathcal{R}_\xi\) gauge. For more information see gauge::Type.

Parameters

particle	Particle (must be a GaugeBoson) for gauge fixing.
choice	New gauge fixing choice, element of gauge::Type.

stringToGroupType()

group::Type mty::stringToGroupType

(

std::string const &

name

)

Converts a string to a group type. Allows to read a group::Type in a file.

Parameters

name	Name of the type.

Returns

The corresponding group::Type.

vectorboson_s()

template<class ... Args>

Particle mty::vectorboson_s ( Args &&...  args )

inline

Delegates the construction of a vector boson and returns the result.

This function can take any argument that the constructors VectorBoson::VectorBoson() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created vector boson.

VectorSpace()

const csl::Space * mty::VectorSpace	(	mty::Model const &	model,
		std::string const &	nameGroup,
		Particle const &	part
	)

Returns the vector space corresponding to the representation of a given particle in a given group.

This function allows to get the vector space associated to any representation in the model, in particular to generate indices in that space. For example in QCD, a quark q and a gluon g would yield for \( SU(3) \) respectively a 3D and a 8D vector spaces. The code would look like:

_3D_space = VectorSpace(QCD, "SU_3", q);
_8D_space = VectorSpace(QCD, "SU_3", g);

Parameters

model	Model in which the particle lives.
nameGroup	Name of the group.
part	Particle from which we take the representation.

Returns

The vector space of the representation of part in the group named nameGroup.

weylfermion_s()

template<class ... Args>

Particle mty::weylfermion_s ( Args &&...  args )

inline

Delegates the construction of a Weyl fermion and returns the result.

This function can take any argument that the constructors WeylFermion::WeylFermion() take to forward them to it.

Template Parameters

...Args

Variadic template arguments

Parameters

...args

Parameter pack

Returns

The newly created Weyl fermion.

wick_s()

csl::Expr mty::wick_s

(

const csl::Expr &

expr

)

Tries to create a Wick object with argument expr. Applies operator (see Operator::applyOperator()) to eliminate constants (with respect to the Wick object) and returns and resulting csl::Expr.

Parameters

expr	Initial argument of the Wick operator.

Returns

The resulting expression when the operator rules have been applied.

Variable Documentation

defaultSpaceTimePoint

csl::Tensor mty::defaultSpaceTimePoint

inline

Initial value:

= csl::tensor_s(
        "X",
        &csl::Minkowski
        )

Default space-time point when not given while defining a QuantumField.

See QuantumField::operator(). To define a QuantumField, one needs in general indices (except for fully scalar fields), and a space-time point. This defines an object like \( A^{\mu A}(X) \). That being said, it is rarely important to specify the space-time point of the field. In particular, in any interaction term of the Lagrangian all fields are at the same point. This variable is given by default to QuantumField when no point is given. A code like

A({mu, A}); 

is equivalent to

A({mu, A}, defaultSpaceTimePoint) 

. Then, whe integrated to the Lagrangian, the point is automatically replaced by the one of the Lagrangian.

I10_E7_data

constexpr std::array<GIndex_t<7>, 21> mty::I10_E7_data

inline

Initial value:

=
    {
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 0}, -2 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 1}, 230 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 2, 0}, 570 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 0, 0}, -456 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 1, 0}, -210 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 0, 0}, -834 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 0, 0}, 760 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 3, 0}, 50160 }),
        GIndex_t<7>({ {0, 0, 0, 1, 0, 0, 0}, -7450 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 1}, 13490 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 1, 0}, -16568 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 1}, 36195 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 2, 0}, 59280 }),
        GIndex_t<7>({ {1, 0, 0, 0, 1, 0, 0}, -78088 }),
        GIndex_t<7>({ {3, 0, 0, 0, 0, 0, 0}, -116620 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 2}, 404280 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 4, 0}, 2153840 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 1, 0}, -75318 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 1, 0}, 22440 }),
        GIndex_t<7>({ {0, 0, 1, 0, 0, 0, 0}, 79800 })
    }

I12_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I12_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, -62 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, -2021 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, -2021 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, 2074 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 2074 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 116 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, 424 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, 424 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, -131928 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, 122202 })
    }

I12_E7_data

constexpr std::array<GIndex_t<7>, 21> mty::I12_E7_data

inline

Initial value:

=
    {
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 0}, -30 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 1}, -2082 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 2, 0}, 2134 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 0, 0}, -1992 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 1, 0}, 534 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 0, 0}, -63438 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 0, 0}, 57480 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 3, 0}, 292896 }),
        GIndex_t<7>({ {0, 0, 0, 1, 0, 0, 0}, 63998 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 1}, -171138 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 1, 0}, -172464 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 1}, -366717 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 2, 0}, 410928 }),
        GIndex_t<7>({ {1, 0, 0, 0, 1, 0, 0}, -197560 }),
        GIndex_t<7>({ {3, 0, 0, 0, 0, 0, 0}, -13615284 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 2}, -6024744 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 4, 0}, 17066368 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 1, 0}, -3178974 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 1, 0}, 3531792 }),
        GIndex_t<7>({ {0, 0, 1, 0, 0, 0, 0}, 2601722601720 })
    }

I12_F4_data

constexpr std::array<GIndex_t<4>, 7> mty::I12_F4_data

inline

Initial value:

=
    {
        GIndex_t<4>({ {0, 0, 0, 1}, 1 }),
        GIndex_t<4>({ {1, 0, 0, 0}, -63 }),
        GIndex_t<4>({ {0, 0, 1, 0}, -1959 }),
        GIndex_t<4>({ {0, 0, 0, 2}, 2073 }),
        GIndex_t<4>({ {1, 0, 0, 1}, 372 }),
        GIndex_t<4>({ {2, 0, 0, 0}, -134373 }),
        GIndex_t<4>({ {0, 1, 0, 0}, 125811 })
    }

I2_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I2_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, 4 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, 25 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, 25 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, 28 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 28 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 50 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, 160 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, 160 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, 270 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, 300 })
    }

I2_E7_data

constexpr std::array<GIndex_t<7>, 21> mty::I2_E7_data

inline

Initial value:

=
    {
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 0}, 3 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 1}, 30 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 2, 0}, 55 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 0, 0}, 54 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 1, 0}, 270 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 0, 0}, 351 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 0, 0}, 390 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 3, 0}, 1440 }),
        GIndex_t<7>({ {0, 0, 0, 1, 0, 0, 0}, 1430 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 1}, 2145 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 1, 0}, 2832 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 1}, 4995 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 2, 0}, 9450 }),
        GIndex_t<7>({ {1, 0, 0, 0, 1, 0, 0}, 9152 }),
        GIndex_t<7>({ {3, 0, 0, 0, 0, 0, 0}, 17940 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 2}, 17820 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 4, 0}, 24310 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 1, 0}, 21762 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 1, 0}, 23760 }),
        GIndex_t<7>({ {0, 0, 1, 0, 0, 0, 0}, 24750 })
    }

I2_F4_data

constexpr std::array<GIndex_t<4>, 7> mty::I2_F4_data

inline

Initial value:

=
    {
        GIndex_t<4>({ {0, 0, 0, 1}, 1 }),
        GIndex_t<4>({ {1, 0, 0, 0}, 3 }),
        GIndex_t<4>({ {0, 0, 1, 0}, 21 }),
        GIndex_t<4>({ {0, 0, 0, 2}, 27 }),
        GIndex_t<4>({ {1, 0, 0, 1}, 108 }),
        GIndex_t<4>({ {2, 0, 0, 0}, 135 }),
        GIndex_t<4>({ {0, 1, 0, 0}, 147 })
    }

I2_G2_data

constexpr std::array<GIndex_t<2>, 16> mty::I2_G2_data

inline

Initial value:

=
    {
        GIndex_t<2>({ {0, 1}, 1 }),
        GIndex_t<2>({ {1, 0}, 4 }),
        GIndex_t<2>({ {0, 2}, 9 }),
        GIndex_t<2>({ {1, 1}, 32 }),
        GIndex_t<2>({ {0, 3}, 44 }),
        GIndex_t<2>({ {2, 0}, 55 }),
        GIndex_t<2>({ {0, 4}, 156 }),
        GIndex_t<2>({ {1, 2}, 144 }),
        GIndex_t<2>({ {3, 0}, 351 }),
        GIndex_t<2>({ {2, 1}, 286 }),
        GIndex_t<2>({ {0, 5}, 450 }),
        GIndex_t<2>({ {1, 3}, 480 }),
        GIndex_t<2>({ {0, 6}, 1122 }),
        GIndex_t<2>({ {2, 2}, 972 }),
        GIndex_t<2>({ {4, 0}, 1496 }),
        GIndex_t<2>({ {3, 1}, 1472 })
    }

I5_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I5_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, -1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, 0 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, 11 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, -11 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, -44 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 44 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 0 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, -88 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, 88 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, 0 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, 0 })
    }

I6_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I6_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, -6 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, -5 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, -5 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, 58 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 58 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 60 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, -80 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, -80 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, -720 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, -270 })
    }

I6_E7_data

constexpr std::array<GIndex_t<7>, 21> mty::I6_E7_data

inline

Initial value:

=
    {
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 0}, -2 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 1}, -10 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 2, 0}, 90 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 0, 0}, 24 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 1, 0}, 30 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 0, 0}, -354 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 0, 0}, -200 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 3, 0}, 3600 }),
        GIndex_t<7>({ {0, 0, 0, 1, 0, 0, 0}, -10 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 1}, 530 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 1, 0}, 2872 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 1}, -3165 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 2, 0}, 8400 }),
        GIndex_t<7>({ {1, 0, 0, 0, 1, 0, 0}, -328 }),
        GIndex_t<7>({ {3, 0, 0, 0, 0, 0, 0}, -26380 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 2}, -9000 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 4, 0}, 88400 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 1, 0}, -9318 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 1, 0}, 600 }),
        GIndex_t<7>({ {0, 0, 1, 0, 0, 0, 0}, -9000 })
    }

I6_F4_data

constexpr std::array<GIndex_t<4>, 7> mty::I6_F4_data

inline

Initial value:

=
    {
        GIndex_t<4>({ {0, 0, 0, 1}, 1 }),
        GIndex_t<4>({ {1, 0, 0, 0}, -7 }),
        GIndex_t<4>({ {0, 0, 1, 0}, 1 }),
        GIndex_t<4>({ {0, 0, 0, 2}, 57 }),
        GIndex_t<4>({ {1, 0, 0, 1}, -132 }),
        GIndex_t<4>({ {2, 0, 0, 0}, -645 }),
        GIndex_t<4>({ {0, 1, 0, 0}, -133 })
    }

I6_G2_data

constexpr std::array<GIndex_t<2>, 16> mty::I6_G2_data

inline

Initial value:

=
    {
        GIndex_t<2>({ {0, 1}, 1 }),
        GIndex_t<2>({ {1, 0}, -26 }),
        GIndex_t<2>({ {0, 2}, 39 }),
        GIndex_t<2>({ {1, 1}, -208 }),
        GIndex_t<2>({ {0, 3}, 494 }),
        GIndex_t<2>({ {2, 0}, -1235 }),
        GIndex_t<2>({ {0, 4}, 3666 }),
        GIndex_t<2>({ {1, 2}, -456 }),
        GIndex_t<2>({ {3, 0}, -20709 }),
        GIndex_t<2>({ {2, 1}, -7904 }),
        GIndex_t<2>({ {0, 5}, 19500 }),
        GIndex_t<2>({ {1, 3}, 2640 }),
        GIndex_t<2>({ {0, 6}, 82212 }),
        GIndex_t<2>({ {2, 2}, -27378 }),
        GIndex_t<2>({ {4, 0}, -193324 }),
        GIndex_t<2>({ {3, 1}, -109408 })
    }

I8_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I8_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, 18 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, -101 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, -101 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, 154 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 154 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 36 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, 664 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, 664 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, 3672 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, -918 })
    }

I8_E7_data

constexpr std::array<GIndex_t<7>, 21> mty::I8_E7_data

inline

Initial value:

=
    {
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 0}, 1 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 0}, 10 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 1}, -82 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 2, 0}, 174 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 0, 0}, -72 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 1, 0}, 774 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 0, 0}, 2682 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 0, 0}, 40 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 3, 0}, 10176 }),
        GIndex_t<7>({ {0, 0, 0, 1, 0, 0, 0}, -3442 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 1, 1}, -3658 }),
        GIndex_t<7>({ {0, 0, 0, 0, 1, 1, 0}, 256 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 0, 1}, 963 }),
        GIndex_t<7>({ {1, 0, 0, 0, 0, 2, 0}, 41328 }),
        GIndex_t<7>({ {1, 0, 0, 0, 1, 0, 0}, 9320 }),
        GIndex_t<7>({ {3, 0, 0, 0, 0, 0, 0}, 271676 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 0, 2}, -94824 }),
        GIndex_t<7>({ {0, 0, 0, 0, 0, 4, 0}, 329888 }),
        GIndex_t<7>({ {2, 0, 0, 0, 0, 1, 0}, 155826 }),
        GIndex_t<7>({ {0, 1, 0, 0, 0, 1, 0}, 12672 }),
        GIndex_t<7>({ {0, 0, 1, 0, 0, 0, 0}, -63240 })
    }

I8_F4_data

constexpr std::array<GIndex_t<4>, 7> mty::I8_F4_data

inline

Initial value:

=
    {
        GIndex_t<4>({ {0, 0, 0, 1}, 1 }),
        GIndex_t<4>({ {1, 0, 0, 0}, 17 }),
        GIndex_t<4>({ {0, 0, 1, 0}, -119 }),
        GIndex_t<4>({ {0, 0, 0, 2}, 153 }),
        GIndex_t<4>({ {1, 0, 0, 1}, 612 }),
        GIndex_t<4>({ {2, 0, 0, 0}, 2907 }),
        GIndex_t<4>({ {0, 1, 0, 0}, -1309 })
    }

I9_E6_data

constexpr std::array<GIndex_t<6>, 12> mty::I9_E6_data

inline

Initial value:

=
    {
        GIndex_t<6>({ {1, 0, 0, 0, 0, 0}, 1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 0}, -1 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 1}, 0 }),
        GIndex_t<6>({ {0, 1, 0, 0, 0, 0}, -229 }),
        GIndex_t<6>({ {0, 0, 0, 1, 0, 0}, 229 }),
        GIndex_t<6>({ {0, 0, 0, 0, 2, 0}, -284 }),
        GIndex_t<6>({ {2, 0, 0, 0, 0, 0}, 284 }),
        GIndex_t<6>({ {1, 0, 0, 0, 1, 0}, 0 }),
        GIndex_t<6>({ {0, 0, 0, 0, 1, 1}, 152 }),
        GIndex_t<6>({ {1, 0, 0, 0, 0, 1}, -152 }),
        GIndex_t<6>({ {0, 0, 0, 0, 0, 2}, 0 }),
        GIndex_t<6>({ {0, 0, 1, 0, 0, 0}, 0 })
    }