RSSpinorWaveFunction.h

// -*- C++ -*-
//
// RSSpinorWaveFunction.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_RSSpinorWaveFunction_H
#define ThePEG_RSSpinorWaveFunction_H
// This is the declaration of the RSSpinorWaveFunction class.
 
#include "WaveFunctionBase.h"
#include <ThePEG/Helicity/LorentzRSSpinor.h>
#include <ThePEG/Helicity/RSFermionSpinInfo.h>
#include <ThePEG/EventRecord/Particle.h>
#include <ThePEG/EventRecord/RhoDMatrix.h>
 
namespace ThePEG {
 
namespace Helicity {
 
class RSSpinorWaveFunction: public WaveFunctionBase {
 
public:
 
  RSSpinorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                       complex<double> xs1, complex<double> xs2,
                       complex<double> xs3, complex<double> xs4,
                       complex<double> ys1, complex<double> ys2,
                       complex<double> ys3, complex<double> ys4,
                       complex<double> zs1, complex<double> zs2,
                       complex<double> zs3, complex<double> zs4,
                       complex<double> ts1, complex<double> ts2,
                       complex<double> ts3, complex<double> ts4)
    : WaveFunctionBase(p,part), _wf(xs1,xs2,xs3,xs4,
                                    ys1,ys2,ys3,ys4,
                                    zs1,zs2,zs3,zs4,
                                    ts1,ts2,ts3,ts4)
  {
    assert(iSpin()==4);
  }
 
  RSSpinorWaveFunction(const Lorentz5Momentum & p, tcPDPtr part,
                       const LorentzRSSpinor<double> & wave,
                       Direction dir=intermediate) 
    : WaveFunctionBase(p,part,dir), _wf(wave)
  {
    assert(iSpin()==4);
  }
  
  RSSpinorWaveFunction(const tPPtr & p,
                       const LorentzRSSpinor<SqrtEnergy> & wave,
                       Direction dir=intermediate) 
    : WaveFunctionBase(p->momentum(),p->dataPtr(),dir), _wf(wave.Type())
  {
    assert(iSpin()==4);
    for (unsigned int i=0; i<4; ++i)
      for(unsigned int j=0; j<4; ++j)
        _wf(i,j)=Complex(wave(i,j)*UnitRemoval::InvSqrtE);
  }
 
  RSSpinorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                       unsigned int ihel, Direction dir) 
    : WaveFunctionBase(p,part,dir)
  {
    assert(iSpin()==4);
    calculateWaveFunction(ihel);
  }
 
  RSSpinorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,Direction dir)
    : WaveFunctionBase(p,part,dir), _wf()
  {
    assert(iSpin()==4);
  }
 
  RSSpinorWaveFunction() 
    : WaveFunctionBase(), _wf()
  {}
 
  RSSpinorWaveFunction(vector<RSSpinorWaveFunction> & wave,
                       tPPtr part,Direction dir,bool time,bool=true) {
    calculateWaveFunctions(wave,part,dir);
    constructSpinInfo(wave,part,dir,time);
  }
 
  complex<double> operator ()(int i, int j) const {
    assert(  i>=0 && i<=3 && j>=0 && j<=3);
    return _wf(i,j);
  }
 
  const LorentzRSSpinor<double> & wave() const {return _wf;}
 
  LorentzRSSpinor<SqrtEnergy> dimensionedWf() const {
    LorentzRSSpinor<SqrtEnergy> temp(_wf.Type());
    for (unsigned int i=0; i<4; ++i)
      for (unsigned int j=0; j<4; ++j)
        temp(i,j) = _wf(i,j)*UnitRemoval::SqrtE;
    return temp;
  }
 
  complex<double> xs1() const {return _wf.xs1();}
 
  complex<double> xs2() const {return _wf.xs2();}
 
  complex<double> xs3() const {return _wf.xs3();}
 
  complex<double> xs4() const {return _wf.xs4();}
 
  complex<double> ys1() const {return _wf.ys1();}
 
  complex<double> ys2() const {return _wf.ys2();}
  
  complex<double> ys3() const {return _wf.ys3();}
  
  complex<double> ys4() const {return _wf.ys4();}
  
  complex<double> zs1() const {return _wf.zs1();}
  
  complex<double> zs2() const {return _wf.zs2();}
  
  complex<double> zs3() const {return _wf.zs3();}
  
  complex<double> zs4() const {return _wf.zs4();}
  
  complex<double> ts1() const {return _wf.ts1();}
  
  complex<double> ts2() const {return _wf.ts2();}
  
  complex<double> ts3() const {return _wf.ts3();}
  
  complex<double> ts4() const {return _wf.ts4();}
 
  void reset(unsigned int ihel) {
    calculateWaveFunction(ihel);
  }
 
public:
 
  void transform(const LorentzRotation & r) {
    _wf.transform(r);
    transformMomentum(r);
  }
 
public:
 
  static void calculateWaveFunctions(vector<LorentzRSSpinor<SqrtEnergy> > & waves,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<RSSpinorWaveFunction> & waves,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<RSSpinorWaveFunction> & waves,
                                     const Lorentz5Momentum & momentum,
                                     tcPDPtr parton,Direction);
 
  static void calculateWaveFunctions(vector<LorentzRSSpinor<SqrtEnergy> > & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<RSSpinorWaveFunction> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction);
 
  static void constructSpinInfo(const vector<LorentzRSSpinor<SqrtEnergy> > & waves,
                                tPPtr part,Direction dir, bool time);
 
  static void constructSpinInfo(const vector<RSSpinorWaveFunction> & waves,
                                tPPtr part,Direction dir, bool time);
 
private:
 
  void calculateWaveFunction(unsigned int ihel);
 
private:
 
  LorentzRSSpinor<double> _wf;
};
 
}
}
 
#endif /* ThePEG_RSSpinorWaveFunction_H */