SpinorWaveFunction.h

// -*- C++ -*-
//
// SpinorWaveFunction.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_SpinorWaveFunction_H
#define ThePEG_SpinorWaveFunction_H
//
// This is the declaration of the SpinorWaveFunction class.
//
#include "WaveFunctionBase.h"
#include <ThePEG/Helicity/LorentzSpinor.h>
#include <ThePEG/Helicity/FermionSpinInfo.h>
#include <ThePEG/EventRecord/Particle.h>
#include <ThePEG/EventRecord/RhoDMatrix.h>
 
namespace ThePEG {
 
namespace Helicity {
 
class SpinorBarWaveFunction;
 
class SpinorWaveFunction : public WaveFunctionBase {
 
public:
 
  SpinorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,complex<double> s1,
                     complex<double> s2,complex<double> s3,complex<double> s4)
    : WaveFunctionBase(p,part), _wf(s1,s2,s3,s4)
  {
    assert(iSpin()==2);
  }
 
  SpinorWaveFunction(const Lorentz5Momentum & p, tcPDPtr part,
                     const LorentzSpinor<double> & wave,
                     Direction dir=intermediate) 
    : WaveFunctionBase(p,part,dir), _wf(wave)
  {
    assert(iSpin()==2);
  }
 
  SpinorWaveFunction(const tPPtr & p, const LorentzSpinor<SqrtEnergy> & wave,
                     Direction dir=intermediate) 
    : WaveFunctionBase(p->momentum(), p->dataPtr(), dir), _wf(wave.Type())
  {
    assert(iSpin()==2);
    for (unsigned int i=0; i<4; ++i)
      _wf[i]=Complex(wave[i]*UnitRemoval::InvSqrtE);
  }
 
  SpinorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     unsigned int ihel,
                     Direction dir) 
    : WaveFunctionBase(p,part,dir)
  {
    assert(iSpin()==2);
    calculateWaveFunction(ihel);
  }
 
  SpinorWaveFunction(const Lorentz5Momentum & p,
                     tcPDPtr part,Direction dir)
    : WaveFunctionBase(p,part,dir), _wf()
  {
    assert(iSpin()==2);
  }
  
  SpinorWaveFunction() 
    : WaveFunctionBase(), _wf()
  {}
 
  SpinorWaveFunction(vector<SpinorWaveFunction> & wave,
                     tPPtr part,Direction dir,bool time,bool=true) {
    calculateWaveFunctions(wave,part,dir);
    constructSpinInfo(wave,part,dir,time);
  }
 
  complex<double> operator ()(int i) const {
    assert(i>=0 &&i<=3);
    return _wf(i);
  }
 
  const LorentzSpinor<double> & wave() const {return _wf;}
 
  LorentzSpinor<SqrtEnergy> dimensionedWave() const {return dimensionedWf();}
 
  complex<double> s1() const {return _wf.s1();}
 
  complex<double> s2() const {return _wf.s2();}
 
  complex<double> s3() const {return _wf.s3();}
 
  complex<double> s4() const {return _wf.s4();}
 
  void conjugate() {
    _wf=_wf.conjugate();
  }
 
  SpinorBarWaveFunction bar();
 
  void reset(unsigned int ihel) {
    calculateWaveFunction(ihel);
  }
 
public:
 
  void transform(const LorentzRotation & r) {
    _wf.transform(r);
    transformMomentum(r);
  }
 
public:
 
  static void calculateWaveFunctions(vector<LorentzSpinor<SqrtEnergy> > & waves,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<SpinorWaveFunction> & waves,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<SpinorWaveFunction> & waves,
                                     const Lorentz5Momentum & momentum,
                                     tcPDPtr parton,Direction);
 
  static void calculateWaveFunctions(vector<LorentzSpinor<SqrtEnergy> > & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction);
 
  static void calculateWaveFunctions(vector<SpinorWaveFunction> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction);
 
  static void constructSpinInfo(const vector<LorentzSpinor<SqrtEnergy> > & waves,
                                tPPtr part,Direction dir, bool time);
 
  static void constructSpinInfo(const vector<SpinorWaveFunction> & waves,
                                tPPtr part,Direction dir, bool time);
  
 
private:
 
  void calculateWaveFunction(unsigned int ihel);
 
private:
 
  LorentzSpinor<double> _wf;
 
  LorentzSpinor<SqrtEnergy> dimensionedWf() const {
    LorentzSpinor<SqrtEnergy> temp(_wf.Type());
    for (unsigned int i=0; i<4; ++i)
      temp(i) = _wf(i)*UnitRemoval::SqrtE;
    return temp;
  }
  
};
 
}
 
}
#endif