FFVVertex.h

// -*- C++ -*-
//
// FFVVertex.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_FFVVertex_H
#define ThePEG_FFVVertex_H
//
// This is the declaration of the FFVVertex class.
 
#include <ThePEG/Helicity/Vertex/AbstractFFVVertex.h>
#include <ThePEG/Helicity/WaveFunction/VectorWaveFunction.h>
#include <ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h>
#include <ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h>
#include "FFVVertex.fh"
 
namespace ThePEG {
 
namespace Helicity{
 
class FFVVertex: public AbstractFFVVertex {
  
public:
  
  static void Init();
  
public:
 
  virtual Complex evaluate(Energy2 q2,const SpinorWaveFunction & sp1,
                           const SpinorBarWaveFunction & sbar2,
                           const VectorWaveFunction & vec3);
 
  virtual SpinorBarWaveFunction evaluate(Energy2 q2,int iopt,tcPDPtr out,
                                         const SpinorBarWaveFunction & sbar2,
                                         const VectorWaveFunction & vec3,
                                         complex<Energy> mass=-GeV,
                                         complex<Energy> width=-GeV);
 
  virtual VectorWaveFunction evaluate(Energy2 q2,int iopt,tcPDPtr out,
                                      const SpinorWaveFunction & sp1,
                                      const SpinorBarWaveFunction & sbar2,
                                      complex<Energy> mass=-GeV,
                                      complex<Energy> width=-GeV);
 
  virtual SpinorWaveFunction evaluate(Energy2 q2,int iopt,tcPDPtr out,
                                      const SpinorWaveFunction & sp1,
                                      const VectorWaveFunction & vec3,
                                      complex<Energy> mass=-GeV,
                                      complex<Energy> width=-GeV);
 
  virtual SpinorWaveFunction evaluateSmall(Energy2 q2,int iopt, tcPDPtr out,
                                           const SpinorWaveFunction & sp1,
                                           const VectorWaveFunction & vec3,
                                           unsigned int fhel, unsigned int vhel,
                                           double ctheta, double phi, double stheta,
                                           bool includeEikonal = true,
                                           SmallAngleDirection direction = PostiveZDirection,
                                           Energy mass=-GeV, Energy width=-GeV);
 
  virtual SpinorBarWaveFunction evaluateSmall(Energy2 q2,int iopt, tcPDPtr out,
                                              const SpinorBarWaveFunction & sbar2,
                                              const VectorWaveFunction & vec3,
                                              unsigned int fhel, unsigned int vhel,
                                              double ctheta, double phi, double stheta,
                                              bool includeEikonal = true,
                                              SmallAngleDirection direction = PostiveZDirection,
                                              Energy mass=-GeV, Energy width=-GeV);
 
  virtual void setCoupling(Energy2 q2,tcPDPtr part1,
                           tcPDPtr part2,tcPDPtr part3)=0;
 
  virtual void setCoupling(Energy2,tcPDPtr,tcPDPtr,tcPDPtr,tcPDPtr) {
    assert(false);
  }
 
  const Complex & left() const { return _left; }
 
  const Complex & right() const { return _right; }
 
protected:
 
  void left(const Complex & in) { _left = in; }
 
  void right(const Complex & in) { _right = in; }
 
private:
  
  FFVVertex & operator=(const FFVVertex &) = delete;
  
private:
 
  Complex _left;
 
  Complex _right;
  
};
}
 
}
#endif /* ThePEG_FFVVertex_H */