diff --git a/MatrixElement/EW/CollinearSudakov.h b/MatrixElement/EW/CollinearSudakov.h
--- a/MatrixElement/EW/CollinearSudakov.h
+++ b/MatrixElement/EW/CollinearSudakov.h
@@ -1,546 +1,546 @@
 // -*- C++ -*-
 #ifndef Herwig_CollinearSudakov_H
 #define Herwig_CollinearSudakov_H
 //
 // This is the declaration of the CollinearSudakov class.
 //
 
 #include "ThePEG/Interface/Interfaced.h"
 #include "Herwig/Utilities/GSLIntegrator.h"
 // work around a Boost 1.64 bug where ublas headers would fail otherwise
 #include <boost/version.hpp>
 #if (BOOST_VERSION / 100 >= 1064)
 #include <boost/serialization/array_wrapper.hpp>
 #endif
 #include <boost/numeric/ublas/matrix.hpp>
 #include "EWProcess.h"
 #include "CollinearSudakov.fh"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  *  Struct for the wavefunction corrections
  */
 struct WaveFunctionCorrections {
   Complex RW;
   Complex RA;
   Complex RZ;
   Complex RAtoZ;
   Complex RZtoA;
   Complex RPhi;
   Complex EW;
   Complex EZ;
   Complex RPhi3;
   Complex RH;
   Complex tLuLDiff;
   Complex bLdLDiff;
   Complex tRuRDiff;
   
   // The following are constants from parameter integrals:
   
   Complex fFW0;
   Complex fF0W;
   Complex fFZZ;
   Complex aHH;
   Complex aZZ;
   Complex aW0;
   Complex a0W;
   Complex bHH;
   Complex bZZ;
   Complex cHH;
   Complex cZZ;
   Complex cW0;
   Complex atHH;
   Complex atZZ;
   Complex atW0;
   Complex at0W;
   Complex ctHH;
   Complex ctZZ;
   Complex ctW0;
   Complex btHH;
   Complex btZZ;
   
   Complex fs10;
   Complex fs1ZW;
   Complex fsWZWZ;
   Complex fsZW1;
   Complex fs01;
   Complex fsHW1;
   Complex fsHZ1;
   Complex fs1HW;
   Complex fs1HZ;
 };
 
 /**
  * Here is the documentation of the CollinearSudakov class.
  *
  * @see \ref CollinearSudakovInterfaces "The interfaces"
  * defined for CollinearSudakov.
  */
 class CollinearSudakov: public Interfaced {
 
 public:
 
   /** @name Standard constructors and destructors. */
   //@{
   /**
    * The default constructor.
    */
   CollinearSudakov();
 
   /**
    * The destructor.
    */
   virtual ~CollinearSudakov();
   //@}
 
 public:
   
   /**
    *  Evalaute the electroweak matching as a matrix
    */
   boost::numeric::ublas::matrix<Complex>
   electroWeakMatching(Energy EWScale, Energy2 s,
 		      Herwig::EWProcess::Process process,
 		      bool oneLoop);
 
   /**
    *  Evalaute the high energy running as a matrix
    */
   boost::numeric::ublas::matrix<Complex>
   highEnergyRunning(Energy highScale, Energy EWScale, Energy2 s,
 		    Herwig::EWProcess::Process process,
 		    bool fixedOrder);
 
   /**
    *  Evaluate the low energy running as a matrix
    */
   boost::numeric::ublas::matrix<Complex>
   lowEnergyRunning(Energy EWScale, Energy lowScale, Energy2 s,
 		   Herwig::EWProcess::Process process);
 public:
 
   /**
    *  Make plots for tests
    */
   void makePlots();
 
 protected:
 
   /**
    *   Evaluate the high scale contributions
    */
   void evaluateHighScale(Energy highScale, Energy EWScale, Energy2 S);
 
   /**
    *   Evaluate the low scale contributions
    */
   void evaluateLowScale(Energy EWScale, Energy lowScale, Energy2 S);
 
   /**
    *  Evaluate the matching
    */
   void evaluateMatching(Energy EWScale,Energy2 S);
 
 public:
 
   /**
    *  The operator to be integrated
    */
   InvEnergy operator ()(Energy mu) const {
     if(high_) return highScaleIntegrand(mu);
     else      return  lowScaleIntegrand(mu);
   }
   /** Argument type for GaussianIntegrator */
   typedef Energy ArgType;
   /** Return type for GaussianIntegrator */
   typedef InvEnergy ValType;
 
 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:
 
   /**
    *  The integral of the high scale part of the Sudakov
    */
   Complex highScaleIntegral(bool SU3, bool SU2, double Y,
 			    Energy2 s, Energy mu_h, Energy mu_l, bool fermion, 
 			    bool longitudinal, double yukFactor);
 
   /**
    *  the integral of the low scale part of the Sudakov
    */
   Complex  lowScaleIntegral(bool SU3, double Q, Energy2 s, 
 			    Energy mu_h, Energy mu_l, bool fermion, 
 			    double boostFactor);
 
 protected:
 
   /**
    *   High-scale integrand
    */
   InvEnergy highScaleIntegrand(Energy mu) const;
 
   /**
    *   Low-scale integrand
    */
   InvEnergy  lowScaleIntegrand(Energy mu) const;
 
   /**
    *  Calculate the wavefunction corrections
    */
   WaveFunctionCorrections waveFunctionCorrections(Energy EWScale);
 
   /**
    *  Collinear matiching for W
    */
   Complex CollinearDw(Energy2 s, Energy EWScale);
 
   /**
    *  Collinear matching for Z
    */
   Complex CollinearDz(Energy2 s, Energy EWScale);
 
 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;
   //@}
 
 
 // If needed, insert declarations of virtual function defined in the
 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
-  CollinearSudakov & operator=(const CollinearSudakov &);
+  CollinearSudakov & operator=(const CollinearSudakov &) = delete;
 private:
 
   /**
    *  Parameters for the integrand
    */
   //@{
   /**
    *  Whether high or low scale
    */
   bool high_;
 
   /**
    *  Whether real of imaginary part
    */
   bool real_;
 
   /**
    * \f$SU(3)\f$
    */
   bool SU3_;
 
   /**
    *
    */
   bool SU2_;
 
   /**
    *
    */
   double Y_;
 
   /**
    *
    */
   Energy2 s_;
 
   /**
    *
    */
   bool fermion_; 
 
   /**
    *
    */
   bool longitudinal_;
 
   /**
    *
    */
   double yukFactor_;
 
   /**
    *
    */
   double boostFactor_;
 
   /**
    *
    */
   double Q_;
   //@}
 
   /**
    * Parameters
    */
   //@{
   /**
    *  Order for the K terms
    */
   int K_ORDER_;
 
   /**
    *  Order for the B terms
    */
   int B_ORDER_;
   //@}
 
   /**
    *  Integrator
    */
   GSLIntegrator integrator_;
 
 private:
 
   /**
    *   Storage of the high scale pieces
    */
   //@{
   /**
    *
    */
   Complex highColW_;
 
   /**
    *
    */
   Complex highColB_;
 
   /**
    *
    */
   Complex highColG_;
 
   /**
    *
    */
   Complex highColQ_;
 
   /**
    *
    */
   Complex highColQt_;
 
   /**
    *
    */
   Complex highColU_;
 
   /**
    *
    */
   Complex highColtR_;
 
   /**
    *
    */
   Complex highColD_;
 
   /**
    *
    */
   Complex highColL_;
 
   /**
    *
    */
   Complex highColE_;
 
   /**
    *
    */
   Complex highColPhi_;
   //@}
 
   /**
    *  Storage of the low scale pieces
    */
   //@{
   /**
    *
    */
   complex<double> lowColW_;
 
   /**
    *
    */
   Complex lowColA_;
 
   /**
    *
    */
   Complex lowColG_;
 
   /**
    *
    */
   Complex lowColU_;
 
   /**
    *
    */
   Complex lowColt_;
 
   /**
    *
    */
   Complex lowColD_;
 
   /**
    *
    */
   Complex lowColE_;
   //@}
 
   /**
    *  Storage of the matching parameters
    */
   //@{
   /**
    *
    */
   Complex ULcollinearCorr_;
 
   /**
    *
    */
   Complex DLcollinearCorr_;
 
   /**
    *
    */
   Complex URcollinearCorr_;
 
   /**
    *
    */
   Complex DRcollinearCorr_;
 
   /**
    *
    */
   Complex tLcollinearCorr_;
 
   /**
    *
    */
   Complex tRcollinearCorr_;
 
   /**
    *
    */
   Complex bLcollinearCorr_;
 
   /**
    *
    */
   Complex nuLcollinearCorr_;
 
   /**
    *
    */
   Complex ELcollinearCorr_;
 
   /**
    *
    */
   Complex ERcollinearCorr_;
 
   /**
    *
    */  
   Complex WtoWcollinearCorr_;
 
   /**
    *
    */
   Complex WtoZcollinearCorr_;
 
   /**
    *
    */
   Complex WtoAcollinearCorr_;
 
   /**
    *
    */
   Complex BtoZcollinearCorr_;
 
   /**
    *
    */
   Complex BtoAcollinearCorr_;
 
   /**
    *
    */
   Complex PhitoWcollinearCorr_;
 
   /**
    *
    */
   Complex PhitoZcollinearCorr_;
 
   /**
    *
    */
   Complex PhitoHcollinearCorr_;
 
   /**
    *
    */
   Complex GcollinearCorr_;
   //@}
 };
 
 }
 
 #endif /* Herwig_CollinearSudakov_H */
