X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fclifford.cpp;h=eb1629d4957aad08f5a001ac2348dc89752a07bb;hp=a3f26c964cb010ddc60b67d2be302aefc7d5a2e0;hb=5a7178a44f067581d3acd8cff8c0801354d0c61f;hpb=4e3a4ac2bcb0837611ea31bc8fc05d84a20c33ac diff --git a/ginac/clifford.cpp b/ginac/clifford.cpp index a3f26c96..eb1629d4 100644 --- a/ginac/clifford.cpp +++ b/ginac/clifford.cpp @@ -1,7 +1,6 @@ /** @file clifford.cpp * - * Implementation of GiNaC's clifford objects. - * No real implementation yet, to be done. */ + * Implementation of GiNaC's clifford algebra (Dirac gamma) objects. */ /* * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany @@ -21,171 +20,355 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include - #include "clifford.h" #include "ex.h" +#include "idx.h" #include "ncmul.h" +#include "print.h" #include "archive.h" -#include "utils.h" #include "debugmsg.h" +#include "utils.h" + +#include namespace GiNaC { -GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, lortensor) +GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, indexed) +GINAC_IMPLEMENT_REGISTERED_CLASS(diracone, tensor) +GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma, tensor) +GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma5, tensor) ////////// // default constructor, destructor, copy constructor assignment operator and helpers ////////// -// public - -clifford::clifford() +clifford::clifford() : representation_label(0) { - debugmsg("clifford default constructor",LOGLEVEL_CONSTRUCT); + debugmsg("clifford default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_clifford; } -// protected - void clifford::copy(const clifford & other) { inherited::copy(other); + representation_label = other.representation_label; } -void clifford::destroy(bool call_parent) -{ - if (call_parent) inherited::destroy(call_parent); -} +DEFAULT_DESTROY(clifford) +DEFAULT_CTORS(diracone) +DEFAULT_CTORS(diracgamma) +DEFAULT_CTORS(diracgamma5) ////////// // other constructors ////////// -// public +/** Construct object without any indices. This constructor is for internal + * use only. Use the dirac_ONE() function instead. + * @see dirac_ONE */ +clifford::clifford(const ex & b, unsigned char rl) : inherited(b), representation_label(rl) +{ + debugmsg("clifford constructor from ex", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; +} -clifford::clifford(const std::string & n, const ex & mu) : inherited(lortensor_symbolic, n, mu) +/** Construct object with one Lorentz index. This constructor is for internal + * use only. Use the dirac_gamma() function instead. + * @see dirac_gamma */ +clifford::clifford(const ex & b, const ex & mu, unsigned char rl) : inherited(b, mu), representation_label(rl) { - debugmsg("clifford constructor from string,ex",LOGLEVEL_CONSTRUCT); - tinfo_key=TINFO_clifford; + debugmsg("clifford constructor from ex,ex", LOGLEVEL_CONSTRUCT); + GINAC_ASSERT(is_ex_of_type(mu, varidx)); + tinfo_key = TINFO_clifford; } -clifford::clifford(const std::string & n, const exvector & iv) : inherited(lortensor_symbolic, n, iv) +clifford::clifford(unsigned char rl, const exvector & v, bool discardable) : inherited(indexed::unknown, v, discardable), representation_label(rl) { - debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT); - GINAC_ASSERT(all_of_type_lorentzidx()); - tinfo_key=TINFO_clifford; + debugmsg("clifford constructor from unsigned char,exvector", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } -clifford::clifford(const std::string & n, exvector *ivp) : inherited(lortensor_symbolic, n, *ivp) +clifford::clifford(unsigned char rl, exvector * vp) : inherited(indexed::unknown, vp), representation_label(rl) { - debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT); - GINAC_ASSERT(all_of_type_lorentzidx()); - tinfo_key=TINFO_clifford; + debugmsg("clifford constructor from unsigned char,exvector *", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } ////////// // archiving ////////// -/** Construct object from archive_node. */ clifford::clifford(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { debugmsg("clifford constructor from archive_node", LOGLEVEL_CONSTRUCT); + unsigned rl; + n.find_unsigned("label", rl); + representation_label = rl; } -/** Unarchive the object. */ -ex clifford::unarchive(const archive_node &n, const lst &sym_lst) -{ - return (new clifford(n, sym_lst))->setflag(status_flags::dynallocated); -} - -/** Archive the object. */ void clifford::archive(archive_node &n) const { inherited::archive(n); + n.add_unsigned("label", representation_label); } +DEFAULT_UNARCHIVE(clifford) +DEFAULT_ARCHIVING(diracone) +DEFAULT_ARCHIVING(diracgamma) +DEFAULT_ARCHIVING(diracgamma5) + ////////// // functions overriding virtual functions from bases classes ////////// -// public - -void clifford::printraw(std::ostream & os) const +int clifford::compare_same_type(const basic & other) const { - debugmsg("clifford printraw",LOGLEVEL_PRINT); - os << "clifford(" << "indices="; - printrawindices(os); - os << ",hash=" << hashvalue << ",flags=" << flags << ")"; -} + GINAC_ASSERT(other.tinfo() == TINFO_clifford); + const clifford &o = static_cast(other); -void clifford::printtree(std::ostream & os, unsigned indent) const -{ - debugmsg("clifford printtree",LOGLEVEL_PRINT); - os << std::string(indent,' ') << " (clifford): " - << seq.size() << "indices="; - printtreeindices(os, indent); - os << ", hash=" << hashvalue - << " (0x" << std::hex << hashvalue << std::dec << ")" - << ", flags=" << flags << std::endl; + if (representation_label != o.representation_label) { + // different representation label + return representation_label < o.representation_label ? -1 : 1; + } + + return inherited::compare_same_type(other); } -void clifford::print(std::ostream & os, unsigned upper_precedence) const +DEFAULT_COMPARE(diracone) +DEFAULT_COMPARE(diracgamma) +DEFAULT_COMPARE(diracgamma5) + +DEFAULT_PRINT(diracone, "ONE") +DEFAULT_PRINT(diracgamma, "gamma") +DEFAULT_PRINT(diracgamma5, "gamma5") + +/** Contraction of a gamma matrix with something else. */ +bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const { - debugmsg("clifford print",LOGLEVEL_PRINT); - os << name; - printindices(os); + GINAC_ASSERT(is_ex_of_type(*self, clifford)); + GINAC_ASSERT(is_ex_of_type(*other, indexed)); + GINAC_ASSERT(is_ex_of_type(self->op(0), diracgamma)); + unsigned char rl = ex_to_clifford(*self).get_representation_label(); + + if (is_ex_of_type(other->op(0), diracgamma)) { + + ex dim = ex_to_idx(self->op(1)).get_dim(); + + // gamma~mu*gamma.mu = dim*ONE + if (other - self == 1) { + *self = dim; + *other = dirac_ONE(rl); + return true; + + // gamma~mu*gamma~alpha*gamma.mu = (2-dim)*gamma~alpha + } else if (other - self == 2 + && is_ex_of_type(self[1], clifford)) { + *self = 2 - dim; + *other = _ex1(); + return true; + + // gamma~mu*gamma~alpha*gamma~beta*gamma.mu = 4*g~alpha~beta+(dim-4)*gamam~alpha*gamma~beta + } else if (other - self == 3 + && is_ex_of_type(self[1], clifford) + && is_ex_of_type(self[2], clifford)) { + *self = 4 * metric_tensor(self[1].op(1), self[2].op(1)) * dirac_ONE(rl) + (dim - 4) * self[1] * self[2]; + self[1] = _ex1(); + self[2] = _ex1(); + *other = _ex1(); + return true; + + // gamma~mu*gamma~alpha*gamma~beta*gamma~delta*gamma.mu = -2*gamma~delta*gamma~beta*gamma~alpha+(4-dim)*gamma~alpha*gamma~beta*gamma~delta + } else if (other - self == 4 + && is_ex_of_type(self[1], clifford) + && is_ex_of_type(self[2], clifford) + && is_ex_of_type(self[3], clifford)) { + *self = -2 * self[3] * self[2] * self[1] + (4 - dim) * self[1] * self[2] * self[3]; + self[1] = _ex1(); + self[2] = _ex1(); + self[3] = _ex1(); + *other = _ex1(); + return true; + } + } + + return false; } -bool clifford::info(unsigned inf) const +/** Perform automatic simplification on noncommutative product of clifford + * objects. This removes superfluous ONEs, permutes gamma5's to the front + * and removes squares of gamma objects. */ +ex clifford::simplify_ncmul(const exvector & v) const { - return inherited::info(inf); + exvector s; + s.reserve(v.size()); + unsigned rl = ex_to_clifford(v[0]).get_representation_label(); + + // Remove superfluous ONEs + exvector::const_iterator cit = v.begin(), citend = v.end(); + while (cit != citend) { + if (!is_ex_of_type(cit->op(0), diracone)) + s.push_back(*cit); + cit++; + } + + bool something_changed = false; + int sign = 1; + + // Anticommute gamma5's to the front + if (s.size() >= 2) { + exvector::iterator first = s.begin(), next_to_last = s.end() - 2; + while (true) { + exvector::iterator it = next_to_last; + while (true) { + exvector::iterator it2 = it + 1; + if (!is_ex_of_type(it->op(0), diracgamma5) && is_ex_of_type(it2->op(0), diracgamma5)) { + it->swap(*it2); + sign = -sign; + something_changed = true; + } + if (it == first) + break; + it--; + } + if (next_to_last == first) + break; + next_to_last--; + } + } + + // Remove squares of gamma5 + while (s.size() >= 2 && is_ex_of_type(s[0].op(0), diracgamma5) && is_ex_of_type(s[1].op(0), diracgamma5)) { + s.erase(s.begin(), s.begin() + 2); + something_changed = true; + } + + // Remove equal adjacent gammas + if (s.size() >= 2) { + exvector::iterator it = s.begin(), itend = s.end() - 1; + while (it != itend) { + ex & a = it[0]; + ex & b = it[1]; + if (is_ex_of_type(a.op(0), diracgamma) && is_ex_of_type(b.op(0), diracgamma)) { + const ex & ia = a.op(1); + const ex & ib = b.op(1); + if (ia.is_equal(ib)) { + a = lorentz_g(ia, ib); + b = dirac_ONE(rl); + something_changed = true; + } + } + it++; + } + } + + if (s.size() == 0) + return clifford(diracone(), rl) * sign; + if (something_changed) + return nonsimplified_ncmul(s) * sign; + else + return simplified_ncmul(s) * sign; } -// protected - -int clifford::compare_same_type(const basic & other) const +ex clifford::thisexprseq(const exvector & v) const { - GINAC_ASSERT(is_of_type(other,clifford)); - // only compare indices - return exprseq::compare_same_type(other); + return clifford(representation_label, v); } -bool clifford::is_equal_same_type(const basic & other) const +ex clifford::thisexprseq(exvector * vp) const { - GINAC_ASSERT(is_of_type(other,clifford)); - // only compare indices - return exprseq::is_equal_same_type(other); + return clifford(representation_label, vp); } -ex clifford::thisexprseq(const exvector & v) const +////////// +// global functions +////////// + +ex dirac_ONE(unsigned char rl) { - return clifford(name, v); + return clifford(diracone(), rl); } -ex clifford::thisexprseq(exvector *vp) const +ex dirac_gamma(const ex & mu, unsigned char rl) { - return clifford(name, vp); + if (!is_ex_of_type(mu, varidx)) + throw(std::invalid_argument("index of Dirac gamma must be of type varidx")); + + return clifford(diracgamma(), mu, rl); } -ex clifford::simplify_ncmul(const exvector & v) const +ex dirac_gamma5(unsigned char rl) { - return simplified_ncmul(v); + return clifford(diracgamma5(), rl); } -////////// -// friend functions -////////// - -/** Construct an object representing a Dirac gamma matrix. The index must - * be of class lorentzidx. - * - * @param mu Index - * @return newly constructed object */ -clifford clifford_gamma(const ex & mu) +ex dirac_trace(const ex & e, unsigned char rl = 0) { - return clifford("gamma", mu); + if (is_ex_of_type(e, clifford)) { + + if (ex_to_clifford(e).get_representation_label() == rl + && is_ex_of_type(e.op(0), diracone)) + return _ex4(); + else + return _ex0(); + + } else if (is_ex_exactly_of_type(e, add)) { + + // Trace of sum = sum of traces + ex sum = _ex0(); + for (unsigned i=0; i