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 */