diff --git a/MatrixElement/EW/EWCouplings.h b/MatrixElement/EW/EWCouplings.h
--- a/MatrixElement/EW/EWCouplings.h
+++ b/MatrixElement/EW/EWCouplings.h
@@ -1,478 +1,478 @@
 // -*- C++ -*-
 #ifndef Herwig_EWCouplings_H
 #define Herwig_EWCouplings_H
 //
 // This is the declaration of the EWCouplings class.
 //
 
 #include "ThePEG/Interface/Interfaced.h"
 // work around a Boost 1.64 bug where ublas headers would fail otherwise
 #include <boost/version.hpp>
 #if (BOOST_VERSION / 100 >= 1064)
 #include <boost/serialization/array_wrapper.hpp>
 #endif
 #include <boost/numeric/ublas/vector.hpp>
 #include <boost/numeric/ublas/matrix.hpp>
 #include "EWCouplings.fh"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * Here is the documentation of the EWCouplings class.
  *
  * @see \ref EWCouplingsInterfaces "The interfaces"
  * defined for EWCouplings.
  */
 class EWCouplings: public Interfaced {
 
 public:
 
   /** @name Standard constructors and destructors. */
   //@{
   /**
    * The default constructor.
    */
   EWCouplings(unsigned int loops=2, unsigned int steps=200, Energy lowScale=10.*GeV);
 
   /**
    * The destructor.
    */
   virtual ~EWCouplings();
   //@}
 
   /**
    *  Initialize the running couplings
    */
   void initialize();
 
   /**
    * Number of dynamical quarks at $\log\mu = x$ (in GeV)
    * N.B.Integrate out top quark at Mz, not at Mt.
    */
   unsigned int numberOfFlavours(double x) {
     return x >= std::log(ewScale_/GeV) ? 6 : 5;
   }
    
 public:
    
   /**
    *  Set whether or not to include \f$SU(3)\f$ running
    */
   void SU3(bool includeSU3) {includeSU3_ = includeSU3;}
 
   /**
    *  Whether or not to include \f$SU(3)\f$ running
    */
   bool SU3() { return includeSU3_;}
     
   /**
    *  Set whether or not to include EW running
    */  
   void EW(bool includeEW) {includeEW_ = includeEW;}
 
   /**
    *  Whether or not to include EW running
    */
   bool EW() { return includeEW_;}
    
   /**
    *  alpha for the U1 gauge coupling at energy mu (in GeV):
    */
   double a1(Energy mu) {
     if (includeEW_) {
       if (mu>=ewScale_) {
 	return (3.0/5.0)*interpolate(log(mu/GeV),1);
       }
       return interpolateLow(log(mu/GeV),1);
     }
     else
       return 0.0;
   }
 
   /**
    *  alpha for the SU2 gauge coupling at energy mu (in GeV):
    */
   double a2(Energy mu) {
     if (includeEW_) {
       if (mu<ewScale_) {
 	return 0.0;
       }
       else
 	return interpolate(log(mu/GeV),2);
     }
     else
       return 0.0;
   }
 
   /**
    *  alpha for the SU3 gauge coupling at energy mu (in GeV):
    */
   double a3(Energy mu) {
     if(includeSU3_) {
       if (mu>=ewScale_) {
 	return interpolate(log(mu/GeV),3);
       }
       else {
 	return interpolateLow(log(mu/GeV),2);
       }
     }
     else
       return 0.0;
   }
 
   /**
    *  alpha for EM
    */
   double aEM(Energy mu) {
     if (includeEW_) {
       if (mu<=ewScale_) {
 	return interpolateLow(log(mu/GeV),1);
       }
       else {
 	double alpha1=a1(mu);
 	double alpha2=a2(mu);
 	return alpha1*alpha2/(alpha1+alpha2);
       }
     }
     return 0.0;
   }
 
   double aS(Energy mu) {
     if(includeSU3_) {
       if (mu<=ewScale_) {
 	return interpolateLow(log(mu/GeV),2);
       }
       else {
 	return interpolate(log(mu/GeV),3);
       }
     }
     else return 0.0;
   }
 
   /**
    *  Top quark Yukawa coupling
    */
   double y_t(Energy mu) {
     if (includeEW_) {
       if(mu<ewScale_)
 	return 0.0;
       else
 	return interpolate(log(mu/GeV),4);
     }
     else
       return 0.0;
   }
 
   /**
    * Quartic scalar coupling lambda (normalization different, hence factor of 2):
    */
   double lambda(Energy mu) {return 2.0*interpolate(log(mu/GeV),5);}
   
   /**
    *  VEV
    */
   Energy vev(Energy mu) {return interpolate(log(mu/GeV),6)*GeV;}
       
   /**
    * \f$\lambda_t\f$
    */
   double lambda_t(Energy mu) {return y_t(mu);}
       
   /**
    *  Z couplings
    */
   //@{
   double g_Lu(Energy mu) {return 0.5-(2.0/3.0)*Sin2thW(mu);}
   double g_Ld(Energy mu) {return -0.5+(1.0/3.0)*Sin2thW(mu);}
   double g_Le(Energy mu) {return (-1.0/2.0)+Sin2thW(mu);}
   double g_Lnu(Energy ) {return (0.5);}
   double g_Ru(Energy mu) {return (-2.0/3.0)*Sin2thW(mu);}
   double g_Rd(Energy mu) {return (1.0/3.0)*Sin2thW(mu);}
   double g_Re(Energy mu) {return Sin2thW(mu);}
   double g_W(Energy mu) {return Cos2thW(mu);}
   double g_phiPlus(Energy mu) {return 0.5-Sin2thW(mu);}
   //@}
 
   /**
    *  \f\cos^2\theta_W\f$
    */
   double Cos2thW(Energy ) {
     //\todo why this value?
     //return mW()*mW()/(mZ()*mZ());
     return (1.-0.2314);
   }
 
   /**
    *  \f\sin^2\theta_W\f$
    */
   double Sin2thW(Energy mu) {return 1.-Cos2thW(mu);}
 
   double aW(Energy mu) {return a2(mu);}
 
   double aZ(Energy mu) {
     //return a2(mu)/Cos2thW(mu); // Same thing, actually
     return a1(mu)+a2(mu);
   }
 
 public: 
 
   /**
    *  Masses of the Standard Model particles
    */
   //@{
   /**
    *  Z mass
    */
   Energy mZ() const { return mZ_;}
  
   /**
    *  W Mass
    */
   Energy mW() const { return mW_;}
 
   /**
    *  Top quark mass
    */
   Energy mT() const {return mT_;}
 
   Energy mTatmZ() { return mT_;}
 
   /**
    *  Higg boson mass
    */
   Energy mH() const {return mH_;}
   //@}
 
 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;
   //@}
 
 private:
 
   /**
    *  Set the initial value of the couplings
    */
   void initializeCouplings(vector<Complex> & y);
 
   /**
    * Assigns numerical values to beta functions 
    * Takes in a point x = log(mu) and the values of y[i] at x and assigns dydx[i] the 
    * value beta[i](mu).  The function Derivs farms out the plugging in to the three
    * functions BetaGauge, BetaYukawa, and BetaHiggs, which evaluates the beta functions
    * for the gauge couplings, yukawa matrices, and higgs quartic coupling/vev, respectively.
    */
   void derivatives(const double x, vector< Complex > &y,
 		   vector< Complex > & dydx);
 
   /**
    * Beta function for the gauge interactions
    */
   void betaGauge(const double x, vector<Complex> &y, vector<Complex> &dydx);
 
   /**
    * Beta function for the gauge interactions at low scales
    */
   void lowBetaGauge(const double x, vector<Complex> &y, vector<Complex> &dydx);
 
   /**
    * Beta function for the Yukawa interactions
    */
   void betaYukawa(const double x, vector<Complex> &y, vector<Complex> &dydx);
 
   /**
    * Beta function for the Higgs interactions
    */
   void betaHiggs(const double x, vector<Complex> &y, vector<Complex> &dydx);
 
   /**
    *  Update the couplings using 4-th order RK
    * Takes in a vector y[i] of function values at a point x and the values of the 
    * first derivatives dydx[i] ( = dy[i]/dx ) alon with a step size stepsize. The 
    * function then defines assigns the value of y[i](x+stepsize) to the variable yout[i].
    * (Adapted from sample code in Numerical Recipes in C++ Press, Teukolsky, et. al.)
    */
   void RK4(vector<Complex> & y, vector<Complex> &dydx, const double x, 
 	   const double stepsize, vector<Complex> &yout);
 
   /**
    *  Initialize the low energy parameters
    */
   void initializeLow();
 
   /**
    *  Interpolate the table,  t = ln(mu)
    */
   double interpolate(double t, int paramIndex);
 
   /**
    *  Interpolate the tabel, t = ln(mu)
    */
   double interpolateLow(double t, int paramIndex);
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
-  EWCouplings & operator=(const EWCouplings &);
+  EWCouplings & operator=(const EWCouplings &) = delete;
 
 private:
 
   /**
    *  Electoweak Scale
    */
   Energy ewScale_;
 
   /**
    *  High Scale
    */
   Energy highScale_;
 
   /**
    *  Low Scale
    */
   Energy lowScale_;
 
   /**
    *  Whether or not to include SU3
    */
   bool includeSU3_;
 
   /**
    *  Whether or not to include EW
    */
   bool includeEW_;
 
   /**
    *  Whether or not the running couplings have been initialized
    */
   bool initialized_;
 
   /**
    *  Masses of Standard Model particles
    */
   //@{
   /**
    *  Mass Choice
    */
   bool massChoice_;
 
   /**
    *   Z mass 
    */
   Energy mZ_;
 
   /**
    *   W mass 
    */
   Energy mW_;
 
   /**
    *  Top mass
    */
   Energy mT_;
 
   /**
    *  Higgs boson mass
    */
   Energy mH_;
   //@}
 
   /**
    *  Number of loops
    */
   unsigned int loops_;
 
   /**
    *  Number of steps for Runga-Kutta (High scale)
    */
   unsigned int highSteps_;
 
   /**
    *  Number of steps for Runga-Kutta (Low scale)
    */
   unsigned int lowSteps_;
 
   /**
    *  Matrix to store the parameters
    */
   boost::numeric::ublas::matrix<double> table_;
 
   /**
    *  Matrix to store the low energy parameters.
    *  This will hold only aEM and a3 at mu<ewScale
    */
   boost::numeric::ublas::matrix<double> lowTable_;
 
   /**
    *  Input values of the couplings
    */
   //@{
   /**
    *   \f%\alpha_1(M_Z)\f$
    */
   double a1MZ_;
 
   /**
    *   \f%\alpha_2(M_Z)\f$
    */
   double a2MZ_;
 
   /**
    *   \f%\alpha_S(M_Z)\f$
    */
   double aSMZ_;
 
   /**
    *  \f$\lambda_t\f$
    */
   double lambdat_;
   //@}
 
 };
 
 }
 
 #endif /* Herwig_EWCouplings_H */
