/** @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
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#include <string>
-
#include "clifford.h"
#include "ex.h"
+#include "idx.h"
#include "ncmul.h"
#include "archive.h"
-#include "utils.h"
#include "debugmsg.h"
+#include "utils.h"
+
+#include <stdexcept>
-#ifndef NO_NAMESPACE_GINAC
namespace GiNaC {
-#endif // ndef NO_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)
//////////
// default constructor, destructor, copy constructor assignment operator and helpers
//////////
-// public
-
clifford::clifford()
{
- 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);
-}
-
-void clifford::destroy(bool call_parent)
-{
- if (call_parent) inherited::destroy(call_parent);
-}
+DEFAULT_COPY(clifford)
+DEFAULT_DESTROY(clifford)
+DEFAULT_CTORS(diracone)
+DEFAULT_CTORS(diracgamma)
//////////
// other constructors
//////////
-// public
+/** 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) : inherited(b, mu)
+{
+ 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 ex & mu) : inherited(lortensor_symbolic, n, mu)
+/** 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) : inherited(b)
{
- debugmsg("clifford constructor from string,ex",LOGLEVEL_CONSTRUCT);
- tinfo_key=TINFO_clifford;
+ debugmsg("clifford constructor from ex", LOGLEVEL_CONSTRUCT);
+ tinfo_key = TINFO_clifford;
}
-clifford::clifford(const std::string & n, const exvector & iv) : inherited(lortensor_symbolic, n, iv)
+clifford::clifford(const exvector & v, bool discardable) : inherited(indexed::unknown, v, discardable)
{
- debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
- GINAC_ASSERT(all_of_type_lorentzidx());
- tinfo_key=TINFO_clifford;
+ debugmsg("clifford constructor from exvector", LOGLEVEL_CONSTRUCT);
+ tinfo_key = TINFO_clifford;
}
-clifford::clifford(const std::string & n, exvector *ivp) : inherited(lortensor_symbolic, n, *ivp)
+clifford::clifford(exvector * vp) : inherited(indexed::unknown, vp)
{
- debugmsg("clifford constructor from string,exvector", LOGLEVEL_CONSTRUCT);
- GINAC_ASSERT(all_of_type_lorentzidx());
- tinfo_key=TINFO_clifford;
+ debugmsg("clifford constructor from 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);
-}
-
-/** 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);
-}
+DEFAULT_ARCHIVING(clifford)
+DEFAULT_ARCHIVING(diracone)
+DEFAULT_ARCHIVING(diracgamma)
//////////
// 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);
-}
-
-void clifford::printraw(std::ostream & os) const
+ return inherited::compare_same_type(other);
+}
+
+DEFAULT_COMPARE(diracone)
+DEFAULT_COMPARE(diracgamma)
+DEFAULT_PRINT(diracone, "ONE")
+DEFAULT_PRINT(diracgamma, "gamma")
+
+/** Contraction of a gamma matrix with something else. */
+bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
+{
+ GINAC_ASSERT(is_ex_of_type(*self, indexed));
+ GINAC_ASSERT(is_ex_of_type(*other, indexed));
+ GINAC_ASSERT(is_ex_of_type(self->op(0), diracgamma));
+
+ 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();
+ 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() + (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;
+}
+
+/** Perform automatic simplification on noncommutative product of clifford
+ * objects. This removes superfluous ONEs. */
+ex clifford::simplify_ncmul(const exvector & v) const
{
- debugmsg("clifford printraw",LOGLEVEL_PRINT);
- os << "clifford(" << "indices=";
- printrawindices(os);
- os << ",hash=" << hashvalue << ",flags=" << flags << ")";
-}
+ exvector s;
+ s.reserve(v.size());
-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;
-}
+ exvector::const_iterator it = v.begin(), itend = v.end();
+ while (it != itend) {
+ if (!is_ex_of_type(it->op(0), diracone))
+ s.push_back(*it);
+ it++;
+ }
-void clifford::print(std::ostream & os, unsigned upper_precedence) const
-{
- debugmsg("clifford print",LOGLEVEL_PRINT);
- os << name;
- printindices(os);
-}
-
-bool clifford::info(unsigned inf) const
-{
- return inherited::info(inf);
+ if (s.size() == 0)
+ return clifford(diracone());
+ else if (s.size() == v.size())
+ return simplified_ncmul(v);
+ else
+ return simplified_ncmul(s);
}
-// 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(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(vp);
}
-ex clifford::thisexprseq(const exvector & v) const
-{
- return clifford(name, v);
-}
+//////////
+// global functions
+//////////
-ex clifford::thisexprseq(exvector *vp) const
+ex dirac_one(void)
{
- return clifford(name, vp);
+ return clifford(diracone());
}
-ex clifford::simplify_ncmul(const exvector & v) const
+ex dirac_gamma(const ex & mu)
{
- return simplified_ncmul(v);
-}
-
-//////////
-// friend functions
-//////////
+ if (!is_ex_of_type(mu, varidx))
+ throw(std::invalid_argument("index of Dirac gamma must be of type varidx"));
-/** 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)
-{
- return clifford("gamma", mu);
+ return clifford(diracgamma(), mu);
}
-#ifndef NO_NAMESPACE_GINAC
} // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
git://www.ginac.de / ginac.git / blobdiff