MEGroup.h

// -*- C++ -*-
//
// MEGroup.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
// Copyright (C) 2009-2019 Simon Platzer
//
// 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_MEGroup_H
#define ThePEG_MEGroup_H
// This is the declaration of the MEGroup class.
 
#include "ThePEG/MatrixElement/MEBase.h"
#include "ThePEG/Cuts/Cuts.fh"
#include "MEGroup.fh"
 
namespace ThePEG {
 
class MEGroup: public MEBase {
 
public:
 
  MEGroup();
 
  virtual ~MEGroup();
 
public:
 
  virtual unsigned int orderInAlphaS() const { return head()->orderInAlphaS(); }
 
  virtual unsigned int orderInAlphaEW() const { return head()->orderInAlphaEW(); }
 
  virtual double me2() const { return head()->me2(); }
 
  virtual Energy2 scale() const { return head()->scale(); }
 
  virtual double alphaS() const { return head()->alphaS(); }
 
  virtual double alphaEM() const { return head()->alphaEM(); }
 
  virtual void setKinematics() {
    MEBase::setKinematics();
    head()->setKinematics();
  }
 
  virtual void constructVertex(tSubProPtr sub) { head()->constructVertex(sub); }
 
  virtual void constructVertex(tSubProPtr sub, const ColourLines* cl) {
    head()->constructVertex(sub,cl);
  }
 
  virtual int nDim() const { return theNDim; }
 
  virtual bool generateKinematics(const double * r);
 
  virtual bool wantCMS () const { return head()->wantCMS(); }
 
  virtual CrossSection dSigHatDR() const { return head()->dSigHatDR(); }
 
  virtual bool haveX1X2() const { return head()->haveX1X2(); }
 
  virtual bool havePDFWeight1 () const { return head()->havePDFWeight1(); }
 
  virtual bool havePDFWeight2 () const { return head()->havePDFWeight2(); }
 
  virtual bool keepRandomNumbers() const { return head()->keepRandomNumbers(); }
 
  virtual void generateSubCollision(SubProcess & sub) { head()->generateSubCollision(sub); }
 
  virtual void clearKinematics();
 
  virtual void getDiagrams() const {
    head()->diagrams();
    useDiagrams(head());
  }
 
  virtual bool noMirror () const { return head()->noMirror(); }
 
  virtual Selector<const ColourLines *>
  colourGeometries(tcDiagPtr diag) const { return head()->colourGeometries(diag); }
 
  virtual const ColourLines &
  selectColourGeometry(tcDiagPtr diag) const { return head()->selectColourGeometry(diag); }
 
  virtual Selector<DiagramIndex> diagrams(const DiagramVector & dv) const  { 
    return head()->diagrams(dv); 
  }
 
  virtual DiagramIndex diagram(const DiagramVector & dv) const {
    DiagramIndex res = head()->diagram(dv); 
    return res;
  }
 
  virtual void setXComb(tStdXCombPtr xc) {
    MEBase::setXComb(xc);
    head()->setXComb(xc);
  }
 
  virtual int maxMultCKKW() const { return head()->maxMultCKKW(); }
 
  virtual int minMultCKKW() const { return head()->minMultCKKW(); }
 
  virtual void maxMultCKKW(int mult) { head()->maxMultCKKW(mult); }
 
  virtual void minMultCKKW(int mult) { head()->minMultCKKW(mult); }
 
  virtual void flushCaches() { head()->flushCaches(); }
 
  virtual void lastEventStatistics() {}
 
  virtual bool discard(const CrossSection&, const CrossSection&) const { return false; }
 
public:
 
  tMEPtr head() const { return theHead; }
 
  const MEVector& dependent() const { return theDependent; }
 
  void head(tMEPtr me) { theHead = me; }
 
  MEVector& dependent() { return theDependent; }
 
  int dependentOffset(tMEPtr dep) const;
 
  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 vector<StdXCombPtr> makeDependentXCombs(tStdXCombPtr xcHead,
                                                  const cPDVector& proc,
                                                  tMEPtr depME,
                                                  const PartonPairVec& allPBins) const;
 
  virtual void fillProjectors() { head()->fillProjectors(); }
 
  virtual bool willProject() const { return false; }
 
  virtual bool groupReweighted() const { return false; }
 
  virtual double reweightHead(const vector<tStdXCombPtr>&) { return 1.; }
 
  virtual double reweightDependent(tStdXCombPtr, const vector<tStdXCombPtr>&) { return 1.; }
 
  virtual bool subProcessGroups() const { return true; }
 
public:
 
  virtual bool uniformAdditional() const = 0;
 
  virtual MEBase::DiagramVector dependentDiagrams(const cPDVector& proc,
                                                  tMEPtr depME) const = 0;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void rebind(const TranslationMap & trans);
 
  virtual IVector getReferences();
 
private:
 
  MEPtr theHead;
 
  MEVector theDependent;
 
  map<tMEPtr,int> theNDimMap;
 
  int theNDim;
 
private:
 
  static AbstractClassDescription<MEGroup> initMEGroup;
 
  MEGroup & operator=(const MEGroup &) = delete;
 
};
 
}
 
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<MEGroup,1> {
  typedef MEBase NthBase;
};
 
template <>
struct ClassTraits<MEGroup>: public ClassTraitsBase<MEGroup> {
  static string className() { return "ThePEG::MEGroup"; }
};
 
}
 
#endif /* ThePEG_MEGroup_H */