XComb.h

// -*- C++ -*-
//
// XComb.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// 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_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/AnyReference.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();
 
  virtual ~XComb();
 
 
 
  const EventHandler & eventHandler() const { return *theEventHandler; }
 
  tEHPtr eventHandlerPtr() 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; }
 
 
  virtual 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);
 
  typedef map<cPPtr,PBIPtr> PartonBinInstanceMap;
 
  PartonBinInstanceMap& partonBinInstanceMap() { return thePartonBinInstanceMap; }
 
  const PartonBinInstanceMap& partonBinInstanceMap() const { return thePartonBinInstanceMap; }
 
  const PBIPair & partonBinInstances() const { return thePartonBinInstances; }
 
  PBIPair & partonBinInstances() { return thePartonBinInstances; }
 
  tPBIPtr partonBinInstance(tcPPtr) const;
 
  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; }
 
  Energy2 lastCentralScale() const { 
    return 
      theLastCentralScale != ZERO ?
      theLastCentralScale :
      lastScale(); 
  }
 
  void lastCentralScale(Energy2 Q2) { theLastCentralScale = Q2; }
 
  Energy2 lastShowerScale() const { 
    return 
      theLastShowerScale != ZERO ?
      theLastShowerScale :
      lastCentralScale(); 
  }
 
  void lastShowerScale(Energy2 Q2) { theLastShowerScale = Q2; }
 
  double lastAlphaS() const { return theLastAlphaS; }
 
  void lastAlphaS(double a) { theLastAlphaS = a; }
 
  double lastAlphaEM() const { return theLastAlphaEM; }
 
  void lastAlphaEM(double a) { theLastAlphaEM = a; }
 
public:
 
  bool hasMeta(int id) const {
    return theMeta.find(id) != theMeta.end();
  }
 
  template<class T>
  void meta(int id, T& ref) {
    theMeta[id] = AnyReference(ref);
  }
 
  void eraseMeta(int id) {
    theMeta.erase(id);
  }
 
  template<class T>
  T& meta(int id) const {
    return theMeta.find(id)->second.cast<T>();
  }
 
  void setPartonBinInfo();
 
  void createPartonBinInstances();
 
  void lastParticles(const PPair & p) { theLastParticles = p; }
 
  void resetPartonBinInstances(const PBIPair & newBins) { thePartonBinInstances = newBins; }
 
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;
 
  PartonBinInstanceMap thePartonBinInstanceMap;
 
  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;
 
  Energy2 theLastCentralScale;
 
  Energy2 theLastShowerScale;
 
  double theLastAlphaS;
 
  double theLastAlphaEM;
 
  Energy theMaxEnergy;
 
  DVector theMEInfo;
 
  SubProPtr theSub;
 
  map<int,AnyReference> theMeta;
 
private:
 
  static ClassDescription<XComb> initXComb;
 
  XComb & operator=(const XComb &) = delete;
 
};
 
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 */