LorentzSpinorBar.h

// -*- C++ -*-
//
// LorentzSpinorBar.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 2003-2019 Peter Richardson, Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_LorentzSpinorBar_H
#define ThePEG_LorentzSpinorBar_H
// This is the declaration of the LorentzSpinorBar class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Vectors/LorentzRotation.h"
#include "ThePEG/Vectors/ThreeVector.h"
#include "HelicityDefinitions.h"
#include "LorentzSpinor.fh"
#include "LorentzSpinorBar.fh"
 
namespace ThePEG {
namespace Helicity {
 
template<typename Value>
class LorentzSpinorBar {
public:
 
  LorentzSpinorBar(SpinorType t = SpinorType::unknown) : _type(t), _spin() {}
 
  LorentzSpinorBar(complex<Value> a, complex<Value> b,
                   complex<Value> c, complex<Value> d,
                   SpinorType t = SpinorType::unknown)
    : _type(t), _spin{{a,b,c,d}} {}
 
  template <typename U>
  LorentzSpinorBar(const LorentzSpinorBar<U> & other)
    : _type(other._type), _spin(other._spin) {}
 
 
  complex<Value> operator[](int i) const {
    assert( i>= 0 && i <= 3 );
    return _spin[i];
  }
 
  complex<Value> operator()(int i) const {
    assert( i>= 0 && i <= 3 );
    return _spin[i];
  }
 
  complex<Value> & operator()(int i) {
    assert( i>= 0 && i <= 3 );
    return _spin[i];
  }
 
  complex<Value> & operator[](int i) {
    assert( i>= 0 && i <= 3 );
    return _spin[i];
  }
 
  complex<Value> s1() const {return _spin[0];}
 
  complex<Value> s2() const {return _spin[1];}
 
  complex<Value> s3() const {return _spin[2];}
 
  complex<Value> s4() const {return _spin[3];}
 
  void setS1(complex<Value> in) {_spin[0]=in;}
 
  void setS2(complex<Value> in) {_spin[1]=in;}
 
  void setS3(complex<Value> in) {_spin[2]=in;}
 
  void setS4(complex<Value> in) {_spin[3]=in;}
 
 
  template <typename ValueB>
  LorentzSpinorBar<Value> & operator+=(const LorentzSpinorBar<ValueB> & a) {
    for(unsigned int ix=0;ix<4;++ix) _spin[ix] += a._spin[ix];
    return *this;
  }
  
  template <typename ValueB>
  LorentzSpinorBar<Value> & operator-=(const LorentzSpinorBar<ValueB> & a) {
    for(unsigned int ix=0;ix<4;++ix) _spin[ix] -= a._spin[ix];
    return *this;
  }
  
  LorentzSpinorBar<Value> & operator*=(double a) {
    for(unsigned int ix=0;ix<4;++ix) _spin[ix] *=a;
    return *this;
  }
 
  LorentzSpinorBar<Value> & operator/=(double a) {
    for(unsigned int ix=0;ix<4;++ix) _spin[ix] /=a;
    return *this;
  }
 
  LorentzSpinor<Value> bar() const;
 
  LorentzSpinorBar conjugate() const;
 
  LorentzSpinorBar & boost(double,double,double);
 
  LorentzSpinorBar & boost(const Boost &);
 
  LorentzSpinorBar & transform(const SpinHalfLorentzRotation &) ;
  
  LorentzSpinorBar & transform(const LorentzRotation & r) {
    transform(r.half());
    return *this;
  }
 
  SpinorType Type() const {return _type;}
 
  template<typename ValueB> 
  auto projectionOperator(const LorentzVector<ValueB> & p, 
                          const ValueB & m) const 
  -> LorentzSpinorBar<decltype(m*Value())>
  {
    typedef decltype(m*Value()) ResultT;
    LorentzSpinorBar<ResultT> spin;
    static const Complex ii(0.,1.);
    complex<ValueB> p0pp3=p.t()+p.z();
    complex<ValueB> p0mp3=p.t()-p.z();
    complex<ValueB> p1pp2=p.x()+ii*p.y();
    complex<ValueB> p1mp2=p.x()-ii*p.y();
    spin.setS1(m*s1()+p0pp3*s3()+p1pp2*s4());
    spin.setS2(m*s2()+p0mp3*s4()+p1mp2*s3());
    spin.setS3(m*s3()+p0mp3*s1()-p1pp2*s2());
    spin.setS4(m*s4()+p0pp3*s2()-p1mp2*s1());
    return spin;
  }
 
  LorentzSpinorBar
  helicityProjectionOperator(const Complex & gL, const Complex & gR) const {
    LorentzSpinorBar spin;
    spin.setS1(gL*s1());
    spin.setS2(gL*s2());
    spin.setS3(gR*s3());
    spin.setS4(gR*s4());
    return spin;
  }
 
  template<typename ValueB>
  auto slash(const LorentzVector<ValueB> & p) const
  -> LorentzSpinorBar<decltype(p.t()*Value())>
  {
    LorentzSpinorBar<decltype(p.t()*Value())> spin;
    static const Complex ii(0.,1.);
    complex<ValueB> p0pp3=p.t()+p.z();
    complex<ValueB> p0mp3=p.t()-p.z();
    complex<ValueB> p1pp2=p.x()+ii*p.y();
    complex<ValueB> p1mp2=p.x()-ii*p.y();
    spin.setS1(p0pp3*s3()+p1pp2*s4());
    spin.setS2(p0mp3*s4()+p1mp2*s3());
    spin.setS3(p0mp3*s1()-p1pp2*s2());
    spin.setS4(p0pp3*s2()-p1mp2*s1());
    return spin;
  }
 
