diff --git a/Shower/QTilde/Makefile.am b/Shower/QTilde/Makefile.am --- a/Shower/QTilde/Makefile.am +++ b/Shower/QTilde/Makefile.am @@ -1,50 +1,51 @@ SUBDIRS = Matching pkglib_LTLIBRARIES = HwShower.la HwShower_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 27:0:0 HwShower_la_SOURCES = \ Couplings/ShowerAlphaQCD.h Couplings/ShowerAlphaQCD.cc \ Couplings/ShowerAlphaQED.h Couplings/ShowerAlphaQED.cc\ QTildeShowerHandler.h QTildeShowerHandler.fh QTildeShowerHandler.cc \ SplittingFunctions/HalfHalfOneSplitFn.h SplittingFunctions/HalfHalfOneSplitFn.cc\ SplittingFunctions/HalfHalfOneEWSplitFn.h SplittingFunctions/HalfHalfOneEWSplitFn.cc\ SplittingFunctions/HalfHalfZeroEWSplitFn.h SplittingFunctions/HalfHalfZeroEWSplitFn.cc\ SplittingFunctions/OneOneOneEWSplitFn.h SplittingFunctions/OneOneOneEWSplitFn.cc\ +SplittingFunctions/OneOneOneQEDSplitFn.h SplittingFunctions/OneOneOneQEDSplitFn.cc\ SplittingFunctions/OneOneZeroEWSplitFn.h SplittingFunctions/OneOneZeroEWSplitFn.cc\ SplittingFunctions/OneOneOneSplitFn.h SplittingFunctions/OneOneOneSplitFn.cc\ SplittingFunctions/OneOneOneMassiveSplitFn.h SplittingFunctions/OneOneOneMassiveSplitFn.cc\ SplittingFunctions/ZeroZeroOneSplitFn.h SplittingFunctions/ZeroZeroOneSplitFn.cc\ SplittingFunctions/OneHalfHalfSplitFn.h SplittingFunctions/OneHalfHalfSplitFn.cc\ SplittingFunctions/HalfOneHalfSplitFn.h SplittingFunctions/HalfOneHalfSplitFn.cc\ SplittingFunctions/CMWOneOneOneSplitFn.h SplittingFunctions/CMWOneOneOneSplitFn.cc\ SplittingFunctions/CMWHalfHalfOneSplitFn.h SplittingFunctions/CMWHalfHalfOneSplitFn.cc\ Kinematics/Decay_QTildeShowerKinematics1to2.cc \ Kinematics/Decay_QTildeShowerKinematics1to2.h \ Kinematics/IS_QTildeShowerKinematics1to2.cc Kinematics/IS_QTildeShowerKinematics1to2.h \ Kinematics/FS_QTildeShowerKinematics1to2.cc Kinematics/FS_QTildeShowerKinematics1to2.h \ Kinematics/KinematicHelpers.h \ Kinematics/KinematicsReconstructor.cc \ Kinematics/KinematicsReconstructor.tcc \ Kinematics/KinematicsReconstructor.h \ Kinematics/KinematicsReconstructor.fh \ Base/HardTree.cc Base/HardTree.h Base/HardTree.fh \ Base/HardBranching.h Base/HardBranching.fh Base/HardBranching.cc\ Base/PartnerFinder.h Base/PartnerFinder.fh Base/PartnerFinder.cc \ Base/ShowerVeto.h Base/ShowerVeto.fh Base/ShowerVeto.cc \ Base/FullShowerVeto.h Base/FullShowerVeto.fh Base/FullShowerVeto.cc \ SplittingFunctions/SplittingGenerator.cc SplittingFunctions/SplittingGenerator.h\ SplittingFunctions/SplittingGenerator.fh \ Base/ShowerTree.h Base/ShowerTree.fh Base/ShowerTree.cc \ ShowerConfig.h ShowerConfig.cc \ Base/Branching.h \ Base/ShowerParticle.cc Base/ShowerParticle.fh Base/ShowerParticle.h \ Kinematics/ShowerKinematics.fh Kinematics/ShowerKinematics.h Kinematics/ShowerKinematics.cc \ Kinematics/ShowerBasis.fh Kinematics/ShowerBasis.h Kinematics/ShowerBasis.cc \ Base/ShowerProgenitor.fh Base/ShowerProgenitor.h \ SplittingFunctions/SudakovFormFactor.cc SplittingFunctions/SudakovFormFactor.h SplittingFunctions/SudakovFormFactor.fh \ SplittingFunctions/SudakovCutOff.cc SplittingFunctions/SudakovCutOff.h SplittingFunctions/SudakovCutOff.fh \ SplittingFunctions/PTCutOff.cc SplittingFunctions/PTCutOff.h \ SplittingFunctions/MassCutOff.cc SplittingFunctions/MassCutOff.h \ SplittingFunctions/VariableMassCutOff.cc SplittingFunctions/VariableMassCutOff.h \ SplittingFunctions/SplittingFunction.h SplittingFunctions/SplittingFunction.fh \ SplittingFunctions/SplittingFunction.cc \ Base/ShowerVertex.cc Base/ShowerVertex.fh Base/ShowerVertex.h diff --git a/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.cc b/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.cc new file mode 100644 --- /dev/null +++ b/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.cc @@ -0,0 +1,236 @@ +// -*- C++ -*- +// +// This is the implementation of the non-inlined, non-templated member +// functions of the OneOneOneQEDSplitFn class. +// + +#include "OneOneOneQEDSplitFn.h" +#include "ThePEG/StandardModel/StandardModelBase.h" +#include "ThePEG/Repository/EventGenerator.h" +#include "ThePEG/Interface/ClassDocumentation.h" +#include "ThePEG/Utilities/DescribeClass.h" +#include "ThePEG/Persistency/PersistentOStream.h" +#include "ThePEG/Persistency/PersistentIStream.h" +#include "ThePEG/PDT/ParticleData.h" +#include "Herwig/Decay/TwoBodyDecayMatrixElement.h" +#include "Herwig/Models/StandardModel/SMFFHVertex.h" + +using namespace Herwig; + +IBPtr OneOneOneQEDSplitFn::clone() const { + return new_ptr(*this); +} + +IBPtr OneOneOneQEDSplitFn::fullclone() const { + return new_ptr(*this); +} + +void OneOneOneQEDSplitFn::persistentOutput(PersistentOStream & os) const { + os << gWWG_ << _theSM; +} + +void OneOneOneQEDSplitFn::persistentInput(PersistentIStream & is, int) { + is >> gWWG_ >> _theSM; +} + +// The following static variable is needed for the type description system in ThePEG. +DescribeClass +describeHerwigOneOneOneQEDSplitFn("Herwig::OneOneOneQEDSplitFn", "HwShower.so"); + + +void OneOneOneQEDSplitFn::Init() { + + static ClassDocumentation documentation + ("The OneOneOneQEDSplitFn class implements the gamma->WW EW splitting."); + +} + + +void OneOneOneQEDSplitFn::doinit() { + SplittingFunction::doinit(); + tcSMPtr sm = generator()->standardModel(); + double sw2 = sm->sin2ThetaW(); + // WWG coupling + gWWG_ = 1.; + // to employ running masses, wherever needed + _theSM = dynamic_ptr_cast(generator()->standardModel()); +} + + +void OneOneOneQEDSplitFn::getCouplings(double & gvvv, const IdList & ids) const { + // G > WW + if(ids[0]->id()==ParticleID::gamma && abs(ids[1]->id())==ParticleID::Wplus + && abs(ids[2]->id())==ParticleID::Wplus){ + gvvv = gWWG_; + } + else + assert(false); +} + + +double OneOneOneQEDSplitFn::P(const double z, const Energy2 t, + const IdList &ids, const bool mass, const RhoDMatrix & rho) const { + double gvvv(0.); + getCouplings(gvvv,ids); + double abs_rho_00 = abs(rho(0,0)); + double abs_rho_11 = abs(rho(1,1)); + double abs_rho_22 = abs(rho(2,2)); + // massless limit + double val = ((2.*sqr(1.-(1.-z)*z))/((1.-z)*z))*(abs_rho_00+abs_rho_22); + // massive limits + if(mass) { + double m0t2 = sqr(getParticleData(ids[0]->id())->mass())/t; + double m1t2 = sqr(getParticleData(ids[1]->id())->mass())/t; + double m2t2 = sqr(getParticleData(ids[2]->id())->mass())/t; + val += (-2.*(m2t2*(1.-sqr(1.-z)*z)+m1t2*(1.-(1.-z)*sqr(z)))*(abs_rho_00+abs_rho_22))/((1.-z)*z) + + (2.*m0t2*(2.*pow(1.-z,3)*z*abs_rho_11+sqr(1.-(1.-z)*z)*(abs_rho_00+abs_rho_22)))/((1.-z)*z); + } + return sqr(gvvv)*val; +} + + +double OneOneOneQEDSplitFn::overestimateP(const double z, + const IdList & ids) const { + double gvvv(0.); + getCouplings(gvvv,ids); + return sqr(gvvv)*(2./(z*(1.-z))); +} + + +double OneOneOneQEDSplitFn::ratioP(const double z, const Energy2 t, + const IdList & ids, const bool mass, + const RhoDMatrix & rho) const { + double val(0.); + double abs_rho_00 = abs(rho(0,0)); + double abs_rho_11 = abs(rho(1,1)); + double abs_rho_22 = abs(rho(2,2)); + // massless limit + val = sqr(1.-(1.-z)*z)*(abs_rho_00+abs_rho_22); + // massive limit + if(mass) { + double m0t2 = sqr(getParticleData(ids[0]->id())->mass())/t; + double m1t2 = sqr(getParticleData(ids[1]->id())->mass())/t; + double m2t2 = sqr(getParticleData(ids[2]->id())->mass())/t; + val += -(m2t2*(1.-sqr(1.-z)*z) + m1t2*(1.-(1.-z)*sqr(z)))*(abs_rho_00+abs_rho_22) + + m0t2*(2.*pow(1.-z,3)*z*abs_rho_11+sqr(1.-(1.-z)*z)*(abs_rho_00+abs_rho_22)); + } + return val; +} + + +double OneOneOneQEDSplitFn::integOverP(const double z, + const IdList & ids, + unsigned int PDFfactor) const { + double gvvv(0.); + getCouplings(gvvv,ids); + double pre = sqr(gvvv); + switch (PDFfactor) { + case 0: + return 2.*pre*(log(z)-log(1.-z)); + case 1: + //return -2.*pre*(1./z+log(1.-z)-log(z)); + case 2: + //return 2.*pre*(2.*log(z)+(2.*z-1.)/(z*(1.-z))-2.*log(1.-z)); + case 3: + //return 2.*pre*(1./(1.-z)-1./z-2.*log(1.-z)+2.*log(z)); + default: + throw Exception() << "OneOneOneQEDSplitFn::integOverP() invalid PDFfactor = " + << PDFfactor << Exception::runerror; + } +} + +double OneOneOneQEDSplitFn::invIntegOverP(const double r, const IdList & ids, + unsigned int PDFfactor) const { + double gvvv(0.); + getCouplings(gvvv,ids); + double pre = sqr(gvvv); + switch (PDFfactor) { + case 0: + return exp(0.5*r/pre)/(1.+exp(0.5*r/pre)); + case 1: + case 2: + case 3: + default: + throw Exception() << "OneOneOneQEDSplitFn::invIntegOverP() invalid PDFfactor = " + << PDFfactor << Exception::runerror; + } +} + +bool OneOneOneQEDSplitFn::accept(const IdList &ids) const { + if(ids.size()!=3) return false; + if(ids[0]->id()==ParticleID::gamma && abs(ids[1]->id())==ParticleID::Wplus + && ids[1]->id()==-ids[2]->id()) + return true; + return false; +} + + +vector > +OneOneOneQEDSplitFn::generatePhiForward(const double, const Energy2, const IdList & , + const RhoDMatrix &) { + // no dependence on the spin density matrix, dependence on off-diagonal terms cancels + // and rest = splitting function for Tr(rho)=1 as required by defn + return vector >(1,make_pair(0,1.)); +} + + +vector > +OneOneOneQEDSplitFn::generatePhiBackward(const double, const Energy2, const IdList & , + const RhoDMatrix &) { + // no dependence on the spin density matrix, dependence on off-diagonal terms cancels + // and rest = splitting function for Tr(rho)=1 as required by defn + return vector >(1,make_pair(0,1.)); +} + + +DecayMEPtr OneOneOneQEDSplitFn::matrixElement(const double z, const Energy2 t, + const IdList & ids, const double phi, + bool) { + // calculate the kernal + DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin1))); + double gvvv(0.); + getCouplings(gvvv,ids); + // defining dummies + double m0t = ids[0]->mass()/sqrt(t); + double m1t = ids[1]->mass()/sqrt(t); + double m2t = ids[2]->mass()/sqrt(t); + Complex phase = exp(Complex(0.,1.)*phi); + Complex cphase = conj(phase); + + double z1_z = z*(1.-z); + double sqrtmass = sqrt(sqr(m0t)-sqr(m1t)/z-sqr(m2t)/(1.-z)+1.); + double r2 = sqrt(2.); + // assign kernel + (*kernal)(0,0,0) = gvvv*phase*(1./sqrt(z1_z))*sqrtmass; + (*kernal)(0,0,1) = gvvv*r2*m2t*(z/(1.-z)); //2>4 + (*kernal)(0,0,2) = -gvvv*cphase*sqrt(z/(1.-z))*sqrtmass; + (*kernal)(0,1,0) = -gvvv*r2*m1t*(1.-z)/z; //2>4 + (*kernal)(0,1,1) = 0.; + (*kernal)(0,1,2) = 0.; + (*kernal)(0,2,0) = -gvvv*(1.-z)*cphase*sqrt((1.-z)/z)*sqrtmass; + (*kernal)(0,2,1) = 0.; + (*kernal)(0,2,2) = 0.; + + (*kernal)(1,0,0) = 0.; + (*kernal)(1,0,1) = 0.; //2>4 + (*kernal)(1,0,2) = -gvvv*r2*m0t*(1.-z); //2>4 + (*kernal)(1,1,0) = 0.; //221>441 + (*kernal)(1,1,1) = 0.; //222>444 + (*kernal)(1,1,2) = 0.; //223>443 + (*kernal)(1,2,0) = -gvvv*r2*m0t*(1.-z); //2>4 + (*kernal)(1,2,1) = 0.; //2>4 + (*kernal)(1,2,2) = 0.; //2>4 + + (*kernal)(2,0,0) = 0.; + (*kernal)(2,0,1) = 0.; + (*kernal)(2,0,2) = gvvv*(1.-z)*phase*sqrt((1.-z)/z)*sqrtmass; + (*kernal)(2,1,0) = 0.; + (*kernal)(2,1,1) = 0.; //2>4 + (*kernal)(2,1,2) = -gvvv*r2*m1t*((1.-z)/z);//2>4 + (*kernal)(2,2,0) = gvvv*phase*sqrt(z/(1.-z))*sqrtmass; + (*kernal)(2,2,1) = gvvv*r2*m2t*(z/(1.-z)); //2>4 + (*kernal)(2,2,2) = -gvvv*cphase*(1./sqrt(z1_z))*sqrtmass; + + // return the answer + return kernal; +} diff --git a/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.h b/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.h new file mode 100644 --- /dev/null +++ b/Shower/QTilde/SplittingFunctions/OneOneOneQEDSplitFn.h @@ -0,0 +1,212 @@ +// -*- C++ -*- +#ifndef Herwig_OneOneOneQEDSplitFn_H +#define Herwig_OneOneOneQEDSplitFn_H +// +// This is the declaration of the OneOneOneQEDSplitFn class. +// + +#include "SplittingFunction.h" +#include "Herwig/Models/StandardModel/StandardModel.h" + +namespace Herwig { + +using namespace ThePEG; + +/** + * The OneOneOneQEDSplitFn class implements the splitting function for + * \f$\1\to q\1 1\f$ where the spin-1 particles are massive electroweak gauge bosons. + * + * @see \ref OneOneOneQEDSplitFnInterfaces "The interfaces" + * defined for OneOneOneQEDSplitFn. + */ +class OneOneOneQEDSplitFn: public SplittingFunction { + +public: + + /** + * Concrete implementation of the method to determine whether this splitting + * function can be used for a given set of particles. + * @param ids The PDG codes for the particles in the splitting. + */ + virtual bool accept(const IdList & ids) const; + + /** + * Methods to return the splitting function. + */ + //@{ + /** + * The concrete implementation of the splitting function, \f$P(z,t)\f$. + * @param z The energy fraction. + * @param t The scale. + * @param ids The PDG codes for the particles in the splitting. + * @param mass Whether or not to include the mass dependent terms + * @param rho The spin density matrix + */ + virtual double P(const double z, const Energy2 t, const IdList & ids, + const bool mass, const RhoDMatrix & rho) const; + + /** + * The concrete implementation of the overestimate of the splitting function, + * \f$P_{\rm over}\f$. + * @param z The energy fraction. + * @param ids The PDG codes for the particles in the splitting. + */ + virtual double overestimateP(const double z, const IdList & ids) const; + + /** + * The concrete implementation of the + * the ratio of the splitting function to the overestimate, i.e. + * \f$P(z,t)/P_{\rm over}(z)\f$. + * @param z The energy fraction. + * @param t The scale. + * @param ids The PDG codes for the particles in the splitting. + * @param mass Whether or not to include the mass dependent terms + * @param rho The spin density matrix + */ + virtual double ratioP(const double z, const Energy2 t, const IdList & ids, + const bool mass, const RhoDMatrix & rho) const; + + /** + * The concrete implementation of the indefinite integral of the + * overestimated splitting function, \f$P_{\rm over}\f$. + * @param z The energy fraction. + * @param ids The PDG codes for the particles in the splitting. + * @param PDFfactor Which additional factor to include for the PDF + * 0 is no additional factor, + * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$ + */ + virtual double integOverP(const double z, const IdList & ids, + unsigned int PDFfactor=0) const; + + /** + * The concrete implementation of the inverse of the indefinite integral. + * @param r Value of the splitting function to be inverted + * @param ids The PDG codes for the particles in the splitting. + * @param PDFfactor Which additional factor to include for the PDF + * 0 is no additional factor, + * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$ + */ + virtual double invIntegOverP(const double r, const IdList & ids, + unsigned int PDFfactor=0) const; + //@} + + /** + * Method to calculate the azimuthal angle + * @param z The energy fraction + * @param t The scale \f$t=2p_j\cdot p_k\f$. + * @param ids The PDG codes for the particles in the splitting. + * @param The azimuthal angle, \f$\phi\f$. + * @return The weight + */ + virtual vector > + generatePhiForward(const double z, const Energy2 t, const IdList & ids, + const RhoDMatrix &); + + /** + * Method to calculate the azimuthal angle for backward evolution + * @param z The energy fraction + * @param t The scale \f$t=2p_j\cdot p_k\f$. + * @param ids The PDG codes for the particles in the splitting. + * @param The azimuthal angle, \f$\phi\f$. + * @return The weight + */ + virtual vector > + generatePhiBackward(const double z, const Energy2 t, const IdList & ids, + const RhoDMatrix &); + + /** + * Calculate the matrix element for the splitting + * @param z The energy fraction + * @param t The scale \f$t=2p_j\cdot p_k\f$. + * @param ids The PDG codes for the particles in the splitting. + * @param The azimuthal angle, \f$\phi\f$. + */ + virtual DecayMEPtr matrixElement(const double z, const Energy2 t, + const IdList & ids, const double phi, bool timeLike); + +protected: + + /** + * Get the couplings + */ + void getCouplings(double & gvvv, const IdList & ids) const; + +public: + + /** @name Functions used by the persistent I/O system. */ + //@{ + /** + * Function used to write out object persistently. + * @param os the persistent output stream written to. + */ + void persistentOutput(PersistentOStream & os) const; + + /** + * Function used to read in object persistently. + * @param is the persistent input stream read from. + * @param version the version number of the object when written. + */ + void persistentInput(PersistentIStream & is, int version); + //@} + + /** + * The standard Init function used to initialize the interfaces. + * Called exactly once for each class by the class description system + * before the main function starts or + * when this class is dynamically loaded. + */ + static void Init(); + +protected: + + /** @name Clone Methods. */ + //@{ + /** + * Make a simple clone of this object. + * @return a pointer to the new object. + */ + virtual IBPtr clone() const; + + /** Make a clone of this object, possibly modifying the cloned object + * to make it sane. + * @return a pointer to the new object. + */ + virtual IBPtr fullclone() const; + //@} + +protected: + + /** @name Standard Interfaced functions. */ + //@{ + /** + * Initialize this object after the setup phase before saving an + * EventGenerator to disk. + * @throws InitException if object could not be initialized properly. + */ + virtual void doinit(); + //@} + +private: + + /** + * The assignment operator is private and must never be called. + * In fact, it should not even be implemented. + */ + OneOneOneQEDSplitFn & operator=(const OneOneOneQEDSplitFn &) = delete; + +private: + + /** + * W^{\pm} -> W^{\pm} G couplings + */ + double gWWG_; + + /** + * Pointer to the SM object. + */ + tcHwSMPtr _theSM; +}; + +} + +#endif /* Herwig_OneOneOneQEDSplitFn_H */ diff --git a/src/defaults/Shower.in b/src/defaults/Shower.in --- a/src/defaults/Shower.in +++ b/src/defaults/Shower.in @@ -1,406 +1,416 @@ # -*- ThePEG-repository -*- ############################################################ # Setup of default parton shower # # Useful switches for users are marked near the top of # this file. # # Don't edit this file directly, but reset the switches # in your own input files! ############################################################ library HwMPI.so library HwShower.so library HwMatching.so mkdir /Herwig/Shower cd /Herwig/Shower create Herwig::QTildeShowerHandler ShowerHandler newdef ShowerHandler:MPIHandler /Herwig/UnderlyingEvent/MPIHandler newdef ShowerHandler:RemDecayer /Herwig/Partons/RemnantDecayer # use LO PDFs for Shower, can be changed later newdef ShowerHandler:PDFA /Herwig/Partons/ShowerLOPDF newdef ShowerHandler:PDFB /Herwig/Partons/ShowerLOPDF newdef ShowerHandler:PDFARemnant /Herwig/Partons/RemnantPDF newdef ShowerHandler:PDFBRemnant /Herwig/Partons/RemnantPDF ##################################### # initial setup, don't change these! ##################################### create Herwig::SplittingGenerator SplittingGenerator create Herwig::ShowerAlphaQCD AlphaQCD create Herwig::ShowerAlphaQED AlphaQED set AlphaQED:CouplingSource Thompson create Herwig::ShowerAlphaQED AlphaEW set AlphaEW:CouplingSource MZ create Herwig::PartnerFinder PartnerFinder newdef PartnerFinder:PartnerMethod 0 newdef PartnerFinder:ScaleChoice 0 create Herwig::KinematicsReconstructor KinematicsReconstructor newdef KinematicsReconstructor:ReconstructionOption Colour3 newdef KinematicsReconstructor:InitialStateReconOption SofterFraction newdef KinematicsReconstructor:InitialInitialBoostOption LongTransBoost newdef KinematicsReconstructor:FinalFinalWeight Yes newdef /Herwig/Partons/RemnantDecayer:AlphaS AlphaQCD newdef /Herwig/Partons/RemnantDecayer:AlphaEM AlphaQED newdef ShowerHandler:PartnerFinder PartnerFinder newdef ShowerHandler:KinematicsReconstructor KinematicsReconstructor newdef ShowerHandler:SplittingGenerator SplittingGenerator newdef ShowerHandler:Interactions QEDQCD newdef ShowerHandler:SpinCorrelations Yes newdef ShowerHandler:SoftCorrelations Singular ################################################################## # Intrinsic pT # # Recommended: # 1.9 GeV for Tevatron W/Z production. # 2.1 GeV for LHC W/Z production at 10 TeV # 2.2 GeV for LHC W/Z production at 14 TeV # # Set all parameters to 0 to disable ################################################################## newdef ShowerHandler:IntrinsicPtGaussian 2.2*GeV newdef ShowerHandler:IntrinsicPtBeta 0 newdef ShowerHandler:IntrinsicPtGamma 0*GeV newdef ShowerHandler:IntrinsicPtIptmax 0*GeV ############################################################# # Set up truncated shower handler. ############################################################# create Herwig::PowhegShowerHandler PowhegShowerHandler set PowhegShowerHandler:MPIHandler /Herwig/UnderlyingEvent/MPIHandler set PowhegShowerHandler:RemDecayer /Herwig/Partons/RemnantDecayer newdef PowhegShowerHandler:PDFA /Herwig/Partons/ShowerLOPDF newdef PowhegShowerHandler:PDFB /Herwig/Partons/ShowerLOPDF newdef PowhegShowerHandler:PDFARemnant /Herwig/Partons/RemnantPDF newdef PowhegShowerHandler:PDFBRemnant /Herwig/Partons/RemnantPDF newdef PowhegShowerHandler:MPIHandler /Herwig/UnderlyingEvent/MPIHandler newdef PowhegShowerHandler:RemDecayer /Herwig/Partons/RemnantDecayer newdef PowhegShowerHandler:PDFA /Herwig/Partons/ShowerLOPDF newdef PowhegShowerHandler:PDFB /Herwig/Partons/ShowerLOPDF newdef PowhegShowerHandler:PDFARemnant /Herwig/Partons/RemnantPDF newdef PowhegShowerHandler:PDFBRemnant /Herwig/Partons/RemnantPDF newdef PowhegShowerHandler:PartnerFinder PartnerFinder newdef PowhegShowerHandler:KinematicsReconstructor KinematicsReconstructor newdef PowhegShowerHandler:SplittingGenerator SplittingGenerator newdef PowhegShowerHandler:Interactions QEDQCD newdef PowhegShowerHandler:SpinCorrelations Yes newdef PowhegShowerHandler:SoftCorrelations Singular newdef PowhegShowerHandler:IntrinsicPtGaussian 2.2*GeV newdef PowhegShowerHandler:IntrinsicPtBeta 0 newdef PowhegShowerHandler:IntrinsicPtGamma 0*GeV newdef PowhegShowerHandler:IntrinsicPtIptmax 0*GeV newdef PowhegShowerHandler:EvolutionScheme DotProduct ############################################################# # End of interesting user servicable section. # # Anything that follows below should only be touched if you # know what you're doing. # # Really. ############################################################# # # a few default values newdef ShowerHandler:MECorrMode 1 newdef ShowerHandler:EvolutionScheme DotProduct newdef AlphaQCD:ScaleFactor 1.0 newdef AlphaQCD:NPAlphaS 2 newdef AlphaQCD:Qmin 0.935 newdef AlphaQCD:NumberOfLoops 2 newdef AlphaQCD:AlphaIn 0.1186 # # # Lets set up all the splittings create Herwig::HalfHalfOneSplitFn QtoQGammaSplitFn set QtoQGammaSplitFn:InteractionType QED set QtoQGammaSplitFn:ColourStructure ChargedChargedNeutral set QtoQGammaSplitFn:AngularOrdered Yes set QtoQGammaSplitFn:StrictAO Yes create Herwig::HalfHalfOneSplitFn QtoQGSplitFn newdef QtoQGSplitFn:InteractionType QCD newdef QtoQGSplitFn:ColourStructure TripletTripletOctet set QtoQGSplitFn:AngularOrdered Yes set QtoQGSplitFn:StrictAO Yes create Herwig::OneOneOneSplitFn GtoGGSplitFn newdef GtoGGSplitFn:InteractionType QCD newdef GtoGGSplitFn:ColourStructure OctetOctetOctet set GtoGGSplitFn:AngularOrdered Yes set GtoGGSplitFn:StrictAO Yes create Herwig::OneOneOneMassiveSplitFn WtoWGammaSplitFn newdef WtoWGammaSplitFn:InteractionType QED newdef WtoWGammaSplitFn:ColourStructure ChargedChargedNeutral set WtoWGammaSplitFn:AngularOrdered Yes set WtoWGammaSplitFn:StrictAO Yes create Herwig::OneHalfHalfSplitFn GtoQQbarSplitFn newdef GtoQQbarSplitFn:InteractionType QCD newdef GtoQQbarSplitFn:ColourStructure OctetTripletTriplet set GtoQQbarSplitFn:AngularOrdered Yes set GtoQQbarSplitFn:StrictAO Yes create Herwig::OneHalfHalfSplitFn GammatoQQbarSplitFn newdef GammatoQQbarSplitFn:InteractionType QED newdef GammatoQQbarSplitFn:ColourStructure NeutralChargedCharged set GammatoQQbarSplitFn:AngularOrdered Yes set GammatoQQbarSplitFn:StrictAO Yes create Herwig::HalfOneHalfSplitFn QtoGQSplitFn newdef QtoGQSplitFn:InteractionType QCD newdef QtoGQSplitFn:ColourStructure TripletOctetTriplet set QtoGQSplitFn:AngularOrdered Yes set QtoGQSplitFn:StrictAO Yes create Herwig::HalfOneHalfSplitFn QtoGammaQSplitFn newdef QtoGammaQSplitFn:InteractionType QED newdef QtoGammaQSplitFn:ColourStructure ChargedNeutralCharged set QtoGammaQSplitFn:AngularOrdered Yes set QtoGammaQSplitFn:StrictAO Yes create Herwig::HalfHalfOneEWSplitFn QtoQWZSplitFn newdef QtoQWZSplitFn:InteractionType EW newdef QtoQWZSplitFn:ColourStructure EW create Herwig::HalfHalfZeroEWSplitFn QtoQHSplitFn newdef QtoQHSplitFn:InteractionType EW newdef QtoQHSplitFn:ColourStructure EW create Herwig::OneOneOneEWSplitFn VtoVVSplitFn newdef VtoVVSplitFn:InteractionType EW newdef VtoVVSplitFn:ColourStructure EW +create Herwig::OneOneOneQEDSplitFn GammatoWWSplitFn +newdef GammatoWWSplitFn:InteractionType QED +newdef GammatoWWSplitFn:ColourStructure ChargedNeutralCharged + create Herwig::OneOneZeroEWSplitFn VtoVHSplitFn newdef VtoVHSplitFn:InteractionType EW newdef VtoVHSplitFn:ColourStructure EW # # Now the Sudakovs create Herwig::PTCutOff PTCutOff newdef PTCutOff:pTmin 0.958*GeV create Herwig::SudakovFormFactor SudakovCommon newdef SudakovCommon:Alpha AlphaQCD newdef SudakovCommon:Cutoff PTCutOff newdef SudakovCommon:PDFmax 1.0 cp SudakovCommon QtoQGSudakov newdef QtoQGSudakov:SplittingFunction QtoQGSplitFn newdef QtoQGSudakov:PDFmax 1.9 cp SudakovCommon QtoQGammaSudakov set QtoQGammaSudakov:SplittingFunction QtoQGammaSplitFn set QtoQGammaSudakov:Alpha AlphaQED set QtoQGammaSudakov:PDFmax 1.9 cp QtoQGammaSudakov LtoLGammaSudakov cp PTCutOff LtoLGammaPTCutOff # Technical parameter to stop evolution. set LtoLGammaPTCutOff:pTmin 0.000001 set LtoLGammaSudakov:Cutoff LtoLGammaPTCutOff cp SudakovCommon QtoQWZSudakov set QtoQWZSudakov:SplittingFunction QtoQWZSplitFn set QtoQWZSudakov:Alpha AlphaEW set QtoQWZSudakov:PDFmax 1.9 cp QtoQWZSudakov LtoLWZSudakov cp SudakovCommon QtoQHSudakov set QtoQHSudakov:SplittingFunction QtoQHSplitFn set QtoQHSudakov:Alpha AlphaEW set QtoQHSudakov:PDFmax 1.9 cp QtoQHSudakov LtoLHSudakov cp SudakovCommon VtoVVSudakov set VtoVVSudakov:SplittingFunction VtoVVSplitFn -set VtoVVSudakov:Alpha AlphaEW -set VtoVVSudakov:PDFmax 1.9 +set VtoVVSudakov:Alpha AlphaQED + +cp SudakovCommon GammatoWWSudakov +set GammatoWWSudakov:SplittingFunction GammatoWWSplitFn +set GammatoWWSudakov:Alpha AlphaEW +set GammatoWWSudakov:PDFmax 1.9 + + cp SudakovCommon VtoVHSudakov set VtoVHSudakov:SplittingFunction VtoVHSplitFn set VtoVHSudakov:Alpha AlphaEW set VtoVHSudakov:PDFmax 1.9 cp SudakovCommon GtoGGSudakov newdef GtoGGSudakov:SplittingFunction GtoGGSplitFn newdef GtoGGSudakov:PDFmax 2.0 cp SudakovCommon WtoWGammaSudakov newdef WtoWGammaSudakov:SplittingFunction WtoWGammaSplitFn set WtoWGammaSudakov:Alpha AlphaQED cp SudakovCommon GtoQQbarSudakov newdef GtoQQbarSudakov:SplittingFunction GtoQQbarSplitFn newdef GtoQQbarSudakov:PDFmax 120.0 cp SudakovCommon GammatoQQbarSudakov newdef GammatoQQbarSudakov:SplittingFunction GammatoQQbarSplitFn set GammatoQQbarSudakov:Alpha AlphaQED newdef GammatoQQbarSudakov:PDFmax 120.0 cp SudakovCommon GtobbbarSudakov newdef GtobbbarSudakov:SplittingFunction GtoQQbarSplitFn newdef GtobbbarSudakov:PDFmax 40000.0 cp SudakovCommon GtoccbarSudakov newdef GtoccbarSudakov:SplittingFunction GtoQQbarSplitFn newdef GtoccbarSudakov:PDFmax 2000.0 cp SudakovCommon QtoGQSudakov newdef QtoGQSudakov:SplittingFunction QtoGQSplitFn cp SudakovCommon QtoGammaQSudakov newdef QtoGammaQSudakov:SplittingFunction QtoGammaQSplitFn set QtoGammaQSudakov:Alpha AlphaQED cp SudakovCommon utoGuSudakov newdef utoGuSudakov:SplittingFunction QtoGQSplitFn newdef utoGuSudakov:PDFFactor OverOneMinusZ newdef utoGuSudakov:PDFmax 5.0 cp SudakovCommon dtoGdSudakov newdef dtoGdSudakov:SplittingFunction QtoGQSplitFn newdef dtoGdSudakov:PDFFactor OverOneMinusZ # # Now add the final splittings # do SplittingGenerator:AddFinalSplitting u->u,g; QtoQGSudakov do SplittingGenerator:AddFinalSplitting d->d,g; QtoQGSudakov do SplittingGenerator:AddFinalSplitting s->s,g; QtoQGSudakov do SplittingGenerator:AddFinalSplitting c->c,g; QtoQGSudakov do SplittingGenerator:AddFinalSplitting b->b,g; QtoQGSudakov do SplittingGenerator:AddFinalSplitting t->t,g; QtoQGSudakov # do SplittingGenerator:AddFinalSplitting g->g,g; GtoGGSudakov # do SplittingGenerator:AddFinalSplitting g->u,ubar; GtoQQbarSudakov do SplittingGenerator:AddFinalSplitting g->d,dbar; GtoQQbarSudakov do SplittingGenerator:AddFinalSplitting g->s,sbar; GtoQQbarSudakov do SplittingGenerator:AddFinalSplitting g->c,cbar; GtoccbarSudakov do SplittingGenerator:AddFinalSplitting g->b,bbar; GtobbbarSudakov do SplittingGenerator:AddFinalSplitting g->t,tbar; GtoQQbarSudakov # do SplittingGenerator:AddFinalSplitting gamma->u,ubar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->d,dbar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->s,sbar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->c,cbar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->b,bbar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->t,tbar; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->e-,e+; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->mu-,mu+; GammatoQQbarSudakov do SplittingGenerator:AddFinalSplitting gamma->tau-,tau+; GammatoQQbarSudakov # do SplittingGenerator:AddFinalSplitting u->u,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting d->d,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting s->s,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting c->c,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting b->b,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting t->t,gamma; QtoQGammaSudakov do SplittingGenerator:AddFinalSplitting e-->e-,gamma; LtoLGammaSudakov do SplittingGenerator:AddFinalSplitting mu-->mu-,gamma; LtoLGammaSudakov do SplittingGenerator:AddFinalSplitting tau-->tau-,gamma; LtoLGammaSudakov do SplittingGenerator:AddFinalSplitting W+->W+,gamma; WtoWGammaSudakov # # Now lets add the initial splittings. Remember the form a->b,c; means # that the current particle b is given and we backward branch to new # particle a which is initial state and new particle c which is final state # do SplittingGenerator:AddInitialSplitting u->u,g; QtoQGSudakov do SplittingGenerator:AddInitialSplitting d->d,g; QtoQGSudakov do SplittingGenerator:AddInitialSplitting s->s,g; QtoQGSudakov do SplittingGenerator:AddInitialSplitting c->c,g; QtoQGSudakov do SplittingGenerator:AddInitialSplitting b->b,g; QtoQGSudakov do SplittingGenerator:AddInitialSplitting u->u,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting d->d,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting s->s,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting c->c,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting b->b,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting t->t,gamma; QtoQGammaSudakov do SplittingGenerator:AddInitialSplitting g->g,g; GtoGGSudakov # do SplittingGenerator:AddInitialSplitting g->d,dbar; GtoQQbarSudakov do SplittingGenerator:AddInitialSplitting g->u,ubar; GtoQQbarSudakov do SplittingGenerator:AddInitialSplitting g->s,sbar; GtoQQbarSudakov do SplittingGenerator:AddInitialSplitting g->c,cbar; GtoccbarSudakov do SplittingGenerator:AddInitialSplitting g->b,bbar; GtobbbarSudakov # do SplittingGenerator:AddInitialSplitting gamma->d,dbar; GammatoQQbarSudakov do SplittingGenerator:AddInitialSplitting gamma->u,ubar; GammatoQQbarSudakov do SplittingGenerator:AddInitialSplitting gamma->s,sbar; GammatoQQbarSudakov do SplittingGenerator:AddInitialSplitting gamma->c,cbar; GammatoQQbarSudakov do SplittingGenerator:AddInitialSplitting gamma->b,bbar; GammatoQQbarSudakov # do SplittingGenerator:AddInitialSplitting d->g,d; dtoGdSudakov do SplittingGenerator:AddInitialSplitting u->g,u; utoGuSudakov do SplittingGenerator:AddInitialSplitting s->g,s; QtoGQSudakov do SplittingGenerator:AddInitialSplitting c->g,c; QtoGQSudakov do SplittingGenerator:AddInitialSplitting b->g,b; QtoGQSudakov do SplittingGenerator:AddInitialSplitting dbar->g,dbar; dtoGdSudakov do SplittingGenerator:AddInitialSplitting ubar->g,ubar; utoGuSudakov do SplittingGenerator:AddInitialSplitting sbar->g,sbar; QtoGQSudakov do SplittingGenerator:AddInitialSplitting cbar->g,cbar; QtoGQSudakov do SplittingGenerator:AddInitialSplitting bbar->g,bbar; QtoGQSudakov # do SplittingGenerator:AddInitialSplitting d->gamma,d; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting u->gamma,u; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting s->gamma,s; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting c->gamma,c; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting b->gamma,b; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting dbar->gamma,dbar; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting ubar->gamma,ubar; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting sbar->gamma,sbar; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting cbar->gamma,cbar; QtoGammaQSudakov do SplittingGenerator:AddInitialSplitting bbar->gamma,bbar; QtoGammaQSudakov # # Electroweak # do SplittingGenerator:AddFinalSplitting u->u,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting d->d,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting s->s,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting c->c,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting b->b,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting t->t,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting u->u,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting d->d,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting s->s,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting c->c,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting b->b,Z0; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting t->t,Z0; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting u->d,W+; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting c->s,W+; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting d->u,W-; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting s->c,W-; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting u->d,W+; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting c->s,W+; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting d->u,W-; QtoQWZSudakov do SplittingGenerator:AddInitialSplitting s->c,W-; QtoQWZSudakov do SplittingGenerator:AddFinalSplitting c->c,h0; QtoQHSudakov do SplittingGenerator:AddFinalSplitting b->b,h0; QtoQHSudakov do SplittingGenerator:AddFinalSplitting t->t,h0; QtoQHSudakov do SplittingGenerator:AddInitialSplitting c->c,h0; QtoQHSudakov do SplittingGenerator:AddInitialSplitting b->b,h0; QtoQHSudakov do SplittingGenerator:AddInitialSplitting t->t,h0; QtoQHSudakov do SplittingGenerator:AddFinalSplitting gamma->W+,W-; VtoVVSudakov -do SplittingGenerator:AddFinalSplitting Z0->W+,W-; VtoVVSudakov +do SplittingGenerator:AddFinalSplitting Z0->W+,W-; GammatoWWSudakov do SplittingGenerator:AddFinalSplitting W+->W+,gamma; VtoVVSudakov do SplittingGenerator:AddFinalSplitting W+->W+,Z0; VtoVVSudakov do SplittingGenerator:AddFinalSplitting W+->W+,h0; VtoVHSudakov do SplittingGenerator:AddFinalSplitting Z0->Z0,h0; VtoVHSudakov