No OneTemporary
Actions

Size

48 KB

Subscribers

None

View Options

	diff --git a/Shower/QTilde/Makefile.am b/Shower/QTilde/Makefile.am
	--- a/Shower/QTilde/Makefile.am
	+++ b/Shower/QTilde/Makefile.am
	@@ -1,49 +1,49 @@
	SUBDIRS = Matching
	pkglib_LTLIBRARIES = HwShower.la
	HwShower_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 26: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/ZeroZeroOneEWSplitFn.h SplittingFunctions/ZeroZeroOneEWSplitFn.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/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/OneOneZeroEWSplitFn.cc b/Shower/QTilde/SplittingFunctions/OneOneZeroEWSplitFn.cc
	new file mode 100644
	--- /dev/null
	+++ b/Shower/QTilde/SplittingFunctions/OneOneZeroEWSplitFn.cc
	@@ -0,0 +1,230 @@
	+// -- C++ --
	+//
	+// This is the implementation of the non-inlined, non-templated member
	+// functions of the OneOneZeroEWSplitFn class.
	+//
	+
	+#include "OneOneZeroEWSplitFn.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 OneOneZeroEWSplitFn::clone() const {
	+ return new_ptr(*this);
	+}
	+
	+IBPtr OneOneZeroEWSplitFn::fullclone() const {
	+ return new_ptr(*this);
	+}
	+
	+void OneOneZeroEWSplitFn::persistentOutput(PersistentOStream & os) const {
	+ os << gWWH_ << gZZH_ << _theSM;
	+}
	+
	+void OneOneZeroEWSplitFn::persistentInput(PersistentIStream & is, int) {
	+ is >> gWWH_ >> gZZH_ >> _theSM;
	+}
	+
	+// The following static variable is needed for the type description system in ThePEG.
	+DescribeClass<OneOneZeroEWSplitFn,SplittingFunction>
	+describeHerwigOneOneZeroEWSplitFn("Herwig::OneOneZeroEWSplitFn", "HwShower.so");
	+
	+
	+void OneOneZeroEWSplitFn::Init() {
	+
	+ static ClassDocumentation<OneOneZeroEWSplitFn> documentation
	+ ("The OneOneZeroEWSplitFn class implements the splittings W->WH and Z->ZH");
	+
	+}
	+
	+
	+void OneOneZeroEWSplitFn::doinit() {
	+ SplittingFunction::doinit();
	+ tcSMPtr sm = generator()->standardModel();
	+ double sw2 = sm->sin2ThetaW();
	+ // W -> W H coupling g = e/sin theta_W
	+ gWWH_ = 1./sqrt(sw2);
	+ // Z -> Z H coupling
	+ gZZH_ = 1./(sqrt(sw2)*sqrt(1.-sw2));
	+ // to employ running masses, wherever needed
	+ _theSM = dynamic_ptr_cast<tcHwSMPtr>(generator()->standardModel());
	+}
	+
	+
	+void OneOneZeroEWSplitFn::getCouplings(double & g, const IdList & ids) const {
	+ if(abs(ids[0]->id())==ParticleID::Wplus){
	+ g = gWWH_;
	+ }
	+ else if(ids[0]->id()==ParticleID::Z0){
	+ g = gZZH_;
	+ }
	+ else
	+ assert(false);
	+}
	+
	+
	+double OneOneZeroEWSplitFn::P(const double z, const Energy2 t,
	+ const IdList &ids, const bool mass, const RhoDMatrix & rho) const {
	+ double gvvh(0.);
	+ getCouplings(gvvh,ids);
	+ double rho00 = abs(rho(0,0));
	+ double rho11 = abs(rho(1,1));
	+ double rho22 = abs(rho(2,2));
	+ // the splitting in the massless limit
	+ double val = ((1.-z)/z)(2.rho11+sqr(z)*(rho00+rho22));
	+ // the massive limit
	+ if(mass){
	+ // get the running mass
	+ double m0t;
	+ if(abs(ids[0]->id())==ParticleID::Wplus)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Wplus))/sqrt(t);
	+ else if(ids[0]->id()==ParticleID::Z0)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Z0))/sqrt(t);
	+ double mHt = _theSM->mass(t,getParticleData(ParticleID::h0))/sqrt(t);
	+ val += -sqr(mHt)((2.rho11)/z+z*(rho00+rho22));
	+ val += -sqr(m0t)(((-4.+2.z)rho11)/z-(1.+(2.-z)z)*(rho00+rho22));
	+ }
	+ return sqr(gvvh)*val;
	+}
	+
	+
	+double OneOneZeroEWSplitFn::overestimateP(const double z,
	+ const IdList & ids) const {
	+ double gvvh(0.);
	+ getCouplings(gvvh,ids);
	+ return sqr(gvvh)*(2./z);
	+}
	+
	+
	+double OneOneZeroEWSplitFn::ratioP(const double z, const Energy2 t,
	+ const IdList & ids, const bool mass,
	+ const RhoDMatrix & rho) const {
	+ double rho00 = abs(rho(0,0));
	+ double rho11 = abs(rho(1,1));
	+ double rho22 = abs(rho(2,2));
	+ // ratio in the massless limit
	+ double val = (1.-z)(2.rho11+sqr(z)*(rho00+rho22))/2.;
	+ // the massive limit
	+ if(mass){
	+ // get the running mass
	+ double m0t;
	+ if(abs(ids[0]->id())==ParticleID::Wplus)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Wplus))/sqrt(t);
	+ else if(ids[0]->id()==ParticleID::Z0)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Z0))/sqrt(t);
	+ double mHt = _theSM->mass(t,getParticleData(ParticleID::h0))/sqrt(t);
	+ val += -sqr(mHt)0.5z((2.rho11)/z+(rho00+rho22)*z);
	+ val += -sqr(m0t)0.5z((rho11(-4.+2.z))/z-(rho00+rho22)(1.+(2.-z)*z));
	+ }
	+ return val;
	+}
	+
	+
	+
	+double OneOneZeroEWSplitFn::integOverP(const double z,
	+ const IdList & ids,
	+ unsigned int PDFfactor) const {
	+ double gvvh(0.);
	+ getCouplings(gvvh,ids);
	+ double pre = sqr(gvvh);
	+ switch (PDFfactor) {
	+ case 0:
	+ return 2.prelog(z);
	+ case 1:
	+ case 2:
	+ case 3:
	+ default:
	+ throw Exception() << "OneOneZeroEWSplitFn::integOverP() invalid PDFfactor = "
	+ << PDFfactor << Exception::runerror;
	+ }
	+}
	+
	+double OneOneZeroEWSplitFn::invIntegOverP(const double r, const IdList & ids,
	+ unsigned int PDFfactor) const {
	+ double gvvh(0.);
	+ getCouplings(gvvh,ids);
	+ double pre = sqr(gvvh);
	+ switch (PDFfactor) {
	+ case 0:
	+ return exp(r/(2.*pre));
	+ case 1:
	+ case 2:
	+ case 3:
	+ default:
	+ throw Exception() << "OneOneZeroEWSplitFn::invIntegOverP() invalid PDFfactor = "
	+ << PDFfactor << Exception::runerror;
	+ }
	+}
	+
	+bool OneOneZeroEWSplitFn::accept(const IdList &ids) const {
	+ if(ids.size()!=3)
	+ return false;
	+ if(ids[0]->id()!=ids[1]->id())
	+ return false;
	+ if(abs(ids[0]->id())==ParticleID::Wplus && ids[2]->id()==ParticleID::h0)
	+ return true;
	+ else if(ids[0]->id()==ParticleID::Z0 && ids[2]->id()==ParticleID::h0)
	+ return true;
	+ else
	+ return false;
	+}
	+
	+
	+vector<pair<int, Complex> >
	+OneOneZeroEWSplitFn::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<pair<int, Complex> >(1,make_pair(0,1.));
	+}
	+
	+
	+vector<pair<int, Complex> >
	+OneOneZeroEWSplitFn::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<pair<int, Complex> >(1,make_pair(0,1.));
	+}
	+
	+
	+DecayMEPtr OneOneZeroEWSplitFn::matrixElement(const double z, const Energy2 t,
	+ const IdList & ids, const double phi,
	+ bool) {
	+ double gvvh(0.);
	+ getCouplings(gvvh,ids);
	+ // calculate the kernal
	+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin0)));
	+ Complex phase = exp(Complex(0.,1.)*phi);
	+ Complex cphase = conj(phase);
	+ double r2 = sqrt(2.);
	+ double m0t;
	+ if(abs(ids[0]->id())==ParticleID::Wplus)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Wplus))/sqrt(t);
	+ else if(ids[0]->id()==ParticleID::Z0)
	+ m0t = _theSM->mass(t,getParticleData(ParticleID::Z0))/sqrt(t);
	+ else
	+ assert(false);
	+ double mHt = _theSM->mass(t,getParticleData(ParticleID::h0))/sqrt(t);
	+ double sqrtmass = sqrt(sqr(m0t)-sqr(m0t)/z-sqr(mHt)/(1.-z)+1.);
	+ // assign kernel
	+ (kernal)(0,0,0) = -gvvhr2*m0t; // 111
	+ (kernal)(0,1,0) = -gvvhcphasesqrt((1.-z)z)*sqrtmass; // 121
	+ (*kernal)(0,2,0) = 0.; // 131
	+ (kernal)(1,0,0) = gvvhphasesqrt((1.-z)/z)sqrtmass; // 211
	+ (*kernal)(1,1,0) = 0.; // 221 > 441
	+ (kernal)(1,2,0) = -gvvhcphasesqrt((1.-z)/z)sqrtmass; // 231
	+ (*kernal)(2,0,0) = 0.; // 311
	+ (kernal)(2,1,0) = gvvhphasesqrt((1.-z)z)*sqrtmass; // 321 > 341
	+ (kernal)(2,2,0) = -gvvhr2*m0t; // 331
	+ // return the answer
	+ return kernal;
	+}
	diff --git a/Shower/QTilde/SplittingFunctions/OneOneZeroEWSplitFn.h b/Shower/QTilde/SplittingFunctions/OneOneZeroEWSplitFn.h
	new file mode 100644
	--- /dev/null
	+++ b/Shower/QTilde/SplittingFunctions/OneOneZeroEWSplitFn.h
	@@ -0,0 +1,219 @@
	+// -- C++ --
	+#ifndef Herwig_OneOneZeroEWSplitFn_H
	+#define Herwig_OneOneZeroEWSplitFn_H
	+//
	+// This is the declaration of the OneOneZeroEWSplitFn class.
	+//
	+
	+#include "SplittingFunction.h"
	+#include "Herwig/Models/StandardModel/StandardModel.h"
	+
	+namespace Herwig {
	+
	+using namespace ThePEG;
	+
	+/**
	+ * The OneOneZeroEWSplitFn class implements the splitting function for
	+ * \f$\1\to q\1 0\f$ where the spin-1 particles are the W / Z massive
	+ * electroweak gauge bosons and the spin-0 particle is the massive Higgs
	+ * boson.
	+ *
	+ * @see \ref OneOneZeroEWSplitFnInterfaces "The interfaces"
	+ * defined for OneOneZeroEWSplitFn.
	+ */
	+class OneOneZeroEWSplitFn: 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<pair<int,Complex> >
	+ 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<pair<int,Complex> >
	+ 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 & g, 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.
	+ */
	+ OneOneZeroEWSplitFn & operator=(const OneOneZeroEWSplitFn &) = delete;
	+
	+private:
	+
	+ /**
	+ * W -> W H couplings
	+ */
	+ double gWWH_;
	+
	+ /**
	+ * Z0 -> Z0 H couplings
	+ */
	+ double gZZH_;
	+
	+ /**
	+ * Pointer to the SM object.
	+ */
	+ tcHwSMPtr _theSM;
	+};
	+
	+}
	+
	+#endif /* Herwig_OneOneZeroEWSplitFn_H */
	diff --git a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.cc b/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.cc
	deleted file mode 100644
	--- a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.cc
	+++ /dev/null
	@@ -1,204 +0,0 @@
	-// -- C++ --
	-//
	-// This is the implementation of the non-inlined, non-templated member
	-// functions of the ZeroZeroOneEWSplitFn class.
	-//
	-
	-#include "ZeroZeroOneEWSplitFn.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 ZeroZeroOneEWSplitFn::clone() const {
	- return new_ptr(*this);
	-}
	-
	-IBPtr ZeroZeroOneEWSplitFn::fullclone() const {
	- return new_ptr(*this);
	-}
	-
	-void ZeroZeroOneEWSplitFn::persistentOutput(PersistentOStream & os) const {
	- os << gHHZ_ << _theSM;
	-}
	-
	-void ZeroZeroOneEWSplitFn::persistentInput(PersistentIStream & is, int) {
	- is >> gHHZ_ >> _theSM;
	-}
	-
	-// The following static variable is needed for the type description system in ThePEG.
	-DescribeClass<ZeroZeroOneEWSplitFn,SplittingFunction>
	-describeHerwigZeroZeroOneEWSplitFn("Herwig::ZeroZeroOneEWSplitFn", "HwShower.so");
	-
	-
	-void ZeroZeroOneEWSplitFn::Init() {
	-
	- static ClassDocumentation<ZeroZeroOneEWSplitFn> documentation
	- ("The ZeroZeroOneEWSplitFn class implements the splitting H->HZ");
	-
	-}
	-
	-
	-void ZeroZeroOneEWSplitFn::doinit() {
	- SplittingFunction::doinit();
	- tcSMPtr sm = generator()->standardModel();
	- double sw2 = sm->sin2ThetaW();
	- // coupling
	- gHHZ_ = 0.5/(sqrt(sw2)*sqrt(1.-sw2));
	- // to employ running masses, wherever needed
	- _theSM = dynamic_ptr_cast<tcHwSMPtr>(generator()->standardModel());
	-}
	-
	-
	-void ZeroZeroOneEWSplitFn::getCouplings(double & g, const IdList & ids) const {
	- if(ids[0]->id()==ParticleID::h0 && ids[1]->id()==ParticleID::h0 && ids[2]->id()==ParticleID::Z0){
	- g = gHHZ_;
	- }
	- else
	- assert(false);
	-}
	-
	-
	-double ZeroZeroOneEWSplitFn::P(const double z, const Energy2 t,
	- const IdList &ids, const bool mass, const RhoDMatrix & rho) const {
	- double gHHZ(0.);
	- getCouplings(gHHZ,ids);
	- // massless limit
	- double val = 4.*z/(1.-z);
	- // massive limits
	- if(mass) {
	- // running masses of the bosons
	- Energy mH_r = _theSM->mass(t,getParticleData(ParticleID::h0));
	- Energy mZ_r = _theSM->mass(t,getParticleData(ParticleID::Z0));
	- double mHt2 = sqr(mH_r)/t;
	- double mZt2 = sqr(mZ_r)/t;
	- val += 2.mZt2(1.+sqr(z))/sqr(1.-z);
	- val -= 4.*mHt2;
	- }
	- return sqr(gHHZ)*val;
	-}
	-
	-
	-double ZeroZeroOneEWSplitFn::overestimateP(const double z,
	- const IdList & ids) const {
	- double gHHZ(0.);
	- getCouplings(gHHZ,ids);
	- return sqr(gHHZ)*4./(1.-z);
	-}
	-
	-
	-double ZeroZeroOneEWSplitFn::ratioP(const double z, const Energy2 t,
	- const IdList & ids, const bool mass,
	- const RhoDMatrix & rho) const {
	- // massless limit
	- double val = z;
	- // massive limits
	- if(mass) {
	- // running masses of the bosons
	- Energy mH_r = _theSM->mass(t,getParticleData(ParticleID::h0));
	- Energy mZ_r = _theSM->mass(t,getParticleData(ParticleID::Z0));
	- double mHt2 = sqr(mH_r)/t;
	- double mZt2 = sqr(mZ_r)/t;
	- val += 0.5mZt2(1.+sqr(z))/(1.-z);
	- val -= mHt2*(1.-z);
	- }
	- return val;
	-}
	-
	-
	-double ZeroZeroOneEWSplitFn::integOverP(const double z,
	- const IdList & ids,
	- unsigned int PDFfactor) const {
	- double gHHZ(0.);
	- getCouplings(gHHZ,ids);
	- double pre = sqr(gHHZ);
	- switch (PDFfactor) {
	- case 0:
	- return -4.prelog(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() << "ZeroZeroOneEWSplitFn::integOverP() invalid PDFfactor = "
	- << PDFfactor << Exception::runerror;
	- }
	-}
	-
	-double ZeroZeroOneEWSplitFn::invIntegOverP(const double r, const IdList & ids,
	- unsigned int PDFfactor) const {
	- double gHHZ(0.);
	- getCouplings(gHHZ,ids);
	- double pre = 4.*sqr(gHHZ);
	- switch (PDFfactor) {
	- case 0:
	- return 1.-exp(-r/pre);
	- case 1:
	- case 2:
	- case 3:
	- default:
	- throw Exception() << "ZeroZeroOneEWSplitFn::invIntegOverP() invalid PDFfactor = "
	- << PDFfactor << Exception::runerror;
	- }
	-}
	-
	-bool ZeroZeroOneEWSplitFn::accept(const IdList &ids) const {
	- if(ids.size()!=3)
	- return false;
	- if(ids[0]->id()==ParticleID::h0 && ids[1]->id()==ParticleID::h0 && ids[2]->id()==ParticleID::Z0)
	- return true;
	- else
	- return false;
	-}
	-
	-
	-vector<pair<int, Complex> >
	-ZeroZeroOneEWSplitFn::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<pair<int, Complex> >(1,make_pair(0,1.));
	-}
	-
	-
	-vector<pair<int, Complex> >
	-ZeroZeroOneEWSplitFn::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<pair<int, Complex> >(1,make_pair(0,1.));
	-}
	-
	-
	-DecayMEPtr ZeroZeroOneEWSplitFn::matrixElement(const double z, const Energy2 t,
	- const IdList & ids, const double phi,
	- bool) {
	- // calculate the kernal
	- DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin0,PDT::Spin0,PDT::Spin1)));
	- double gHHZ(0.);
	- getCouplings(gHHZ,ids);
	- // defining dummies
	- Energy mH_r = _theSM->mass(t,getParticleData(ParticleID::h0));
	- Energy mZ_r = _theSM->mass(t,getParticleData(ParticleID::Z0));
	- double m0t = mH_r/sqrt(t);
	- double m1t = mH_r/sqrt(t);
	- double m2t = mZ_r/sqrt(t);
	- Complex phase = exp(Complex(0.,1.)*phi);
	- Complex cphase = conj(phase);
	- double sqrtmass = sqrt(sqr(m0t)-sqr(m1t)/z-sqr(m2t)/(1.-z)+1.);
	- // assign kernel
	- (kernal)(0,0,0) = 2.gHHZphasesqrt(z/(1.-z))*sqrtmass;
	- (kernal)(0,0,1) = sqrt(2.)gHHZm2t((1.+z)/(1.-z)); //2>4
	- (kernal)(0,0,2) = -2.gHHZcphasesqrt(z/(1.-z))*sqrtmass;
	- // return the answer
	- return kernal;
	-}
	diff --git a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h b/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h
	deleted file mode 100644
	--- a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h
	+++ /dev/null
	@@ -1,213 +0,0 @@
	-// -- C++ --
	-#ifndef Herwig_ZeroZeroOneEWSplitFn_H
	-#define Herwig_ZeroZeroOneEWSplitFn_H
	-//
	-// This is the declaration of the ZeroZeroOneEWSplitFn class.
	-//
	-
	-#include "SplittingFunction.h"
	-#include "Herwig/Models/StandardModel/StandardModel.h"
	-
	-namespace Herwig {
	-
	-using namespace ThePEG;
	-
	-/**
	- * The ZeroZeroOneEWSplitFn class implements the splitting function for
	- * \f$\0\to q\0 1\f$ where the spin-0 particles are massive Higgs bosons and
	- * the spin-1 particle is the Z0 massive electroweak gauge boson.
	- *
	- * @see \ref ZeroZeroOneEWSplitFnInterfaces "The interfaces"
	- * defined for ZeroZeroOneEWSplitFn.
	- */
	-class ZeroZeroOneEWSplitFn: 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<pair<int,Complex> >
	- 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<pair<int,Complex> >
	- 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 & g, 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.
	- */
	- ZeroZeroOneEWSplitFn & operator=(const ZeroZeroOneEWSplitFn &) = delete;
	-
	-private:
	-
	- /**
	- * H -> H Z0 couplings
	- */
	- double gHHZ_;
	-
	- /**
	- * Pointer to the SM object.
	- */
	- tcHwSMPtr _theSM;
	-};
	-
	-}
	-
	-#endif /* Herwig_ZeroZeroOneEWSplitFn_H */
	diff --git a/src/defaults/Shower.in b/src/defaults/Shower.in
	--- a/src/defaults/Shower.in
	+++ b/src/defaults/Shower.in
	@@ -1,405 +1,406 @@
	# -- 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 1
	newdef PartnerFinder:ScaleChoice 1
	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 1.3*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 1.3*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::ZeroZeroOneEWSplitFn HtoHZSplitFn
	-newdef HtoHZSplitFn:InteractionType EW
	-newdef HtoHZSplitFn:ColourStructure EW
	+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

	-cp SudakovCommon HtoHZSudakov
	-set HtoHZSudakov:SplittingFunction HtoHZSplitFn
	-set HtoHZSudakov:Alpha AlphaEW
	-set HtoHZSudakov: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 W+->W+,gamma; VtoVVSudakov
	do SplittingGenerator:AddFinalSplitting W+->W+,Z0; VtoVVSudakov

	-do SplittingGenerator:AddFinalSplitting h0->h0,Z0; HtoHZSudakov
	+do SplittingGenerator:AddFinalSplitting W+->W+,h0; VtoVHSudakov
	+do SplittingGenerator:AddFinalSplitting Z0->Z0,h0; VtoVHSudakov

File Metadata

Mime Type: text/x-diff
Expires: Sat, Dec 21, 12:29 PM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4022773
Default Alt Text: (48 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions