X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ftensor.cpp;h=d16bbfce4b7949b85359f926767673c5f66c839f;hp=9d5feb63c4051dbe5c9d65ee3a0398fd5ada7c96;hb=43e0a8f5ca5e1c48cef5daaf014acdbca4e44568;hpb=539de73dc25de63f2888f8696d73ac3fc83db45f diff --git a/ginac/tensor.cpp b/ginac/tensor.cpp index 9d5feb63..d16bbfce 100644 --- a/ginac/tensor.cpp +++ b/ginac/tensor.cpp @@ -21,12 +21,15 @@ */ #include +#include #include "tensor.h" #include "idx.h" #include "indexed.h" #include "relational.h" +#include "lst.h" #include "numeric.h" +#include "print.h" #include "archive.h" #include "utils.h" #include "debugmsg.h" @@ -43,21 +46,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(tensepsilon, tensor) // default constructor, destructor, copy constructor assignment operator and helpers ////////// -#define DEFAULT_CTORS(classname) \ -classname::classname() : inherited(TINFO_##classname) \ -{ \ - debugmsg(#classname " default constructor", LOGLEVEL_CONSTRUCT); \ -} \ -void classname::copy(const classname & other) \ -{ \ - inherited::copy(other); \ -} \ -void classname::destroy(bool call_parent) \ -{ \ - if (call_parent) \ - inherited::destroy(call_parent); \ -} - tensor::tensor(unsigned ti) : inherited(ti) { debugmsg("tensor constructor from unsigned", LOGLEVEL_CONSTRUCT); \ @@ -66,7 +54,8 @@ tensor::tensor(unsigned ti) : inherited(ti) DEFAULT_CTORS(tensor) DEFAULT_CTORS(tensdelta) DEFAULT_CTORS(tensmetric) -DEFAULT_CTORS(tensepsilon) +DEFAULT_DESTROY(minkmetric) +DEFAULT_DESTROY(tensepsilon) minkmetric::minkmetric() : pos_sig(false) { @@ -86,34 +75,34 @@ void minkmetric::copy(const minkmetric & other) pos_sig = other.pos_sig; } -void minkmetric::destroy(bool call_parent) +tensepsilon::tensepsilon() : minkowski(false), pos_sig(false) +{ + debugmsg("tensepsilon default constructor", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_tensepsilon; +} + +tensepsilon::tensepsilon(bool mink, bool ps) : minkowski(mink), pos_sig(ps) { - if (call_parent) - inherited::destroy(call_parent); + debugmsg("tensepsilon constructor from bool,bool", LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_tensepsilon; +} + +void tensepsilon::copy(const tensepsilon & other) +{ + inherited::copy(other); + minkowski = other.minkowski; + pos_sig = other.pos_sig; } ////////// // archiving ////////// -#define DEFAULT_ARCHIVING(classname) \ -classname::classname(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) \ -{ \ - debugmsg(#classname " constructor from archive_node", LOGLEVEL_CONSTRUCT); \ -} \ -ex classname::unarchive(const archive_node &n, const lst &sym_lst) \ -{ \ - return (new classname(n, sym_lst))->setflag(status_flags::dynallocated); \ -} \ -void classname::archive(archive_node &n) const \ -{ \ - inherited::archive(n); \ -} - DEFAULT_ARCHIVING(tensor) DEFAULT_ARCHIVING(tensdelta) DEFAULT_ARCHIVING(tensmetric) -DEFAULT_ARCHIVING(tensepsilon) +DEFAULT_UNARCHIVE(minkmetric) +DEFAULT_UNARCHIVE(tensepsilon) minkmetric::minkmetric(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { @@ -121,14 +110,23 @@ minkmetric::minkmetric(const archive_node &n, const lst &sym_lst) : inherited(n, n.find_bool("pos_sig", pos_sig); } -ex minkmetric::unarchive(const archive_node &n, const lst &sym_lst) +void minkmetric::archive(archive_node &n) const { - return (new minkmetric(n, sym_lst))->setflag(status_flags::dynallocated); + inherited::archive(n); + n.add_bool("pos_sig", pos_sig); } -void minkmetric::archive(archive_node &n) const +tensepsilon::tensepsilon(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +{ + debugmsg("tensepsilon constructor from archive_node", LOGLEVEL_CONSTRUCT); + n.find_bool("minkowski", minkowski); + n.find_bool("pos_sig", pos_sig); +} + +void tensepsilon::archive(archive_node &n) const { inherited::archive(n); + n.add_bool("minkowski", minkowski); n.add_bool("pos_sig", pos_sig); } @@ -136,17 +134,9 @@ void minkmetric::archive(archive_node &n) const // functions overriding virtual functions from bases classes ////////// -#define DEFAULT_COMPARE(classname) \ -int classname::compare_same_type(const basic & other) const \ -{ \ - /* by default, two tensors of the same class are always identical */ \ - return 0; \ -} - DEFAULT_COMPARE(tensor) DEFAULT_COMPARE(tensdelta) DEFAULT_COMPARE(tensmetric) -DEFAULT_COMPARE(tensepsilon) int minkmetric::compare_same_type(const basic & other) const { @@ -159,29 +149,23 @@ int minkmetric::compare_same_type(const basic & other) const return inherited::compare_same_type(other); } -void tensdelta::print(std::ostream & os, unsigned upper_precedence) const +int tensepsilon::compare_same_type(const basic & other) const { - debugmsg("tensdelta print",LOGLEVEL_PRINT); - os << "delta"; -} + GINAC_ASSERT(is_of_type(other, tensepsilon)); + const tensepsilon &o = static_cast(other); -void tensmetric::print(std::ostream & os, unsigned upper_precedence) const -{ - debugmsg("tensmetric print",LOGLEVEL_PRINT); - os << "g"; -} - -void minkmetric::print(std::ostream & os, unsigned upper_precedence) const -{ - debugmsg("minkmetric print",LOGLEVEL_PRINT); - os << "eta"; + if (minkowski != o.minkowski) + return minkowski ? -1 : 1; + else if (pos_sig != o.pos_sig) + return pos_sig ? -1 : 1; + else + return inherited::compare_same_type(other); } -void tensepsilon::print(std::ostream & os, unsigned upper_precedence) const -{ - debugmsg("tensepsilon print",LOGLEVEL_PRINT); - os << "eps"; -} +DEFAULT_PRINT(tensdelta, "delta") +DEFAULT_PRINT(tensmetric, "g") +DEFAULT_PRINT(minkmetric, "eta") +DEFAULT_PRINT(tensepsilon, "eps") /** Automatic symbolic evaluation of an indexed delta tensor. */ ex tensdelta::eval_indexed(const basic & i) const @@ -197,6 +181,15 @@ ex tensdelta::eval_indexed(const basic & i) const if (is_dummy_pair(i1, i2)) return i1.get_dim(); + // Numeric evaluation + if (static_cast(i).all_index_values_are(info_flags::integer)) { + int n1 = ex_to_numeric(i1.get_value()).to_int(), n2 = ex_to_numeric(i2.get_value()).to_int(); + if (n1 == n2) + return _ex1(); + else + return _ex0(); + } + // No further simplifications return i.hold(); } @@ -249,6 +242,49 @@ ex minkmetric::eval_indexed(const basic & i) const return inherited::eval_indexed(i); } +/** Automatic symbolic evaluation of an indexed epsilon tensor. */ +ex tensepsilon::eval_indexed(const basic & i) const +{ + GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(i.nops() > 1); + GINAC_ASSERT(is_ex_of_type(i.op(0), tensepsilon)); + + // Convolutions are zero + if (static_cast(i).get_dummy_indices().size() != 0) + return _ex0(); + + // Numeric evaluation + if (static_cast(i).all_index_values_are(info_flags::nonnegint)) { + + // Get sign of index permutation (the indices should already be in + // a canonic order but we can't assume what exactly that order is) + std::vector v; + v.reserve(i.nops() - 1); + for (unsigned j=1; jop(0), tensdelta)) + if (is_ex_of_type(other->op(0), tensdelta)) return false; // Try to contract first index @@ -351,7 +387,7 @@ ex metric_tensor(const ex & i1, const ex & i2) if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx)) throw(std::invalid_argument("indices of metric tensor must be of type varidx")); - return indexed(tensmetric(), i1, i2); + return indexed(tensmetric(), indexed::symmetric, i1, i2); } ex lorentz_g(const ex & i1, const ex & i2, bool pos_sig) @@ -366,10 +402,54 @@ ex epsilon_tensor(const ex & i1, const ex & i2) { if (!is_ex_of_type(i1, idx) || !is_ex_of_type(i2, idx)) throw(std::invalid_argument("indices of epsilon tensor must be of type idx")); - if (!ex_to_idx(i1).get_dim().is_equal(_ex2()) || !ex_to_idx(i2).get_dim().is_equal(_ex2())) - throw(std::invalid_argument("index dimension of epsilon tensor must match number of indices")); + + ex dim = ex_to_idx(i1).get_dim(); + if (!dim.is_equal(ex_to_idx(i2).get_dim())) + throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); + if (!ex_to_idx(i1).get_dim().is_equal(_ex2())) + throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); return indexed(tensepsilon(), indexed::antisymmetric, i1, i2); } +ex epsilon_tensor(const ex & i1, const ex & i2, const ex & i3) +{ + if (!is_ex_of_type(i1, idx) || !is_ex_of_type(i2, idx) || !is_ex_of_type(i3, idx)) + throw(std::invalid_argument("indices of epsilon tensor must be of type idx")); + + ex dim = ex_to_idx(i1).get_dim(); + if (!dim.is_equal(ex_to_idx(i2).get_dim()) || !dim.is_equal(ex_to_idx(i3).get_dim())) + throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); + if (!ex_to_idx(i1).get_dim().is_equal(_ex3())) + throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); + + return indexed(tensepsilon(), indexed::antisymmetric, i1, i2, i3); +} + +ex lorentz_eps(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig) +{ + if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx) || !is_ex_of_type(i3, varidx) || !is_ex_of_type(i4, varidx)) + throw(std::invalid_argument("indices of Lorentz epsilon tensor must be of type varidx")); + + ex dim = ex_to_idx(i1).get_dim(); + if (!dim.is_equal(ex_to_idx(i2).get_dim()) || !dim.is_equal(ex_to_idx(i3).get_dim()) || !dim.is_equal(ex_to_idx(i4).get_dim())) + throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); + if (!ex_to_idx(i1).get_dim().is_equal(_ex4())) + throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); + + return indexed(tensepsilon(true, pos_sig), indexed::antisymmetric, i1, i2, i3, i4); +} + +ex eps0123(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig) +{ + if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx) || !is_ex_of_type(i3, varidx) || !is_ex_of_type(i4, varidx)) + throw(std::invalid_argument("indices of epsilon tensor must be of type varidx")); + + ex dim = ex_to_idx(i1).get_dim(); + if (dim.is_equal(4)) + return lorentz_eps(i1, i2, i3, i4, pos_sig); + else + return indexed(tensepsilon(true, pos_sig), indexed::antisymmetric, i1, i2, i3, i4); +} + } // namespace GiNaC