MEPP2QQ.h

// -*- C++ -*-
//
// MEPP2QQ.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_MEPP2QQ_H
#define HERWIG_MEPP2QQ_H
//
// This is the declaration of the MEPP2QQ class.
//
 
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/MatrixElement/ProductionMatrixElement.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVVertex.h"
#include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
 
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
 
class MEPP2QQ: public HwMEBase {
 
public:
 
  MEPP2QQ();
 
  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:
 
  double gg2qqbarME(vector<VectorWaveFunction> &g1,vector<VectorWaveFunction> &g2,
                    vector<SpinorBarWaveFunction> & q,vector<SpinorWaveFunction> & qbar,
                    unsigned int flow) const;
 
  double qqbar2qqbarME(vector<SpinorWaveFunction> & q1,
                       vector<SpinorBarWaveFunction> & q2,
                       vector<SpinorBarWaveFunction>    & q3,
                       vector<SpinorWaveFunction>    & q4,
                       unsigned int flow) const;
 
  double qq2qqME(vector<SpinorWaveFunction> & q1, vector<SpinorWaveFunction> & q2,
                 vector<SpinorBarWaveFunction> & q3, vector<SpinorBarWaveFunction> & q4,
                 unsigned int flow) const;
 
  double qbarqbar2qbarqbarME(vector<SpinorBarWaveFunction> & q1,
                             vector<SpinorBarWaveFunction> & q2,
                             vector<SpinorWaveFunction>    & q3,
                             vector<SpinorWaveFunction>    & q4,
                             unsigned int flow) const;
 
  double qg2qgME(vector<SpinorWaveFunction> & qin,vector<VectorWaveFunction> &g2,
                 vector<SpinorBarWaveFunction> & qout,vector<VectorWaveFunction> &g4,
                 unsigned int flow) const;
 
  double qbarg2qbargME(vector<SpinorBarWaveFunction> & qin,
                       vector<VectorWaveFunction> &g2,
                       vector<SpinorWaveFunction> & qout,vector<VectorWaveFunction> &g4,
                       unsigned int flow) const;
 
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();
 
private:
 
  MEPP2QQ & operator=(const MEPP2QQ &) = delete;
 
private:
 
  AbstractVVVVertexPtr _gggvertex;
 
  AbstractFFVVertexPtr _qqgvertex;
 
  unsigned int _quarkflavour;
 
  unsigned int _process;
 
  unsigned int _bottomopt;
 
  unsigned int _topopt;
 
  unsigned int _maxflavour;
 
  mutable unsigned int _flow;
 
  mutable unsigned int _diagram;
 
  mutable ProductionMatrixElement _me;
 
  PDPtr _gluon;
  
  vector<PDPtr> _quark;
 
  vector<PDPtr> _antiquark;
 
};
 
}
 
#endif /* HERWIG_MEPP2QQ_H */