ShowerApproximation.h

// -*- C++ -*-
//
// ShowerApproximation.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_ShowerApproximation_H
#define Herwig_ShowerApproximation_H
//
// This is the declaration of the ShowerApproximation class.
//
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Handlers/StandardXComb.h"
#include "Herwig/MatrixElement/Matchbox/Dipoles/SubtractionDipole.fh"
#include "Herwig/MatrixElement/Matchbox/Utility/ColourBasis.h"
#include "Herwig/MatrixElement/Matchbox/Phasespace/TildeKinematics.fh"
#include "Herwig/MatrixElement/Matchbox/Phasespace/InvertedTildeKinematics.fh"
#include "HardScaleProfile.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class ShowerApproximation: public HandlerBase {
 
public:
 
  ShowerApproximation();
 
public:
 
  virtual bool needsSplittingGenerator() const { return false; }
 
  virtual bool hasHEvents() const { return true; }
 
  virtual bool needsTildeXCombs() const { return false; }
 
  virtual bool needsTruncatedShower() const { return false; }
 
  virtual Ptr<TildeKinematics>::tptr showerTildeKinematics() const;
 
  virtual Ptr<InvertedTildeKinematics>::tptr showerInvertedTildeKinematics() const;
 
public:
 
  void setBornXComb(tStdXCombPtr xc) { theBornXComb = xc; }
 
  tStdXCombPtr bornXComb() const { return theBornXComb; }
 
  tcStdXCombPtr bornCXComb() const { return theBornXComb; }
 
  void setRealXComb(tStdXCombPtr xc) { theRealXComb = xc; }
 
  tStdXCombPtr realXComb() const { return theRealXComb; }
 
  tcStdXCombPtr realCXComb() const { return theRealXComb; }
 
  void setTildeXCombs(const vector<StdXCombPtr>& xc) { theTildeXCombs = xc; }
 
  const vector<StdXCombPtr>& tildeXCombs() const { return theTildeXCombs; }
 
  void setDipole(Ptr<SubtractionDipole>::tptr);
 
  Ptr<SubtractionDipole>::tptr dipole() const;
 
  virtual bool hasSpinCorrelations() const { return false; }
 
public:
 
  bool belowCutoff() const { return theBelowCutoff; }
 
  void wasBelowCutoff() { theBelowCutoff = true; }
 
  void resetBelowCutoff() { theBelowCutoff = false; }
 
  Energy ffPtCut() const { return theFFPtCut; }
 
  Energy fiPtCut() const { return theFIPtCut; }
 
  Energy iiPtCut() const { return theIIPtCut; }
 
  Energy safeCut() const { return theSafeCut;}
 
  Energy ffScreeningScale() const { return theFFScreeningScale; }
 
  Energy fiScreeningScale() const { return theFIScreeningScale; }
 
  Energy iiScreeningScale() const { return theIIScreeningScale; }
 
  virtual Energy2 showerEmissionScale() const;
 
  Energy2 showerRenormalizationScale() const {
    return sqr(renormalizationScaleFactor())*showerEmissionScale();
  }
 
  Energy2 showerFactorizationScale() const {
    return sqr(factorizationScaleFactor())*showerEmissionScale();
  }
 
  Energy2 bornRenormalizationScale() const;
 
  Energy2 bornFactorizationScale() const;
 
  Energy2 realRenormalizationScale() const;
 
  Energy2 realFactorizationScale() const;
 
  enum ScaleChoices {
 
    bornScale = 0,
    realScale = 1,
    showerScale = 2
  };
 
  int realEmissionScaleInSubtraction() const { return theRealEmissionScaleInSubtraction; }
 
  int bornScaleInSubtraction() const { return theBornScaleInSubtraction; }
 
  int emissionScaleInSubtraction() const { return theEmissionScaleInSubtraction; }
 
  int realEmissionScaleInSplitting() const { return theRealEmissionScaleInSplitting; }
 
  int bornScaleInSplitting() const { return theBornScaleInSplitting; }
 
  int emissionScaleInSplitting() const { return theEmissionScaleInSplitting; }
 
  double scaleWeight(int rScale, int bScale, int eScale) const;
 
  double subtractionScaleWeight() const {
    return scaleWeight(realEmissionScaleInSubtraction(),
                       bornScaleInSubtraction(),
                       emissionScaleInSubtraction());
  }
 
  double splittingScaleWeight() const {
    return scaleWeight(realEmissionScaleInSplitting(),
                       bornScaleInSplitting(),
                       emissionScaleInSplitting());
  }
 
