DipoleSplittingKernel.h

// -*- C++ -*-
//
// DipoleSplittingKernel.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_DipoleSplittingKernel_H
#define HERWIG_DipoleSplittingKernel_H
//
// This is the declaration of the DipoleSplittingKernel class.
//
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/StandardModel/AlphaSBase.h"
#include "ThePEG/PDF/PDF.h"
 
#include "Herwig/Shower/Dipole/Utility/PDFRatio.h"
#include "Herwig/Shower/Dipole/Base/DipoleSplittingInfo.h"
#include "Herwig/Shower/Dipole/Kinematics/DipoleSplittingKinematics.h"
 
#include "ThePEG/EventRecord/RhoDMatrix.h"
#include "Herwig/Decay/DecayMatrixElement.h"
#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class DipoleSplittingKernel: public HandlerBase {
 
public:
 
  DipoleSplittingKernel();
 
public:
 
  Ptr<AlphaSBase>::tptr alphaS() const { return theAlphaS; }
 
  void alphaS(Ptr<AlphaSBase>::tptr ap) { theAlphaS = ap; }
 
  Ptr<DipoleSplittingKinematics>::tptr splittingKinematics() const {
      return theSplittingKinematics; 
  }
 
  Ptr<DipoleMCCheck>::ptr mcCheck() const { return theMCCheck; }
 
  void splittingKinematics(Ptr<DipoleSplittingKinematics>::tptr sp) { 
    theSplittingKinematics = sp; 
  }
 
  Ptr<PDFRatio>::tptr pdfRatio() const { return thePDFRatio; }
 
  void pdfRatio(Ptr<PDFRatio>::tptr sp) { thePDFRatio = sp; }
 
  virtual int nDimAdditional() const { return 0; }
 
  void renormalizationScaleFreeze(Energy s) { theRenormalizationScaleFreeze = s; }
 
  void factorizationScaleFreeze(Energy s) { theFactorizationScaleFreeze = s; }
 
  Energy renormalizationScaleFreeze() const { return theRenormalizationScaleFreeze; }
 
  Energy factorizationScaleFreeze() const { return theFactorizationScaleFreeze; }
 
public:
 
  virtual bool canHandle(const DipoleIndex&) const = 0;
 
  virtual bool canHandleEquivalent(const DipoleIndex& a,
                                   const DipoleSplittingKernel& sk,
                                   const DipoleIndex& b) const = 0;
 
  virtual tcPDPtr emitter(const DipoleIndex&) const = 0;
 
  virtual tcPDPtr emission(const DipoleIndex&) const = 0;
 
  virtual tcPDPtr spectator(const DipoleIndex&) const = 0;
 
  PDPtr flavour() const { return theFlavour; }
 
  bool strictLargeN() const { return theStrictLargeN; }
 
public:
 
  virtual void startPresampling(const DipoleIndex&) {
    presampling = true;
  }
 
  virtual void stopPresampling(const DipoleIndex&) {
    presampling = false;
  }
 
  unsigned long presamplingPoints() const { return thePresamplingPoints; }
 
  unsigned long maxtry() const { return theMaxtry; }
 
  unsigned long freezeGrid() const { return theFreezeGrid; }
 
  void freezeGrid(unsigned long n) { theFreezeGrid = n; }
 
  void detuning(double d) { theDetuning = d; }
 
  double detuning() const { return theDetuning; }
 
  virtual double evaluate(const DipoleSplittingInfo&) const = 0;
  
  virtual vector< pair<int, Complex> >  generatePhi( const DipoleSplittingInfo& dInfo, const RhoDMatrix& rho) const = 0;
   
  virtual DecayMEPtr matrixElement(const DipoleSplittingInfo& dInfo) const = 0;
 
  void clearAlphaPDFCache() const {
    theAlphaSCache.clear();
    thePDFCache.clear();
  }
 
  virtual void accept(const DipoleSplittingInfo&, double, double, map<string,double>&) const;
 
  virtual void veto(const DipoleSplittingInfo&, double, double, map<string,double>&) const;
 
  virtual bool haveOverestimate(const DipoleSplittingInfo&) const { return false; }
 
  virtual double overestimate(const DipoleSplittingInfo&) const { return -1.; }
 
  virtual double invertOverestimateIntegral(const DipoleSplittingInfo&, double) const {
    return -1.; 
  }
  
  bool useThisKernel() const {
    return theUseThisKernel;
  }
 
public:
 
  double factorizationScaleFactor() const { return theFactorizationScaleFactor; }
 
  void factorizationScaleFactor(double f) { theFactorizationScaleFactor = f; }
 
  double renormalizationScaleFactor() const { return theRenormalizationScaleFactor; }
 
  void renormalizationScaleFactor(double f) { theRenormalizationScaleFactor = f; }
 
  unsigned int cmwScheme() const {return theCMWScheme;}
  
protected:
 
  double alphaPDF(const DipoleSplittingInfo&,
                  Energy optScale = ZERO,
                  double rScaleFactor = 1.0,
                  double fScaleFactor = 1.0) const;
 
  bool virtualitySplittingScale() const { return theVirtualitySplittingScale; }
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
private:
 
  Ptr<AlphaSBase>::ptr theAlphaS;
 
  Energy theScreeningScale;
 
  Ptr<DipoleSplittingKinematics>::ptr theSplittingKinematics;
 
  Ptr<PDFRatio>::ptr thePDFRatio;
 
  unsigned long thePresamplingPoints;
 
  unsigned long theMaxtry;
  
  static double theMaxPDFRatio;
  
  unsigned long theFreezeGrid;
 
  double theDetuning;
 
  PDPtr theFlavour;
 
  Ptr<DipoleMCCheck>::ptr theMCCheck;
 
  bool theStrictLargeN;
 
  double theFactorizationScaleFactor;
 
  double theRenormalizationScaleFactor;
 
  Energy theRenormalizationScaleFreeze;
 
  Energy theFactorizationScaleFreeze;
 
  bool theVirtualitySplittingScale;
 
  unsigned int theCMWScheme=0;
 
  mutable map<double,double> theAlphaSCache;
 
  mutable map<double,double> thePDFCache;
 
  bool presampling;
 
  bool theUseThisKernel = true;
 
  
private:
 
  static AbstractClassDescription<DipoleSplittingKernel> initDipoleSplittingKernel;
 
  DipoleSplittingKernel & operator=(const DipoleSplittingKernel &) = delete;
 
};
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<Herwig::DipoleSplittingKernel,1> {
  typedef HandlerBase NthBase;
};
 
template <>
struct ClassTraits<Herwig::DipoleSplittingKernel>
  : public ClassTraitsBase<Herwig::DipoleSplittingKernel> {
  static string className() { return "Herwig::DipoleSplittingKernel"; }
  static string library() { return "HwDipoleShower.so"; }
};
 
}
 
#endif /* HERWIG_DipoleSplittingKernel_H */