diff --git a/MatrixElement/EW/ElectroWeakReweighter.h b/MatrixElement/EW/ElectroWeakReweighter.h
--- a/MatrixElement/EW/ElectroWeakReweighter.h
+++ b/MatrixElement/EW/ElectroWeakReweighter.h
@@ -1,212 +1,212 @@
 // -*- C++ -*-
 #ifndef Herwig_ElectroWeakReweighter_H
 #define Herwig_ElectroWeakReweighter_H
 //
 // This is the declaration of the ElectroWeakReweighter class.
 //
 
 #include "ThePEG/MatrixElement/ReweightBase.h"
 #include "EWCouplings.h"
 #include "CollinearSudakov.h"
 #include "SoftSudakov.h"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * The ElectroWeakReweighter class.
  *
  * @see \ref ElectroWeakReweighterInterfaces "The interfaces"
  * defined for ElectroWeakReweighter.
  */
 class ElectroWeakReweighter: public ReweightBase {
 
 public:
 
   /** @name Standard constructors and destructors. */
   //@{
   /**
    * The default constructor.
    */
   ElectroWeakReweighter();
 
   /**
    * The destructor.
    */
   virtual ~ElectroWeakReweighter();
   //@}  
 
 public:
 
   /**
    * Return the weight for the kinematical configuation provided by
    * the assigned XComb object (in the LastXCombInfo base class).
    */
   virtual double weight() const;
 
   /**
    *
    */
   static tEWCouplingsPtr coupling() {
     assert(staticEWCouplings_);
     return staticEWCouplings_;
   }
 
 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:
 
   /**
    *  Functions to reweight specific processes
    */
   //@{
   /**
    *  Reweight \f$g g\to q\bar{q}\f$
    */
   double reweightggqqbar() const;
 
   /**
    *  Reweight \f$q\bar{q}\to g g\f$
    */
   double reweightqqbargg() const;
 
   /**
    *  Reweight \f$q g\to qg\f$
    */
   double reweightqgqg() const;
 
   /**
    *  Reweight \f$q g\to qg\f$
    */
   double reweightqbargqbarg() const;
 
   /**
    *  Reweight \f$q\bar{q}\to q'\bar{q'}\f$ (s-channel)
    */
   double reweightqqbarqqbarS() const;
 
   /**
    *  Reweight \f$q\bar{q}\to q'\bar{q'}\f$ (t-channel)
    */
   double reweightqqbarqqbarT() const;
 
   /**
    *  Reweight \f$qq \to qq\f$
    */
   double reweightqqqq() const;
 
   /**
    *  Reweight \f$\bar{q}\bar{q} \to \bar{q}\bar{q}\f$
    */
   double reweightqbarqbarqbarqbar() const;
   //@}
 
 protected:
 
   /**
    *  Check the evolution for a fixed s,t,u
    */
   void testEvolution(Energy2 s,Energy2 t, Energy2 u) const;
 
   /**
    *  Evalaute the running
    */
   boost::numeric::ublas::matrix<complex<InvEnergy2> >
   evaluateRunning(EWProcess::Process process, Energy2 s,
 		  Energy2 t, Energy2 u, bool born,
 		  unsigned int iswap) 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();
   //@}
 
 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;
   //@}
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
-  ElectroWeakReweighter & operator=(const ElectroWeakReweighter &);
+  ElectroWeakReweighter & operator=(const ElectroWeakReweighter &) = delete;
 
 private:
 
   /**
    *  The Electroweak Couplings
    */
   EWCouplingsPtr EWCouplings_;
 
   /**
    *  The Collinear Sudakov
    */
   CollinearSudakovPtr collinearSudakov_;
 
   /**
    *  The Soft Sudakov
    */
   SoftSudakovPtr softSudakov_;
 
   /**
    *  The couplings to allow global access
    */
   static tEWCouplingsPtr staticEWCouplings_;
 
   /**
    *  Whether or not to output testing information
    */
   bool testing_;
 
 };
 
 }
 
 #endif /* Herwig_ElectroWeakReweighter_H */
