MEPP2VVPowheg.h

// -*- C++ -*-
#ifndef HERWIG_MEPP2VVPowheg_H
#define HERWIG_MEPP2VVPowheg_H
//
// This is the declaration of the MEPP2VVPowheg class.
//
 
#include "Herwig/MatrixElement/Hadron/MEPP2VV.h"
#include "Herwig/MatrixElement/Powheg/VVKinematics.h"
#include "Herwig/Utilities/Maths.h"
#include "Herwig/Models/StandardModel/StandardCKM.h"
#include "Herwig/Shower/ShowerAlpha.h"
 
namespace Herwig {
using namespace ThePEG;
using Math::ReLi2;
using Constants::pi;
 
class MEPP2VVPowheg: public MEPP2VV {
 
public:
 
  MEPP2VVPowheg();
 
  virtual POWHEGType hasPOWHEGCorrection() {return ISR;}
 
  virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr,
                                                 ShowerInteraction inter);
 
public:
 
  virtual bool generateKinematics(const double * r);
 
  virtual int nDim() const;
 
  virtual double me2() const;
 
  virtual Energy2 scale() const;
 
  bool sanityCheck() const;
 
  Complex CKM(int ix,int iy) const { return ckm_[ix][iy]; }
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
    static void Init();
 
protected:
 
  virtual void doinit();
 
public:
 
  void getKinematics(double xt, double y, double theta2);
 
  double NLOweight() const;
 
  double Lhat_ab(tcPDPtr a, tcPDPtr b, realVVKinematics Kinematics) const;
 
  double Vtilde_universal(realVVKinematics S) const;
 
  double Ctilde_Ltilde_qq_on_x(tcPDPtr a,tcPDPtr b,realVVKinematics C) const;
 
  double Ctilde_Ltilde_gq_on_x(tcPDPtr a,tcPDPtr b,realVVKinematics C) const;
 
  double Rtilde_Ltilde_qqb_on_x(tcPDPtr a,tcPDPtr b) const;
 
  double Rtilde_Ltilde_qg_on_x(tcPDPtr a,tcPDPtr b) const;
 
  double Rtilde_Ltilde_gqb_on_x(tcPDPtr a,tcPDPtr b) const;
 
  double M_V_regular(realVVKinematics S) const;
 
  mutable double M_V_regular_;
 
