The Helicity namespace contains classes for spin representation classes in ThePEG. More...

Namespaces
	ColourStructure
	Namespace for naming types of colour structures to allow models to define new type.

	CouplingType
	Namespace for naming types of couplings to allow models to define new type.

	VertexType
	Namespace for naming of vertices.

Classes
class	AbstractFFFFVertex
	The AbstractFFFFVertex class provides a base class for all 4-fermion vertices in ThePEG. More...

class	AbstractFFSSVertex
	Here is the documentation of the AbstractFFSSVertex class. More...

class	AbstractFFSTVertex
	The AbstractFFSTVertex class is the base class for all fermion-fermion-scalar-tensor interactions in ThePEG. More...

class	AbstractFFSVertex
	The AbstractFFSVertex class provides a base class for all fermion-fermion-scalar vertices in ThePEG. More...

class	AbstractFFTVertex
	The AbstractFFTVertex class is the base class for all fermion-fermion-tensor interactions in ThePEG. More...

class	AbstractFFVSVertex
	Here is the documentation of the AbstractFFVSVertex class. More...

class	AbstractFFVTVertex
	The AbstractFFVTVertex class is the base class for all fermion-fermion-vector-tensor interactions in ThePEG. More...

class	AbstractFFVVertex
	The AbstractFFVVertex class provides a base class for all fermion-fermion-vector vertices in ThePEG. More...

class	AbstractFFVVVertex
	The AbstractFFVVVertex class provides a base class for all fermion-fermion-vector-vector vertices in ThePEG. More...

class	AbstractRFSSVertex
	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-scalar-scalar vertices in ThePEG. More...

class	AbstractRFSVertex
	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-scalar vertices in ThePEG. More...

class	AbstractRFVSVertex
	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-vector-scalar vertices in ThePEG. More...

class	AbstractRFVVertex
	The AbstractRFVVertex class provides a base class for all spin-3/2 fermion-fermion-vector vertices in ThePEG. More...

class	AbstractRFVVVertex
	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-vector-vector vertices in ThePEG. More...

class	AbstractSSSSVertex
	The AbstractSSSSVertex class is the base class for all scalar-scalar-scalar interactions in ThePEG. More...

class	AbstractSSSTVertex
	The AbstractSSSTVertex class is the base class for all scalar-scalar-scalar-tensor interactions in ThePEG. More...

class	AbstractSSSVertex
	The AbstractSSSVertex class is the base class for all scalar-scalar-scalar interactions in ThePEG. More...

class	AbstractSSTVertex
	The AbstractSSTVertex class is the base class for scalar-scalar-tensor interactions in ThePEG. More...

class	AbstractVSSVertex
	The AbstractVSSVertex class is the base class for vector-scalar-scalar interactions in ThePEG. More...

class	AbstractVVSSVertex
	The AbstractVVSSVertex class is the base class for vector-vector-scalar-scalar interactions in ThePEG. More...

class	AbstractVVSTVertex
	The AbstractVVSTVertex class is the base class for all vector-vector-scalar-tensor interactions in ThePEG. More...

class	AbstractVVSVertex
	Here is the documentation of the AbstractVVSVertex class. More...

class	AbstractVVTVertex
	Here is the documentation of the AbstractVVTVertex class. More...

class	AbstractVVVSVertex
	The AbstractVVVSVertex class provides the base class for all vector-vector-vector interactions in ThePEG. More...

class	AbstractVVVTVertex
	The AbstractVVVTVertex class is the base class for all vector-vector-vector-tensor interactions in ThePEG. More...

class	AbstractVVVVertex
	The AbstractVVVVertex class provides the base class for all vector-vector-vector interactions in ThePEG. More...

class	AbstractVVVVVertex
	The AbstractVVVVVertex class is the base class for vector-vector-vector-vector interactions in ThePEG. More...

class	FermionSpinInfo
	The FermionSpinInfo class inherits from the SpinInfo class and implements the storage of the basis vectors for a spin-1/2 particle. More...

class	FFSVertex
	The FFSVertex class is the implementation of the interact of a scalar boson and a fermion-antifermion pair. More...