diff --git a/MatrixElement/EW/SoftSudakov.h b/MatrixElement/EW/SoftSudakov.h
--- a/MatrixElement/EW/SoftSudakov.h
+++ b/MatrixElement/EW/SoftSudakov.h
@@ -1,198 +1,198 @@
 // -*- C++ -*-
 #ifndef Herwig_SoftSudakov_H
 #define Herwig_SoftSudakov_H
 //
 // This is the declaration of the SoftSudakov class.
 //
 
 #include "ThePEG/Interface/Interfaced.h"
 #include "Herwig/Utilities/GSLIntegrator.h"
 // work around a Boost 1.64 bug where ublas headers would fail otherwise
 #include <boost/version.hpp>
 #if (BOOST_VERSION / 100 >= 1064)
 #include <boost/serialization/array_wrapper.hpp>
 #endif
 #include <boost/numeric/ublas/matrix.hpp>
 #include "EWProcess.h"
 #include "SoftSudakov.fh"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * Here is the documentation of the SoftSudakov class.
  *
  * @see \ref SoftSudakovInterfaces "The interfaces"
  * defined for SoftSudakov.
  */
 class SoftSudakov: public Interfaced {
 
 public:
 
   /** @name Standard constructors and destructors. */
   //@{
   /**
    * The default constructor.
    */
   SoftSudakov();
 
   /**
    * The destructor.
    */
   virtual ~SoftSudakov();
   //@}
 
 public:
 
   /**
    *  Low energy soft evolution
    */
   boost::numeric::ublas::matrix<Complex>
   lowEnergyRunning(Energy EWScale, Energy lowScale, 
 		   Energy2 s, Energy2 t, Energy2 u,
 		   Herwig::EWProcess::Process process,
 		   unsigned int iswap);
   
   /**
    *  Evalaute the high energy running as a matrix
    */
   boost::numeric::ublas::matrix<Complex>
   highEnergyRunning(Energy highScale, Energy EWScale,
 		    Energy2 s, Energy2 t, Energy2 u,
 		    Herwig::EWProcess::Process process,
 		    unsigned int iswap);
 
   /**
    *  Number of operators for the broken theory at low energy
    */
   unsigned int numberBrokenGauge(Herwig::EWProcess::Process process);
 
   /**
    *  Number of operators for the unbroken theory at high energy
    */
   unsigned int numberGauge(Herwig::EWProcess::Process process);
 
 protected:
       
   /**
    *  Evaluate the soft evolution 
    */
   boost::numeric::ublas::matrix<Complex> evaluateSoft(boost::numeric::ublas::matrix<Complex> & G3,
 						      boost::numeric::ublas::matrix<Complex> & G2,
 						      boost::numeric::ublas::matrix<Complex> & G1,
 						      Energy mu_h, Energy mu_l, bool high);
 
 public:
 
   /**
    *  The operator to be integrated
    */
   InvEnergy operator ()(Energy mu) const;
   /** Argument type for GaussianIntegrator */
   typedef Energy ArgType;
   /** Return type for GaussianIntegrator */
   typedef InvEnergy ValType;
 
 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;
   //@}
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
-  SoftSudakov & operator=(const SoftSudakov &);
+  SoftSudakov & operator=(const SoftSudakov &) = delete;
 
 private:
 
   /**
    *  Order for K
    */
   unsigned int K_ORDER_;
 
   /**
    *  Integrator
    */
   GSLIntegrator integrator_;
 
   /**
    *  Whether doing the high or low scale contribution
    */
   bool high_;
 
   /**
    *  Column
    */
   unsigned int row_; 
 
   /**
    *  Row
    */
   unsigned int col_; 
 
   /**
    *
    */
   bool real_; 
 
   /**
    *
    */
   boost::numeric::ublas::matrix<Complex> G1_;
 
   /**
    *
    */
   boost::numeric::ublas::matrix<Complex> G2_;
 
   /**
    *
    */
   boost::numeric::ublas::matrix<Complex> G3_;
 };
 
 }
 
 #endif /* Herwig_SoftSudakov_H */
