X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fclifford.cpp;h=eb1629d4957aad08f5a001ac2348dc89752a07bb;hp=16f9a4d4c9822e30137f6a074de614c94dabf8e2;hb=5a7178a44f067581d3acd8cff8c0801354d0c61f;hpb=24fe247f9ed16114a765a01c593fec5c4a2f591c;ds=sidebyside diff --git a/ginac/clifford.cpp b/ginac/clifford.cpp index 16f9a4d4..eb1629d4 100644 --- a/ginac/clifford.cpp +++ b/ginac/clifford.cpp @@ -1,10 +1,9 @@ /** @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 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,194 +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 "utils.h" +#include "print.h" +#include "archive.h" #include "debugmsg.h" +#include "utils.h" + +#include namespace GiNaC { +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); - serial=next_serial++; - name=autoname_prefix()+ToString(serial); - tinfo_key=TINFO_clifford; + debugmsg("clifford default constructor", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } -clifford::~clifford() +void clifford::copy(const clifford & other) { - debugmsg("clifford destructor",LOGLEVEL_DESTRUCT); - destroy(0); + inherited::copy(other); + representation_label = other.representation_label; } -clifford::clifford(clifford const & other) +DEFAULT_DESTROY(clifford) +DEFAULT_CTORS(diracone) +DEFAULT_CTORS(diracgamma) +DEFAULT_CTORS(diracgamma5) + +////////// +// other constructors +////////// + +/** 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 copy constructor",LOGLEVEL_CONSTRUCT); - copy (other); + debugmsg("clifford constructor from ex", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } -clifford const & clifford::operator=(clifford const & other) +/** 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 operator=",LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(1); - copy(other); - } - return *this; + debugmsg("clifford constructor from ex,ex", LOGLEVEL_CONSTRUCT); + GINAC_ASSERT(is_ex_of_type(mu, varidx)); + tinfo_key = TINFO_clifford; } -// protected - -void clifford::copy(clifford const & other) +clifford::clifford(unsigned char rl, const exvector & v, bool discardable) : inherited(indexed::unknown, v, discardable), representation_label(rl) { - indexed::copy(other); - name=other.name; - serial=other.serial; + debugmsg("clifford constructor from unsigned char,exvector", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } -void clifford::destroy(bool call_parent) +clifford::clifford(unsigned char rl, exvector * vp) : inherited(indexed::unknown, vp), representation_label(rl) { - if (call_parent) { - indexed::destroy(call_parent); - } + debugmsg("clifford constructor from unsigned char,exvector *", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_clifford; } ////////// -// other constructors +// archiving ////////// -// public +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; +} -clifford::clifford(string const & initname) +void clifford::archive(archive_node &n) const { - debugmsg("clifford constructor from string",LOGLEVEL_CONSTRUCT); - name=initname; - serial=next_serial++; - tinfo_key=TINFO_clifford; + 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 - -basic * clifford::duplicate() const +int clifford::compare_same_type(const basic & other) const { - debugmsg("clifford duplicate",LOGLEVEL_DUPLICATE); - return new clifford(*this); -} + GINAC_ASSERT(other.tinfo() == TINFO_clifford); + const clifford &o = static_cast(other); -void clifford::printraw(ostream & os) const -{ - debugmsg("clifford printraw",LOGLEVEL_PRINT); - os << "clifford(" << "name=" << name << ",serial=" << serial - << ",indices="; - printrawindices(os); - os << ",hash=" << hashvalue << ",flags=" << flags << ")"; -} + if (representation_label != o.representation_label) { + // different representation label + return representation_label < o.representation_label ? -1 : 1; + } -void clifford::printtree(ostream & os, unsigned indent) const -{ - debugmsg("clifford printtree",LOGLEVEL_PRINT); - os << string(indent,' ') << name << " (clifford): " - << "serial=" << serial << "," - << seq.size() << "indices="; - printtreeindices(os,indent); - os << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")" - << ", flags=" << flags << endl; + return inherited::compare_same_type(other); } -void clifford::print(ostream & os, unsigned upper_precedence) const -{ - debugmsg("clifford print",LOGLEVEL_PRINT); - os << name; - printindices(os); -} +DEFAULT_COMPARE(diracone) +DEFAULT_COMPARE(diracgamma) +DEFAULT_COMPARE(diracgamma5) -void clifford::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const -{ - debugmsg("clifford print csrc",LOGLEVEL_PRINT); - print(os,upper_precedence); -} +DEFAULT_PRINT(diracone, "ONE") +DEFAULT_PRINT(diracgamma, "gamma") +DEFAULT_PRINT(diracgamma5, "gamma5") -bool clifford::info(unsigned inf) const +/** Contraction of a gamma matrix with something else. */ +bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const { - return indexed::info(inf); + 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; } -// protected - -int clifford::compare_same_type(basic const & other) 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 { - GINAC_ASSERT(other.tinfo() == TINFO_clifford); - const clifford *o = static_cast(&other); - if (serial==o->serial) { - return indexed::compare_same_type(other); - } - return serial < o->serial ? -1 : 1; + 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; } -ex clifford::simplify_ncmul(exvector const & v) const +ex clifford::thisexprseq(const exvector & v) const { - return simplified_ncmul(v); + return clifford(representation_label, v); } -unsigned clifford::calchash(void) const +ex clifford::thisexprseq(exvector * vp) const { - hashvalue=golden_ratio_hash(golden_ratio_hash(0x55555556U ^ - golden_ratio_hash(tinfo_key) ^ - serial)); - setflag(status_flags::hash_calculated); - return hashvalue; + return clifford(representation_label, vp); } ////////// -// virtual functions which can be overridden by derived classes +// global functions ////////// -// none - -////////// -// non-virtual functions in this class -////////// - -void clifford::setname(string const & n) +ex dirac_ONE(unsigned char rl) { - name=n; + return clifford(diracone(), rl); } -// private - -string & clifford::autoname_prefix(void) +ex dirac_gamma(const ex & mu, unsigned char rl) { - static string * s=new string("clifford"); - return *s; -} + if (!is_ex_of_type(mu, varidx)) + throw(std::invalid_argument("index of Dirac gamma must be of type varidx")); -////////// -// static member variables -////////// - -// private - -unsigned clifford::next_serial=0; + return clifford(diracgamma(), mu, rl); +} -////////// -// global constants -////////// +ex dirac_gamma5(unsigned char rl) +{ + return clifford(diracgamma5(), rl); +} -const clifford some_clifford; -type_info const & typeid_clifford=typeid(some_clifford); +ex dirac_trace(const ex & e, unsigned char rl = 0) +{ + 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