diff --git a/Shower/QTilde/Base/ShowerParticle.cc b/Shower/QTilde/Base/ShowerParticle.cc
--- a/Shower/QTilde/Base/ShowerParticle.cc
+++ b/Shower/QTilde/Base/ShowerParticle.cc
@@ -1,584 +1,593 @@
 // -*- C++ -*-
 //
 // ShowerParticle.cc 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.
 //
 //
 // This is the implementation of the non-inlined, non-templated member
 // functions of the ShowerParticle class.
 //
 
 #include "ShowerParticle.h"
 #include "ThePEG/Interface/ClassDocumentation.h"
 #include "ThePEG/Persistency/PersistentOStream.h"
 #include "ThePEG/Persistency/PersistentIStream.h"
 #include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
 #include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
 #include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
 #include "ThePEG/Helicity/WaveFunction/ScalarWaveFunction.h"
 #include <ostream>
 
 using namespace Herwig;
 
 PPtr ShowerParticle::clone() const {
   return new_ptr(*this);
 }
 
 PPtr ShowerParticle::fullclone() const {
   return new_ptr(*this);
 }
 
 ClassDescription<ShowerParticle> ShowerParticle::initShowerParticle;
 // Definition of the static class description member.
 
 void ShowerParticle::vetoEmission(ShowerPartnerType, Energy scale) {
   scales_.QED         = min(scale,scales_.QED        );
   scales_.QED_noAO    = min(scale,scales_.QED_noAO   );
   scales_.QCD_c       = min(scale,scales_.QCD_c      );
   scales_.QCD_c_noAO  = min(scale,scales_.QCD_c_noAO );
   scales_.QCD_ac      = min(scale,scales_.QCD_ac     );
   scales_.QCD_ac_noAO = min(scale,scales_.QCD_ac_noAO);
   scales_.EW          = min(scale,scales_.EW         );
   if(spinInfo()) spinInfo()->undecay();
 }
 
 void ShowerParticle::addPartner(EvolutionPartner in ) {
-  partners_.push_back(in); 
+  partners_.push_back(in);
 }
 
 namespace {
 
 LorentzRotation boostToShower(Lorentz5Momentum & porig, tShowerBasisPtr basis) {
-  LorentzRotation output; 
+  LorentzRotation output;
   assert(basis);
   if(basis->frame()==ShowerBasis::BackToBack) {
     // we are doing the evolution in the back-to-back frame
     // work out the boostvector
     Boost boostv(-(basis->pVector()+basis->nVector()).boostVector());
     // momentum of the parton
     Lorentz5Momentum ptest(basis->pVector());
     // construct the Lorentz boost
     output = LorentzRotation(boostv);
     ptest *= output;
     Axis axis(ptest.vect().unit());
     // now rotate so along the z axis as needed for the splitting functions
     if(axis.perp2()>1e-10) {
       double sinth(sqrt(1.-sqr(axis.z())));
       output.rotate(-acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
     }
     else if(axis.z()<0.) {
       output.rotate(Constants::pi,Axis(1.,0.,0.));
     }
     porig = output*basis->pVector();
     porig.setX(ZERO);
     porig.setY(ZERO);
   }
   else {
     output = LorentzRotation(-basis->pVector().boostVector());
     porig = output*basis->pVector();
     porig.setX(ZERO);
     porig.setY(ZERO);
     porig.setZ(ZERO);
   }
   return output;
 }
 
 RhoDMatrix bosonMapping(ShowerParticle & particle,
 			const Lorentz5Momentum & porig,
 			VectorSpinPtr vspin,
 			const LorentzRotation & rot,
 			Helicity::Direction dir) {
   // rotate the original basis
   vector<LorentzPolarizationVector> sbasis;
   for(unsigned int ix=0;ix<3;++ix) {
     sbasis.push_back(vspin->getProductionBasisState(ix));
     sbasis.back().transform(rot);
   }
   // splitting basis
   vector<LorentzPolarizationVector> fbasis;
   bool massless(particle.id()==ParticleID::g||particle.id()==ParticleID::gamma);
   VectorWaveFunction wave(porig,particle.dataPtr(),dir==outgoing ? incoming : outgoing);
   for(unsigned int ix=0;ix<3;++ix) {
     if(massless&&ix==1) {
       fbasis.push_back(LorentzPolarizationVector());
     }
     else {
       wave.reset(ix,vector_phase);
       fbasis.push_back(wave.wave());
     }
   }
   // work out the mapping
   RhoDMatrix mapping=RhoDMatrix(PDT::Spin1,false);
   for(unsigned int ix=0;ix<3;++ix) {
     for(unsigned int iy=0;iy<3;++iy) {
       mapping(ix,iy)= -conj(sbasis[ix].dot(fbasis[iy]));
       if(particle.id()<0) mapping(ix,iy)=conj(mapping(ix,iy));
     }
   }
   return mapping;
 }
 
 RhoDMatrix fermionMapping(ShowerParticle & particle,
 			  const Lorentz5Momentum & porig,
 			  FermionSpinPtr fspin,
 			  const LorentzRotation & rot) {
   // extract the original basis states
   vector<LorentzSpinor<SqrtEnergy> > sbasis;
   for(unsigned int ix=0;ix<2;++ix) {
     sbasis.push_back(fspin->getProductionBasisState(ix));
     sbasis.back().transform(rot);
   }
   // calculate the states in the splitting basis
   vector<LorentzSpinor<SqrtEnergy> > fbasis;
   SpinorWaveFunction wave(porig,particle.dataPtr(),
 			  particle.id()>0 ? incoming : outgoing);
   for(unsigned int ix=0;ix<2;++ix) {
     wave.reset(ix);
     fbasis.push_back(wave.dimensionedWave());
   }
   RhoDMatrix mapping=RhoDMatrix(PDT::Spin1Half,false);
   for(unsigned int ix=0;ix<2;++ix) {
     if(fbasis[0].s2()==complex<SqrtEnergy>()) {
       mapping(ix,0) = sbasis[ix].s3()/fbasis[0].s3();
       mapping(ix,1) = sbasis[ix].s2()/fbasis[1].s2();
     }
     else {
       mapping(ix,0) = sbasis[ix].s2()/fbasis[0].s2();
       mapping(ix,1) = sbasis[ix].s3()/fbasis[1].s3();
     }
   }
   return mapping;
 }
 
 FermionSpinPtr createFermionSpinInfo(ShowerParticle & particle,
 				     const Lorentz5Momentum & porig,
 				     const LorentzRotation & rot,
 				     Helicity::Direction dir) {
   // calculate the splitting basis for the branching
   // and rotate back to construct the basis states
   LorentzRotation rinv = rot.inverse();
   SpinorWaveFunction wave;
   if(particle.id()>0)
     wave=SpinorWaveFunction(porig,particle.dataPtr(),incoming);
   else
     wave=SpinorWaveFunction(porig,particle.dataPtr(),outgoing);
   FermionSpinPtr fspin = new_ptr(FermionSpinInfo(particle.momentum(),dir==outgoing));
   for(unsigned int ix=0;ix<2;++ix) {
     wave.reset(ix);
     LorentzSpinor<SqrtEnergy> basis = wave.dimensionedWave();
     basis.transform(rinv);
     fspin->setBasisState(ix,basis);
   }
   particle.spinInfo(fspin);
   return fspin;
 }
 
 VectorSpinPtr createVectorSpinInfo(ShowerParticle & particle,
 				   const Lorentz5Momentum & porig,
 				   const LorentzRotation & rot,
 				   Helicity::Direction dir) {
   // calculate the splitting basis for the branching
   // and rotate back to construct the basis states
   LorentzRotation rinv = rot.inverse();
   bool massless(particle.id()==ParticleID::g||particle.id()==ParticleID::gamma);
+
+  Energy mass = porig.mass();
+  bool EWGVB(abs(particle.id())==ParticleID::Wplus||particle.id()==ParticleID::Z0);
+  if(EWGVB&&mass<1E-6*MeV) {
+    massless = true;
+    cerr << "Warning: ignoting the longitudinal polarization of "<< particle.id()
+         << " with mass "<< mass/GeV <<".\n";
+  }
+
   VectorWaveFunction wave(porig,particle.dataPtr(),dir);
   VectorSpinPtr vspin = new_ptr(VectorSpinInfo(particle.momentum(),dir==outgoing));
   for(unsigned int ix=0;ix<3;++ix) {
     LorentzPolarizationVector basis;
     if(massless&&ix==1) {
       basis = LorentzPolarizationVector();
     }
     else {
       wave.reset(ix,vector_phase);
       basis = wave.wave();
     }
     basis *= rinv;
     vspin->setBasisState(ix,basis);
   }
   particle.spinInfo(vspin);
   vspin->  DMatrix() = RhoDMatrix(PDT::Spin1);
   vspin->rhoMatrix() = RhoDMatrix(PDT::Spin1);
   if(massless) {
     vspin->  DMatrix()(0,0) = 0.5;
     vspin->rhoMatrix()(0,0) = 0.5;
     vspin->  DMatrix()(2,2) = 0.5;
     vspin->rhoMatrix()(2,2) = 0.5;
   }
   return vspin;
 }
 
 }
 
 RhoDMatrix ShowerParticle::extractRhoMatrix(bool forward) {
   // get the spin density matrix and the mapping
   RhoDMatrix mapping;
   SpinPtr inspin;
   bool needMapping = getMapping(inspin,mapping);
   // set the decayed flag
   inspin->decay();
   // get the spin density matrix
   RhoDMatrix rho = forward ? inspin->rhoMatrix() : inspin->DMatrix();
-  // map to the shower basis if needed  
+  // map to the shower basis if needed
   if(needMapping) {
     RhoDMatrix rhop(rho.iSpin(),false);
     for(int ixb=0;ixb<rho.iSpin();++ixb) {
   	for(int iyb=0;iyb<rho.iSpin();++iyb) {
   	  if(mapping(iyb,ixb)==0.)continue;
 	  for(int iya=0;iya<rho.iSpin();++iya) {
             if(rho(iya,iyb)==0.)continue;
 	    for(int ixa=0;ixa<rho.iSpin();++ixa) {
   	      rhop(ixa,ixb) += rho(iya,iyb)*mapping(iya,ixa)*conj(mapping(iyb,ixb));
   	    }
   	  }
   	}
     }
     rhop.normalize();
     rho = rhop;
   }
   return rho;
 }
 
 bool ShowerParticle::getMapping(SpinPtr & output, RhoDMatrix & mapping) {
   // if the particle is not from the hard process
   if(!this->perturbative()) {
     // mapping is the identity
     output=this->spinInfo();
     mapping=RhoDMatrix(this->dataPtr()->iSpin());
     if(output) {
       return false;
     }
     else {
       Lorentz5Momentum porig;
       LorentzRotation rot = boostToShower(porig,showerBasis());
       Helicity::Direction dir = this->isFinalState() ? outgoing : incoming;
       if(this->dataPtr()->iSpin()==PDT::Spin0) {
 	assert(false);
       }
       else if(this->dataPtr()->iSpin()==PDT::Spin1Half) {
 	output = createFermionSpinInfo(*this,porig,rot,dir);
       }
       else if(this->dataPtr()->iSpin()==PDT::Spin1) {
 	output = createVectorSpinInfo(*this,porig,rot,dir);
       }
       else {
 	assert(false);
       }
       return false;
     }
   }
   // if particle is final-state and is from the hard process
   else if(this->isFinalState()) {
     assert(this->perturbative()==1 || this->perturbative()==2);
     // get transform to shower frame
     Lorentz5Momentum porig;
     LorentzRotation rot = boostToShower(porig,showerBasis());
     // the rest depends on the spin of the particle
     PDT::Spin spin(this->dataPtr()->iSpin());
     mapping=RhoDMatrix(spin,false);
     // do the spin dependent bit
     if(spin==PDT::Spin0) {
       ScalarSpinPtr sspin=dynamic_ptr_cast<ScalarSpinPtr>(this->spinInfo());
       if(!sspin) {
 	ScalarWaveFunction::constructSpinInfo(this,outgoing,true);
       }
       output=this->spinInfo();
       return false;
     }
     else if(spin==PDT::Spin1Half) {
       FermionSpinPtr fspin=dynamic_ptr_cast<FermionSpinPtr>(this->spinInfo());
       // spin info exists get information from it
       if(fspin) {
 	output=fspin;
 	mapping = fermionMapping(*this,porig,fspin,rot);
 	return true;
       }
       // spin info does not exist create it
       else {
 	output = createFermionSpinInfo(*this,porig,rot,outgoing);
 	return false;
       }
     }
     else if(spin==PDT::Spin1) {
       VectorSpinPtr vspin=dynamic_ptr_cast<VectorSpinPtr>(this->spinInfo());
       // spin info exists get information from it
       if(vspin) {
 	output=vspin;
 	mapping = bosonMapping(*this,porig,vspin,rot,outgoing);
-	return true; 
+	return true;
       }
       else {
 	output = createVectorSpinInfo(*this,porig,rot,outgoing);
 	return false;
       }
     }
     // not scalar/fermion/vector
     else
       assert(false);
   }
   // incoming to hard process
   else if(this->perturbative()==1 && !this->isFinalState()) {
     // get the basis vectors
     // get transform to shower frame
     Lorentz5Momentum porig;
     LorentzRotation rot = boostToShower(porig,showerBasis());
     porig *= this->x();
     // the rest depends on the spin of the particle
     PDT::Spin spin(this->dataPtr()->iSpin());
     mapping=RhoDMatrix(spin);
     // do the spin dependent bit
     if(spin==PDT::Spin0) {
       cerr << "testing spin 0 not yet implemented " << endl;
       assert(false);
     }
     // spin-1/2
     else if(spin==PDT::Spin1Half) {
       FermionSpinPtr fspin=dynamic_ptr_cast<FermionSpinPtr>(this->spinInfo());
       // spin info exists get information from it
       if(fspin) {
 	output=fspin;
 	mapping = fermionMapping(*this,porig,fspin,rot);
 	return true;
       }
       // spin info does not exist create it
       else {
 	output = createFermionSpinInfo(*this,porig,rot,incoming);
 	return false;
       }
     }
     // spin-1
     else if(spin==PDT::Spin1) {
       VectorSpinPtr vspin=dynamic_ptr_cast<VectorSpinPtr>(this->spinInfo());
       // spinInfo exists map it
       if(vspin) {
 	output=vspin;
 	mapping = bosonMapping(*this,porig,vspin,rot,incoming);
 	return true;
       }
       // create the spininfo
       else {
 	output = createVectorSpinInfo(*this,porig,rot,incoming);
 	return false;
       }
     }
     assert(false);
   }
   // incoming to decay
-  else if(this->perturbative() == 2 && !this->isFinalState()) { 
+  else if(this->perturbative() == 2 && !this->isFinalState()) {
     // get the basis vectors
     Lorentz5Momentum porig;
-    LorentzRotation rot=boostToShower(porig,showerBasis());
+    //LorentzRotation rot=boostToShower(porig,showerBasis());
     // the rest depends on the spin of the particle
     PDT::Spin spin(this->dataPtr()->iSpin());
     mapping=RhoDMatrix(spin);
     // do the spin dependent bit
     if(spin==PDT::Spin0) {
       cerr << "testing spin 0 not yet implemented " << endl;
       assert(false);
     }
     // spin-1/2
     else if(spin==PDT::Spin1Half) {
     //   FermionSpinPtr fspin=dynamic_ptr_cast<FermionSpinPtr>(this->spinInfo());
     //   // spin info exists get information from it
     //   if(fspin) {
     // 	output=fspin;
     // 	mapping = fermionMapping(*this,porig,fspin,rot);
     // 	return true;
     //   // spin info does not exist create it
     //   else {
     // 	output = createFermionSpinInfo(*this,porig,rot,incoming);
     // 	return false;
     //   }
     // }
       assert(false);
     }
     // // spin-1
     // else if(spin==PDT::Spin1) {
     //   VectorSpinPtr vspin=dynamic_ptr_cast<VectorSpinPtr>(this->spinInfo());
     //   // spinInfo exists map it
     //   if(vspin) {
     // 	output=vspin;
     // 	mapping = bosonMapping(*this,porig,vspin,rot);
     // 	return true;
     //   }
     //   // create the spininfo
     //   else {
     // 	output = createVectorSpinInfo(*this,porig,rot,incoming);
     // 	return false;
     //   }
     // }
     // assert(false);
     assert(false);
   }
   else
     assert(false);
   return true;
 }
 
 void ShowerParticle::constructSpinInfo(bool timeLike) {
   // now construct the required spininfo and calculate the basis states
   PDT::Spin spin(dataPtr()->iSpin());
   if(spin==PDT::Spin0) {
     ScalarWaveFunction::constructSpinInfo(this,outgoing,timeLike);
   }
   // calculate the basis states and construct the SpinInfo for a spin-1/2 particle
   else if(spin==PDT::Spin1Half) {
     // outgoing particle
     if(id()>0) {
       vector<LorentzSpinorBar<SqrtEnergy> > stemp;
       SpinorBarWaveFunction::calculateWaveFunctions(stemp,this,outgoing);
       SpinorBarWaveFunction::constructSpinInfo(stemp,this,outgoing,timeLike);
     }
     // outgoing antiparticle
     else {
       vector<LorentzSpinor<SqrtEnergy> > stemp;
       SpinorWaveFunction::calculateWaveFunctions(stemp,this,outgoing);
       SpinorWaveFunction::constructSpinInfo(stemp,this,outgoing,timeLike);
     }
   }
   // calculate the basis states and construct the SpinInfo for a spin-1 particle
   else if(spin==PDT::Spin1) {
     bool massless(id()==ParticleID::g||id()==ParticleID::gamma);
     vector<Helicity::LorentzPolarizationVector> vtemp;
     VectorWaveFunction::calculateWaveFunctions(vtemp,this,outgoing,massless,vector_phase);
     VectorWaveFunction::constructSpinInfo(vtemp,this,outgoing,timeLike,massless);
   }
   else {
-    throw Exception() << "Spins higher than 1 are not yet implemented in " 
+    throw Exception() << "Spins higher than 1 are not yet implemented in "
 		      << "FS_QtildaShowerKinematics1to2::constructVertex() "
 		      << Exception::runerror;
   }
 }
 
 void ShowerParticle::initializeDecay() {
   Lorentz5Momentum p, n, ppartner, pcm;
   assert(perturbative()!=1);
   // this is for the initial decaying particle
   if(perturbative()==2) {
     ShowerBasisPtr newBasis;
     p = momentum();
     Lorentz5Momentum ppartner(partner()->momentum());
     // removed to make inverse recon work properly
     //if(partner->thePEGBase()) ppartner=partner->thePEGBase()->momentum();
     pcm=ppartner;
     Boost boost(p.findBoostToCM());
     pcm.boost(boost);
-    n = Lorentz5Momentum( ZERO,0.5*p.mass()*pcm.vect().unit()); 
+    n = Lorentz5Momentum( ZERO,0.5*p.mass()*pcm.vect().unit());
     n.boost( -boost);
     newBasis = new_ptr(ShowerBasis());
     newBasis->setBasis(p,n,ShowerBasis::Rest);
     showerBasis(newBasis,false);
   }
   else {
     showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis(),true);
   }
 }
 
 void ShowerParticle::initializeInitialState(PPtr parent) {
   // For the time being we are considering only 1->2 branching
   Lorentz5Momentum p, n, pthis, pcm;
   assert(perturbative()!=2);
   if(perturbative()==1) {
     ShowerBasisPtr newBasis;
     // find the partner and its momentum
     if(!partner()) return;
     if(partner()->isFinalState()) {
       Lorentz5Momentum pa = -momentum()+partner()->momentum();
       Lorentz5Momentum pb =  momentum();
       Energy scale=parent->momentum().t();
       Lorentz5Momentum pbasis(ZERO,parent->momentum().vect().unit()*scale);
       Axis axis(pa.vect().unit());
       LorentzRotation rot;
       double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
       if(axis.perp2()>1e-20) {
 	rot.setRotate(-acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
 	rot.rotateX(Constants::pi);
       }
       if(abs(1.-pa.e()/pa.vect().mag())>1e-6) rot.boostZ( pa.e()/pa.vect().mag());
       pb *= rot;
       if(pb.perp2()/GeV2>1e-20) {
 	Boost trans = -1./pb.e()*pb.vect();
 	trans.setZ(0.);
 	rot.boost(trans);
       }
       pbasis *=rot;
       rot.invert();
       n = rot*Lorentz5Momentum(ZERO,-pbasis.vect());
       p = rot*Lorentz5Momentum(ZERO, pbasis.vect());
     }
     else {
       pcm = parent->momentum();
       p = Lorentz5Momentum(ZERO, pcm.vect());
       n = Lorentz5Momentum(ZERO, -pcm.vect());
     }
     newBasis = new_ptr(ShowerBasis());
     newBasis->setBasis(p,n,ShowerBasis::BackToBack);
     showerBasis(newBasis,false);
-  } 
+  }
   else {
     showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(children()[0])->showerBasis(),true);
   }
 }
 
 void ShowerParticle::initializeFinalState() {
   // set the basis vectors
   Lorentz5Momentum p,n;
   if(perturbative()!=0) {
     ShowerBasisPtr newBasis;
     // find the partner() and its momentum
     if(!partner()) return;
     Lorentz5Momentum ppartner(partner()->momentum());
     // momentum of the emitting particle
     p = momentum();
     Lorentz5Momentum pcm;
     // if the partner is a final-state particle then the reference
     // vector is along the partner in the rest frame of the pair
     if(partner()->isFinalState()) {
       Boost boost=(p + ppartner).findBoostToCM();
       pcm = ppartner;
       pcm.boost(boost);
       n = Lorentz5Momentum(ZERO,pcm.vect());
       n.boost( -boost);
     }
     else if(!partner()->isFinalState()) {
       // if the partner is an initial-state particle then the reference
       // vector is along the partner which should be massless
       if(perturbative()==1) {
 	n = Lorentz5Momentum(ZERO,ppartner.vect());
       }
       // if the partner is an initial-state decaying particle then the reference
       // vector is along the backwards direction in rest frame of decaying particle
       else {
 	Boost boost=ppartner.findBoostToCM();
 	pcm = p;
 	pcm.boost(boost);
-	n = Lorentz5Momentum( ZERO, -pcm.vect()); 
+	n = Lorentz5Momentum( ZERO, -pcm.vect());
 	n.boost( -boost);
-      } 
+      }
     }
     newBasis = new_ptr(ShowerBasis());
     newBasis->setBasis(p,n,ShowerBasis::BackToBack);
     showerBasis(newBasis,false);
   }
   else if(initiatesTLS()) {
     showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0]->children()[0])->showerBasis(),true);
   }
   else  {
     showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis(),true);
   }
 }
 
 void ShowerParticle::setShowerMomentum(bool timeLike) {
   Energy m = this->mass() > ZERO ? this->mass() : this->data().mass();
   // calculate the momentum of the assuming on-shell
   Energy2 pt2 = sqr(this->showerParameters().pt);
   double alpha = timeLike ? this->showerParameters().alpha : this->x();
   double beta = 0.5*(sqr(m) + pt2 - sqr(alpha)*showerBasis()->pVector().m2())/(alpha*showerBasis()->p_dot_n());
   Lorentz5Momentum porig=showerBasis()->sudakov2Momentum(alpha,beta,
 							 this->showerParameters().ptx,
 							 this->showerParameters().pty);
   porig.setMass(m);
   this->set5Momentum(porig);
 }
