StandardXComb.h

// -*- C++ -*-
//
// StandardXComb.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_StandardXComb_H
#define ThePEG_StandardXComb_H
// This is the declaration of the StandardXComb class.

#include "ThePEG/Config/ThePEG.h"
#include "SubProcessHandler.fh"
#include "ThePEG/PDF/PartonExtractor.fh"
#include "ThePEG/PDF/PartonBin.h"
#include "ThePEG/PDF/PartonBinInstance.h"
#include "ThePEG/Utilities/VSelector.h"
#include "ThePEG/Utilities/ClassDescription.h"
#include "ThePEG/Utilities/Maths.h"
#include "ThePEG/Utilities/XSecStat.h"
#include "ThePEG/EventRecord/Particle.h"
#include "ThePEG/MatrixElement/MEBase.h"
#include "ThePEG/Handlers/XComb.h"
#include "ThePEG/Handlers/StandardEventHandler.h"
#include "ThePEG/Handlers/SubProcessHandler.fh"
#include "StandardXComb.fh"

namespace ThePEG {

class StandardXComb: public XComb {

public:

  typedef MEBase::DiagramVector DiagramVector;

  typedef MEBase::DiagramIndex DiagramIndex;

  friend class MEBase;

public:

  StandardXComb(Energy newMaxEnergy, const cPDPair & inc,
                tEHPtr newEventHandler,tSubHdlPtr newSubProcessHandler,
                tPExtrPtr newExtractor, tCascHdlPtr newCKKW,
                const PBPair & newPartonBins, tCutsPtr newCuts, tMEPtr newME,
                const DiagramVector & newDiagrams, bool mir);

  StandardXComb();

  ~StandardXComb();

  StandardXComb(tMEPtr me, const tPVector & parts, DiagramIndex i);


  tcSubHdlPtr subProcessHandler() const { return theSubProcessHandler; }

  tMEPtr matrixElement() const { return theME; }

  virtual bool checkInit();

  int nDim() const { return theNDim; }

  CrossSection dSigDR(const pair<double,double> ll, int nr, const double * r);

  tSubProPtr construct();

  const XSecStat & stats() const { return theStats; }

  void select(double weight) { theStats.select(weight); }

  void accept() { theStats.accept(); }

  void reject(double weight = 1.0) { theStats.reject(weight); }

  void reset() { theStats.reset(); }

  const DiagramVector & diagrams() const { return theDiagrams; }

  bool mirror() const { return isMirror; }

  const vector<Lorentz5Momentum> & meMomenta() const { return theMEMomenta; }

  tcDiagPtr lastDiagram() const { return diagrams()[lastDiagramIndex()]; }

  const cPDVector & mePartonData() const { return theMEPartonData; }

  DiagramIndex lastDiagramIndex() const { return theLastDiagramIndex; }

  const DVector & meInfo() const { return theMEInfo; }

  void meInfo(const DVector & info) { theMEInfo = info; }

protected:

  void newSubProcess();

  vector<Lorentz5Momentum> & meMomenta() { return theMEMomenta; }

  cPDVector & mePartonData() { return theMEPartonData; }

  void lastDiagramIndex(DiagramIndex i) { theLastDiagramIndex = i; }

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

private:

  tSubHdlPtr theSubProcessHandler;

  tMEPtr theME;

  XSecStat theStats;

  DiagramVector theDiagrams;

  bool isMirror;

  int theNDim;

  pair<int,int> partonDims;

  vector<Lorentz5Momentum> theMEMomenta;

  cPDVector theMEPartonData;

  DiagramIndex theLastDiagramIndex;

  DVector theMEInfo;

private:

  static ClassDescription<StandardXComb> initStandardXComb;
 
  StandardXComb & operator=(const StandardXComb &);

};

template <>
struct BaseClassTrait<StandardXComb,1>: public ClassTraitsType {
  typedef XComb NthBase;
};

template <>
struct ClassTraits<StandardXComb>:
    public ClassTraitsBase<StandardXComb> {
  static string className() { return "ThePEG::StandardXComb"; }
};

}

#endif /* ThePEG_StandardXComb_H */

---