SpinorBarWaveFunction.h

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