class	FFTVertex
	The FFTVertex class is the implementation of the fermion-fermion-tensor vertex. More...

class	FFVTVertex
	The FFVTVertex class is the implementation of the fermion-fermion–vector-tensor vertex. More...

class	FFVVertex
	The FFVVertex class is the base class for all helicity amplitude vertices which use the renormalisable form for the fermion-fermion-vector vertex. More...

class	GeneralFFVVertex
	The GeneralFFVVertex class is the base class for all helicity amplitude vertices which use a general form of the fermion-fermion-vector vertex. More...

class	GeneralVSSVertex
	Here is the documentation of the GeneralVSSVertex class. More...

class	GeneralVVSVertex
	The GeneralVVSVertex class implements a general Vector-Vector-Scalar vertex allowing for decay modes that only enter at the one-loop level. More...

class	LorentzRSSpinor
	The LorentzRSSpinor class is designed to store a Rarita-Schwinger spinor for a spin-3/2 particle. More...

class	LorentzRSSpinorBar
	The `LorentzRSSpinorBar` class implements the storage of a barred Lorentz Rarita-Schwinger Spinor for a spin-3/2 particle. More...

class	LorentzSpinor
	The LorentzSpinor class is designed to store a spinor. More...

class	LorentzSpinorBar
	The LorentzSpinorBar class implements the storage of a barred LorentzSpinor. More...

class	LorentzTensor
	The LorentzTensor class is designed to implement the storage of a complex tensor to be used to representation the wavefunction of a spin-2 particle. More...

class	RFSVertex
	The RFSVertex class is the implementation of the interact of a scalar boson and a spin-3/2 fermion-antifermion pair. More...

class	RFVVertex
	The RFVVertex class is the base class for all helicity amplitude vertices which use the renormalisable form for the spin-3/2 fermion-fermion-vector vertex. More...

class	RSFermionSpinInfo
	The RSFermionSpinInfo class inherits from the SpinInfo class and implements the storage of the basis vector for a spin-3/2 particle. More...

class	RSSpinorBarWaveFunction
	The `RSSpinorBarWaveFunction` class is designed to store the wavefunction of a spin- $\frac32$ particle in a form suitable for use in helicity amplitude calculations of the matrix element using a similar philosophy to the FORTRAN HELAS code. More...

class	RSSpinorWaveFunction
	The RSSpinorWaveFunction class is designed to store the wavefunction of a spin-3/2 particle in a form suitable for use in helicity amplitude calculations of the matrix element using a similar philosophy to the FORTRAN HELAS code. More...

class	ScalarSpinInfo
	The ScalarSpinInfo class is designed to be the implementation of the spin information for a scalar particle. More...

class	ScalarWaveFunction

class	SpinorBarWaveFunction

class	SpinorWaveFunction

class	SSSSVertex
	The SSSSVertex class is the implementation of the interaction of four scalars. More...

class	SSSVertex
	The SSSVertex class is the implementation of the interaction of three scalars. More...

class	SSTVertex
	The VVTVertexclass is the implementation of the scalar-scalar-tensor vertex. More...

class	TensorSpinInfo
	The TensorSpinInfo class is the implementation of the spin information for tensor particles. More...

class	TensorWaveFunction

class	VectorSpinInfo
	The VectorSpinInfo class is the implementation of the spin information for vector particles. More...

class	VectorWaveFunction

class	VertexBase
	The VertexBase class is the base class for all helicity amplitude vertices. More...

class	VSSVertex
	The VSSVertex class is the implementation of the vector-scalar-scalar vertex. More...

class	VVSSVertex
	The VVSSVertex class is the implementation of the coupling of two vectors and two scalars. More...

class	VVSVertex
	The VVSVertex class is the implementation of the vector-vector-scalar. More...

class	VVTVertex
	The VVTVertex class is the implementation of the vector-vector-tensor vertex. More...

class	VVVSVertex
	The VVVSVertex class is the base class for triple vector scalar vertices. More...

class	VVVTVertex
	The VVTVertex class is the implementation of the vector-vector-vector-tensor vertex. More...

class	VVVVertex
	The VVVVertex class is the base class for triple vector vertices using the perturbative form. More...

