MEee2gZ2qq.h

// -*- C++ -*-
//
// MEee2gZ2qq.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_MEee2gZ2qq_H
#define HERWIG_MEee2gZ2qq_H
//
// This is the declaration of the MEee2gZ2qq class.
//
 
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/Models/StandardModel/StandardModel.h"
#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/Repository/EventGenerator.h"
#include "ThePEG/Utilities/Rebinder.h"
#include "Herwig/MatrixElement/ProductionMatrixElement.h"
#include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
#include "Herwig/Shower/ShowerAlpha.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class MEee2gZ2qq: public HwMEBase {
 
public:
 
  MEee2gZ2qq() : minflav_(1), maxflav_(5), massopt_(1),
                 spinCorrelations_(true),
                 pTminQED_(GeV), pTminQCD_(GeV),
                 preFactor_(6.)
  {}
 
  virtual POWHEGType hasPOWHEGCorrection() {return FSR;}
 
  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);
 
  virtual unsigned int orderInAlphaS() const;
 
  virtual unsigned int orderInAlphaEW() const;
 
  virtual double me2() const;
 
  virtual Energy2 scale() 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 rebind(const TranslationMap & trans)
   ;
 
  virtual IVector getReferences();
 
protected:
 
  double loME(const vector<cPDPtr> & partons, 
              const vector<Lorentz5Momentum> & momenta,
              bool first) const;
 
  ProductionMatrixElement HelicityME(vector<SpinorWaveFunction>    & fin,
                                     vector<SpinorBarWaveFunction> & ain,
                                     vector<SpinorBarWaveFunction> & fout,
                                     vector<SpinorWaveFunction>    & aout,
                                     double & me,
                                     double & cont,
                                     double & BW ) const;
 
  double meRatio(vector<cPDPtr> partons, 
                 vector<Lorentz5Momentum> momenta,
                 unsigned int iemitter,
                 ShowerInteraction inter,
                 bool subtract =false) const;
 
  InvEnergy2 realME(const vector<cPDPtr> & partons, 
                    const vector<Lorentz5Momentum> & momenta,
                    ShowerInteraction inter) const;
 
private:
 
  pair<Energy,ShowerInteraction> 
  generateHard(RealEmissionProcessPtr, 
               vector<Lorentz5Momentum> & emission,
               unsigned int & iemit, unsigned int & ispect,
               bool applyVeto,ShowerInteraction);
 
  RealEmissionProcessPtr calculateRealEmission(RealEmissionProcessPtr born, bool veto,
                                               ShowerInteraction inter);
 
  double getKfromX(double, double);
 
  double MEV(double, double);
 
  double PS(double x1, double x2);
 
protected:
  
  AbstractFFVVertexPtr FFZVertex() const {return FFZVertex_;}
  
  AbstractFFVVertexPtr FFPVertex() const {return FFPVertex_;}
  
  PDPtr Z0() const {return Z0_;}
 
  PDPtr gamma() const {return gamma_;}
 
  PDPtr gluon() const {return gluon_;}
 
private:
 
  MEee2gZ2qq & operator=(const MEee2gZ2qq &) = delete;
 
private:
 
   int minflav_;
 
   int maxflav_;
 
  unsigned int massopt_;
 
  AbstractFFVVertexPtr FFZVertex_;
  
  AbstractFFVVertexPtr FFPVertex_;
  
  AbstractFFVVertexPtr FFGVertex_;
 
  bool spinCorrelations_;
 
  PDPtr Z0_;
 
  PDPtr gamma_;
 
  PDPtr gluon_;
 
  Energy d_Q_;
 
  Energy d_m_;
 
  double d_rho_;
 
  double d_v_;
 
  double d_kt1_;
 
  double d_kt2_;
 
  static const double EPS_;
 
  ShowerAlphaPtr alphaQCD_;
 
  ShowerAlphaPtr alphaQED_;
 
private:
 
  Energy pTminQED_;
  Energy pTminQCD_;
 
  double preFactor_;
 
  vector<cPDPtr> partons_;
 
  vector<Lorentz5Momentum> loMomenta_;
 
};
 
}
 
#endif /* HERWIG_MEee2gZ2qq_H */