MEfftoffH.h

// -*- C++ -*-
#ifndef HERWIG_MEfftoffH_H
#define HERWIG_MEfftoffH_H
//
// This is the declaration of the MEfftoffH class.
//
 
#include "HwMEBase.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h"
#include "Herwig/MatrixElement/ProductionMatrixElement.h"
#include "Herwig/PDT/GenericMassGenerator.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class MEfftoffH: public HwMEBase {
 
public:
 
  MEfftoffH() : _shapeopt(2), _maxflavour(5), _minflavour(1), _process(0), 
                _mh(), _wh(), _swap(false) {}
  
  virtual unsigned int orderInAlphaS() const;
 
  virtual unsigned int orderInAlphaEW() const;
 
  virtual double me2() const;
 
  virtual Energy2 scale() const;
 
  virtual void setKinematics();
 
  virtual int nDim() const;
 
  virtual bool generateKinematics(const double * r);
 
  virtual CrossSection dSigHatDR() const;
 
  virtual Selector<DiagramIndex> diagrams(const DiagramVector & dv) const;
 
  virtual Selector<const ColourLines *>
  colourGeometries(tcDiagPtr diag) const;
 
  virtual void constructVertex(tSubProPtr);
 
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  double helicityME(vector<SpinorWaveFunction> & f1 ,
                    vector<SpinorWaveFunction> & f2 ,
                    vector<SpinorBarWaveFunction> & a1,
                    vector<SpinorBarWaveFunction> & a2,
                    bool swap1, bool swap2,
                    bool me) const;
 
  PDPtr WPlus() const {return _wplus;}
 
  PDPtr WMinus() const {return _wminus;}
 
  PDPtr Z0() const {return _z0;}
 
  PDPtr higgs() const {return _higgs;}
 
  void higgs(PDPtr in) {_higgs=in;}
 
  void setWWHVertex(AbstractVVSVertexPtr in) {
    _vertexWWH = in;
  }
 
  void lineShape(unsigned int in) {_shapeopt=in;}
 
  unsigned int process() const {return _process;}
 
  bool swapOrder() {return _swap;}
 
  void process(unsigned int in) {_process = in;}
 
  unsigned int maxFlavour() const {return _maxflavour;}
 
  unsigned int minFlavour() const {return _minflavour;}
 
protected:
 
  virtual void doinit();
 
private:
 
  MEfftoffH & operator=(const MEfftoffH &) = delete;
 
private:
 
  unsigned int _shapeopt;
 
  unsigned int _maxflavour;
 
  unsigned int _minflavour;
 
  unsigned int _process;
 
  PDPtr _wplus;
 
  PDPtr _wminus;
 
  PDPtr _z0;
 
  PDPtr _higgs;
 
  AbstractFFVVertexPtr _vertexFFW;
 
  AbstractFFVVertexPtr _vertexFFZ;
 
  AbstractVVSVertexPtr _vertexWWH;
 
  Energy _mh;
 
  Energy _wh;
 
  GenericMassGeneratorPtr _hmass;
 
 
  mutable ProductionMatrixElement _me;
 
  bool _swap;
};
 
}
 
#endif /* HERWIG_MEfftoffH_H */