class	VVVVVertex
	This is the implementation of the four vector vertex. More...

class	WaveFunctionBase

Typedefs
typedef LorentzVector< complex< double > >	LorentzPolarizationVector
	Convenience typedef.

typedef LorentzVector< complex< Energy > >	LorentzPolarizationVectorE
	Convenience typedef.

Enumerations
enum	SpinorType { SpinorType::u, SpinorType::v, SpinorType::unknown }
	Enumeration to specify spinor type. More...

enum	VectorPhase { vector_phase, vector_nophase, default_vector_phase =vector_nophase }
	Definition of the enumerated values of the phase to include in the calculation of the polarization vector. More...

enum	TensorPhase { tensor_phase, tensor_nophase, default_tensor_phase =tensor_nophase }
	Definition of the enumerated values of the phase to include in the calculation of the polarization tensor. More...

enum	Direction { incoming, outgoing, intermediate }
	Definition of the enumerated values used for the direction of the particles in the calculation of the wavefunction. More...

Functions
template<typename A , typename B , typename C >
auto	epsilon (const LorentzVector< A > &a, const LorentzVector< B > &b, const LorentzVector< C > &c) -> LorentzVector< decltype(a.x() b.y() c.z())>
	Return the product $\epsilon^{\mu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}v_{3\gamma}$ . More...

template<typename T , typename U >
auto	operator* (complex< U > a, const LorentzTensor< T > &t) -> LorentzTensor< decltype(a.real() *t.xx().real())>
	Multiplication by a complex number.

template<typename T , typename U >
auto	operator* (const LorentzTensor< T > &t, complex< U > a) -> LorentzTensor< decltype(a.real() *t.xx().real())>
	Multiplication by a complex number.

template<typename T , typename U >
auto	operator* (const LorentzVector< U > &v, const LorentzTensor< T > &t) -> LorentzVector< decltype(v.t() *t(3, 0))>
	Multiply a LorentzVector by a LorentzTensor.

template<typename T , typename U >
auto	operator* (const LorentzTensor< T > &t, const LorentzVector< U > &v) -> LorentzVector< decltype(v.t() *t(0, 3))>
	Multiply a LorentzTensor by a LorentzVector.

template<typename T , typename U >
auto	operator* (const LorentzTensor< T > &t, const LorentzTensor< U > &u) -> decltype(t.xx() *u.xx())
	Multiply a LorentzTensor by a LorentzTensor. More...

ostream &	operator<< (ostream &, const VertexBase &)
	Output the information on the vertex. More...

Basic mathematical operations
template<typename Value >
LorentzRSSpinor< double >	operator/ (const LorentzRSSpinor< Value > &v, Value a)

LorentzRSSpinor< double >	operator/ (const LorentzRSSpinor< double > &v, Complex a)

template<typename Value >
LorentzRSSpinor< Value >	operator- (const LorentzRSSpinor< Value > &v)

template<typename ValueA , typename ValueB >
LorentzRSSpinor< ValueA >	operator+ (LorentzRSSpinor< ValueA > a, const LorentzRSSpinor< ValueB > &b)

template<typename ValueA , typename ValueB >
LorentzRSSpinor< ValueA >	operator- (LorentzRSSpinor< ValueA > a, const LorentzRSSpinor< ValueB > &b)

template<typename Value >
LorentzRSSpinor< Value >	operator* (const LorentzRSSpinor< Value > &a, double b)

template<typename Value >
LorentzRSSpinor< Value >	operator* (double b, LorentzRSSpinor< Value > a)

template<typename Value >
LorentzRSSpinor< Value >	operator* (const LorentzRSSpinor< Value > &a, Complex b)

template<typename ValueA , typename ValueB >
auto	operator* (complex< ValueB > a, const LorentzRSSpinor< ValueA > &v) -> LorentzRSSpinor< decltype(a.real() *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzRSSpinor< ValueA > &v, complex< ValueB > b) -> LorentzRSSpinor< decltype(b.real() *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzRSSpinor< ValueA > &v, complex< ValueB > b) -> LorentzRSSpinor< decltype(v.xs1().real()/b.real())>