diff --git a/Shower/Base/ShowerBasis.h b/Shower/Base/ShowerBasis.h
--- a/Shower/Base/ShowerBasis.h
+++ b/Shower/Base/ShowerBasis.h
@@ -1,135 +1,135 @@
 // -*- C++ -*-
 #ifndef Herwig_ShowerBasis_H
 #define Herwig_ShowerBasis_H
 //
 // This is the declaration of the ShowerBasis class.
 //
 
 #include "ShowerBasis.fh"
 #include "ShowerParticle.fh"
 #include "Herwig/Shower/ShowerConfig.h"
 #include "ThePEG/Config/ThePEG.h"
 #include "ThePEG/Vectors/Lorentz5Vector.h"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * The ShowerBasis class stores the basis vectors used by the shower
  */
 class ShowerBasis: public Base {
 
 public:
 
   /**
    *   enum for the frame definition
    */
   enum Frame {BackToBack,Rest};
 
 public:
 
   /**
    * The default constructor.
    */
   ShowerBasis() {}
   
   /**
    * Access to the frame definition
    */
   Frame frame() const {return frame_;}
   
   /**
    *  Set the frame definition
    */
   void frame(Frame frame) {frame_ = frame;}
 
   /**
    * Implementation of the virtual function returning a set of basis vectors, specific to
    * the type of evolution.  This function will be used by the
    * ForwardShowerEvolver in order to access \f$p\f$
    * and \f$n\f$.
    */
   virtual vector<Lorentz5Momentum> getBasis() const; 
 
   /**
    *  Set the basis vectors
    */
   void setBasis(const Lorentz5Momentum &p, const Lorentz5Momentum & n,
 		Frame frame);
 
   /**
    * Access to the \f$p\f$ vector used to describe the kinematics.
    */
   const Lorentz5Momentum & pVector() const {return pVector_;}
 
   /**
    * Access to the \f$n\f$ vector used to describe the kinematics.
    */
   const Lorentz5Momentum & nVector() const {return nVector_;}
 
   /**
    *  Dot product of thew basis vectors
    */
   Energy2 p_dot_n() const {return pVector_*nVector_;}
 
   /**
    *  Transform the shower kinematics (usually the reference vectors)
    */
   virtual void transform(const LorentzRotation & r);
 
   /**
    * Converts a Sudakov parametrization of a momentum w.r.t. the given 
    * basis \f$p\f$ and \f$n\f$ into a 5 momentum.
    * @param alpha The \f$\alpha\f$ parameter of the Sudakov parameterisation
    * @param beta  The \f$\beta\f$ parameter of the Sudakov parameterisation
    * @param px    The \f$x\f$-component of the transverse momentum in the Sudakov 
    *              parameterisation
    * @param py    The \f$x\f$-component of the transverse momentum in the Sudakov 
    *              parameterisation
    */
   Lorentz5Momentum sudakov2Momentum(double alpha, double beta,
 				    Energy px, Energy py) const {
     return alpha*pVector_ + beta*nVector_ + px*xPerp_ + py*yPerp_;
   }
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
-  ShowerBasis & operator=(const ShowerBasis &);
+  ShowerBasis & operator=(const ShowerBasis &) = delete;
 
 private:
 
   /**
    *  The frame in which the basis vectors are defined
    */
   Frame frame_;
 
   /**
    *  The \f$p\f$ reference vector
    */
   Lorentz5Momentum pVector_;
 
   /**
    *  The \f$n\f$ reference vector
    */
   Lorentz5Momentum nVector_;
 
   /**
    *  x \f$q_\perp\f$ reference vector
    */
   LorentzVector<double> xPerp_;
 
   /**
    *  y \f$q_\perp\f$reference vector
    */
   LorentzVector<double> yPerp_;
 
 };
 
 }
 
 #endif /* Herwig_ShowerBasis_H */
