SpinorWaveFunction.h

// -*- C++ -*-
//
// SpinorWaveFunction.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_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/Helicity/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]=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<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

---