template<typename ValueA , typename ValueB >
auto	operator* (ValueB a, const LorentzRSSpinor< ValueA > &v) -> LorentzRSSpinor< decltype(a *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzRSSpinor< ValueA > &v, ValueB b) -> LorentzRSSpinor< decltype(b *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzRSSpinor< ValueA > &v, ValueB b) -> LorentzRSSpinor< decltype(v.xs1().real()/b)>

template<typename Value >
LorentzRSSpinorBar< double >	operator/ (const LorentzRSSpinorBar< Value > &v, Value a)

LorentzRSSpinorBar< double >	operator/ (const LorentzRSSpinorBar< double > &v, Complex a)

template<typename Value >
LorentzRSSpinorBar< Value >	operator- (const LorentzRSSpinorBar< Value > &v)

template<typename ValueA , typename ValueB >
LorentzRSSpinorBar< ValueA >	operator+ (LorentzRSSpinorBar< ValueA > a, const LorentzRSSpinorBar< ValueB > &b)

template<typename ValueA , typename ValueB >
LorentzRSSpinorBar< ValueA >	operator- (LorentzRSSpinorBar< ValueA > a, const LorentzRSSpinorBar< ValueB > &b)

template<typename Value >
LorentzRSSpinorBar< Value >	operator* (const LorentzRSSpinorBar< Value > &a, double b)

template<typename Value >
LorentzRSSpinorBar< Value >	operator* (double b, LorentzRSSpinorBar< Value > a)

template<typename Value >
LorentzRSSpinorBar< Value >	operator* (const LorentzRSSpinorBar< Value > &a, Complex b)

template<typename ValueA , typename ValueB >
auto	operator* (complex< ValueB > a, const LorentzRSSpinorBar< ValueA > &v) -> LorentzRSSpinorBar< decltype(a.real() *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzRSSpinorBar< ValueA > &v, complex< ValueB > b) -> LorentzRSSpinorBar< decltype(b.real() *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzRSSpinorBar< ValueA > &v, complex< ValueB > b) -> LorentzRSSpinorBar< decltype(v.xs1().real()/b.real())>

template<typename ValueA , typename ValueB >
auto	operator* (ValueB a, const LorentzRSSpinorBar< ValueA > &v) -> LorentzRSSpinorBar< decltype(a *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzRSSpinorBar< ValueA > &v, ValueB b) -> LorentzRSSpinorBar< decltype(b *v.xs1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzRSSpinorBar< ValueA > &v, ValueB b) -> LorentzRSSpinorBar< decltype(v.xs1().real()/b)>

template<typename Value >
LorentzSpinor< double >	operator/ (const LorentzSpinor< Value > &v, Value a)

LorentzSpinor< double >	operator/ (const LorentzSpinor< double > &v, Complex a)

template<typename Value >
LorentzSpinor< Value >	operator- (const LorentzSpinor< Value > &v)

template<typename ValueA , typename ValueB >
LorentzSpinor< ValueA >	operator+ (LorentzSpinor< ValueA > a, const LorentzSpinor< ValueB > &b)

template<typename ValueA , typename ValueB >
LorentzSpinor< ValueA >	operator- (LorentzSpinor< ValueA > a, const LorentzSpinor< ValueB > &b)

template<typename Value >
LorentzSpinor< Value >	operator* (const LorentzSpinor< Value > &a, double b)

template<typename Value >
LorentzSpinor< Value >	operator* (double b, LorentzSpinor< Value > a)

template<typename Value >
LorentzSpinor< Value >	operator* (const LorentzSpinor< Value > &a, Complex b)

template<typename ValueA , typename ValueB >
auto	operator* (complex< ValueB > a, const LorentzSpinor< ValueA > &v) -> LorentzSpinor< decltype(a.real() *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzSpinor< ValueA > &v, complex< ValueB > b) -> LorentzSpinor< decltype(b.real() *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzSpinor< ValueA > &v, complex< ValueB > b) -> LorentzSpinor< decltype(v.s1().real()/b.real())>

template<typename ValueA , typename ValueB >
auto	operator* (ValueB a, const LorentzSpinor< ValueA > &v) -> LorentzSpinor< decltype(a *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzSpinor< ValueA > &v, ValueB b) -> LorentzSpinor< decltype(b *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzSpinor< ValueA > &v, ValueB b) -> LorentzSpinor< decltype(v.s1().real()/b)>

