MEee2ff.h

// -*- C++ -*-
//
// MEee2ff.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_MEee2ff_H
#define HERWIG_MEee2ff_H
//
// This is the declaration of the MEee2ff class.
//
 
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/Models/StandardModel/StandardModel.h"
#include "ThePEG/PDT/EnumParticles.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 MEee2ff: public HwMEBase {
 
public:
 
  MEee2ff() : allowed_(0), helicity_(0), incoming_(0), pTmin_(GeV),
                 preFactor_(6.) {
    massOption(vector<unsigned int>(2,1));
  }
 
  virtual POWHEGType hasPOWHEGCorrection() {return FSR;}
 
  virtual bool hasMECorrection() {return false;}
 
  virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr,
                                                 ShowerInteraction);
 
public:
 
  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 iemittor,
                 bool subtract=false) const;
 
  InvEnergy2 realME(const vector<cPDPtr> & partons,
                    const vector<Lorentz5Momentum> & momenta) const;
 
  Energy generateHard(RealEmissionProcessPtr tree,
                      vector<Lorentz5Momentum> & emission,
                      unsigned int & iemit, unsigned int & ispect,
                      bool applyVeto);
 
 
protected:
 
  AbstractFFVVertexPtr FFZVertex() const {return FFZVertex_;}
 
  AbstractFFVVertexPtr FFPVertex() const {return FFPVertex_;}
 
  PDPtr Z0() const {return Z0_;}
 
  PDPtr gamma() const {return gamma_;}
 
private:
 
  MEee2ff & operator=(const MEee2ff &) = delete;
 
private:
 
  AbstractFFVVertexPtr FFZVertex_;
 
  AbstractFFVVertexPtr FFPVertex_;
 
  PDPtr Z0_;
 
  PDPtr gamma_;
 
  int allowed_;
 
  int helicity_;
 
  int incoming_;
 
  ShowerAlphaPtr alphaQED_;
 
  Energy pTmin_;
 
  double preFactor_;
 
  vector<cPDPtr> partons_;
 
  vector<Lorentz5Momentum> loMomenta_;
 
};
 
}
 
#endif /* HERWIG_MEee2ff_H */