DrellYanBase.h

// -*- C++ -*-
#ifndef HERWIG_DrellYanBase_H
#define HERWIG_DrellYanBase_H
//
// This is the declaration of the DrellYanBase class.
//
 
#include "HwMEBase.h"
#include "Herwig/Shower/ShowerAlpha.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class DrellYanBase: public HwMEBase {
 
public:
 
  DrellYanBase();
 
  //virtual bool hasPOWHEGCorrection() {return _alpha;}
 
  virtual POWHEGType hasPOWHEGCorrection() {return ISR;}
 
 
  virtual bool hasMECorrection() {return _alpha;}
 
  virtual void initializeMECorrection(RealEmissionProcessPtr, double & initial,
                                      double & final) {
    final   = 1.;
    initial = 1.;
  }
 
  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 void setKinematics() {
    HwMEBase::setKinematics();
    mb2_ = sHat();
  }
 
protected:
 
  bool applyHard(ParticleVector & quarks,
                 vector<tcBeamPtr> beams,
                 Lorentz5Momentum boson,unsigned int & iemit,
                 unsigned int & itype,vector<Lorentz5Momentum> & pnew,
                 LorentzRotation & trans, pair<double,double> & xnew,
                 Energy2 shad);
 
  double getResult(int emis_type, Energy pt, double yj);
 
  bool getEvent(vector<Lorentz5Momentum> & pnew,int & emissiontype);
  
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void doinit();
 
  virtual void dofinish();
 
private:
 
  DrellYanBase & operator=(const DrellYanBase &) = delete;
 
private:
 
  Energy2 mb2_;
 
  double _channelwgtA;
 
  double _channelwgtB;
 
  vector<double> _channelweights;
  
  unsigned int _nover;
 
  double _maxwgt;
 
  double _power;
 
  double _preqqbar;
 
  double _preqg;
 
  double _pregqbar;
 
  vector<double> _prefactor;
 
  vector<tcBeamPtr> _beams;
  
  vector<tcPDPtr> _partons;
 
  double _yb;
 
  Energy _mass;
 
  bool _quarkplus;
 
  double _yj;
 
  Energy _pt;
 
  Energy _min_pt;
 
  ShowerAlphaPtr _alpha;
};
 
}
 
#endif /* HERWIG_DrellYanBase_H */