MEBase.h

// -*- C++ -*-
//
// MEBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_MEBase_H
#define ThePEG_MEBase_H
// This is the declaration of the MEBase class.
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/EventRecord/SubProcess.h"
#include "ThePEG/MatrixElement/DiagramBase.h"
#include "ThePEG/MatrixElement/ColourLines.h"
#include "ThePEG/MatrixElement/Amplitude.h"
#include "ThePEG/Handlers/LastXCombInfo.h"
#include "ThePEG/Handlers/StandardXComb.fh"
#include "ReweightBase.h"
 
#include "ThePEG/Handlers/EventHandler.fh"
#include "ThePEG/Handlers/StandardEventHandler.fh"
#include "ThePEG/Handlers/SubProcessHandler.fh"
#include "ThePEG/PDF/PartonBin.fh"
 
#include "MEBase.fh"
 
namespace ThePEG {
 
class MEBase: public HandlerBase, public LastXCombInfo<StandardXComb> {
 
public:
 
  typedef vector<DiagPtr> DiagramVector;
  typedef DiagramVector::size_type DiagramIndex;
  typedef vector<ReweightPtr> ReweightVector;
 
public:
 
  MEBase();
 
  virtual ~MEBase();
 
public:
 
  virtual unsigned int orderInAlphaS() const = 0;
 
  virtual unsigned int orderInAlphaEW() const = 0;
 
  virtual double me2() const = 0;
 
  virtual Energy2 scale() const = 0;
 
  virtual double alphaS() const;
 
  virtual double alphaEM() const;
 
  void setKinematics(tPPair in, const PVector & out);
 
  virtual void setKinematics() {}
 
  virtual void constructVertex(tSubProPtr sub);
 
  virtual void constructVertex(tSubProPtr sub, const ColourLines* cl);
 
  virtual int nDim() const;
 
  virtual bool generateKinematics(const double * r) = 0;
 
  virtual bool wantCMS() const { return true; }
 
  virtual bool headCuts() const { return false; }
 
  virtual bool ignoreCuts() const { return false; }
 
  virtual bool apply() const { return true; }
 
  virtual CrossSection dSigHatDR() const = 0;
 
  virtual map<string,double> generateOptionalWeights() {
    return map<string,double>();
  }
 
  virtual bool haveX1X2() const { return false; }
 
  virtual bool havePDFWeight1() const { return false; }
 
  virtual bool havePDFWeight2() const { return false; }
 
  virtual bool keepRandomNumbers() const { return false; }
 
  virtual void generateSubCollision(SubProcess &);
 
  virtual void clearKinematics();
 
  virtual void getDiagrams() const = 0;
 
  virtual bool noMirror () const { return false; }
 
  const DiagramVector & diagrams() const {
    if ( theDiagrams.empty() ) getDiagrams();
    return theDiagrams;
  }
 
  virtual Selector<const ColourLines *>
  colourGeometries(tcDiagPtr diag) const = 0;
 
  virtual const ColourLines &
  selectColourGeometry(tcDiagPtr diag) const;
 
  virtual Selector<DiagramIndex> diagrams(const DiagramVector &) const {
    return Selector<DiagramIndex>();
  }
 
 
  virtual DiagramIndex diagram(const DiagramVector &) const;
 
  inline bool reweighted() const {
    return reweights.size() > 0 || preweights.size() > 0;
  }
 
  double reWeight() const;
 
  double preWeight() const;
 
  void addReweighter(tReweightPtr rw);
 
  void addPreweighter(tReweightPtr rw);
 
  Ptr<Amplitude>::pointer amplitude() const { return theAmplitude; }
 
  void amplitude(Ptr<Amplitude>::pointer amp) { theAmplitude = amp; }
 
public:
 
  Energy2 sHat() const { return lastSHat(); }
 
  double preweight() const { return lastPreweight(); }
 
  virtual void flushCaches() {}
 
  virtual StdXCombPtr makeXComb(Energy newMaxEnergy, const cPDPair & inc,
                                tEHPtr newEventHandler,tSubHdlPtr newSubProcessHandler,
                                tPExtrPtr newExtractor, tCascHdlPtr newCKKW,
                                const PBPair & newPartonBins, tCutsPtr newCuts,
                                const DiagramVector & newDiagrams, bool mir,
                                const PartonPairVec& allPBins,
                                tStdXCombPtr newHead = tStdXCombPtr(),
                                tMEPtr newME = tMEPtr());
 
  virtual StdXCombPtr makeXComb(tStdXCombPtr newHead,
                                const PBPair & newPartonBins,
                                const DiagramVector & newDiagrams,
                                tMEPtr newME = tMEPtr());
 
  virtual void fillProjectors() { }
 
  virtual void setXComb(tStdXCombPtr);
 
  const DVector & meInfo() const;
 
  void meInfo(const DVector & info) const;
 
  virtual int maxMultCKKW() const { return theMaxMultCKKW; }
 
  virtual int minMultCKKW() const { return theMinMultCKKW; }
 
  virtual void maxMultCKKW(int mult) { theMaxMultCKKW = mult; }
 
  virtual void minMultCKKW(int mult) { theMinMultCKKW = mult; }
 
  virtual void setVetoScales(tSubProPtr) const {}
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  void add(DiagPtr dp) const { theDiagrams.push_back(dp); }
 
  vector<Lorentz5Momentum> & meMomenta();
  using LastXCombInfo<StandardXComb>::meMomenta;
 
  void lastME2(double v) const;
  using LastXCombInfo<StandardXComb>::lastME2;
 
  void lastPreweight(double w) const;
  using LastXCombInfo<StandardXComb>::lastPreweight;
 
  void lastMECrossSection(CrossSection v) const;
  using LastXCombInfo<StandardXComb>::lastMECrossSection;
 
  void lastMEPDFWeight(double v) const;
  using LastXCombInfo<StandardXComb>::lastMEPDFWeight;
 
  void lastMECouplings(double v) const;
  using LastXCombInfo<StandardXComb>::lastMECouplings;
 
  void jacobian(double j);
  using LastXCombInfo<StandardXComb>::jacobian;
 
  void use(tcMEPtr other);
 
  void useDiagrams(tcMEPtr other) const;
 
protected:
 
 
  virtual void doinit();
 
  virtual void doinitrun();
 
private:
 
  mutable DiagramVector theDiagrams;
 
  ReweightVector reweights;
 
  ReweightVector preweights;
 
  Ptr<Amplitude>::pointer theAmplitude;
 
  int theMaxMultCKKW;
 
  int theMinMultCKKW;
 
private:
 
  static AbstractClassDescription<MEBase> initMEBase;
 
  MEBase & operator=(const MEBase &) = delete;
 
};
 
}
 
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<MEBase,1>: public ClassTraitsType {
  typedef HandlerBase NthBase;
};
 
template <>
struct ClassTraits<MEBase>: public ClassTraitsBase<MEBase> {
  static string className() { return "ThePEG::MEBase"; }
};
 
}
 
#include "ThePEG/Handlers/StandardXComb.h"
 
#endif /* ThePEG_MEBase_H */