  Energy2 t_u_M_R_qqb(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_qqb_;
 
  Energy2 t_u_M_R_qg(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_qg_;
 
  Energy2 t_u_M_R_gqb(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_gqb_;
 
  Energy2 t_u_M_R_qqb_hel_amp(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_qqb_hel_amp_;
 
  Energy2 t_u_M_R_qg_hel_amp(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_qg_hel_amp_;
 
  Energy2 t_u_M_R_gqb_hel_amp(realVVKinematics R) const;
 
  mutable Energy2 t_u_M_R_gqb_hel_amp_;
 
  double lo_me() const;
 
  double M_Born_WZ(bornVVKinematics B) const;
 
  mutable double M_Born_;
 
  double M_Born_ZZ(bornVVKinematics B) const;
 
  double M_V_regular_ZZ(realVVKinematics S) const;
 
  Energy2 t_u_M_R_qqb_ZZ(realVVKinematics R) const;
 
  double M_Born_WW(bornVVKinematics B) const;
 
  double M_V_regular_WW(realVVKinematics S) const;
 
  Energy2 t_u_M_R_qqb_WW(realVVKinematics R) const;
 
  Energy2 mu_F2() const;
 
  Energy2 mu_UV2() const;
 
protected:
 
  inline virtual IBPtr clone() const { return new_ptr(*this); }
 
  inline virtual IBPtr fullclone() const { return new_ptr(*this); }
 
private:
 
  MEPP2VVPowheg & operator=(const MEPP2VVPowheg &) = delete;
 
private:
 
 
  double tiny;
 
  tcBeamPtr hadron_A_;
  tcBeamPtr hadron_B_;
 
  bornVVKinematics B_;
 
  realVVKinematics S_;
 
  realVVKinematics SCp_;
 
  realVVKinematics SCm_;
 
  realVVKinematics Cp_;
 
  realVVKinematics Cm_;
 
  realVVKinematics H_;
 
  tcPDPtr ab_, bb_;
 
  tcPDPtr quark_, antiquark_;
 
  double lo_lumi_;
 
  mutable double lo_me2_;
 
  double CF_;
 
  double TR_;
 
  double NC_;
 
  mutable double gW_, sin2ThetaW_;
 
  mutable double guL_, gdL_;
 
  mutable double guR_, gdR_;
 
  mutable double eZ_;
 
  mutable double eZ2_;
 
  mutable double Fij2_;
 
  unsigned int contrib_;
 
  unsigned int channels_;
 
  unsigned int nlo_alphaS_opt_;
 
  double fixed_alphaS_;
 
  unsigned int removebr_;
 
  unsigned int scaleopt_;
 
  Energy mu_F_;
 
  Energy mu_UV_;
 
  Energy2 k1r_perp2_lab_;
 
  Energy2 k2r_perp2_lab_;
 
  vector< vector<Complex> > ckm_;
 
  bool helicityConservation_;
 
  mutable ProductionMatrixElement qqb_hel_amps_;
 
  mutable ProductionMatrixElement qg_hel_amps_;
 
  mutable ProductionMatrixElement gqb_hel_amps_;
 
  AbstractFFVVertexPtr FFPvertex_;
 
  AbstractFFVVertexPtr FFWvertex_;
 
  AbstractFFVVertexPtr FFZvertex_;
 
  AbstractVVVVertexPtr WWWvertex_;
 
  AbstractFFVVertexPtr FFGvertex_;
 
  mutable double alphaS_;
 
protected:
 
  double getResult(int emis_type, realVVKinematics R, Energy pT);
 
  bool getEvent(vector<Lorentz5Momentum> & pnew,unsigned int & emissiontype);
  
  void setTheScales(Energy pT);
 
  Energy2 t_u_M_R_qqb_hel_amp(realVVKinematics R, bool getMatrix) const;
 
 
  Energy2 t_u_M_R_qg_hel_amp(realVVKinematics R, bool getMatrix) const;
 
  Energy2 t_u_M_R_gqb_hel_amp(realVVKinematics R, bool getMatrix) const;
 
  double lo_me(bool getMatrix) const;
 
  void recalculateVertex();
 
  bool isotropicDecayer();
 
  Energy2 triangleFn(Energy2,Energy2,Energy2);
 
private:
 
  bool realMESpinCorrelations_;
 
  double lo_me_;
 
  realVVKinematics R_;
 
  unsigned int channel_;
 
  int fermionNumberOfMother_;
 
  ShowerAlphaPtr showerAlphaS_;
 
  double power_;
 
  double preqqbar_;
 
  double preqg_;
 
  double pregqbar_;
 
  double b0_;
 
  Energy LambdaQCD_;
 
  vector<double> prefactor_;
 
  PPtr qProgenitor_;
  PPtr qbProgenitor_;
 
  PPtr showerQuark_;
  PPtr showerAntiquark_;
 
  tcBeamPtr qHadron_;
  tcBeamPtr qbHadron_;
 
  PPtr gluon_;
  PPtr V1_;
  PPtr V2_;
  vector<PPtr> children_;
 
  bool flipped_;
 
  double Yk_;
 
  Energy pT_;
 
  Energy min_pT_;
 
  // Work out the scales we want to use in the matrix elements and the pdfs:
  Energy2 QCDScale_;
 
  Energy2 PDFScale_;
 
  Energy2 EWScale_;
 
  mutable Complex productionMatrix_[3][3][3][3];
 
};
 
}
 
#endif /* HERWIG_MEPP2VVPowheg_H */