DISBase.h

// -*- C++ -*-
#ifndef HERWIG_DISBase_H
#define HERWIG_DISBase_H
//
// This is the declaration of the DISBase class.
//
 
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/Shower/ShowerAlpha.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class DISBase: public HwMEBase {
 
public:
 
  DISBase();
 
  virtual ~DISBase();
 
  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 POWHEGType hasPOWHEGCorrection() {return Both;}
 
  virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr,
                                                 ShowerInteraction);
 
public:
 
  virtual Energy2 scale() const;
 
  virtual int nDim() const;
 
  virtual bool generateKinematics(const double * r);
 
  virtual CrossSection dSigHatDR() const;
 
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void doinit();
 
private:
 
  DISBase & operator=(const DISBase &) = delete;
 
protected:
 
  double NLOWeight() const;
 
  virtual double A(tcPDPtr lin, tcPDPtr lout, tcPDPtr qin, tcPDPtr qout,
                   Energy2 scale) const =0;
 
  double generateComptonPoint(double &xp, double & zp);
 
  double generateBGFPoint(double &xp, double & zp);
 
  vector<double> ComptonME(double xp, double x2, double xperp,
                           bool norm);
  
  vector<double> BGFME(double xp, double x2, double x3, double xperp,
                       bool norm);
 
  void generateCompton();
 
  void generateBGF();
 
private:
 
  double initial_;
 
  double final_;
 
  double procProb_;
 
  double comptonInt_;
 
  double bgfInt_;
 
  double comptonWeight_;
 
  double BGFWeight_;
 
  Energy pTmin_;
 
  Energy2 q2_;
 
  double l_;
 
  double xB_;
 
  tcBeamPtr beam_;
 
  tcPDPtr partons_[2];
 
  tcPDPtr leptons_[2];
 
  tcPDFPtr pdf_;
  LorentzRotation rot_;
 
  Lorentz5Momentum pl_[2];
 
  Lorentz5Momentum pq_[2];
 
  Lorentz5Momentum q_;
 
  Energy pTCompton_;
  bool ComptonISFS_;
  vector<Lorentz5Momentum> ComptonMomenta_;
 
  Energy pTBGF_;
  vector<Lorentz5Momentum> BGFMomenta_;
 
  double acoeff_;
 
  ShowerAlphaPtr alpha_;
 
  PDPtr gluon_;
 
private:
 
  double xp_;
 
  tcBeamPtr hadron_;
 
  unsigned int scaleOpt_;
 
  Energy muF_;
 
  double scaleFact_;
 
  unsigned int contrib_;
 
  double power_;
 
  double jac_;
 
};
 
}
 
#endif /* HERWIG_DISBase_H */