MEBase.h

// -*- C++ -*-
//
// MEBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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 "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 int nDim() const;

  virtual bool generateKinematics(const double * r) = 0;

  virtual CrossSection dSigHatDR() const = 0;

  virtual void generateSubCollision(SubProcess &);

  virtual void clearKinematics();

  virtual void getDiagrams() const = 0;

  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; }

public:

  Energy2 sHat() const { return theLastSHat; }

  double preweight() const { return lastPreweight; }

  virtual void setXComb(tStdXCombPtr);

  const DVector & meInfo() const;

  void meInfo(const DVector & info) const;

  int maxMultCKKW() const { return theMaxMultCKKW; }

  int minMultCKKW() const { return theMinMultCKKW; }

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;

  double jacobian() const { return theLastJacobian; }

  void jacobian(double j) { theLastJacobian = j; }

private:

  mutable DiagramVector theDiagrams;

  Energy2 theLastSHat;

  ReweightVector reweights;

  ReweightVector preweights;

  mutable double lastPreweight;

  Ptr<Amplitude>::pointer theAmplitude;

  double theLastJacobian;

  int theMaxMultCKKW;

  int theMinMultCKKW;

private:

  static AbstractClassDescription<MEBase> initMEBase;

  MEBase & operator=(const MEBase &);

};

}


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

---