[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
4.15.2 Color algebra
For computations in quantum chromodynamics, GiNaC implements the base elements and structure constants of the su(3) Lie algebra (color algebra). The base elements T_a are constructed by the function
ex color_T(const ex & a, unsigned char rl = 0); |
which takes two arguments: the index and a representation label in the
range 0 to 255 which is used to distinguish elements of different color
algebras. Objects with different labels commutate with each other. The
dimension of the index must be exactly 8 and it should be of class idx
,
not varidx
.
The unity element of a color algebra is constructed by
ex color_ONE(unsigned char rl = 0); |
Please notice: You must always use color_ONE()
when referring to
multiples of the unity element, even though it's customary to omit it.
E.g. instead of color_T(a)*(color_T(b)*indexed(X,b)+1)
you have to
write color_T(a)*(color_T(b)*indexed(X,b)+color_ONE())
. Otherwise,
GiNaC may produce incorrect results.
The functions
ex color_d(const ex & a, const ex & b, const ex & c); ex color_f(const ex & a, const ex & b, const ex & c); |
create the symmetric and antisymmetric structure constants d_abc and f_abc which satisfy {T_a, T_b} = 1/3 delta_ab + d_abc T_c and [T_a, T_b] = i f_abc T_c.
These functions evaluate to their numerical values, if you supply numeric indices to them. The index values should be in the range from 1 to 8, not from 0 to 7. This departure from usual conventions goes along better with the notations used in physical literature.
There's an additional function
ex color_h(const ex & a, const ex & b, const ex & c); |
which returns the linear combination ‘color_d(a, b, c)+I*color_f(a, b, c)’.
The function simplify_indexed()
performs some simplifications on
expressions containing color objects:
{ ... idx a(symbol("a"), 8), b(symbol("b"), 8), c(symbol("c"), 8), k(symbol("k"), 8), l(symbol("l"), 8); e = color_d(a, b, l) * color_f(a, b, k); cout << e.simplify_indexed() << endl; // -> 0 e = color_d(a, b, l) * color_d(a, b, k); cout << e.simplify_indexed() << endl; // -> 5/3*delta.k.l e = color_f(l, a, b) * color_f(a, b, k); cout << e.simplify_indexed() << endl; // -> 3*delta.k.l e = color_h(a, b, c) * color_h(a, b, c); cout << e.simplify_indexed() << endl; // -> -32/3 e = color_h(a, b, c) * color_T(b) * color_T(c); cout << e.simplify_indexed() << endl; // -> -2/3*T.a e = color_h(a, b, c) * color_T(a) * color_T(b) * color_T(c); cout << e.simplify_indexed() << endl; // -> -8/9*ONE e = color_T(k) * color_T(a) * color_T(b) * color_T(k); cout << e.simplify_indexed() << endl; // -> 1/4*delta.b.a*ONE-1/6*T.a*T.b ... |
To calculate the trace of an expression containing color objects you use one of the functions
ex color_trace(const ex & e, const std::set<unsigned char> & rls); ex color_trace(const ex & e, const lst & rll); ex color_trace(const ex & e, unsigned char rl = 0); |
These functions take the trace over all color ‘T’ objects in the
specified set rls
or list rll
of representation labels, or the
single label rl
; ‘T’s with other labels are left standing. For
example:
... e = color_trace(4 * color_T(a) * color_T(b) * color_T(c)); cout << e << endl; // -> -I*f.a.c.b+d.a.c.b } |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |