- added variants of dirac_trace() and color_trace() that take the trace over

[ginac.git] / ginac / color.cpp

diff --git a/ginac/color.cpp b/ginac/color.cpp
index 600da082f06a575b41ddd5c63446422289680af3..3f45bba5acaaa4bf9983245f650442f46091e3a2 100644 (file)
--- a/ginac/color.cpp
+++ b/ginac/color.cpp
@@ -89,12 +89,12 @@ color::color(const ex & b, const ex & i1, unsigned char rl) : inherited(b, i1),
        tinfo_key = TINFO_color;
 }
 
-color::color(unsigned char rl, const exvector & v, bool discardable) : inherited(sy_none(), v, discardable), representation_label(rl)
+color::color(unsigned char rl, const exvector & v, bool discardable) : inherited(not_symmetric(), v, discardable), representation_label(rl)
 {
        tinfo_key = TINFO_color;
 }
 
-color::color(unsigned char rl, std::auto_ptr<exvector> vp) : inherited(sy_none(), vp), representation_label(rl)
+color::color(unsigned char rl, std::auto_ptr<exvector> vp) : inherited(not_symmetric(), vp), representation_label(rl)
 {
        tinfo_key = TINFO_color;
 }
@@ -475,37 +475,44 @@ bool su3f::contract_with(exvector::iterator self, exvector::iterator other, exve
 
 ex color_ONE(unsigned char rl)
 {
-       return color(su3one(), rl);
+       static ex ONE = (new su3one)->setflag(status_flags::dynallocated);
+       return color(ONE, rl);
 }
 
 ex color_T(const ex & a, unsigned char rl)
 {
+       static ex t = (new su3t)->setflag(status_flags::dynallocated);
+
        if (!is_a<idx>(a))
                throw(std::invalid_argument("indices of color_T must be of type idx"));
        if (!ex_to<idx>(a).get_dim().is_equal(8))
                throw(std::invalid_argument("index dimension for color_T must be 8"));
 
-       return color(su3t(), a, rl);
+       return color(t, a, rl);
 }
 
 ex color_f(const ex & a, const ex & b, const ex & c)
 {
+       static ex f = (new su3f)->setflag(status_flags::dynallocated);
+
        if (!is_a<idx>(a) || !is_a<idx>(b) || !is_a<idx>(c))
                throw(std::invalid_argument("indices of color_f must be of type idx"));
        if (!ex_to<idx>(a).get_dim().is_equal(8) || !ex_to<idx>(b).get_dim().is_equal(8) || !ex_to<idx>(c).get_dim().is_equal(8))
                throw(std::invalid_argument("index dimension for color_f must be 8"));
 
-       return indexed(su3f(), sy_anti(), a, b, c);
+       return indexed(f, antisymmetric3(), a, b, c);
 }
 
 ex color_d(const ex & a, const ex & b, const ex & c)
 {
+       static ex d = (new su3d)->setflag(status_flags::dynallocated);
+
        if (!is_a<idx>(a) || !is_a<idx>(b) || !is_a<idx>(c))
                throw(std::invalid_argument("indices of color_d must be of type idx"));
        if (!ex_to<idx>(a).get_dim().is_equal(8) || !ex_to<idx>(b).get_dim().is_equal(8) || !ex_to<idx>(c).get_dim().is_equal(8))
                throw(std::invalid_argument("index dimension for color_d must be 8"));
 
-       return indexed(su3d(), sy_symm(), a, b, c);
+       return indexed(d, symmetric3(), a, b, c);
 }
 
 ex color_h(const ex & a, const ex & b, const ex & c)
@@ -520,12 +527,32 @@ static bool is_color_tinfo(unsigned ti, unsigned char rl)
        return ti == (TINFO_color + rl);
 }
 
-ex color_trace(const ex & e, unsigned char rl)
+/** Check whether a given tinfo key (as returned by return_type_tinfo()
+ *  is that of a color object (with an arbitrary representation label). */
+static bool is_color_tinfo(unsigned ti)
+{
+       return (ti & ~0xff) == TINFO_color;
+}
+
+/** Extract representation label from tinfo key (as returned by
+ *  return_type_tinfo()). */
+static unsigned char get_representation_label(unsigned ti)
+{
+       return ti & 0xff;
+}
+
+ex color_trace(const ex & e, const std::set<unsigned char> & rls)
 {
        if (is_a<color>(e)) {
 
-               if (ex_to<color>(e).get_representation_label() == rl
-                && is_a<su3one>(e.op(0)))
+               unsigned char rl = ex_to<color>(e).get_representation_label();
+
+               // Are we taking the trace over this object's representation label?
+               if (rls.find(rl) == rls.end())
+                       return e;
+
+               // Yes, all generators are traceless, except for color_ONE
+               if (is_a<su3one>(e.op(0)))
                        return _ex3;
                else
                        return _ex0;
@@ -536,8 +563,8 @@ ex color_trace(const ex & e, unsigned char rl)
                ex prod = _ex1;
                for (size_t i=0; i<e.nops(); i++) {
                        const ex &o = e.op(i);
-                       if (is_color_tinfo(o.return_type_tinfo(), rl))
-                               prod *= color_trace(o, rl);
+                       if (is_color_tinfo(o.return_type_tinfo()))
+                               prod *= color_trace(o, rls);
                        else
                                prod *= o;
                }
@@ -545,13 +572,16 @@ ex color_trace(const ex & e, unsigned char rl)
 
        } else if (is_exactly_a<ncmul>(e)) {
 
-               if (!is_color_tinfo(e.return_type_tinfo(), rl))
-                       return _ex0;
+               unsigned char rl = get_representation_label(e.return_type_tinfo());
+
+               // Are we taking the trace over this string's representation label?
+               if (rls.find(rl) == rls.end())
+                       return e;
 
-               // Expand product, if necessary
+               // Yes, expand product if necessary
                ex e_expanded = e.expand();
                if (!is_a<ncmul>(e_expanded))
-                       return color_trace(e_expanded, rl);
+                       return color_trace(e_expanded, rls);
 
                size_t num = e.nops();
 
@@ -590,11 +620,32 @@ ex color_trace(const ex & e, unsigned char rl)
        } else if (e.nops() > 0) {
 
                // Trace maps to all other container classes (this includes sums)
-               pointer_to_map_function_1arg<unsigned char> fcn(color_trace, rl);
+               pointer_to_map_function_1arg<const std::set<unsigned char> &> fcn(color_trace, rls);
                return e.map(fcn);
 
        } else
                return _ex0;
 }
 
+ex color_trace(const ex & e, const lst & rll)
+{
+       // Convert list to set
+       std::set<unsigned char> rls;
+       for (lst::const_iterator i = rll.begin(); i != rll.end(); ++i) {
+               if (i->info(info_flags::nonnegint))
+                       rls.insert(ex_to<numeric>(*i).to_int());
+       }
+
+       return color_trace(e, rls);
+}
+
+ex color_trace(const ex & e, unsigned char rl)
+{
+       // Convert label to set
+       std::set<unsigned char> rls;
+       rls.insert(rl);
+
+       return color_trace(e, rls);
+}
+
 } // namespace GiNaC