  template<typename ValueB>
  auto slash(const LorentzVector<complex<ValueB> > & p) const
  -> LorentzSpinor<decltype(ValueB()*Value())>
  {
    LorentzSpinor<decltype(ValueB()*Value())> spin;
    static const Complex ii(0.,1.);
    complex<ValueB> p0pp3=p.t()+p.z();
    complex<ValueB> p0mp3=p.t()-p.z();
    complex<ValueB> p1pp2=p.x()+ii*p.y();
    complex<ValueB> p1mp2=p.x()-ii*p.y();
    spin.setS1(p0pp3*s3()+p1pp2*s4());
    spin.setS2(p0mp3*s4()+p1mp2*s3());
    spin.setS3(p0mp3*s1()-p1pp2*s2());
    spin.setS4(p0pp3*s2()-p1mp2*s1());
    return spin;
  }
 
private:
  SpinorType _type;
 
  std::array<complex<Value>,4> _spin;
};
 
 
template <typename Value>
inline LorentzSpinorBar<double>
operator/(const LorentzSpinorBar<Value> & v, Value a) {
  return LorentzSpinorBar<double>(v.s1()/a, v.s2()/a, v.s3()/a, v.s4()/a,v.Type());
}
 
inline LorentzSpinorBar<double>
operator/(const LorentzSpinorBar<double> & v, Complex a) {
  return LorentzSpinorBar<double>(v.s1()/a, v.s2()/a, v.s3()/a, v.s4()/a,v.Type());
}
 
template <typename Value>
inline LorentzSpinorBar<Value> operator-(const LorentzSpinorBar<Value> & v) {
  return LorentzSpinorBar<Value>(-v.s1(),-v.s2(),-v.s3(),-v.s4(),v.Type());
}
 
template <typename ValueA, typename ValueB>
inline LorentzSpinorBar<ValueA>
operator+(LorentzSpinorBar<ValueA> a, const LorentzSpinorBar<ValueB> & b) {
  return a += b;
}
 
template <typename ValueA, typename ValueB>
inline LorentzSpinorBar<ValueA>
operator-(LorentzSpinorBar<ValueA> a, const LorentzSpinorBar<ValueB> & b) {
  return a -= b;
}
 
template <typename Value>
inline LorentzSpinorBar<Value>
operator*(const LorentzSpinorBar<Value> & a, double b) {
  return LorentzSpinorBar<Value>(a.s1()*b, a.s2()*b, a.s3()*b, a.s4()*b,a.Type());
}
 
template <typename Value>
inline LorentzSpinorBar<Value>
operator*(double b, LorentzSpinorBar<Value> a) {
  return a *= b;
}
  
template <typename Value>
inline LorentzSpinorBar<Value>
operator*(const LorentzSpinorBar<Value> & a, Complex b) {
  return LorentzSpinorBar<Value>(a.s1()*b, a.s2()*b, a.s3()*b, a.s4()*b,a.Type());
}
 
template <typename ValueA, typename ValueB>
inline auto operator*(complex<ValueB> a, const LorentzSpinorBar<ValueA> & v) 
  -> LorentzSpinorBar<decltype(a.real()*v.s1().real())>
{
  return {a*v.s1(), a*v.s2(), a*v.s3(), a*v.s4(),v.Type()};
}
 
template <typename ValueA, typename ValueB>
inline auto operator*(const LorentzSpinorBar<ValueA> & v, complex<ValueB> b) 
  -> LorentzSpinorBar<decltype(b.real()*v.s1().real())>
{
  return b*v;
}
 
template <typename ValueA, typename ValueB>
inline auto operator/(const LorentzSpinorBar<ValueA> & v, complex<ValueB> b) 
  -> LorentzSpinorBar<decltype(v.s1().real()/b.real())>
{
  return {v.s1()/b, v.s2()/b, v.s3()/b, v.s4()/b,v.Type()};
}
  
template <typename ValueA, typename ValueB>
inline auto operator*(ValueB a, const LorentzSpinorBar<ValueA> & v) 
  -> LorentzSpinorBar<decltype(a*v.s1().real())>
{
  return {a*v.s1(), a*v.s2(), a*v.s3(), a*v.s4(),v.Type()};
}
 
template <typename ValueA, typename ValueB>
inline auto operator*(const LorentzSpinorBar<ValueA> & v, ValueB b) 
  -> LorentzSpinorBar<decltype(b*v.s1().real())>
{
  return b*v;
}
 
template <typename ValueA, typename ValueB>
inline auto operator/(const LorentzSpinorBar<ValueA> & v, ValueB b) 
  -> LorentzSpinorBar<decltype(v.s1().real()/b)>
{
  return {v.s1()/b, v.s2()/b, v.s3()/b, v.s4()/b,v.Type()};
}
 
}
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "LorentzSpinorBar.tcc"
#endif 
 
#endif