LorentzRSSpinorBar.h

// -*- C++ -*-
//
// LorentzRSSpinorBar.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 2003-2007 Peter Richardson, Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_LorentzRSSpinorBar_H
#define ThePEG_LorentzRSSpinorBar_H
// This is the declaration of the LorentzRSSpinorBar class.

#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Vectors/ThreeVector.h"
#include "HelicityDefinitions.h"
#include "LorentzRSSpinor.fh"
#include "LorentzRSSpinorBar.fh"
#include "LorentzSpinorBar.h"
#include "LorentzSpinor.h"
#include "LorentzPolarizationVector.h"

namespace ThePEG {
namespace Helicity {

template <typename Value>
class LorentzRSSpinorBar {

public:

  LorentzRSSpinorBar(SpinorType t = unknown_spinortype) : _type(t) {
    for(unsigned int ix=0;ix<4;++ix)
      for(unsigned int iy=0;iy<4;++iy) 
        _spin[ix][iy]=Value();
  }

  LorentzRSSpinorBar(complex<Value> a1,complex<Value> b1,
                     complex<Value> c1,complex<Value> d1,
                     complex<Value> a2,complex<Value> b2,
                     complex<Value> c2,complex<Value> d2,
                     complex<Value> a3,complex<Value> b3,
                     complex<Value> c3,complex<Value> d3,
                     complex<Value> a4,complex<Value> b4,
                     complex<Value> c4,complex<Value> d4,
                     SpinorType t=unknown_spinortype)
    : _type(t) {
    _spin[0][0]=a1;_spin[1][0]=a2;_spin[2][0]=a3;_spin[3][0]=a4;
    _spin[0][1]=b1;_spin[1][1]=b2;_spin[2][1]=b3;_spin[3][1]=b4;
    _spin[0][2]=c1;_spin[1][2]=c2;_spin[2][2]=c3;_spin[3][2]=c4;
    _spin[0][3]=d1;_spin[1][3]=d2;_spin[2][3]=d3;_spin[3][3]=d4;
  }

  complex<Value> operator()(int i, int j) const {
    assert( i >= 0 && i <= 3 && j>=0 && j<=3 );
    return _spin[i][j];
  }

  complex<Value> & operator () (int i, int j) {
    assert( i >= 0 && i <= 3 && j>=0 && j<=3 );
    return _spin[i][j];
  }
  
  complex<Value> xs1() const {return _spin[0][0];}

  complex<Value> xs2() const {return _spin[0][1];}

  complex<Value> xs3() const {return _spin[0][2];}

  complex<Value> xs4() const {return _spin[0][3];}

  complex<Value> ys1() const {return _spin[1][0];}

  complex<Value> ys2() const {return _spin[1][1];}
  
  complex<Value> ys3() const {return _spin[1][2];}
  
  complex<Value> ys4() const {return _spin[1][3];}
  
  complex<Value> zs1() const {return _spin[2][0];}
  
  complex<Value> zs2() const {return _spin[2][1];}
  
  complex<Value> zs3() const {return _spin[2][2];}
  
  complex<Value> zs4() const {return _spin[2][3];}
  
  complex<Value> ts1() const {return _spin[3][0];}
  
  complex<Value> ts2() const {return _spin[3][1];}
  
  complex<Value> ts3() const {return _spin[3][2];}
  
  complex<Value> ts4() const {return _spin[3][3];}
  
  void setXS1(complex<Value> in) {_spin[0][0]=in;}
  
  void setXS2(complex<Value> in) {_spin[0][1]=in;}
  
  void setXS3(complex<Value> in) {_spin[0][2]=in;}
  
  void setXS4(complex<Value> in) {_spin[0][3]=in;}
  
  void setYS1(complex<Value> in) {_spin[1][0]=in;}
  
  void setYS2(complex<Value> in) {_spin[1][1]=in;}
  
  void setYS3(complex<Value> in) {_spin[1][2]=in;}
  
  void setYS4(complex<Value> in) {_spin[1][3]=in;}
  
  void setZS1(complex<Value> in) {_spin[2][0]=in;}
  
  void setZS2(complex<Value> in) {_spin[2][1]=in;}
  
  void setZS3(complex<Value> in) {_spin[2][2]=in;}
  
  void setZS4(complex<Value> in) {_spin[2][3]=in;}
  
  void setTS1(complex<Value> in) {_spin[3][0]=in;}
  
  void setTS2(complex<Value> in) {_spin[3][1]=in;}
  
  void setTS3(complex<Value> in) {_spin[3][2]=in;}
  
  void setTS4(complex<Value> in ) {_spin[3][3]=in;}

  LorentzSpinorBar<Value> dot(const LorentzPolarizationVector & vec) const {
    LorentzSpinorBar<Value> output(_type);
    for(unsigned int ix=0;ix<4;++ix) {
      output[ix]=_spin[3][ix]*vec.t()-_spin[0][ix]*vec.x()
        -_spin[1][ix]*vec.y()-_spin[2][ix]*vec.z();
    }
    return output;
  }

  LorentzSpinorBar<Value> dot(const LorentzMomentum & invec) const {
    LorentzSpinorBar<Value> output(_type);
    LorentzVector<double> vec = UnitRemoval::InvE * invec;
    unsigned int ix;
    for(ix=0;ix<4;++ix) {
      output[ix]=_spin[3][ix]*vec.t()-_spin[0][ix]*vec.x()
        -_spin[1][ix]*vec.y()-_spin[2][ix]*vec.z();
    }
    return output;
  }
  
  LorentzRSSpinor<Value> bar() const;

  LorentzRSSpinorBar & boost(double,double,double);

  LorentzRSSpinorBar & boost(const Boost &);

  LorentzRSSpinorBar & transform(const LorentzRotation &);

  SpinorType Type() const {return _type;}

  template <typename ValueB>
  LorentzVector<complex<
    typename BinaryOpTraits<Value,ValueB>::MulT> >
    generalCurrent(LorentzSpinor<ValueB>& f, Complex left, Complex right) {
      typedef complex<typename BinaryOpTraits<Value,ValueB>::MulT> ResultT;
      ResultT output[4];
      unsigned int iz;
      for(iz=0;iz<4;++iz){
        output[iz]=  left*(_spin[iz][0]*f.s1()+_spin[iz][1]*f.s2())
          +right*(_spin[iz][2]*f.s3()+_spin[iz][3]*f.s4());
      }
      return LorentzVector<ResultT>(output[0],output[1],
                                    output[2],output[3]);
    }
  
private:
  SpinorType _type;

  complex<Value> _spin[4][4];
};
}
}
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "LorentzRSSpinorBar.tcc"
#endif 

#endif

---