GeneralVSSVertex.h

// -*- C++ -*-
#ifndef Helicity_GeneralVSSVertex_H
#define Helicity_GeneralVSSVertex_H
//
// This is the declaration of the GeneralVSSVertex class.
//
 
#include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h"
#include "ThePEG/Helicity/WaveFunction/ScalarWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
#include "GeneralVSSVertex.fh"
 
namespace ThePEG {
namespace Helicity {
 
using namespace ThePEG;
 
class GeneralVSSVertex: public AbstractVSSVertex {
 
public:
 
  GeneralVSSVertex() : a_(1.), b_(-1.)
  {}
 
  static void Init();
 
  Complex evaluate(Energy2 q2,const VectorWaveFunction & vec1,
                   const ScalarWaveFunction & sca2, const ScalarWaveFunction & sca3);
 
  VectorWaveFunction evaluate(Energy2 q2,int iopt,tcPDPtr out,
                              const ScalarWaveFunction & sca2,
                              const ScalarWaveFunction & sca3,
                              complex<Energy> mass=-GeV, complex<Energy> width=-GeV);
 
  ScalarWaveFunction evaluate(Energy2 q2,int iopt, tcPDPtr out,
                              const VectorWaveFunction & vec1,
                              const ScalarWaveFunction & sca2,
                              complex<Energy> mass=-GeV, complex<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);
  }
 
protected:
 
  Complex a() const {return a_;}
  
  Complex b() const {return b_;}
  
  void a(Complex in) {a_=in;}
  
  void b(Complex in) {b_=in;}
  
private:
 
  GeneralVSSVertex & operator=(const GeneralVSSVertex &) = delete;
 
private:
 
  Complex a_;
 
  Complex b_;
 
};
 
}
}
 
#endif /* Helicity_GeneralVSSVertex_H */