- added find() (like has(), but returns list of all occurrences)
[ginac.git] / ginac / clifford.h
1 /** @file clifford.h
2  *
3  *  Interface to GiNaC's clifford algebra (Dirac gamma) objects. */
4
5 /*
6  *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #ifndef __GINAC_CLIFFORD_H__
24 #define __GINAC_CLIFFORD_H__
25
26 #include "indexed.h"
27 #include "tensor.h"
28
29 namespace GiNaC {
30
31
32 /** This class holds an object representing an element of the Clifford
33  *  algebra (the Dirac gamma matrices). These objects only carry Lorentz
34  *  indices. Spinor indices are hidden. A representation label (an unsigned
35  *  8-bit integer) is used to distinguish elements from different Clifford
36  *  algebras (objects with different labels commute). */
37 class clifford : public indexed
38 {
39         GINAC_DECLARE_REGISTERED_CLASS(clifford, indexed)
40
41         // other constructors
42 public:
43         clifford(const ex & b, unsigned char rl = 0);
44         clifford(const ex & b, const ex & mu, unsigned char rl = 0);
45
46         // internal constructors
47         clifford(unsigned char rl, const exvector & v, bool discardable = false);
48         clifford(unsigned char rl, exvector * vp); // vp will be deleted
49
50         // functions overriding virtual functions from base classes
51 protected:
52         bool match_same_type(const basic & other) const;
53         ex simplify_ncmul(const exvector & v) const;
54         ex thisexprseq(const exvector & v) const;
55         ex thisexprseq(exvector * vp) const;
56         unsigned return_type(void) const { return return_types::noncommutative; }
57         unsigned return_type_tinfo(void) const { return TINFO_clifford + representation_label; }
58
59         // non-virtual functions in this class
60 public:
61         unsigned char get_representation_label(void) const {return representation_label;}
62
63         // member variables
64 private:
65         unsigned char representation_label; /**< Representation label to distinguish independent spin lines */
66 };
67
68
69 /** This class represents the Clifford algebra unity element. */
70 class diracone : public tensor
71 {
72         GINAC_DECLARE_REGISTERED_CLASS(diracone, tensor)
73
74         // functions overriding virtual functions from bases classes
75 public:
76         void print(const print_context & c, unsigned level = 0) const;
77 };
78
79
80 /** This class represents the Dirac gamma Lorentz vector. */
81 class diracgamma : public tensor
82 {
83         GINAC_DECLARE_REGISTERED_CLASS(diracgamma, tensor)
84
85         // functions overriding virtual functions from bases classes
86 public:
87         void print(const print_context & c, unsigned level = 0) const;
88         bool contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const;
89 };
90
91
92 /** This class represents the Dirac gamma5 object which anticommutes with
93  *  all other gammas. */
94 class diracgamma5 : public tensor
95 {
96         GINAC_DECLARE_REGISTERED_CLASS(diracgamma5, tensor)
97
98         // functions overriding virtual functions from bases classes
99 public:
100         void print(const print_context & c, unsigned level = 0) const;
101 };
102
103
104 // global functions
105
106 /** Return the clifford object handled by an ex.  Deprecated: use ex_to<clifford>().
107  *  This is unsafe: you need to check the type first. */
108 inline const clifford &ex_to_clifford(const ex &e)
109 {
110         return static_cast<const clifford &>(*e.bp);
111 }
112
113 /** Specialization of is_exactly_a<clifford>(obj) for clifford objects. */
114 template<> inline bool is_exactly_a<clifford>(const basic & obj)
115 {
116         return obj.tinfo()==TINFO_clifford;
117 }
118
119 /** Create a Clifford unity object.
120  *
121  *  @param rl Representation label
122  *  @return newly constructed object */
123 ex dirac_ONE(unsigned char rl = 0);
124
125 /** Create a Dirac gamma object.
126  *
127  *  @param mu Index (must be of class varidx or a derived class)
128  *  @param rl Representation label
129  *  @return newly constructed gamma object */
130 ex dirac_gamma(const ex & mu, unsigned char rl = 0);
131
132 /** Create a Dirac gamma5 object.
133  *
134  *  @param rl Representation label
135  *  @return newly constructed object */
136 ex dirac_gamma5(unsigned char rl = 0);
137
138 /** This returns (dirac_ONE(rl) + dirac_gamma5(rl)). */
139 ex dirac_gamma6(unsigned char rl = 0);
140
141 /** This returns (dirac_ONE(rl) - dirac_gamma5(rl)). */
142 ex dirac_gamma7(unsigned char rl = 0);
143
144 /** Create a term of the form e_mu * gamma~mu with a unique index mu.
145  *
146  *  @param dim Dimension of index
147  *  @param rl Representation label */
148 ex dirac_slash(const ex & e, const ex & dim, unsigned char rl = 0);
149
150 /** Calculate the trace of an expression containing gamma objects with
151  *  a specified representation label. The computed trace is a linear
152  *  functional that is equal to the usual trace only in D = 4 dimensions.
153  *  In particular, the functional is not always cyclic in D != 4 dimensions
154  *  when gamma5 is involved.
155  *
156  *  @param e Expression to take the trace of
157  *  @param rl Representation label
158  *  @param trONE Expression to be returned as the trace of the unit matrix */
159 ex dirac_trace(const ex & e, unsigned char rl = 0, const ex & trONE = 4);
160
161 /** Bring all products of clifford objects in an expression into a canonical
162  *  order. This is not necessarily the most simple form but it will allow
163  *  to check two expressions for equality. */
164 ex canonicalize_clifford(const ex & e);
165
166 } // namespace GiNaC
167
168 #endif // ndef __GINAC_CLIFFORD_H__