VectorWaveFunction.h

// -*- C++ -*-
//
// VectorWaveFunction.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_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/Helicity/RhoDMatrix.h>
#include <ThePEG/EventRecord/Particle.h>

namespace ThePEG {
namespace Helicity {

enum VectorPhase {
  vector_phase, 
  vector_nophase, 
  default_vector_phase=vector_nophase 
};

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<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

---