GiNaC/ginac/clifford.h

/** @file clifford.h
 *
 *  Interface to GiNaC's clifford algebra (Dirac gamma) objects. */

/*
 *  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
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __GINAC_CLIFFORD_H__
#define __GINAC_CLIFFORD_H__

#include "indexed.h"
#include "tensor.h"

namespace GiNaC {


/** This class holds an object representing an element of the Clifford
 *  algebra (the Dirac gamma matrices). These objects only carry Lorentz
 *  indices. Spinor indices are hidden. A representation label (an unsigned
 *  8-bit integer) is used to distinguish elements from different Clifford
 *  algebras (objects with different labels commute). */
class clifford : public indexed
{
        GINAC_DECLARE_REGISTERED_CLASS(clifford, indexed)

        // other constructors
public:
        clifford(const ex & b, unsigned char rl = 0);
        clifford(const ex & b, const ex & mu, unsigned char rl = 0);

        // internal constructors
        clifford(unsigned char rl, const exvector & v, bool discardable = false);
        clifford(unsigned char rl, exvector * vp); // vp will be deleted

        // functions overriding virtual functions from base classes
protected:
        ex simplify_ncmul(const exvector & v) const;
        ex thisexprseq(const exvector & v) const;
        ex thisexprseq(exvector * vp) const;
        unsigned return_type(void) const { return return_types::noncommutative; }
        unsigned return_type_tinfo(void) const { return TINFO_clifford + representation_label; }

        // non-virtual functions in this class
public:
        unsigned char get_representation_label(void) const {return representation_label;}

        // member variables
private:
        unsigned char representation_label; /**< Representation label to distinguish independent spin lines */
};


/** This class represents the Clifford algebra unity element. */
class diracone : public tensor
{
        GINAC_DECLARE_REGISTERED_CLASS(diracone, tensor)

        // functions overriding virtual functions from bases classes
public:
        void print(const print_context & c, unsigned level = 0) const;
};


/** This class represents the Dirac gamma Lorentz vector. */
class diracgamma : public tensor
{
        GINAC_DECLARE_REGISTERED_CLASS(diracgamma, tensor)

        // functions overriding virtual functions from bases classes
public:
        void print(const print_context & c, unsigned level = 0) const;
        bool contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const;
};


/** This class represents the Dirac gamma5 object which anticommutes with
 *  all other gammas. */
class diracgamma5 : public tensor
{
        GINAC_DECLARE_REGISTERED_CLASS(diracgamma5, tensor)

        // functions overriding virtual functions from bases classes
public:
        void print(const print_context & c, unsigned level = 0) const;
};


// global functions
inline const clifford &ex_to_clifford(const ex &e)
{
        return static_cast<const clifford &>(*e.bp);
}


/** Create a Clifford unity object.
 *
 *  @param rl Representation label
 *  @return newly constructed object */
ex dirac_ONE(unsigned char rl = 0);

/** Create a Dirac gamma object.
 *
 *  @param mu Index (must be of class varidx or a derived class)
 *  @param rl Representation label
 *  @return newly constructed gamma object */
ex dirac_gamma(const ex & mu, unsigned char rl = 0);

/** Create a Dirac gamma5 object.
 *
 *  @param rl Representation label
 *  @return newly constructed object */
ex dirac_gamma5(unsigned char rl = 0);

/** This returns (dirac_ONE(rl) + dirac_gamma5(rl)). */
ex dirac_gamma6(unsigned char rl = 0);

/** This returns (dirac_ONE(rl) - dirac_gamma5(rl)). */
ex dirac_gamma7(unsigned char rl = 0);

/** Create a term of the form e_mu * gamma~mu with a unique index mu.
 *
 *  @param dim Dimension of index
 *  @param rl Representation label */
ex dirac_slash(const ex & e, const ex & dim, unsigned char rl = 0);