diff --git a/src/defaults/Shower.in b/src/defaults/Shower.in
--- a/src/defaults/Shower.in
+++ b/src/defaults/Shower.in
@@ -1,442 +1,445 @@
 # -*- 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::HalfHalfOneEWSplitFn LtoLWZSplitFn
 newdef LtoLWZSplitFn:InteractionType EW
 newdef LtoLWZSplitFn: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 SudakovCommon LtoLWZSudakov
 set LtoLWZSudakov:SplittingFunction LtoLWZSplitFn
 set LtoLWZSudakov:Alpha AlphaEW
 set LtoLWZSudakov:PDFmax 1.9
 
 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 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 10000.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
 newdef QtoGammaQSudakov:PDFmax 2000.0
 
 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 gamma->e-,e+; GammatoQQbarSudakov
 do SplittingGenerator:AddInitialSplitting gamma->mu-,mu+; GammatoQQbarSudakov
 do SplittingGenerator:AddInitialSplitting gamma->tau-,tau+; 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 e-->e-,Z0; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting mu-->mu-,Z0; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting tau-->tau-,Z0; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_e->nu_e,Z0; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_mu->nu_mu,Z0; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_tau->nu_tau,Z0; LtoLWZSudakov
-
-do SplittingGenerator:AddFinalSplitting e-->nu_e,W-; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting mu-->nu_mu,W-; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting tau-->nu_tau,W-; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_e->e-,W+; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_mu->mu-,W+; LtoLWZSudakov
-do SplittingGenerator:AddFinalSplitting nu_tau->tau-,W+; LtoLWZSudakov
-
 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-; GammatoWWSudakov
 
 do SplittingGenerator:AddFinalSplitting Z0->W+,W-; VtoVVSudakov
 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
+
+#
+#  Electroweak l -> l V
+#
+#do SplittingGenerator:AddFinalSplitting e-->e-,Z0; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting mu-->mu-,Z0; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting tau-->tau-,Z0; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_e->nu_e,Z0; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_mu->nu_mu,Z0; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_tau->nu_tau,Z0; LtoLWZSudakov
+
+#do SplittingGenerator:AddFinalSplitting e-->nu_e,W-; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting mu-->nu_mu,W-; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting tau-->nu_tau,W-; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_e->e-,W+; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_mu->mu-,W+; LtoLWZSudakov
+#do SplittingGenerator:AddFinalSplitting nu_tau->tau-,W+; LtoLWZSudakov