Rank3TensorWaveFunction.h

// -*- C++ -*-
//
// Rank3TensorWaveFunction.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_Rank3TensorWaveFunction_H
#define ThePEG_Rank3TensorWaveFunction_H
//
// This is the declaration of the Rank3TensorWaveFunction class.
//
#include "WaveFunctionBase.h"
#include "VectorWaveFunction.h"
#include <ThePEG/Helicity/LorentzRank3Tensor.h>
#include <ThePEG/Helicity/Rank3TensorSpinInfo.h>
#include <ThePEG/EventRecord/Particle.h>
#include <ThePEG/EventRecord/RhoDMatrix.h>
 
namespace ThePEG {
namespace Helicity {
 
class Rank3TensorWaveFunction : public WaveFunctionBase {
 
public:
 
  Rank3TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                          const LorentzRank3Tensor<double> & wave,
                          Direction  dir=intermediate) 
    : WaveFunctionBase(p,part,dir), _wf(wave) {
    assert(iSpin()==PDT::Spin3);
  }
 
  Rank3TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
                          unsigned int ihel,Direction dir) 
    : WaveFunctionBase(p,part,dir) {
    assert(iSpin()==PDT::Spin3);
    calculateWaveFunction(ihel);
  }
 
  Rank3TensorWaveFunction(const Lorentz5Momentum & p,
                          tcPDPtr part,Direction dir) 
    : WaveFunctionBase(p,part,dir), _wf() {
    assert(iSpin()==PDT::Spin3);
  }
 
  Rank3TensorWaveFunction() {}
 
  Rank3TensorWaveFunction(vector<Rank3TensorWaveFunction> & wave,
                          tPPtr part,Direction dir,bool time,bool massless,
                          bool=true) {
    calculateWaveFunctions(wave,part,dir,massless);
    constructSpinInfo(wave,part,dir,time,massless);
  }
 
  Complex operator ()(int i, int j, int k) const {
    return _wf(i,j,k);
  }
 
  Complex & operator () (int i, int j, int k) {
    return _wf(i,j,k);
  }
 
  const LorentzRank3Tensor<double> & wave() const {return _wf;}
 
 
  void reset(unsigned int ihel) {
    calculateWaveFunction(ihel);
  }
 
public:
 
  void transform(const LorentzRotation & r) {
    _wf.transform(r);
    transformMomentum(r);
  }
 
public:
 
  static void calculateWaveFunctions(vector<LorentzRank3Tensor<double> > & waves,
                                     tPPtr particle,Direction,bool massless);
 
  static void calculateWaveFunctions(vector<Rank3TensorWaveFunction> & waves,
                                     tPPtr particle,Direction,bool massless);
 
  static void calculateWaveFunctions(vector<LorentzRank3Tensor<double> > & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless);
 
  static void calculateWaveFunctions(vector<Rank3TensorWaveFunction> & waves,
                                     RhoDMatrix & rho,
                                     tPPtr particle,Direction,bool massless);
 
  static void constructSpinInfo(const vector<LorentzRank3Tensor<double> > & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
  static void constructSpinInfo(const vector<Rank3TensorWaveFunction> & waves,
                                tPPtr part,Direction dir, bool time,bool massless);
 
private:
 
  void calculateWaveFunction(unsigned int ihel);
 
private:
 
  LorentzRank3Tensor<double> _wf;
 
};
}
}
 
#endif