public:
 
  bool restrictPhasespace() const { return theRestrictPhasespace; }
 
  void restrictPhasespace(bool yes) { theRestrictPhasespace = yes; }
 
  Ptr<HardScaleProfile>::tptr profileScales() const { return theHardScaleProfile; }
 
  void profileScales(Ptr<HardScaleProfile>::ptr prof) { theHardScaleProfile = prof; }
 
  bool hardScaleIsMuF() const { return maxPtIsMuF; }
 
  void hardScaleIsMuF(bool yes) { maxPtIsMuF = yes; }
 
  double hardScaleFactor() const { return theHardScaleFactor; }
 
  void hardScaleFactor(double f) { theHardScaleFactor = f; }
 
  double factorizationScaleFactor() const { return theFactorizationScaleFactor; }
 
  double renormalizationScaleFactor() const { return theRenormalizationScaleFactor; }
 
  void factorizationScaleFactor(double f) { theFactorizationScaleFactor = f; }
 
  void renormalizationScaleFactor(double f) { theRenormalizationScaleFactor = f; }
 
  virtual void checkCutoff();
 
  virtual void getShowerVariables();
 
  virtual CrossSection dSigHatDR() const = 0;
 
  virtual double me2() const = 0;
 
  double bornPDFWeight(Energy2 muF) const;
 
  double realPDFWeight(Energy2 muF) const;
 
protected:
 
  virtual bool isInShowerPhasespace() const;
 
  virtual bool isAboveCutoff() const;
 
  virtual Energy hardScale() const;
 
  void useOpenZ(bool yes) { theOpenZ = yes; }
 
  bool openZ() const { return theOpenZ; }
 
public:
 
  virtual double channelWeight(int emitter, int emission, 
                               int spectator, int bemitter) const;
 
  virtual double channelWeight() const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
 
protected:
 
  virtual void doinit();
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
public:
 
  Ptr<ColourBasis>::tptr largeNBasis() const { return theLargeNBasis; }
 
protected:
 
  Ptr<ColourBasis>::ptr theLargeNBasis;
 
  void setLargeNBasis();
 
  double theExtrapolationX;
 
private:
 
  tStdXCombPtr theBornXComb;
 
  tStdXCombPtr theRealXComb;
 
  vector<StdXCombPtr> theTildeXCombs;
 
  Ptr<SubtractionDipole>::tptr theDipole;
 
  bool theBelowCutoff;
 
  Energy theFFPtCut;
 
  Energy theFFScreeningScale;
 
  Energy theFIPtCut;
 
  Energy theFIScreeningScale;
 
  Energy theIIPtCut;
 
  Energy theIIScreeningScale;
 
  Energy theSafeCut;
 
  bool theRestrictPhasespace;
 
  double theHardScaleFactor;
 
  double theRenormalizationScaleFactor;
 
  double theFactorizationScaleFactor;
 
  int theRealEmissionScaleInSubtraction;
 
  int theBornScaleInSubtraction;
 
  int theEmissionScaleInSubtraction;
 
  int theRealEmissionScaleInSplitting;
 
  int theBornScaleInSplitting;
 
  int theEmissionScaleInSplitting;
 
  Energy theRenormalizationScaleFreeze;
 
  Energy theFactorizationScaleFreeze;
 
  bool maxPtIsMuF;
 
  Ptr<HardScaleProfile>::ptr theHardScaleProfile;
 
  bool theOpenZ;
 
private:
 
  ShowerApproximation & operator=(const ShowerApproximation &) = delete;
 
};
 
}
 
#endif /* Herwig_ShowerApproximation_H */