template<typename Value >
LorentzSpinorBar< double >	operator/ (const LorentzSpinorBar< Value > &v, Value a)

LorentzSpinorBar< double >	operator/ (const LorentzSpinorBar< double > &v, Complex a)

template<typename Value >
LorentzSpinorBar< Value >	operator- (const LorentzSpinorBar< Value > &v)

template<typename ValueA , typename ValueB >
LorentzSpinorBar< ValueA >	operator+ (LorentzSpinorBar< ValueA > a, const LorentzSpinorBar< ValueB > &b)

template<typename ValueA , typename ValueB >
LorentzSpinorBar< ValueA >	operator- (LorentzSpinorBar< ValueA > a, const LorentzSpinorBar< ValueB > &b)

template<typename Value >
LorentzSpinorBar< Value >	operator* (const LorentzSpinorBar< Value > &a, double b)

template<typename Value >
LorentzSpinorBar< Value >	operator* (double b, LorentzSpinorBar< Value > a)

template<typename Value >
LorentzSpinorBar< Value >	operator* (const LorentzSpinorBar< Value > &a, Complex b)

template<typename ValueA , typename ValueB >
auto	operator* (complex< ValueB > a, const LorentzSpinorBar< ValueA > &v) -> LorentzSpinorBar< decltype(a.real() *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzSpinorBar< ValueA > &v, complex< ValueB > b) -> LorentzSpinorBar< decltype(b.real() *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzSpinorBar< ValueA > &v, complex< ValueB > b) -> LorentzSpinorBar< decltype(v.s1().real()/b.real())>

template<typename ValueA , typename ValueB >
auto	operator* (ValueB a, const LorentzSpinorBar< ValueA > &v) -> LorentzSpinorBar< decltype(a *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator* (const LorentzSpinorBar< ValueA > &v, ValueB b) -> LorentzSpinorBar< decltype(b *v.s1().real())>

template<typename ValueA , typename ValueB >
auto	operator/ (const LorentzSpinorBar< ValueA > &v, ValueB b) -> LorentzSpinorBar< decltype(v.s1().real()/b)>

Detailed Description

The Helicity namespace contains classes for spin representation classes in ThePEG.

Enumeration Type Documentation

◆ Direction

enum ThePEG::Helicity::Direction

Definition of the enumerated values used for the direction of the particles in the calculation of the wavefunction.

Enumerator
incoming	An incoming particle.
outgoing	An outgoing particle.
intermediate	An intermediate particle.

Definition at line 29 of file WaveFunctionBase.h.

◆ SpinorType

enum ThePEG::Helicity::SpinorType

strong

Enumeration to specify spinor type.

Enumerator
u	u spinor.
v	v spinor.
unknown	Undefined spinor type.

Definition at line 37 of file HelicityDefinitions.h.

◆ TensorPhase

enum ThePEG::Helicity::TensorPhase

Definition of the enumerated values of the phase to include in the calculation of the polarization tensor.

Enumerator
tensor_phase	Include the phase factor.
tensor_nophase	No phase-factor.
default_tensor_phase	Default option.

Definition at line 28 of file TensorWaveFunction.h.

◆ VectorPhase

enum ThePEG::Helicity::VectorPhase

Definition of the enumerated values of the phase to include in the calculation of the polarization vector.

Enumerator
vector_phase	Include the phase factor.
vector_nophase	No phase-factor.
default_vector_phase	Default option.

Definition at line 47 of file HelicityDefinitions.h.

Function Documentation

◆ epsilon()

template<typename A , typename B , typename C >

auto ThePEG::Helicity::epsilon	(	const LorentzVector< A > &	a,
		const LorentzVector< B > &	b,
		const LorentzVector< C > &	c
	)		-> LorentzVector<decltype(a.x()b.y()c.z())>

Return the product $\epsilon^{\mu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}v_{3\gamma}$ .

Author: Peter Richardson

This class is designed to combine 5-momenta and polarization vectors together with the result being the product with the eps function. The class is purely static and contains no data.