MEPP2Higgs.h

// -*- C++ -*-
//
// MEPP2Higgs.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_MEPP2Higgs_H
#define HERWIG_MEPP2Higgs_H
//
// This is the declaration of the MEPP2Higgs class.
//
 
#include "Herwig/MatrixElement/HwMEBase.h"
#include "ThePEG/Helicity/WaveFunction/ScalarWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
#include "ThePEG/Helicity/Vertex/AbstractFFSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h"
#include "Herwig/PDT/GenericMassGenerator.h"
#include "Herwig/MatrixElement/ProductionMatrixElement.h"
#include "Herwig/Shower/ShowerAlpha.h"
 
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
 
class MEPP2Higgs: public HwMEBase {
 
public:
 
  MEPP2Higgs();
 
  virtual CrossSection dSigHatDR() const;
 
  virtual void setKinematics() {
    HwMEBase::setKinematics();
    mh2_ = sHat();
  }
 
public:
 
  virtual POWHEGType hasPOWHEGCorrection() {return ISR;}
 
  virtual bool hasMECorrection() {return true;}
 
  virtual void initializeMECorrection(RealEmissionProcessPtr, double &,
                                      double & );
 
  virtual RealEmissionProcessPtr applyHardMatrixElementCorrection(RealEmissionProcessPtr);
 
  virtual bool softMatrixElementVeto(PPtr parent,
                                     PPtr progenitor,
                                     const bool & fs,
                                     const Energy & highestpT,
                                     const vector<tcPDPtr> & ids,
                                     const double & z,
                                     const Energy & scale,
                                     const Energy & pT);
 
  virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr,
                                                 ShowerInteraction);
 
public:
 
  virtual unsigned int orderInAlphaS() const;
 
  virtual unsigned int orderInAlphaEW() const;
 
  virtual double me2() const;
 
  virtual bool generateKinematics(const double * r);
 
  virtual Energy2 scale() const;
 
  virtual int nDim() const;
 
  virtual void getDiagrams() 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:
 
  virtual IBPtr clone() const { return new_ptr(*this); }
 
  virtual IBPtr fullclone() const { return new_ptr(*this); }
 
protected:
 
  virtual void doinit();
 
  virtual void dofinish();
 
protected:
  
  Energy4 loME() const;
 
  Energy2 ggME(Energy2 s, Energy2 t, Energy2 u);
 
  Energy2 qgME(Energy2 s, Energy2 t, Energy2 u);
 
  Energy2 qbargME(Energy2 s, Energy2 t, Energy2 u);
 
  Complex B(Energy2 s,Energy2 mf2) const;
 
  complex<InvEnergy2> C(Energy2 s,Energy2 mf2) const;
 
  complex<InvEnergy4> D(Energy2 s,Energy2 t, Energy2 u,Energy2 mf2) const;
 
  Complex dIntegral(Energy2 a, Energy2 b, double y0) const;
 
  complex<Energy> me1(Energy2 s,Energy2 t,Energy2 u, Energy2 mf2,
                             unsigned int i,unsigned int j, unsigned int k,
                             unsigned int i1,unsigned int j1, unsigned int k1) const;
 
  complex<Energy> me2(Energy2 s,Energy2 t,Energy2 u, Energy2 mf2) const;
 
  Complex F(double x) const;
 
  tPDPtr quarkFlavour(tcPDFPtr pdf, Energy2 scale, double x, tcBeamPtr beam, 
                      double & pdfweight, bool anti);
 
  bool applyHard(ParticleVector gluons,
                 vector<tcBeamPtr> beams,
                 PPtr higgs,unsigned int & iemit,
                 unsigned int & itype,vector<Lorentz5Momentum> & pnew,
                 pair<double,double> & xnew,
                 tPDPtr & out);
 
  bool getEvent(vector<Lorentz5Momentum> & pnew,int & emissiontype);
 
  double getResult(int emis_type, Energy pt, double yj,tcPDPtr & outParton);
 
private:
 
  MEPP2Higgs & operator=(const MEPP2Higgs &) = delete;
 
  double ggME(vector<VectorWaveFunction> g1,
              vector<VectorWaveFunction> g2,
              ScalarWaveFunction &, 
              bool calc) const;
 
  double qqME(vector<SpinorWaveFunction> & fin, 
              vector<SpinorBarWaveFunction> & ain, 
              ScalarWaveFunction &, 
              bool calc) const;
 
private:
 
  unsigned int scaleopt_;
 
  Energy mu_F_;
 
  unsigned int shapeOption_;
 
  unsigned int processOption_;
 
  int minFlavour_;
 
  int maxFlavour_;
 
  ProductionMatrixElement me_;
 
  AbstractVVSVertexPtr HGGVertex_;
 
  AbstractFFSVertexPtr HFFVertex_;
 
  GenericMassGeneratorPtr hmass_;
 
  Energy mh_;
 
  Energy wh_;
 
  unsigned int minLoop_;
 
  unsigned int maxLoop_;
 
  unsigned int massOption_;
 
  unsigned int mu_R_opt_;
 
  unsigned int mu_F_opt_;
 
 
  static const complex<Energy2> epsi_;
 
  mutable Complex bi_[5];
 
  mutable complex<InvEnergy2> ci_[8];
 
  mutable complex<InvEnergy4> di_[4];
 
  ShowerAlphaPtr alpha_;
 
  Energy2 mh2_;
 
  double channelwgtA_;
 
  double channelwgtB_;
 
  vector<double> channelWeights_;
 
  double ggPow_;
 
  double qgPow_;
 
  double enhance_;
  
  unsigned int nover_;
 
  unsigned int ntry_;
 
  unsigned int ngen_;
 
  double maxwgt_;
 
  double power_;
 
  double pregg_;
 
  double preqg_;
 
  double pregqbar_;
 
  vector<double> prefactor_;
 
  Energy minpT_;
 
  vector<tcBeamPtr> beams_;
  
  vector<tcPDPtr> partons_;
 
  double yh_;
 
  Energy mass_;
 
  double yj_;
 
  Energy pt_;
 
  tcPDPtr out_;
 
  bool spinCorrelations_;
 
};
 
}
 
#endif /* HERWIG_MEPP2Higgs_H */