XComb.h

// -*- C++ -*-
//
// XComb.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_XComb_H
#define ThePEG_XComb_H
// This is the declaration of the XComb class.

#include "ThePEG/Config/ThePEG.h"
#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/EventRecord/Particle.h"
#include "ThePEG/Handlers/EventHandler.fh"
#include "ThePEG/Cuts/Cuts.fh"

namespace ThePEG {

class XComb: public Base {

public:

  XComb(Energy newMaxEnergy, const cPDPair & inc,
        tEHPtr newEventHandler, tPExtrPtr newExtractor, tCascHdlPtr newCKKW,
        const PBPair & newPartonBins,   tCutsPtr newCuts);

  XComb();

  ~XComb();



  const EventHandler & eventHandler() const { return *theEventHandler; }

  tPExtrPtr pExtractor() const { return thePartonExtractor; }

  tCutsPtr cuts() const { return theCuts; }

  tCascHdlPtr CKKWHandler() const { return theCKKW; }

  const cPDPair & particles() const { return theParticles; }

  const cPDPair & partons() const { return thePartons; }

  const PBPair & partonBins() const { return thePartonBins; }
  
  Energy maxEnergy() const { return theMaxEnergy; }

  bool empty() const { return !theEventHandler; }


  void clean();

  void setPartonBinInstances(PBIPair pbis, Energy2 scale);

  void prepare(const PPair &);

  const PPair & lastParticles() const { return theLastParticles; }

  const PPair & lastPartons() const { return theLastPartons; }

  void lastPartons(PPair pp) { theLastPartons = pp; }

  tSubProPtr subProcess() const { return theSub; }

  void subProcess(tSubProPtr);

  const PBIPair & partonBinInstances() const { return thePartonBinInstances; }

  Energy2 lastS() const { return theLastS; }

  void lastS(Energy2 s) { theLastS = s; }

  Energy2 lastSHat() const { return theLastSHat; }

  void lastSHat(Energy2 sh) { theLastSHat = sh; }

  double lastTau() const { return lastSHat()/lastS(); }

  double lastY() const { return theLastY; }

  void lastY(double y) { theLastY = y; }

  double lastP1() const { return theLastP1P2.first; }

  double lastP2() const { return theLastP1P2.second; }

  void lastP1P2(pair<double,double> pp) { theLastP1P2 = pp; }

  double lastL1() const { return theLastL1L2.first; }

  double lastL2() const { return theLastL1L2.second; }

  void lastL1L2(pair<double,double>);

  double lastX1() const { return theLastX1X2.first; }

  double lastX2() const { return theLastX1X2.second; }

  void lastX1X2(pair<double,double>);

  double lastE1() const { return theLastE1E2.first; }

  double lastE2() const { return theLastE1E2.second; }

  void lastE1E2(pair<double,double>);

  Energy2 lastScale() const { return theLastScale; }

  void lastScale(Energy2 Q2) { theLastScale = Q2; }

  double lastAlphaS() const { return theLastAlphaS; }

  void lastAlphaS(double a) { theLastAlphaS = a; }

  double lastAlphaEM() const { return theLastAlphaEM; }

  void lastAlphaEM(double a) { theLastAlphaEM = a; }

protected:

  void setPartonBinInfo();

  void createPartonBinInstances();

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

private:

  tEHPtr theEventHandler;

  tPExtrPtr thePartonExtractor;

  tCascHdlPtr theCKKW;

  tCutsPtr theCuts;

  cPDPair theParticles;

  cPDPair thePartons;

  PBPair thePartonBins;

  PBPair theParticleBins;

  PBIPair thePartonBinInstances;

  PPair theLastParticles;

  PPair theLastPartons;

  Energy2 theLastS;

  Energy2 theLastSHat;

  double theLastY;

  DPair theLastP1P2;

  DPair theLastL1L2;

  DPair theLastX1X2;

  DPair theLastE1E2;

  Energy2 theLastScale;

  double theLastAlphaS;

  double theLastAlphaEM;

  Energy theMaxEnergy;

  DVector theMEInfo;

  SubProPtr theSub;

private:

  static ClassDescription<XComb> initXComb;
 
  XComb & operator=(const XComb &);

};

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

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

}

#endif /* ThePEG_XComb_H */

---