ThePEG/Helicity/epsilon.h

0001 // -*- C++ -*-
0002 //
0003 // epsilon.h is a part of ThePEG - Toolkit for HEP Event Generation
0004 // Copyright (C) 2003-2019 Peter Richardson, Leif Lonnblad
0005 //
0006 // ThePEG is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef ThePEG_epsilon_H
0010 #define ThePEG_epsilon_H
0011 //
0012 // This is the declaration of the epsilon class.
0013
0014 #include "ThePEG/Vectors/LorentzVector.h"
0015 #include "LorentzTensor.h"
0016
0017 namespace ThePEG {
0018 namespace Helicity {
0019
0020 /** \ingroup Helicity
0021  *  \author Peter Richardson
0022  *
0023  *  This class is designed to combine 5-momenta and polarization
0024  *  vectors together with the result being the product with the
0025  *  eps function. The class is purely static and contains no data.
0026  *
0027  *  @see LorentzPolarizationVector
0028  *  @see Lorentz5Vector
0029  */
0030
0031   /**
0032    *  Return the product
0033    *  \f$\epsilon^{\alpha\beta\gamma\delta}v_{1\alpha}v_{2\beta}v_{3\gamma}v_{4\delta}\f$.
0034    * @param a The first  vector \f$v_{1\alpha}\f$.
0035    * @param b The second vector \f$v_{2\beta}\f$.
0036    * @param c The third  vector \f$v_{3\gamma}\f$.
0037    * @param d The fourth vector \f$v_{4\delta}\f$.
0038    * @return The product
0039    * \f$\epsilon^{\alpha\beta\gamma\delta}v_{1\alpha}v_{2\beta}v_{3\gamma}v_{4\delta}\f$
0040    */
0041   template <typename A, typename B, typename C, typename D>
0042   auto epsilon(const LorentzVector<A> & a,
0043                const LorentzVector<B> & b,
0044                const LorentzVector<C> & c,
0045                const LorentzVector<D> & d)
0046     -> decltype(a.x()*b.y()*c.z()*d.t())
0047   {
0048     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0049     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0050     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0051     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0052     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0053     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0054
0055     auto diff2xy = c.x() * d.y()  -  c.y() * d.x();
0056     auto diff2xz = c.x() * d.z()  -  c.z() * d.x();
0057     auto diff2xt = c.x() * d.t()  -  c.t() * d.x();
0058     auto diff2yz = c.y() * d.z()  -  c.z() * d.y();
0059     auto diff2yt = c.y() * d.t()  -  c.t() * d.y();
0060     auto diff2zt = c.z() * d.t()  -  c.t() * d.z();
0061
0062     return
0063       diff2yz*diffxt + diff2zt*diffxy - diff2yt*diffxz -
0064       diff2xz*diffyt + diff2xt*diffyz + diff2xy*diffzt;
0065   }
0066
0067   /**
0068    *  Return the product
0069    *  \f$\epsilon^{\mu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}v_{3\gamma}\f$.
0070    * @param a The first  vector \f$v_{1\alpha}\f$.
0071    * @param b The second vector \f$v_{2\beta}\f$.
0072    * @param c The third  vector \f$v_{3\gamma}\f$.
0073    * @return The product
0074    * \f$\epsilon^{\mu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}v_{3\gamma}\f$.
0075    */
0076   template <typename A, typename B, typename C>
0077   auto epsilon(const LorentzVector<A> & a,
0078                const LorentzVector<B> & b,
0079                const LorentzVector<C> & c)
0080   -> LorentzVector<decltype(a.x()*b.y()*c.z())>
0081   {
0082     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0083     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0084     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0085     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0086     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0087     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0088
0089     using ResultType = LorentzVector<decltype(a.x()*b.x()*c.x())>;
0090     ResultType result;
0091     result.setX( c.z() * diffyt  - c.t() * diffyz  - c.y() * diffzt);
0092     result.setY( c.t() * diffxz  - c.z() * diffxt  + c.x() * diffzt);
0093     result.setZ(-c.t() * diffxy  + c.y() * diffxt  - c.x() * diffyt);
0094     result.setT(-c.z() * diffxy  + c.y() * diffxz  - c.x() * diffyz);
0095
0096     return result;
0097   }
0098
0099   /**
0100    *  Return the product
0101    *  \f$\epsilon^{\mu\nu\alpha\beta}v_{1\alpha}v_{2\beta}\f$.
0102    * @param a The first  vector \f$v_{1\alpha}\f$.
0103    * @param b The second vector \f$v_{2\beta}\f$.
0104    * @return The product
0105    * \f$\epsilon^{\mu\nu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}\f$.
0106    */
0107   template <typename A, typename B>
0108   auto epsilon(const LorentzVector<complex<A> > & a,
0109                const LorentzVector<complex<B> > & b)
0110     -> LorentzTensor<decltype(a.x().real()*b.y().real())>
0111   {
0112     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0113     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0114     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0115     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0116     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0117     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0118     complex<decltype(a.x().real()*b.x().real())> zero(ZERO);
0119
0120     using ResultType = LorentzTensor<decltype(a.x().real()*b.x().real())>;
0121     ResultType result;
0122     result.setTT(  zero ); result.setTX( diffyz); result.setTY(-diffxz); result.setTZ( diffxy);
0123     result.setXT(-diffyz); result.setXX(  zero ); result.setXY( diffzt); result.setXZ(-diffyt);
0124     result.setYT( diffxz); result.setYX(-diffzt); result.setYY(  zero ); result.setYZ( diffxt);
0125     result.setZT(-diffxy); result.setZX( diffyt); result.setZY(-diffxt); result.setZZ(  zero );
0126
0127     return result;
0128   }
0129
0130   /**
0131    *  Return the product
0132    *  \f$\epsilon^{\mu\nu\alpha\beta}v_{1\alpha}v_{2\beta}\f$.
0133    * @param a The first  vector \f$v_{1\alpha}\f$.
0134    * @param b The second vector \f$v_{2\beta}\f$.
0135    * @return The product
0136    * \f$\epsilon^{\mu\nu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}\f$.
0137    */
0138   template <typename A, typename B>
0139   auto epsilon(const LorentzVector<A>           & a,
0140                const LorentzVector<complex<B> > & b)
0141     -> LorentzTensor<decltype(a.x()*b.y().real())>
0142   {
0143     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0144     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0145     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0146     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0147     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0148     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0149     complex<decltype(a.x()*b.x().real())> zero(ZERO);
0150
0151     using ResultType = LorentzTensor<decltype(a.x()*b.x().real())>;
0152     ResultType result;
0153     result.setTT(  zero ); result.setTX( diffyz); result.setTY(-diffxz); result.setTZ( diffxy);
0154     result.setXT(-diffyz); result.setXX(  zero ); result.setXY( diffzt); result.setXZ(-diffyt);
0155     result.setYT( diffxz); result.setYX(-diffzt); result.setYY(  zero ); result.setYZ( diffxt);
0156     result.setZT(-diffxy); result.setZX( diffyt); result.setZY(-diffxt); result.setZZ(  zero );
0157
0158     return result;
0159   }
0160
0161   /**
0162    *  Return the product
0163    *  \f$\epsilon^{\mu\nu\alpha\beta}v_{1\alpha}v_{2\beta}\f$.
0164    * @param a The first  vector \f$v_{1\alpha}\f$.
0165    * @param b The second vector \f$v_{2\beta}\f$.
0166    * @return The product
0167    * \f$\epsilon^{\mu\nu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}\f$.
0168    */
0169   template <typename A, typename B>
0170   auto epsilon(const LorentzVector<complex<A> > & a,
0171                const LorentzVector<B>           & b)
0172     -> LorentzTensor<decltype(a.x().real()*b.y())>
0173   {
0174     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0175     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0176     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0177     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0178     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0179     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0180     complex<decltype(a.x().real()*b.x())> zero(ZERO);
0181
0182     using ResultType = LorentzTensor<decltype(a.x().real()*b.x())>;
0183     ResultType result;
0184     result.setTT(  zero ); result.setTX( diffyz); result.setTY(-diffxz); result.setTZ( diffxy);
0185     result.setXT(-diffyz); result.setXX(  zero ); result.setXY( diffzt); result.setXZ(-diffyt);
0186     result.setYT( diffxz); result.setYX(-diffzt); result.setYY(  zero ); result.setYZ( diffxt);
0187     result.setZT(-diffxy); result.setZX( diffyt); result.setZY(-diffxt); result.setZZ(  zero );
0188
0189     return result;
0190   }
0191
0192   /**
0193    *  Return the product
0194    *  \f$\epsilon^{\mu\nu\alpha\beta}v_{1\alpha}v_{2\beta}\f$.
0195    * @param a The first  vector \f$v_{1\alpha}\f$.
0196    * @param b The second vector \f$v_{2\beta}\f$.
0197    * @return The product
0198    * \f$\epsilon^{\mu\nu\alpha\beta\gamma}v_{1\alpha}v_{2\beta}\f$.
0199    */
0200   template <typename A, typename B>
0201   auto epsilon(const LorentzVector<A> & a,
0202                const LorentzVector<B> & b)
0203     -> LorentzTensor<decltype(a.x()*b.y())>
0204   {
0205     auto diffxy = a.x() * b.y()  -  a.y() * b.x();
0206     auto diffxz = a.x() * b.z()  -  a.z() * b.x();
0207     auto diffxt = a.x() * b.t()  -  a.t() * b.x();
0208     auto diffyz = a.y() * b.z()  -  a.z() * b.y();
0209     auto diffyt = a.y() * b.t()  -  a.t() * b.y();
0210     auto diffzt = a.z() * b.t()  -  a.t() * b.z();
0211     complex<decltype(a.x()*b.x())> zero(ZERO);
0212
0213     using ResultType = LorentzTensor<decltype(a.x()*b.x())>;
0214     ResultType result;
0215     result.setTT(  zero ); result.setTX( diffyz); result.setTY(-diffxz); result.setTZ( diffxy);
0216     result.setXT(-diffyz); result.setXX(  zero ); result.setXY( diffzt); result.setXZ(-diffyt);
0217     result.setYT( diffxz); result.setYX(-diffzt); result.setYY(  zero ); result.setYZ( diffxt);
0218     result.setZT(-diffxy); result.setZX( diffyt); result.setZY(-diffxt); result.setZZ(  zero );
0219
0220     return result;
0221   }
0222
0223
0224 }
0225 }
0226
0227 #endif /* ThePEG_epsilon_H */