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() {}

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