diff --git a/Shower/QTilde/SplittingFunctions/HalfHalfOneEWSplitFn.h b/Shower/QTilde/SplittingFunctions/HalfHalfOneEWSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/HalfHalfOneEWSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/HalfHalfOneEWSplitFn.h
@@ -1,212 +1,212 @@
 // -*- C++ -*-
 #ifndef Herwig_HalfHalfOneEWSplitFn_H
 #define Herwig_HalfHalfOneEWSplitFn_H
 //
 // This is the declaration of the HalfHalfOneEWSplitFn class.
 //
 
 #include "SplittingFunction.h"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * The HalfHalfOneEWSplitFn class implements the splitting function for 
  * \f$\frac12\to q\frac12 1\f$ where the spin-1 particle is a massive electroweak gauge boson.
  *
  * @see \ref HalfHalfOneEWSplitFnInterfaces "The interfaces"
  * defined for HalfHalfOneEWSplitFn.
  */
 class HalfHalfOneEWSplitFn: 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 & gL, double & gR, 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.
    */
-  HalfHalfOneEWSplitFn & operator=(const HalfHalfOneEWSplitFn &);
+  HalfHalfOneEWSplitFn & operator=(const HalfHalfOneEWSplitFn &) = delete;
 
 private:
 
   /**
    *  Z couplings
    */
   map<long,pair<double,double> > gZ_;
 
   /**
    *  W couplings
    */
   double gWL_;
 
 };
 
 }
 
 #endif /* Herwig_HalfHalfOneEWSplitFn_H */