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