VectorWaveFunction.h

// -*- C++ -*-
//
// VectorWaveFunction.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_VectorWaveFunction_H
#define ThePEG_VectorWaveFunction_H
//
// This is the declaration of the VectorWaveFunction class.
//
#include "WaveFunctionBase.h"
#include <ThePEG/Helicity/LorentzPolarizationVector.h>
#include <ThePEG/Helicity/VectorSpinInfo.h>
#include <ThePEG/EventRecord/RhoDMatrix.h>
#include <ThePEG/EventRecord/Particle.h>
 
namespace ThePEG {
namespace Helicity {
 
class VectorWaveFunction : public WaveFunctionBase {
 
public:
 
  VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     const LorentzPolarizationVector & wave,
                     Direction  dir=intermediate) 
    : WaveFunctionBase(p,part,dir), _wf(wave)
  {
    assert(iSpin()==3);
  }
 
  VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,const Complex & x,
                     const Complex & y,const Complex & z, const Complex & t) 
    : WaveFunctionBase(p,part), _wf(x,y,z,t)
  {
    assert(iSpin()==3);
  }
  
  VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     unsigned int ihel,Direction dir,
                     VectorPhase phase=default_vector_phase) 
    : WaveFunctionBase(p,part,dir)
  {
    assert(iSpin()==3);
    calculateWaveFunction(ihel,phase);
  }
  
  VectorWaveFunction(const Lorentz5Momentum &p,
                     tcPDPtr part,Direction dir)  
    : WaveFunctionBase(p,part,dir), _wf()
  {
    assert(iSpin()==3);
  }
  
  VectorWaveFunction() {}
 
  VectorWaveFunction(vector<VectorWaveFunction> & wave,
                     tPPtr part,Direction dir,bool time,bool massless,
                     bool=true,
                     VectorPhase phase=default_vector_phase) {
    calculateWaveFunctions(wave,part,dir,massless,phase);
    constructSpinInfo(wave,part,dir,time,massless);
  }
 
  const LorentzPolarizationVector & wave() const { return _wf;}
  
  Complex x() const {return _wf.x();}
  
  Complex y() const {return _wf.y();}
  
  Complex z() const {return _wf.z();}
  
  Complex t() const {return _wf.t();}
 
  void reset(unsigned int ihel,VectorPhase phase=default_vector_phase) {
    calculateWaveFunction(ihel,phase);
  }
 
public:
 
  void transform(const LorentzRotation & r) {
    _wf.transform(r);
    transformMomentum(r);
  }
 
public:
 
  static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
                                     tPPtr particle,Direction,bool massless,
                                     VectorPhase phase=default_vector_phase);
 
  static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
                                     tPPtr particle,Direction,bool massless,
                                     VectorPhase phase=default_vector_phase);
 
  static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
                                     const Lorentz5Momentum & momentum,
                                     tcPDPtr parton, Direction,bool massless,
                                     VectorPhase phase=default_vector_phase);
 
  static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless,
                                     VectorPhase phase=default_vector_phase);
 
  static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless,
                                     VectorPhase phase=default_vector_phase);
 
  static void constructSpinInfo(const vector<LorentzPolarizationVector> & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
  static void constructSpinInfo(const vector<VectorWaveFunction> & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
private:
  
  void calculateWaveFunction(unsigned int ihel,
                             VectorPhase phase=default_vector_phase);
 
private:
  
  LorentzPolarizationVector _wf;
  
};
 
}
}
 
#endif