include/ninja/spinors.hh

0001 // A simple class for Spinor-related operations.  It allows the
0002 // construction of spinors from massless momenta, and it can also be
0003 // used for the construction of polarization vectors.
0004
0005
0006 #ifndef NINJA_SPINORS_HH
0007 #define NINJA_SPINORS_HH
0008
0009 #include <ninja/types.hh>
0010 #include <ninja/momentum.hh>
0011
0012 namespace ninja {
0013
0014   class Spinor;
0015
0016   // Angle product <i,j>
0017   Complex spaa(const Spinor & i, const Spinor & j);
0018
0019   // Bracket product [i,j]
0020   Complex spbb(const Spinor & i, const Spinor & j);
0021
0022   // Complex momentum from two spinors.
0023   // Returns 0.5 * <i \gamma^\mu j ]
0024   ComplexMomentum momentumFromSpinors(const Spinor & i, const Spinor & j);
0025
0026   // Right handed polarization vector from two spinors.
0027   // Returns <r | \gamma^\mu | k ]/sqrt2/<r,k>
0028   ComplexMomentum polarizationVectorR(const Spinor & r, const Spinor & k);
0029
0030   // Right handed polarization vector from two momenta.
0031   // Returns <r | \gamma^\mu | k ]/sqrt2/<r,k>
0032   ComplexMomentum polarizationVectorR(const RealMomentum & r,
0033                                       const RealMomentum & k);
0034
0035   // Left handed polarization vector from two spinors.
0036   // Returns <k | \gamma^/mu | r ]/sqrt2/[k,r]
0037   ComplexMomentum polarizationVectorL(const Spinor & r, const Spinor & k);
0038
0039   // Left handed polarization vector from two momenta.
0040   // Returns <k | \gamma^/mu | r ]/sqrt2/[k,r]
0041   ComplexMomentum polarizationVectorL(const RealMomentum & r,
0042                                       const RealMomentum & k);
0043
0044
0045
0046   class Spinor {
0047   public:
0048
0049     // Default constructor
0050     Spinor(): ap(0.), ame(0.), bp(0.), bme(0.) {}
0051
0052     // Copy constructor
0053     Spinor(const Spinor & s): ap(s.ap), ame(s.ame), bp(s.bp), bme(s.bme) {}
0054
0055     // Independent construction of angle and square brackets
0056     Spinor(const Spinor & a, const Spinor & b)
0057       : ap(a.ap), ame(a.ame), bp(b.bp), bme(b.bme) {}
0058
0059     // Constructors from Momentum types
0060     explicit Spinor(const RealMomentum & p);
0061     explicit Spinor(const ComplexMomentum & p);
0062
0063     friend Complex spaa(const Spinor & i, const Spinor & j);
0064     friend Complex spbb(const Spinor & i, const Spinor & j);
0065     friend ComplexMomentum momentumFromSpinors(const Spinor & i,
0066                                                const Spinor & j);
0067     friend ComplexMomentum polarizationVectorR(const Spinor & r,
0068                                                const Spinor & k);
0069     friend ComplexMomentum polarizationVectorR(const RealMomentum & r,
0070                                                const RealMomentum & k);
0071     friend ComplexMomentum polarizationVectorL(const Spinor & r,
0072                                                const Spinor & k);
0073     friend ComplexMomentum polarizationVectorL(const RealMomentum & r,
0074                                                const RealMomentum & k);
0075     friend std::ostream & operator << (std::ostream & os,
0076                                        const Spinor & s);
0077
0078   private:
0079     Complex ap, ame, bp, bme;
0080
0081   };
0082
0083
0084   // Angle product <i,j>
0085   inline Complex spaa(const Spinor & i, const Spinor & j)
0086   {
0087     return i.ame*j.ap-i.ap*j.ame;
0088   }
0089
0090   // Bracket product [i,j]
0091   inline Complex spbb(const Spinor & i, const Spinor & j)
0092   {
0093     return -i.bme*j.bp+i.bp*j.bme;
0094   }
0095
0096   // Complex momentum from two spinors.
0097   // Returns 0.5 * <i \gamma^\mu j ]
0098   inline ComplexMomentum
0099   momentumFromSpinors(const Spinor & i, const Spinor & j)
0100   {
0101     return ComplexMomentum(HALF * (i.ame*j.bme + i.ap*j.bp),
0102                            HALF * (i.ap*j.bme + i.ame*j.bp),
0103                            HALF * I * (i.ap*j.bme - i.ame*j.bp),
0104                            HALF * (-i.ame*j.bme + i.ap*j.bp));
0105   }
0106
0107
0108   inline ComplexMomentum
0109   polarizationVectorR(const Spinor & r, const Spinor & k)
0110   {
0111     Complex spaark = spaa(r,k);
0112     return ComplexMomentum
0113       ( INVSQRT2 *    (  r.ame*k.bme + r.ap*k.bp   )/spaark,
0114         INVSQRT2 * (  r.ap*k.bme + r.ame*k.bp  )/spaark,
0115         INVSQRT2 * I * (  r.ap*k.bme - r.ame*k.bp  )/spaark,
0116         INVSQRT2 * (  -r.ame*k.bme + r.ap*k.bp   )/spaark  );
0117   }
0118
0119   inline ComplexMomentum
0120   polarizationVectorL(const Spinor & r, const Spinor & k)
0121   {
0122     Complex spbbkr = spbb(k,r);
0123     return ComplexMomentum
0124       ( INVSQRT2 * (  k.ame*r.bme + k.ap*r.bp   )/spbbkr,
0125         INVSQRT2 * (  k.ap*r.bme + k.ame*r.bp  )/spbbkr,
0126         INVSQRT2 * I * (  k.ap*r.bme - k.ame*r.bp  )/spbbkr,
0127         INVSQRT2 * (  -k.ame*r.bme + k.ap*r.bp   )/spbbkr  );
0128   }
0129
0130   inline ComplexMomentum polarizationVectorR(const RealMomentum & r,
0131                                              const RealMomentum & k)
0132   {
0133     return polarizationVectorR(Spinor(r), Spinor(k));
0134   }
0135
0136   inline ComplexMomentum polarizationVectorL(const RealMomentum & r,
0137                                              const RealMomentum & k)
0138   {
0139     return polarizationVectorL(Spinor(r), Spinor(k));
0140   }
0141
0142   // printing (mostly for debugging)
0143   inline std::ostream & operator << (std::ostream & os, const Spinor & s)
0144   {
0145     os << "spinor("
0146        << s.ap << "," << s.ame << "," << s.bp << "," << s.bme << ")";
0147     return os;
0148   }
0149
0150 } // namespace ninja
0151
0152 #endif // NINJA_SPINORS_HH