TensorWaveFunction.h

// -*- C++ -*-
//
// TensorWaveFunction.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_TensorWaveFunction_H
#define ThePEG_TensorWaveFunction_H
//
// This is the declaration of the TensorWaveFunction class.
//
#include "WaveFunctionBase.h"
#include "VectorWaveFunction.h"
#include <ThePEG/Helicity/LorentzTensor.h>
#include <ThePEG/Helicity/TensorSpinInfo.h>
#include <ThePEG/EventRecord/Particle.h>
#include <ThePEG/EventRecord/RhoDMatrix.h>
 
namespace ThePEG {
namespace Helicity {
 
enum TensorPhase {
  tensor_phase, 
  tensor_nophase, 
  default_tensor_phase=tensor_nophase 
};
 
class TensorWaveFunction : public WaveFunctionBase {
 
public:
 
  TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     const LorentzTensor<double> & wave,
                     Direction  dir=intermediate) 
    : WaveFunctionBase(p,part,dir), _wf(wave)
  {
    assert(iSpin()==PDT::Spin2);
  }
 
  TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     Complex xx,Complex xy,Complex xz,Complex xt,Complex yx,
                     Complex yy,Complex yz,Complex yt,Complex zx,Complex zy,
                     Complex zz,Complex zt,Complex tx,Complex ty,Complex tz,
                     Complex tt) 
    : WaveFunctionBase(p,part), _wf(xx,xy,xz,xt,
                                    yx,yy,yz,yt,
                                    zx,zy,zz,zt,
                                    tx,ty,tz,tt)
  {
    assert(iSpin()==PDT::Spin2);
  }
 
  TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                     unsigned int ihel,Direction dir,
                     TensorPhase phase=default_tensor_phase) 
    : WaveFunctionBase(p,part,dir)
  {
    assert(iSpin()==PDT::Spin2);
    calculateWaveFunction(ihel,phase);
  }
 
  TensorWaveFunction(const Lorentz5Momentum & p,
                     tcPDPtr part,Direction dir) 
    : WaveFunctionBase(p,part,dir), _wf()
  {
    assert(iSpin()==PDT::Spin2);
  }
 
  TensorWaveFunction() {}
 
  TensorWaveFunction(vector<TensorWaveFunction> & wave,
                     tPPtr part,Direction dir,bool time,bool massless,
                     bool=true,
                     TensorPhase phase=default_tensor_phase) {
    calculateWaveFunctions(wave,part,dir,massless,phase);
    constructSpinInfo(wave,part,dir,time,massless);
  }
 
  Complex operator ()(int i, int j) const {
    return _wf(i,j);
  }
 
  Complex & operator () (int i, int j) {
    return _wf(i,j);
  }
 
  const LorentzTensor<double> & wave() const {return _wf;}
 
  Complex xx() const {return _wf.xx();}
 
  Complex yx() const {return _wf.yx();}
 
  Complex zx() const {return _wf.zx();}
 
  Complex tx() const {return _wf.tx();}
 
  Complex xy() const {return _wf.xy();}
 
  Complex yy() const {return _wf.yy();}
 
  Complex zy() const {return _wf.zy();}
 
  Complex ty() const {return _wf.ty();}
 
  Complex xz() const {return _wf.xz();}
 
  Complex yz() const {return _wf.yz();}
 
  Complex zz() const {return _wf.zz();}
 
  Complex tz() const {return _wf.tz();}
 
  Complex xt() const {return _wf.xt();}
 
  Complex yt() const {return _wf.yt();}
 
  Complex zt() const {return _wf.zt();}
 
  Complex tt() const {return _wf.tt();}
 
 
  void reset(unsigned int ihel,TensorPhase phase=default_tensor_phase) {
    calculateWaveFunction(ihel,phase);
  }
 
public:
 
  void transform(const LorentzRotation & r) {
    _wf.transform(r);
    transformMomentum(r);
  }
 
public:
 
  static void calculateWaveFunctions(vector<LorentzTensor<double> > & waves,
                                     tPPtr particle,Direction,bool massless,
                                     TensorPhase phase=default_tensor_phase);
 
  static void calculateWaveFunctions(vector<TensorWaveFunction> & waves,
                                     tPPtr particle,Direction,bool massless,
                                     TensorPhase phase=default_tensor_phase);
 
  static void calculateWaveFunctions(vector<LorentzTensor<double> > & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless,
                                     TensorPhase phase=default_tensor_phase);
 
  static void calculateWaveFunctions(vector<TensorWaveFunction> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless,
                                     TensorPhase phase=default_tensor_phase);
 
  static void constructSpinInfo(const vector<LorentzTensor<double> > & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
  static void constructSpinInfo(const vector<TensorWaveFunction> & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
private:
 
  void calculateWaveFunction(unsigned int ihel,
                             TensorPhase phase=default_tensor_phase);
 
private:
 
  LorentzTensor<double> _wf;
 
};
}
}
 
#endif