/** Calculate the trace of an expression containing gamma objects with
 *  a specified representation label. The computed trace is a linear
 *  functional that is equal to the usual trace only in D = 4 dimensions.
 *  In particular, the functional is not always cyclic in D != 4 dimensions
 *  when gamma5 is involved.
 *
 *  @param rl Representation label */
ex dirac_trace(const ex & e, unsigned char rl = 0);


} // namespace GiNaC

#endif // ndef __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	ex simplify_ncmul(const exvector & v) const;
53	ex thisexprseq(const exvector & v) const;
54	ex thisexprseq(exvector * vp) const;
55	unsigned return_type(void) const { return return_types::noncommutative; }
56	unsigned return_type_tinfo(void) const { return TINFO_clifford + representation_label; }
57
58	// non-virtual functions in this class
59	public:
60	unsigned char get_representation_label(void) const {return representation_label;}
61
62	// member variables
63	private:
64	unsigned char representation_label; /*< Representation label to distinguish independent spin lines /
65	};
66
67
68	/** This class represents the Clifford algebra unity element. */
69	class diracone : public tensor
70	{
71	GINAC_DECLARE_REGISTERED_CLASS(diracone, tensor)
72
73	// functions overriding virtual functions from bases classes
74	public:
75	void print(const print_context & c, unsigned level = 0) const;
76	};
77
78
79	/** This class represents the Dirac gamma Lorentz vector. */
80	class diracgamma : public tensor
81	{
82	GINAC_DECLARE_REGISTERED_CLASS(diracgamma, tensor)
83
84	// functions overriding virtual functions from bases classes
85	public:
86	void print(const print_context & c, unsigned level = 0) const;
87	bool contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const;
88	};
89
90
91	/** This class represents the Dirac gamma5 object which anticommutes with
92	* all other gammas. */
93	class diracgamma5 : public tensor
94	{
95	GINAC_DECLARE_REGISTERED_CLASS(diracgamma5, tensor)
96
97	// functions overriding virtual functions from bases classes
98	public:
99	void print(const print_context & c, unsigned level = 0) const;
100	};
101
102
103	// global functions
104	inline const clifford &ex_to_clifford(const ex &e)
105	{
106	return static_cast<const clifford &>(*e.bp);
107	}
108
109
110	/** Create a Clifford unity object.
111	*
112	* @param rl Representation label
113	* @return newly constructed object */
114	ex dirac_ONE(unsigned char rl = 0);
115
116	/** Create a Dirac gamma object.
117	*
118	* @param mu Index (must be of class varidx or a derived class)
119	* @param rl Representation label
120	* @return newly constructed gamma object */
121	ex dirac_gamma(const ex & mu, unsigned char rl = 0);
122
123	/** Create a Dirac gamma5 object.
124	*
125	* @param rl Representation label
126	* @return newly constructed object */
127	ex dirac_gamma5(unsigned char rl = 0);
128
129	/** This returns (dirac_ONE(rl) + dirac_gamma5(rl)). */
130	ex dirac_gamma6(unsigned char rl = 0);
131
132	/** This returns (dirac_ONE(rl) - dirac_gamma5(rl)). */
133	ex dirac_gamma7(unsigned char rl = 0);
134
135	/** Create a term of the form e_mu * gamma~mu with a unique index mu.
136	*
137	* @param dim Dimension of index
138	* @param rl Representation label */
139	ex dirac_slash(const ex & e, const ex & dim, unsigned char rl = 0);
140
141	/** Calculate the trace of an expression containing gamma objects with
142	* a specified representation label. The computed trace is a linear
143	* functional that is equal to the usual trace only in D = 4 dimensions.
144	* In particular, the functional is not always cyclic in D != 4 dimensions
145	* when gamma5 is involved.
146	*
147	* @param rl Representation label */
148	ex dirac_trace(const ex & e, unsigned char rl = 0);
149
150
151	} // namespace GiNaC
152
153	#endif // ndef __GINAC_CLIFFORD_H__
Christian Bauer">Christian Bauer	ViewVC Help
Powered by ViewVC 1.1.15