GeneralVVSVertex.h

// -*- C++ -*-
#ifndef HELICITY_GeneralVVSVertex_H
#define HELICITY_GeneralVVSVertex_H
//
// This is the declaration of the GeneralVVSVertex class.
//

#include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h"
#include "ThePEG/Helicity/WaveFunction/ScalarWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
#include "GeneralVVSVertex.fh"

namespace ThePEG {
namespace Helicity {

using namespace ThePEG;

class GeneralVVSVertex: public AbstractVVSVertex {

public:

  GeneralVVSVertex() : _a00(1), 
                       _a11(0), _a12(0), 
                       _a21(0), _a22(0),
                       _aEp(0)
  {}

  static void Init();

public:
  
  virtual Complex evaluate(Energy2 q2,const VectorWaveFunction & vec1,
                           const VectorWaveFunction & vec2,
                           const ScalarWaveFunction & sca3);

  virtual VectorWaveFunction evaluate(Energy2 q2,int iopt,tcPDPtr out,
                                      const VectorWaveFunction & vec2,
                                      const ScalarWaveFunction & sca3,
                                      Energy mass=-GeV, Energy width=-GeV);

  virtual ScalarWaveFunction evaluate(Energy2 q2,int iopt, tcPDPtr out,
                                      const VectorWaveFunction & vec1,
                                      const VectorWaveFunction & vec2,
                                      Energy mass=-GeV, Energy width=-GeV);

  virtual void setCoupling(Energy2 q2,tcPDPtr part1, tcPDPtr part2,
                           tcPDPtr part3)=0;

public:

  Complex a00() const {return _a00;}
      
  Complex a11() const {return _a11;}
      
  Complex a12() const {return _a12;}
      
  Complex a21() const {return _a21;}
      
  Complex a22() const {return _a22;}
      
  Complex aEp() const {return _aEp;}
      
  void a00(const Complex & val) {_a00 = val;}
      
  void a11(const Complex & val) {_a11 = val;}
      
  void a12(const Complex & val) {_a12 = val;}
      
  void a21(const Complex & val) {_a21 = val;}
      
  void a22(const Complex & val) {_a22 = val;}
      
  void aEp(const Complex & val) {_aEp = val;}

private:

  static AbstractNoPIOClassDescription<GeneralVVSVertex> initGeneralVVSVertex;

  GeneralVVSVertex & operator=(const GeneralVVSVertex &);

      
private:
  
  Complex _a00;

  Complex _a11;

  Complex _a12;

  Complex _a21;

  Complex _a22;

  Complex _aEp;
};

}
}

#include "ThePEG/Utilities/ClassTraits.h"

namespace ThePEG {

template <>
struct BaseClassTrait<Helicity::GeneralVVSVertex,1> {
  typedef Helicity::AbstractVVSVertex NthBase;
};

template <>
struct ClassTraits<Helicity::GeneralVVSVertex>
  : public ClassTraitsBase<Helicity::GeneralVVSVertex> {
  static string className() { return "Helicity::GeneralVVSVertex"; }
};

}

#endif /* HELICITY_GeneralVVSVertex_H */

---