No OneTemporary
Actions

Size

294 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/Shower/Base/Evolver.cc b/Shower/Base/Evolver.cc
	--- a/Shower/Base/Evolver.cc
	+++ b/Shower/Base/Evolver.cc
	@@ -1,3220 +1,3220 @@
	// -- C++ --
	//
	// Evolver.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 Evolver class.
	//
	#include "Evolver.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/Reference.h"
	#include "ThePEG/Interface/RefVector.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "Herwig/Shower/Base/ShowerParticle.h"
	#include "ThePEG/Utilities/EnumIO.h"
	#include "ShowerKinematics.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/Handlers/EventHandler.h"
	#include "ThePEG/Utilities/Throw.h"
	#include "ShowerTree.h"
	#include "ShowerProgenitor.h"
	#include "KinematicsReconstructor.h"
	#include "PartnerFinder.h"
	#include "ThePEG/Handlers/StandardXComb.h"
	#include "ThePEG/PDT/DecayMode.h"
	#include "Herwig/Shower/ShowerHandler.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ShowerVertex.h"
	#include "ThePEG/Repository/CurrentGenerator.h"
	#include "Herwig/MatrixElement/Matchbox/Base/SubtractedME.h"
	#include "Herwig/MatrixElement/Matchbox/MatchboxFactory.h"
	#include "ThePEG/Handlers/StandardXComb.h"

	using namespace Herwig;

	namespace {

	/**
	* A struct to order the particles in the same way as in the DecayMode's
	*/
	struct ParticleOrdering {
	/**
	* Operator for the ordering
	* @param p1 The first ParticleData object
	* @param p2 The second ParticleData object
	*/
	bool operator() (tcPDPtr p1, tcPDPtr p2) {
	return abs(p1->id()) > abs(p2->id()) \|\|
	( abs(p1->id()) == abs(p2->id()) && p1->id() > p2->id() ) \|\|
	( p1->id() == p2->id() && p1->fullName() > p2->fullName() );
	}
	};
	typedef multiset<tcPDPtr,ParticleOrdering> OrderedParticles;

	/**
	* Cached lookup of decay modes.
	* Generator::findDecayMode() is not efficient.
	*/
	tDMPtr findDecayMode(const string & tag) {
	static map<string,DMPtr> cache;
	map<string,DMPtr>::const_iterator pos = cache.find(tag);

	if ( pos != cache.end() )
	return pos->second;

	tDMPtr dm = CurrentGenerator::current().findDecayMode(tag);
	cache[tag] = dm;
	return dm;
	}
	}

	DescribeClass<Evolver,Interfaced>
	describeEvolver ("Herwig::Evolver","HwShower.so");

	bool Evolver::_hardEmissionModeWarn = true;
	bool Evolver::_missingTruncWarn = true;

	IBPtr Evolver::clone() const {
	return new_ptr(*this);
	}

	IBPtr Evolver::fullclone() const {
	return new_ptr(*this);
	}

	void Evolver::persistentOutput(PersistentOStream & os) const {
	os << _model << _splittingGenerator << _maxtry
	<< _meCorrMode << _hardVetoMode << _hardVetoRead << _hardVetoReadOption
	<< _limitEmissions << _spinOpt << _softOpt << _hardPOWHEG
	<< ounit(_iptrms,GeV) << _beta << ounit(_gamma,GeV) << ounit(_iptmax,GeV)
	<< _vetoes << _trunc_Mode << _hardEmissionMode << _reconOpt
	<< isMCatNLOSEvent << isMCatNLOHEvent
	<< isPowhegSEvent << isPowhegHEvent
	<< theFactorizationScaleFactor << theRenormalizationScaleFactor << ounit(muPt,GeV)
	<< oenum(interaction_) << _maxTryFSR << _maxFailFSR << _fracFSR;
	}

	void Evolver::persistentInput(PersistentIStream & is, int) {
	is >> _model >> _splittingGenerator >> _maxtry
	>> _meCorrMode >> _hardVetoMode >> _hardVetoRead >> _hardVetoReadOption
	>> _limitEmissions >> _spinOpt >> _softOpt >> _hardPOWHEG
	>> iunit(_iptrms,GeV) >> _beta >> iunit(_gamma,GeV) >> iunit(_iptmax,GeV)
	>> _vetoes >> _trunc_Mode >> _hardEmissionMode >> _reconOpt
	>> isMCatNLOSEvent >> isMCatNLOHEvent
	>> isPowhegSEvent >> isPowhegHEvent
	>> theFactorizationScaleFactor >> theRenormalizationScaleFactor >> iunit(muPt,GeV)
	>> ienum(interaction_) >> _maxTryFSR >> _maxFailFSR >> _fracFSR;
	}

	void Evolver::doinit() {
	Interfaced::doinit();
	// calculate max no of FSR vetos
	_maxFailFSR = max(int(_maxFailFSR), int(_fracFSR*double(generator()->N())));
	}

	void Evolver::Init() {

	static ClassDocumentation<Evolver> documentation
	("This class is responsible for carrying out the showering,",
	"including the kinematics reconstruction, in a given scale range,"
	"including the option of the POWHEG approach to simulated next-to-leading order"
	" radiation\\cite{Nason:2004rx}.",
	"%\\cite{Nason:2004rx}\n"
	"\\bibitem{Nason:2004rx}\n"
	" P.~Nason,\n"
	" ``A new method for combining NLO QCD with shower Monte Carlo algorithms,''\n"
	" JHEP {\\bf 0411} (2004) 040\n"
	" [arXiv:hep-ph/0409146].\n"
	" %%CITATION = JHEPA,0411,040;%%\n");

	static Reference<Evolver,SplittingGenerator>
	interfaceSplitGen("SplittingGenerator",
	"A reference to the SplittingGenerator object",
	&Herwig::Evolver::_splittingGenerator,
	false, false, true, false);

	static Reference<Evolver,ShowerModel> interfaceShowerModel
	("ShowerModel",
	"The pointer to the object which defines the shower evolution model.",
	&Evolver::_model, false, false, true, false, false);

	static Parameter<Evolver,unsigned int> interfaceMaxTry
	("MaxTry",
	"The maximum number of attempts to generate the shower from a"
	" particular ShowerTree",
	&Evolver::_maxtry, 100, 1, 1000,
	false, false, Interface::limited);

	static Switch<Evolver, unsigned int> ifaceMECorrMode
	("MECorrMode",
	"Choice of the ME Correction Mode",
	&Evolver::_meCorrMode, 1, false, false);
	static SwitchOption off
	(ifaceMECorrMode,"No","MECorrections off", 0);
	static SwitchOption on
	(ifaceMECorrMode,"Yes","hard+soft on", 1);
	static SwitchOption hard
	(ifaceMECorrMode,"Hard","only hard on", 2);
	static SwitchOption soft
	(ifaceMECorrMode,"Soft","only soft on", 3);

	static Switch<Evolver, unsigned int> ifaceHardVetoMode
	("HardVetoMode",
	"Choice of the Hard Veto Mode",
	&Evolver::_hardVetoMode, 1, false, false);
	static SwitchOption HVoff
	(ifaceHardVetoMode,"No","hard vetos off", 0);
	static SwitchOption HVon
	(ifaceHardVetoMode,"Yes","hard vetos on", 1);
	static SwitchOption HVIS
	(ifaceHardVetoMode,"Initial", "only IS emissions vetoed", 2);
	static SwitchOption HVFS
	(ifaceHardVetoMode,"Final","only FS emissions vetoed", 3);

	static Switch<Evolver, unsigned int> ifaceHardVetoRead
	("HardVetoScaleSource",
	"If hard veto scale is to be read",
	&Evolver::_hardVetoRead, 0, false, false);
	static SwitchOption HVRcalc
	(ifaceHardVetoRead,"Calculate","Calculate from hard process", 0);
	static SwitchOption HVRread
	(ifaceHardVetoRead,"Read","Read from XComb->lastScale", 1);

	static Switch<Evolver, bool> ifaceHardVetoReadOption
	("HardVetoReadOption",
	"Apply read-in scale veto to all collisions or just the primary one?",
	&Evolver::_hardVetoReadOption, false, false, false);
	static SwitchOption AllCollisions
	(ifaceHardVetoReadOption,
	"AllCollisions",
	"Read-in pT veto applied to primary and secondary collisions.",
	false);
	static SwitchOption PrimaryCollision
	(ifaceHardVetoReadOption,
	"PrimaryCollision",
	"Read-in pT veto applied to primary but not secondary collisions.",
	true);

	static Parameter<Evolver, Energy> ifaceiptrms
	("IntrinsicPtGaussian",
	"RMS of intrinsic pT of Gaussian distribution:\n"
	"2(1-Beta)exp(-sqr(intrinsicpT/RMS))/sqr(RMS)",
	&Evolver::_iptrms, GeV, ZERO, ZERO, 1000000.0*GeV,
	false, false, Interface::limited);

	static Parameter<Evolver, double> ifacebeta
	("IntrinsicPtBeta",
	"Proportion of inverse quadratic distribution in generating intrinsic pT.\n"
	"(1-Beta) is the proportion of Gaussian distribution",
	&Evolver::_beta, 0, 0, 1,
	false, false, Interface::limited);

	static Parameter<Evolver, Energy> ifacegamma
	("IntrinsicPtGamma",
	"Parameter for inverse quadratic:\n"
	"2BetaGamma/(sqr(Gamma)+sqr(intrinsicpT))",
	&Evolver::_gamma,GeV, ZERO, ZERO, 100000.0*GeV,
	false, false, Interface::limited);

	static Parameter<Evolver, Energy> ifaceiptmax
	("IntrinsicPtIptmax",
	"Upper bound on intrinsic pT for inverse quadratic",
	&Evolver::_iptmax,GeV, ZERO, ZERO, 100000.0*GeV,
	false, false, Interface::limited);

	static RefVector<Evolver,ShowerVeto> ifaceVetoes
	("Vetoes",
	"The vetoes to be checked during showering",
	&Evolver::_vetoes, -1,
	false,false,true,true,false);

	static Switch<Evolver,unsigned int> interfaceLimitEmissions
	("LimitEmissions",
	"Limit the number and type of emissions for testing",
	&Evolver::_limitEmissions, 0, false, false);
	static SwitchOption interfaceLimitEmissionsNoLimit
	(interfaceLimitEmissions,
	"NoLimit",
	"Allow an arbitrary number of emissions",
	0);
	static SwitchOption interfaceLimitEmissionsOneInitialStateEmission
	(interfaceLimitEmissions,
	"OneInitialStateEmission",
	"Allow one emission in the initial state and none in the final state",
	1);
	static SwitchOption interfaceLimitEmissionsOneFinalStateEmission
	(interfaceLimitEmissions,
	"OneFinalStateEmission",
	"Allow one emission in the final state and none in the initial state",
	2);
	static SwitchOption interfaceLimitEmissionsHardOnly
	(interfaceLimitEmissions,
	"HardOnly",
	"Only allow radiation from the hard ME correction",
	3);
	static SwitchOption interfaceLimitEmissionsOneEmission
	(interfaceLimitEmissions,
	"OneEmission",
	"Allow one emission in either the final state or initial state, but not both",
	4);

	static Switch<Evolver,bool> interfaceTruncMode
	("TruncatedShower", "Include the truncated shower?",
	&Evolver::_trunc_Mode, 1, false, false);
	static SwitchOption interfaceTruncMode0
	(interfaceTruncMode,"No","Truncated Shower is OFF", 0);
	static SwitchOption interfaceTruncMode1
	(interfaceTruncMode,"Yes","Truncated Shower is ON", 1);

	static Switch<Evolver,int> interfaceHardEmissionMode
	("HardEmissionMode",
	"Whether to use ME corrections or POWHEG for the hardest emission",
	&Evolver::_hardEmissionMode, 0, false, false);
	static SwitchOption interfaceHardEmissionModeDecayMECorrection
	(interfaceHardEmissionMode,
	"DecayMECorrection",
	"Old fashioned ME correction for decays only",
	-1);
	static SwitchOption interfaceHardEmissionModeMECorrection
	(interfaceHardEmissionMode,
	"MECorrection",
	"Old fashioned ME correction",
	0);
	static SwitchOption interfaceHardEmissionModePOWHEG
	(interfaceHardEmissionMode,
	"POWHEG",
	"Powheg style hard emission using internal matrix elements",
	1);
	static SwitchOption interfaceHardEmissionModeMatchboxPOWHEG
	(interfaceHardEmissionMode,
	"MatchboxPOWHEG",
	"Powheg style emission for the hard process using Matchbox",
	2);
	static SwitchOption interfaceHardEmissionModeFullPOWHEG
	(interfaceHardEmissionMode,
	"FullPOWHEG",
	"Powheg style emission for the hard process using Matchbox "
	"and decays using internal matrix elements",
	3);

	static Switch<Evolver,ShowerInteraction::Type > interfaceInteraction
	("Interaction",
	"The interactions to be used in the shower",
	&Evolver::interaction_, ShowerInteraction::QEDQCD, false, false);
	static SwitchOption interfaceInteractionQCD
	(interfaceInteraction,
	"QCDOnly",
	"Only QCD",
	ShowerInteraction::QCD);
	static SwitchOption interfaceInteractionQEDOnly
	(interfaceInteraction,
	"QEDOnly",
	"Only QED",
	ShowerInteraction::QED);
	static SwitchOption interfaceInteractionBothAtOnce
	(interfaceInteraction,
	"QEDQCD",
	"QED and QCD",
	ShowerInteraction::QEDQCD);

	static Switch<Evolver,unsigned int> interfaceReconstructionOption
	("ReconstructionOption",
	"Treatment of the reconstruction of the transverse momentum of "
	"a branching from the evolution scale.",
	&Evolver::_reconOpt, 0, false, false);
	static SwitchOption interfaceReconstructionOptionCutOff
	(interfaceReconstructionOption,
	"CutOff",
	"Use the cut-off masses in the calculation",
	0);
	static SwitchOption interfaceReconstructionOptionOffShell
	(interfaceReconstructionOption,
	"OffShell",
	"Use the off-shell masses in the calculation veto the emission of the parent,"
	" no veto in generation of emissions from children",
	1);
	static SwitchOption interfaceReconstructionOptionOffShell2
	(interfaceReconstructionOption,
	"OffShell2",
	"Use the off-shell masses in the calculation veto the emissions from the children."
	" no veto in generation of emissions from children",
	2);
	static SwitchOption interfaceReconstructionOptionOffShell3
	(interfaceReconstructionOption,
	"OffShell3",
	"Use the off-shell masses in the calculation veto the emissions from the children."
	" veto in generation of emissions from children using cut-off for second parton",
	3);

	static Switch<Evolver,unsigned int> interfaceSpinCorrelations
	("SpinCorrelations",
	"Treatment of spin correlations in the parton shower",
	&Evolver::_spinOpt, 1, false, false);
	static SwitchOption interfaceSpinCorrelationsOff
	(interfaceSpinCorrelations,
	"No",
	"No spin correlations",
	0);
	static SwitchOption interfaceSpinCorrelationsSpin
	(interfaceSpinCorrelations,
	"Yes",
	"Include the azimuthal spin correlations only",
	1);

	static Switch<Evolver,unsigned int> interfaceSoftCorrelations
	("SoftCorrelations",
	"Option for the treatment of soft correlations in the parton shower",
	&Evolver::_softOpt, 2, false, false);
	static SwitchOption interfaceSoftCorrelationsNone
	(interfaceSoftCorrelations,
	"No",
	"No soft correlations",
	0);
	static SwitchOption interfaceSoftCorrelationsFull
	(interfaceSoftCorrelations,
	"Full",
	"Use the full eikonal",
	1);
	static SwitchOption interfaceSoftCorrelationsSingular
	(interfaceSoftCorrelations,
	"Singular",
	"Use original Webber-Marchisini form",
	2);

	static Switch<Evolver,bool> interfaceHardPOWHEG
	("HardPOWHEG",
	"Treatment of powheg emissions which are too hard to have a shower interpretation",
	&Evolver::_hardPOWHEG, false, false, false);
	static SwitchOption interfaceHardPOWHEGAsShower
	(interfaceHardPOWHEG,
	"AsShower",
	"Still interpret as shower emissions",
	false);
	static SwitchOption interfaceHardPOWHEGRealEmission
	(interfaceHardPOWHEG,
	"RealEmission",
	"Generate shower from the real emmission configuration",
	true);

	static Parameter<Evolver,unsigned int> interfaceMaxTryFSR
	("MaxTryFSR",
	"The maximum number of attempted FSR emissions in"
	" the generation of the FSR",
	&Evolver::_maxTryFSR, 100000, 10, 100000000,
	false, false, Interface::limited);

	static Parameter<Evolver,unsigned int> interfaceMaxFailFSR
	("MaxFailFSR",
	"Maximum number of failures generating the FSR",
	&Evolver::_maxFailFSR, 100, 1, 100000000,
	false, false, Interface::limited);


	static Parameter<Evolver,double> interfaceFSRFailureFraction
	("FSRFailureFraction",
	"Maximum fraction of events allowed to fail due to too many FSR emissions",
	&Evolver::_fracFSR, 0.001, 1e-10, 1,
	false, false, Interface::limited);
	}

	void Evolver::generateIntrinsicpT(vector<ShowerProgenitorPtr> particlesToShower) {
	_intrinsic.clear();
	if ( !ipTon() \|\| !isISRadiationON() ) return;
	// don't do anything for the moment for secondary scatters
	if( !ShowerHandler::currentHandler()->firstInteraction() ) return;
	// generate intrinsic pT
	for(unsigned int ix=0;ix<particlesToShower.size();++ix) {
	// only consider initial-state particles
	if(particlesToShower[ix]->progenitor()->isFinalState()) continue;
	if(!particlesToShower[ix]->progenitor()->dataPtr()->coloured()) continue;
	Energy ipt;
	if(UseRandom::rnd() > _beta) {
	ipt=_iptrms*sqrt(-log(UseRandom::rnd()));
	}
	else {
	ipt=_gamma*sqrt(pow(1.+sqr(_iptmax/_gamma), UseRandom::rnd())-1.);
	}
	pair<Energy,double> pt = make_pair(ipt,UseRandom::rnd(Constants::twopi));
	_intrinsic[particlesToShower[ix]] = pt;
	}
	}

	void Evolver::setupMaximumScales(const vector<ShowerProgenitorPtr> & p,
	XCPtr xcomb) {
	// let POWHEG events radiate freely
	if(_hardEmissionMode>0&&hardTree()) {
	vector<ShowerProgenitorPtr>::const_iterator ckt = p.begin();
	for (; ckt != p.end(); ckt++) (*ckt)->maxHardPt(Constants::MaxEnergy);
	return;
	}
	// return if no vetos
	if (!hardVetoOn()) return;
	// find out if hard partonic subprocess.
	bool isPartonic(false);
	map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit = _currenttree->incomingLines().begin();
	Lorentz5Momentum pcm;
	for(; cit!=currentTree()->incomingLines().end(); ++cit) {
	pcm += cit->first->progenitor()->momentum();
	isPartonic \|= cit->first->progenitor()->coloured();
	}
	// find minimum pt from hard process, the maximum pt from all outgoing
	// coloured lines (this is simpler and more general than
	// 2stu/(s^2+t^2+u^2)). Maximum scale for scattering processes will
	// be transverse mass.
	Energy ptmax = generator()->maximumCMEnergy();
	// general case calculate the scale
	if (!hardVetoXComb()\|\|
	(hardVetoReadOption()&&
	!ShowerHandler::currentHandler()->firstInteraction())) {
	// scattering process
	if(currentTree()->isHard()) {
	assert(xcomb);
	// coloured incoming particles
	if (isPartonic) {
	map<ShowerProgenitorPtr,tShowerParticlePtr>::const_iterator
	cjt = currentTree()->outgoingLines().begin();
	for(; cjt!=currentTree()->outgoingLines().end(); ++cjt) {
	if (cjt->first->progenitor()->coloured())
	ptmax = min(ptmax,cjt->first->progenitor()->momentum().mt());
	}
	}
	if (ptmax == generator()->maximumCMEnergy() ) ptmax = pcm.m();
	if(hardVetoXComb()&&hardVetoReadOption()&&
	!ShowerHandler::currentHandler()->firstInteraction()) {
	ptmax=min(ptmax,sqrt(xcomb->lastShowerScale()));
	}
	}
	// decay, incoming() is the decaying particle.
	else {
	ptmax = currentTree()->incomingLines().begin()->first
	->progenitor()->momentum().mass();
	}
	}
	// hepeup.SCALUP is written into the lastXComb by the
	// LesHouchesReader itself - use this by user's choice.
	// Can be more general than this.
	else {
	if(currentTree()->isHard()) {
	assert(xcomb);
	ptmax = sqrt( xcomb->lastShowerScale() );
	}
	else {
	ptmax = currentTree()->incomingLines().begin()->first
	->progenitor()->momentum().mass();
	}
	}
	ptmax *= ShowerHandler::currentHandler()->hardScaleFactor();
	// set maxHardPt for all progenitors. For partonic processes this
	// is now the max pt in the FS, for non-partonic processes or
	// processes with no coloured FS the invariant mass of the IS
	vector<ShowerProgenitorPtr>::const_iterator ckt = p.begin();
	for (; ckt != p.end(); ckt++) (*ckt)->maxHardPt(ptmax);
	}

	void Evolver::setupHardScales(const vector<ShowerProgenitorPtr> & p,
	XCPtr xcomb) {
	if ( hardVetoXComb() &&
	(!hardVetoReadOption() \|\|
	ShowerHandler::currentHandler()->firstInteraction()) ) {
	Energy hardScale = ZERO;
	if(currentTree()->isHard()) {
	assert(xcomb);
	hardScale = sqrt( xcomb->lastShowerScale() );
	}
	else {
	hardScale = currentTree()->incomingLines().begin()->first
	->progenitor()->momentum().mass();
	}
	hardScale *= ShowerHandler::currentHandler()->hardScaleFactor();
	vector<ShowerProgenitorPtr>::const_iterator ckt = p.begin();
	for (; ckt != p.end(); ckt++) (*ckt)->hardScale(hardScale);
	muPt = hardScale;
	}
	}

	void Evolver::showerHardProcess(ShowerTreePtr hard, XCPtr xcomb) {


	isMCatNLOSEvent = false;
	isMCatNLOHEvent = false;
	isPowhegSEvent = false;
	isPowhegHEvent = false;

	Ptr<SubtractedME>::tptr subme;
	Ptr<MatchboxMEBase>::tptr me;
	Ptr<SubtractionDipole>::tptr dipme;

	Ptr<StandardXComb>::ptr sxc = dynamic_ptr_cast<Ptr<StandardXComb>::ptr>(xcomb);

	if ( sxc ) {
	subme = dynamic_ptr_cast<Ptr<SubtractedME>::tptr>(sxc->matrixElement());
	me = dynamic_ptr_cast<Ptr<MatchboxMEBase>::tptr>(sxc->matrixElement());
	dipme = dynamic_ptr_cast<Ptr<SubtractionDipole>::tptr>(sxc->matrixElement());
	}

	if ( subme ) {
	if ( subme->showerApproximation() ) {
	theShowerApproximation = subme->showerApproximation();
	// separate MCatNLO and POWHEG-type corrections
	if ( !subme->showerApproximation()->needsSplittingGenerator() ) {
	if ( subme->realShowerSubtraction() )
	isMCatNLOHEvent = true;
	else if ( subme->virtualShowerSubtraction() )
	isMCatNLOSEvent = true;
	}
	else {
	if ( subme->realShowerSubtraction() )
	isPowhegHEvent = true;
	else if ( subme->virtualShowerSubtraction() \|\| subme->loopSimSubtraction() )
	isPowhegSEvent = true;
	}
	}
	} else if ( me ) {
	if ( me->factory()->showerApproximation() ) {
	theShowerApproximation = me->factory()->showerApproximation();
	if ( !me->factory()->showerApproximation()->needsSplittingGenerator() )
	isMCatNLOSEvent = true;
	else
	isPowhegSEvent = true;
	}
	}

	string error = "Inconsistent hard emission set-up in Evolver::showerHardProcess(). ";
	if ( ( isMCatNLOSEvent \|\| isMCatNLOHEvent ) ){
	if (_hardEmissionMode > 1)
	throw Exception() << error
	<< "Cannot generate POWHEG matching with MC@NLO shower "
	<< "approximation. Add 'set Evolver:HardEmissionMode 0' to input file."
	<< Exception::runerror;
	if ( ShowerHandler::currentHandler()->canHandleMatchboxTrunc())
	throw Exception() << error
	<< "Cannot use truncated qtilde shower with MC@NLO shower "
	<< "approximation. Set LHCGenerator:EventHandler"
	<< ":CascadeHandler to '/Herwig/Shower/ShowerHandler' or "
	<< "'/Herwig/DipoleShower/DipoleShowerHandler'."
	<< Exception::runerror;
	}
	else if ( ((isPowhegSEvent \|\| isPowhegHEvent) \|\| dipme) &&
	_hardEmissionMode < 2){
	if ( ShowerHandler::currentHandler()->canHandleMatchboxTrunc())
	throw Exception() << error
	<< "Unmatched events requested for POWHEG shower "
	<< "approximation. Set Evolver:HardEmissionMode to "
	<< "'MatchboxPOWHEG' or 'FullPOWHEG'."
	<< Exception::runerror;
	else if (_hardEmissionModeWarn){
	_hardEmissionModeWarn = false;
	_hardEmissionMode+=2;
	throw Exception() << error
	<< "Unmatched events requested for POWHEG shower "
	<< "approximation. Changing Evolver:HardEmissionMode from "
	<< _hardEmissionMode-2 << " to " << _hardEmissionMode
	<< Exception::warning;
	}
	}

	if ( isPowhegSEvent \|\| isPowhegHEvent) {
	if (theShowerApproximation->needsTruncatedShower() &&
	!ShowerHandler::currentHandler()->canHandleMatchboxTrunc() )
	throw Exception() << error
	<< "Current shower handler cannot generate truncated shower. "
	<< "Set Generator:EventHandler:CascadeHandler to "
	<< "'/Herwig/Shower/PowhegShowerHandler'."
	<< Exception::runerror;
	}
	else if ( dipme && _missingTruncWarn){
	_missingTruncWarn=false;
	throw Exception() << "Warning: POWHEG shower approximation used without "
	<< "truncated shower. Set Generator:EventHandler:"
	<< "CascadeHandler to '/Herwig/Shower/PowhegShowerHandler' and "
	<< "'MEMatching:TruncatedShower Yes'."
	<< Exception::warning;
	}
	else if ( !dipme && _hardEmissionMode > 1 &&
	ShowerHandler::currentHandler()->firstInteraction())
	throw Exception() << error
	<< "POWHEG matching requested for LO events. Include "
	<< "'set Factory:ShowerApproximation MEMatching' in input file."
	<< Exception::runerror;

	_hardme = HwMEBasePtr();
	// extract the matrix element
	tStdXCombPtr lastXC = dynamic_ptr_cast<tStdXCombPtr>(xcomb);
	if(lastXC) {
	_hardme = dynamic_ptr_cast<HwMEBasePtr>(lastXC->matrixElement());
	}
	_decayme = HwDecayerBasePtr();
	// set the current tree
	currentTree(hard);
	hardTree(HardTreePtr());
	// number of attempts if more than one interaction switched on
	unsigned int interactionTry=0;
	do {
	try {
	// generate the showering
	doShowering(true,xcomb);
	// if no vetos return
	return;
	}
	catch (InteractionVeto) {
	currentTree()->clear();
	++interactionTry;
	}
	}
	while(interactionTry<=5);
	throw Exception() << "Too many tries for shower in "
	<< "Evolver::showerHardProcess()"
	<< Exception::eventerror;
	}

	void Evolver::hardMatrixElementCorrection(bool hard) {
	// set the initial enhancement factors for the soft correction
	_initialenhance = 1.;
	_finalenhance = 1.;
	// if hard matrix element switched off return
	if(!MECOn(hard)) return;
	// see if we can get the correction from the matrix element
	// or decayer
	if(hard) {
	if(_hardme&&_hardme->hasMECorrection()) {
	_hardme->initializeMECorrection(_currenttree,
	_initialenhance,_finalenhance);
	if(hardMEC(hard))
	_hardme->applyHardMatrixElementCorrection(_currenttree);
	}
	}
	else {
	if(_decayme&&_decayme->hasMECorrection()) {
	_decayme->initializeMECorrection(_currenttree,
	_initialenhance,_finalenhance);
	if(hardMEC(hard))
	_decayme->applyHardMatrixElementCorrection(_currenttree);
	}
	}
	}

	ShowerParticleVector Evolver::createTimeLikeChildren(tShowerParticlePtr particle, IdList ids) {
	// Create the ShowerParticle objects for the two children of
	// the emitting particle; set the parent/child relationship
	// if same as definition create particles, otherwise create cc
	tcPDPtr pdata[2];
	for(unsigned int ix=0;ix<2;++ix) pdata[ix]=getParticleData(ids[ix+1]);
	if(particle->id()!=ids[0]) {
	for(unsigned int ix=0;ix<2;++ix) {
	tPDPtr cc(pdata[ix]->CC());
	if(cc) pdata[ix]=cc;
	}
	}
	ShowerParticleVector children;
	for(unsigned int ix=0;ix<2;++ix) {
	children.push_back(new_ptr(ShowerParticle(pdata[ix],true)));
	if(children[ix]->id()==_progenitor->id()&&!pdata[ix]->stable())
	children[ix]->set5Momentum(Lorentz5Momentum(_progenitor->progenitor()->mass()));
	else
	children[ix]->set5Momentum(Lorentz5Momentum(pdata[ix]->mass()));
	}
	return children;
	}

	bool Evolver::timeLikeShower(tShowerParticlePtr particle,
	ShowerInteraction::Type type,
	Branching fb, bool first) {
	// don't do anything if not needed
	if(_limitEmissions == 1 \|\| hardOnly() \|\|
	( _limitEmissions == 2 && _nfs != 0) \|\|
	( _limitEmissions == 4 && _nfs + _nis != 0) ) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return false;
	}
	// too many tries
	if(_nFSR>=_maxTryFSR) {
	++_nFailedFSR;
	// too many failed events
	if(_nFailedFSR>=_maxFailFSR)
	throw Exception() << "Too many events have failed due to too many shower emissions, in\n"
	<< "Evolver::timeLikeShower(). Terminating run\n"
	<< Exception::runerror;
	throw Exception() << "Too many attempted emissions in Evolver::timeLikeShower()\n"
	<< Exception::eventerror;
	}
	// generate the emission
	ShowerParticleVector children;
	int ntry=0;
	// generate the emission
	if(!fb.kinematics)
	fb = selectTimeLikeBranching(particle,type,HardBranchingPtr());
	// no emission, return
	if(!fb.kinematics) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return false;
	}
	Branching fc[2];
	bool setupChildren = true;
	while (ntry<50) {
	fc[0] = Branching();
	fc[1] = Branching();
	++ntry;
	assert(fb.kinematics);
	// has emitted
	// Assign the shower kinematics to the emitting particle.
	if(setupChildren) {
	++_nFSR;
	particle->showerKinematics(fb.kinematics);
	// generate phi
	fb.kinematics->phi(fb.sudakov->generatePhiForward(*particle,fb.ids,fb.kinematics));
	// check highest pT
	if(fb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(fb.kinematics->pT());
	// create the children
	children = createTimeLikeChildren(particle,fb.ids);
	// update the children
	particle->showerKinematics()->
	updateChildren(particle, children,fb.type,_reconOpt>=3);
	// update number of emissions
	++_nfs;
	if(_limitEmissions!=0) {
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return true;
	}
	setupChildren = false;
	}
	// select branchings for children
	fc[0] = selectTimeLikeBranching(children[0],type,HardBranchingPtr());
	fc[1] = selectTimeLikeBranching(children[1],type,HardBranchingPtr());
	// old default
	if(_reconOpt==0) {
	// shower the first particle
	if(fc[0].kinematics) timeLikeShower(children[0],type,fc[0],false);
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],false);
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	break;
	}
	// Herwig default
	else if(_reconOpt==1) {
	// shower the first particle
	if(fc[0].kinematics) timeLikeShower(children[0],type,fc[0],false);
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],false);
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	// clean up the vetoed emission
	if(particle->virtualMass()==ZERO) {
	particle->showerKinematics(ShoKinPtr());
	for(unsigned int ix=0;ix<children.size();++ix)
	particle->abandonChild(children[ix]);
	children.clear();
	if(particle->spinInfo()) particle->spinInfo()->decayVertex(VertexPtr());
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	// generate the new emission
	fb = selectTimeLikeBranching(particle,type,HardBranchingPtr());
	// no emission, return
	if(!fb.kinematics) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return false;
	}
	setupChildren = true;
	continue;
	}
	else
	break;
	}
	// veto children
	else if(_reconOpt>=2) {
	// cut-off masses for the branching
	const vector<Energy> & virtualMasses = fb.sudakov->virtualMasses(fb.ids);
	// compute the masses of the children
	Energy masses[3];
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].kinematics) {
	const vector<Energy> & vm = fc[ix].sudakov->virtualMasses(fc[ix].ids);
	Energy2 q2 =
	fc[ix].kinematics->z()(1.-fc[ix].kinematics->z())sqr(fc[ix].kinematics->scale());
	if(fc[ix].ids[0]!=ParticleID::g) q2 += sqr(vm[0]);
	masses[ix+1] = sqrt(q2);
	}
	else {
	masses[ix+1] = virtualMasses[ix+1];
	}
	}
	masses[0] = fb.ids[0]!=ParticleID::g ? virtualMasses[0] : ZERO;
	double z = fb.kinematics->z();
	Energy2 pt2 = z(1.-z)(z(1.-z)sqr(fb.kinematics->scale()) + sqr(masses[0]))
	- sqr(masses[1])(1.-z) - sqr(masses[2])z;
	if(pt2>=ZERO) {
	break;
	}
	else {
	// reset the scales for the children
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].kinematics)
	children[ix]->vetoEmission(fc[ix].type,fc[ix].kinematics->scale());
	else
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,ZERO);
	children[ix]->virtualMass(ZERO);
	}
	}
	}
	};
	if(_reconOpt>=2) {
	// shower the first particle
	if(fc[0].kinematics) timeLikeShower(children[0],type,fc[0],false);
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],false);
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	}
	if(first&&!children.empty())
	particle->showerKinematics()->resetChildren(particle,children);
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return true;
	}

	bool
	Evolver::spaceLikeShower(tShowerParticlePtr particle, PPtr beam,
	ShowerInteraction::Type type) {
	//using the pdf's associated with the ShowerHandler assures, that
	//modified pdf's are used for the secondary interactions via
	//CascadeHandler::resetPDFs(...)
	tcPDFPtr pdf;
	if(ShowerHandler::currentHandler()->firstPDF().particle() == _beam)
	pdf = ShowerHandler::currentHandler()->firstPDF().pdf();
	if(ShowerHandler::currentHandler()->secondPDF().particle() == _beam)
	pdf = ShowerHandler::currentHandler()->secondPDF().pdf();
	Energy freeze = ShowerHandler::currentHandler()->pdfFreezingScale();
	// don't do anything if not needed
	if(_limitEmissions == 2 \|\| hardOnly() \|\|
	( _limitEmissions == 1 && _nis != 0 ) \|\|
	( _limitEmissions == 4 && _nis + _nfs != 0 ) ) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return false;
	}
	Branching bb;
	// generate branching
	while (true) {
	bb=_splittingGenerator->chooseBackwardBranching(*particle,beam,
	_initialenhance,
	_beam,type,
	pdf,freeze);
	// return if no emission
	if(!bb.kinematics) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return false;
	}
	// if not vetoed break
	if(!spaceLikeVetoed(bb,particle)) break;
	// otherwise reset scale and continue
	particle->vetoEmission(bb.type,bb.kinematics->scale());
	if(particle->spinInfo()) particle->spinInfo()->decayVertex(VertexPtr());
	}
	// assign the splitting function and shower kinematics
	particle->showerKinematics(bb.kinematics);
	if(bb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(bb.kinematics->pT());
	// For the time being we are considering only 1->2 branching
	// particles as in Sudakov form factor
	tcPDPtr part[2]={getParticleData(bb.ids[0]),
	getParticleData(bb.ids[2])};
	if(particle->id()!=bb.ids[1]) {
	if(part[0]->CC()) part[0]=part[0]->CC();
	if(part[1]->CC()) part[1]=part[1]->CC();
	}
	// Now create the actual particles, make the otherChild a final state
	// particle, while the newParent is not
	ShowerParticlePtr newParent=new_ptr(ShowerParticle(part[0],false));
	ShowerParticlePtr otherChild = new_ptr(ShowerParticle(part[1],true,true));
	ShowerParticleVector theChildren;
	theChildren.push_back(particle);
	theChildren.push_back(otherChild);
	//this updates the evolution scale
	particle->showerKinematics()->
	updateParent(newParent, theChildren,bb.type);
	// update the history if needed
	_currenttree->updateInitialStateShowerProduct(_progenitor,newParent);
	_currenttree->addInitialStateBranching(particle,newParent,otherChild);
	// for the reconstruction of kinematics, parent/child
	// relationships are according to the branching process:
	// now continue the shower
	++_nis;
	bool emitted = _limitEmissions==0 ?
	spaceLikeShower(newParent,beam,type) : false;
	if(newParent->spinInfo()) newParent->spinInfo()->develop();
	// now reconstruct the momentum
	if(!emitted) {
	if(_intrinsic.find(_progenitor)==_intrinsic.end()) {
	bb.kinematics->updateLast(newParent,ZERO,ZERO);
	}
	else {
	pair<Energy,double> kt=_intrinsic[_progenitor];
	bb.kinematics->updateLast(newParent,
	kt.first*cos(kt.second),
	kt.first*sin(kt.second));
	}
	}
	particle->showerKinematics()->
	updateChildren(newParent, theChildren,bb.type,false);
	if(_limitEmissions!=0) {
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return true;
	}
	// perform the shower of the final-state particle
	timeLikeShower(otherChild,type,Branching(),true);
	updateHistory(otherChild);
	if(theChildren[1]->spinInfo()) theChildren[1]->spinInfo()->develop();
	// return the emitted
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return true;
	}

	void Evolver::showerDecay(ShowerTreePtr decay) {
	_decayme = HwDecayerBasePtr();
	_hardme = HwMEBasePtr();
	// find the decayer
	// try the normal way if possible
	tDMPtr dm = decay->incomingLines().begin()->first->original() ->decayMode();
	if(!dm) dm = decay->incomingLines().begin()->first->copy() ->decayMode();
	if(!dm) dm = decay->incomingLines().begin()->first->progenitor()->decayMode();
	// otherwise make a string and look it up
	if(!dm) {
	string tag = decay->incomingLines().begin()->first->original()->dataPtr()->name()
	+ "->";
	OrderedParticles outgoing;
	for(map<ShowerProgenitorPtr,tShowerParticlePtr>::const_iterator
	it=decay->outgoingLines().begin();it!=decay->outgoingLines().end();++it) {
	if(abs(decay->incomingLines().begin()->first->original()->id()) == ParticleID::t &&
	abs(it->first->original()->id())==ParticleID::Wplus &&
	decay->treelinks().size() == 1) {
	ShowerTreePtr Wtree = decay->treelinks().begin()->first;
	for(map<ShowerProgenitorPtr,tShowerParticlePtr>::const_iterator
	it2=Wtree->outgoingLines().begin();it2!=Wtree->outgoingLines().end();++it2) {
	outgoing.insert(it2->first->original()->dataPtr());
	}
	}
	else {
	outgoing.insert(it->first->original()->dataPtr());
	}
	}
	for(OrderedParticles::const_iterator it=outgoing.begin(); it!=outgoing.end();++it) {
	if(it!=outgoing.begin()) tag += ",";
	tag +=(**it).name();
	}
	tag += ";";
	dm = findDecayMode(tag);
	}
	if(dm) _decayme = dynamic_ptr_cast<HwDecayerBasePtr>(dm->decayer());
	// set the ShowerTree to be showered
	currentTree(decay);
	decay->applyTransforms();
	hardTree(HardTreePtr());
	unsigned int interactionTry=0;
	do {
	try {
	// generate the showering
	doShowering(false,XCPtr());
	// if no vetos
	// force calculation of spin correlations
	SpinPtr spInfo = decay->incomingLines().begin()->first->progenitor()->spinInfo();
	if(spInfo) {
	if(!spInfo->developed()) spInfo->needsUpdate();
	spInfo->develop();
	}
	// and then return
	return;
	}
	catch (InteractionVeto) {
	currentTree()->clear();
	++interactionTry;
	}
	}
	while(interactionTry<=5);
	throw Exception() << "Too many tries for QED shower in Evolver::showerDecay()"
	<< Exception::eventerror;
	}

	bool Evolver::spaceLikeDecayShower(tShowerParticlePtr particle,
	const ShowerParticle::EvolutionScales & maxScales,
	Energy minmass,ShowerInteraction::Type type,
	Branching fb) {
	// too many tries
	if(_nFSR>=_maxTryFSR) {
	++_nFailedFSR;
	// too many failed events
	if(_nFailedFSR>=_maxFailFSR)
	throw Exception() << "Too many events have failed due to too many shower emissions, in\n"
	<< "Evolver::timeLikeShower(). Terminating run\n"
	<< Exception::runerror;
	throw Exception() << "Too many attempted emissions in Evolver::timeLikeShower()\n"
	<< Exception::eventerror;
	}
	// generate the emission
	ShowerParticleVector children;
	int ntry=0;
	// generate the emission
	if(!fb.kinematics)
	fb = selectSpaceLikeDecayBranching(particle,maxScales,minmass,type,
	HardBranchingPtr());
	// no emission, return
	if(!fb.kinematics) return false;
	Branching fc[2];
	bool setupChildren = true;
	while (ntry<50) {
	if(particle->virtualMass()==ZERO)
	particle->virtualMass(_progenitor->progenitor()->mass());
	fc[0] = Branching();
	fc[1] = Branching();
	++ntry;
	assert(fb.kinematics);
	// has emitted
	// Assign the shower kinematics to the emitting particle.
	if(setupChildren) {
	++_nFSR;
	// Assign the shower kinematics to the emitting particle.
	particle->showerKinematics(fb.kinematics);
	if(fb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(fb.kinematics->pT());
	// create the ShowerParticle objects for the two children
	children = createTimeLikeChildren(particle,fb.ids);
	// updateChildren the children
	particle->showerKinematics()->
	updateChildren(particle, children, fb.type,_reconOpt>=3);
	setupChildren = false;
	}
	// select branchings for children
	fc[0] = selectSpaceLikeDecayBranching(children[0],maxScales,minmass,
	type,HardBranchingPtr());
	fc[1] = selectTimeLikeBranching (children[1],type,HardBranchingPtr());
	// old default
	if(_reconOpt==0) {
	// shower the first particle
	_currenttree->updateInitialStateShowerProduct(_progenitor,children[0]);
	_currenttree->addInitialStateBranching(particle,children[0],children[1]);
	if(fc[0].kinematics) spaceLikeDecayShower(children[0],maxScales,minmass,type,Branching());
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],true);
	updateHistory(children[1]);
	// branching has happened
	break;
	}
	// Herwig default
	else if(_reconOpt==1) {
	// shower the first particle
	_currenttree->updateInitialStateShowerProduct(_progenitor,children[0]);
	_currenttree->addInitialStateBranching(particle,children[0],children[1]);
	if(fc[0].kinematics) spaceLikeDecayShower(children[0],maxScales,minmass,type,Branching());
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],true);
	updateHistory(children[1]);
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	// clean up the vetoed emission
	if(particle->virtualMass()==ZERO) {
	particle->showerKinematics(ShoKinPtr());
	for(unsigned int ix=0;ix<children.size();++ix)
	particle->abandonChild(children[ix]);
	children.clear();
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	// generate the new emission
	fb = selectSpaceLikeDecayBranching(particle,maxScales,minmass,type,
	HardBranchingPtr());
	// no emission, return
	if(!fb.kinematics) {
	return false;
	}
	setupChildren = true;
	continue;
	}
	else
	break;
	}
	else if(_reconOpt>=2) {
	// cut-off masses for the branching
	const vector<Energy> & virtualMasses = fb.sudakov->virtualMasses(fb.ids);
	// compute the masses of the children
	Energy masses[3];
	// space-like children
	masses[1] = children[0]->virtualMass();
	// time-like child
	if(fc[1].kinematics) {
	const vector<Energy> & vm = fc[1].sudakov->virtualMasses(fc[1].ids);
	Energy2 q2 =
	fc[1].kinematics->z()(1.-fc[1].kinematics->z())sqr(fc[1].kinematics->scale());
	if(fc[1].ids[0]!=ParticleID::g) q2 += sqr(vm[0]);
	masses[2] = sqrt(q2);
	}
	else {
	masses[2] = virtualMasses[2];
	}
	masses[0]=particle->virtualMass();
	double z = fb.kinematics->z();
	Energy2 pt2 = (1.-z)(zsqr(masses[0])-sqr(masses[1])-z/(1.-z)*sqr(masses[2]));
	if(pt2>=ZERO) {
	break;
	}
	else {
	// reset the scales for the children
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].kinematics)
	children[ix]->vetoEmission(fc[ix].type,fc[ix].kinematics->scale());
	else {
	if(ix==0)
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,Constants::MaxEnergy);
	else
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,ZERO);
	}
	}
	children[0]->virtualMass(_progenitor->progenitor()->mass());
	children[1]->virtualMass(ZERO);
	}
	}
	};
	if(_reconOpt>=2) {
	// In the case of splittings which involves coloured particles,
	// set properly the colour flow of the branching.
	// update the history if needed
	_currenttree->updateInitialStateShowerProduct(_progenitor,children[0]);
	_currenttree->addInitialStateBranching(particle,children[0],children[1]);
	// shower the first particle
	if(fc[0].kinematics) spaceLikeDecayShower(children[0],maxScales,minmass,type,Branching());
	// shower the second particle
	if(fc[1].kinematics) timeLikeShower(children[1],type,fc[1],true);
	updateHistory(children[1]);
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	}
	// branching has happened
	return true;
	}

	vector<ShowerProgenitorPtr> Evolver::setupShower(bool hard) {
	// generate POWHEG hard emission if needed
	if(_hardEmissionMode>0) hardestEmission(hard);
	ShowerInteraction::Type inter = interaction_;
	if(_hardtree&&inter!=ShowerInteraction::QEDQCD && inter!=ShowerInteraction::ALL) {
	inter = _hardtree->interaction();
	}
	// set the initial colour partners
	setEvolutionPartners(hard,inter,false);
	// generate hard me if needed
	if(_hardEmissionMode==0 \|\|
	(!hard && _hardEmissionMode==-1)) hardMatrixElementCorrection(hard);
	// get the particles to be showered
	vector<ShowerProgenitorPtr> particlesToShower =
	currentTree()->extractProgenitors();
	// remake the colour partners if needed
	if(_currenttree->hardMatrixElementCorrection()) {
	setEvolutionPartners(hard,interaction_,true);
	_currenttree->resetShowerProducts();
	}
	// return the answer
	return particlesToShower;
	}

	void Evolver::setEvolutionPartners(bool hard,ShowerInteraction::Type type,
	bool clear) {
	// match the particles in the ShowerTree and hardTree
	if(hardTree() && !hardTree()->connect(currentTree()))
	throw Exception() << "Can't match trees in "
	<< "Evolver::setEvolutionPartners()"
	<< Exception::eventerror;
	// extract the progenitors
	vector<ShowerParticlePtr> particles =
	currentTree()->extractProgenitorParticles();
	// clear the partners if needed
	if(clear) {
	for(unsigned int ix=0;ix<particles.size();++ix) {
	particles[ix]->partner(ShowerParticlePtr());
	particles[ix]->clearPartners();
	}
	}
	// sort out the colour partners
	if(hardTree()) {
	// find the partner
	for(unsigned int ix=0;ix<particles.size();++ix) {
	tHardBranchingPtr partner =
	hardTree()->particles()[particles[ix]]->colourPartner();
	if(!partner) continue;
	for(map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	it=hardTree()->particles().begin();
	it!=hardTree()->particles().end();++it) {
	if(it->second==partner) particles[ix]->partner(it->first);
	}
	if(!particles[ix]->partner())
	throw Exception() << "Can't match partners in "
	<< "Evolver::setEvolutionPartners()"
	<< Exception::eventerror;
	}
	}
	// Set the initial evolution scales
	showerModel()->partnerFinder()->
	setInitialEvolutionScales(particles,!hard,type,!_hardtree);
	if(hardTree() && _hardPOWHEG) {
	bool tooHard=false;
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	eit=hardTree()->particles().end();
	for(unsigned int ix=0;ix<particles.size();++ix) {
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	mit = hardTree()->particles().find(particles[ix]);
	Energy hardScale(ZERO);
	ShowerPartnerType::Type type(ShowerPartnerType::Undefined);
	// final-state
	if(particles[ix]->isFinalState()) {
	if(mit!= eit && !mit->second->children().empty()) {
	hardScale = mit->second->scale();
	type = mit->second->type();
	}
	}
	// initial-state
	else {
	if(mit!= eit && mit->second->parent()) {
	hardScale = mit->second->parent()->scale();
	type = mit->second->parent()->type();
	}
	}
	if(type!=ShowerPartnerType::Undefined) {
	if(type==ShowerPartnerType::QED) {
	tooHard \|= particles[ix]->scales().QED_noAO<hardScale;
	}
	else if(type==ShowerPartnerType::QCDColourLine) {
	tooHard \|= particles[ix]->scales().QCD_c_noAO<hardScale;
	}
	else if(type==ShowerPartnerType::QCDAntiColourLine) {
	tooHard \|= particles[ix]->scales().QCD_ac_noAO<hardScale;
	}
	else if(type==ShowerPartnerType::EW) {
	tooHard \|= particles[ix]->scales().EW<hardScale;
	}
	}
	}
	if(tooHard) convertHardTree(hard,type);
	}
	}

	void Evolver::updateHistory(tShowerParticlePtr particle) {
	if(!particle->children().empty()) {
	ShowerParticleVector theChildren;
	for(unsigned int ix=0;ix<particle->children().size();++ix) {
	ShowerParticlePtr part = dynamic_ptr_cast<ShowerParticlePtr>
	(particle->children()[ix]);
	theChildren.push_back(part);
	}
	// update the history if needed
	if(particle==_currenttree->getFinalStateShowerProduct(_progenitor))
	_currenttree->updateFinalStateShowerProduct(_progenitor,
	particle,theChildren);
	_currenttree->addFinalStateBranching(particle,theChildren);
	for(unsigned int ix=0;ix<theChildren.size();++ix)
	updateHistory(theChildren[ix]);
	}
	}

	bool Evolver::startTimeLikeShower(ShowerInteraction::Type type) {
	_nFSR = 0;
	+ // initialize basis vectors etc
	+ progenitor()->progenitor()->initializeFinalState();
	if(hardTree()) {
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	eit=hardTree()->particles().end(),
	mit = hardTree()->particles().find(progenitor()->progenitor());
	if( mit != eit && !mit->second->children().empty() ) {
	bool output=truncatedTimeLikeShower(progenitor()->progenitor(),
	mit->second ,type,Branching(),true);
	if(output) updateHistory(progenitor()->progenitor());
	return output;
	}
	}
	- // initialize basis vectors etc
	- progenitor()->progenitor()->initializeFinalState();
	// do the shower
	bool output = hardOnly() ? false :
	timeLikeShower(progenitor()->progenitor() ,type,Branching(),true) ;
	if(output) updateHistory(progenitor()->progenitor());
	return output;
	}

	bool Evolver::startSpaceLikeShower(PPtr parent, ShowerInteraction::Type type) {
	+ // initialise the basis vectors
	+ progenitor()->progenitor()->initializeInitialState(parent);
	if(hardTree()) {
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	eit =hardTree()->particles().end(),
	mit = hardTree()->particles().find(progenitor()->progenitor());
	if( mit != eit && mit->second->parent() ) {
	return truncatedSpaceLikeShower( progenitor()->progenitor(),
	parent, mit->second->parent(), type );
	}
	}
	- // initialise the basis vectors
	- progenitor()->progenitor()->initializeInitialState(parent);
	// perform the shower
	return hardOnly() ? false :
	spaceLikeShower(progenitor()->progenitor(),parent,type);
	}

	bool Evolver::
	startSpaceLikeDecayShower(const ShowerParticle::EvolutionScales & maxScales,
	Energy minimumMass,ShowerInteraction::Type type) {
	_nFSR = 0;
	+ // set up the particle basis vectors
	+ progenitor()->progenitor()->initializeDecay();
	if(hardTree()) {
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	eit =hardTree()->particles().end(),
	mit = hardTree()->particles().find(progenitor()->progenitor());
	if( mit != eit && mit->second->parent() ) {
	HardBranchingPtr branch=mit->second;
	while(branch->parent()) branch=branch->parent();
	return truncatedSpaceLikeDecayShower(progenitor()->progenitor(),maxScales,
	minimumMass, branch ,type, Branching());
	}
	}
	- // set up the particle basis vectors
	- progenitor()->progenitor()->initializeDecay();
	// perform the shower
	return hardOnly() ? false :
	spaceLikeDecayShower(progenitor()->progenitor(),maxScales,minimumMass,type,Branching());
	}

	bool Evolver::timeLikeVetoed(const Branching & fb,
	ShowerParticlePtr particle) {
	// work out type of interaction
	ShowerInteraction::Type type = convertInteraction(fb.type);
	// check whether emission was harder than largest pt of hard subprocess
	if ( hardVetoFS() && fb.kinematics->pT() > _progenitor->maxHardPt() )
	return true;
	// soft matrix element correction veto
	if( softMEC()) {
	if(_hardme && _hardme->hasMECorrection()) {
	if(_hardme->softMatrixElementVeto(_progenitor,particle,fb))
	return true;
	}
	else if(_decayme && _decayme->hasMECorrection()) {
	if(_decayme->softMatrixElementVeto(_progenitor,particle,fb))
	return true;
	}
	}
	// veto on maximum pt
	if(fb.kinematics->pT()>_progenitor->maximumpT(type)) return true;
	// general vetos
	if (fb.kinematics && !_vetoes.empty()) {
	bool vetoed=false;
	for (vector<ShowerVetoPtr>::iterator v = _vetoes.begin();
	v != _vetoes.end(); ++v) {
	bool test = (**v).vetoTimeLike(_progenitor,particle,fb);
	switch((**v).vetoType()) {
	case ShowerVeto::Emission:
	vetoed \|= test;
	break;
	case ShowerVeto::Shower:
	if(test) throw VetoShower();
	break;
	case ShowerVeto::Event:
	if(test) throw Veto();
	break;
	}
	}
	if(vetoed) return true;
	}
	if ( ShowerHandler::currentHandler()->firstInteraction() &&
	ShowerHandler::currentHandler()->profileScales() ) {
	double weight =
	ShowerHandler::currentHandler()->profileScales()->
	hardScaleProfile(_progenitor->hardScale(),fb.kinematics->pT());
	if ( UseRandom::rnd() > weight )
	return true;
	}
	return false;
	}

	bool Evolver::spaceLikeVetoed(const Branching & bb,
	ShowerParticlePtr particle) {
	// work out type of interaction
	ShowerInteraction::Type type = convertInteraction(bb.type);
	// check whether emission was harder than largest pt of hard subprocess
	if (hardVetoIS() && bb.kinematics->pT() > _progenitor->maxHardPt())
	return true;
	// apply the soft correction
	if( softMEC() && _hardme && _hardme->hasMECorrection() ) {
	if(_hardme->softMatrixElementVeto(_progenitor,particle,bb))
	return true;
	}
	// the more general vetos

	// check vs max pt for the shower
	if(bb.kinematics->pT()>_progenitor->maximumpT(type)) return true;

	if (!_vetoes.empty()) {
	bool vetoed=false;
	for (vector<ShowerVetoPtr>::iterator v = _vetoes.begin();
	v != _vetoes.end(); ++v) {
	bool test = (**v).vetoSpaceLike(_progenitor,particle,bb);
	switch ((**v).vetoType()) {
	case ShowerVeto::Emission:
	vetoed \|= test;
	break;
	case ShowerVeto::Shower:
	if(test) throw VetoShower();
	break;
	case ShowerVeto::Event:
	if(test) throw Veto();
	break;
	}
	}
	if (vetoed) return true;
	}
	if ( ShowerHandler::currentHandler()->firstInteraction() &&
	ShowerHandler::currentHandler()->profileScales() ) {
	double weight =
	ShowerHandler::currentHandler()->profileScales()->
	hardScaleProfile(_progenitor->hardScale(),bb.kinematics->pT());
	if ( UseRandom::rnd() > weight )
	return true;
	}
	return false;
	}

	bool Evolver::spaceLikeDecayVetoed( const Branching & fb,
	ShowerParticlePtr particle) {
	// work out type of interaction
	ShowerInteraction::Type type = convertInteraction(fb.type);
	// apply the soft correction
	if( softMEC() && _decayme && _decayme->hasMECorrection() ) {
	if(_decayme->softMatrixElementVeto(_progenitor,particle,fb))
	return true;
	}
	// veto on hardest pt in the shower
	if(fb.kinematics->pT()> _progenitor->maximumpT(type)) return true;
	// general vetos
	if (!_vetoes.empty()) {
	bool vetoed=false;
	for (vector<ShowerVetoPtr>::iterator v = _vetoes.begin();
	v != _vetoes.end(); ++v) {
	bool test = (**v).vetoSpaceLike(_progenitor,particle,fb);
	switch((**v).vetoType()) {
	case ShowerVeto::Emission:
	vetoed \|= test;
	break;
	case ShowerVeto::Shower:
	if(test) throw VetoShower();
	break;
	case ShowerVeto::Event:
	if(test) throw Veto();
	break;
	}
	if (vetoed) return true;
	}
	}
	return false;
	}

	void Evolver::hardestEmission(bool hard) {
	HardTreePtr ISRTree;
	if( ( _hardme && _hardme->hasPOWHEGCorrection()!=0 && _hardEmissionMode< 2) \|\|
	( _decayme && _decayme->hasPOWHEGCorrection()!=0 && _hardEmissionMode!=2) ) {
	if(_hardme) {
	assert(hard);
	_hardtree = _hardme->generateHardest( currentTree(),interaction_);
	}
	else {
	assert(!hard);
	_hardtree = _decayme->generateHardest( currentTree() );
	}
	// store initial state POWHEG radiation
	if(_hardtree && _hardme && _hardme->hasPOWHEGCorrection()==1)
	ISRTree=_hardtree;
	}

	else if (_hardEmissionMode>1 && hard) {
	// Get minimum pT cutoff used in shower approximation
	Energy maxpt = 1.*GeV;
	int colouredIn = 0;
	int colouredOut = 0;
	for( map< ShowerProgenitorPtr, tShowerParticlePtr >::iterator it
	= currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if( it->second->coloured() ) colouredOut+=1;
	}
	for( map< ShowerProgenitorPtr, ShowerParticlePtr >::iterator it
	= currentTree()->incomingLines().begin();
	it != currentTree()->incomingLines().end(); ++it ) {
	if( ! it->second->coloured() ) colouredIn+=1;
	}

	if ( theShowerApproximation ){
	if ( theShowerApproximation->ffPtCut() == theShowerApproximation->fiPtCut() &&
	theShowerApproximation->ffPtCut() == theShowerApproximation->iiPtCut() )
	maxpt = theShowerApproximation->ffPtCut();
	else if ( colouredIn == 2 && colouredOut == 0 )
	maxpt = theShowerApproximation->iiPtCut();
	else if ( colouredIn == 0 && colouredOut > 1 )
	maxpt = theShowerApproximation->ffPtCut();
	else if ( colouredIn == 2 && colouredOut == 1 )
	maxpt = min(theShowerApproximation->iiPtCut(), theShowerApproximation->fiPtCut());
	else if ( colouredIn == 1 && colouredOut > 1 )
	maxpt = min(theShowerApproximation->ffPtCut(), theShowerApproximation->fiPtCut());
	else
	maxpt = min(min(theShowerApproximation->iiPtCut(), theShowerApproximation->fiPtCut()),
	theShowerApproximation->ffPtCut());
	}

	// Generate hardtree from born and real emission subprocesses
	_hardtree = ShowerHandler::currentHandler()->generateCKKW(currentTree());

	// Find transverse momentum of hardest emission
	if (_hardtree){
	for(set<HardBranchingPtr>::iterator it=_hardtree->branchings().begin();
	it!=_hardtree->branchings().end();++it) {
	if ((it)->parent() && (it)->status()==HardBranching::Incoming)
	maxpt=(*it)->branchingParticle()->momentum().perp();
	if ((it)->children().size()==2 && (it)->status()==HardBranching::Outgoing){
	if ((*it)->branchingParticle()->id()!=21 &&
	abs((*it)->branchingParticle()->id())>5 ){
	if ((*it)->children()[0]->branchingParticle()->id()==21 \|\|
	abs((*it)->children()[0]->branchingParticle()->id())<6)
	maxpt=(*it)->children()[0]->branchingParticle()->momentum().perp();
	else if ((*it)->children()[1]->branchingParticle()->id()==21 \|\|
	abs((*it)->children()[1]->branchingParticle()->id())<6)
	maxpt=(*it)->children()[1]->branchingParticle()->momentum().perp();
	}
	else {
	if ( abs((*it)->branchingParticle()->id())<6){
	if (abs((*it)->children()[0]->branchingParticle()->id())<6)
	maxpt = (*it)->children()[1]->branchingParticle()->momentum().perp();
	else
	maxpt = (*it)->children()[0]->branchingParticle()->momentum().perp();
	}
	else maxpt = (*it)->children()[1]->branchingParticle()->momentum().perp();
	}
	}
	}
	}


	// Hardest (pt) emission should be the first powheg emission.
	maxpt=min(sqrt(ShowerHandler::currentHandler()->lastXCombPtr()->lastShowerScale()),maxpt);

	// Set maxpt to pT of emission when showering POWHEG real-emission subprocesses
	if (!isPowhegSEvent && !isPowhegHEvent){
	vector<int> outGluon;
	vector<int> outQuark;
	map< ShowerProgenitorPtr, tShowerParticlePtr >::iterator it;
	for( it = currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if ( abs(it->second->id())< 6) outQuark.push_back(it->second->id());
	if ( it->second->id()==21 ) outGluon.push_back(it->second->id());
	}
	if (outGluon.size() + outQuark.size() == 1){
	for( it = currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if ( abs(it->second->id())< 6 \|\| it->second->id()==21 )
	maxpt = it->second->momentum().perp();
	}
	}
	else if (outGluon.size() + outQuark.size() > 1){
	// assume qqbar pair from a Z/gamma
	if (outGluon.size()==1 && outQuark.size() == 2 && outQuark[0]==-outQuark[1]){
	for( it = currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if ( it->second->id()==21 )
	maxpt = it->second->momentum().perp();
	}
	}
	// otherwise take the lowest pT avoiding born DY events
	else {
	maxpt = generator()->maximumCMEnergy();
	for( it = currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if ( abs(it->second->id())< 6 \|\| it->second->id()==21 )
	maxpt = min(maxpt,it->second->momentum().perp());
	}
	}
	}
	}

	// set maximum pT for subsequent emissions from S events
	if ( isPowhegSEvent \|\| (!isPowhegSEvent && !isPowhegHEvent)){
	for( map< ShowerProgenitorPtr, tShowerParticlePtr >::iterator it
	= currentTree()->outgoingLines().begin();
	it != currentTree()->outgoingLines().end(); ++it ) {
	if( ! it->second->coloured() ) continue;
	it->first->maximumpT(maxpt, ShowerInteraction::QCD );
	}
	for( map< ShowerProgenitorPtr, ShowerParticlePtr >::iterator it
	= currentTree()->incomingLines().begin();
	it != currentTree()->incomingLines().end(); ++it ) {
	if( ! it->second->coloured() ) continue;
	it->first->maximumpT(maxpt, ShowerInteraction::QCD );
	}
	}
	}
	else
	_hardtree = ShowerHandler::currentHandler()->generateCKKW(currentTree());

	// if hard me doesn't have a FSR powheg
	// correction use decay powheg correction
	if (_hardme && _hardme->hasPOWHEGCorrection()<2) {
	// check for intermediate colour singlet resonance
	const ParticleVector inter = _hardme->subProcess()->intermediates();
	if (inter.size()!=1 \|\|
	inter[0]->momentum().m2()/GeV2 < 0 \|\|
	inter[0]->dataPtr()->iColour()!=PDT::Colour0){
	if(_hardtree) connectTrees(currentTree(),_hardtree,hard);
	return;
	}

	map<ShowerProgenitorPtr, tShowerParticlePtr > out = currentTree()->outgoingLines();
	// ignore cases where outgoing particles are not coloured
	if (out.size()!=2 \|\|
	out. begin()->second->dataPtr()->iColour()==PDT::Colour0 \|\|
	out.rbegin()->second->dataPtr()->iColour()==PDT::Colour0) {
	if(_hardtree) connectTrees(currentTree(),_hardtree,hard);
	return;
	}

	// look up decay mode
	tDMPtr dm;
	string tag;
	string inParticle = inter[0]->dataPtr()->name() + "->";
	vector<string> outParticles;
	outParticles.push_back(out.begin ()->first->progenitor()->dataPtr()->name());
	outParticles.push_back(out.rbegin()->first->progenitor()->dataPtr()->name());
	for (int it=0; it<2; ++it){
	tag = inParticle + outParticles[it] + "," + outParticles[(it+1)%2] + ";";
	dm = generator()->findDecayMode(tag);
	if(dm) break;
	}

	// get the decayer
	HwDecayerBasePtr decayer;
	if(dm) decayer = dynamic_ptr_cast<HwDecayerBasePtr>(dm->decayer());
	// check if decayer has a FSR POWHEG correction
	if (!decayer \|\| decayer->hasPOWHEGCorrection()<2){
	if(_hardtree) connectTrees(currentTree(),_hardtree,hard);
	return;
	}

	// generate the hardest emission
	ShowerDecayMap decay;
	PPtr in = new_ptr(*inter[0]);
	ShowerTreePtr decayTree = new_ptr(ShowerTree(in, decay));
	HardTreePtr FSRTree = decayer->generateHardest(decayTree);
	if (!FSRTree) {
	if(_hardtree) connectTrees(currentTree(),_hardtree,hard);
	return;
	}

	// if there is no ISRTree make _hardtree from FSRTree
	if (!ISRTree){
	vector<HardBranchingPtr> inBranch,hardBranch;
	for(map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit =currentTree()->incomingLines().begin();
	cit!=currentTree()->incomingLines().end();++cit ) {
	inBranch.push_back(new_ptr(HardBranching(cit->second,SudakovPtr(),
	HardBranchingPtr(),
	HardBranching::Incoming)));
	inBranch.back()->beam(cit->first->original()->parents()[0]);
	hardBranch.push_back(inBranch.back());
	}
	if(inBranch[0]->branchingParticle()->dataPtr()->coloured()) {
	inBranch[0]->colourPartner(inBranch[1]);
	inBranch[1]->colourPartner(inBranch[0]);
	}
	for(set<HardBranchingPtr>::iterator it=FSRTree->branchings().begin();
	it!=FSRTree->branchings().end();++it) {
	if((**it).branchingParticle()->id()!=in->id())
	hardBranch.push_back(*it);
	}
	hardBranch[2]->colourPartner(hardBranch[3]);
	hardBranch[3]->colourPartner(hardBranch[2]);
	HardTreePtr newTree = new_ptr(HardTree(hardBranch,inBranch,
	ShowerInteraction::QCD));
	_hardtree = newTree;
	}

	// Otherwise modify the ISRTree to include the emission in FSRTree
	else {
	vector<tShowerParticlePtr> FSROut, ISROut;
	set<HardBranchingPtr>::iterator itFSR, itISR;
	// get outgoing particles
	for(itFSR =FSRTree->branchings().begin();
	itFSR!=FSRTree->branchings().end();++itFSR){
	if ((**itFSR).status()==HardBranching::Outgoing)
	FSROut.push_back((*itFSR)->branchingParticle());
	}
	for(itISR =ISRTree->branchings().begin();
	itISR!=ISRTree->branchings().end();++itISR){
	if ((**itISR).status()==HardBranching::Outgoing)
	ISROut.push_back((*itISR)->branchingParticle());
	}

	// find COM frame formed by outgoing particles
	LorentzRotation eventFrameFSR, eventFrameISR;
	eventFrameFSR = ((FSROut[0]->momentum()+FSROut[1]->momentum()).findBoostToCM());
	eventFrameISR = ((ISROut[0]->momentum()+ISROut[1]->momentum()).findBoostToCM());

	// find rotation between ISR and FSR frames
	int j=0;
	if (ISROut[0]->id()!=FSROut[0]->id()) j=1;
	eventFrameISR.rotateZ( (eventFrameFSR*FSROut[0]->momentum()).phi()-
	(eventFrameISR*ISROut[j]->momentum()).phi() );
	eventFrameISR.rotateY( (eventFrameFSR*FSROut[0]->momentum()).theta()-
	(eventFrameISR*ISROut[j]->momentum()).theta() );
	eventFrameISR.invert();

	for (itFSR=FSRTree->branchings().begin();
	itFSR!=FSRTree->branchings().end();++itFSR){
	if ((**itFSR).branchingParticle()->id()==in->id()) continue;
	for (itISR =ISRTree->branchings().begin();
	itISR!=ISRTree->branchings().end();++itISR){
	if ((**itISR).status()==HardBranching::Incoming) continue;
	if ((**itFSR).branchingParticle()->id()==
	(**itISR).branchingParticle()->id()){
	// rotate FSRTree particle to ISRTree event frame
	(*itISR).branchingParticle()->setMomentum(eventFrameISR
	eventFrameFSR*
	(**itFSR).branchingParticle()->momentum());
	(**itISR).branchingParticle()->rescaleMass();
	// add the children of the FSRTree particles to the ISRTree
	if(!(**itFSR).children().empty()){
	(itISR).addChild((itFSR).children()[0]);
	(itISR).addChild((itFSR).children()[1]);
	// rotate momenta to ISRTree event frame
	(*itISR).children()[0]->branchingParticle()->setMomentum(eventFrameISR
	eventFrameFSR*
	(**itFSR).children()[0]->branchingParticle()->momentum());
	(*itISR).children()[1]->branchingParticle()->setMomentum(eventFrameISR
	eventFrameFSR*
	(**itFSR).children()[1]->branchingParticle()->momentum());
	}
	}
	}
	}
	_hardtree = ISRTree;
	}
	}
	if(_hardtree){
	connectTrees(currentTree(),_hardtree,hard);
	}
	}

	bool Evolver::truncatedTimeLikeShower(tShowerParticlePtr particle,
	HardBranchingPtr branch,
	ShowerInteraction::Type type,
	Branching fb, bool first) {
	// select a branching if we don't have one
	if(!fb.kinematics)
	fb = selectTimeLikeBranching(particle,type,branch);
	// must be an emission, the forced one it not a truncated one
	assert(fb.kinematics);
	ShowerParticleVector children;
	int ntry=0;
	Branching fc[2];
	bool setupChildren = true;
	while (ntry<50) {
	if(!fc[0].hard) fc[0] = Branching();
	if(!fc[1].hard) fc[1] = Branching();
	++ntry;
	// Assign the shower kinematics to the emitting particle.
	if(setupChildren) {
	++_nFSR;
	// Assign the shower kinematics to the emitting particle.
	particle->showerKinematics(fb.kinematics);
	if(fb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(fb.kinematics->pT());
	// if not hard generate phi
	if(!fb.hard)
	fb.kinematics->phi(fb.sudakov->generatePhiForward(*particle,fb.ids,fb.kinematics));
	// create the children
	children = createTimeLikeChildren(particle,fb.ids);
	// update the children
	particle->showerKinematics()->
	updateChildren(particle, children,fb.type,_reconOpt>=3);
	setupChildren = false;
	}
	// select branchings for children
	if(!fc[0].kinematics) {
	// select branching for first particle
	if(!fb.hard && fb.iout ==1 )
	fc[0] = selectTimeLikeBranching(children[0],type,branch);
	else if(fb.hard && !branch->children()[0]->children().empty() )
	fc[0] = selectTimeLikeBranching(children[0],type,branch->children()[0]);
	else
	fc[0] = selectTimeLikeBranching(children[0],type,HardBranchingPtr());
	}
	// select branching for the second particle
	if(!fc[1].kinematics) {
	// select branching for first particle
	if(!fb.hard && fb.iout ==2 )
	fc[1] = selectTimeLikeBranching(children[1],type,branch);
	else if(fb.hard && !branch->children()[1]->children().empty() )
	fc[1] = selectTimeLikeBranching(children[1],type,branch->children()[1]);
	else
	fc[1] = selectTimeLikeBranching(children[1],type,HardBranchingPtr());
	}
	// old default
	if(_reconOpt==0 \|\| (_reconOpt==1 && fb.hard) ) {
	// shower the first particle
	if(fc[0].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 1)
	truncatedTimeLikeShower(children[0],branch,type,fc[0],false);
	// hard emission and subsquent hard emissions
	else if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[0],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 2)
	truncatedTimeLikeShower(children[1],branch,type,fc[1],false);
	// hard emission and subsquent hard emissions
	else if(fb.hard && !branch->children()[1]->children().empty() )
	truncatedTimeLikeShower(children[1],branch->children()[1],type,fc[1],false);
	else
	timeLikeShower(children[1],type,fc[1],false);
	}
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	break;
	}
	// H7 default
	else if(_reconOpt==1) {
	// shower the first particle
	if(fc[0].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 1)
	truncatedTimeLikeShower(children[0],branch,type,fc[0],false);
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 2)
	truncatedTimeLikeShower(children[1],branch,type,fc[1],false);
	else
	timeLikeShower(children[1],type,fc[1],false);
	}
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	// clean up the vetoed emission
	if(particle->virtualMass()==ZERO) {
	particle->showerKinematics(ShoKinPtr());
	for(unsigned int ix=0;ix<children.size();++ix)
	particle->abandonChild(children[ix]);
	children.clear();
	if(particle->spinInfo()) particle->spinInfo()->decayVertex(VertexPtr());
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	// generate the new emission
	fb = selectTimeLikeBranching(particle,type,branch);
	// must be at least hard emission
	assert(fb.kinematics);
	setupChildren = true;
	continue;
	}
	else
	break;
	}
	else if(_reconOpt>=2) {
	// cut-off masses for the branching
	const vector<Energy> & virtualMasses = fb.sudakov->virtualMasses(fb.ids);
	// compute the masses of the children
	Energy masses[3];
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].kinematics) {
	const vector<Energy> & vm = fc[ix].sudakov->virtualMasses(fc[ix].ids);
	Energy2 q2 =
	fc[ix].kinematics->z()(1.-fc[ix].kinematics->z())sqr(fc[ix].kinematics->scale());
	if(fc[ix].ids[0]!=ParticleID::g) q2 += sqr(vm[0]);
	masses[ix+1] = sqrt(q2);
	}
	else {
	masses[ix+1] = virtualMasses[ix+1];
	}
	}
	masses[0] = fb.ids[0]!=ParticleID::g ? virtualMasses[0] : ZERO;
	double z = fb.kinematics->z();
	Energy2 pt2 = z(1.-z)(z(1.-z)sqr(fb.kinematics->scale()) + sqr(masses[0]))
	- sqr(masses[1])(1.-z) - sqr(masses[2])z;
	if(pt2>=ZERO) {
	break;
	}
	// if only the hard emission have to accept it
	else if ((fc[0].hard && !fc[1].kinematics) \|\|
	(fc[1].hard && !fc[0].kinematics) ) {
	break;
	}
	else {
	// reset the scales for the children
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].hard) continue;
	if(fc[ix].kinematics && ! fc[ix].hard )
	children[ix]->vetoEmission(fc[ix].type,fc[ix].kinematics->scale());
	else
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,ZERO);
	children[ix]->virtualMass(ZERO);
	}
	}
	}
	};
	if(_reconOpt>=2) {
	// shower the first particle
	if(fc[0].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 1)
	truncatedTimeLikeShower(children[0],branch,type,fc[0],false);
	// hard emission and subsquent hard emissions
	else if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[0],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	if(children[0]->spinInfo()) children[0]->spinInfo()->develop();
	// shower the second particle
	if(fc[1].kinematics) {
	// the parent has truncated emission and following line
	if(!fb.hard && fb.iout == 2)
	truncatedTimeLikeShower(children[1],branch,type,fc[1],false);
	// hard emission and subsquent hard emissions
	else if(fb.hard && !branch->children()[1]->children().empty() )
	truncatedTimeLikeShower(children[1],branch->children()[1],type,fc[1],false);
	else
	timeLikeShower(children[1],type,fc[1],false);
	}
	if(children[1]->spinInfo()) children[1]->spinInfo()->develop();
	// branching has happened
	particle->showerKinematics()->updateParent(particle, children,fb.type);
	}
	if(first&&!children.empty())
	particle->showerKinematics()->resetChildren(particle,children);
	if(particle->spinInfo()) particle->spinInfo()->develop();
	return true;
	}

	bool Evolver::truncatedSpaceLikeShower(tShowerParticlePtr particle, PPtr beam,
	HardBranchingPtr branch,
	ShowerInteraction::Type type) {
	tcPDFPtr pdf;
	if(ShowerHandler::currentHandler()->firstPDF().particle() == beamParticle())
	pdf = ShowerHandler::currentHandler()->firstPDF().pdf();
	if(ShowerHandler::currentHandler()->secondPDF().particle() == beamParticle())
	pdf = ShowerHandler::currentHandler()->secondPDF().pdf();
	Energy freeze = ShowerHandler::currentHandler()->pdfFreezingScale();
	Branching bb;
	// parameters of the force branching
	double z(0.);
	HardBranchingPtr timelike;
	for( unsigned int ix = 0; ix < branch->children().size(); ++ix ) {
	if( branch->children()[ix]->status() ==HardBranching::Outgoing) {
	timelike = branch->children()[ix];
	}
	if( branch->children()[ix]->status() ==HardBranching::Incoming )
	z = branch->children()[ix]->z();
	}
	// generate truncated branching
	tcPDPtr part[2];
	if(z>=0.&&z<=1.) {
	while (true) {
	if( !isTruncatedShowerON() \|\| hardOnly() ) break;
	bb = splittingGenerator()->chooseBackwardBranching( *particle,
	beam, 1., beamParticle(),
	type , pdf,freeze);
	if( !bb.kinematics \|\| bb.kinematics->scale() < branch->scale() ) {
	bb = Branching();
	break;
	}
	// particles as in Sudakov form factor
	part[0] = getParticleData( bb.ids[0] );
	part[1] = getParticleData( bb.ids[2] );

	//is emitter anti-particle
	if( particle->id() != bb.ids[1]) {
	if( part[0]->CC() ) part[0] = part[0]->CC();
	if( part[1]->CC() ) part[1] = part[1]->CC();
	}
	double zsplit = bb.kinematics->z();
	// apply the vetos for the truncated shower
	// if doesn't carry most of momentum
	ShowerInteraction::Type type2 = convertInteraction(bb.type);
	if(type2==branch->sudakov()->interactionType() &&
	zsplit < 0.5) {
	particle->vetoEmission(bb.type,bb.kinematics->scale());
	continue;
	}
	// others
	if( part[0]->id() != particle->id() \|\| // if particle changes type
	bb.kinematics->pT() > progenitor()->maximumpT(type2) \|\| // pt veto
	bb.kinematics->scale() < branch->scale()) { // angular ordering veto
	particle->vetoEmission(bb.type,bb.kinematics->scale());
	continue;
	}
	// and those from the base class
	if(spaceLikeVetoed(bb,particle)) {
	particle->vetoEmission(bb.type,bb.kinematics->scale());
	continue;
	}
	break;
	}
	}
	if( !bb.kinematics ) {
	//do the hard emission
	ShoKinPtr kinematics =
	branch->sudakov()->createInitialStateBranching( branch->scale(), z, branch->phi(),
	branch->children()[0]->pT() );
	// assign the splitting function and shower kinematics
	particle->showerKinematics( kinematics );
	if(kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(kinematics->pT());
	// For the time being we are considering only 1->2 branching
	// Now create the actual particles, make the otherChild a final state
	// particle, while the newParent is not
	ShowerParticlePtr newParent =
	new_ptr( ShowerParticle( branch->branchingParticle()->dataPtr(), false ) );
	ShowerParticlePtr otherChild =
	new_ptr( ShowerParticle( timelike->branchingParticle()->dataPtr(),
	true, true ) );
	ShowerParticleVector theChildren;
	theChildren.push_back( particle );
	theChildren.push_back( otherChild );
	particle->showerKinematics()->
	updateParent( newParent, theChildren, branch->type());
	// update the history if needed
	currentTree()->updateInitialStateShowerProduct( progenitor(), newParent );
	currentTree()->addInitialStateBranching( particle, newParent, otherChild );
	// for the reconstruction of kinematics, parent/child
	// relationships are according to the branching process:
	// now continue the shower
	bool emitted=false;
	if(!hardOnly()) {
	if( branch->parent() ) {
	emitted = truncatedSpaceLikeShower( newParent, beam, branch->parent() , type);
	}
	else {
	emitted = spaceLikeShower( newParent, beam , type);
	}
	}
	if( !emitted ) {
	if( intrinsicpT().find( progenitor() ) == intrinsicpT().end() ) {
	kinematics->updateLast( newParent, ZERO, ZERO );
	}
	else {
	pair<Energy,double> kt = intrinsicpT()[progenitor()];
	kinematics->updateLast( newParent,
	kt.first*cos( kt.second ),
	kt.first*sin( kt.second ) );
	}
	}
	particle->showerKinematics()->
	updateChildren( newParent, theChildren,bb.type,false);
	if(hardOnly()) return true;
	// perform the shower of the final-state particle
	if( timelike->children().empty() ) {
	timeLikeShower( otherChild , type,Branching(),true);
	}
	else {
	truncatedTimeLikeShower( otherChild, timelike , type,Branching(), true);
	}
	updateHistory(otherChild);
	// return the emitted
	return true;
	}
	// assign the splitting function and shower kinematics
	particle->showerKinematics( bb.kinematics );
	if(bb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(bb.kinematics->pT());
	// For the time being we are considering only 1->2 branching
	// Now create the actual particles, make the otherChild a final state
	// particle, while the newParent is not
	ShowerParticlePtr newParent = new_ptr( ShowerParticle( part[0], false ) );
	ShowerParticlePtr otherChild = new_ptr( ShowerParticle( part[1], true, true ) );
	ShowerParticleVector theChildren;
	theChildren.push_back( particle );
	theChildren.push_back( otherChild );
	particle->showerKinematics()->
	updateParent( newParent, theChildren, bb.type);
	// update the history if needed
	currentTree()->updateInitialStateShowerProduct( progenitor(), newParent );
	currentTree()->addInitialStateBranching( particle, newParent, otherChild );
	// for the reconstruction of kinematics, parent/child
	// relationships are according to the branching process:
	// now continue the shower
	bool emitted = truncatedSpaceLikeShower( newParent, beam, branch,type);
	// now reconstruct the momentum
	if( !emitted ) {
	if( intrinsicpT().find( progenitor() ) == intrinsicpT().end() ) {
	bb.kinematics->updateLast( newParent, ZERO, ZERO );
	}
	else {
	pair<Energy,double> kt = intrinsicpT()[ progenitor() ];
	bb.kinematics->updateLast( newParent,
	kt.first*cos( kt.second ),
	kt.first*sin( kt.second ) );
	}
	}
	particle->showerKinematics()->
	updateChildren( newParent, theChildren, bb.type,false);
	// perform the shower of the final-state particle
	timeLikeShower( otherChild , type,Branching(),true);
	updateHistory(otherChild);
	// return the emitted
	return true;
	}

	bool Evolver::
	truncatedSpaceLikeDecayShower(tShowerParticlePtr particle,
	const ShowerParticle::EvolutionScales & maxScales,
	Energy minmass, HardBranchingPtr branch,
	ShowerInteraction::Type type, Branching fb) {
	// select a branching if we don't have one
	if(!fb.kinematics)
	fb = selectSpaceLikeDecayBranching(particle,maxScales,minmass,type,branch);
	// must be an emission, the forced one it not a truncated one
	assert(fb.kinematics);
	ShowerParticleVector children;
	int ntry=0;
	Branching fc[2];
	bool setupChildren = true;
	while (ntry<50) {
	if(!fc[0].hard) fc[0] = Branching();
	if(!fc[1].hard) fc[1] = Branching();
	++ntry;
	if(setupChildren) {
	++_nFSR;
	// Assign the shower kinematics to the emitting particle.
	particle->showerKinematics(fb.kinematics);
	if(fb.kinematics->pT()>progenitor()->highestpT())
	progenitor()->highestpT(fb.kinematics->pT());
	// create the ShowerParticle objects for the two children
	children = createTimeLikeChildren(particle,fb.ids);
	// updateChildren the children
	particle->showerKinematics()->
	updateChildren(particle, children, fb.type,_reconOpt>=3);
	setupChildren = false;
	}
	// select branchings for children
	if(!fc[0].kinematics) {
	if(children[0]->id()==particle->id()) {
	// select branching for first particle
	if(!fb.hard)
	fc[0] = selectSpaceLikeDecayBranching(children[0],maxScales,minmass,type,branch);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	fc[0] = selectSpaceLikeDecayBranching(children[0],maxScales,minmass,type,
	branch->children()[0]);
	else
	fc[0] = selectSpaceLikeDecayBranching(children[0],maxScales,minmass,type,
	HardBranchingPtr());
	}
	else {
	// select branching for first particle
	if(fb.hard && !branch->children()[0]->children().empty() )
	fc[0] = selectTimeLikeBranching(children[0],type,branch->children()[0]);
	else
	fc[0] = selectTimeLikeBranching(children[0],type,HardBranchingPtr());
	}
	}
	// select branching for the second particle
	if(!fc[1].kinematics) {
	if(children[1]->id()==particle->id()) {
	// select branching for first particle
	if(!fb.hard)
	fc[1] = selectSpaceLikeDecayBranching(children[1],maxScales,minmass,type,branch);
	else if(fb.hard && ! branch->children()[1]->children().empty() )
	fc[1] = selectSpaceLikeDecayBranching(children[1],maxScales,minmass,type,
	branch->children()[1]);
	else
	fc[1] = selectSpaceLikeDecayBranching(children[1],maxScales,minmass,type,
	HardBranchingPtr());
	}
	else {
	if(fb.hard && !branch->children()[1]->children().empty() )
	fc[1] = selectTimeLikeBranching(children[1],type,branch->children()[1]);
	else
	fc[1] = selectTimeLikeBranching(children[1],type,HardBranchingPtr());
	}
	}
	// old default
	if(_reconOpt==0 \|\| (_reconOpt==1 && fb.hard) ) {
	// update the history if needed
	currentTree()->updateInitialStateShowerProduct(progenitor(),children[0]);
	currentTree()->addInitialStateBranching(particle,children[0],children[1]);
	// shower the first particle
	if(fc[0].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[0]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[0]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[0]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[0],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	}
	// shower the second particle
	if(fc[1].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[1]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[1]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[1]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[1],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[1],false);
	}
	}
	updateHistory(children[1]);
	// branching has happened
	break;
	}
	// H7 default
	else if(_reconOpt==1) {
	// update the history if needed
	currentTree()->updateInitialStateShowerProduct(progenitor(),children[0]);
	currentTree()->addInitialStateBranching(particle,children[0],children[1]);
	// shower the first particle
	if(fc[0].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[0]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[0]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[0]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[0],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	}
	// shower the second particle
	if(fc[1].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[1]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[1]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[1]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[1],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[1],false);
	}
	}
	// clean up the vetoed emission
	if(particle->virtualMass()==ZERO) {
	particle->showerKinematics(ShoKinPtr());
	for(unsigned int ix=0;ix<children.size();++ix)
	particle->abandonChild(children[ix]);
	children.clear();
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	// generate the new emission
	fb = selectSpaceLikeDecayBranching(particle,maxScales,minmass,type,branch);
	// must be at least hard emission
	assert(fb.kinematics);
	setupChildren = true;
	continue;
	}
	else {
	updateHistory(children[1]);
	break;
	}
	}
	else if(_reconOpt>=2) {
	// cut-off masses for the branching
	const vector<Energy> & virtualMasses = fb.sudakov->virtualMasses(fb.ids);
	// compute the masses of the children
	Energy masses[3];
	// space-like children
	masses[1] = children[0]->virtualMass();
	// time-like child
	if(fc[1].kinematics) {
	const vector<Energy> & vm = fc[1].sudakov->virtualMasses(fc[1].ids);
	Energy2 q2 =
	fc[1].kinematics->z()(1.-fc[1].kinematics->z())sqr(fc[1].kinematics->scale());
	if(fc[1].ids[0]!=ParticleID::g) q2 += sqr(vm[0]);
	masses[2] = sqrt(q2);
	}
	else {
	masses[2] = virtualMasses[2];
	}
	masses[0]=particle->virtualMass();
	double z = fb.kinematics->z();
	Energy2 pt2 = (1.-z)(zsqr(masses[0])-sqr(masses[1])-z/(1.-z)*sqr(masses[2]));
	if(pt2>=ZERO) {
	break;
	}
	else {
	// reset the scales for the children
	for(unsigned int ix=0;ix<2;++ix) {
	if(fc[ix].kinematics)
	children[ix]->vetoEmission(fc[ix].type,fc[ix].kinematics->scale());
	else {
	if(ix==0)
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,Constants::MaxEnergy);
	else
	children[ix]->vetoEmission(ShowerPartnerType::QCDColourLine,ZERO);
	}
	}
	children[0]->virtualMass(_progenitor->progenitor()->mass());
	children[1]->virtualMass(ZERO);
	}
	}
	};
	if(_reconOpt>=2) {
	// update the history if needed
	currentTree()->updateInitialStateShowerProduct(progenitor(),children[0]);
	currentTree()->addInitialStateBranching(particle,children[0],children[1]);
	// shower the first particle
	if(fc[0].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[0]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[0]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[0]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[0],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[0],false);
	}
	}
	// shower the second particle
	if(fc[1].kinematics) {
	if(children[0]->id()==particle->id()) {
	if(!fb.hard)
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch,type,fc[1]);
	else if(fb.hard && ! branch->children()[0]->children().empty() )
	truncatedSpaceLikeDecayShower( children[0],maxScales,minmass,
	branch->children()[0],type,fc[1]);
	else
	spaceLikeDecayShower( children[0],maxScales,minmass,type,fc[1]);
	}
	else {
	if(fb.hard && !branch->children()[0]->children().empty() )
	truncatedTimeLikeShower(children[0],branch->children()[0],type,fc[1],false);
	// normal shower
	else
	timeLikeShower(children[0],type,fc[1],false);
	}
	}
	updateHistory(children[1]);
	}
	return true;
	}

	void Evolver::connectTrees(ShowerTreePtr showerTree,
	HardTreePtr hardTree, bool hard ) {
	ShowerParticleVector particles;
	// find the Sudakovs
	for(set<HardBranchingPtr>::iterator cit=hardTree->branchings().begin();
	cit!=hardTree->branchings().end();++cit) {
	// Sudakovs for ISR
	if((cit).parent()&&(cit).status()==HardBranching::Incoming) {
	++_nis;
	IdList br(3);
	br[0] = (**cit).parent()->branchingParticle()->id();
	br[1] = (**cit). branchingParticle()->id();
	br[2] = (*cit).parent()->children()[0]==cit ?
	(**cit).parent()->children()[1]->branchingParticle()->id() :
	(**cit).parent()->children()[0]->branchingParticle()->id();
	BranchingList branchings = splittingGenerator()->initialStateBranchings();
	if(br[1]<0&&br[0]==br[1]) {
	br[0] = abs(br[0]);
	br[1] = abs(br[1]);
	}
	else if(br[1]<0) {
	br[1] = -br[1];
	br[2] = -br[2];
	}
	long index = abs(br[1]);
	SudakovPtr sudakov;
	for(BranchingList::const_iterator cjt = branchings.lower_bound(index);
	cjt != branchings.upper_bound(index); ++cjt ) {
	IdList ids = cjt->second.second;
	if(ids[0]==br[0]&&ids[1]==br[1]&&ids[2]==br[2]) {
	sudakov=cjt->second.first;
	break;
	}
	}
	if(!sudakov) throw Exception() << "Can't find Sudakov for the hard emission in "
	<< "Evolver::connectTrees() for ISR"
	<< Exception::runerror;
	(**cit).parent()->sudakov(sudakov);
	}
	// Sudakovs for FSR
	else if(!(**cit).children().empty()) {
	++_nfs;
	IdList br(3);
	br[0] = (**cit) .branchingParticle()->id();
	br[1] = (**cit).children()[0]->branchingParticle()->id();
	br[2] = (**cit).children()[1]->branchingParticle()->id();
	BranchingList branchings = splittingGenerator()->finalStateBranchings();
	if(br[0]<0) {
	br[0] = abs(br[0]);
	br[1] = abs(br[1]);
	br[2] = abs(br[2]);
	}
	long index = br[0];
	SudakovPtr sudakov;
	for(BranchingList::const_iterator cjt = branchings.lower_bound(index);
	cjt != branchings.upper_bound(index); ++cjt ) {
	IdList ids = cjt->second.second;
	if(ids[0]==br[0]&&ids[1]==br[1]&&ids[2]==br[2]) {
	sudakov=cjt->second.first;
	break;
	}
	}
	if(!sudakov) throw Exception() << "Can't find Sudakov for the hard emission in "
	<< "Evolver::connectTrees()"
	<< Exception::runerror;
	(**cit).sudakov(sudakov);
	}
	}
	// calculate the evolution scale
	for(set<HardBranchingPtr>::iterator cit=hardTree->branchings().begin();
	cit!=hardTree->branchings().end();++cit) {
	particles.push_back((*cit)->branchingParticle());
	}
	showerModel()->partnerFinder()->
	setInitialEvolutionScales(particles,!hard,hardTree->interaction(),
	!hardTree->partnersSet());
	hardTree->partnersSet(true);
	// inverse reconstruction
	if(hard) {
	showerModel()->kinematicsReconstructor()->
	deconstructHardJets(hardTree,ShowerHandler::currentHandler()->evolver(),
	hardTree->interaction());
	}
	else
	showerModel()->kinematicsReconstructor()->
	deconstructDecayJets(hardTree,ShowerHandler::currentHandler()->evolver(),
	hardTree->interaction());
	// now reset the momenta of the showering particles
	vector<ShowerProgenitorPtr> particlesToShower;
	for(map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit=showerTree->incomingLines().begin();
	cit!=showerTree->incomingLines().end();++cit )
	particlesToShower.push_back(cit->first);
	// extract the showering particles
	for(map<ShowerProgenitorPtr,tShowerParticlePtr>::const_iterator
	cit=showerTree->outgoingLines().begin();
	cit!=showerTree->outgoingLines().end();++cit )
	particlesToShower.push_back(cit->first);
	// match them
	map<ShowerProgenitorPtr,HardBranchingPtr> partners;
	for(set<HardBranchingPtr>::const_iterator bit=hardTree->branchings().begin();
	bit!=hardTree->branchings().end();++bit) {
	Energy2 dmin( 1e30*GeV2 );
	ShowerProgenitorPtr partner;
	for(vector<ShowerProgenitorPtr>::const_iterator pit=particlesToShower.begin();
	pit!=particlesToShower.end();++pit) {
	if(partners.find(*pit)!=partners.end()) continue;
	if( (bit).branchingParticle()->id() != (pit).progenitor()->id() ) continue;
	if( (**bit).branchingParticle()->isFinalState() !=
	(**pit).progenitor()->isFinalState() ) continue;
	if( (**pit).progenitor()->isFinalState() ) {
	Energy2 dtest =
	sqr( (pit).progenitor()->momentum().x() - (bit).showerMomentum().x() ) +
	sqr( (pit).progenitor()->momentum().y() - (bit).showerMomentum().y() ) +
	sqr( (pit).progenitor()->momentum().z() - (bit).showerMomentum().z() ) +
	sqr( (pit).progenitor()->momentum().t() - (bit).showerMomentum().t() );
	// add mass difference for identical particles (e.g. Z0 Z0 production)
	dtest += 1e10sqr((pit).progenitor()->momentum().m()-(*bit).showerMomentum().m());
	if( dtest < dmin ) {
	partner = *pit;
	dmin = dtest;
	}
	}
	else {
	// ensure directions are right
	if((pit).progenitor()->momentum().z()/(bit).showerMomentum().z()>ZERO) {
	partner = *pit;
	break;
	}
	}
	}
	if(!partner) throw Exception() << "Failed to match shower and hard trees in Evolver::hardestEmission"
	<< Exception::eventerror;
	partners[partner] = *bit;
	}
	for(vector<ShowerProgenitorPtr>::const_iterator pit=particlesToShower.begin();
	pit!=particlesToShower.end();++pit) {
	HardBranchingPtr partner = partners[*pit];
	if((**pit).progenitor()->dataPtr()->stable()) {
	(**pit).progenitor()->set5Momentum(partner->showerMomentum());
	(**pit).copy()->set5Momentum(partner->showerMomentum());
	}
	else {
	Lorentz5Momentum oldMomentum = (**pit).progenitor()->momentum();
	Lorentz5Momentum newMomentum = partner->showerMomentum();
	LorentzRotation boost( oldMomentum.findBoostToCM(),oldMomentum.e()/oldMomentum.mass());
	(**pit).progenitor()->transform(boost);
	(**pit).copy() ->transform(boost);
	boost = LorentzRotation(-newMomentum.findBoostToCM(),newMomentum.e()/newMomentum.mass());
	(**pit).progenitor()->transform(boost);
	(**pit).copy() ->transform(boost);
	}
	}
	// correction boosts for daughter trees
	for(map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> >::const_iterator
	tit = showerTree->treelinks().begin();
	tit != showerTree->treelinks().end();++tit) {
	ShowerTreePtr decayTree = tit->first;
	map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit = decayTree->incomingLines().begin();
	// reset the momentum of the decay particle
	Lorentz5Momentum oldMomentum = cit->first->progenitor()->momentum();
	Lorentz5Momentum newMomentum = tit->second.second->momentum();
	LorentzRotation boost( oldMomentum.findBoostToCM(),oldMomentum.e()/oldMomentum.mass());
	decayTree->transform(boost,true);
	boost = LorentzRotation(-newMomentum.findBoostToCM(),newMomentum.e()/newMomentum.mass());
	decayTree->transform(boost,true);
	}
	}

	void Evolver::doShowering(bool hard,XCPtr xcomb) {
	// zero number of emissions
	_nis = _nfs = 0;
	// if MC@NLO H event and limited emissions
	// indicate both final and initial state emission
	if ( isMCatNLOHEvent && _limitEmissions != 0 ) {
	_nis = _nfs = 1;
	}
	// extract particles to shower
	vector<ShowerProgenitorPtr> particlesToShower(setupShower(hard));
	// setup the maximum scales for the shower
	if (hardVetoOn()) setupMaximumScales(particlesToShower,xcomb);
	// set the hard scales for the profiles
	setupHardScales(particlesToShower,xcomb);
	// specific stuff for hard processes and decays
	Energy minmass(ZERO), mIn(ZERO);
	// hard process generate the intrinsic p_T once and for all
	if(hard) {
	generateIntrinsicpT(particlesToShower);
	}
	// decay compute the minimum mass of the final-state
	else {
	for(unsigned int ix=0;ix<particlesToShower.size();++ix) {
	if(particlesToShower[ix]->progenitor()->isFinalState()) {
	if(particlesToShower[ix]->progenitor()->dataPtr()->stable())
	minmass += particlesToShower[ix]->progenitor()->dataPtr()->constituentMass();
	else
	minmass += particlesToShower[ix]->progenitor()->mass();
	}
	else {
	mIn = particlesToShower[ix]->progenitor()->mass();
	}
	}
	// throw exception if decay can't happen
	if ( minmass > mIn ) {
	throw Exception() << "Evolver.cc: Mass of decaying particle is "
	<< "below constituent masses of decay products."
	<< Exception::eventerror;
	}
	}
	// create random particle vector
	vector<ShowerProgenitorPtr> tmp;
	unsigned int nColouredIncoming = 0;
	while(particlesToShower.size()>0){
	unsigned int xx=UseRandom::irnd(particlesToShower.size());
	tmp.push_back(particlesToShower[xx]);
	particlesToShower.erase(particlesToShower.begin()+xx);
	}
	particlesToShower=tmp;
	for(unsigned int ix=0;ix<particlesToShower.size();++ix) {
	if(!particlesToShower[ix]->progenitor()->isFinalState() &&
	particlesToShower[ix]->progenitor()->coloured()) ++nColouredIncoming;
	}
	bool switchRecon = hard && nColouredIncoming !=1;
	// main shower loop
	unsigned int ntry(0);
	bool reconstructed = false;
	do {
	// clear results of last attempt if needed
	if(ntry!=0) {
	currentTree()->clear();
	setEvolutionPartners(hard,interaction_,true);
	_nis = _nfs = 0;
	// if MC@NLO H event and limited emissions
	// indicate both final and initial state emission
	if ( isMCatNLOHEvent && _limitEmissions != 0 ) {
	_nis = _nfs = 1;
	}
	for(unsigned int ix=0; ix<particlesToShower.size();++ix) {
	SpinPtr spin = particlesToShower[ix]->progenitor()->spinInfo();
	if(spin && spin->decayVertex() &&
	dynamic_ptr_cast<tcSVertexPtr>(spin->decayVertex())) {
	spin->decayVertex(VertexPtr());
	}
	}
	}
	// loop over particles
	for(unsigned int ix=0;ix<particlesToShower.size();++ix) {
	// extract the progenitor
	progenitor(particlesToShower[ix]);
	// final-state radiation
	if(progenitor()->progenitor()->isFinalState()) {
	if(!isFSRadiationON()) continue;
	// perform shower
	progenitor()->hasEmitted(startTimeLikeShower(interaction_));
	}
	// initial-state radiation
	else {
	if(!isISRadiationON()) continue;
	// hard process
	if(hard) {
	// get the PDF
	setBeamParticle(_progenitor->beam());
	assert(beamParticle());
	// perform the shower
	// set the beam particle
	tPPtr beamparticle=progenitor()->original();
	if(!beamparticle->parents().empty())
	beamparticle=beamparticle->parents()[0];
	// generate the shower
	progenitor()->hasEmitted(startSpaceLikeShower(beamparticle,
	interaction_));
	}
	// decay
	else {
	// skip colour and electrically neutral particles
	if(!progenitor()->progenitor()->dataPtr()->coloured() &&
	!progenitor()->progenitor()->dataPtr()->charged()) {
	progenitor()->hasEmitted(false);
	continue;
	}
	// perform shower
	// set the scales correctly. The current scale is the maximum scale for
	// emission not the starting scale
	ShowerParticle::EvolutionScales maxScales(progenitor()->progenitor()->scales());
	progenitor()->progenitor()->scales() = ShowerParticle::EvolutionScales();
	if(progenitor()->progenitor()->dataPtr()->charged()) {
	progenitor()->progenitor()->scales().QED = progenitor()->progenitor()->mass();
	progenitor()->progenitor()->scales().QED_noAO = progenitor()->progenitor()->mass();
	}
	if(progenitor()->progenitor()->hasColour()) {
	progenitor()->progenitor()->scales().QCD_c = progenitor()->progenitor()->mass();
	progenitor()->progenitor()->scales().QCD_c_noAO = progenitor()->progenitor()->mass();
	}
	if(progenitor()->progenitor()->hasAntiColour()) {
	progenitor()->progenitor()->scales().QCD_ac = progenitor()->progenitor()->mass();
	progenitor()->progenitor()->scales().QCD_ac_noAO = progenitor()->progenitor()->mass();
	}
	// perform the shower
	progenitor()->hasEmitted(startSpaceLikeDecayShower(maxScales,minmass,
	interaction_));
	}
	}
	}
	// do the kinematic reconstruction, checking if it worked
	reconstructed = hard ?
	showerModel()->kinematicsReconstructor()->
	reconstructHardJets (currentTree(),intrinsicpT(),interaction_,
	switchRecon && ntry>maximumTries()/2) :
	showerModel()->kinematicsReconstructor()->
	reconstructDecayJets(currentTree(),interaction_);
	}
	while(!reconstructed&&maximumTries()>++ntry);
	// check if failed to generate the shower
	if(ntry==maximumTries()) {
	if(hard)
	throw ShowerHandler::ShowerTriesVeto(ntry);
	else
	throw Exception() << "Failed to generate the shower after "
	<< ntry << " attempts in Evolver::showerDecay()"
	<< Exception::eventerror;
	}
	// tree has now showered
	_currenttree->hasShowered(true);
	hardTree(HardTreePtr());
	}

	void Evolver:: convertHardTree(bool hard,ShowerInteraction::Type type) {
	map<ColinePtr,ColinePtr> cmap;
	// incoming particles
	for(map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit=currentTree()->incomingLines().begin();cit!=currentTree()->incomingLines().end();++cit) {
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	mit = hardTree()->particles().find(cit->first->progenitor());
	// put the colour lines in the map
	ShowerParticlePtr oldParticle = cit->first->progenitor();
	ShowerParticlePtr newParticle = mit->second->branchingParticle();
	ColinePtr cLine = oldParticle-> colourLine();
	ColinePtr aLine = oldParticle->antiColourLine();
	if(newParticle->colourLine() &&
	cmap.find(newParticle-> colourLine())==cmap.end())
	cmap[newParticle-> colourLine()] = cLine;
	if(newParticle->antiColourLine() &&
	cmap.find(newParticle->antiColourLine())==cmap.end())
	cmap[newParticle->antiColourLine()] = aLine;
	// check whether or not particle emits
	bool emission = mit->second->parent();
	if(emission) {
	if(newParticle->colourLine()) {
	ColinePtr ctemp = newParticle-> colourLine();
	ctemp->removeColoured(newParticle);
	}
	if(newParticle->antiColourLine()) {
	ColinePtr ctemp = newParticle->antiColourLine();
	ctemp->removeAntiColoured(newParticle);
	}
	newParticle = mit->second->parent()->branchingParticle();
	}
	// get the new colour lines
	ColinePtr newCLine,newALine;
	// sort out colour lines
	if(newParticle->colourLine()) {
	ColinePtr ctemp = newParticle-> colourLine();
	ctemp->removeColoured(newParticle);
	if(cmap.find(ctemp)!=cmap.end()) {
	newCLine = cmap[ctemp];
	}
	else {
	newCLine = new_ptr(ColourLine());
	cmap[ctemp] = newCLine;
	}
	}
	// and anticolour lines
	if(newParticle->antiColourLine()) {
	ColinePtr ctemp = newParticle->antiColourLine();
	ctemp->removeAntiColoured(newParticle);
	if(cmap.find(ctemp)!=cmap.end()) {
	newALine = cmap[ctemp];
	}
	else {
	newALine = new_ptr(ColourLine());
	cmap[ctemp] = newALine;
	}
	}
	// remove colour lines from old particle
	if(aLine) {
	aLine->removeAntiColoured(cit->first->copy());
	aLine->removeAntiColoured(cit->first->progenitor());
	}
	if(cLine) {
	cLine->removeColoured(cit->first->copy());
	cLine->removeColoured(cit->first->progenitor());
	}
	// add particle to colour lines
	if(newCLine) newCLine->addColoured (newParticle);
	if(newALine) newALine->addAntiColoured(newParticle);
	// insert new particles
	cit->first->copy(newParticle);
	ShowerParticlePtr sp(new_ptr(ShowerParticle(*newParticle,1,false)));
	cit->first->progenitor(sp);
	currentTree()->incomingLines()[cit->first]=sp;
	cit->first->perturbative(!emission);
	// and the emitted particle if needed
	if(emission) {
	ShowerParticlePtr newOut = mit->second->parent()->children()[1]->branchingParticle();
	if(newOut->colourLine()) {
	ColinePtr ctemp = newOut-> colourLine();
	ctemp->removeColoured(newOut);
	assert(cmap.find(ctemp)!=cmap.end());
	cmap[ctemp]->addColoured (newOut);
	}
	if(newOut->antiColourLine()) {
	ColinePtr ctemp = newOut->antiColourLine();
	ctemp->removeAntiColoured(newOut);
	assert(cmap.find(ctemp)!=cmap.end());
	cmap[ctemp]->addAntiColoured(newOut);
	}
	ShowerParticlePtr sout=new_ptr(ShowerParticle(*newOut,1,true));
	ShowerProgenitorPtr out=new_ptr(ShowerProgenitor(cit->first->original(),newOut,sout));
	out->perturbative(false);
	currentTree()->outgoingLines().insert(make_pair(out,sout));
	}
	if(hard) {
	// sort out the value of x
	if(mit->second->beam()->momentum().z()>ZERO) {
	sp->x(newParticle->momentum(). plus()/mit->second->beam()->momentum(). plus());
	}
	else {
	sp->x(newParticle->momentum().minus()/mit->second->beam()->momentum().minus());
	}
	}
	}
	// outgoing particles
	for(map<ShowerProgenitorPtr,tShowerParticlePtr>::const_iterator
	cit=currentTree()->outgoingLines().begin();cit!=currentTree()->outgoingLines().end();++cit) {
	map<tShowerTreePtr,pair<tShowerProgenitorPtr,
	tShowerParticlePtr> >::const_iterator tit;
	for(tit = currentTree()->treelinks().begin();
	tit != currentTree()->treelinks().end();++tit) {
	if(tit->second.first && tit->second.second==cit->first->progenitor())
	break;
	}
	map<ShowerParticlePtr,tHardBranchingPtr>::const_iterator
	mit = hardTree()->particles().find(cit->first->progenitor());
	if(mit==hardTree()->particles().end()) continue;
	// put the colour lines in the map
	ShowerParticlePtr oldParticle = cit->first->progenitor();
	ShowerParticlePtr newParticle = mit->second->branchingParticle();
	ShowerParticlePtr newOut;
	ColinePtr cLine = oldParticle-> colourLine();
	ColinePtr aLine = oldParticle->antiColourLine();
	if(newParticle->colourLine() &&
	cmap.find(newParticle-> colourLine())==cmap.end())
	cmap[newParticle-> colourLine()] = cLine;
	if(newParticle->antiColourLine() &&
	cmap.find(newParticle->antiColourLine())==cmap.end())
	cmap[newParticle->antiColourLine()] = aLine;
	// check whether or not particle emits
	bool emission = !mit->second->children().empty();
	if(emission) {
	if(newParticle->colourLine()) {
	ColinePtr ctemp = newParticle-> colourLine();
	ctemp->removeColoured(newParticle);
	}
	if(newParticle->antiColourLine()) {
	ColinePtr ctemp = newParticle->antiColourLine();
	ctemp->removeAntiColoured(newParticle);
	}
	newParticle = mit->second->children()[0]->branchingParticle();
	newOut = mit->second->children()[1]->branchingParticle();
	if(newParticle->id()!=oldParticle->id()&&newParticle->id()==newOut->id())
	swap(newParticle,newOut);
	}
	// get the new colour lines
	ColinePtr newCLine,newALine;
	// sort out colour lines
	if(newParticle->colourLine()) {
	ColinePtr ctemp = newParticle-> colourLine();
	ctemp->removeColoured(newParticle);
	if(cmap.find(ctemp)!=cmap.end()) {
	newCLine = cmap[ctemp];
	}
	else {
	newCLine = new_ptr(ColourLine());
	cmap[ctemp] = newCLine;
	}
	}
	// and anticolour lines
	if(newParticle->antiColourLine()) {
	ColinePtr ctemp = newParticle->antiColourLine();
	ctemp->removeAntiColoured(newParticle);
	if(cmap.find(ctemp)!=cmap.end()) {
	newALine = cmap[ctemp];
	}
	else {
	newALine = new_ptr(ColourLine());
	cmap[ctemp] = newALine;
	}
	}
	// remove colour lines from old particle
	if(aLine) {
	aLine->removeAntiColoured(cit->first->copy());
	aLine->removeAntiColoured(cit->first->progenitor());
	}
	if(cLine) {
	cLine->removeColoured(cit->first->copy());
	cLine->removeColoured(cit->first->progenitor());
	}
	// special for unstable particles
	if(newParticle->id()==oldParticle->id() &&
	(tit!=currentTree()->treelinks().end()\|\|!oldParticle->dataPtr()->stable())) {
	Lorentz5Momentum oldMomentum = oldParticle->momentum();
	Lorentz5Momentum newMomentum = newParticle->momentum();
	LorentzRotation boost( oldMomentum.findBoostToCM(),oldMomentum.e()/oldMomentum.mass());
	if(tit!=currentTree()->treelinks().end()) tit->first->transform(boost,false);
	oldParticle->transform(boost);
	boost = LorentzRotation(-newMomentum.findBoostToCM(),newMomentum.e()/newMomentum.mass());
	oldParticle->transform(boost);
	if(tit!=currentTree()->treelinks().end()) tit->first->transform(boost,false);
	newParticle=oldParticle;
	}
	// add particle to colour lines
	if(newCLine) newCLine->addColoured (newParticle);
	if(newALine) newALine->addAntiColoured(newParticle);
	// insert new particles
	cit->first->copy(newParticle);
	ShowerParticlePtr sp(new_ptr(ShowerParticle(*newParticle,1,true)));
	cit->first->progenitor(sp);
	currentTree()->outgoingLines()[cit->first]=sp;
	cit->first->perturbative(!emission);
	// and the emitted particle if needed
	if(emission) {
	if(newOut->colourLine()) {
	ColinePtr ctemp = newOut-> colourLine();
	ctemp->removeColoured(newOut);
	assert(cmap.find(ctemp)!=cmap.end());
	cmap[ctemp]->addColoured (newOut);
	}
	if(newOut->antiColourLine()) {
	ColinePtr ctemp = newOut->antiColourLine();
	ctemp->removeAntiColoured(newOut);
	assert(cmap.find(ctemp)!=cmap.end());
	cmap[ctemp]->addAntiColoured(newOut);
	}
	ShowerParticlePtr sout=new_ptr(ShowerParticle(*newOut,1,true));
	ShowerProgenitorPtr out=new_ptr(ShowerProgenitor(cit->first->original(),newOut,sout));
	out->perturbative(false);
	currentTree()->outgoingLines().insert(make_pair(out,sout));
	}
	// update any decay products
	if(tit!=currentTree()->treelinks().end())
	currentTree()->updateLink(tit->first,make_pair(cit->first,sp));
	}
	// reset the tree
	currentTree()->resetShowerProducts();
	// reextract the particles and set the colour partners
	vector<ShowerParticlePtr> particles =
	currentTree()->extractProgenitorParticles();
	// clear the partners
	for(unsigned int ix=0;ix<particles.size();++ix) {
	particles[ix]->partner(ShowerParticlePtr());
	particles[ix]->clearPartners();
	}
	// clear the tree
	hardTree(HardTreePtr());
	// Set the initial evolution scales
	showerModel()->partnerFinder()->
	setInitialEvolutionScales(particles,!hard,type,!_hardtree);
	}

	Branching Evolver::selectTimeLikeBranching(tShowerParticlePtr particle,
	ShowerInteraction::Type type,
	HardBranchingPtr branch) {
	Branching fb;
	unsigned int iout=0;
	tcPDPtr pdata[2];
	while (true) {
	// break if doing truncated shower and no truncated shower needed
	if(branch && (!isTruncatedShowerON()\|\|hardOnly())) break;
	fb=_splittingGenerator->chooseForwardBranching(*particle,_finalenhance,type);
	// no emission break
	if(!fb.kinematics) break;
	// special for truncated shower
	if(branch) {
	// check haven't evolved too far
	if(fb.kinematics->scale() < branch->scale()) {
	fb=Branching();
	break;
	}
	// get the particle data objects
	for(unsigned int ix=0;ix<2;++ix) pdata[ix]=getParticleData(fb.ids[ix+1]);
	if(particle->id()!=fb.ids[0]) {
	for(unsigned int ix=0;ix<2;++ix) {
	tPDPtr cc(pdata[ix]->CC());
	if(cc) pdata[ix]=cc;
	}
	}
	// find the truncated line
	iout=0;
	if(pdata[0]->id()!=pdata[1]->id()) {
	if(pdata[0]->id()==particle->id()) iout=1;
	else if (pdata[1]->id()==particle->id()) iout=2;
	}
	else if(pdata[0]->id()==particle->id()) {
	if(fb.kinematics->z()>0.5) iout=1;
	else iout=2;
	}
	// apply the vetos for the truncated shower
	// no flavour changing branchings
	if(iout==0) {
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	double zsplit = iout==1 ? fb.kinematics->z() : 1-fb.kinematics->z();
	// only if same interaction for forced branching
	ShowerInteraction::Type type2 = convertInteraction(fb.type);
	// and evolution
	if(type2==branch->sudakov()->interactionType()) {
	if(zsplit < 0.5 \|\| // hardest line veto
	fb.kinematics->scale()*zsplit < branch->scale() ) { // angular ordering veto
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	}
	// pt veto
	if(fb.kinematics->pT() > progenitor()->maximumpT(type2)) {
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	}
	// standard vetos for all emissions
	if(timeLikeVetoed(fb,particle)) {
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	if(particle->spinInfo()) particle->spinInfo()->decayVertex(VertexPtr());
	continue;
	}
	break;
	}
	// normal case
	if(!branch) {
	if(fb.kinematics) fb.hard = false;
	return fb;
	}
	// truncated emission
	if(fb.kinematics) {
	fb.hard = false;
	fb.iout = iout;
	return fb;
	}
	// otherwise need to return the hard emission
	// construct the kinematics for the hard emission
	ShoKinPtr showerKin=
	branch->sudakov()->createFinalStateBranching(branch->scale(),
	branch->children()[0]->z(),
	branch->phi(),
	branch->children()[0]->pT());
	IdList idlist(3);
	idlist[0] = particle->id();
	idlist[1] = branch->children()[0]->branchingParticle()->id();
	idlist[2] = branch->children()[1]->branchingParticle()->id();
	fb = Branching( showerKin, idlist, branch->sudakov(),branch->type() );
	fb.hard = true;
	fb.iout=0;
	// return it
	return fb;
	}

	Branching Evolver::selectSpaceLikeDecayBranching(tShowerParticlePtr particle,
	const ShowerParticle::EvolutionScales & maxScales,
	Energy minmass,ShowerInteraction::Type type,
	HardBranchingPtr branch) {
	Branching fb;
	unsigned int iout=0;
	tcPDPtr pdata[2];
	while (true) {
	// break if doing truncated shower and no truncated shower needed
	if(branch && (!isTruncatedShowerON()\|\|hardOnly())) break;
	// select branching
	fb=_splittingGenerator->chooseDecayBranching(*particle,maxScales,minmass,
	_initialenhance,type);
	// return if no radiation
	if(!fb.kinematics) break;
	// special for truncated shower
	if(branch) {
	// check haven't evolved too far
	if(fb.kinematics->scale() < branch->scale()) {
	fb=Branching();
	break;
	}
	// get the particle data objects
	for(unsigned int ix=0;ix<2;++ix) pdata[ix]=getParticleData(fb.ids[ix+1]);
	if(particle->id()!=fb.ids[0]) {
	for(unsigned int ix=0;ix<2;++ix) {
	tPDPtr cc(pdata[ix]->CC());
	if(cc) pdata[ix]=cc;
	}
	}
	// find the truncated line
	iout=0;
	if(pdata[0]->id()!=pdata[1]->id()) {
	if(pdata[0]->id()==particle->id()) iout=1;
	else if (pdata[1]->id()==particle->id()) iout=2;
	}
	else if(pdata[0]->id()==particle->id()) {
	if(fb.kinematics->z()>0.5) iout=1;
	else iout=2;
	}
	// apply the vetos for the truncated shower
	// no flavour changing branchings
	if(iout==0) {
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	ShowerInteraction::Type type2 = convertInteraction(fb.type);
	double zsplit = iout==1 ? fb.kinematics->z() : 1-fb.kinematics->z();
	if(type2==branch->sudakov()->interactionType()) {
	if(zsplit < 0.5 \|\| // hardest line veto
	fb.kinematics->scale()*zsplit < branch->scale() ) { // angular ordering veto
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	}
	// pt veto
	if(fb.kinematics->pT() > progenitor()->maximumpT(type2)) {
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	}
	// if not vetoed break
	if(spaceLikeDecayVetoed(fb,particle)) {
	// otherwise reset scale and continue
	particle->vetoEmission(fb.type,fb.kinematics->scale());
	continue;
	}
	break;
	}
	// normal case
	if(!branch) {
	if(fb.kinematics) fb.hard = false;
	return fb;
	}
	// truncated emission
	if(fb.kinematics) {
	fb.hard = false;
	fb.iout = iout;
	return fb;
	}
	// otherwise need to return the hard emission
	// construct the kinematics for the hard emission
	ShoKinPtr showerKin=
	branch->sudakov()->createDecayBranching(branch->scale(),
	branch->children()[0]->z(),
	branch->phi(),
	branch->children()[0]->pT());
	IdList idlist(3);
	idlist[0] = particle->id();
	idlist[1] = branch->children()[0]->branchingParticle()->id();
	idlist[2] = branch->children()[1]->branchingParticle()->id();
	// create the branching
	fb = Branching( showerKin, idlist, branch->sudakov(),ShowerPartnerType::QCDColourLine );
	fb.hard=true;
	fb.iout=0;
	// return it
	return fb;
	}
	diff --git a/Shower/Base/ShowerKinematics.cc b/Shower/Base/ShowerKinematics.cc
	--- a/Shower/Base/ShowerKinematics.cc
	+++ b/Shower/Base/ShowerKinematics.cc
	@@ -1,70 +1,65 @@
	// -- C++ --
	//
	// ShowerKinematics.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 ShowerKinematics class.
	//
	#include "ShowerKinematics.h"

	using namespace Herwig;

	void ShowerKinematics::updateChildren(const tShowerParticlePtr,
	const ShowerParticleVector &,
	ShowerPartnerType::Type,bool) const {
	throw Exception() << "Base class ShowerKinematics::updateChildren called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}
	void ShowerKinematics::resetChildren(const tShowerParticlePtr,
	const ShowerParticleVector &) const {
	throw Exception() << "Base class ShowerKinematics::resetChildren called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}

	void ShowerKinematics::updateParent(const tShowerParticlePtr,
	const ShowerParticleVector &,
	ShowerPartnerType::Type) const {
	throw Exception() << "Base class ShowerKinematics::updateParent called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}

	void ShowerKinematics::reconstructChildren(const tShowerParticlePtr,
	const ShowerParticleVector &) const {
	throw Exception() << "Base class ShowerKinematics::reconstructChildren called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}

	void ShowerKinematics::reconstructParent(const tShowerParticlePtr,
	const ParticleVector &) const {
	throw Exception() << "Base class ShowerKinematics::reconstructParent called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}

	void ShowerKinematics::reconstructLast(const tShowerParticlePtr,
	Energy) const {
	throw Exception() << "Base class ShowerKinematics::reconstructLast called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}

	void ShowerKinematics::updateLast(const tShowerParticlePtr,
	Energy,Energy) const {
	throw Exception() << "Base class ShowerKinematics::updatetLast called,"
	<< " should have been overriden in an inheriting class"
	<< Exception::runerror;
	}
	-
	-void ShowerKinematics::transform(const LorentzRotation & ) {
	- throw Exception() << "Base class ShowerKinematics::transform called "
	- << Exception::runerror;
	-}
	diff --git a/Shower/Base/ShowerKinematics.h b/Shower/Base/ShowerKinematics.h
	--- a/Shower/Base/ShowerKinematics.h
	+++ b/Shower/Base/ShowerKinematics.h
	@@ -1,308 +1,303 @@
	// -- C++ --
	//
	// ShowerKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 of the GPL, see COPYING for details.
	// Please respect the MCnet academic guidelines, see GUIDELINES for details.
	//
	#ifndef HERWIG_ShowerKinematics_H
	#define HERWIG_ShowerKinematics_H
	//
	// This is the declaration of the ShowerKinematics class.
	//

	#include "Herwig/Shower/ShowerConfig.h"
	#include "ThePEG/Config/ThePEG.h"
	#include "Herwig/Shower/Base/SudakovFormFactor.h"
	#include "ShowerKinematics.fh"

	namespace Herwig {

	using namespace ThePEG;

	/**\ingroup Shower
	*
	* This is the abstract base class from which all other shower
	* kinematics classes derive. The main purpose of the
	* shower kinematics classes is to allow the reconstruction
	* of jet masses, at the end of the showering (indeed, for
	* multi-scale showering, at the end of each scale-range evolution).
	* This is necessary for the kinematics reshuffling
	* in order to compensate the recoil of the emissions.
	* The KinematicsReconstructor class is in
	* charge of this job, and which is the main "user" of
	* ShowerKinematics and its derived classes.
	* How this is done depends on the choice of kinematics variables
	* and whether the jet is time-like (forward evolved) or
	* space-like (backward evolved), whereas the class ShowerKinematics
	* describes only the common features which are independent by them.
	*
	* In general there are a number of methods specific to a shower approach
	*
	* @see KinematicsReconstructor
	*/
	class ShowerKinematics: public Base {

	public:

	/**
	* The default constructor.
	*/
	ShowerKinematics() : Base(), _isTheJetStartingPoint( false ),
	_scale(), _z( 0.0 ), _phi( 0.0 ), _pt(),
	_sudakov() {}

	/**
	* The updateChildren and updateParent
	* members to update the values of the \f$\alpha\f$ and
	* \f$p_\perp\f$ variables during the shower evolution.
	*/
	//@{
	/**
	* Along with the showering evolution --- going forward for
	* time-like (forward) evolution, and going backward for space-like
	* (backward) evolution --- the kinematical variables of the
	* branching products are calculated and updated from the knowledge
	* of the parent kinematics.
	* @param parent The parent
	* @param children The children
	* @param partnerType The type of evolution partner
	*/
	virtual void updateChildren(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type partnerType,
	bool massVeto ) const;

	virtual void resetChildren( const tShowerParticlePtr parent,
	const ShowerParticleVector & children) const;

	/**
	* Update the parent Kinematics from the knowledge of the kinematics
	* of the children. This method will be used by the KinematicsReconstructor.
	* @param parent The parent
	* @param children The children
	* @param partnerType The type of evolution partner
	*/
	virtual void updateParent(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type partnerType) const;

	/**
	* Update the kinematical data of a particle when a reconstruction
	* fixpoint was found. This will highly depend on the kind of
	* kinematics chosen and will be defined in the inherited concrete
	* classes. This method will be used by the KinematicsReconstructor.
	* @param last The particle.
	* @param px The \f$x\f$ component of the \f$p_T\f$.
	* @param py The \f$y\f$ component of the \f$p_T\f$.
	*/
	virtual void updateLast(const tShowerParticlePtr last,
	Energy px, Energy py) const;
	//@}

	/**
	* The reconstructLast, reconstructChildren and reconstructParent members
	* are used during the reconstruction
	*/
	//@{
	/**
	* Along with the showering evolution --- going forward for
	* time-like (forward) evolution, and going backward for space-like
	* (backward) evolution --- the kinematical variables of the
	* branching products are calculated and updated from the knowledge
	* of the parent kinematics.
	* @param parent The parent
	* @param children The children
	*/
	virtual void reconstructChildren(const tShowerParticlePtr parent,
	const ShowerParticleVector & children) const;

	/**
	* Reconstruct the parent Kinematics from the knowledge of the kinematics
	* of the children. This method will be used by the KinematicsReconstructor.
	* @param parent The parent
	* @param children The children
	*/
	virtual void reconstructParent(const tShowerParticlePtr parent,
	const ParticleVector & children) const;

	/**
	* Update the kinematical data of a particle when a reconstruction
	* fixpoint was found. This will highly depend on the kind of
	* kinematics chosen and will be defined in the inherited concrete
	* classes. This method will be used by the KinematicsReconstructor.
	* @param last The particle.
	* @param mass The mass to be used, if less than zero on-shell
	*/
	virtual void reconstructLast(const tShowerParticlePtr last, Energy mass=-1.*GeV) const;
	//@}

	public:

	/**
	* Set/access the flag that tells whether or not this ShowerKinematics
	* object is associated to the starting particle of the jet: only in this
	* case it is sensible to use the two main virtual methods below.
	*/
	//@{
	/**
	* Set the starting point flag
	*/
	void isTheJetStartingPoint(const bool );

	/**
	* Get the starting point flag
	*/
	bool isTheJetStartingPoint() const;
	//@}

	/**
	* Set/Get methods for the kinematic variables
	*/
	//@{
	/**
	* Access the scale of the splitting.
	*/
	Energy scale() const { return _scale; }

	/**
	* Set the scale of the splitting.
	*/
	void scale(const Energy in) { _scale=in; }

	/**
	* Access the energy fraction, \f$z\f$.
	*/
	double z() const { return _z; }

	/**
	* Set the energy fraction, \f$z\f$.
	*/
	void z(const double in) { _z=in; }

	/**
	* Access the azimuthal angle, \f$\phi\f$.
	*/
	double phi() const { return _phi; }

	/**
	* Set the azimuthal angle, \f$\phi\f$.
	*/
	void phi(const double in) { _phi=in; }

	/**
	* Access the relative \f$p_T\f$ for the branching
	*/
	Energy pT() const { return _pt; }

	/**
	* Set the relative \f$p_T\f$ for the branching
	*/
	void pT(const Energy in) const { _pt=in; }
	//@}

	/**
	* Set and get methods for the SplittingFunction object
	*/
	//@{
	/**
	* Access the SplittingFunction object responsible of the
	* eventual branching of this particle.
	*/
	tSplittingFnPtr splittingFn() const { return _sudakov-> splittingFn(); }
	//@}

	/**
	* Set and get methods for the SudakovFormFactor object
	*/
	/**
	* Access the SudakovFormFactor object responsible of the
	* eventual branching of this particle.
	*/
	tSudakovPtr SudakovFormFactor() const { return _sudakov; }

	/**
	* Set the SudakovFormFactor object responsible of the
	* eventual branching of this particle.
	*/
	void SudakovFormFactor(const tSudakovPtr sud) { _sudakov=sud; }
	//@}

	- /**
	- * Transform the shower kinematics (usually the reference vectors)
	- */
	- virtual void transform(const LorentzRotation & r);
	-
	private:

	/**
	* The assignment operator is private and must never be called.
	* In fact, it should not even be implemented.
	*/
	ShowerKinematics & operator=(const ShowerKinematics &);

	private:

	/**
	* Is this the starting point of the jet
	*/
	bool _isTheJetStartingPoint;

	/**
	* The \f$\tilde{q}\f$ evolution variable.
	*/
	Energy _scale;

	/**
	* The energy fraction, \f$z\f$
	*/
	double _z;

	/**
	* The azimuthal angle, \f$\phi\f$.
	*/
	double _phi;

	/**
	* The relative \f$p_T\f$
	*/
	mutable Energy _pt;

	/**
	* The splitting function for the branching of the particle
	*/
	tSudakovPtr _sudakov;

	};

	}

	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/** This template specialization informs ThePEG about the
	* base classes of ShowerKinematics. */
	template <>
	struct BaseClassTrait<Herwig::ShowerKinematics,1> {
	/** Typedef of the first base class of ShowerKinematics. */
	typedef Base NthBase;
	};

	/** This template specialization informs ThePEG about the name of
	* the ShowerKinematics class and the shared object where it is defined. */
	template <>
	struct ClassTraits<Herwig::ShowerKinematics>
	: public ClassTraitsBase<Herwig::ShowerKinematics> {
	/** Return a platform-independent class name */
	static string className() { return "Herwig::ShowerKinematics"; }
	};

	/** @endcond */

	}

	#endif /* HERWIG_ShowerKinematics_H */
	diff --git a/Shower/Base/ShowerParticle.cc b/Shower/Base/ShowerParticle.cc
	--- a/Shower/Base/ShowerParticle.cc
	+++ b/Shower/Base/ShowerParticle.cc
	@@ -1,595 +1,593 @@
	// -- C++ --
	//
	// ShowerParticle.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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/SpinorWaveFunction.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::Type, 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 );
	}

	void ShowerParticle::addPartner(EvolutionPartner in ) {
	partners_.push_back(in);
	}

	namespace {

	LorentzRotation boostToShower(Lorentz5Momentum & porig, tShowerBasisPtr basis) {
	LorentzRotation output;
	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) {
	// 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(),outgoing);
	for(unsigned int ix=0;ix<3;++ix) {
	if(massless&&ix==1) {
	fbasis.push_back(LorentzPolarizationVector());
	}
	else {
	wave.reset(ix);
	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)= sbasis[iy].dot(fbasis[ix].conjugate());
	if(particle.id()<0)
	mapping(ix,iy)=conj(mapping(ix,iy));
	}
	}
	// \todo need to fix this
	mapping = RhoDMatrix(PDT::Spin1,false);
	if(massless) {
	mapping(0,0) = 1.;
	mapping(2,2) = 1.;
	}
	else {
	mapping(0,0) = 1.;
	mapping(1,1) = 1.;
	mapping(2,2) = 1.;
	}
	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);
	fspin->setDecayState(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);
	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);
	basis = wave.wave();
	}
	basis *= rinv;
	vspin->setBasisState(ix,basis);
	vspin->setDecayState(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
	if(needMapping) {
	RhoDMatrix rhop(rho.iSpin(),false);
	for(int ixa=0;ixa<rho.iSpin();++ixa) {
	for(int ixb=0;ixb<rho.iSpin();++ixb) {
	for(int iya=0;iya<rho.iSpin();++iya) {
	for(int iyb=0;iyb<rho.iSpin();++iyb) {
	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);
	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);
	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()) {
	// get the basis vectors
	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);
	// 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);
	VectorWaveFunction::constructSpinInfo(vtemp,this,outgoing,timeLike,massless);
	}
	else {
	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);
	- ShowerBasisPtr newBasis;
	// 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.5p.mass()pcm.vect().unit());
	n.boost( -boost);
	newBasis = new_ptr(ShowerBasis());
	newBasis->setBasis(p,n,ShowerBasis::Rest);
	+ showerBasis(newBasis,false);
	}
	else {
	- newBasis = dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis();
	+ showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis(),true);
	}
	- assert(newBasis);
	- showerBasis(newBasis);
	}

	void ShowerParticle::initializeInitialState(PPtr parent) {
	// For the time being we are considering only 1->2 branching
	Lorentz5Momentum p, n, pthis, pcm;
	assert(perturbative()!=2);
	- ShowerBasisPtr newBasis;
	if(perturbative()==1) {
	+ ShowerBasisPtr newBasis;
	// find the partner and its momentum
	- assert(partner());
	+ 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 {
	- newBasis = dynamic_ptr_cast<ShowerParticlePtr>(children()[0])->showerBasis();
	+ showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(children()[0])->showerBasis(),true);
	}
	- assert(newBasis);
	- showerBasis(newBasis);
	}

	void ShowerParticle::initializeFinalState() {
	// set the basis vectors
	Lorentz5Momentum p,n;
	- ShowerBasisPtr newBasis;
	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.boost( -boost);
	}
	}
	newBasis = new_ptr(ShowerBasis());
	newBasis->setBasis(p,n,ShowerBasis::BackToBack);
	+ showerBasis(newBasis,false);
	}
	else if(initiatesTLS()) {
	- newBasis = dynamic_ptr_cast<ShowerParticlePtr>(parents()[0]->children()[0])->showerBasis();
	+ showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0]->children()[0])->showerBasis(),true);
	}
	else {
	- newBasis = dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis();
	+ showerBasis(dynamic_ptr_cast<ShowerParticlePtr>(parents()[0])->showerBasis(),true);
	}
	- assert(newBasis);
	- showerBasis(newBasis);
	}

	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/Shower/Base/ShowerParticle.h b/Shower/Base/ShowerParticle.h
	--- a/Shower/Base/ShowerParticle.h
	+++ b/Shower/Base/ShowerParticle.h
	@@ -1,529 +1,536 @@
	// -- C++ --
	//
	// ShowerParticle.h is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 of the GPL, see COPYING for details.
	// Please respect the MCnet academic guidelines, see GUIDELINES for details.
	//
	#ifndef HERWIG_ShowerParticle_H
	#define HERWIG_ShowerParticle_H
	//
	// This is the declaration of the ShowerParticle class.
	//

	#include "ThePEG/EventRecord/Particle.h"
	#include "Herwig/Shower/SplittingFunctions/SplittingFunction.fh"
	#include "Herwig/Shower/ShowerConfig.h"
	#include "ShowerBasis.h"
	#include "ShowerKinematics.h"
	#include "ShowerParticle.fh"
	#include <iosfwd>

	namespace Herwig {

	using namespace ThePEG;

	/** \ingroup Shower
	* This class represents a particle in the showering process.
	* It inherits from the Particle class of ThePEG and has some
	* specifics information useful only during the showering process.
	*
	* Notice that:
	* - for forward evolution, it is clear what is meant by parent/child;
	* for backward evolution, however, it depends whether we want
	* to keep a physical picture or a Monte-Carlo effective one.
	* In the former case, an incoming particle (emitting particle)
	* splits into an emitted particle and the emitting particle after
	* the emission: the latter two are then children of the
	* emitting particle, the parent. In the Monte-Carlo effective
	* picture, we have that the particle close to the hard subprocess,
	* with higher (space-like) virtuality, splits into an emitted particle
	* and the emitting particle at lower virtuality: the latter two are,
	* in this case, the children of the first one, the parent. However we
	* choose a more physical picture where the new emitting particle is the
	* parented of the emitted final-state particle and the original emitting
	* particle.
	* - the pointer to a SplitFun object is set only in the case
	* that the particle has undergone a shower emission. This is similar to
	* the case of the decay of a normal Particle where
	* the pointer to a Decayer object is set only in the case
	* that the particle has undergone to a decay.
	* In the case of particle connected directly to the hard subprocess,
	* there is no pointer to the hard subprocess, but there is a method
	* isFromHardSubprocess() which returns true only in this case.
	*
	* @see Particle
	* @see ShowerConfig
	* @see ShowerKinematics
	*/
	class ShowerParticle: public Particle {

	public:

	/**
	* Struct for all the info on an evolution partner
	*/
	struct EvolutionPartner {

	/**
	* Constructor
	*/
	EvolutionPartner(tShowerParticlePtr p,double w, ShowerPartnerType::Type t,
	Energy s) : partner(p), weight(w), type(t), scale(s)
	{}

	/**
	* The partner
	*/
	tShowerParticlePtr partner;

	/**
	* Weight
	*/
	double weight;

	/**
	* Type
	*/
	ShowerPartnerType::Type type;

	/**
	* The assoicated evolution scale
	*/
	Energy scale;
	};

	/**
	* Struct to store the evolution scales
	*/
	struct EvolutionScales {

	/**
	* Constructor
	*/
	EvolutionScales() : QED(),QCD_c(),QCD_ac(),
	QED_noAO(),QCD_c_noAO(),QCD_ac_noAO(),EW(),
	Max_Q2(Constants::MaxEnergy2)
	{}

	/**
	* QED scale
	*/
	Energy QED;

	/**
	* QCD colour scale
	*/
	Energy QCD_c;

	/**
	* QCD anticolour scale
	*/
	Energy QCD_ac;

	/**
	* QED scale
	*/
	Energy QED_noAO;

	/**
	* QCD colour scale
	*/
	Energy QCD_c_noAO;

	/**
	* QCD anticolour scale
	*/
	Energy QCD_ac_noAO;

	/**
	* EW scale
	*/
	Energy EW;

	/**
	* Maximum allowed virtuality of the particle
	*/
	Energy2 Max_Q2;
	};


	/** @name Construction and descruction functions. */
	//@{

	/**
	* Standard Constructor. Note that the default constructor is
	* private - there is no particle without a pointer to a
	* ParticleData object.
	* @param x the ParticleData object
	* @param fs Whether or not the particle is an inital or final-state particle
	* @param tls Whether or not the particle initiates a time-like shower
	*/
	ShowerParticle(tcEventPDPtr x, bool fs, bool tls=false)
	: Particle(x), _isFinalState(fs),
	_perturbative(0), _initiatesTLS(tls), _x(1.0), _showerKinematics(),
	_vMass(ZERO), _thePEGBase() {}

	/**
	* Copy constructor from a ThePEG Particle
	* @param x ThePEG particle
	* @param pert Where the particle came from
	* @param fs Whether or not the particle is an inital or final-state particle
	* @param tls Whether or not the particle initiates a time-like shower
	*/
	ShowerParticle(const Particle & x, unsigned int pert, bool fs, bool tls=false)
	: Particle(x), _isFinalState(fs),
	_perturbative(pert), _initiatesTLS(tls), _x(1.0), _showerKinematics(),
	_vMass(ZERO), _thePEGBase(&x) {}
	//@}

	public:

	/**
	* Set a preliminary momentum for the particle
	*/
	void setShowerMomentum(bool timelike);

	/**
	* Construct the spin info object for a shower particle
	*/
	void constructSpinInfo(bool timelike);

	/**
	* Perform any initial calculations needed after the branching has been selected
	*/
	void initializeDecay();

	/**
	* Perform any initial calculations needed after the branching has been selected
	* @param parent The beam particle
	*/
	void initializeInitialState(PPtr parent);

	/**
	* Perform any initial calculations needed after the branching has been selected
	*/
	void initializeFinalState();

	/**
	* Access/Set various flags about the state of the particle
	*/
	//@{
	/**
	* Access the flag that tells if the particle is final state
	* or initial state.
	*/
	bool isFinalState() const { return _isFinalState; }

	/**
	* Access the flag that tells if the particle is initiating a
	* time like shower when it has been emitted in an initial state shower.
	*/
	bool initiatesTLS() const { return _initiatesTLS; }

	/**
	* Access the flag which tells us where the particle came from
	* This is 0 for a particle produced in the shower, 1 if the particle came
	* from the hard sub-process and 2 is it came from a decay.
	*/
	unsigned int perturbative() const { return _perturbative; }
	//@}

	/**
	* Set/Get the momentum fraction for initial-state particles
	*/
	//@{
	/**
	* For an initial state particle get the fraction of the beam momentum
	*/
	void x(double x) { _x = x; }

	/**
	* For an initial state particle set the fraction of the beam momentum
	*/
	double x() const { return _x; }
	//@}

	/**
	* Set/Get methods for the ShowerKinematics objects
	*/
	//@{
	/**
	* Access/ the ShowerKinematics object.
	*/
	const ShoKinPtr & showerKinematics() const { return _showerKinematics; }


	/**
	* Set the ShowerKinematics object.
	*/
	void showerKinematics(const ShoKinPtr in) { _showerKinematics = in; }
	//@}

	/**
	* Set/Get methods for the ShowerBasis objects
	*/
	//@{
	/**
	* Access/ the ShowerBasis object.
	*/
	const ShowerBasisPtr & showerBasis() const { return _showerBasis; }


	/**
	* Set the ShowerBasis object.
	*/
	- void showerBasis(const ShowerBasisPtr in) { _showerBasis = in; }
	+ void showerBasis(const ShowerBasisPtr in, bool copy) {
	+ if(!copy)
	+ _showerBasis = in;
	+ else {
	+ _showerBasis = new_ptr(ShowerBasis());
	+ _showerBasis->setBasis(in->pVector(),in->nVector(),in->frame());
	+ }
	+ }
	//@}

	/**
	* Members relating to the initial evolution scale and partner for the particle
	*/
	//@{
	/**
	* Veto emission at a given scale
	*/
	void vetoEmission(ShowerPartnerType::Type type, Energy scale);

	/**
	* Access to the evolution scales
	*/
	const EvolutionScales & scales() const {return scales_;}

	/**
	* Access to the evolution scales
	*/
	EvolutionScales & scales() {return scales_;}

	/**
	* Return the virtual mass\f$
	*/
	Energy virtualMass() const { return _vMass; }

	/**
	* Set the virtual mass
	*/
	void virtualMass(Energy mass) { _vMass = mass; }

	/**
	* Return the partner
	*/
	tShowerParticlePtr partner() const { return _partner; }

	/**
	* Set the partner
	*/
	void partner(const tShowerParticlePtr partner) { _partner = partner; }

	/**
	* Get the possible partners
	*/
	vector<EvolutionPartner> & partners() { return partners_; }

	/**
	* Add a possible partners
	*/
	void addPartner(EvolutionPartner in );

	/**
	* Clear the evolution partners
	*/
	void clearPartners() { partners_.clear(); }

	/**
	* Return the progenitor of the shower
	*/
	tShowerParticlePtr progenitor() const { return _progenitor; }

	/**
	* Set the progenitor of the shower
	*/
	void progenitor(const tShowerParticlePtr progenitor) { _progenitor = progenitor; }
	//@}


	/**
	* Members to store and provide access to variables for a specific
	* shower evolution scheme
	*/
	//@{
	struct Parameters {
	Parameters() : alpha(1.), beta(), ptx(), pty(), pt() {}
	double alpha;
	double beta;
	Energy ptx;
	Energy pty;
	Energy pt;
	};


	/**
	* Set the vector containing dimensionless variables
	*/
	Parameters & showerParameters() { return _parameters; }
	//@}

	/**
	* If this particle came from the hard process get a pointer to ThePEG particle
	* it came from
	*/
	const tcPPtr thePEGBase() const { return _thePEGBase; }

	public:

	/**
	* Extract the rho matrix including mapping needed in the shower
	*/
	RhoDMatrix extractRhoMatrix(bool forward);

	protected:

	/**
	* For a particle which came from the hard process get the spin density and
	* the mapping required to the basis used in the Shower
	* @param rho The \f$\rho\f$ matrix
	* @param mapping The mapping
	* @param showerkin The ShowerKinematics object
	*/
	bool getMapping(SpinPtr &, RhoDMatrix & map);


	protected:

	/**
	* Standard clone function.
	*/
	virtual PPtr clone() const;

	/**
	* Standard clone function.
	*/
	virtual PPtr fullclone() const;

	private:

	/**
	* The static object used to initialize the description of this class.
	* Indicates that this is a concrete class with persistent data.
	*/
	static ClassDescription<ShowerParticle> initShowerParticle;

	/**
	* The assignment operator is private and must never be called.
	* In fact, it should not even be implemented.
	*/
	ShowerParticle & operator=(const ShowerParticle &);

	private:

	/**
	* Whether the particle is in the final or initial state
	*/
	bool _isFinalState;

	/**
	* Whether the particle came from
	*/
	unsigned int _perturbative;

	/**
	* Does a particle produced in the backward shower initiate a time-like shower
	*/
	bool _initiatesTLS;

	/**
	* Dimensionless parameters
	*/
	Parameters _parameters;

	/**
	* The beam energy fraction for particle's in the initial state
	*/
	double _x;

	/**
	* The shower kinematics for the particle
	*/
	ShoKinPtr _showerKinematics;

	/**
	* The shower basis for the particle
	*/
	ShowerBasisPtr _showerBasis;

	/**
	* Storage of the evolution scales
	*/
	EvolutionScales scales_;

	/**
	* Virtual mass
	*/
	Energy _vMass;

	/**
	* Partners
	*/
	tShowerParticlePtr _partner;

	/**
	* Pointer to ThePEG Particle this ShowerParticle was created from
	*/
	const tcPPtr _thePEGBase;

	/**
	* Progenitor
	*/
	tShowerParticlePtr _progenitor;

	/**
	* Partners
	*/
	vector<EvolutionPartner> partners_;

	};

	inline ostream & operator<<(ostream & os, const ShowerParticle::EvolutionScales & es) {
	os << "Scales: QED=" << es.QED / GeV
	<< " QCD_c=" << es.QCD_c / GeV
	<< " QCD_ac=" << es.QCD_ac / GeV
	<< " QED_noAO=" << es.QED_noAO / GeV
	<< " QCD_c_noAO=" << es.QCD_c_noAO / GeV
	<< " QCD_ac_noAO=" << es.QCD_ac_noAO / GeV
	<< '\n';
	return os;
	}

	}

	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/** This template specialization informs ThePEG about the
	* base classes of ShowerParticle. */
	template <>
	struct BaseClassTrait<Herwig::ShowerParticle,1> {
	/** Typedef of the first base class of ShowerParticle. */
	typedef Particle NthBase;
	};

	/** This template specialization informs ThePEG about the name of
	* the ShowerParticle class and the shared object where it is defined. */
	template <>
	struct ClassTraits<Herwig::ShowerParticle>
	: public ClassTraitsBase<Herwig::ShowerParticle> {
	/** Return a platform-independent class name */
	static string className() { return "Herwig::ShowerParticle"; }
	/** Create a Event object. */
	static TPtr create() { return TPtr::Create(Herwig::ShowerParticle(tcEventPDPtr(),true)); }
	};

	/** @endcond */

	}

	#endif /* HERWIG_ShowerParticle_H */
	diff --git a/Shower/Default/Decay_QTildeShowerKinematics1to2.cc b/Shower/Default/Decay_QTildeShowerKinematics1to2.cc
	--- a/Shower/Default/Decay_QTildeShowerKinematics1to2.cc
	+++ b/Shower/Default/Decay_QTildeShowerKinematics1to2.cc
	@@ -1,117 +1,117 @@
	// -- C++ --
	//
	// Decay_QTildeShowerKinematics1to2.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 Decay_QTildeShowerKinematics1to2 class.
	//

	#include "Decay_QTildeShowerKinematics1to2.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "Herwig/Shower/SplittingFunctions/SplittingFunction.h"
	#include "Herwig/Shower/Base/ShowerParticle.h"
	#include <cassert>
	#include "Herwig/Shower/ShowerHandler.h"
	#include "Herwig/Shower/Base/Evolver.h"
	#include "Herwig/Shower/Base/PartnerFinder.h"
	#include "Herwig/Shower/Base/ShowerModel.h"
	#include "Herwig/Shower/Base/KinematicsReconstructor.h"
	#include "Herwig/Shower/Base/ShowerVertex.h"

	using namespace Herwig;

	void Decay_QTildeShowerKinematics1to2::
	updateChildren(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type partnerType,
	bool massVeto) const {
	assert(children.size() == 2);
	// calculate the scales
	splittingFn()->evaluateDecayScales(partnerType,scale(),z(),parent,
	children[0],children[1]);
	// set the maximum virtual masses
	vector<long> ids(3);
	ids[0] = parent->id();
	ids[1] = children[0]->id();
	ids[2] = children[1]->id();
	const vector<Energy> & virtualMasses = SudakovFormFactor()->virtualMasses(ids);
	Energy2 q2 = sqr(virtualMasses[0])-(1.-z())*sqr(scale());
	children[0]->virtualMass(sqrt(q2));
	if(massVeto) {
	children[1]->scales().Max_Q2 = (1.-z())/z()(z()sqr(virtualMasses[0])-q2);
	}
	// determine alphas of children according to interpretation of z
	const ShowerParticle::Parameters & params = parent->showerParameters();
	ShowerParticle::Parameters & child0 = children[0]->showerParameters();
	ShowerParticle::Parameters & child1 = children[1]->showerParameters();
	child0.alpha = z() * params.alpha;
	child1.alpha = (1.-z()) * params.alpha;

	child0.ptx = pT() * cos(phi()) + z()* params.ptx;
	child0.pty = pT() * sin(phi()) + z()* params.pty;
	child0.pt = sqrt( sqr(child0.ptx) + sqr(child0.pty) );

	child1.ptx = -pT() * cos(phi()) + (1.-z()) * params.ptx;
	child1.pty = -pT() * sin(phi()) + (1.-z()) * params.pty;
	child1.pt = sqrt( sqr(child1.ptx) + sqr(child1.pty) );

	// set up the colour connections
	splittingFn()->colourConnection(parent,children[0],children[1],partnerType,false);
	// make the products children of the parent
	parent->addChild(children[0]);
	parent->addChild(children[1]);
	// set the momenta of the children
	for(ShowerParticleVector::const_iterator pit=children.begin();
	pit!=children.end();++pit) {
	- (**pit).showerBasis(parent->showerBasis());
	+ (**pit).showerBasis(parent->showerBasis(),true);
	(**pit).setShowerMomentum(true);
	}
	}

	void Decay_QTildeShowerKinematics1to2::
	reconstructParent( const tShowerParticlePtr, const ParticleVector &) const {
	throw Exception() << "Decay_QTildeShowerKinematics1to2::reconstructParent not implemented"
	<< Exception::abortnow;
	}

	void Decay_QTildeShowerKinematics1to2::
	reconstructLast(const tShowerParticlePtr last, Energy mass) const {
	// set beta component and consequently all missing data from that,
	// using the nominal (i.e. PDT) mass.
	Energy theMass = mass > ZERO ? mass : last->data().constituentMass();
	last->showerParameters().beta=
	(sqr(theMass) + sqr(last->showerParameters().pt)
	- sqr( last->showerParameters().alpha )*last->showerBasis()->pVector().m2())
	/ ( 2.last->showerParameters().alphalast->showerBasis()->p_dot_n() );
	// set that new momentum
	last->set5Momentum( last->showerBasis()->sudakov2Momentum( last->showerParameters().alpha,
	last->showerParameters().beta,
	last->showerParameters().ptx,
	last->showerParameters().pty) );
	}

	void Decay_QTildeShowerKinematics1to2::updateParent(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type) const {
	IdList ids(3);
	ids[0] = parent->id();
	ids[1] = children[0]->id();
	ids[2] = children[1]->id();
	const vector<Energy> & virtualMasses = SudakovFormFactor()->virtualMasses(ids);
	children[0]->virtualMass(sqrt(sqr(virtualMasses[0])-(1.-z())*sqr(scale())));
	if(children[1]->children().empty()) children[1]->virtualMass(virtualMasses[2]);
	// compute the new pT of the branching
	Energy2 pt2=(1.-z())(z()sqr(virtualMasses[0])-sqr(children[0]->virtualMass()))
	-z()*sqr(children[1]->virtualMass());
	if(pt2>ZERO) {
	pT(sqrt(pt2));
	}
	else {
	parent->virtualMass(ZERO);
	}
	}
	diff --git a/Shower/Default/FS_QTildeShowerKinematics1to2.cc b/Shower/Default/FS_QTildeShowerKinematics1to2.cc
	--- a/Shower/Default/FS_QTildeShowerKinematics1to2.cc
	+++ b/Shower/Default/FS_QTildeShowerKinematics1to2.cc
	@@ -1,200 +1,200 @@
	// -- C++ --
	//
	// FS_QTildeShowerKinematics1to2.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 FS_QTildeShowerKinematics1to2 class.
	//

	#include "FS_QTildeShowerKinematics1to2.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "Herwig/Shower/SplittingFunctions/SplittingFunction.h"
	#include "Herwig/Shower/Base/ShowerParticle.h"
	#include "ThePEG/Utilities/Debug.h"
	#include "Herwig/Shower/ShowerHandler.h"
	#include "Herwig/Shower/Base/Evolver.h"
	#include "Herwig/Shower/Base/PartnerFinder.h"
	#include "Herwig/Shower/Base/ShowerModel.h"
	#include "Herwig/Shower/Base/KinematicsReconstructor.h"
	#include "Herwig/Shower/Base/ShowerVertex.h"

	using namespace Herwig;

	void FS_QTildeShowerKinematics1to2::
	updateParameters(tShowerParticlePtr theParent,
	tShowerParticlePtr theChild0,
	tShowerParticlePtr theChild1,
	bool setAlpha) const {
	const ShowerParticle::Parameters & parent = theParent->showerParameters();
	ShowerParticle::Parameters & child0 = theChild0->showerParameters();
	ShowerParticle::Parameters & child1 = theChild1->showerParameters();
	// determine alphas of children according to interpretation of z
	if ( setAlpha ) {
	child0.alpha = z() * parent.alpha;
	child1.alpha = (1.-z()) * parent.alpha;
	}
	// set the values
	double cphi = cos(phi());
	double sphi = sin(phi());

	child0.ptx = pT() * cphi + z() * parent.ptx;
	child0.pty = pT() * sphi + z() * parent.pty;
	child0.pt = sqrt( sqr(child0.ptx) + sqr(child0.pty) );

	child1.ptx = -pT() * cphi + (1.-z())* parent.ptx;
	child1.pty = -pT() * sphi + (1.-z())* parent.pty;
	child1.pt = sqrt( sqr(child1.ptx) + sqr(child1.pty) );

	}

	void FS_QTildeShowerKinematics1to2::
	updateChildren(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type partnerType,
	bool massVeto) const {
	assert(children.size()==2);
	// calculate the scales
	splittingFn()->evaluateFinalStateScales(partnerType,scale(),z(),parent,
	children[0],children[1]);
	// set the maximum virtual masses
	if(massVeto) {
	Energy2 q2 = z()(1.-z())sqr(scale());
	vector<long> ids(3);
	ids[0] = parent->id();
	ids[1] = children[0]->id();
	ids[2] = children[1]->id();
	const vector<Energy> & virtualMasses = SudakovFormFactor()->virtualMasses(ids);
	if(ids[0]!=ParticleID::g && ids[0]!=ParticleID::gamma ) {
	q2 += sqr(virtualMasses[0]);
	}
	// limits on further evolution
	children[0]->scales().Max_Q2 = z() *(q2-sqr(virtualMasses[2])/(1.-z()));
	children[1]->scales().Max_Q2 = (1.-z())*(q2-sqr(virtualMasses[1])/ z() );
	}
	// update the parameters
	updateParameters(parent, children[0], children[1], true);
	// set up the colour connections
	splittingFn()->colourConnection(parent,children[0],children[1],partnerType,false);
	// make the products children of the parent
	parent->addChild(children[0]);
	parent->addChild(children[1]);
	// set the momenta of the children
	for(ShowerParticleVector::const_iterator pit=children.begin();
	pit!=children.end();++pit) {
	- (**pit).showerBasis(parent->showerBasis());
	+ (**pit).showerBasis(parent->showerBasis(),true);
	(**pit).setShowerMomentum(true);
	}
	// sort out the helicity stuff
	if(! ShowerHandler::currentHandler()->evolver()->correlations()) return;
	SpinPtr pspin(parent->spinInfo());
	if(!pspin \|\| !ShowerHandler::currentHandler()->evolver()->spinCorrelations() ) return;
	Energy2 t = sqr(scale())z()(1.-z());
	IdList ids;
	ids.push_back(parent->id());
	ids.push_back(children[0]->id());
	ids.push_back(children[1]->id());
	// create the vertex
	SVertexPtr vertex(new_ptr(ShowerVertex()));
	// set the matrix element
	vertex->ME(splittingFn()->matrixElement(z(),t,ids,phi(),true));
	// set the incoming particle for the vertex
	parent->spinInfo()->decayVertex(vertex);
	for(ShowerParticleVector::const_iterator pit=children.begin();
	pit!=children.end();++pit) {
	// construct the spin info for the children
	(**pit).constructSpinInfo(true);
	// connect the spinInfo object to the vertex
	(*pit)->spinInfo()->productionVertex(vertex);
	}
	}

	void FS_QTildeShowerKinematics1to2::
	reconstructParent(const tShowerParticlePtr parent,
	const ParticleVector & children ) const {
	assert(children.size() == 2);
	ShowerParticlePtr c1 = dynamic_ptr_cast<ShowerParticlePtr>(children[0]);
	ShowerParticlePtr c2 = dynamic_ptr_cast<ShowerParticlePtr>(children[1]);
	parent->showerParameters().beta=
	c1->showerParameters().beta + c2->showerParameters().beta;
	Lorentz5Momentum pnew = c1->momentum() + c2->momentum();
	Energy2 m2 = sqr(pT())/z()/(1.-z()) + sqr(c1->mass())/z()
	+ sqr(c2->mass())/(1.-z());
	pnew.setMass(sqrt(m2));
	parent->set5Momentum( pnew );
	}

	void FS_QTildeShowerKinematics1to2::reconstructLast(const tShowerParticlePtr last,
	Energy mass) const {
	// set beta component and consequently all missing data from that,
	// using the nominal (i.e. PDT) mass.
	Energy theMass = mass > ZERO ? mass : last->data().constituentMass();
	Lorentz5Momentum pVector = last->showerBasis()->pVector();
	ShowerParticle::Parameters & lastParam = last->showerParameters();
	Energy2 denom = 2. * lastParam.alpha * last->showerBasis()->p_dot_n();
	if(abs(denom)/(sqr(pVector.e())+pVector.rho2())<1e-10) {
	throw KinematicsReconstructionVeto();
	}
	lastParam.beta = ( sqr(theMass) + sqr(lastParam.pt)
	- sqr(lastParam.alpha) * pVector.m2() )
	/ denom;
	// set that new momentum
	Lorentz5Momentum newMomentum = last->showerBasis()->
	sudakov2Momentum( lastParam.alpha, lastParam.beta,
	lastParam.ptx , lastParam.pty);
	newMomentum.setMass(theMass);
	newMomentum.rescaleEnergy();
	if(last->data().stable()) {
	last->set5Momentum( newMomentum );
	}
	else {
	last->boost(last->momentum().findBoostToCM());
	last->boost(newMomentum.boostVector());
	}
	}

	void FS_QTildeShowerKinematics1to2::updateParent(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type) const {
	IdList ids(3);
	ids[0] = parent->id();
	ids[1] = children[0]->id();
	ids[2] = children[1]->id();
	const vector<Energy> & virtualMasses = SudakovFormFactor()->virtualMasses(ids);
	if(children[0]->children().empty()) children[0]->virtualMass(virtualMasses[1]);
	if(children[1]->children().empty()) children[1]->virtualMass(virtualMasses[2]);
	// compute the new pT of the branching
	Energy2 pt2=sqr(z()(1.-z()))sqr(scale())
	- sqr(children[0]->virtualMass())*(1.-z())
	- sqr(children[1]->virtualMass())* z() ;
	if(ids[0]!=ParticleID::g) pt2 += z()(1.-z())sqr(virtualMasses[0]);
	if(pt2>ZERO) {
	Energy2 q2 =
	sqr(children[0]->virtualMass())/z() +
	sqr(children[1]->virtualMass())/(1.-z()) +
	pt2/z()/(1.-z());
	parent->virtualMass(sqrt(q2));
	pT(sqrt(pt2));
	}
	else {
	parent->virtualMass(ZERO);
	}
	}

	void FS_QTildeShowerKinematics1to2::
	resetChildren(const tShowerParticlePtr parent,
	const ShowerParticleVector & children) const {
	updateParameters(parent, children[0], children[1], false);
	for(unsigned int ix=0;ix<children.size();++ix) {
	if(children[ix]->children().empty()) continue;
	ShowerParticleVector newChildren;
	for(unsigned int iy=0;iy<children[ix]->children().size();++iy)
	newChildren.push_back(dynamic_ptr_cast<ShowerParticlePtr>
	(children[ix]->children()[iy]));
	children[ix]->showerKinematics()->resetChildren(children[ix],newChildren);
	}
	}
	diff --git a/Shower/Default/IS_QTildeShowerKinematics1to2.cc b/Shower/Default/IS_QTildeShowerKinematics1to2.cc
	--- a/Shower/Default/IS_QTildeShowerKinematics1to2.cc
	+++ b/Shower/Default/IS_QTildeShowerKinematics1to2.cc
	@@ -1,147 +1,147 @@
	// -- C++ --
	//
	// IS_QTildeShowerKinematics1to2.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 IS_QTildeShowerKinematics1to2 class.
	//

	#include "IS_QTildeShowerKinematics1to2.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "Herwig/Shower/Base/ShowerParticle.h"
	#include "ThePEG/Utilities/Debug.h"
	#include "Herwig/Shower/ShowerHandler.h"
	#include "Herwig/Shower/Base/Evolver.h"
	#include "Herwig/Shower/Base/PartnerFinder.h"
	#include "Herwig/Shower/Base/ShowerModel.h"
	#include "Herwig/Shower/Base/KinematicsReconstructor.h"
	#include "Herwig/Shower/Base/ShowerVertex.h"
	#include <cassert>

	using namespace Herwig;

	void IS_QTildeShowerKinematics1to2::
	updateChildren( const tShowerParticlePtr theParent,
	const ShowerParticleVector & theChildren,
	ShowerPartnerType::Type,
	bool) const {
	const ShowerParticle::Parameters & parent = theParent->showerParameters();
	ShowerParticle::Parameters & child0 = theChildren[0]->showerParameters();
	ShowerParticle::Parameters & child1 = theChildren[1]->showerParameters();
	double cphi = cos(phi());
	double sphi = sin(phi());

	child1.alpha = (1.-z()) * parent.alpha;

	child1.ptx = (1.-z()) * parent.ptx - cphi * pT();
	child1.pty = (1.-z()) * parent.pty - sphi * pT();
	child1.pt = sqrt( sqr(child1.ptx) + sqr(child1.pty) );
	// space-like child
	child0.alpha = parent.alpha - child1.alpha;
	child0.beta = parent.beta - child1.beta;
	child0.ptx = parent.ptx - child1.ptx;
	child0.pty = parent.pty - child1.pty;
	}


	void IS_QTildeShowerKinematics1to2::
	updateParent(const tShowerParticlePtr parent,
	const ShowerParticleVector & children,
	ShowerPartnerType::Type partnerType) const {
	// calculate the scales
	splittingFn()->evaluateInitialStateScales(partnerType,scale(),z(),parent,
	children[0],children[1]);
	// set proper colour connections
	splittingFn()->colourConnection(parent,children[0],children[1],
	partnerType,true);
	// set proper parent/child relationships
	parent->addChild(children[0]);
	parent->addChild(children[1]);
	parent->x(children[0]->x()/z());
	// sort out the helicity stuff
	// construct the spin info for parent and timelike child
	// temporary assignment of shower parameters to calculate correlations
	parent->showerParameters().alpha = parent->x();
	children[1]->showerParameters().alpha = (1.-z()) * parent->x();
	children[1]->showerParameters().ptx = - cos(phi()) * pT();
	children[1]->showerParameters().pty = - sin(phi()) * pT();
	children[1]->showerParameters().pt = pT();
	- parent ->showerBasis(children[0]->showerBasis());
	- children[1]->showerBasis(children[0]->showerBasis());
	+ parent ->showerBasis(children[0]->showerBasis(),true);
	+ children[1]->showerBasis(children[0]->showerBasis(),true);
	parent ->setShowerMomentum(false);
	children[1]->setShowerMomentum(true);
	if(! ShowerHandler::currentHandler()->evolver()->correlations()) return;
	SpinPtr pspin(children[0]->spinInfo());
	if(!pspin \|\| !ShowerHandler::currentHandler()->evolver()->spinCorrelations() ) return;
	// compute the matrix element for spin correlations
	IdList ids;
	ids.push_back(parent->id());
	ids.push_back(children[0]->id());
	ids.push_back(children[1]->id());
	Energy2 t = (1.-z())*sqr(scale())/z();
	// create the vertex
	SVertexPtr vertex(new_ptr(ShowerVertex()));
	// set the matrix element
	vertex->ME(splittingFn()->matrixElement(z(),t,ids,phi(),false));
	// set the incoming particle for the vertex
	// (in reality the first child as going backwards)
	pspin->decayVertex(vertex);
	// construct the spin infos
	parent ->constructSpinInfo(false);
	children[1]->constructSpinInfo(true);
	// connect the spinInfo objects to the vertex
	parent ->spinInfo()->productionVertex(vertex);
	children[1]->spinInfo()->productionVertex(vertex);
	}

	void IS_QTildeShowerKinematics1to2::
	reconstructParent(const tShowerParticlePtr parent,
	const ParticleVector & children ) const {
	PPtr c1 = children[0];
	ShowerParticlePtr c2 = dynamic_ptr_cast<ShowerParticlePtr>(children[1]);
	ShowerParticle::Parameters & c2param = c2->showerParameters();
	// get shower variables from 1st child in order to keep notation
	// parent->(c1, c2) clean even though the splitting was initiated
	// from c1. The name updateParent is still referring to the
	// timelike branching though.
	// on-shell child
	c2param.beta = 0.5*( sqr(c2->data().constituentMass()) + sqr(c2param.pt) )
	/ ( c2param.alpha * parent->showerBasis()->p_dot_n() );
	Lorentz5Momentum pnew = parent->showerBasis()->
	sudakov2Momentum(c2param.alpha, c2param.beta,
	c2param.ptx , c2param.pty);
	pnew.setMass(c2->data().constituentMass());
	pnew.rescaleEnergy();
	c2->set5Momentum( pnew );
	// spacelike child
	Lorentz5Momentum pc1(parent->momentum() - c2->momentum());
	pc1.rescaleMass();
	c1->set5Momentum(pc1);
	}

	void IS_QTildeShowerKinematics1to2::
	updateLast( const tShowerParticlePtr theLast,Energy px,Energy py) const {
	if(theLast->isFinalState()) return;
	Lorentz5Momentum pVector = theLast->showerBasis()->pVector();
	ShowerParticle::Parameters & last = theLast->showerParameters();
	Energy2 pt2 = sqr(px) + sqr(py);
	last.alpha = theLast->x();
	last.beta = 0.5 * pt2 / last.alpha / theLast->showerBasis()->p_dot_n();
	last.ptx = ZERO;
	last.pty = ZERO;
	last.pt = ZERO;
	// momentum
	Lorentz5Momentum ntemp = Lorentz5Momentum(ZERO,-pVector.vect());
	double beta = 0.5 * pt2 / last.alpha / ( pVector * ntemp);
	Lorentz5Momentum plast =
	Lorentz5Momentum( (pVector.z()>ZERO ? px : -px), py, ZERO, ZERO)
	+ theLast->x() * pVector + beta * ntemp;
	plast.rescaleMass();
	theLast->set5Momentum(plast);
	}
	diff --git a/Shower/Default/QTildeReconstructor.cc b/Shower/Default/QTildeReconstructor.cc
	--- a/Shower/Default/QTildeReconstructor.cc
	+++ b/Shower/Default/QTildeReconstructor.cc
	@@ -1,2938 +1,2938 @@
	// -- C++ --
	//
	// QTildeReconstructor.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2011 The Herwig Collaboration
	//
	// Herwig is licenced under version 2 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 QTildeReconstructor class.
	//

	#include "QTildeReconstructor.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/EventRecord/Event.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/RefVector.h"
	#include "Herwig/Shower/Base/Evolver.h"
	#include "Herwig/Shower/Base/PartnerFinder.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "Herwig/Shower/SplittingFunctions/SplittingFunction.h"
	#include "ThePEG/Repository/UseRandom.h"
	#include "ThePEG/EventRecord/ColourLine.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include <cassert>

	using namespace Herwig;

	DescribeClass<QTildeReconstructor,KinematicsReconstructor>
	describeQTildeReconstructor("Herwig::QTildeReconstructor", "HwShower.so");

	namespace {

	/**
	* Struct to order the jets in off-shellness
	*/
	struct JetOrdering {

	bool operator() (const JetKinStruct & j1, const JetKinStruct & j2) {
	Energy diff1 = j1.q.m()-j1.p.m();
	Energy diff2 = j2.q.m()-j2.p.m();
	if(diff1!=diff2) {
	return diff1>diff2;
	}
	else if( j1.q.e() != j2.q.e() )
	return j1.q.e()>j2.q.e();
	else
	return j1.parent->uniqueId>j2.parent->uniqueId;
	}
	};

	}

	void QTildeReconstructor::persistentOutput(PersistentOStream & os) const {
	os << _reconopt << _initialBoost << ounit(_minQ,GeV) << _noRescale
	<< _noRescaleVector << _finalStateReconOption
	<< _initialStateReconOption;
	}

	void QTildeReconstructor::persistentInput(PersistentIStream & is, int) {
	is >> _reconopt >> _initialBoost >> iunit(_minQ,GeV) >> _noRescale
	>> _noRescaleVector >> _finalStateReconOption
	>> _initialStateReconOption;
	}

	void QTildeReconstructor::Init() {

	static ClassDocumentation<QTildeReconstructor> documentation
	( "This class is responsible for the kinematics reconstruction of the showering,",
	" including the kinematics reshuffling necessary to compensate for the recoil"
	"of the emissions." );

	static Switch<QTildeReconstructor,unsigned int> interfaceReconstructionOption
	("ReconstructionOption",
	"Option for the kinematics reconstruction",
	&QTildeReconstructor::_reconopt, 0, false, false);
	static SwitchOption interfaceReconstructionOptionGeneral
	(interfaceReconstructionOption,
	"General",
	"Use the general solution which ignores the colour structure for all processes",
	0);
	static SwitchOption interfaceReconstructionOptionColour
	(interfaceReconstructionOption,
	"Colour",
	"Use the colour structure of the process to determine the reconstruction procedure.",
	1);
	static SwitchOption interfaceReconstructionOptionColour2
	(interfaceReconstructionOption,
	"Colour2",
	"Make the most use possible of the colour structure of the process to determine the reconstruction procedure. "
	"Start with FF, then IF then II colour connections",
	2);
	static SwitchOption interfaceReconstructionOptionColour3
	(interfaceReconstructionOption,
	"Colour3",
	"Make the most use possible of the colour structure of the process to determine the reconstruction procedure. "
	"Do the colour connections in order of the pT's emitted in the shower starting with the hardest."
	" The colour partner is fully reconstructed at the same time.",
	3);
	static SwitchOption interfaceReconstructionOptionColour4
	(interfaceReconstructionOption,
	"Colour4",
	"Make the most use possible of the colour structure of the process to determine the reconstruction procedure. "
	"Do the colour connections in order of the pT's emitted in the shower starting with the hardest, while leaving"
	" the colour partner on mass-shell",
	4);

	static Parameter<QTildeReconstructor,Energy> interfaceMinimumQ2
	("MinimumQ2",
	"The minimum Q2 for the reconstruction of initial-final systems",
	&QTildeReconstructor::_minQ, GeV, 0.001GeV, 1e-6GeV, 10.0*GeV,
	false, false, Interface::limited);

	static RefVector<QTildeReconstructor,ParticleData> interfaceNoRescale
	("NoRescale",
	"Particles which shouldn't be rescaled to be on shell by the shower",
	&QTildeReconstructor::_noRescaleVector, -1, false, false, true, false, false);

	static Switch<QTildeReconstructor,unsigned int> interfaceInitialInitialBoostOption
	("InitialInitialBoostOption",
	"Option for how the boost from the system before ISR to that after ISR is applied.",
	&QTildeReconstructor::_initialBoost, 0, false, false);
	static SwitchOption interfaceInitialInitialBoostOptionOneBoost
	(interfaceInitialInitialBoostOption,
	"OneBoost",
	"Apply one boost from old CMS to new CMS",
	0);
	static SwitchOption interfaceInitialInitialBoostOptionLongTransBoost
	(interfaceInitialInitialBoostOption,
	"LongTransBoost",
	"First apply a longitudinal and then a transverse boost",
	1);

	static Switch<QTildeReconstructor,unsigned int> interfaceFinalStateReconOption
	("FinalStateReconOption",
	"Option for how to reconstruct the momenta of the final-state system",
	&QTildeReconstructor::_finalStateReconOption, 0, false, false);
	static SwitchOption interfaceFinalStateReconOptionDefault
	(interfaceFinalStateReconOption,
	"Default",
	"All the momenta are rescaled in the rest frame",
	0);
	static SwitchOption interfaceFinalStateReconOptionMostOffShell
	(interfaceFinalStateReconOption,
	"MostOffShell",
	"All particles put on the new-mass shell and then the most off-shell and"
	" recoiling system are rescaled to ensure 4-momentum is conserved.",
	1);
	static SwitchOption interfaceFinalStateReconOptionRecursive
	(interfaceFinalStateReconOption,
	"Recursive",
	"Recursively put on shell by putting the most off-shell particle which"
	" hasn't been rescaled on-shell by rescaling the particles and the recoiling system. ",
	2);
	static SwitchOption interfaceFinalStateReconOptionRestMostOffShell
	(interfaceFinalStateReconOption,
	"RestMostOffShell",
	"The most off-shell is put on shell by rescaling it and the recoiling system,"
	" the recoiling system is then put on-shell in its rest frame.",
	3);
	static SwitchOption interfaceFinalStateReconOptionRestRecursive
	(interfaceFinalStateReconOption,
	"RestRecursive",
	"As 3 but recursive treated the currently most-off shell,"
	" only makes a difference if more than 3 partons.",
	4);

	static Switch<QTildeReconstructor,unsigned int> interfaceInitialStateReconOption
	("InitialStateReconOption",
	"Option for the reconstruction of initial state radiation",
	&QTildeReconstructor::_initialStateReconOption, 0, false, false);
	static SwitchOption interfaceInitialStateReconOptionRapidity
	(interfaceInitialStateReconOption,
	"Rapidity",
	"Preserve shat and rapidity",
	0);
	static SwitchOption interfaceInitialStateReconOptionLongitudinal
	(interfaceInitialStateReconOption,
	"Longitudinal",
	"Preserve longitudinal momentum",
	1);
	static SwitchOption interfaceInitialStateReconOptionSofterFraction
	(interfaceInitialStateReconOption,
	"SofterFraction",
	"Preserve the momentum fraction of the parton which has emitted softer.",
	2);

	}

	void QTildeReconstructor::doinit() {
	KinematicsReconstructor::doinit();
	_noRescale = set<cPDPtr>(_noRescaleVector.begin(),_noRescaleVector.end());
	}

	bool QTildeReconstructor::
	reconstructTimeLikeJet(const tShowerParticlePtr particleJetParent) const {
	assert(particleJetParent);
	bool emitted=true;
	// if this is not a fixed point in the reconstruction
	if( !particleJetParent->children().empty() ) {
	// if not a reconstruction fixpoint, dig deeper for all children:
	for ( ParticleVector::const_iterator cit =
	particleJetParent->children().begin();
	cit != particleJetParent->children().end(); ++cit )
	reconstructTimeLikeJet(dynamic_ptr_cast<ShowerParticlePtr>(*cit));
	}
	// it is a reconstruction fixpoint, ie kinematical data has to be available
	else {
	// check if the parent was part of the shower
	ShowerParticlePtr jetGrandParent;
	if(!particleJetParent->parents().empty())
	jetGrandParent= dynamic_ptr_cast<ShowerParticlePtr>
	(particleJetParent->parents()[0]);
	// update if so
	if (jetGrandParent) {
	if (jetGrandParent->showerKinematics()) {
	if(particleJetParent->id()==_progenitor->id()&&
	!_progenitor->data().stable()) {
	jetGrandParent->showerKinematics()->reconstructLast(particleJetParent,
	_progenitor->mass());
	}
	else {
	jetGrandParent->showerKinematics()->reconstructLast(particleJetParent);
	}
	}
	}
	// otherwise
	else {
	Energy dm = particleJetParent->data().constituentMass();
	if (abs(dm-particleJetParent->momentum().m())>0.001*MeV
	&&particleJetParent->dataPtr()->stable()
	&&particleJetParent->id()!=ParticleID::gamma
	&&_noRescale.find(particleJetParent->dataPtr())==_noRescale.end()) {
	Lorentz5Momentum dum = particleJetParent->momentum();
	dum.setMass(dm);
	dum.rescaleEnergy();
	particleJetParent->set5Momentum(dum);
	}
	else {
	emitted=false;
	}
	}
	}
	// recursion has reached an endpoint once, ie we can reconstruct the
	// kinematics from the children.
	if( !particleJetParent->children().empty() )
	particleJetParent->showerKinematics()
	->reconstructParent( particleJetParent, particleJetParent->children() );
	return emitted;
	}

	bool QTildeReconstructor::
	reconstructHardJets(ShowerTreePtr hard,
	const map<tShowerProgenitorPtr,
	pair<Energy,double> > & intrinsic,
	ShowerInteraction::Type type,
	bool switchRecon) const {
	_currentTree = hard;
	_intrinsic=intrinsic;
	// extract the particles from the ShowerTree
	vector<ShowerProgenitorPtr> ShowerHardJets=hard->extractProgenitors();
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	_boosts[ShowerHardJets[ix]->progenitor()] = vector<LorentzRotation>();
	}
	for(map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> >::const_iterator
	tit = _currentTree->treelinks().begin();
	tit != _currentTree->treelinks().end();++tit) {
	_treeBoosts[tit->first] = vector<LorentzRotation>();
	}
	try {
	// old recon method, using new member functions
	if(_reconopt == 0 \|\| switchRecon ) {
	reconstructGeneralSystem(ShowerHardJets);
	}
	// reconstruction based on coloured systems
	else if( _reconopt == 1) {
	reconstructColourSinglets(ShowerHardJets,type);
	}
	// reconstruction of FF, then IF, then II
	else if( _reconopt == 2) {
	reconstructFinalFirst(ShowerHardJets);
	}
	// reconstruction based on coloured systems
	else if( _reconopt == 3 \|\| _reconopt == 4) {
	reconstructColourPartner(ShowerHardJets);
	}
	else
	assert(false);
	}
	catch(KinematicsReconstructionVeto) {
	_progenitor=tShowerParticlePtr();
	_intrinsic.clear();
	for(map<tPPtr,vector<LorentzRotation> >::const_iterator bit=_boosts.begin();bit!=_boosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot);
	}
	}
	_boosts.clear();
	for(map<tShowerTreePtr,vector<LorentzRotation> >::const_iterator bit=_treeBoosts.begin();bit!=_treeBoosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot,false);
	}
	}
	_currentTree = tShowerTreePtr();
	_treeBoosts.clear();
	return false;
	}
	catch (Exception & ex) {
	_progenitor=tShowerParticlePtr();
	_intrinsic.clear();
	_currentTree = tShowerTreePtr();
	_boosts.clear();
	_treeBoosts.clear();
	throw ex;
	}
	_progenitor=tShowerParticlePtr();
	_intrinsic.clear();
	// ensure x<1
	for(map<ShowerProgenitorPtr,ShowerParticlePtr>::const_iterator
	cit=hard->incomingLines().begin();cit!=hard->incomingLines().end();++cit) {
	tPPtr parent = cit->first->progenitor();
	while (!parent->parents().empty()) {
	parent = parent->parents()[0];
	}
	tPPtr hadron;
	if ( cit->first->original()->parents().empty() ) {
	hadron = cit->first->original();
	}
	else {
	hadron = cit->first->original()->parents()[0];
	}
	if( ! (hadron->id() == parent->id() && hadron->children().size() <= 1)
	&& parent->momentum().rho() > hadron->momentum().rho()) {
	_progenitor=tShowerParticlePtr();
	_intrinsic.clear();
	for(map<tPPtr,vector<LorentzRotation> >::const_iterator bit=_boosts.begin();bit!=_boosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot);
	}
	}
	_boosts.clear();
	for(map<tShowerTreePtr,vector<LorentzRotation> >::const_iterator bit=_treeBoosts.begin();bit!=_treeBoosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot,false);
	}
	}
	_currentTree = tShowerTreePtr();
	_treeBoosts.clear();
	return false;
	}
	}
	_boosts.clear();
	_treeBoosts.clear();
	_currentTree = tShowerTreePtr();
	return true;
	}

	double
	QTildeReconstructor::solveKfactor(const Energy & root_s,
	const JetKinVect & jets) const {
	Energy2 s = sqr(root_s);
	// must be at least two jets
	if ( jets.size() < 2) throw KinematicsReconstructionVeto();
	// sum of jet masses must be less than roots
	if(momConsEq( 0.0, root_s, jets )>ZERO) throw KinematicsReconstructionVeto();
	// if two jets simple solution
	if ( jets.size() == 2 ) {
	static const Energy2 eps = 1.0e-4 * MeV2;
	if ( sqr(jets[0].p.x()+jets[1].p.x()) < eps &&
	sqr(jets[0].p.y()+jets[1].p.y()) < eps &&
	sqr(jets[0].p.z()+jets[1].p.z()) < eps ) {
	Energy test = (jets[0].p+jets[1].p).vect().mag();
	if(test > 1.0e-4 * MeV) throw KinematicsReconstructionVeto();
	if ( jets[0].p.vect().mag2() < eps ) throw KinematicsReconstructionVeto();
	Energy2 m1sq(jets[0].q.m2()),m2sq(jets[1].q.m2());
	return sqrt( ( sqr(s - m1sq - m2sq) - 4.m1sqm2sq )
	/(4.sjets[0].p.vect().mag2()) );
	}
	else throw KinematicsReconstructionVeto();
	}
	// i.e. jets.size() > 2, numerically
	// check convergence, if it's a problem maybe use Newton iteration?
	else {
	double k1 = 0.,k2 = 1.,k = 0.;
	if ( momConsEq( k1, root_s, jets ) < ZERO ) {
	while ( momConsEq( k2, root_s, jets ) < ZERO ) {
	k1 = k2;
	k2 *= 2;
	}
	while ( fabs( (k1 - k2)/(k1 + k2) ) > 1.e-10 ) {
	if( momConsEq( k2, root_s, jets ) == ZERO ) {
	return k2;
	} else {
	k = (k1+k2)/2.;
	if ( momConsEq( k, root_s, jets ) > ZERO ) {
	k2 = k;
	} else {
	k1 = k;
	}
	}
	}
	return k1;
	} else throw KinematicsReconstructionVeto();
	}
	throw KinematicsReconstructionVeto();
	}

	bool QTildeReconstructor::
	reconstructSpaceLikeJet( const tShowerParticlePtr p) const {
	bool emitted = true;
	tShowerParticlePtr child;
	tShowerParticlePtr parent;
	if(!p->parents().empty())
	parent = dynamic_ptr_cast<ShowerParticlePtr>(p->parents()[0]);
	if(parent) {
	emitted=true;
	reconstructSpaceLikeJet(parent);
	}
	// if branching reconstruct time-like child
	if(p->children().size()==2)
	child = dynamic_ptr_cast<ShowerParticlePtr>(p->children()[1]);
	if(p->perturbative()==0 && child) {
	dynamic_ptr_cast<ShowerParticlePtr>(p->children()[0])->
	showerKinematics()->reconstructParent(p,p->children());
	if(!child->children().empty()) {
	_progenitor=child;
	reconstructTimeLikeJet(child);
	// calculate the momentum of the particle
	Lorentz5Momentum pnew=p->momentum()-child->momentum();
	pnew.rescaleMass();
	p->children()[0]->set5Momentum(pnew);
	}
	}
	return emitted;
	}

	Boost QTildeReconstructor::
	solveBoostBeta( const double k, const Lorentz5Momentum & newq,
	const Lorentz5Momentum & oldp ) {
	// try something different, purely numerical first:
	// a) boost to rest frame of newq, b) boost with kp/E
	Energy q = newq.vect().mag();
	Energy2 qs = sqr(q);
	Energy2 Q2 = newq.m2();
	Energy kp = k*(oldp.vect().mag());
	Energy2 kps = sqr(kp);

	// usually we take the minus sign, since this boost will be smaller.
	// we only require \|k \vec p\| = \|\vec q'\| which leaves the sign of
	// the boost open but the 'minus' solution gives a smaller boost
	// parameter, i.e. the result should be closest to the previous
	// result. this is to be changed if we would get many momentum
	// conservation violations at the end of the shower from a hard
	// process.
	double betam = (qsqrt(qs + Q2) - kpsqrt(kps + Q2))/(kps + qs + Q2);
	// move directly to 'return'
	Boost beta = -betam(k/kp)oldp.vect();
	// note that (k/kp)*oldp.vect() = oldp.vect()/oldp.vect().mag() but cheaper.
	// leave this out if it's running properly!
	if ( betam >= 0 ) return beta;
	else return Boost(0., 0., 0.);
	}

	bool QTildeReconstructor::
	reconstructDecayJets(ShowerTreePtr decay,
	ShowerInteraction::Type) const {
	_currentTree = decay;
	// extract the particles from the ShowerTree
	vector<ShowerProgenitorPtr> ShowerHardJets=decay->extractProgenitors();
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	_boosts[ShowerHardJets[ix]->progenitor()] = vector<LorentzRotation>();
	}
	for(map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> >::const_iterator
	tit = _currentTree->treelinks().begin();
	tit != _currentTree->treelinks().end();++tit) {
	_treeBoosts[tit->first] = vector<LorentzRotation>();
	}
	try {
	bool radiated[2]={false,false};
	// find the decaying particle and check if particles radiated
	ShowerProgenitorPtr initial;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	// only consider initial-state jets
	if(ShowerHardJets[ix]->progenitor()->isFinalState()) {
	radiated[1] \|=ShowerHardJets[ix]->hasEmitted();
	}
	else {
	initial=ShowerHardJets[ix];
	radiated[0]\|=ShowerHardJets[ix]->hasEmitted();
	}
	}
	// find boost to the rest frame if needed
	Boost boosttorest=-initial->progenitor()->momentum().boostVector();
	double gammarest =
	initial->progenitor()->momentum().e()/
	initial->progenitor()->momentum().mass();
	// check if need to boost to rest frame
	bool gottaBoost = (boosttorest.mag() > 1e-12);
	// if initial state radiation reconstruct the jet and set up the basis vectors
	Lorentz5Momentum pjet;
	Lorentz5Momentum nvect;
	// find the partner
	ShowerParticlePtr partner = initial->progenitor()->partner();
	Lorentz5Momentum ppartner[2];
	if(partner) ppartner[0]=partner->momentum();
	// get the n reference vector
	if(partner) {
	if(initial->progenitor()->showerKinematics()) {
	nvect = initial->progenitor()->showerBasis()->getBasis()[1];
	}
	else {
	Lorentz5Momentum ppartner=initial->progenitor()->partner()->momentum();
	if(gottaBoost) ppartner.boost(boosttorest,gammarest);
	nvect = Lorentz5Momentum( ZERO,0.5initial->progenitor()->mass()
	ppartner.vect().unit());
	nvect.boost(-boosttorest,gammarest);
	}
	}
	// if ISR
	if(radiated[0]) {
	// reconstruct the decay jet
	reconstructDecayJet(initial->progenitor());
	// momentum of decaying particle after ISR
	pjet=initial->progenitor()->momentum()
	-decay->incomingLines().begin()->second->momentum();
	pjet.rescaleMass();
	}
	// boost initial state jet and basis vector if needed
	if(gottaBoost) {
	pjet.boost(boosttorest,gammarest);
	nvect.boost(boosttorest,gammarest);
	ppartner[0].boost(boosttorest,gammarest);
	}
	// loop over the final-state particles and do the reconstruction
	JetKinVect possiblepartners;
	JetKinVect jetKinematics;
	bool atLeastOnce = radiated[0];
	LorentzRotation restboost(boosttorest,gammarest);
	Energy inmass(ZERO);
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	// only consider final-state jets
	if(!ShowerHardJets[ix]->progenitor()->isFinalState()) {
	inmass=ShowerHardJets[ix]->progenitor()->mass();
	continue;
	}
	// do the reconstruction
	JetKinStruct tempJetKin;
	tempJetKin.parent = ShowerHardJets[ix]->progenitor();
	if(ShowerHardJets.size()==2) {
	Lorentz5Momentum dum=ShowerHardJets[ix]->progenitor()->momentum();
	dum.setMass(inmass);
	dum.rescaleRho();
	tempJetKin.parent->set5Momentum(dum);
	}
	tempJetKin.p = ShowerHardJets[ix]->progenitor()->momentum();
	if(gottaBoost) tempJetKin.p.boost(boosttorest,gammarest);
	_progenitor=tempJetKin.parent;
	if(ShowerHardJets[ix]->reconstructed()==ShowerProgenitor::notReconstructed) {
	atLeastOnce \|= reconstructTimeLikeJet(tempJetKin.parent);
	ShowerHardJets[ix]->reconstructed(ShowerProgenitor::done);
	}
	if(gottaBoost) deepTransform(tempJetKin.parent,restboost);
	tempJetKin.q = ShowerHardJets[ix]->progenitor()->momentum();
	jetKinematics.push_back(tempJetKin);
	}
	if(partner) ppartner[1]=partner->momentum();
	// calculate the rescaling parameters
	double k1,k2;
	Lorentz5Momentum qt;
	if(!solveDecayKFactor(initial->progenitor()->mass(),nvect,pjet,
	jetKinematics,partner,ppartner,k1,k2,qt)) {
	for(map<tPPtr,vector<LorentzRotation> >::const_iterator bit=_boosts.begin();bit!=_boosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot);
	}
	}
	_boosts.clear();
	for(map<tShowerTreePtr,vector<LorentzRotation> >::const_iterator bit=_treeBoosts.begin();bit!=_treeBoosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot,false);
	}
	}
	_treeBoosts.clear();
	_currentTree = tShowerTreePtr();
	return false;
	}
	// apply boosts and rescalings to final-state jets
	for(JetKinVect::iterator it = jetKinematics.begin();
	it != jetKinematics.end(); ++it) {
	LorentzRotation Trafo = LorentzRotation();
	if(it->parent!=partner) {
	// boost for rescaling
	if(atLeastOnce) {
	map<tShowerTreePtr,pair<tShowerProgenitorPtr,
	tShowerParticlePtr> >::const_iterator tit;
	for(tit = _currentTree->treelinks().begin();
	tit != _currentTree->treelinks().end();++tit) {
	if(tit->second.first && tit->second.second==it->parent)
	break;
	}
	if(it->parent->children().empty()&&!it->parent->spinInfo() &&
	tit==_currentTree->treelinks().end()) {
	Lorentz5Momentum pnew(k2*it->p.vect(),
	sqrt(sqr(k2*it->p.vect().mag())+it->q.mass2()),
	it->q.mass());
	it->parent->set5Momentum(pnew);
	}
	else {
	// rescaling boost can't ever work in this case
	if(k2<0. && it->q.mass()==ZERO)
	throw KinematicsReconstructionVeto();
	Trafo = solveBoost(k2, it->q, it->p);
	}
	}
	if(gottaBoost) Trafo.boost(-boosttorest,gammarest);
	if(atLeastOnce \|\| gottaBoost) deepTransform(it->parent,Trafo);
	}
	else {
	Lorentz5Momentum pnew=ppartner[0];
	pnew *=k1;
	pnew-=qt;
	pnew.setMass(ppartner[1].mass());
	pnew.rescaleEnergy();
	LorentzRotation Trafo=solveBoost(1.,ppartner[1],pnew);
	if(gottaBoost) Trafo.boost(-boosttorest,gammarest);
	deepTransform(partner,Trafo);
	}
	}
	}
	catch(KinematicsReconstructionVeto) {
	for(map<tPPtr,vector<LorentzRotation> >::const_iterator bit=_boosts.begin();bit!=_boosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot);
	}
	}
	_boosts.clear();
	for(map<tShowerTreePtr,vector<LorentzRotation> >::const_iterator bit=_treeBoosts.begin();bit!=_treeBoosts.end();++bit) {
	for(vector<LorentzRotation>::const_reverse_iterator rit=bit->second.rbegin();rit!=bit->second.rend();++rit) {
	LorentzRotation rot = rit->inverse();
	bit->first->transform(rot,false);
	}
	}
	_treeBoosts.clear();
	_currentTree = tShowerTreePtr();
	return false;
	}
	catch (Exception & ex) {
	_currentTree = tShowerTreePtr();
	_boosts.clear();
	_treeBoosts.clear();
	throw ex;
	}
	_boosts.clear();
	_treeBoosts.clear();
	_currentTree = tShowerTreePtr();
	return true;
	}

	bool QTildeReconstructor::
	reconstructDecayJet( const tShowerParticlePtr p) const {
	if(p->children().empty()) return false;
	tShowerParticlePtr child;
	// if branching reconstruct time-like child
	child = dynamic_ptr_cast<ShowerParticlePtr>(p->children()[1]);
	if(child) {
	_progenitor=child;
	reconstructTimeLikeJet(child);
	// calculate the momentum of the particle
	Lorentz5Momentum pnew=p->momentum()-child->momentum();
	pnew.rescaleMass();
	p->children()[0]->set5Momentum(pnew);
	child=dynamic_ptr_cast<ShowerParticlePtr>(p->children()[0]);
	reconstructDecayJet(child);
	return true;
	}
	return false;
	}

	bool QTildeReconstructor::
	solveDecayKFactor(Energy mb,
	const Lorentz5Momentum & n,
	const Lorentz5Momentum & pjet,
	const JetKinVect & jetKinematics,
	ShowerParticlePtr partner,
	Lorentz5Momentum ppartner[2],
	double & k1, double & k2,
	Lorentz5Momentum & qt) const {
	Energy2 pjn = partner ? pjet.vect()*n.vect() : ZERO;
	Energy2 pcn = partner ? ppartner[0].vect()n.vect() : 1.MeV2;
	Energy2 nmag = n.vect().mag2();
	Lorentz5Momentum pn = partner ? (pjn/nmag)*n : Lorentz5Momentum();
	qt=pjet-pn; qt.setE(ZERO);
	Energy2 pt2=qt.vect().mag2();
	Energy Ejet = pjet.e();
	// magnitudes of the momenta for fast access
	vector<Energy2> pmag;
	Energy total(Ejet);
	for(unsigned int ix=0;ix<jetKinematics.size();++ix) {
	pmag.push_back(jetKinematics[ix].p.vect().mag2());
	total+=jetKinematics[ix].q.mass();
	}
	// return if no possible solution
	if(total>mb) return false;
	Energy2 pcmag=ppartner[0].vect().mag2();
	// used newton-raphson to get the rescaling
	static const Energy eps=1e-8*GeV;
	long double d1(1.),d2(1.);
	Energy roots, ea, ec, ds;
	unsigned int ix=0;
	do {
	++ix;
	d2 = d1 + pjn/pcn;
	roots = Ejet;
	ds = ZERO;
	for(unsigned int iy=0;iy<jetKinematics.size();++iy) {
	if(jetKinematics[iy].parent==partner) continue;
	ea = sqrt(sqr(d2)*pmag[iy]+jetKinematics[iy].q.mass2());
	roots += ea;
	ds += d2/ea*pmag[iy];
	}
	if(partner) {
	ec = sqrt(sqr(d1)*pcmag + pt2 + ppartner[1].mass2());
	roots += ec;
	ds += d1/ec*pcmag;
	}
	d1 += (mb-roots)/ds;
	d2 = d1 + pjn/pcn;
	}
	while(abs(mb-roots)>eps && ix<100);
	k1=d1;
	k2=d2;
	// return true if N-R succeed, otherwise false
	return ix<100;
	}

	bool QTildeReconstructor::
	deconstructDecayJets(HardTreePtr decay, cEvolverPtr,
	ShowerInteraction::Type) const {
	// extract the momenta of the particles
	vector<Lorentz5Momentum> pin;
	vector<Lorentz5Momentum> pout;
	// on-shell masses of the decay products
	vector<Energy> mon;
	Energy mbar(-GeV);
	// the hard branchings of the particles
	set<HardBranchingPtr>::iterator cit;
	set<HardBranchingPtr> branchings=decay->branchings();
	// properties of the incoming particle
	bool ISR = false;
	HardBranchingPtr initial;
	Lorentz5Momentum qisr;
	// find the incoming particle, both before and after
	// any ISR
	for(cit=branchings.begin();cit!=branchings.end();++cit){
	if((*cit)->status()==HardBranching::Incoming\|\|
	(*cit)->status()==HardBranching::Decay) {
	// search back up isr if needed
	HardBranchingPtr branch = *cit;
	while(branch->parent()) branch=branch->parent();
	initial=branch;
	// momentum or original parent
	pin.push_back(branch->branchingParticle()->momentum());
	// ISR?
	ISR = !branch->branchingParticle()->children().empty();
	// ISR momentum
	qisr = pin.back()-(**cit).branchingParticle()->momentum();
	qisr.rescaleMass();
	}
	}
	assert(pin.size()==1);
	// compute boost to rest frame
	Boost boostv=-pin[0].boostVector();
	// partner for ISR
	ShowerParticlePtr partner;
	Lorentz5Momentum ppartner;
	if(initial->branchingParticle()->partner()) {
	partner=initial->branchingParticle()->partner();
	ppartner=partner->momentum();
	}
	// momentum of the decay products
	for(cit=branchings.begin();cit!=branchings.end();++cit) {
	if((*cit)->status()!=HardBranching::Outgoing) continue;
	// find the mass of the particle
	// including special treatment for off-shell resonances
	// to preserve off-shell mass
	Energy mass;
	if(!(**cit).branchingParticle()->dataPtr()->stable()) {
	HardBranchingPtr branch=*cit;
	while(!branch->children().empty()) {
	for(unsigned int ix=0;ix<branch->children().size();++ix) {
	if(branch->children()[ix]->branchingParticle()->id()==
	(**cit).branchingParticle()->id()) {
	branch = branch->children()[ix];
	continue;
	}
	}
	};
	mass = branch->branchingParticle()->mass();
	}
	else {
	mass = (**cit).branchingParticle()->dataPtr()->mass();
	}
	// if not evolution partner of decaying particle
	if((*cit)->branchingParticle()!=partner) {
	pout.push_back((*cit)->branchingParticle()->momentum());
	mon.push_back(mass);
	}
	// evolution partner of decaying particle
	else {
	mbar = mass;
	}
	}
	// boost all the momenta to the rest frame of the decaying particle
	for(unsigned int ix=0;ix<pout.size();++ix) pout[ix].boost(boostv);
	if(initial->branchingParticle()->partner()) {
	ppartner.boost(boostv);
	qisr.boost(boostv);
	}
	// compute the rescaling factors
	double k1,k2;
	if(!ISR) {
	if(partner) {
	pout.push_back(ppartner);
	mon.push_back(mbar);
	}
	k1=k2=inverseRescalingFactor(pout,mon,pin[0].mass());
	if(partner) {
	pout.pop_back();
	mon.pop_back();
	}
	}
	else {
	if(!inverseDecayRescalingFactor(pout,mon,pin[0].mass(),
	ppartner,mbar,k1,k2)) return false;
	}
	// now calculate the p reference vectors
	unsigned int ifinal=0;
	for(cit=branchings.begin();cit!=branchings.end();++cit) {
	if((**cit).status()!=HardBranching::Outgoing) continue;
	// for partners other than colour partner of decaying particle
	if((*cit)->branchingParticle()!=partner) {
	Lorentz5Momentum pvect = (*cit)->branchingParticle()->momentum();
	pvect.boost(boostv);
	pvect /= k1;
	pvect.setMass(mon[ifinal]);
	++ifinal;
	pvect.rescaleEnergy();
	pvect.boost(-boostv);
	(*cit)->pVector(pvect);
	(*cit)->showerMomentum(pvect);
	}
	// for colour partner of decaying particle
	else {
	Lorentz5Momentum pvect = (*cit)->branchingParticle()->momentum();
	pvect.boost(boostv);
	Lorentz5Momentum qtotal;
	for(unsigned int ix=0;ix<pout.size();++ix) qtotal+=pout[ix];
	Lorentz5Momentum qperp =
	qisr-(qisr.vect()qtotal.vect())/(qtotal.vect().mag2())qtotal;
	pvect +=qperp;
	pvect /=k2;
	pvect.setMass(mbar);
	pvect.rescaleEnergy();
	pvect.boost(-boostv);
	(*cit)->pVector(pvect);
	(*cit)->showerMomentum(pvect);
	}
	}
	// // find the evolution partners
	// ShowerParticleVector particles;
	// particles.push_back((**decay->incoming().begin()).branchingParticle());
	// for(cit=branchings.begin();cit!=branchings.end();++cit) {
	// if((**cit).status()==HardBranching::Outgoing)
	// particles.push_back((*cit)->branchingParticle());
	// }
	// // partners should
	// evolver->showerModel()->partnerFinder()
	// ->setInitialEvolutionScales(particles,true,type,false);
	// For initial-state if needed
	if(initial) {
	tShowerParticlePtr newPartner=initial->branchingParticle()->partner();
	if(newPartner) {
	tHardBranchingPtr branch;
	for( set<HardBranchingPtr>::iterator clt = branchings.begin();
	clt != branchings.end(); ++clt ) {
	if((**clt).branchingParticle()==newPartner) {
	initial->colourPartner(*clt);
	branch=*clt;
	break;
	}
	}
	Lorentz5Momentum pvect = initial->branchingParticle()->momentum();
	initial->pVector(pvect);
	Lorentz5Momentum ptemp = branch->pVector();
	ptemp.boost(boostv);
	Lorentz5Momentum nvect = Lorentz5Momentum( ZERO,
	0.5initial->branchingParticle()->mass()
	ptemp.vect().unit());
	nvect.boost(-boostv);
	initial->nVector(nvect);
	}
	}
	// calculate the reference vectors, then for outgoing particles
	for(cit=branchings.begin();cit!=branchings.end();++cit){
	if((**cit).status()!=HardBranching::Outgoing) continue;
	// find the partner branchings
	tShowerParticlePtr newPartner=(*cit)->branchingParticle()->partner();
	if(!newPartner) continue;
	tHardBranchingPtr branch;
	for( set<HardBranchingPtr>::iterator clt = branchings.begin();
	clt != branchings.end(); ++clt ) {
	if(cit==clt) continue;
	if((**clt).branchingParticle()==newPartner) {
	(*cit).colourPartner(clt);
	branch=*clt;
	break;
	}
	}
	if((**decay->incoming().begin()).branchingParticle()==newPartner) {
	(*cit).colourPartner(decay->incoming().begin());
	branch = *decay->incoming().begin();
	}
	// final-state colour partner
	if(branch->status()==HardBranching::Outgoing) {
	Boost boost=((*cit)->pVector()+branch->pVector()).findBoostToCM();
	Lorentz5Momentum pcm = branch->pVector();
	pcm.boost(boost);
	Lorentz5Momentum nvect = Lorentz5Momentum(ZERO,pcm.vect());
	nvect.boost( -boost);
	(*cit)->nVector(nvect);
	}
	// initial-state colour partner
	else {
	Boost boost=branch->pVector().findBoostToCM();
	Lorentz5Momentum pcm = (*cit)->pVector();
	pcm.boost(boost);
	Lorentz5Momentum nvect = Lorentz5Momentum( ZERO, -pcm.vect());
	nvect.boost( -boost);
	(*cit)->nVector(nvect);
	}
	}
	// now compute the new momenta
	// and calculate the shower variables
	for(cit=branchings.begin();cit!=branchings.end();++cit) {
	if((**cit).status()!=HardBranching::Outgoing) continue;
	LorentzRotation B=LorentzRotation(-boostv);
	LorentzRotation A=LorentzRotation(boostv),R;
	if((*cit)->branchingParticle()==partner) {
	Lorentz5Momentum qnew;
	Energy2 dot=(cit)->pVector()(*cit)->nVector();
	double beta = 0.5((cit)->branchingParticle()->momentum().m2()
	-sqr((*cit)->pVector().mass()))/dot;
	qnew=(cit)->pVector()+beta(*cit)->nVector();
	qnew.rescaleMass();
	// compute the boost
	R=BsolveBoost(Aqnew,A(cit)->branchingParticle()->momentum())*A;
	}
	else {
	Lorentz5Momentum qnew;
	if((*cit)->branchingParticle()->partner()) {
	Energy2 dot=(cit)->pVector()(*cit)->nVector();
	double beta = 0.5((cit)->branchingParticle()->momentum().m2()
	-sqr((*cit)->pVector().mass()))/dot;
	qnew=(cit)->pVector()+beta(*cit)->nVector();
	qnew.rescaleMass();
	}
	else {
	qnew = (*cit)->pVector();
	}
	// compute the boost
	R=BsolveBoost(Aqnew,A(cit)->branchingParticle()->momentum())*A;
	}
	// reconstruct the momenta
	(*cit)->setMomenta(R,1.0,Lorentz5Momentum());
	}
	if(initial) {
	initial->setMomenta(LorentzRotation(),1.0,Lorentz5Momentum());
	}
	return true;
	}

	double QTildeReconstructor::
	inverseRescalingFactor(vector<Lorentz5Momentum> pout,
	vector<Energy> mon, Energy roots) const {
	double lambda=1.;
	if(pout.size()==2) {
	double mu_q1(pout[0].m()/roots), mu_q2(pout[1].m()/roots);
	double mu_p1(mon[0]/roots) , mu_p2(mon[1]/roots);
	lambda =
	((1.+mu_q1+mu_q2)(1.-mu_q1-mu_q2)(mu_q1-1.-mu_q2)*(mu_q2-1.-mu_q1))/
	((1.+mu_p1+mu_p2)(1.-mu_p1-mu_p2)(mu_p1-1.-mu_p2)*(mu_p2-1.-mu_p1));
	if(lambda<0.)
	throw Exception() << "Rescaling factor is imaginary in QTildeReconstructor::"
	<< "inverseRescalingFactor lambda^2= " << lambda
	<< Exception::eventerror;
	lambda = sqrt(lambda);
	}
	else {
	unsigned int ntry=0;
	// compute magnitudes once for speed
	vector<Energy2> pmag;
	for(unsigned int ix=0;ix<pout.size();++ix) {
	pmag.push_back(pout[ix].vect().mag2());
	}
	// Newton-Raphson for the rescaling
	vector<Energy> root(pout.size());
	do {
	// compute new energies
	Energy sum(ZERO);
	for(unsigned int ix=0;ix<pout.size();++ix) {
	root[ix] = sqrt(pmag[ix]/sqr(lambda)+sqr(mon[ix]));
	sum+=root[ix];
	}
	// if accuracy reached exit
	if(abs(sum/roots-1.)<1e-10) break;
	// use Newton-Raphson to compute new guess for lambda
	Energy numer(ZERO),denom(ZERO);
	for(unsigned int ix=0;ix<pout.size();++ix) {
	numer +=root[ix];
	denom +=pmag[ix]/root[ix];
	}
	numer-=roots;
	double fact = 1.+sqr(lambda)*numer/denom;
	if(fact<0.) fact=0.5;
	lambda *=fact;
	++ntry;
	}
	while(ntry<100);
	}
	if(isnan(lambda))
	throw Exception() << "Rescaling factor is nan in QTildeReconstructor::"
	<< "inverseRescalingFactor "
	<< Exception::eventerror;
	return lambda;
	}

	bool QTildeReconstructor::
	deconstructGeneralSystem(HardTreePtr tree,
	cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	// extract incoming and outgoing particles
	ColourSingletShower in,out;
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((*it).status()==HardBranching::Incoming) in .jets.push_back(it);
	else out.jets.push_back(*it);
	}
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	// do the initial-state reconstruction
	deconstructInitialInitialSystem(applyBoost,toRest,fromRest,
	tree,in.jets,type);
	// do the final-state reconstruction
	deconstructFinalStateSystem(toRest,fromRest,tree,
	out.jets,evolver,type);
	// only at this point that we can be sure all the reference vectors
	// are correct
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((**it).status()==HardBranching::Incoming) continue;
	if((**it).branchingParticle()->coloured())
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	for(set<HardBranchingPtr>::const_iterator it=tree->incoming().begin();
	it!=tree->incoming().end();++it) {
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	return true;
	}

	bool QTildeReconstructor::deconstructHardJets(HardTreePtr tree,
	cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	// inverse of old recon method
	if(_reconopt == 0) {
	return deconstructGeneralSystem(tree,evolver,type);
	}
	else if(_reconopt == 1) {
	return deconstructColourSinglets(tree,evolver,type);
	}
	else if(_reconopt == 2) {
	throw Exception() << "Inverse reconstruction is not currently supported for ReconstructionOption Colour2 "
	<< "in QTildeReconstructor::deconstructHardJets(). Please use one of the other options\n"
	<< Exception::runerror;
	}
	else if(_reconopt == 3 \|\| _reconopt == 4 ) {
	return deconstructColourPartner(tree,evolver,type);
	}
	else
	assert(false);
	}

	bool QTildeReconstructor::
	deconstructColourSinglets(HardTreePtr tree,cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	// identify the colour singlet systems
	unsigned int nnun(0),nnii(0),nnif(0),nnf(0),nni(0);
	vector<ColourSingletShower>
	systems(identifySystems(tree->branchings(),nnun,nnii,nnif,nnf,nni));
	// now decide what to do
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	bool general(false);
	// initial-initial connection and final-state colour singlet systems
	// Drell-Yan type
	if(nnun==0&&nnii==1&&nnif==0&&nnf>0&&nni==0) {
	// reconstruct initial-initial system
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==II)
	deconstructInitialInitialSystem(applyBoost,toRest,fromRest,tree,
	systems[ix].jets,type);
	}
	if(type!=ShowerInteraction::QCD) {
	combineFinalState(systems);
	general=false;
	}
	}
	// DIS and VBF type
	else if(nnun==0&&nnii==0&&((nnif==1&&nnf>0&&nni==1)\|\|
	(nnif==2&& nni==0))) {
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==IF)
	deconstructInitialFinalSystem(tree,systems[ix].jets,evolver,type);
	}
	}
	// e+e- type
	else if(nnun==0&&nnii==0&&nnif==0&&nnf>0&&nni==2) {
	// only FS needed
	// but need to boost to rest frame if QED ISR
	Lorentz5Momentum ptotal;
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==I)
	ptotal += systems[ix].jets[0]->branchingParticle()->momentum();
	}
	toRest = LorentzRotation(ptotal.findBoostToCM());
	fromRest = toRest;
	fromRest.invert();
	if(type!=ShowerInteraction::QCD) {
	combineFinalState(systems);
	general=false;
	}
	}
	// general type
	else {
	general = true;
	}
	// final-state systems except for general recon
	if(!general) {
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==F)
	deconstructFinalStateSystem(toRest,fromRest,tree,
	systems[ix].jets,evolver,type);
	}
	// only at this point that we can be sure all the reference vectors
	// are correct
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((**it).status()==HardBranching::Incoming) continue;
	if((**it).branchingParticle()->coloured())
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	for(set<HardBranchingPtr>::const_iterator it=tree->incoming().begin();
	it!=tree->incoming().end();++it) {
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	return true;
	}
	else {
	return deconstructGeneralSystem(tree,evolver,type);
	}
	return true;
	}

	bool QTildeReconstructor::
	deconstructColourPartner(HardTreePtr tree,cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	Lorentz5Momentum ptotal;
	HardBranchingPtr emitter;
	ColourSingletShower incomingShower,outgoingShower;
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((**it).status()==HardBranching::Incoming) {
	incomingShower.jets.push_back(*it);
	ptotal += (*it)->branchingParticle()->momentum();
	// check for emitting particle
	if((**it).parent() ) {
	if(!emitter)
	emitter = *it;
	else
	throw Exception() << "Only one emitting particle allowed in "
	<< "QTildeReconstructor::deconstructColourPartner()"
	<< Exception::runerror;
	}
	}
	else if ((**it).status()==HardBranching::Outgoing) {
	outgoingShower.jets.push_back(*it);
	// check for emitting particle
	if(!(**it).children().empty() ) {
	if(!emitter)
	emitter = *it;
	else
	throw Exception() << "Only one emitting particle allowed in "
	<< "QTildeReconstructor::deconstructColourPartner()"
	<< Exception::runerror;
	}
	}
	}
	assert(emitter);
	assert(emitter->colourPartner());
	ColourSingletShower system;
	system.jets.push_back(emitter);
	system.jets.push_back(emitter->colourPartner());
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	// identify the colour singlet system
	if(emitter->status() == HardBranching::Outgoing &&
	emitter->colourPartner()->status() == HardBranching::Outgoing ) {
	system.type=F;
	// need to boost to rest frame if QED ISR
	if( !incomingShower.jets[0]->branchingParticle()->coloured() &&
	!incomingShower.jets[1]->branchingParticle()->coloured() ) {
	Boost boost = ptotal.findBoostToCM();
	toRest = LorentzRotation( boost);
	fromRest = LorentzRotation(-boost);
	}
	else
	findInitialBoost(ptotal,ptotal,toRest,fromRest);
	deconstructFinalStateSystem(toRest,fromRest,tree,
	system.jets,evolver,type);
	}
	else if (emitter->status() == HardBranching::Incoming &&
	emitter->colourPartner()->status() == HardBranching::Incoming) {
	system.type=II;
	deconstructInitialInitialSystem(applyBoost,toRest,fromRest,tree,system.jets,type);
	// make sure the recoil gets applied
	deconstructFinalStateSystem(toRest,fromRest,tree,
	outgoingShower.jets,evolver,type);
	}
	else if ((emitter->status() == HardBranching::Outgoing &&
	emitter->colourPartner()->status() == HardBranching::Incoming ) \|\|
	(emitter->status() == HardBranching::Incoming &&
	emitter->colourPartner()->status() == HardBranching::Outgoing)) {
	system.type=IF;
	// enusre incoming first
	if(system.jets[0]->status() == HardBranching::Outgoing)
	swap(system.jets[0],system.jets[1]);
	deconstructInitialFinalSystem(tree,system.jets,evolver,type);
	}
	else {
	throw Exception() << "Unknown type of system in "
	<< "QTildeReconstructor::deconstructColourPartner()"
	<< Exception::runerror;
	}
	// only at this point that we can be sure all the reference vectors
	// are correct
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((**it).status()==HardBranching::Incoming) continue;
	if((**it).branchingParticle()->coloured())
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	for(set<HardBranchingPtr>::const_iterator it=tree->incoming().begin();
	it!=tree->incoming().end();++it) {
	(**it).setMomenta(LorentzRotation(),1.,Lorentz5Momentum(),false);
	}
	for(set<HardBranchingPtr>::const_iterator it=tree->branchings().begin();
	it!=tree->branchings().end();++it) {
	if((**it).status()!=HardBranching::Incoming) continue;
	if(it==system.jets[0] \|\| it==system.jets[1]) continue;
	if((**it).branchingParticle()->momentum().z()>ZERO) {
	(it).z((it).branchingParticle()->momentum().plus()/(**it).beam()->momentum().plus());
	}
	else {
	(it).z((it).branchingParticle()->momentum().minus()/(**it).beam()->momentum().minus());
	}
	}
	return true;
	}

	void QTildeReconstructor::
	reconstructInitialFinalSystem(vector<ShowerProgenitorPtr> jets) const {
	Lorentz5Momentum pin[2],pout[2],pbeam;
	for(unsigned int ix=0;ix<jets.size();++ix) {
	// final-state parton
	if(jets[ix]->progenitor()->isFinalState()) {
	pout[0] +=jets[ix]->progenitor()->momentum();
	_progenitor = jets[ix]->progenitor();
	if(jets[ix]->reconstructed()==ShowerProgenitor::notReconstructed) {
	reconstructTimeLikeJet(jets[ix]->progenitor());
	jets[ix]->reconstructed(ShowerProgenitor::done);
	}
	}
	// initial-state parton
	else {
	pin[0] +=jets[ix]->progenitor()->momentum();
	if(jets[ix]->progenitor()->showerKinematics()) {
	pbeam = jets[ix]->progenitor()->showerBasis()->getBasis()[0];
	}
	else {
	if ( jets[ix]->original()->parents().empty() ) {
	pbeam = jets[ix]->progenitor()->momentum();
	}
	else {
	pbeam = jets[ix]->original()->parents()[0]->momentum();
	}
	}
	if(jets[ix]->reconstructed()==ShowerProgenitor::notReconstructed) {
	reconstructSpaceLikeJet(jets[ix]->progenitor());
	jets[ix]->reconstructed(ShowerProgenitor::done);
	}
	assert(!jets[ix]->original()->parents().empty());
	}
	}
	// add intrinsic pt if needed
	addIntrinsicPt(jets);
	// momenta after showering
	for(unsigned int ix=0;ix<jets.size();++ix) {
	if(jets[ix]->progenitor()->isFinalState())
	pout[1] += jets[ix]->progenitor()->momentum();
	else
	pin[1] += jets[ix]->progenitor()->momentum();
	}
	// work out the boost to the Breit frame
	Lorentz5Momentum pa = pout[0]-pin[0];
	Axis axis(pa.vect().unit());
	LorentzRotation rot;
	double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
	if ( sinth > 1.e-9 )
	rot.setRotate(-acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
	rot.rotateX(Constants::pi);
	rot.boostZ( pa.e()/pa.vect().mag());
	Lorentz5Momentum ptemp=rot*pbeam;
	Boost trans = -1./ptemp.e()*ptemp.vect();
	trans.setZ(0.);
	if ( trans.mag2() - 1. >= 0. ) throw KinematicsReconstructionVeto();
	rot.boost(trans);
	pa *=rot;
	// project and calculate rescaling
	// reference vectors
	Lorentz5Momentum n1(ZERO,ZERO,-pa.z(),-pa.z());
	Lorentz5Momentum n2(ZERO,ZERO, pa.z(),-pa.z());
	Energy2 n1n2 = n1*n2;
	// decompose the momenta
	Lorentz5Momentum qbp=rotpin[1],qcp=rotpout[1];
	qbp.rescaleMass();
	qcp.rescaleMass();
	double a[2],b[2];
	a[0] = n2*qbp/n1n2;
	b[0] = n1*qbp/n1n2;
	Lorentz5Momentum qperp = qbp-a[0]n1-b[0]n2;
	b[1] = 0.5;
	a[1] = 0.5*(qcp.m2()-qperp.m2())/n1n2/b[1];
	double kb;
	if(a[0]!=0.) {
	double A(0.5a[0]),B(b[0]a[0]-a[1]b[1]-0.25),C(-0.5b[0]);
	if(sqr(B)-4.AC<0.) throw KinematicsReconstructionVeto();
	kb = 0.5(-B+sqrt(sqr(B)-4.A*C))/A;
	}
	else {
	kb = 0.5b[0]/(b[0]a[0]-a[1]*b[1]-0.25);
	}
	// changed to improve stability
	if(kb==0.) throw KinematicsReconstructionVeto();
	if ( a[1]>b[1] && abs(a[1]) < 1e-12 )
	throw KinematicsReconstructionVeto();
	if ( a[1]<=b[1] && abs(0.5+b[0]/kb) < 1e-12 )
	throw KinematicsReconstructionVeto();
	double kc = (a[1]>b[1]) ? (a[0]*kb-0.5)/a[1] : b[1]/(0.5+b[0]/kb);
	if(kc==0.) throw KinematicsReconstructionVeto();
	Lorentz5Momentum pnew[2] = { a[0]kbn1+b[0]/kb*n2+qperp,
	a[1]kcn1+b[1]/kc*n2+qperp};
	LorentzRotation rotinv=rot.inverse();
	for(unsigned int ix=0;ix<jets.size();++ix) {
	if(jets[ix]->progenitor()->isFinalState()) {
	deepTransform(jets[ix]->progenitor(),rot);
	deepTransform(jets[ix]->progenitor(),solveBoost(pnew[1],qcp));
	Energy delta = jets[ix]->progenitor()->momentum().m()-jets[ix]->progenitor()->momentum().mass();
	if ( abs(delta) > MeV ) throw KinematicsReconstructionVeto();
	deepTransform(jets[ix]->progenitor(),rotinv);
	}
	else {
	tPPtr parent;
	boostChain(jets[ix]->progenitor(),rot,parent);
	boostChain(jets[ix]->progenitor(),solveBoostZ(pnew[0],qbp),parent);
	// check the first boost worked, and if not apply small correction to
	// fix energy/momentum conservation
	// this is a kludge but it reduces momentum non-conservation dramatically
	Lorentz5Momentum pdiff = pnew[0]-jets[ix]->progenitor()->momentum();
	Energy2 delta = sqr(pdiff.x())+sqr(pdiff.y())+sqr(pdiff.z())+sqr(pdiff.t());
	unsigned int ntry=0;
	while(delta>1e-6*GeV2 && ntry<5 ) {
	ntry +=1;
	boostChain(jets[ix]->progenitor(),solveBoostZ(pnew[0],jets[ix]->progenitor()->momentum()),parent);
	pdiff = pnew[0]-jets[ix]->progenitor()->momentum();
	delta = sqr(pdiff.x())+sqr(pdiff.y())+sqr(pdiff.z())+sqr(pdiff.t());
	}
	// apply test in breit-frame
	Lorentz5Momentum ptest1 = parent->momentum();
	Lorentz5Momentum ptest2 = rot*pbeam;
	if(ptest1.z()/ptest2.z()<0. \|\| ptest1.z()/ptest2.z()>1.)
	throw KinematicsReconstructionVeto();
	boostChain(jets[ix]->progenitor(),rotinv,parent);
	}
	}
	}

	bool QTildeReconstructor::addIntrinsicPt(vector<ShowerProgenitorPtr> jets) const {
	bool added=false;
	// add the intrinsic pt if needed
	for(unsigned int ix=0;ix<jets.size();++ix) {
	// only for initial-state particles which haven't radiated
	if(jets[ix]->progenitor()->isFinalState()\|\|
	jets[ix]->hasEmitted()\|\|
	jets[ix]->reconstructed()==ShowerProgenitor::dontReconstruct) continue;
	if(_intrinsic.find(jets[ix])==_intrinsic.end()) continue;
	pair<Energy,double> pt=_intrinsic[jets[ix]];
	Energy etemp = jets[ix]->original()->parents()[0]->momentum().z();
	Lorentz5Momentum
	p_basis(ZERO, ZERO, etemp, abs(etemp)),
	n_basis(ZERO, ZERO,-etemp, abs(etemp));
	double alpha = jets[ix]->progenitor()->x();
	double beta = 0.5*(sqr(jets[ix]->progenitor()->data().mass())+
	sqr(pt.first))/alpha/(p_basis*n_basis);
	Lorentz5Momentum pnew=alphap_basis+betan_basis;
	pnew.setX(pt.first*cos(pt.second));
	pnew.setY(pt.first*sin(pt.second));
	pnew.rescaleMass();
	jets[ix]->progenitor()->set5Momentum(pnew);
	added = true;
	}
	return added;
	}

	LorentzRotation QTildeReconstructor::
	solveBoost(const double k, const Lorentz5Momentum & newq,
	const Lorentz5Momentum & oldp ) const {
	Energy q = newq.vect().mag();
	Energy2 qs = sqr(q);
	Energy2 Q2 = newq.mass2();
	Energy kp = k*(oldp.vect().mag());
	Energy2 kps = sqr(kp);
	double betam = (qnewq.e() - kpsqrt(kps + Q2))/(kps + qs + Q2);
	if ( abs(betam) - 1. >= 0. ) throw KinematicsReconstructionVeto();
	Boost beta = -betam(k/kp)oldp.vect();
	double gamma = 0.;
	if(Q2/sqr(oldp.e())>1e-4) {
	if(betam<0.5) {
	gamma = 1./sqrt(1.-sqr(betam));
	}
	else {
	gamma = ( kps+ qs + Q2)/
	sqrt(2.kpsqs + kpsQ2 + qsQ2 + sqr(Q2) + 2.qnewq.e()kpsqrt(kps + Q2));
	}
	}
	else {
	if(k>0) {
	gamma = 4.kpsqs/sqr(kps +qs) + 2.sqr(kps-qs)Q2/pow<3,1>(kps +qs)
	- 0.25( sqr(kps) + 14.kpsqs + sqr(qs))sqr(kps-qs)/(pow<4,1>(kps +qs)kpsqs)*sqr(Q2);
	}
	else {
	gamma = 0.25sqr(Q2)/(kpsqs)(1. - 0.5(kps+qs)/(kpsqs)Q2);
	}
	if(gamma<=0.) throw KinematicsReconstructionVeto();
	gamma = 1./sqrt(gamma);
	}
	// note that (k/kp)*oldp.vect() = oldp.vect()/oldp.vect().mag() but cheaper.
	ThreeVector<Energy2> ax = newq.vect().cross( oldp.vect() );
	double delta = newq.vect().angle( oldp.vect() );
	LorentzRotation R;
	using Constants::pi;
	Energy2 scale1 = sqr(newq.x())+ sqr(newq.y())+sqr(newq.z());
	Energy2 scale2 = sqr(oldp.x())+ sqr(oldp.y())+sqr(oldp.z());
	if ( ax.mag2()/scale1/scale2 > 1e-28 ) {
	R.rotate( delta, unitVector(ax) ).boost( beta , gamma );
	}
	else if(abs(delta-pi)/pi < 0.001) {
	double phi=2.piUseRandom::rnd();
	Axis axis(cos(phi),sin(phi),0.);
	axis.rotateUz(newq.vect().unit());
	R.rotate(delta,axis).boost( beta , gamma );
	}
	else {
	R.boost( beta , gamma );
	}
	return R;
	}

	LorentzRotation QTildeReconstructor::solveBoost(const Lorentz5Momentum & q,
	const Lorentz5Momentum & p ) const {
	Energy modp = p.vect().mag();
	Energy modq = q.vect().mag();
	double betam = (p.e()modp-q.e()modq)/(sqr(modq)+sqr(modp)+p.mass2());
	if ( abs(betam)-1. >= 0. ) throw KinematicsReconstructionVeto();
	Boost beta = -betam*q.vect().unit();
	ThreeVector<Energy2> ax = p.vect().cross( q.vect() );
	double delta = p.vect().angle( q.vect() );
	LorentzRotation R;
	using Constants::pi;
	if ( beta.mag2() - 1. >= 0. ) throw KinematicsReconstructionVeto();
	if ( ax.mag2()/GeV2/MeV2 > 1e-16 ) {
	R.rotate( delta, unitVector(ax) ).boost( beta );
	}
	else {
	R.boost( beta );
	}
	return R;
	}

	LorentzRotation QTildeReconstructor::solveBoostZ(const Lorentz5Momentum & q,
	const Lorentz5Momentum & p ) const {
	static const double eps = 1e-6;
	LorentzRotation R;
	double beta;
	Energy2 mt2 = p.mass()<ZERO ? -sqr(p.mass())+sqr(p.x())+sqr(p.y()) : sqr(p.mass())+sqr(p.x())+sqr(p.y()) ;
	double ratio = mt2/(sqr(p.t())+sqr(q.t()));
	if(abs(ratio)>eps) {
	double erat = (q.t()+q.z())/(p.t()+p.z());
	Energy2 den = mt2*(erat+1./erat);
	Energy2 num = (q.z()-p.z())(q.t()+p.t()) + (p.z()+q.z())(p.t()-q.t());
	beta = num/den;
	if ( abs(beta) - 1. >= 0. ) throw KinematicsReconstructionVeto();
	R.boostZ(beta);
	}
	else {
	double er = sqr(p.t()/q.t());
	double x = ratio+0.125(er+10.+1./er)sqr(ratio);
	beta = -(p.t()-q.t())(p.t()+q.t())/(sqr(p.t())+sqr(q.t()))(1.+x);
	double gamma = (4.sqr(p.t()q.t()) +sqr(p.t()-q.t())sqr(p.t()+q.t())
	(-2.*x+sqr(x)))/sqr(sqr(p.t())+sqr(q.t()));
	if ( abs(beta) - 1. >= 0. ) throw KinematicsReconstructionVeto();
	gamma = 1./sqrt(gamma);
	R.boost(0.,0.,beta,gamma);
	}
	Lorentz5Momentum ptest = R*p;
	if(ptest.z()/q.z() < 0. \|\| ptest.t()/q.t() < 0. ) {
	throw KinematicsReconstructionVeto();
	}
	return R;
	}

	void QTildeReconstructor::
	reconstructFinalStateSystem(bool applyBoost,
	const LorentzRotation & toRest,
	const LorentzRotation & fromRest,
	vector<ShowerProgenitorPtr> jets) const {
	LorentzRotation trans = applyBoost? toRest : LorentzRotation();
	// special for case of individual particle
	if(jets.size()==1) {
	deepTransform(jets[0]->progenitor(),trans);
	deepTransform(jets[0]->progenitor(),fromRest);
	return;
	}
	bool radiated(false);
	// find the hard process centre-of-mass energy
	Lorentz5Momentum pcm;
	// check if radiated and calculate total momentum
	for(unsigned int ix=0;ix<jets.size();++ix) {
	radiated \|=jets[ix]->hasEmitted();
	pcm += jets[ix]->progenitor()->momentum();
	}
	if(applyBoost) pcm *= trans;
	// check if in CMF frame
	Boost beta_cm = pcm.findBoostToCM();
	bool gottaBoost(false);
	if(beta_cm.mag() > 1e-12) {
	gottaBoost = true;
	trans.boost(beta_cm);
	}
	// collection of pointers to initial hard particle and jet momenta
	// for final boosts
	JetKinVect jetKinematics;
	vector<ShowerProgenitorPtr>::const_iterator cit;
	for(cit = jets.begin(); cit != jets.end(); cit++) {
	JetKinStruct tempJetKin;
	tempJetKin.parent = (*cit)->progenitor();
	if(applyBoost \|\| gottaBoost) {
	deepTransform(tempJetKin.parent,trans);
	}
	tempJetKin.p = (*cit)->progenitor()->momentum();
	_progenitor=tempJetKin.parent;
	if((**cit).reconstructed()==ShowerProgenitor::notReconstructed) {
	radiated \|= reconstructTimeLikeJet((*cit)->progenitor());
	(**cit).reconstructed(ShowerProgenitor::done);
	}
	else {
	radiated \|= !(*cit)->progenitor()->children().empty();
	}
	tempJetKin.q = (*cit)->progenitor()->momentum();
	jetKinematics.push_back(tempJetKin);
	}
	// default option rescale everything with the same factor
	if( _finalStateReconOption == 0 \|\| jetKinematics.size() <= 2 ) {
	// find the rescaling factor
	double k = 0.0;
	if(radiated) {
	k = solveKfactor(pcm.m(), jetKinematics);
	// perform the rescaling and boosts
	for(JetKinVect::iterator it = jetKinematics.begin();
	it != jetKinematics.end(); ++it) {
	LorentzRotation Trafo = solveBoost(k, it->q, it->p);
	deepTransform(it->parent,Trafo);
	}
	}
	}
	// different treatment of most off-shell
	else if ( _finalStateReconOption <= 4 ) {
	// sort the jets by virtuality
	std::sort(jetKinematics.begin(),jetKinematics.end(),JetOrdering());
	// Bryan's procedures from FORTRAN
	if( _finalStateReconOption <=2 ) {
	// loop over the off-shell partons, _finalStateReconOption==1 only first ==2 all
	JetKinVect::const_iterator jend = _finalStateReconOption==1 ? jetKinematics.begin()+1 : jetKinematics.end();
	for(JetKinVect::const_iterator jit=jetKinematics.begin(); jit!=jend;++jit) {
	// calculate the 4-momentum of the recoiling system
	Lorentz5Momentum psum;
	bool done = true;
	for(JetKinVect::const_iterator it=jetKinematics.begin();it!=jetKinematics.end();++it) {
	if(it==jit) {
	done = false;
	continue;
	}
	// first option put on-shell and sum 4-momenta
	if( _finalStateReconOption == 1 ) {
	LorentzRotation Trafo = solveBoost(1., it->q, it->p);
	deepTransform(it->parent,Trafo);
	psum += it->parent->momentum();
	}
	// second option, sum momenta
	else {
	// already rescaled
	if(done) psum += it->parent->momentum();
	// still needs to be rescaled
	else psum += it->p;
	}
	}
	// set the mass
	psum.rescaleMass();
	// calculate the 3-momentum rescaling factor
	Energy2 s(pcm.m2());
	Energy2 m1sq(jit->q.m2()),m2sq(psum.m2());
	Energy4 num = sqr(s - m1sq - m2sq) - 4.m1sqm2sq;
	if(num<ZERO) throw KinematicsReconstructionVeto();
	double k = sqrt( num / (4.sjit->p.vect().mag2()) );
	// boost the off-shell parton
	LorentzRotation B1 = solveBoost(k, jit->q, jit->p);
	deepTransform(jit->parent,B1);
	// boost everything else to rescale
	LorentzRotation B2 = solveBoost(k, psum, psum);
	for(JetKinVect::iterator it=jetKinematics.begin();it!=jetKinematics.end();++it) {
	if(it==jit) continue;
	deepTransform(it->parent,B2);
	it->p *= B2;
	it->q *= B2;
	}
	}
	}
	// Peter's C++ procedures
	else {
	reconstructFinalFinalOffShell(jetKinematics,pcm.m2(), _finalStateReconOption == 4);
	}
	}
	else
	assert(false);
	// apply the final boosts
	if(gottaBoost \|\| applyBoost) {
	LorentzRotation finalBoosts;
	if(gottaBoost) finalBoosts.boost(-beta_cm);
	if(applyBoost) finalBoosts.transform(fromRest);
	for(JetKinVect::iterator it = jetKinematics.begin();
	it != jetKinematics.end(); ++it) {
	deepTransform(it->parent,finalBoosts);
	}
	}
	}

	void QTildeReconstructor::
	reconstructInitialInitialSystem(bool & applyBoost,
	LorentzRotation & toRest,
	LorentzRotation & fromRest,
	vector<ShowerProgenitorPtr> jets) const {
	bool radiated = false;
	Lorentz5Momentum pcm;
	// check whether particles radiated and calculate total momentum
	for( unsigned int ix = 0; ix < jets.size(); ++ix ) {
	radiated \|= jets[ix]->hasEmitted();
	pcm += jets[ix]->progenitor()->momentum();
	if(jets[ix]->original()->parents().empty()) return;
	}
	pcm.rescaleMass();
	// check if intrinsic pt to be added
	radiated \|= !_intrinsic.empty();
	// if no radiation return
	if(!radiated) {
	for(unsigned int ix=0;ix<jets.size();++ix) {
	if(jets[ix]->reconstructed()==ShowerProgenitor::notReconstructed)
	jets[ix]->reconstructed(ShowerProgenitor::done);
	}
	return;
	}
	// initial state shuffling
	applyBoost=false;
	vector<Lorentz5Momentum> p, pq, p_in;
	vector<Energy> pts;
	for(unsigned int ix=0;ix<jets.size();++ix) {
	// add momentum to vector
	p_in.push_back(jets[ix]->progenitor()->momentum());
	// reconstruct the jet
	if(jets[ix]->reconstructed()==ShowerProgenitor::notReconstructed) {
	radiated \|= reconstructSpaceLikeJet(jets[ix]->progenitor());
	jets[ix]->reconstructed(ShowerProgenitor::done);
	}
	assert(!jets[ix]->original()->parents().empty());
	Energy etemp = jets[ix]->original()->parents()[0]->momentum().z();
	Lorentz5Momentum ptemp = Lorentz5Momentum(ZERO, ZERO, etemp, abs(etemp));
	pq.push_back(ptemp);
	pts.push_back(jets[ix]->highestpT());
	}
	// add the intrinsic pt if needed
	radiated \|=addIntrinsicPt(jets);
	for(unsigned int ix=0;ix<jets.size();++ix) {
	p.push_back(jets[ix]->progenitor()->momentum());
	}
	double x1 = p_in[0].z()/pq[0].z();
	double x2 = p_in[1].z()/pq[1].z();
	vector<double> beta=initialStateRescaling(x1,x2,p_in[0]+p_in[1],p,pq,pts);
	// if not need don't apply boosts
	if(!(radiated && p.size() == 2 && pq.size() == 2)) return;
	applyBoost=true;
	// apply the boosts
	Lorentz5Momentum newcmf;
	for(unsigned int ix=0;ix<jets.size();++ix) {
	tPPtr toBoost = jets[ix]->progenitor();
	Boost betaboost(0, 0, beta[ix]);
	tPPtr parent;
	boostChain(toBoost, LorentzRotation(0.,0.,beta[ix]),parent);
	if(parent->momentum().e()/pq[ix].e()>1.\|\|
	parent->momentum().z()/pq[ix].z()>1.) throw KinematicsReconstructionVeto();
	newcmf+=toBoost->momentum();
	}
	if(newcmf.m()<ZERO\|\|newcmf.e()<ZERO) throw KinematicsReconstructionVeto();
	findInitialBoost(pcm,newcmf,toRest,fromRest);
	}

	void QTildeReconstructor::
	deconstructInitialInitialSystem(bool & applyBoost,
	LorentzRotation & toRest,
	LorentzRotation & fromRest,
	HardTreePtr tree,
	vector<HardBranchingPtr> jets,
	ShowerInteraction::Type) const {
	assert(jets.size()==2);
	// put beam with +z first
	if(jets[0]->beam()->momentum().z()<ZERO) swap(jets[0],jets[1]);
	// get the momenta of the particles
	vector<Lorentz5Momentum> pin,pq;
	for(unsigned int ix=0;ix<jets.size();++ix) {
	pin.push_back(jets[ix]->branchingParticle()->momentum());
	Energy etemp = jets[ix]->beam()->momentum().z();
	pq.push_back(Lorentz5Momentum(ZERO, ZERO,etemp, abs(etemp)));
	}
	// calculate the rescaling
	double x[2];
	Lorentz5Momentum pcm=pin[0]+pin[1];
	assert(pcm.mass2()>ZERO);
	pcm.rescaleMass();
	vector<double> boost = inverseInitialStateRescaling(x[0],x[1],pcm,pin,pq);
	set<HardBranchingPtr>::const_iterator cjt=tree->incoming().begin();
	HardBranchingPtr incoming[2];
	incoming[0] = *cjt;
	++cjt;
	incoming[1] = *cjt;
	if((*tree->incoming().begin())->beam()->momentum().z()/pq[0].z()<0.)
	swap(incoming[0],incoming[1]);
	// apply the boost the the particles
	unsigned int iswap[2]={1,0};
	for(unsigned int ix=0;ix<2;++ix) {
	LorentzRotation R(0.,0.,-boost[ix]);
	incoming[ix]->pVector(pq[ix]);
	incoming[ix]->nVector(pq[iswap[ix]]);
	incoming[ix]->setMomenta(R,1.,Lorentz5Momentum());
	jets[ix]->showerMomentum(x[ix]*jets[ix]->pVector());
	}
	// and calculate the boosts
	applyBoost=true;
	// do one boost
	if(_initialBoost==0) {
	toRest = LorentzRotation(-pcm.boostVector());
	}
	else if(_initialBoost==1) {
	// first the transverse boost
	Energy pT = sqrt(sqr(pcm.x())+sqr(pcm.y()));
	double beta = -pT/pcm.t();
	toRest=LorentzRotation(Boost(betapcm.x()/pT,betapcm.y()/pT,0.));
	// the longitudinal
	beta = pcm.z()/sqrt(pcm.m2()+sqr(pcm.z()));
	toRest.boost(Boost(0.,0.,-beta));
	}
	else
	assert(false);
	fromRest = LorentzRotation((jets[0]->showerMomentum()+
	jets[1]->showerMomentum()).boostVector());
	}

	void QTildeReconstructor::
	deconstructFinalStateSystem(const LorentzRotation & toRest,
	const LorentzRotation & fromRest,
	HardTreePtr tree, vector<HardBranchingPtr> jets,
	cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	LorentzRotation trans = toRest;
	if(jets.size()==1) {
	Lorentz5Momentum pnew = toRest*(jets[0]->branchingParticle()->momentum());
	pnew *= fromRest;
	jets[0]-> original(pnew);
	jets[0]->showerMomentum(pnew);
	// find the colour partners
	ShowerParticleVector particles;
	vector<Lorentz5Momentum> ptemp;
	set<HardBranchingPtr>::const_iterator cjt;
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	ptemp.push_back((**cjt).branchingParticle()->momentum());
	(cjt).branchingParticle()->set5Momentum((cjt).showerMomentum());
	particles.push_back((**cjt).branchingParticle());
	}
	evolver->showerModel()->partnerFinder()
	->setInitialEvolutionScales(particles,false,type,false);
	// calculate the reference vectors
	unsigned int iloc(0);
	set<HardBranchingPtr>::iterator clt;
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	// reset the momentum
	(**cjt).branchingParticle()->set5Momentum(ptemp[iloc]);
	++iloc;
	// sort out the partners
	tShowerParticlePtr partner =
	(*cjt)->branchingParticle()->partner();
	if(!partner) continue;
	for(clt=tree->branchings().begin();clt!=tree->branchings().end();++clt) {
	if((**clt).branchingParticle()==partner) {
	(*cjt).colourPartner(clt);
	break;
	}
	}
	tHardBranchingPtr branch;
	for(clt=tree->branchings().begin();clt!=tree->branchings().end();++clt) {
	if(clt==cjt) continue;
	if((*clt)->branchingParticle()==partner) {
	branch=*clt;
	break;
	}
	}
	}
	return;
	}
	vector<HardBranchingPtr>::iterator cit;
	vector<Lorentz5Momentum> pout;
	vector<Energy> mon;
	Lorentz5Momentum pin;
	for(cit=jets.begin();cit!=jets.end();++cit) {
	pout.push_back((*cit)->branchingParticle()->momentum());
	mon.push_back(findMass(*cit));
	pin+=pout.back();
	}
	// boost all the momenta to the rest frame of the decaying particle
	pin.rescaleMass();
	pin *=trans;
	Boost beta_cm = pin.findBoostToCM();
	bool gottaBoost(false);
	if(beta_cm.mag() > 1e-12) {
	gottaBoost = true;
	trans.boost(beta_cm);
	pin.boost(beta_cm);
	}
	for(unsigned int ix=0;ix<pout.size();++ix) {
	pout[ix].transform(trans);
	}
	// rescaling factor
	double lambda=inverseRescalingFactor(pout,mon,pin.mass());
	if (lambda< 1.e-10) throw KinematicsReconstructionVeto();
	// now calculate the p reference vectors
	for(unsigned int ix=0;ix<jets.size();++ix) {
	Lorentz5Momentum pvect = jets[ix]->branchingParticle()->momentum();
	pvect.transform(trans);
	pvect /= lambda;
	pvect.setMass(mon[ix]);
	pvect.rescaleEnergy();
	if(gottaBoost) pvect.boost(-beta_cm);
	pvect.transform(fromRest);
	jets[ix]->pVector(pvect);
	jets[ix]->showerMomentum(pvect);
	}
	// find the colour partners
	ShowerParticleVector particles;
	vector<Lorentz5Momentum> ptemp;
	set<HardBranchingPtr>::const_iterator cjt;
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	ptemp.push_back((**cjt).branchingParticle()->momentum());
	(cjt).branchingParticle()->set5Momentum((cjt).showerMomentum());
	particles.push_back((**cjt).branchingParticle());
	}
	evolver->showerModel()->partnerFinder()
	->setInitialEvolutionScales(particles,false,type,false);
	// calculate the reference vectors
	unsigned int iloc(0);
	set<HardBranchingPtr>::iterator clt;
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	// reset the momentum
	(**cjt).branchingParticle()->set5Momentum(ptemp[iloc]);
	++iloc;
	}
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	// sort out the partners
	tShowerParticlePtr partner =
	(*cjt)->branchingParticle()->partner();
	if(!partner) continue;
	for(clt=tree->branchings().begin();clt!=tree->branchings().end();++clt) {
	if((**clt).branchingParticle()==partner) {
	(*cjt).colourPartner(clt);
	break;
	}
	}
	tHardBranchingPtr branch;
	for(clt=tree->branchings().begin();clt!=tree->branchings().end();++clt) {
	if(clt==cjt) continue;
	if((*clt)->branchingParticle()==partner) {
	branch=*clt;
	break;
	}
	}
	// compute the reference vectors
	// both incoming, should all ready be done
	if((**cjt).status()==HardBranching::Incoming &&
	(**clt).status()==HardBranching::Incoming) {
	continue;
	}
	// both outgoing
	else if((**cjt).status()!=HardBranching::Incoming&&
	branch->status()==HardBranching::Outgoing) {
	Boost boost=((*cjt)->pVector()+branch->pVector()).findBoostToCM();
	Lorentz5Momentum pcm = branch->pVector();
	pcm.boost(boost);
	Lorentz5Momentum nvect = Lorentz5Momentum(ZERO,pcm.vect());
	nvect.boost( -boost);
	(**cjt).nVector(nvect);
	}
	else if((**cjt).status()==HardBranching::Incoming) {
	Lorentz5Momentum pa = -(**cjt).showerMomentum()+branch->showerMomentum();
	Lorentz5Momentum pb = (**cjt).showerMomentum();
	Axis axis(pa.vect().unit());
	LorentzRotation rot;
	double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
	rot.setRotate(-acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
	rot.rotateX(Constants::pi);
	rot.boostZ( pa.e()/pa.vect().mag());
	pb*=rot;
	Boost trans = -1./pb.e()*pb.vect();
	trans.setZ(0.);
	rot.boost(trans);
	Energy scale=(**cjt).beam()->momentum().e();
	Lorentz5Momentum pbasis(ZERO,(*cjt).beam()->momentum().vect().unit()scale);
	Lorentz5Momentum pcm = rot*pbasis;
	rot.invert();
	(*cjt).nVector(rotLorentz5Momentum(ZERO,-pcm.vect()));
	tHardBranchingPtr branch2 = *cjt;;
	while (branch2->parent()) {
	branch2=branch2->parent();
	branch2->nVector(rot*Lorentz5Momentum(ZERO,-pcm.vect()));
	}
	}
	else if(branch->status()==HardBranching::Incoming) {
	(**cjt).nVector(Lorentz5Momentum(ZERO,branch->showerMomentum().vect()));
	}
	}
	// now compute the new momenta
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	if(!(*cjt)->branchingParticle()->isFinalState()) continue;
	Lorentz5Momentum qnew;
	if((*cjt)->branchingParticle()->partner()) {
	Energy2 dot=(cjt)->pVector()(*cjt)->nVector();
	double beta = 0.5((cjt)->branchingParticle()->momentum().m2()
	-sqr((*cjt)->pVector().mass()))/dot;
	qnew=(cjt)->pVector()+beta(*cjt)->nVector();
	qnew.rescaleMass();
	}
	else {
	qnew = (*cjt)->pVector();
	}
	// qnew is the unshuffled momentum in the rest frame of the p basis vectors,
	// for the simple case Z->q qbar g this was checked against analytic formulae.
	// compute the boost
	LorentzRotation R=solveBoost(qnew,
	toRest(cjt)->branchingParticle()->momentum())*toRest;
	(*cjt)->setMomenta(R,1.0,Lorentz5Momentum());
	}
	}

	Energy QTildeReconstructor::momConsEq(const double & k,
	const Energy & root_s,
	const JetKinVect & jets) const {
	static const Energy2 eps=1e-8*GeV2;
	Energy dum = ZERO;
	for(JetKinVect::const_iterator it = jets.begin(); it != jets.end(); ++it) {
	Energy2 dum2 = (it->q).m2() + sqr(k)*(it->p).vect().mag2();
	if(dum2 < ZERO) {
	if(dum2 < -eps) throw KinematicsReconstructionVeto();
	dum2 = ZERO;
	}
	dum += sqrt(dum2);
	}
	return dum - root_s;
	}

	void QTildeReconstructor::boostChain(tPPtr p, const LorentzRotation &bv,
	tPPtr & parent) const {
	if(!p->parents().empty()) boostChain(p->parents()[0], bv,parent);
	else parent=p;
	p->transform(bv);
	if(p->children().size()==2) {
	if(dynamic_ptr_cast<ShowerParticlePtr>(p->children()[1]))
	deepTransform(p->children()[1],bv);
	}
	}

	namespace {

	bool sortJets(ShowerProgenitorPtr j1, ShowerProgenitorPtr j2) {
	return j1->highestpT()>j2->highestpT();
	}

	}

	void QTildeReconstructor::
	reconstructGeneralSystem(vector<ShowerProgenitorPtr> & ShowerHardJets) const {
	// find initial- and final-state systems
	ColourSingletSystem in,out;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if(ShowerHardJets[ix]->progenitor()->isFinalState())
	out.jets.push_back(ShowerHardJets[ix]);
	else
	in.jets.push_back(ShowerHardJets[ix]);
	}
	// reconstruct initial-initial system
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	// reconstruct initial-initial system
	reconstructInitialInitialSystem(applyBoost,toRest,fromRest,in.jets);
	// reconstruct the final-state systems
	reconstructFinalStateSystem(applyBoost,toRest,fromRest,out.jets);
	}


	void QTildeReconstructor::
	reconstructFinalFirst(vector<ShowerProgenitorPtr> & ShowerHardJets) const {
	static const Energy2 minQ2 = 1e-4*GeV2;
	map<ShowerProgenitorPtr,bool> used;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	used[ShowerHardJets[ix]] = false;
	} // first to the final-state reconstruction of any systems which need it
	set<ShowerProgenitorPtr> outgoing;
	// first find any particles with final state partners
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if(ShowerHardJets[ix]->progenitor()->isFinalState()&&
	ShowerHardJets[ix]->progenitor()->partner()&&
	ShowerHardJets[ix]->progenitor()->partner()->isFinalState()) outgoing.insert(ShowerHardJets[ix]);
	}
	// then find the colour partners
	if(!outgoing.empty()) {
	set<ShowerProgenitorPtr> partners;
	for(set<ShowerProgenitorPtr>::const_iterator it=outgoing.begin();it!=outgoing.end();++it) {
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if((**it).progenitor()->partner()==ShowerHardJets[ix]->progenitor()) {
	partners.insert(ShowerHardJets[ix]);
	break;
	}
	}
	}
	outgoing.insert(partners.begin(),partners.end());
	}
	// do the final-state reconstruction if needed
	if(!outgoing.empty()) {
	assert(outgoing.size()!=1);
	LorentzRotation toRest,fromRest;
	vector<ShowerProgenitorPtr> outgoingJets(outgoing.begin(),outgoing.end());
	reconstructFinalStateSystem(false,toRest,fromRest,outgoingJets);
	}
	// Now do any initial-final systems which are needed
	vector<ColourSingletSystem> IFSystems;
	// find the systems N.B. can have duplicates
	// find initial-state with FS partners or FS with IS partners
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if(!ShowerHardJets[ix]->progenitor()->isFinalState()&&
	ShowerHardJets[ix]->progenitor()->partner()&&
	ShowerHardJets[ix]->progenitor()->partner()->isFinalState()) {
	IFSystems.push_back(ColourSingletSystem(IF,ShowerHardJets[ix]));
	}
	else if(ShowerHardJets[ix]->progenitor()->isFinalState()&&
	ShowerHardJets[ix]->progenitor()->partner()&&
	!ShowerHardJets[ix]->progenitor()->partner()->isFinalState()) {
	IFSystems.push_back(ColourSingletSystem(IF,ShowerHardJets[ix]));
	}
	}
	// then add the partners
	for(unsigned int is=0;is<IFSystems.size();++is) {
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if(IFSystems[is].jets[0]->progenitor()->partner()==ShowerHardJets[ix]->progenitor()) {
	IFSystems[is].jets.push_back(ShowerHardJets[ix]);
	}
	}
	// ensure incoming first
	if(IFSystems[is].jets[0]->progenitor()->isFinalState())
	swap(IFSystems[is].jets[0],IFSystems[is].jets[1]);
	}
	if(!IFSystems.empty()) {
	unsigned int istart = UseRandom::irnd(IFSystems.size());
	unsigned int istop=IFSystems.size();
	for(unsigned int is=istart;is<=istop;++is) {
	if(is==IFSystems.size()) {
	if(istart!=0) {
	istop = istart-1;
	is=0;
	}
	else break;
	}
	// skip duplicates
	if(used[IFSystems[is].jets[0]] &&
	used[IFSystems[is].jets[1]] ) continue;
	if(IFSystems[is].jets[0]->original()&&IFSystems[is].jets[0]->original()->parents().empty()) continue;
	Lorentz5Momentum psum;
	for(unsigned int ix=0;ix<IFSystems[is].jets.size();++ix) {
	if(IFSystems[is].jets[ix]->progenitor()->isFinalState())
	psum += IFSystems[is].jets[ix]->progenitor()->momentum();
	else
	psum -= IFSystems[is].jets[ix]->progenitor()->momentum();
	}
	if(-psum.m2()>minQ2) {
	reconstructInitialFinalSystem(IFSystems[is].jets);
	for(unsigned int ix=0;ix<IFSystems[is].jets.size();++ix) {
	used[IFSystems[is].jets[ix]] = true;
	}
	}
	}
	}
	// now we finally need to handle the initial state system
	ColourSingletSystem in,out;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	if(ShowerHardJets[ix]->progenitor()->isFinalState())
	out.jets.push_back(ShowerHardJets[ix]);
	else
	in.jets.push_back(ShowerHardJets[ix]);
	}
	// reconstruct initial-initial system
	bool doRecon = false;
	for(unsigned int ix=0;ix<in.jets.size();++ix) {
	if(!used[in.jets[ix]]) {
	doRecon = true;
	break;
	}
	}
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	if(doRecon) {
	reconstructInitialInitialSystem(applyBoost,toRest,fromRest,in.jets);
	}
	// reconstruct the final-state systems
	if(!doRecon) {
	for(unsigned int ix=0;ix<out.jets.size();++ix) {
	if(!used[out.jets[ix]]) {
	doRecon = true;
	break;
	}
	}
	}
	if(doRecon) {
	reconstructFinalStateSystem(applyBoost,toRest,fromRest,out.jets);
	}
	}

	void QTildeReconstructor::
	reconstructColourPartner(vector<ShowerProgenitorPtr> & ShowerHardJets) const {
	static const Energy2 minQ2 = 1e-4*GeV2;
	// sort the vector by hardness of emission
	std::sort(ShowerHardJets.begin(),ShowerHardJets.end(),sortJets);
	// map between particles and progenitors for easy lookup
	map<ShowerParticlePtr,ShowerProgenitorPtr> progenitorMap;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	progenitorMap[ShowerHardJets[ix]->progenitor()] = ShowerHardJets[ix];
	}
	// check that the IF systems can be reconstructed
	bool canReconstruct = true;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	tShowerParticlePtr progenitor = ShowerHardJets[ix]->progenitor();
	tShowerParticlePtr partner = progenitor->partner();
	if(!partner) continue;
	else if((progenitor->isFinalState() &&
	!partner->isFinalState()) \|\|
	(!progenitor->isFinalState() &&
	partner->isFinalState()) ) {
	vector<ShowerProgenitorPtr> jets(2);
	jets[0] = ShowerHardJets[ix];
	jets[1] = progenitorMap[partner];
	Lorentz5Momentum psum;
	for(unsigned int iy=0;iy<jets.size();++iy) {
	if(jets[iy]->progenitor()->isFinalState())
	psum += jets[iy]->progenitor()->momentum();
	else
	psum -= jets[iy]->progenitor()->momentum();
	}
	if(-psum.m2()<minQ2) {
	canReconstruct = false;
	break;
	}
	}
	}
	if(!canReconstruct) {
	reconstructGeneralSystem(ShowerHardJets);
	return;
	}
	map<ShowerProgenitorPtr,bool> used;
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	used[ShowerHardJets[ix]] = false;
	}
	for(unsigned int ix=0;ix<ShowerHardJets.size();++ix) {
	// skip jets which have already been handled
	if(ShowerHardJets[ix]->reconstructed()==ShowerProgenitor::done) continue;
	// already reconstructed
	if(used[ShowerHardJets[ix]]) continue;
	// no partner continue
	tShowerParticlePtr progenitor = ShowerHardJets[ix]->progenitor();
	tShowerParticlePtr partner = progenitor->partner();
	if(!partner) {
	// check if there's a daughter tree which also needs boosting
	Lorentz5Momentum porig = progenitor->momentum();
	map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> >::const_iterator tit;
	for(tit = _currentTree->treelinks().begin();
	tit != _currentTree->treelinks().end();++tit) {
	// if there is, boost it
	if(tit->second.first && tit->second.second==progenitor) {
	Lorentz5Momentum pnew = tit->first->incomingLines().begin()
	->first->progenitor()->momentum();
	pnew *= tit->first->transform();
	Lorentz5Momentum pdiff = porig-pnew;
	Energy2 test = sqr(pdiff.x()) + sqr(pdiff.y()) +
	sqr(pdiff.z()) + sqr(pdiff.t());
	LorentzRotation rot;
	if(test>1e-6*GeV2) rot = solveBoost(porig,pnew);
	tit->first->transform(rot,false);
	_treeBoosts[tit->first].push_back(rot);
	}
	}
	ShowerHardJets[ix]->reconstructed(ShowerProgenitor::done);
	continue;
	}
	// do the reconstruction
	// final-final
	if(progenitor->isFinalState() &&
	partner->isFinalState() ) {
	LorentzRotation toRest,fromRest;
	vector<ShowerProgenitorPtr> jets(2);
	jets[0] = ShowerHardJets[ix];
	jets[1] = progenitorMap[partner];
	if(_reconopt==4 && jets[1]->reconstructed()==ShowerProgenitor::notReconstructed)
	jets[1]->reconstructed(ShowerProgenitor::dontReconstruct);
	reconstructFinalStateSystem(false,toRest,fromRest,jets);
	if(_reconopt==4 && jets[1]->reconstructed()==ShowerProgenitor::dontReconstruct)
	jets[1]->reconstructed(ShowerProgenitor::notReconstructed);
	used[jets[0]] = true;
	if(_reconopt==3) used[jets[1]] = true;
	}
	// initial-final
	else if((progenitor->isFinalState() &&
	!partner->isFinalState()) \|\|
	(!progenitor->isFinalState() &&
	partner->isFinalState()) ) {
	vector<ShowerProgenitorPtr> jets(2);
	jets[0] = ShowerHardJets[ix];
	jets[1] = progenitorMap[partner];
	if(jets[0]->progenitor()->isFinalState()) swap(jets[0],jets[1]);
	if(jets[0]->original()&&jets[0]->original()->parents().empty()) continue;
	Lorentz5Momentum psum;
	for(unsigned int iy=0;iy<jets.size();++iy) {
	if(jets[iy]->progenitor()->isFinalState())
	psum += jets[iy]->progenitor()->momentum();
	else
	psum -= jets[iy]->progenitor()->momentum();
	}
	if(_reconopt==4 && progenitorMap[partner]->reconstructed()==ShowerProgenitor::notReconstructed)
	progenitorMap[partner]->reconstructed(ShowerProgenitor::dontReconstruct);
	reconstructInitialFinalSystem(jets);
	if(_reconopt==4 && progenitorMap[partner]->reconstructed()==ShowerProgenitor::dontReconstruct)
	progenitorMap[partner]->reconstructed(ShowerProgenitor::notReconstructed);
	used[ShowerHardJets[ix]] = true;
	if(_reconopt==3) used[progenitorMap[partner]] = true;
	}
	// initial-initial
	else if(!progenitor->isFinalState() &&
	!partner->isFinalState() ) {
	ColourSingletSystem in,out;
	in.jets.push_back(ShowerHardJets[ix]);
	in.jets.push_back(progenitorMap[partner]);
	for(unsigned int iy=0;iy<ShowerHardJets.size();++iy) {
	if(ShowerHardJets[iy]->progenitor()->isFinalState())
	out.jets.push_back(ShowerHardJets[iy]);
	}
	LorentzRotation toRest,fromRest;
	bool applyBoost(false);
	if(_reconopt==4 && in.jets[1]->reconstructed()==ShowerProgenitor::notReconstructed)
	in.jets[1]->reconstructed(ShowerProgenitor::dontReconstruct);
	reconstructInitialInitialSystem(applyBoost,toRest,fromRest,in.jets);
	if(_reconopt==4 && in.jets[1]->reconstructed()==ShowerProgenitor::dontReconstruct)
	in.jets[1]->reconstructed(ShowerProgenitor::notReconstructed);
	used[in.jets[0]] = true;
	if(_reconopt==3) used[in.jets[1]] = true;
	for(unsigned int iy=0;iy<out.jets.size();++iy) {
	if(out.jets[iy]->reconstructed()==ShowerProgenitor::notReconstructed)
	out.jets[iy]->reconstructed(ShowerProgenitor::dontReconstruct);
	}
	// reconstruct the final-state systems
	LorentzRotation finalBoosts;
	finalBoosts.transform( toRest);
	finalBoosts.transform(fromRest);
	for(unsigned int iy=0;iy<out.jets.size();++iy) {
	deepTransform(out.jets[iy]->progenitor(),finalBoosts);
	}
	for(unsigned int iy=0;iy<out.jets.size();++iy) {
	if(out.jets[iy]->reconstructed()==ShowerProgenitor::dontReconstruct)
	out.jets[iy]->reconstructed(ShowerProgenitor::notReconstructed);
	}
	}
	}
	}

	bool QTildeReconstructor::
	inverseDecayRescalingFactor(vector<Lorentz5Momentum> pout,
	vector<Energy> mon,Energy roots,
	Lorentz5Momentum ppartner, Energy mbar,
	double & k1, double & k2) const {
	ThreeVector<Energy> qtotal;
	vector<Energy2> pmag;
	for(unsigned int ix=0;ix<pout.size();++ix) {
	pmag.push_back(pout[ix].vect().mag2());
	qtotal+=pout[ix].vect();
	}
	Energy2 dot1 = qtotal*ppartner.vect();
	Energy2 qmag2=qtotal.mag2();
	double a = -dot1/qmag2;
	static const Energy eps=1e-10*GeV;
	unsigned int itry(0);
	Energy numer(ZERO),denom(ZERO);
	k1=1.;
	do {
	++itry;
	numer=denom=0.*GeV;
	double k12=sqr(k1);
	for(unsigned int ix=0;ix<pout.size();++ix) {
	Energy en = sqrt(pmag[ix]/k12+sqr(mon[ix]));
	numer += en;
	denom += pmag[ix]/en;
	}
	Energy en = sqrt(qmag2/k12+sqr(mbar));
	numer += en-roots;
	denom += qmag2/en;
	k1 += numer/denomk12k1;
	if(abs(k1)>1e10) return false;
	}
	while (abs(numer)>eps&&itry<100);
	k1 = abs(k1);
	k2 = a*k1;
	return itry<100;
	}

	void QTildeReconstructor::
	deconstructInitialFinalSystem(HardTreePtr tree,vector<HardBranchingPtr> jets,
	cEvolverPtr evolver,
	ShowerInteraction::Type type) const {
	HardBranchingPtr incoming;
	Lorentz5Momentum pin[2],pout[2],pbeam;
	HardBranchingPtr initial;
	Energy mc(ZERO);
	for(unsigned int ix=0;ix<jets.size();++ix) {
	// final-state parton
	if(jets[ix]->status()==HardBranching::Outgoing) {
	pout[0] += jets[ix]->branchingParticle()->momentum();
	mc = jets[ix]->branchingParticle()->thePEGBase() ?
	jets[ix]->branchingParticle()->thePEGBase()->mass() :
	jets[ix]->branchingParticle()->dataPtr()->mass();
	}
	// initial-state parton
	else {
	pin[0] += jets[ix]->branchingParticle()->momentum();
	initial = jets[ix];
	pbeam = jets[ix]->beam()->momentum();
	Energy scale=pbeam.t();
	pbeam = Lorentz5Momentum(ZERO,pbeam.vect().unit()*scale);
	incoming = jets[ix];
	while(incoming->parent()) incoming = incoming->parent();
	}
	}
	if(jets.size()>2) {
	pout[0].rescaleMass();
	mc = pout[0].mass();
	}
	// work out the boost to the Breit frame
	Lorentz5Momentum pa = pout[0]-pin[0];
	Axis axis(pa.vect().unit());
	LorentzRotation rot;
	double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
	if(axis.perp2()>0.) {
	rot.setRotate(-acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
	rot.rotateX(Constants::pi);
	rot.boostZ( pa.e()/pa.vect().mag());
	}
	// transverse part
	Lorentz5Momentum paxis=rot*pbeam;
	Boost trans = -1./paxis.e()*paxis.vect();
	trans.setZ(0.);
	rot.boost(trans);
	pa *= rot;
	// reference vectors
	Lorentz5Momentum n1(ZERO,ZERO,-pa.z(),-pa.z());
	Lorentz5Momentum n2(ZERO,ZERO, pa.z(),-pa.z());
	Energy2 n1n2 = n1*n2;
	// decompose the momenta
	Lorentz5Momentum qbp=rotpin[0],qcp= rotpout[0];
	double a[2],b[2];
	a[0] = n2*qbp/n1n2;
	b[0] = n1*qbp/n1n2;
	a[1] = n2*qcp/n1n2;
	b[1] = n1*qcp/n1n2;
	Lorentz5Momentum qperp = qbp-a[0]n1-b[0]n2;
	// before reshuffling
	Energy Q = abs(pa.z());
	double c = sqr(mc/Q);
	Lorentz5Momentum pb(ZERO,ZERO,0.5Q(1.+c),0.5Q(1.+c));
	Lorentz5Momentum pc(ZERO,ZERO,0.5Q(c-1.),0.5Q(1.+c));
	double anew[2],bnew[2];
	anew[0] = pb*n2/n1n2;
	bnew[0] = 0.5*(qbp.m2()-qperp.m2())/n1n2/anew[0];
	bnew[1] = pc*n1/n1n2;
	anew[1] = 0.5*qcp.m2()/bnew[1]/n1n2;
	Lorentz5Momentum qnewb = (anew[0]n1+bnew[0]n2+qperp);
	Lorentz5Momentum qnewc = (anew[1]n1+bnew[1]n2);
	// initial-state boost
	LorentzRotation rotinv=rot.inverse();
	LorentzRotation transb=rotinvsolveBoostZ(qnewb,qbp)rot;
	// final-state boost
	LorentzRotation transc=rotinvsolveBoost(qnewc,qcp)rot;
	// this will need changing for more than one outgoing particle
	// set the pvectors
	for(unsigned int ix=0;ix<jets.size();++ix) {
	if(jets[ix]->status()==HardBranching::Incoming) {
	jets[ix]->pVector(pbeam);
	jets[ix]->showerMomentum(rotinv*pb);
	incoming->pVector(jets[ix]->pVector());
	}
	else {
	jets[ix]->pVector(rotinv*pc);
	jets[ix]->showerMomentum(jets[ix]->pVector());
	}
	}
	// find the colour partners
	ShowerParticleVector particles;
	vector<Lorentz5Momentum> ptemp;
	set<HardBranchingPtr>::const_iterator cjt;
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	ptemp.push_back((**cjt).branchingParticle()->momentum());
	(cjt).branchingParticle()->set5Momentum((cjt).showerMomentum());
	particles.push_back((**cjt).branchingParticle());
	}
	evolver->showerModel()->partnerFinder()
	->setInitialEvolutionScales(particles,false,type,false);
	unsigned int iloc(0);
	for(cjt=tree->branchings().begin();cjt!=tree->branchings().end();++cjt) {
	// reset the momentum
	(**cjt).branchingParticle()->set5Momentum(ptemp[iloc]);
	++iloc;
	}
	for(vector<HardBranchingPtr>::const_iterator cjt=jets.begin();
	cjt!=jets.end();++cjt) {
	// sort out the partners
	tShowerParticlePtr partner =
	(*cjt)->branchingParticle()->partner();
	if(!partner) continue;
	tHardBranchingPtr branch;
	for(set<HardBranchingPtr>::const_iterator
	clt=tree->branchings().begin();clt!=tree->branchings().end();++clt) {
	if((**clt).branchingParticle()==partner) {
	(*cjt).colourPartner(clt);
	branch=*clt;
	break;
	}
	}
	// compute the reference vectors
	// both incoming, should all ready be done
	if((**cjt).status()==HardBranching::Incoming &&
	branch->status()==HardBranching::Incoming) {
	Energy etemp = (*cjt)->beam()->momentum().z();
	Lorentz5Momentum nvect(ZERO, ZERO,-etemp, abs(etemp));
	tHardBranchingPtr branch2 = *cjt;
	(**cjt).nVector(nvect);
	while (branch2->parent()) {
	branch2=branch2->parent();
	branch2->nVector(nvect);
	}
	}
	// both outgoing
	else if((**cjt).status()==HardBranching::Outgoing&&
	branch->status()==HardBranching::Outgoing) {
	Boost boost=((*cjt)->pVector()+branch->pVector()).findBoostToCM();
	Lorentz5Momentum pcm = branch->pVector();
	pcm.boost(boost);
	Lorentz5Momentum nvect = Lorentz5Momentum(ZERO,pcm.vect());
	nvect.boost( -boost);
	(**cjt).nVector(nvect);
	}
	else if((**cjt).status()==HardBranching::Incoming) {
	Lorentz5Momentum pa = -(**cjt).showerMomentum()+branch->showerMomentum();
	Lorentz5Momentum pb = (**cjt).showerMomentum();
	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;
	Boost trans = -1./pb.e()*pb.vect();
	trans.setZ(0.);
	rot.boost(trans);
	Energy scale=(**cjt).beam()->momentum().t();
	Lorentz5Momentum pbasis(ZERO,(*cjt).beam()->momentum().vect().unit()scale);
	Lorentz5Momentum pcm = rot*pbasis;
	rot.invert();
	Lorentz5Momentum nvect = rot*Lorentz5Momentum(ZERO,-pcm.vect());
	(**cjt).nVector(nvect);
	tHardBranchingPtr branch2 = *cjt;
	while (branch2->parent()) {
	branch2=branch2->parent();
	branch2->nVector(nvect);
	}
	}
	else if(branch->status()==HardBranching::Incoming) {
	Lorentz5Momentum nvect=Lorentz5Momentum(ZERO,branch->showerMomentum().vect());
	(**cjt).nVector(nvect);
	}
	}
	// now compute the new momenta
	for(vector<HardBranchingPtr>::const_iterator cjt=jets.begin();
	cjt!=jets.end();++cjt) {
	if((**cjt).status()==HardBranching::Outgoing) {
	(**cjt).setMomenta(transc,1.,Lorentz5Momentum());
	}
	}
	incoming->setMomenta(transb,1.,Lorentz5Momentum());
	}

	void QTildeReconstructor::deepTransform(PPtr particle,
	const LorentzRotation & r,
	bool match,
	PPtr original) const {
	if(_boosts.find(particle)!=_boosts.end()) {
	_boosts[particle].push_back(r);
	}
	Lorentz5Momentum porig = particle->momentum();
	if(!original) original = particle;
	for ( int i = 0, N = particle->children().size(); i < N; ++i ) {
	deepTransform(particle->children()[i],r,
	particle->children()[i]->id()==original->id()&&match,original);
	}
	particle->transform(r);
	// transform the p and n vectors
	ShowerParticlePtr sparticle = dynamic_ptr_cast<ShowerParticlePtr>(particle);
	- if(sparticle && sparticle->showerKinematics()) {
	- sparticle->showerKinematics()->transform(r);
	+ if(sparticle && sparticle->showerBasis()) {
	+ sparticle->showerBasis()->transform(r);
	}
	if ( particle->next() ) deepTransform(particle->next(),r,match,original);
	if(!match) return;
	if(!particle->children().empty()) return;
	// force the mass shell
	if(particle->dataPtr()->stable()) {
	Lorentz5Momentum ptemp = particle->momentum();
	ptemp.rescaleEnergy();
	particle->set5Momentum(ptemp);
	}
	// check if there's a daughter tree which also needs boosting
	map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> >::const_iterator tit;
	for(tit = _currentTree->treelinks().begin();
	tit != _currentTree->treelinks().end();++tit) {
	// if there is, boost it
	if(tit->second.first && tit->second.second==original) {
	Lorentz5Momentum pnew = tit->first->incomingLines().begin()
	->first->progenitor()->momentum();
	pnew *= tit->first->transform();
	Lorentz5Momentum pdiff = porig-pnew;
	Energy2 test = sqr(pdiff.x()) + sqr(pdiff.y()) +
	sqr(pdiff.z()) + sqr(pdiff.t());
	LorentzRotation rot;
	if(test>1e-6*GeV2) rot = solveBoost(porig,pnew);
	tit->first->transform(r*rot,false);
	_treeBoosts[tit->first].push_back(r*rot);
	}
	}
	}

	void QTildeReconstructor::reconstructFinalFinalOffShell(JetKinVect orderedJets,
	Energy2 s,
	bool recursive) const {
	JetKinVect::iterator jit;
	jit = orderedJets.begin(); ++jit;
	// 4-momentum of recoiling system
	Lorentz5Momentum psum;
	for( ; jit!=orderedJets.end(); ++jit) psum += jit->p;
	psum.rescaleMass();
	// calculate the 3-momentum rescaling factor
	Energy2 m1sq(orderedJets.begin()->q.m2()),m2sq(psum.m2());
	Energy4 num = sqr(s - m1sq - m2sq) - 4.m1sqm2sq;
	if(num<ZERO) throw KinematicsReconstructionVeto();
	double k = sqrt( num / (4.sorderedJets.begin()->p.vect().mag2()) );
	// boost the most off-shell
	LorentzRotation B1 = solveBoost(k, orderedJets.begin()->q, orderedJets.begin()->p);
	deepTransform(orderedJets.begin()->parent,B1);
	// boost everything else
	// first to rescale
	LorentzRotation B2 = solveBoost(k, psum, psum);
	// and then to rest frame of new system
	Lorentz5Momentum pnew = B2*psum;
	pnew.rescaleMass();
	B2.transform(pnew.findBoostToCM());
	// apply transform (calling routine ensures at least 3 elements)
	jit = orderedJets.begin(); ++jit;
	for(;jit!=orderedJets.end();++jit) {
	deepTransform(jit->parent,B2);
	jit->p *= B2;
	jit->q *= B2;
	}
	JetKinVect newJets(orderedJets.begin()+1,orderedJets.end());
	// final reconstruction
	if(newJets.size()==2 \|\| !recursive ) {
	// rescaling factor
	double k = solveKfactor(psum.m(), newJets);
	// rescale jets in the new CMF
	for(JetKinVect::iterator it = newJets.begin(); it != newJets.end(); ++it) {
	LorentzRotation Trafo = solveBoost(k, it->q, it->p);
	deepTransform(it->parent,Trafo);
	}
	}
	// recursive
	else {
	std::sort(newJets.begin(),newJets.end(),JetOrdering());
	reconstructFinalFinalOffShell(newJets,psum.m2(),recursive);
	}
	// finally boost back from new CMF
	LorentzRotation back(-pnew.findBoostToCM());
	for(JetKinVect::iterator it = newJets.begin(); it != newJets.end(); ++it) {
	deepTransform(it->parent,back);
	}
	}

	Energy QTildeReconstructor::findMass(HardBranchingPtr branch) const {
	// KH - 230909 - If the particle has no children then it will
	// not have showered and so it should be "on-shell" so we can
	// get it's mass from it's momentum. This means that the
	// inverseRescalingFactor doesn't give any nans or do things
	// it shouldn't if it gets e.g. two Z bosons generated with
	// off-shell masses. This is for sure not the best solution.
	// PR 1/1/10 modification to previous soln
	// PR 28/8/14 change to procedure and factorize into a function
	if(branch->children().empty()) {
	return branch->branchingParticle()->mass();
	}
	else if(!branch->children().empty() &&
	!branch->branchingParticle()->dataPtr()->stable() ) {
	for(unsigned int ix=0;ix<branch->children().size();++ix) {
	if(branch->branchingParticle()->id()==
	branch->children()[ix]->branchingParticle()->id())
	return findMass(branch->children()[ix]);
	}
	}
	return branch->branchingParticle()->dataPtr()->mass();
	}

	vector<double>
	QTildeReconstructor::inverseInitialStateRescaling(double & x1, double & x2,
	const Lorentz5Momentum & pold,
	const vector<Lorentz5Momentum> & p,
	const vector<Lorentz5Momentum> & pq) const {
	// hadronic CMS
	Energy2 s = (pq[0] +pq[1] ).m2();
	// partonic CMS
	Energy MDY = pold.m();
	// find alpha, beta and pt
	Energy2 p12=pq[0]*pq[1];
	double a[2],b[2];
	Lorentz5Momentum pt[2];
	for(unsigned int ix=0;ix<2;++ix) {
	a[ix] = p[ix]*pq[1]/p12;
	b [ix] = p[ix]*pq[0]/p12;
	pt[ix] = p[ix]-a[ix]pq[0]-b[ix]pq[1];
	}
	// compute kappa
	// we always want to preserve the mass of the system
	double k1(1.),k2(1.);
	if(_initialStateReconOption==0) {
	double rap=pold.rapidity();
	x2 = MDY/sqrt(sexp(2.rap));
	x1 = sqr(MDY)/s/x2;
	k1=a[0]/x1;
	k2=b[1]/x2;
	}
	// longitudinal momentum
	else if(_initialStateReconOption==1) {
	double A = 1.;
	double C = -sqr(MDY)/s;
	double B = 2.*pold.z()/sqrt(s);
	if(abs(B)>1e-10) {
	double discrim = 1.-4.AC/sqr(B);
	if(discrim < 0.) throw KinematicsReconstructionVeto();
	x1 = B>0. ? 0.5B/A(1.+sqrt(discrim)) : 0.5B/A(1.-sqrt(discrim));
	}
	else {
	x1 = -C/A;
	if( x1 <= 0.) throw KinematicsReconstructionVeto();
	x1 = sqrt(x1);
	}
	x2 = sqr(MDY)/s/x1;
	k1=a[0]/x1;
	k2=b[1]/x2;
	}
	// preserve mass and don't scale the softer system
	// to reproduce the dipole kinematics
	else if(_initialStateReconOption==2) {
	// in this case kp = k1 or k2 depending on who's the harder guy
	k1 = a[0]b[1]s/sqr(MDY);
	if ( pt[0].perp2() < pt[1].perp2() ) swap(k1,k2);
	x1 = a[0]/k1;
	x2 = b[1]/k2;
	}
	else
	assert(false);
	// decompose the momenta
	double anew[2] = {a[0]/k1,a[1]*k2};
	double bnew[2] = {b[0]*k1,b[1]/k2};
	vector<double> boost(2);
	for(unsigned int ix=0;ix<2;++ix) {
	boost[ix] = getBeta(a [ix]+b [ix], a[ix] -b [ix],
	anew[ix]+bnew[ix], anew[ix]-bnew[ix]);
	}
	return boost;
	}

	vector<double>
	QTildeReconstructor::initialStateRescaling(double x1, double x2,
	const Lorentz5Momentum & pold,
	const vector<Lorentz5Momentum> & p,
	const vector<Lorentz5Momentum> & pq,
	const vector<Energy>& highestpts) const {
	Energy2 S = (pq[0]+pq[1]).m2();
	// find alphas and betas in terms of desired basis
	Energy2 p12 = pq[0]*pq[1];
	double a[2] = {p[0]pq[1]/p12,p[1]pq[1]/p12};
	double b[2] = {p[0]pq[0]/p12,p[1]pq[0]/p12};
	Lorentz5Momentum p1p = p[0] - a[0]pq[0] - b[0]pq[1];
	Lorentz5Momentum p2p = p[1] - a[1]pq[0] - b[1]pq[1];
	// compute kappa
	// we always want to preserve the mass of the system
	Energy MDY = pold.m();
	Energy2 A = a[0]b[1]S;
	Energy2 B = Energy2(sqr(MDY)) - (a[0]b[0]+a[1]b[1])*S - (p1p+p2p).m2();
	Energy2 C = a[1]b[0]S;
	double rad = 1.-4.AC/sqr(B);
	if(rad < 0.) throw KinematicsReconstructionVeto();
	double kp = B/(2.A)(1.+sqrt(rad));
	// now compute k1
	// conserve rapidity
	double k1(0.);
	double k2(0.);
	if(_initialStateReconOption==0) {
	rad = kp(b[0]+kpb[1])/(kp*a[0]+a[1]);
	rad = pq[0].z()<ZERO ? exp(-2.pold.rapidity()) : exp(2.*pold.rapidity());
	if(rad <= 0.) throw KinematicsReconstructionVeto();
	k1 = sqrt(rad);
	k2 = kp/k1;
	}
	// conserve longitudinal momentum
	else if(_initialStateReconOption==1) {
	double a2 = (a[0]+a[1]/kp);
	double b2 = -x2+x1;
	double c2 = -(b[1]*kp+b[0]);
	if(abs(b2)>1e-10) {
	double discrim = 1.-4.a2c2/sqr(b2);
	if(discrim < 0.) throw KinematicsReconstructionVeto();
	k1 = b2>0. ? 0.5b2/a2(1.+sqrt(discrim)) : 0.5b2/a2(1.-sqrt(discrim));
	}
	else {
	k1 = -c2/a2;
	if( k1 <= 0.) throw KinematicsReconstructionVeto();
	k1 = sqrt(k1);
	}
	k2 = kp/k1;
	}
	// preserve mass and don't scale the softer system
	// to reproduce the dipole kinematics
	else if(_initialStateReconOption==2) {
	// in this case kp = k1 or k2 depending on who's the harder guy
	k1 = kp; k2 = 1.;
	if ( highestpts[0] < highestpts[1] )
	swap(k1,k2);
	}
	else
	assert(false);
	// calculate the boosts
	vector<double> beta(2);
	beta[0] = getBeta((a[0]+b[0]), (a[0]-b[0]), (k1a[0]+b[0]/k1), (k1a[0]-b[0]/k1));
	beta[1] = getBeta((a[1]+b[1]), (a[1]-b[1]), (a[1]/k2+k2b[1]), (a[1]/k2-k2b[1]));
	if (pq[0].z() > ZERO) {
	beta[0] = -beta[0];
	beta[1] = -beta[1];
	}
	return beta;
	}

	void QTildeReconstructor::
	reconstructColourSinglets(vector<ShowerProgenitorPtr> & ShowerHardJets,
	ShowerInteraction::Type type) const {
	// identify and catagorize the colour singlet systems
	unsigned int nnun(0),nnii(0),nnif(0),nnf(0),nni(0);
	vector<ColourSingletSystem>
	systems(identifySystems(set<ShowerProgenitorPtr>(ShowerHardJets.begin(),ShowerHardJets.end()),
	nnun,nnii,nnif,nnf,nni));
	// now decide what to do
	// initial-initial connection and final-state colour singlet systems
	LorentzRotation toRest,fromRest;
	bool applyBoost(false),general(false);
	// Drell-Yan type
	if(nnun==0&&nnii==1&&nnif==0&&nnf>0&&nni==0) {
	// reconstruct initial-initial system
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==II)
	reconstructInitialInitialSystem(applyBoost,toRest,fromRest,
	systems[ix].jets);
	}
	if(type!=ShowerInteraction::QCD) {
	combineFinalState(systems);
	general=false;
	}
	}
	// DIS and VBF type
	else if(nnun==0&&nnii==0&&((nnif==1&&nnf>0&&nni==1)\|\|
	(nnif==2&& nni==0))) {
	// check these systems can be reconstructed
	for(unsigned int ix=0;ix<systems.size();++ix) {
	// compute q^2
	if(systems[ix].type!=IF) continue;
	Lorentz5Momentum q;
	for(unsigned int iy=0;iy<systems[ix].jets.size();++iy) {
	if(systems[ix].jets[iy]->progenitor()->isFinalState())
	q += systems[ix].jets[iy]->progenitor()->momentum();
	else
	q -= systems[ix].jets[iy]->progenitor()->momentum();
	}
	q.rescaleMass();
	// check above cut
	if(abs(q.m())>=_minQ) continue;
	if(nnif==1&&nni==1) {
	throw KinematicsReconstructionVeto();
	}
	else {
	general = true;
	break;
	}
	}
	if(!general) {
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==IF)
	reconstructInitialFinalSystem(systems[ix].jets);
	}
	}
	}
	// e+e- type
	else if(nnun==0&&nnii==0&&nnif==0&&nnf>0&&nni==2) {
	general = type !=ShowerInteraction::QCD;
	}
	// general type
	else {
	general = true;
	}
	// final-state systems except for general recon
	if(!general) {
	for(unsigned int ix=0;ix<systems.size();++ix) {
	if(systems[ix].type==F)
	reconstructFinalStateSystem(applyBoost,toRest,fromRest,
	systems[ix].jets);
	}
	}
	else {
	reconstructGeneralSystem(ShowerHardJets);
	}
	}

	void QTildeReconstructor::findInitialBoost(const Lorentz5Momentum & pold,
	const Lorentz5Momentum & pnew,
	LorentzRotation & toRest,
	LorentzRotation & fromRest) const {
	// do one boost
	if(_initialBoost==0) {
	toRest = LorentzRotation(pold.findBoostToCM());
	fromRest = LorentzRotation(pnew.boostVector());
	}
	else if(_initialBoost==1) {
	// boost to rest frame
	// first transverse
	toRest = Boost(-pold.x()/pold.t(),-pold.y()/pold.t(),0.);
	// then longitudinal
	double beta = pold.z()/sqrt(pold.m2()+sqr(pold.z()));
	toRest.boost((Boost(0.,0.,-beta)));
	// boost from rest frame
	// first apply longitudinal boost
	beta = pnew.z()/sqrt(pnew.m2()+sqr(pnew.z()));
	fromRest=LorentzRotation(Boost(0.,0.,beta));
	// then transverse one
	fromRest.boost(Boost(pnew.x()/pnew.t(),
	pnew.y()/pnew.t(),0.));
	}
	else
	assert(false);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Dec 21, 6:26 PM (8 h, 2 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4013647
Default Alt Text: (294 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions