Page MenuHomeHEPForge
Files F10880972

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/Decay/Dalitz/DalitzKMatrix.h b/Decay/Dalitz/DalitzKMatrix.h
--- a/Decay/Dalitz/DalitzKMatrix.h
+++ b/Decay/Dalitz/DalitzKMatrix.h
@@ -1,145 +1,145 @@
// -*- C++ -*-
#ifndef Herwig_DalitzKMatrix_H
#define Herwig_DalitzKMatrix_H
//
// This is the declaration of the DalitzKMatrix class.
//
#include "DalitzResonance.h"
#include "Herwig/Decay/FormFactors/KMatrix.h"
namespace Herwig {
using namespace ThePEG;
/**
* The DalitzKMatrix class allows the use of \f$K\f$-matrices in Dalitz decays
*/
class DalitzKMatrix: public DalitzResonance {
public:
/**
* The default constructor.
*/
DalitzKMatrix()
{}
/**
* Constructor specifiying the parameters
*/
DalitzKMatrix(long pid, ResonanceType::Type rtype, Energy m, Energy w,
unsigned int d1, unsigned int d2, unsigned int s,
double mag, double phi, InvEnergy rr,
unsigned int imat, unsigned int chan,
Energy2 sc, unsigned int itype,
vector<pair<double,double> > beta,
vector<pair<double,vector<double > > > coeffs)
: DalitzResonance(pid,rtype,m,w,d1,d2,s,mag,phi,rr),
imat_(imat), channel_(chan), sc_(sc), expType_(itype), coeffs_(coeffs) {
beta_.clear();
for(unsigned int ix=0;ix<beta.size();++ix) {
beta_.push_back(beta[ix].first*exp(Complex(0.,beta[ix].second)));
}
}
public:
/**
* Return the Breit-Wigner times the form factor
*/
virtual Complex BreitWigner(const Energy & mAB, const Energy & mA, const Energy & mB) const;
/**
* Output the parameters
*/
virtual void dataBaseOutput(ofstream & output);
public:
/**
* Set the K-matrix
*/
void setKMatrix(KMatrixPtr mat) {kMatrix_ = mat;}
/**
* Location of the matrix
*/
unsigned int imatrix() const {return imat_;}
public:
/** @name Functions used by the persistent I/O system. */
//@{
/**
* Function used to write out object persistently.
* @param os the persistent output stream written to.
*/
void persistentOutput(PersistentOStream & os) const;
/**
* Function used to read in object persistently.
* @param is the persistent input stream read from.
* @param version the version number of the object when written.
*/
void persistentInput(PersistentIStream & is, int version);
//@}
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
DalitzKMatrix & operator=(const DalitzKMatrix &) = delete;
private:
/**
* The K-matrix for the channel
*/
KMatrixPtr kMatrix_;
/**
* Which \f$K-matrix\f$ to do
*/
- unsigned int imat_;
+ unsigned int imat_ = 0;
/**
* Which channel to use from the K-matrix
*/
- unsigned int channel_;
+ unsigned int channel_ = 0;
/**
* Expansion point for the constant terms
*/
- Energy2 sc_;
+ Energy2 sc_ = ZERO;
/**
* Coefficients of the poles
*/
vector<Complex> beta_;
/**
* Type of expansion
*/
- unsigned int expType_;
+ unsigned int expType_ = 0;
/**
* Coefficients for the series expansion
*/
vector<pair<double,vector<double > > > coeffs_;
};
}
#endif /* Herwig_DalitzKMatrix_H */
diff --git a/Hadronization/ClusterFissioner.cc b/Hadronization/ClusterFissioner.cc
--- a/Hadronization/ClusterFissioner.cc
+++ b/Hadronization/ClusterFissioner.cc
@@ -1,1672 +1,1672 @@
// -*- C++ -*-
//
// ClusterFissioner.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// Thisk is the implementation of the non-inlined, non-templated member
// functions of the ClusterFissioner class.
//
#include "ClusterFissioner.h"
#include <ThePEG/Interface/ClassDocumentation.h>
#include <ThePEG/Interface/Reference.h>
#include <ThePEG/Interface/Parameter.h>
#include <ThePEG/Interface/Switch.h>
#include <ThePEG/Persistency/PersistentOStream.h>
#include <ThePEG/Persistency/PersistentIStream.h>
#include <ThePEG/PDT/EnumParticles.h>
#include "Herwig/Utilities/Kinematics.h"
#include "Cluster.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Repository/EventGenerator.h"
#include <ThePEG/Utilities/DescribeClass.h>
#include "ThePEG/Interface/ParMap.h"
#include "Herwig/Utilities/AlphaS.h"
using namespace Herwig;
DescribeClass<ClusterFissioner,Interfaced>
describeClusterFissioner("Herwig::ClusterFissioner","Herwig.so");
ClusterFissioner::ClusterFissioner() :
_clMaxLight(3.35*GeV),
_clMaxDiquark(3.35*GeV),
_clMaxExotic(3.35*GeV),
_clPowLight(2.0),
_clPowDiquark(2.0),
_clPowExotic(2.0),
_pSplitLight(1.0),
_pSplitExotic(1.0),
_phaseSpaceWeights(0),
_dim(4),
_fissionCluster(0),
_kinematicThresholdChoice(0),
_pwtDIquark(0.0),
_diquarkClusterFission(0),
_btClM(1.0*GeV),
_iopRem(1),
_kappa(1.0e15*GeV/meter),
_enhanceSProb(0),
_m0Fission(2.*GeV),
_massMeasure(0),
_probPowFactor(4.0),
_probShift(0.0),
_kinThresholdShift(1.0*sqr(GeV)),
_strictDiquarkKinematics(0),
_covariantBoost(false),
_hadronizingStrangeDiquarks(2),
_writeOut(0)
{
}
ClusterFissioner::~ClusterFissioner(){
}
IBPtr ClusterFissioner::clone() const {
return new_ptr(*this);
}
IBPtr ClusterFissioner::fullclone() const {
return new_ptr(*this);
}
void ClusterFissioner::persistentOutput(PersistentOStream & os) const {
os << ounit(_clMaxLight,GeV) << ounit(_clMaxHeavy,GeV) << ounit(_clMaxDiquark,GeV) << ounit(_clMaxExotic,GeV)
<< _clPowLight << _clPowHeavy << _clPowDiquark << _clPowExotic
<< _pSplitLight << _pSplitHeavy << _pSplitExotic
<< _fissionCluster << _fissionPwt
<< _pwtDIquark
<< _diquarkClusterFission
<< ounit(_btClM,GeV)
<< _iopRem << ounit(_kappa, GeV/meter)
<< _enhanceSProb << ounit(_m0Fission,GeV) << _massMeasure
<< _dim << _phaseSpaceWeights
<< _hadronSpectrum << _kinematicThresholdChoice
<< _probPowFactor << _probShift << ounit(_kinThresholdShift,sqr(GeV))
<< _strictDiquarkKinematics
<< _covariantBoost
<< _hadronizingStrangeDiquarks
<< _writeOut
;
}
void ClusterFissioner::persistentInput(PersistentIStream & is, int) {
is >> iunit(_clMaxLight,GeV) >> iunit(_clMaxHeavy,GeV) >> iunit(_clMaxDiquark,GeV) >> iunit(_clMaxExotic,GeV)
>> _clPowLight >> _clPowHeavy >> _clPowDiquark >> _clPowExotic
>> _pSplitLight >> _pSplitHeavy >> _pSplitExotic
>> _fissionCluster >> _fissionPwt
>> _pwtDIquark
>> _diquarkClusterFission
>> iunit(_btClM,GeV)
>> _iopRem >> iunit(_kappa, GeV/meter)
>> _enhanceSProb >> iunit(_m0Fission,GeV) >> _massMeasure
>> _dim >> _phaseSpaceWeights
>> _hadronSpectrum >> _kinematicThresholdChoice
>> _probPowFactor >> _probShift >> iunit(_kinThresholdShift,sqr(GeV))
>> _strictDiquarkKinematics
>> _covariantBoost
>> _hadronizingStrangeDiquarks
>> _writeOut
;
}
void ClusterFissioner::doinit() {
Interfaced::doinit();
if (_writeOut){
std::ofstream out("data_CluFis.dat", std::ios::out);
out.close();
}
for ( const long& id : spectrum()->heavyHadronizingQuarks() ) {
if ( _pSplitHeavy.find(id) == _pSplitHeavy.end() ||
_clPowHeavy.find(id) == _clPowHeavy.end() ||
_clMaxHeavy.find(id) == _clMaxHeavy.end() ){
std::cout << "id = "<<id << std::endl;
throw InitException() << "not all parameters have been set for heavy quark cluster fission";
}
}
// for default Pwts not needed to initialize
if (_fissionCluster==0) return;
for ( const long& id : spectrum()->lightHadronizingQuarks() ) {
if ( _fissionPwt.find(id) == _fissionPwt.end() )
// check that all relevant weights are set
throw InitException() << "fission weights for light quarks have not been set";
}
double pwtDquark=_fissionPwt.find(ParticleID::d)->second;
double pwtUquark=_fissionPwt.find(ParticleID::u)->second;
double pwtSquark=_fissionPwt.find(ParticleID::s)->second;
// TODO better solution for this magic number alternative
_fissionPwt[1103] = _pwtDIquark * pwtDquark * pwtDquark;
_fissionPwt[2101] = 0.5 * _pwtDIquark * pwtUquark * pwtDquark;
_fissionPwt[2203] = _pwtDIquark * pwtUquark * pwtUquark;
if (_hadronizingStrangeDiquarks>0) {
_fissionPwt[3101] = 0.5 * _pwtDIquark * pwtSquark * pwtDquark;
_fissionPwt[3201] = 0.5 * _pwtDIquark * pwtSquark * pwtUquark;
if (_hadronizingStrangeDiquarks==2) {
_fissionPwt[3303] = _pwtDIquark* pwtSquark * pwtSquark;
}
}
}
void ClusterFissioner::Init() {
static ClassDocumentation<ClusterFissioner> documentation
("Class responsibles for chopping up the clusters");
static Reference<ClusterFissioner,HadronSpectrum> interfaceHadronSpectrum
("HadronSpectrum",
"Set the Hadron spectrum for this cluster fissioner.",
&ClusterFissioner::_hadronSpectrum, false, false, true, false);
// ClMax for light, Bottom, Charm and exotic (e.g. Susy) quarks
static Parameter<ClusterFissioner,Energy>
interfaceClMaxLight ("ClMaxLight","cluster max mass for light quarks (unit [GeV])",
&ClusterFissioner::_clMaxLight, GeV, 3.35*GeV, ZERO, 100.0*GeV,
false,false,false);
static Parameter<ClusterFissioner,Energy>
interfaceClMaxDiquark ("ClMaxDiquark","cluster max mass for light hadronizing diquarks (unit [GeV])",
&ClusterFissioner::_clMaxDiquark, GeV, 3.35*GeV, ZERO, 100.0*GeV,
false,false,false);
static ParMap<ClusterFissioner,Energy> interfaceClMaxHeavy
("ClMaxHeavy",
"ClMax for heavy quarks",
&ClusterFissioner::_clMaxHeavy, GeV, -1, 3.35*GeV, ZERO, 100.0*GeV,
false, false, Interface::upperlim);
static Parameter<ClusterFissioner,Energy>
interfaceClMaxExotic ("ClMaxExotic","cluster max mass for exotic quarks (unit [GeV])",
&ClusterFissioner::_clMaxExotic, GeV, 3.35*GeV, ZERO, 100.0*GeV,
false,false,false);
// ClPow for light, Bottom, Charm and exotic (e.g. Susy) quarks
static Parameter<ClusterFissioner,double>
interfaceClPowLight ("ClPowLight","cluster mass exponent for light quarks",
&ClusterFissioner::_clPowLight, 0, 2.0, 0.0, 10.0,false,false,false);
static ParMap<ClusterFissioner,double> interfaceClPowHeavy
("ClPowHeavy",
"ClPow for heavy quarks",
&ClusterFissioner::_clPowHeavy, -1, 1.0, 0.0, 10.0,
false, false, Interface::upperlim);
static Parameter<ClusterFissioner,double>
interfaceClPowDiquark ("ClPowDiquark","cluster mass exponent for light hadronizing diquarks",
&ClusterFissioner::_clPowDiquark, 0, 2.0, 0.0, 10.0,false,false,false);
static Parameter<ClusterFissioner,double>
interfaceClPowExotic ("ClPowExotic","cluster mass exponent for exotic quarks",
&ClusterFissioner::_clPowExotic, 0, 2.0, 0.0, 10.0,false,false,false);
// PSplit for light, Bottom, Charm and exotic (e.g. Susy) quarks
static Parameter<ClusterFissioner,double>
interfacePSplitLight ("PSplitLight","cluster mass splitting param for light quarks",
&ClusterFissioner::_pSplitLight, 0, 1.0, 0.0, 10.0,false,false,false);
static ParMap<ClusterFissioner,double> interfacePSplitHeavy
("PSplitHeavy",
"PSplit for heavy quarks",
&ClusterFissioner::_pSplitHeavy, -1, 1.0, 0.0, 10.0,
false, false, Interface::upperlim);
static Parameter<ClusterFissioner,double>
interfacePSplitExotic ("PSplitExotic","cluster mass splitting param for exotic quarks",
&ClusterFissioner::_pSplitExotic, 0, 1.0, 0.0, 10.0,false,false,false);
static Switch<ClusterFissioner,int> interfaceFission
("Fission",
"Option for different Fission options",
&ClusterFissioner::_fissionCluster, 1, false, false);
static SwitchOption interfaceFissionDefault
(interfaceFission,
"Default",
"Normal cluster fission which depends on the hadron spectrum class.",
0);
static SwitchOption interfaceFissionNew
(interfaceFission,
"New",
"Alternative cluster fission which does not depend on the hadron spectrum class",
1);
static SwitchOption interfaceFissionNewDiquarkSuppression
(interfaceFission,
"NewDiquarkSuppression",
"Alternative cluster fission which does not depend on the hadron spectrum class"
" and includes a suppression of AlphaS^2(Mc) for Diquark Production during "
"Cluster Fission",
-1);
static Switch<ClusterFissioner,int> interfaceDiquarkClusterFission
("DiquarkClusterFission",
"Allow clusters to fission to 1 or 2 diquark Clusters or Turn off diquark fission completely",
&ClusterFissioner::_diquarkClusterFission, 0, false, false);
static SwitchOption interfaceDiquarkClusterFissionAll
(interfaceDiquarkClusterFission,
"All",
"Allow diquark clusters and baryon clusters to fission to new diquark Clusters",
2);
static SwitchOption interfaceDiquarkClusterFissionOnlyBaryonClusters
(interfaceDiquarkClusterFission,
"OnlyBaryonClusters",
"Allow only baryon clusters to fission to new diquark Clusters",
1);
static SwitchOption interfaceDiquarkClusterFissionNo
(interfaceDiquarkClusterFission,
"No",
"Don't allow clusters to fission to new diquark Clusters",
0);
static SwitchOption interfaceDiquarkClusterFissionOff
(interfaceDiquarkClusterFission,
"Off",
"Don't allow clusters fission to draw diquarks ",
-1);
static ParMap<ClusterFissioner,double> interfaceFissionPwt
("FissionPwt",
"The weights for quarks in the fission process.",
&ClusterFissioner::_fissionPwt, -1, 1.0, 0.0, 10.0,
false, false, Interface::upperlim);
static Switch<ClusterFissioner,int> interfaceRemnantOption
("RemnantOption",
"Option for the treatment of remnant clusters",
&ClusterFissioner::_iopRem, 1, false, false);
static SwitchOption interfaceRemnantOptionSoft
(interfaceRemnantOption,
"Soft",
"Both clusters produced in the fission of the beam cluster"
" are treated as soft clusters.",
0);
static SwitchOption interfaceRemnantOptionHard
(interfaceRemnantOption,
"Hard",
"Only the cluster containing the remnant is treated as a soft cluster.",
1);
static SwitchOption interfaceRemnantOptionVeryHard
(interfaceRemnantOption,
"VeryHard",
"Even remnant clusters are treated as hard, i.e. all clusters the same",
2);
static Parameter<ClusterFissioner,Energy> interfaceBTCLM
("SoftClusterFactor",
"Parameter for the mass spectrum of remnant clusters",
&ClusterFissioner::_btClM, GeV, 1.*GeV, 0.1*GeV, 10.0*GeV,
false, false, Interface::limited);
static Parameter<ClusterFissioner,Tension> interfaceStringTension
("StringTension",
"String tension used in vertex displacement calculation",
&ClusterFissioner::_kappa, GeV/meter,
1.0e15*GeV/meter, ZERO, ZERO,
false, false, Interface::lowerlim);
static Switch<ClusterFissioner,int> interfaceEnhanceSProb
("EnhanceSProb",
"Option for enhancing strangeness",
&ClusterFissioner::_enhanceSProb, 0, false, false);
static SwitchOption interfaceEnhanceSProbNo
(interfaceEnhanceSProb,
"No",
"No strangeness enhancement.",
0);
static SwitchOption interfaceEnhanceSProbScaled
(interfaceEnhanceSProb,
"Scaled",
"Scaled strangeness enhancement",
1);
static SwitchOption interfaceEnhanceSProbExponential
(interfaceEnhanceSProb,
"Exponential",
"Exponential strangeness enhancement",
2);
static Switch<ClusterFissioner,int> interfaceMassMeasure
("MassMeasure",
"Option to use different mass measures",
&ClusterFissioner::_massMeasure,0,false,false);
static SwitchOption interfaceMassMeasureMass
(interfaceMassMeasure,
"Mass",
"Mass Measure",
0);
static SwitchOption interfaceMassMeasureLambda
(interfaceMassMeasure,
"Lambda",
"Lambda Measure",
1);
static Parameter<ClusterFissioner,Energy> interfaceFissionMassScale
("FissionMassScale",
"Cluster fission mass scale",
&ClusterFissioner::_m0Fission, GeV, 2.0*GeV, 0.1*GeV, 50.*GeV,
false, false, Interface::limited);
static Parameter<ClusterFissioner,double> interfaceProbPowFactor
("ProbabilityPowerFactor",
"Power factor in ClusterFissioner bell probablity function",
&ClusterFissioner::_probPowFactor, 2.0, 0.001, 20.0,
false, false, Interface::limited);
static Parameter<ClusterFissioner,double> interfaceProbShift
("ProbabilityShift",
"Shifts from the center in ClausterFissioner bell probablity function",
&ClusterFissioner::_probShift, 0.0, -10.0, 10.0,
false, false, Interface::limited);
static Parameter<ClusterFissioner,Energy2> interfaceKineticThresholdShift
("KineticThresholdShift",
"Shifts from the kinetic threshold in ClusterFissioner",
&ClusterFissioner::_kinThresholdShift, sqr(GeV), 0.*sqr(GeV), -10.0*sqr(GeV), 10.0*sqr(GeV),
false, false, Interface::limited);
static Switch<ClusterFissioner,int> interfaceKinematicThreshold
("KinematicThreshold",
"Option for using static or dynamic kinematic thresholds in cluster splittings",
&ClusterFissioner::_kinematicThresholdChoice, 0, false, false);
static SwitchOption interfaceKinematicThresholdStatic
(interfaceKinematicThreshold,
"Static",
"Set static kinematic thresholds for cluster splittings.",
0);
static SwitchOption interfaceKinematicThresholdDynamic
(interfaceKinematicThreshold,
"Dynamic",
"Set dynamic kinematic thresholds for cluster splittings.",
1);
static Switch<ClusterFissioner,bool> interfaceCovariantBoost
("CovariantBoost",
"Use single Covariant Boost for Cluster Fission",
&ClusterFissioner::_covariantBoost, false, false, false);
static SwitchOption interfaceCovariantBoostYes
(interfaceCovariantBoost,
"Yes",
"Use Covariant boost",
true);
static SwitchOption interfaceCovariantBoostNo
(interfaceCovariantBoost,
"No",
"Do NOT use Covariant boost",
false);
static Switch<ClusterFissioner,int> interfaceStrictDiquarkKinematics
("StrictDiquarkKinematics",
"Option for selecting different selection criterions of diquarks for ClusterFission",
&ClusterFissioner::_strictDiquarkKinematics, 0, false, false);
static SwitchOption interfaceStrictDiquarkKinematicsLoose
(interfaceStrictDiquarkKinematics,
"Loose",
"No kinematic threshold for diquark selection except for Mass bigger than 2 baryons",
0);
static SwitchOption interfaceStrictDiquarkKinematicsStrict
(interfaceStrictDiquarkKinematics,
"Strict",
"Resulting clusters are at least as heavy as 2 lightest baryons",
1);
static Parameter<ClusterFissioner,double> interfacePwtDIquark
("PwtDIquark",
"specific probability for choosing a d diquark",
&ClusterFissioner::_pwtDIquark, 0.0, 0.0, 10.0,
false, false, Interface::limited);
static Switch<ClusterFissioner,int> interfacePhaseSpaceWeights
("PhaseSpaceWeights",
"Include phase space weights.",
&ClusterFissioner::_phaseSpaceWeights, 0, false, false);
static SwitchOption interfacePhaseSpaceWeightsNo
(interfacePhaseSpaceWeights,
"No",
"Do not include the effect of cluster phase space",
0);
static SwitchOption interfacePhaseSpaceWeightsYes
(interfacePhaseSpaceWeights,
"Yes",
"Do include the effect of cluster fission phase space "
"related to constituent masses."
"Note: Need static Threshold choice",
1);
static SwitchOption interfacePhaseSpaceWeightsUseHadronMasses
(interfacePhaseSpaceWeights,
"UseHadronMasses",
"Do include the effect of cluster fission phase space "
"related to hadron masses."
"Note: Need static Threshold choice",
2);
static SwitchOption interfacePhaseSpaceWeightsNoConstituentMasses
(interfacePhaseSpaceWeights,
"NoConstituentMasses",
"Do not include the effect of cluster fission phase space "
"related to constituent masses."
"Note: Need static Threshold choice",
3);
static Parameter<ClusterFissioner,double>
interfaceDim ("Dimension","Dimension in which phase space weights are calculated",
&ClusterFissioner::_dim, 0, 4.0, 0.0, 10.0,false,false,false);
// Allowing for strange diquarks in the ClusterFission
static Switch<ClusterFissioner,unsigned int> interfaceHadronizingStrangeDiquarks
("HadronizingStrangeDiquarks",
"Option for adding strange diquarks to Cluster Fission (if Fission = New or Hybrid is enabled)",
&ClusterFissioner::_hadronizingStrangeDiquarks, 0, false, false);
static SwitchOption interfaceHadronizingStrangeDiquarksNo
(interfaceHadronizingStrangeDiquarks,
"No",
"No strangeness containing diquarks during Cluster Fission",
0);
static SwitchOption interfaceHadronizingStrangeDiquarksOnlySingleStrange
(interfaceHadronizingStrangeDiquarks,
"OnlySingleStrange",
"Only one strangeness containing diquarks during Cluster Fission i.e. su,sd",
1);
static SwitchOption interfaceHadronizingStrangeDiquarksAll
(interfaceHadronizingStrangeDiquarks,
"All",
"All strangeness containing diquarks during Cluster Fission i.e. su,sd,ss",
2);
}
tPVector ClusterFissioner::fission(ClusterVector & clusters, bool softUEisOn) {
// return if no clusters
if (clusters.empty()) return tPVector();
/*****************
* Loop over the (input) collection of cluster pointers, and store in
* the vector splitClusters all the clusters that need to be split
* (these are beam clusters, if soft underlying event is off, and
* heavy non-beam clusters).
********************/
stack<ClusterPtr> splitClusters;
for(ClusterVector::iterator it = clusters.begin() ;
it != clusters.end() ; ++it) {
/**************
* Skip 3-component clusters that have been redefined (as 2-component
* clusters) or not available clusters. The latter check is indeed
* redundant now, but it is used for possible future extensions in which,
* for some reasons, some of the clusters found by ClusterFinder are tagged
* straight away as not available.
**************/
if((*it)->isRedefined() || !(*it)->isAvailable()) continue;
// if the cluster is a beam cluster add it to the vector of clusters
// to be split or if it is heavy
if((*it)->isBeamCluster() || isHeavy(*it)) splitClusters.push(*it);
}
tPVector finalhadrons;
cut(splitClusters, clusters, finalhadrons, softUEisOn);
return finalhadrons;
}
void ClusterFissioner::cut(stack<ClusterPtr> & clusterStack,
ClusterVector &clusters, tPVector & finalhadrons,
bool softUEisOn) {
/**************************************************
* This method does the splitting of the cluster pointed by cluPtr
* and "recursively" by all of its cluster children, if heavy. All of these
* new children clusters are added (indeed the pointers to them) to the
* collection of cluster pointers collecCluPtr. The method works as follows.
* Initially the vector vecCluPtr contains just the input pointer to the
* cluster to be split. Then it will be filled "recursively" by all
* of the cluster's children that are heavy enough to require, in their turn,
* to be split. In each loop, the last element of the vector vecCluPtr is
* considered (only once because it is then removed from the vector).
* This approach is conceptually recursive, but avoid the overhead of
* a concrete recursive function. Furthermore it requires minimal changes
* in the case that the fission of an heavy cluster could produce more
* than two cluster children as assumed now.
*
* Draw the masses: for normal, non-beam clusters a power-like mass dist
* is used, whereas for beam clusters a fast-decreasing exponential mass
* dist is used instead (to avoid many iterative splitting which could
* produce an unphysical large transverse energy from a supposed soft beam
* remnant process).
****************************************/
// Here we recursively loop over clusters in the stack and cut them
while (!clusterStack.empty()) {
// take the last element of the vector
ClusterPtr iCluster = clusterStack.top(); clusterStack.pop();
// split it
cutType ct = iCluster->numComponents() == 2 ?
cutTwo(iCluster, finalhadrons, softUEisOn) :
cutThree(iCluster, finalhadrons, softUEisOn);
// There are cases when we don't want to split, even if it fails mass test
if(!ct.first.first || !ct.second.first) {
// if an unsplit beam cluster leave if for the underlying event
if(iCluster->isBeamCluster() && softUEisOn)
iCluster->isAvailable(false);
continue;
}
// check if clusters
ClusterPtr one = dynamic_ptr_cast<ClusterPtr>(ct.first.first);
ClusterPtr two = dynamic_ptr_cast<ClusterPtr>(ct.second.first);
// is a beam cluster must be split into two clusters
if(iCluster->isBeamCluster() && (!one||!two) && softUEisOn) {
iCluster->isAvailable(false);
continue;
}
// There should always be a intermediate quark(s) from the splitting
assert(ct.first.second && ct.second.second);
/// \todo sort out motherless quark pairs here. Watch out for 'quark in final state' errors
iCluster->addChild(ct.first.first);
// iCluster->addChild(ct.first.second);
// ct.first.second->addChild(ct.first.first);
iCluster->addChild(ct.second.first);
// iCluster->addChild(ct.second.second);
// ct.second.second->addChild(ct.second.first);
// Sometimes the clusters decay C -> H + C' or C -> H + H' rather then C -> C' + C''
if(one) {
clusters.push_back(one);
if(one->isBeamCluster() && softUEisOn)
one->isAvailable(false);
if(isHeavy(one) && one->isAvailable())
clusterStack.push(one);
}
if(two) {
clusters.push_back(two);
if(two->isBeamCluster() && softUEisOn)
two->isAvailable(false);
if(isHeavy(two) && two->isAvailable())
clusterStack.push(two);
}
}
}
ClusterFissioner::cutType
ClusterFissioner::cutTwo(ClusterPtr & cluster, tPVector & finalhadrons,
bool softUEisOn) {
// need to make sure only 2-cpt clusters get here
assert(cluster->numComponents() == 2);
tPPtr ptrQ1 = cluster->particle(0);
tPPtr ptrQ2 = cluster->particle(1);
Energy Mc = cluster->mass();
assert(ptrQ1);
assert(ptrQ2);
// And check if those particles are from a beam remnant
bool rem1 = cluster->isBeamRemnant(0);
bool rem2 = cluster->isBeamRemnant(1);
// workout which distribution to use
bool soft1(false),soft2(false);
switch (_iopRem) {
case 0:
soft1 = rem1 || rem2;
soft2 = rem2 || rem1;
break;
case 1:
soft1 = rem1;
soft2 = rem2;
break;
}
// Initialization for the exponential ("soft") mass distribution.
static const int max_loop = 1000;
int counter = 0;
Energy Mc1 = ZERO, Mc2 = ZERO,m1=ZERO,m2=ZERO,m=ZERO;
tcPDPtr toHadron1, toHadron2;
PPtr newPtr1 = PPtr ();
PPtr newPtr2 = PPtr ();
bool succeeded = false;
Lorentz5Momentum pClu1, pClu2, pQ1, pQone, pQtwo, pQ2;
do
{
succeeded = false;
++counter;
// get a flavour for the qqbar pair
drawNewFlavour(newPtr1,newPtr2,cluster);
// check for right ordering
assert (ptrQ2);
assert (newPtr2);
assert (ptrQ2->dataPtr());
assert (newPtr2->dataPtr());
if(cantMakeHadron(ptrQ1, newPtr1) || cantMakeHadron(ptrQ2, newPtr2)) {
swap(newPtr1, newPtr2);
// check again
if(cantMakeHadron(ptrQ1, newPtr1) || cantMakeHadron(ptrQ2, newPtr2)) {
throw Exception()
<< "ClusterFissioner cannot split the cluster ("
<< ptrQ1->PDGName() << ' ' << ptrQ2->PDGName()
<< ") into hadrons.\n" << Exception::runerror;
}
}
// Check that new clusters can produce particles and there is enough
// phase space to choose the drawn flavour
m1 = ptrQ1->data().constituentMass();
m2 = ptrQ2->data().constituentMass();
m = newPtr1->data().constituentMass();
// Do not split in the case there is no phase space available
if(Mc < m1+m + m2+m) continue;
pQ1.setMass(m1);
pQone.setMass(m);
pQtwo.setMass(m);
pQ2.setMass(m2);
double weightMasses = drawNewMasses(Mc, soft1, soft2, pClu1, pClu2,
ptrQ1, pQ1, newPtr1, pQone,
newPtr2, pQtwo, ptrQ2, pQ2);
if (weightMasses==0.0)
continue;
// derive the masses of the children
Mc1 = pClu1.mass();
Mc2 = pClu2.mass();
// static kinematic threshold
if(_kinematicThresholdChoice == 0) {
if (Mc1 < m1+m || Mc2 < m+m2 || Mc1+Mc2 > Mc) continue;
if (_phaseSpaceWeights==2 &&
( Mc1 < spectrum()->massLightestHadronPair(ptrQ1->dataPtr(),newPtr1->dataPtr())
|| Mc2 < spectrum()->massLightestHadronPair(ptrQ2->dataPtr(),newPtr2->dataPtr()) ))
continue;
// dynamic kinematic threshold
}
else if(_kinematicThresholdChoice == 1) {
bool C1 = ( sqr(Mc1) )/( sqr(m1) + sqr(m) + _kinThresholdShift ) < 1.0 ? true : false;
bool C2 = ( sqr(Mc2) )/( sqr(m2) + sqr(m) + _kinThresholdShift ) < 1.0 ? true : false;
bool C3 = ( sqr(Mc1) + sqr(Mc2) )/( sqr(Mc) ) > 1.0 ? true : false;
if( C1 || C2 || C3 ) continue;
}
if ( _phaseSpaceWeights && phaseSpaceVeto(Mc,Mc1,Mc2,m,m1,m2, ptrQ1, ptrQ2, newPtr1, 0.0) ) {
// reduce counter as it regards only the mass sampling
counter--;
continue;
}
/**************************
* New (not present in Fortran Herwig):
* check whether the fragment masses Mc1 and Mc2 are above the
* threshold for the production of the lightest pair of hadrons with the
* right flavours. If not, then set by hand the mass to the lightest
* single hadron with the right flavours, in order to solve correctly
* the kinematics, and (later in this method) create directly such hadron
* and add it to the children hadrons of the cluster that undergoes the
* fission (i.e. the one pointed by iCluPtr). Notice that in this special
* case, the heavy cluster that undergoes the fission has one single
* cluster child and one single hadron child. We prefer this approach,
* rather than to create a light cluster, with the mass set equal to
* the lightest hadron, and let then the class LightClusterDecayer to do
* the job to decay it to that single hadron, for two reasons:
* First, because the sum of the masses of the two constituents can be,
* in this case, greater than the mass of that hadron, hence it would
* be impossible to solve the kinematics for such two components, and
* therefore we would have a cluster whose components are undefined.
* Second, the algorithm is faster, because it avoids the reshuffling
* procedure that would be necessary if we used LightClusterDecayer
* to decay the light cluster to the lightest hadron.
****************************/
// override chosen masses if needed
toHadron1 = _hadronSpectrum->chooseSingleHadron(ptrQ1->dataPtr(), newPtr1->dataPtr(),Mc1);
if(toHadron1) { Mc1 = toHadron1->mass(); pClu1.setMass(Mc1); }
toHadron2 = _hadronSpectrum->chooseSingleHadron(ptrQ2->dataPtr(), newPtr2->dataPtr(),Mc2);
if(toHadron2) { Mc2 = toHadron2->mass(); pClu2.setMass(Mc2); }
// if a beam cluster not allowed to decay to hadrons
if(cluster->isBeamCluster() && (toHadron1||toHadron2) && softUEisOn)
continue;
// Check if the decay kinematics is still possible: if not then
// force the one-hadron decay for the other cluster as well.
if(Mc1 + Mc2 > Mc) {
if(!toHadron1) {
toHadron1 = _hadronSpectrum->chooseSingleHadron(ptrQ1->dataPtr(), newPtr1->dataPtr(),Mc-Mc2);
if(toHadron1) { Mc1 = toHadron1->mass(); pClu1.setMass(Mc1); }
}
else if(!toHadron2) {
toHadron2 = _hadronSpectrum->chooseSingleHadron(ptrQ2->dataPtr(), newPtr2->dataPtr(),Mc-Mc1);
if(toHadron2) { Mc2 = toHadron2->mass(); pClu2.setMass(Mc2); }
}
}
succeeded = (Mc >= Mc1+Mc2);
}
while (!succeeded && counter < max_loop);
if(counter >= max_loop) {
static const PPtr null = PPtr();
return cutType(PPair(null,null),PPair(null,null));
}
// Determined the (5-components) momenta (all in the LAB frame)
Lorentz5Momentum pClu = cluster->momentum(); // known
Lorentz5Momentum p0Q1 = ptrQ1->momentum(); // known (mom Q1 before fission)
calculateKinematics(pClu,p0Q1,toHadron1,toHadron2,
pClu1,pClu2,pQ1,pQone,pQtwo,pQ2);
/******************
* The previous methods have determined the kinematics and positions
* of C -> C1 + C2.
* In the case that one of the two product is light, that means either
* decayOneHadronClu1 or decayOneHadronClu2 is true, then the momenta
* of the components of that light product have not been determined,
* and a (light) cluster will not be created: the heavy father cluster
* decays, in this case, into a single (not-light) cluster and a
* single hadron. In the other, "normal", cases the father cluster
* decays into two clusters, each of which has well defined components.
* Notice that, in the case of components which point to particles, the
* momenta of the components is properly set to the new values, whereas
* we do not change the momenta of the pointed particles, because we
* want to keep all of the information (that is the new momentum of a
* component after the splitting, which is contained in the _momentum
* member of the Component class, and the (old) momentum of that component
* before the splitting, which is contained in the momentum of the
* pointed particle). Please not make confusion of this only apparent
* inconsistency!
********************/
LorentzPoint posC,pos1,pos2;
posC = cluster->vertex();
calculatePositions(pClu, posC, pClu1, pClu2, pos1, pos2);
cutType rval;
if(toHadron1) {
rval.first = produceHadron(toHadron1, newPtr1, pClu1, pos1);
finalhadrons.push_back(rval.first.first);
}
else {
rval.first = produceCluster(ptrQ1, newPtr1, pClu1, pos1, pQ1, pQone, rem1);
}
if(toHadron2) {
rval.second = produceHadron(toHadron2, newPtr2, pClu2, pos2);
finalhadrons.push_back(rval.second.first);
}
else {
rval.second = produceCluster(ptrQ2, newPtr2, pClu2, pos2, pQ2, pQtwo, rem2);
}
return rval;
}
ClusterFissioner::cutType
ClusterFissioner::cutThree(ClusterPtr & cluster, tPVector & finalhadrons,
bool softUEisOn) {
// need to make sure only 3-cpt clusters get here
assert(cluster->numComponents() == 3);
// extract quarks
tPPtr ptrQ[3] = {cluster->particle(0),cluster->particle(1),cluster->particle(2)};
assert( ptrQ[0] && ptrQ[1] && ptrQ[2] );
// find maximum mass pair
Energy mmax(ZERO);
Lorentz5Momentum pDiQuark;
int iq1(-1),iq2(-1);
Lorentz5Momentum psum;
for(int q1=0;q1<3;++q1) {
psum+= ptrQ[q1]->momentum();
for(int q2=q1+1;q2<3;++q2) {
Lorentz5Momentum ptest = ptrQ[q1]->momentum()+ptrQ[q2]->momentum();
ptest.rescaleMass();
Energy mass = ptest.m();
if(mass>mmax) {
mmax = mass;
pDiQuark = ptest;
iq1 = q1;
iq2 = q2;
}
}
}
// and the spectators
int iother(-1);
for(int ix=0;ix<3;++ix) if(ix!=iq1&&ix!=iq2) iother=ix;
assert(iq1>=0&&iq2>=0&&iother>=0);
// And check if those particles are from a beam remnant
bool rem1 = cluster->isBeamRemnant(iq1);
bool rem2 = cluster->isBeamRemnant(iq2);
// workout which distribution to use
bool soft1(false),soft2(false);
switch (_iopRem) {
case 0:
soft1 = rem1 || rem2;
soft2 = rem2 || rem1;
break;
case 1:
soft1 = rem1;
soft2 = rem2;
break;
}
// Initialization for the exponential ("soft") mass distribution.
static const int max_loop = 1000;
int counter = 0;
Energy Mc1 = ZERO, Mc2 = ZERO, m1=ZERO, m2=ZERO, m=ZERO;
tcPDPtr toHadron;
bool toDiQuark(false);
PPtr newPtr1 = PPtr(),newPtr2 = PPtr();
PDPtr diquark;
bool succeeded = false;
Lorentz5Momentum pClu1, pClu2, pQ1, pQone, pQtwo, pQ2;
do {
succeeded = false;
++counter;
// get a flavour for the qqbar pair
drawNewFlavour(newPtr1,newPtr2,cluster);
// randomly pick which will be (anti)diquark and which a mesonic cluster
if(UseRandom::rndbool()) {
swap(iq1,iq2);
swap(rem1,rem2);
}
// check first order
if(cantMakeHadron(ptrQ[iq1], newPtr1) || !spectrum()->canMakeDiQuark(ptrQ[iq2], newPtr2)) {
swap(newPtr1,newPtr2);
}
// check again
if(cantMakeHadron(ptrQ[iq1], newPtr1) || !spectrum()->canMakeDiQuark(ptrQ[iq2], newPtr2)) {
throw Exception()
<< "ClusterFissioner cannot split the cluster ("
<< ptrQ[iq1]->PDGName() << ' ' << ptrQ[iq2]->PDGName()
<< ") into a hadron and diquark.\n" << Exception::runerror;
}
// Check that new clusters can produce particles and there is enough
// phase space to choose the drawn flavour
m1 = ptrQ[iq1]->data().constituentMass();
m2 = ptrQ[iq2]->data().constituentMass();
m = newPtr1->data().constituentMass();
// Do not split in the case there is no phase space available
if(mmax < m1+m + m2+m) continue;
pQ1.setMass(m1);
pQone.setMass(m);
pQtwo.setMass(m);
pQ2.setMass(m2);
double weightMasses = drawNewMasses(mmax, soft1, soft2, pClu1, pClu2,
ptrQ[iq1], pQ1, newPtr1, pQone,
newPtr2, pQtwo, ptrQ[iq1], pQ2);
if (weightMasses == 0.0) continue;
Mc1 = pClu1.mass();
Mc2 = pClu2.mass();
if(Mc1 < m1+m || Mc2 < m+m2 || Mc1+Mc2 > mmax) continue;
if ( _phaseSpaceWeights && phaseSpaceVeto(mmax,Mc1,Mc2,m,m1,m2) ) {
// reduce counter as it regards only the mass sampling
counter--;
continue;
}
// check if need to force meson clster to hadron
toHadron = _hadronSpectrum->chooseSingleHadron(ptrQ[iq1]->dataPtr(), newPtr1->dataPtr(),Mc1);
if(toHadron) { Mc1 = toHadron->mass(); pClu1.setMass(Mc1); }
// check if need to force diquark cluster to be on-shell
toDiQuark = false;
diquark = spectrum()->makeDiquark(ptrQ[iq2]->dataPtr(), newPtr2->dataPtr());
if(Mc2 < diquark->constituentMass()) {
Mc2 = diquark->constituentMass(); pClu2.setMass(Mc2);
toDiQuark = true;
}
// if a beam cluster not allowed to decay to hadrons
if(cluster->isBeamCluster() && toHadron && softUEisOn)
continue;
// Check if the decay kinematics is still possible: if not then
// force the one-hadron decay for the other cluster as well.
if(Mc1 + Mc2 > mmax) {
if(!toHadron) {
toHadron = _hadronSpectrum->chooseSingleHadron(ptrQ[iq1]->dataPtr(), newPtr1->dataPtr(),mmax-Mc2);
if(toHadron) { Mc1 = toHadron->mass(); pClu1.setMass(Mc1); }
}
else if(!toDiQuark) {
Mc2 = _hadronSpectrum->massLightestHadron(ptrQ[iq2]->dataPtr(), newPtr2->dataPtr()); pClu2.setMass(Mc2);
toDiQuark = true;
}
}
succeeded = (mmax >= Mc1+Mc2);
}
while (!succeeded && counter < max_loop);
// check no of tries
if(counter >= max_loop) return cutType();
// Determine the (5-components) momenta (all in the LAB frame)
Lorentz5Momentum p0Q1 = ptrQ[iq1]->momentum();
calculateKinematics(pDiQuark,p0Q1,toHadron,toDiQuark,
pClu1,pClu2,pQ1,pQone,pQtwo,pQ2);
// positions of the new clusters
LorentzPoint pos1,pos2;
Lorentz5Momentum pBaryon = pClu2+ptrQ[iother]->momentum();
calculatePositions(cluster->momentum(), cluster->vertex(), pClu1, pBaryon, pos1, pos2);
// first the mesonic cluster/meson
cutType rval;
if(toHadron) {
rval.first = produceHadron(toHadron, newPtr1, pClu1, pos1);
finalhadrons.push_back(rval.first.first);
}
else {
rval.first = produceCluster(ptrQ[iq1], newPtr1, pClu1, pos1, pQ1, pQone, rem1);
}
if(toDiQuark) {
rem2 |= cluster->isBeamRemnant(iother);
PPtr newDiQuark = diquark->produceParticle(pClu2);
rval.second = produceCluster(newDiQuark, ptrQ[iother], pBaryon, pos2, pClu2,
ptrQ[iother]->momentum(), rem2);
}
else {
rval.second = produceCluster(ptrQ[iq2], newPtr2, pBaryon, pos2, pQ2, pQtwo, rem2,
ptrQ[iother],cluster->isBeamRemnant(iother));
}
cluster->isAvailable(false);
return rval;
}
ClusterFissioner::PPair
ClusterFissioner::produceHadron(tcPDPtr hadron, tPPtr newPtr, const Lorentz5Momentum &a,
const LorentzPoint &b) const {
PPair rval;
if(hadron->coloured()) {
rval.first = (_hadronSpectrum->lightestHadron(hadron,newPtr->dataPtr()))->produceParticle();
}
else
rval.first = hadron->produceParticle();
rval.second = newPtr;
rval.first->set5Momentum(a);
rval.first->setVertex(b);
return rval;
}
ClusterFissioner::PPair ClusterFissioner::produceCluster(tPPtr ptrQ, tPPtr newPtr,
const Lorentz5Momentum & a,
const LorentzPoint & b,
const Lorentz5Momentum & c,
const Lorentz5Momentum & d,
bool isRem,
tPPtr spect, bool remSpect) const {
PPair rval;
rval.second = newPtr;
ClusterPtr cluster = !spect ? new_ptr(Cluster(ptrQ,rval.second)) : new_ptr(Cluster(ptrQ,rval.second,spect));
rval.first = cluster;
cluster->set5Momentum(a);
cluster->setVertex(b);
assert(cluster->particle(0)->id() == ptrQ->id());
cluster->particle(0)->set5Momentum(c);
cluster->particle(1)->set5Momentum(d);
cluster->setBeamRemnant(0,isRem);
if(remSpect) cluster->setBeamRemnant(2,remSpect);
return rval;
}
/**
* Calculate the phase space weight for M1*M2*(2 body PhaseSpace) ignore constituent masses
*/
double ClusterFissioner::weightFlatPhaseSpaceNoConstituentMasses(const Energy Mc, const Energy Mc1, const Energy Mc2) const {
double M_temp = Mc/GeV;
double M1_temp = Mc1/GeV;
double M2_temp = Mc2/GeV;
if (sqr(M_temp)<sqr(M1_temp+M2_temp)) {
// This should be checked before
throw Exception()
<< "ERROR in ClusterFissioner::weightFlatPhaseSpaceNoConstituentMasses\n"
<< "ClusterFissioner has not checked Masses properly\n"
<< "Mc = " << M_temp << "\n"
<< "Mc1 = " << M1_temp << "\n"
<< "Mc2 = " << M2_temp << "\n"
<< Exception::warning;
return 0.0;
}
double lam = Kinematics::kaellen(M_temp, M1_temp, M2_temp);
double ratio;
// new weight with the Jacobi factor M1*M2 of the Mass integration
double PSweight = M1_temp*M2_temp*pow(sqrt(lam),_dim-3.);
// overestimate only possible for dim>=3.0
assert(_dim>=3.0);
// new improved overestimate with the Jacobi factor M1*M2 of the Mass integration
double overEstimate = pow(6.0*sqrt(3.0), 3.0 - _dim)*pow(M_temp, 2.*(_dim-2.));
ratio = PSweight/overEstimate;
if (!(ratio>=0) || !(ratio<=1)) {
throw Exception()
<< "ERROR in ClusterFissioner::weightFlatPhaseSpaceNoConstituentMasses\n"
<< "ratio = " <<ratio
<<" M "<<M_temp
<<" M1 "<<M1_temp
<<" M2 "<<M2_temp <<"\t"<<_dim<<"\t" << lam
<<"\t"<< overEstimate<<"\n\n"
<< Exception::runerror;
}
return ratio;
}
/**
* Calculate the phase space weight for M1*M2*(2 body PhaseSpace)^3
*/
double ClusterFissioner::weightPhaseSpaceConstituentMasses(const Energy Mc, const Energy Mc1, const Energy Mc2,
const Energy m, const Energy m1, const Energy m2, const double power) const {
double M_temp = Mc/GeV;
double M1_temp = Mc1/GeV;
double M2_temp = Mc2/GeV;
double m_temp = m/GeV;
double m1_temp = m1/GeV;
double m2_temp = m2/GeV;
if (sqr(M_temp)<sqr(M1_temp+M2_temp)
|| sqr(M1_temp)<sqr(m1_temp+m_temp)
|| sqr(M2_temp)<sqr(m2_temp+m_temp)
) {
// This should be checked before
throw Exception()
<< "ERROR in ClusterFissioner::weightPhaseSpaceConstituentMasses\n"
<< "ClusterFissioner has not checked Masses properly\n"
<< "Mc = " << M_temp << "\n"
<< "Mc1 = " << M1_temp << "\n"
<< "Mc2 = " << M2_temp << "\n"
<< "m1 = " << m1_temp << "\n"
<< "m2 = " << m2_temp << "\n"
<< "m = " << m_temp << "\n"
<< Exception::warning;
return 0.0;
}
double lam1 = Kinematics::kaellen(M1_temp, m1_temp, m_temp);
double lam2 = Kinematics::kaellen(M2_temp, m2_temp, m_temp);
double lam3 = Kinematics::kaellen(M_temp, M1_temp, M2_temp);
double ratio;
// new weight with the Jacobi factor M1*M2 of the Mass integration
double PSweight = pow(lam1*lam2*lam3,(_dim-3.)/2.0)*pow(M1_temp*M2_temp,3.-_dim);
// overestimate only possible for dim>=3.0
assert(_dim>=3.0);
// new improved overestimate with the Jacobi factor M1*M2 of the Mass integration
double overEstimate = pow(6.0*sqrt(3.0), 3.0 - _dim)*pow(M_temp, 4.*_dim-12.);
ratio = PSweight/overEstimate;
if (!(ratio>=0)) std::cout << "ratio = " <<ratio<<" M "<<M_temp<<" M1 "<<M1_temp<<" M2 "<<M2_temp<<" m1 "<<m1_temp<<" m2 "<<m2_temp<<" m "<<m_temp<<"\t"<<_dim<<"\t" << lam1<<"\t"<< lam2<<"\t" << lam3 <<"\t"<< overEstimate<<"\n\n";
if (!(ratio>=0) || !(ratio<=1)) {
throw Exception()
<< "ERROR in ClusterFissioner::weightPhaseSpaceConstituentMasses\n"
<< "ratio = " <<ratio
<<" M "<<M_temp
<<" M1 "<<M1_temp
<<" M2 "<<M2_temp
<<" m1 "<<m1_temp
<<" m2 "<<m2_temp
<<" m "<<m_temp <<"\t"<<_dim
<<"\t" << lam1<<"\t"<< lam2<<"\t" << lam3
<<"\t"<< overEstimate<<"\n\n"
<< Exception::runerror;
}
// multiply by overestimate of power of matrix element to modulate the phase space with (M1*M2)^power
if (power) {
double powerLawOver = power<0 ? pow(Mc1*Mc2/((m1+m)*(m2+m)),power):pow(Mc1*Mc2/((Mc-(m1+m))*(Mc-(m2+m))),power);
ratio*=powerLawOver;
}
return ratio;
}
/**
* Calculate the phase space weight for M1*M2*(2 body PhaseSpace)^3
* using Hadron Masses
*/
double ClusterFissioner::weightFlatPhaseSpaceHadronMasses(const Energy Mc, const Energy Mc1, const Energy Mc2, tcPPtr pQ, tcPPtr pQ1, tcPPtr pQ2) const {
auto LHP1 = spectrum()->lightestHadronPair(pQ1->dataPtr(),pQ->dataPtr());
auto LHP2 = spectrum()->lightestHadronPair(pQ2->dataPtr(),pQ->dataPtr());
if (sqr(Mc1)<sqr(LHP1.first->mass()+LHP1.second->mass()))
return true;
if (sqr(Mc2)<sqr(LHP2.first->mass()+LHP2.second->mass()))
return true;
double lam1 = sqrt(Kinematics::kaellen(Mc1/GeV, LHP1.first->mass()/GeV, LHP1.second->mass()/GeV));
double lam2 = sqrt(Kinematics::kaellen(Mc2/GeV, LHP2.first->mass()/GeV, LHP2.second->mass()/GeV));
double lam3 = sqrt(Kinematics::kaellen(Mc/GeV, Mc1/GeV, Mc2/GeV));
double ratio;
// new weight with the Jacobi factor M1*M2 of the Mass integration
double PSweight = pow(lam1*lam2*lam3,_dim-3.)*pow(Mc1*Mc2/GeV2,3.-_dim);
// overestimate only possible for dim>=3.0
assert(_dim>=3.0);
// new improved overestimate with the Jacobi factor M1*M2 of the Mass integration
double overEstimate = pow(6.0*sqrt(3.0), 3.0 - _dim)*pow(Mc/GeV, 4.*_dim-12.);
ratio = PSweight/overEstimate;
if (!(ratio>=0) || !(ratio<=1)) {
throw Exception()
<< "ERROR in ClusterFissioner::weightFlatPhaseSpaceHadronMasses\n"
<< "ratio = " <<ratio
<<" M "<<Mc/GeV
<<" M1 "<<Mc1/GeV
<<" M2 "<<Mc2/GeV <<"\t"<<_dim<<"\t" << lam1<<"\t" << lam2 <<"\t" << lam3
<<"\t"<< overEstimate<<"\n\n"
<< Exception::runerror;
}
return ratio;
}
/**
* Veto for the phase space weight
* returns true if proposed Masses are rejected
* else returns false
*/
bool ClusterFissioner::phaseSpaceVeto(const Energy Mc, const Energy Mc1, const Energy Mc2,
const Energy m, const Energy m1, const Energy m2, tcPPtr pQ1, tcPPtr pQ2, tcPPtr pQ, const double power) const {
switch (_phaseSpaceWeights)
{
case 1:
return phaseSpaceVetoConstituentMasses(Mc, Mc1, Mc2, m, m1, m2, power);
case 2:
return phaseSpaceVetoHadronPairs(Mc, Mc1, Mc2, pQ, pQ1, pQ2);
case 3:
return phaseSpaceVetoNoConstituentMasses(Mc, Mc1, Mc2);
default:
assert(false);
}
}
/**
* Veto for the phase space weight
* returns true if proposed Masses are rejected
* else returns false
*/
bool ClusterFissioner::phaseSpaceVetoConstituentMasses(const Energy Mc, const Energy Mc1, const Energy Mc2,
const Energy m, const Energy m1, const Energy m2, const double power) const {
return (UseRandom::rnd()>weightPhaseSpaceConstituentMasses(Mc, Mc1, Mc2, m, m1, m2, power));
}
bool ClusterFissioner::phaseSpaceVetoNoConstituentMasses(const Energy Mc, const Energy Mc1, const Energy Mc2) const {
return (UseRandom::rnd()>weightFlatPhaseSpaceNoConstituentMasses(Mc, Mc1, Mc2));
}
bool ClusterFissioner::phaseSpaceVetoHadronPairs(const Energy Mc, const Energy Mc1, const Energy Mc2, tcPPtr pQ, tcPPtr pQ1, tcPPtr pQ2) const {
return (UseRandom::rnd()>weightFlatPhaseSpaceHadronMasses(Mc, Mc1, Mc2, pQ, pQ1, pQ2));
}
/**
* Calculate the masses and possibly kinematics of the cluster
* fission at hand; if calculateKineamtics is perfomring non-trivial
* steps kinematics claulcated here will be overriden. Currentl;y resorts to the default
*/
double ClusterFissioner::drawNewMasses(const Energy Mc, const bool soft1, const bool soft2,
Lorentz5Momentum& pClu1, Lorentz5Momentum& pClu2,
tcPPtr ptrQ1, const Lorentz5Momentum& pQ1,
tcPPtr, const Lorentz5Momentum& pQone,
tcPPtr, const Lorentz5Momentum& pQtwo,
tcPPtr ptrQ2, const Lorentz5Momentum& pQ2) const {
// power for splitting
double exp1 = !spectrum()->isExotic(ptrQ1->dataPtr()) ? _pSplitLight : _pSplitExotic;
double exp2 = !spectrum()->isExotic(ptrQ2->dataPtr()) ? _pSplitLight : _pSplitExotic;
for ( const long& id : spectrum()->heavyHadronizingQuarks() ) {
assert(_pSplitHeavy.find(id) != _pSplitHeavy.end());
if ( spectrum()->hasHeavy(id,ptrQ1->dataPtr()) ) exp1 = _pSplitHeavy.find(id)->second;
if ( spectrum()->hasHeavy(id,ptrQ2->dataPtr()) ) exp2 = _pSplitHeavy.find(id)->second;
}
Energy M1 = drawChildMass(Mc,pQ1.mass(),pQ2.mass(),pQone.mass(),exp1,soft1);
Energy M2 = drawChildMass(Mc,pQ2.mass(),pQ1.mass(),pQtwo.mass(),exp2,soft2);
pClu1.setMass(M1);
pClu2.setMass(M2);
return 1.0; // succeeds
}
void ClusterFissioner::drawNewFlavourDiquarks(PPtr& newPtrPos,PPtr& newPtrNeg,
const ClusterPtr & clu) const {
// Flavour is assumed to be only u, d, s, with weights
// (which are not normalized probabilities) given
// by the same weights as used in HadronsSelector for
// the decay of clusters into two hadrons.
unsigned hasDiquarks=0;
assert(clu->numComponents()==2);
tcPDPtr pD1=clu->particle(0)->dataPtr();
tcPDPtr pD2=clu->particle(1)->dataPtr();
bool isDiq1=DiquarkMatcher::Check(pD1->id());
if (isDiq1) hasDiquarks++;
bool isDiq2=DiquarkMatcher::Check(pD2->id());
if (isDiq2) hasDiquarks++;
assert(hasDiquarks<=2);
Energy Mc=(clu->momentum().mass());
Energy minMass;
double weight;
Selector<long> choice;
// adding quark-antiquark pairs to the selection list
for ( const long& id : spectrum()->lightHadronizingQuarks() ) {
minMass=spectrum()->massLightestHadronPair(pD1,pD2);
if (_fissionCluster==0) choice.insert(_hadronSpectrum->pwtQuark(id),id);
else if (abs(_fissionCluster)==1) choice.insert(_fissionPwt.find(id)->second,id);
else assert(false);
}
// adding diquark-antidiquark pairs to the selection list
switch (hasDiquarks)
{
case 0:
for ( const long& id : spectrum()->lightHadronizingDiquarks() ) {
if (_strictDiquarkKinematics) {
tPDPtr cand = getParticleData(id);
Energy mH1=spectrum()->massLightestHadron(pD2,cand);
Energy mH2=spectrum()->massLightestHadron(cand,pD1);
minMass = mH1 + mH2;
}
else {
minMass = spectrum()->massLightestBaryonPair(pD1,pD2);
}
if (Mc < minMass) continue;
if (_fissionCluster==0) weight = _hadronSpectrum->pwtQuark(id);
else if (abs(_fissionCluster)==1) weight = _fissionPwt.find(id)->second;
else assert(false);
if (_fissionCluster==-1)
weight*=sqr(Herwig::Math::alphaS(Mc, 0.25*GeV,3, 2));
choice.insert(weight,id);
}
break;
case 1:
if (_diquarkClusterFission<1) break;
for ( const long& id : spectrum()->lightHadronizingDiquarks() ) {
tPDPtr diq = getParticleData(id);
if (isDiq1)
minMass = spectrum()->massLightestHadron(pD2,diq)
+ spectrum()->massLightestBaryonPair(diq,pD1);
else
minMass = spectrum()->massLightestHadron(pD1,diq)
+ spectrum()->massLightestBaryonPair(diq,pD2);
if (Mc < minMass) continue;
if (_fissionCluster==0) weight = _hadronSpectrum->pwtQuark(id);
else if (abs(_fissionCluster)==1) weight = _fissionPwt.find(id)->second;
else assert(false);
if (_fissionCluster==-1)
weight*=sqr(Herwig::Math::alphaS(Mc, 0.25*GeV,3, 2));
choice.insert(weight,id);
}
break;
case 2:
if (_diquarkClusterFission<2) break;
for ( const long& id : spectrum()->lightHadronizingDiquarks() ) {
tPDPtr diq = getParticleData(id);
if (Mc < spectrum()->massLightestBaryonPair(pD1,pD2)) {
throw Exception() << "Found Diquark Cluster:\n" << *clu << "\nwith MassCluster = "
- << ounit(Mc,GeV) <<" GeV MassLightestBaryonPair = "
- << ounit(spectrum()->massLightestBaryonPair(pD1,pD2) ,GeV)
+ << Mc/GeV <<" GeV MassLightestBaryonPair = "
+ << spectrum()->massLightestBaryonPair(pD1,pD2)/GeV
<< " GeV cannot decay" << Exception::eventerror;
}
minMass = spectrum()->massLightestBaryonPair(pD1,diq)
+ spectrum()->massLightestBaryonPair(diq,pD2);
if (Mc < minMass) continue;
if (_fissionCluster==0) weight = _hadronSpectrum->pwtQuark(id);
else if (abs(_fissionCluster)==1) weight = _fissionPwt.find(id)->second;
else assert(false);
if (_fissionCluster==-1)
weight*=sqr(Herwig::Math::alphaS(Mc, 0.25*GeV,3, 2));
choice.insert(weight,id);
}
break;
default:
assert(false);
}
assert(choice.size()>0);
long idNew = choice.select(UseRandom::rnd());
newPtrPos = getParticle(idNew);
newPtrNeg = getParticle(-idNew);
assert(newPtrPos);
assert(newPtrNeg);
assert(newPtrPos->dataPtr());
assert(newPtrNeg->dataPtr());
}
void ClusterFissioner::drawNewFlavourQuarks(PPtr& newPtrPos,PPtr& newPtrNeg) const {
// Flavour is assumed to be only u, d, s, with weights
// (which are not normalized probabilities) given
// by the same weights as used in HadronsSelector for
// the decay of clusters into two hadrons.
Selector<long> choice;
switch(abs(_fissionCluster)){
case 0:
for ( const long& id : spectrum()->lightHadronizingQuarks() )
choice.insert(_hadronSpectrum->pwtQuark(id),id);
break;
case 1:
for ( const long& id : spectrum()->lightHadronizingQuarks() )
choice.insert(_fissionPwt.find(id)->second,id);
break;
default :
assert(false);
}
long idNew = choice.select(UseRandom::rnd());
newPtrPos = getParticle(idNew);
newPtrNeg = getParticle(-idNew);
assert (newPtrPos);
assert(newPtrNeg);
assert (newPtrPos->dataPtr());
assert(newPtrNeg->dataPtr());
}
void ClusterFissioner::drawNewFlavourEnhanced(PPtr& newPtrPos,PPtr& newPtrNeg,
Energy2 mass2) const {
if ( spectrum()->gluonId() != ParticleID::g )
throw Exception() << "strange enhancement only working with Standard Model hadronization"
<< Exception::runerror;
// Flavour is assumed to be only u, d, s, with weights
// (which are not normalized probabilities) given
// by the same weights as used in HadronsSelector for
// the decay of clusters into two hadrons.
double prob_d = 0.;
double prob_u = 0.;
double prob_s = 0.;
double scale = abs(double(sqr(_m0Fission)/mass2));
// Choose which splitting weights you wish to use
switch(abs(_fissionCluster)){
// 0: ClusterFissioner and ClusterDecayer use the same weights
case 0:
prob_d = _hadronSpectrum->pwtQuark(ParticleID::d);
prob_u = _hadronSpectrum->pwtQuark(ParticleID::u);
/* Strangeness enhancement:
Case 1: probability scaling
Case 2: Exponential scaling
*/
if (_enhanceSProb == 1)
prob_s = (_maxScale < scale) ? 0. : pow(_hadronSpectrum->pwtQuark(ParticleID::s),scale);
else if (_enhanceSProb == 2)
prob_s = (_maxScale < scale) ? 0. : exp(-scale);
break;
/* 1: ClusterFissioner uses its own unique set of weights,
i.e. decoupled from ClusterDecayer */
case 1:
prob_d = _fissionPwt.find(ParticleID::d)->second;
prob_u = _fissionPwt.find(ParticleID::u)->second;
if (_enhanceSProb == 1)
prob_s = (_maxScale < scale) ? 0. : pow(_fissionPwt.find(ParticleID::s)->second,scale);
else if (_enhanceSProb == 2)
prob_s = (_maxScale < scale) ? 0. : exp(-scale);
break;
default:
assert(false);
}
int choice = UseRandom::rnd3(prob_u, prob_d, prob_s);
long idNew = 0;
switch (choice) {
case 0: idNew = ThePEG::ParticleID::u; break;
case 1: idNew = ThePEG::ParticleID::d; break;
case 2: idNew = ThePEG::ParticleID::s; break;
}
newPtrPos = getParticle(idNew);
newPtrNeg = getParticle(-idNew);
assert (newPtrPos);
assert(newPtrNeg);
assert (newPtrPos->dataPtr());
assert(newPtrNeg->dataPtr());
}
Energy2 ClusterFissioner::clustermass(const ClusterPtr & cluster) const {
Lorentz5Momentum pIn = cluster->momentum();
Energy2 endpointmass2 = sqr(cluster->particle(0)->mass() +
cluster->particle(1)->mass());
Energy2 singletm2 = pIn.m2();
// Return either the cluster mass, or the lambda measure
return (_massMeasure == 0) ? singletm2 : singletm2 - endpointmass2;
}
Energy ClusterFissioner::drawChildMass(const Energy M, const Energy m1,
const Energy m2, const Energy m,
const double expt, const bool soft) const {
/***************************
* This method, given in input the cluster mass Mclu of an heavy cluster C,
* made of consituents of masses m1 and m2, draws the masses Mclu1 and Mclu2
* of, respectively, the children cluster C1, made of constituent masses m1
* and m, and cluster C2, of mass Mclu2 and made of constituent masses m2
* and m. The mass is extracted from one of the two following mass
* distributions:
* --- power-like ("normal" distribution)
* d(Prob) / d(M^exponent) = const
* where the exponent can be different from the two children C1 (exp1)
* and C2 (exponent2).
* --- exponential ("soft" distribution)
* d(Prob) / d(M^2) = exp(-b*M)
* where b = 2.0 / average.
* Such distributions are limited below by the masses of
* the constituents quarks, and above from the mass of decaying cluster C.
* The choice of which of the two mass distributions to use for each of the
* two cluster children is dictated by iRemnant (see below).
* If the number of attempts to extract a pair of mass values that are
* kinematically acceptable is above some fixed number (max_loop, see below)
* the method gives up and returns false; otherwise, when it succeeds, it
* returns true.
*
* These distributions have been modified from HERWIG:
* Before these were:
* Mclu1 = m1 + (Mclu - m1 - m2)*pow( rnd(), 1.0/exponent1 );
* The new one coded here is a more efficient version, same density
* but taking into account 'in phase space from' beforehand
***************************/
// hard cluster
if(!soft) {
return pow(UseRandom::rnd(pow((M-m1-m2-m)*UnitRemoval::InvE, expt),
pow(m*UnitRemoval::InvE, expt)), 1./expt
)*UnitRemoval::E + m1;
}
// Otherwise it uses a soft mass distribution
else {
static const InvEnergy b = 2.0 / _btClM;
Energy max = M-m1-m2-2.0*m;
double rmin = b*max;
rmin = ( rmin < 50 ) ? exp(-rmin) : 0.;
double r1;
do {
r1 = UseRandom::rnd(rmin, 1.0) * UseRandom::rnd(rmin, 1.0);
}
while (r1 < rmin);
return m1 + m - log(r1)/b;
}
}
void ClusterFissioner::calculateKinematics(const Lorentz5Momentum & pClu,
const Lorentz5Momentum & p0Q1,
const bool toHadron1,
const bool toHadron2,
Lorentz5Momentum & pClu1,
Lorentz5Momentum & pClu2,
Lorentz5Momentum & pQ1,
Lorentz5Momentum & pQbar,
Lorentz5Momentum & pQ,
Lorentz5Momentum & pQ2bar) const {
/******************
* This method solves the kinematics of the two body cluster decay:
* C (Q1 Q2bar) ---> C1 (Q1 Qbar) + C2 (Q Q2bar)
* In input we receive the momentum of C, pClu, and the momentum
* of the quark Q1 (constituent of C), p0Q1, both in the LAB frame.
* Furthermore, two boolean variables inform whether the two fission
* products (C1, C2) decay immediately into a single hadron (in which
* case the cluster itself is identify with that hadron) and we do
* not have to solve the kinematics of the components (Q1,Qbar) for
* C1 and (Q,Q2bar) for C2.
* The output is given by the following momenta (all 5-components,
* and all in the LAB frame):
* pClu1 , pClu2 respectively of C1 , C2
* pQ1 , pQbar respectively of Q1 , Qbar in C1
* pQ , pQ2bar respectively of Q , Q2 in C2
* The assumption, suggested from the string model, is that, in C frame,
* C1 and its constituents Q1 and Qbar are collinear, and collinear to
* the direction of Q1 in C (that is before cluster decay); similarly,
* (always in the C frame) C2 and its constituents Q and Q2bar are
* collinear (and therefore anti-collinear with C1,Q1,Qbar).
* The solution is then obtained by using Lorentz boosts, as follows.
* The kinematics of C1 and C2 is solved in their parent C frame,
* and then boosted back in the LAB. The kinematics of Q1 and Qbar
* is solved in their parent C1 frame and then boosted back in the LAB;
* similarly, the kinematics of Q and Q2bar is solved in their parent
* C2 frame and then boosted back in the LAB. In each of the three
* "two-body decay"-like cases, we use the fact that the direction
* of the motion of the decay products is known in the rest frame of
* their parent. This is obvious for the first case in which the
* parent rest frame is C; but it is also true in the other two cases
* where the rest frames are C1 and C2. This is because C1 and C2
* are boosted w.r.t. C in the same direction where their components,
* respectively (Q1,Qbar) and (Q,Q2bar) move in C1 and C2 rest frame
* respectively.
* Of course, although the notation used assumed that C = (Q1 Q2bar)
* where Q1 is a quark and Q2bar an antiquark, indeed everything remain
* unchanged also in all following cases:
* Q1 quark, Q2bar antiquark; --> Q quark;
* Q1 antiquark , Q2bar quark; --> Q antiquark;
* Q1 quark, Q2bar diquark; --> Q quark
* Q1 antiquark, Q2bar anti-diquark; --> Q antiquark
* Q1 diquark, Q2bar quark --> Q antiquark
* Q1 anti-diquark, Q2bar antiquark; --> Q quark
**************************/
// Calculate the unit three-vector, in the C frame, along which
// all of the constituents and children clusters move.
Lorentz5Momentum u(p0Q1);
u.boost( -pClu.boostVector() ); // boost from LAB to C
// the unit three-vector is then u.vect().unit()
// Calculate the momenta of C1 and C2 in the (parent) C frame first,
// where the direction of C1 is u.vect().unit(), and then boost back in the
// LAB frame.
if (pClu.m() < pClu1.mass() + pClu2.mass() ) {
throw Exception() << "Impossible Kinematics in ClusterFissioner::calculateKinematics() (A)"
<< Exception::eventerror;
}
Kinematics::twoBodyDecay(pClu, pClu1.mass(), pClu2.mass(),
u.vect().unit(), pClu1, pClu2);
// In the case that cluster1 does not decay immediately into a single hadron,
// calculate the momenta of Q1 (as constituent of C1) and Qbar in the
// (parent) C1 frame first, where the direction of Q1 is u.vect().unit(),
// and then boost back in the LAB frame.
if(!toHadron1) {
if (pClu1.m() < pQ1.mass() + pQbar.mass() ) {
throw Exception() << "Impossible Kinematics in ClusterFissioner::calculateKinematics() (B)"
<< Exception::eventerror;
}
Kinematics::twoBodyDecay(pClu1, pQ1.mass(), pQbar.mass(),
u.vect().unit(), pQ1, pQbar);
}
// In the case that cluster2 does not decay immediately into a single hadron,
// Calculate the momenta of Q and Q2bar (as constituent of C2) in the
// (parent) C2 frame first, where the direction of Q is u.vect().unit(),
// and then boost back in the LAB frame.
if(!toHadron2) {
if (pClu2.m() < pQ.mass() + pQ2bar.mass() ) {
throw Exception() << "Impossible Kinematics in ClusterFissioner::calculateKinematics() (C)"
<< Exception::eventerror;
}
Kinematics::twoBodyDecay(pClu2, pQ.mass(), pQ2bar.mass(),
u.vect().unit(), pQ, pQ2bar);
}
}
void ClusterFissioner::calculatePositions(const Lorentz5Momentum & pClu,
const LorentzPoint & positionClu,
const Lorentz5Momentum & pClu1,
const Lorentz5Momentum & pClu2,
LorentzPoint & positionClu1,
LorentzPoint & positionClu2) const {
// Determine positions of cluster children.
// See Marc Smith's thesis, page 127, formulas (4.122) and (4.123).
Energy Mclu = pClu.m();
Energy Mclu1 = pClu1.m();
Energy Mclu2 = pClu2.m();
// Calculate the unit three-vector, in the C frame, along which
// children clusters move.
Lorentz5Momentum u(pClu1);
u.boost( -pClu.boostVector() ); // boost from LAB to C frame
// the unit three-vector is then u.vect().unit()
Energy pstarChild = Kinematics::pstarTwoBodyDecay(Mclu,Mclu1,Mclu2);
// First, determine the relative positions of the children clusters
// in the parent cluster reference frame.
Energy2 mag2 = u.vect().mag2();
InvEnergy fact = mag2>ZERO ? 1./sqrt(mag2) : 1./GeV;
Length x1 = ( 0.25*Mclu + 0.5*( pstarChild + (sqr(Mclu2) - sqr(Mclu1))/(2.0*Mclu)))/_kappa;
Length t1 = Mclu/_kappa - x1;
LorentzDistance distanceClu1( x1 * fact * u.vect(), t1 );
Length x2 = (-0.25*Mclu + 0.5*(-pstarChild + (sqr(Mclu2) - sqr(Mclu1))/(2.0*Mclu)))/_kappa;
Length t2 = Mclu/_kappa + x2;
LorentzDistance distanceClu2( x2 * fact * u.vect(), t2 );
// Then, transform such relative positions from the parent cluster
// reference frame to the Lab frame.
distanceClu1.boost( pClu.boostVector() );
distanceClu2.boost( pClu.boostVector() );
// Finally, determine the absolute positions in the Lab frame.
positionClu1 = positionClu + distanceClu1;
positionClu2 = positionClu + distanceClu2;
}
bool ClusterFissioner::ProbabilityFunction(double scale, double threshold) {
double cut = UseRandom::rnd(0.0,1.0);
return 1./(1.+pow(abs((threshold-_probShift)/scale),_probPowFactor)) > cut ? true : false;
}
bool ClusterFissioner::ProbabilityFunctionPower(double Mass, double threshold) {
double cut = UseRandom::rnd(0.0,1.0);
if ((Mass-threshold)<=0)
return false;
return 1.0/(1.0 + _probPowFactor*pow(1.0/(Mass-threshold),_clPowLight)) > cut ? true : false;
}
bool ClusterFissioner::isHeavy(tcClusterPtr clu) {
// particle data for constituents
tcPDPtr cptr[3]={tcPDPtr(),tcPDPtr(),tcPDPtr()};
bool hasDiquark=0;
for(size_t ix=0;ix<min(clu->numComponents(),3);++ix) {
cptr[ix]=clu->particle(ix)->dataPtr();
// Assuming diquark masses are ordered with larger id corresponding to larger masses
if (DiquarkMatcher::Check(*(cptr[ix]))) {
hasDiquark=true;
break;
}
}
// different parameters for exotic, bottom and charm clusters
double clpow = !spectrum()->isExotic(cptr[0],cptr[1],cptr[1]) ? _clPowLight : _clPowExotic;
Energy clmax = !spectrum()->isExotic(cptr[0],cptr[1],cptr[1]) ? _clMaxLight : _clMaxExotic;
// if no heavy quark is found in the cluster, but diquarks are present use
// different ClMax and ClPow
if ( hasDiquark) {
clpow = _clPowDiquark;
clmax = _clMaxDiquark;
}
for ( const long& id : spectrum()->heavyHadronizingQuarks() ) {
if ( spectrum()->hasHeavy(id,cptr[0],cptr[1],cptr[1])) {
clpow = _clPowHeavy[id];
clmax = _clMaxHeavy[id];
}
}
// required test for SUSY clusters, since aboveCutoff alone
// cannot guarantee (Mc > m1 + m2 + 2*m) in cut()
static const Energy minmass
= getParticleData(ParticleID::d)->constituentMass();
bool aboveCutoff = false, canSplitMinimally = false;
// static kinematic threshold
if(_kinematicThresholdChoice == 0) {
aboveCutoff = (
pow(clu->mass()*UnitRemoval::InvE , clpow)
>
pow(clmax*UnitRemoval::InvE, clpow)
+ pow(clu->sumConstituentMasses()*UnitRemoval::InvE, clpow)
);
canSplitMinimally = clu->mass() > clu->sumConstituentMasses() + 2.0 * minmass;
}
// dynamic kinematic threshold
else if(_kinematicThresholdChoice == 1) {
//some smooth probablity function to create a dynamic thershold
double scale = pow(clu->mass()/GeV , clpow);
double threshold = pow(clmax/GeV, clpow)
+ pow(clu->sumConstituentMasses()/GeV, clpow);
aboveCutoff = ProbabilityFunction(scale,threshold);
scale = clu->mass()/GeV;
threshold = clu->sumConstituentMasses()/GeV + 2.0 * minmass/GeV;
canSplitMinimally = ProbabilityFunction(scale,threshold);
}
// probablistic kinematic threshold
else if(_kinematicThresholdChoice == 2) {
// Consistent power law for CF probability
double Mass = clu->mass()/GeV;
double threshold = clu->sumConstituentMasses()/GeV + 2.0 * minmass/GeV;
aboveCutoff = ProbabilityFunctionPower(Mass,threshold + clmax/GeV);
canSplitMinimally = Mass - threshold>ZERO;
}
return aboveCutoff && canSplitMinimally;
}
diff --git a/MatrixElement/FxFx/FxFxHandler.cc b/MatrixElement/FxFx/FxFxHandler.cc
--- a/MatrixElement/FxFx/FxFxHandler.cc
+++ b/MatrixElement/FxFx/FxFxHandler.cc
@@ -1,1655 +1,1665 @@
#include "FxFxHandler.h"
#include "FxFxReader.h"
#include "FxFxReader.fh"
#include "FxFxEventHandler.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "Herwig/Shower/QTilde/Base/PartnerFinder.h"
#include "Herwig/PDF/HwRemDecayer.h"
#include <queue>
#include "ThePEG/Utilities/Throw.h"
#include "Herwig/Shower/QTilde/Kinematics/KinematicsReconstructor.h"
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequence.hh"
#include "gsl/gsl_rng.h"
#include "gsl/gsl_randist.h"
#include <boost/algorithm/string.hpp>
using namespace Herwig;
using namespace ThePEG;
bool recordEntry(PPtr i,PPtr j) {
return (i->number()<j->number());
}
bool pTsortFunction(PPtr i,PPtr j) {
return (i->momentum().perp2()>j->momentum().perp2());
}
bool ETsortFunction(pair<Energy, Lorentz5Momentum> i,pair<Energy, Lorentz5Momentum> j) {
return (i.first>j.first);
}
bool isMomLessThanEpsilon(Lorentz5Momentum p,Energy epsilon) {
return (abs(p.x())<epsilon&&abs(p.y())<epsilon&&
abs(p.z())<epsilon&&abs(p.t())<epsilon);
}
FxFxHandler::FxFxHandler()
: ncy_(100),ncphi_(60),ihvy_(-999),nph_(-999),nh_(-999),
mergemode_(0), vetoHeavyQ_(true), vetoHeavyFlavour_(false), etclusmean_(20*GeV), jetAlgorithm_(1),vetoIsTurnedOff_(false),vetoSoftThanMatched_(false),etclusfixed_(true),epsetclus_(2.5*GeV),rclus_(0.4),etaclmax_(5.0),rclusfactor_(1.5), hpdetect_(true), ihrd_(-999),njets_(-999),drjmin_(-999), highestMultiplicity_(false), ycmax_(5.4),ycmin_(-5.4)
{}
void FxFxHandler::doinitrun() {
QTildeShowerHandler::doinitrun();
// et_ holds the ET deposited in the (ncy_ x ncphi_) calorimeter cells.
et_.resize(ncy_);
for(unsigned int ixx=0; ixx<et_.size(); ixx++) et_[ixx].resize(ncphi_);
// jetIdx_ for a given calorimeter cell this holds the index of the jet
// that the cell was clustered into.
jetIdx_.resize(ncy_);
for(unsigned int ixx=0; ixx<jetIdx_.size(); ixx++) jetIdx_[ixx].resize(ncphi_);
if(mergemode_ == 0) {
cout << "Merging mode is FxFx." << endl;
} else if (mergemode_ == 1) {
cout << "Merging mode is Tree level." << endl;
} else if (mergemode_ == 2) {
cout << "Merging mode is Tree level, using MadGraph Les Houches information." << endl;
}
if(hpdetect_ && mergemode_ != 2) {
cout << "Automatic detection of hard process enabled." << endl;
ihrd_ = -999;
}
}
IBPtr FxFxHandler::clone() const {
return new_ptr(*this);
}
IBPtr FxFxHandler::fullclone() const {
return new_ptr(*this);
}
void FxFxHandler::persistentOutput(PersistentOStream & os) const {
os << alphaS_
<< ncy_ << ncphi_ << ihvy_ << nph_ << nh_
<< ounit(etclusmean_,GeV) << rclus_ << etaclmax_ << rclusfactor_
<< ihrd_ << njets_ << drjmin_ << highestMultiplicity_
<< ycmax_ << ycmin_ << jetAlgorithm_ << vetoIsTurnedOff_ << vetoSoftThanMatched_ << etclusfixed_
<< cphcal_ << sphcal_ << cthcal_ << sthcal_ << ounit(epsetclus_,GeV) << vetoHeavyQ_ << mergemode_ << hpdetect_ << vetoHeavyFlavour_;
}
void FxFxHandler::persistentInput(PersistentIStream & is, int) {
is >> alphaS_
>> ncy_ >> ncphi_ >> ihvy_ >> nph_ >> nh_
>> iunit(etclusmean_,GeV) >> rclus_ >> etaclmax_ >> rclusfactor_
>> ihrd_ >> njets_ >> drjmin_ >> highestMultiplicity_
>> ycmax_ >> ycmin_ >> jetAlgorithm_ >> vetoIsTurnedOff_ >> vetoSoftThanMatched_ >> etclusfixed_
>> cphcal_ >> sphcal_ >> cthcal_ >> sthcal_ >> iunit(epsetclus_,GeV) >> vetoHeavyQ_ >> mergemode_ >> hpdetect_ >> vetoHeavyFlavour_;
}
ClassDescription<FxFxHandler> FxFxHandler::initFxFxHandler;
// Definition of the static class description member.
void FxFxHandler::Init() {
static ClassDocumentation<FxFxHandler> documentation
("The FxFxHandler class performs MEPS merging "
"using the MLM procedure.");
static Reference<FxFxHandler,ShowerAlpha> interfaceShowerAlpha
("ShowerAlpha",
"The object calculating the strong coupling constant",
&FxFxHandler::alphaS_, false, false, true, false, false);
static Parameter<FxFxHandler,int> interfaceihvy
("ihvy",
"heavy flavour in WQQ,ZQQ,2Q etc (4=c, 5=b, 6=t)",
&FxFxHandler::ihvy_, -999, -999, 7,
false, false, Interface::limited);
static Parameter<FxFxHandler,int> interfacenph
("nph",
"Number of photons in the AlpGen process",
&FxFxHandler::nph_, -999, -999, 7,
false, false, Interface::limited);
static Parameter<FxFxHandler,int> interfacenh
("nh",
"Number of higgses in the AlpGen process",
&FxFxHandler::nph_, -999, -999, 7,
false, false, Interface::limited);
static Parameter<FxFxHandler,Energy> interfaceETClus
("ETClus",
"The ET threshold defining a jet in the merging procedure",
&FxFxHandler::etclusmean_, GeV, 20*GeV, 0*GeV, 14000*GeV,
false, false, Interface::limited);
static Parameter<FxFxHandler,double> interfaceRClus
("RClus",
"The cone size used to define a jet in the merging procedure",
&FxFxHandler::rclus_, 0.4, 0.0, 4.0,
false, false, Interface::limited);
static Parameter<FxFxHandler,double> interfaceEtaClusMax
("EtaClusMax",
"The maximum |eta| used to define a jet in the merging procedure",
&FxFxHandler::etaclmax_, 5.0, 0.0, 15.0,
false, false, Interface::limited);
static Parameter<FxFxHandler,double> interfaceRClusFactor
("RClusFactor",
"The prefactor for RClus used to define the jet-parton matching "
"distance",
&FxFxHandler::rclusfactor_, 1.5, 0.0, 4.0,
false, false, Interface::limited);
static Parameter<FxFxHandler,int> interfaceihrd
("ihrd",
"The hard process code",
&FxFxHandler::ihrd_, -999, 0, 10000,
false, false, Interface::limited);
static Parameter<FxFxHandler,int> interfacenjetsmax
("njetsmax",
"The number of light jets in the maximum-multiplicity process",
&FxFxHandler::njets_, -999, 0, 10000,
false, false, Interface::limited);
static Parameter<FxFxHandler,double> interfacedrjmin
("drjmin",
"Mimimum parton-parton R-sep used for generation.",
&FxFxHandler::drjmin_, 0.7, 0.0, 4.0,
false, false, Interface::limited);
- static Parameter<FxFxHandler,bool> interfacehighestMultiplicity
+ static Switch<FxFxHandler,bool> interfacehighestMultiplicity
("highestMultiplicity",
- "If true it indicates that this is the highest multiplicity input "
- "ME-level configuration to be processed.",
- &FxFxHandler::highestMultiplicity_, 0, 0, 1,
- false, false, Interface::limited);
+ "If true it indicates that this is the highest multiplicity input ME-level configuration to be processed.",
+ &FxFxHandler::highestMultiplicity_, false, false, false);
+ static SwitchOption interfacehighestMultiplicityYes
+ (interfacehighestMultiplicity,
+ "Yes",
+ "Highest Multiplicity",
+ true);
+ static SwitchOption interfacehighestMultiplicityNo
+ (interfacehighestMultiplicity,
+ "No",
+ "Not the highest multiplicity",
+ false);
- static Parameter<FxFxHandler,bool> interfaceETClusFixed
+ static Switch<FxFxHandler,bool> interfaceETClusFixed
("ETClusFixed",
- "If false, indicates that the jet merging scale, etclus_ is allowed to vary"
- "according to epsetclus_",
- &FxFxHandler::etclusfixed_, 1, 0, 1,
- false, false, Interface::limited);
-
- static Parameter<FxFxHandler,Energy> interfaceEpsilonETClus
- ("EpsilonETClus",
- "The ET threshold defining a jet in the merging procedure",
- &FxFxHandler::epsetclus_, GeV, 2.5*GeV, 0*GeV, 100.0*GeV,
- false, false, Interface::limited);
+ "If false, indicates that the jet merging scale, etclus_ is allowed to vary according to epsetclus_",
+ &FxFxHandler::etclusfixed_, true, false, false);
+ static SwitchOption interfaceETClusFixedYes
+ (interfaceETClusFixed,
+ "Yes",
+ "Fixed",
+ true);
+ static SwitchOption interfaceETClusFixedNo
+ (interfaceETClusFixed,
+ "No",
+ "Varying",
+ false);
static Switch<FxFxHandler,int> interfaceJetAlgorithm
("JetAlgorithm",
"Determines the jet algorithm for finding jets in parton-jet "
"matching in the MLM procedure.",
&FxFxHandler::jetAlgorithm_, 1, false, false);
static SwitchOption AntiKt
(interfaceJetAlgorithm,
"AntiKt",
"The anti-kt jet algorithm.",
-1);
static SwitchOption CambridgeAachen
(interfaceJetAlgorithm,
"CambridgeAachen",
"The Cambridge-Aachen jet algorithm.",
0);
static SwitchOption Kt
(interfaceJetAlgorithm,
"Kt",
"The Kt jet algorithm.",
1);
static Switch<FxFxHandler,int> interfaceMergeMode
("MergeMode",
"The choice of merging mode",
&FxFxHandler::mergemode_, 0, false, false);
static SwitchOption FxFx
(interfaceMergeMode,
"FxFx",
"FxFx merging.",
0);
static SwitchOption Tree
(interfaceMergeMode,
"Tree",
"Tree-level merging.",
1);
static SwitchOption TreeMG
(interfaceMergeMode,
"TreeMG5",
"Tree-level merging using the MadGraph pt clustering information.",
2);
static Switch<FxFxHandler,bool> interfaceHardProcessDetection
("HardProcessDetection",
"The choice of merging mode",
&FxFxHandler::hpdetect_, true, false, false);
static SwitchOption Automatic
(interfaceHardProcessDetection,
"Automatic",
"Automatically determine which particles to include in the merging.",
true);
static SwitchOption Manual
(interfaceHardProcessDetection,
"Manual",
"Use the ihrd code to determine which particles to include in the merging.",
false);
static Switch<FxFxHandler,bool> interfaceVetoIsTurnedOff
("VetoIsTurnedOff",
"Allows the vetoing mechanism to be switched off.",
&FxFxHandler::vetoIsTurnedOff_, false, false, false);
static SwitchOption VetoingIsOn
(interfaceVetoIsTurnedOff,
"VetoingIsOn",
"The MLM merging veto mechanism is switched ON.",
false);
static SwitchOption VetoingIsOff
(interfaceVetoIsTurnedOff,
"VetoingIsOff",
"The MLM merging veto mechanism is switched OFF.",
true);
static Switch<FxFxHandler,bool> interfaceVetoHeavyFlavour
("VetoHeavyFlavour",
"Allows the heavy flavour vetoing mechanism to be switched off.",
&FxFxHandler::vetoHeavyFlavour_, false, false, false);
static SwitchOption HeavyFVetoingIsOn
(interfaceVetoHeavyFlavour,
"Yes",
"The MLM merging veto mechanism for heavy flavour is switched ON.",
true);
static SwitchOption HeavyFVetoingIsOff
(interfaceVetoHeavyFlavour,
"No",
"The MLM merging veto mechanism for heavy flavour is switched OFF.",
false);
static Switch<FxFxHandler,bool> interfaceHeavyQVeto
("HeavyQVeto",
"Allows the vetoing mechanism on the heavy quark products to be switched off.",
&FxFxHandler::vetoHeavyQ_, false, false, false);
static SwitchOption HQVetoingIsOn
(interfaceHeavyQVeto,
"Yes",
"The MLM merging veto on Heavy quark decay produts mechanism is switched ON.",
true);
static SwitchOption HQVetoingIsOff
(interfaceHeavyQVeto,
"No",
"The MLM merging veto on Heavy quark decay products mechanism is switched OFF.",
false);
static Switch<FxFxHandler,bool> interfaceVetoSoftThanMatched
("VetoSoftThanMatched",
"Allows the vetoing mechanism to be switched off.",
&FxFxHandler::vetoSoftThanMatched_, false, false, false);
static SwitchOption VetoSoftIsOn
(interfaceVetoSoftThanMatched,
"VetoSoftIsOn",
"The vetoing of highest-mult. events with jets softer than matched ones is ON",
true);
static SwitchOption VetoSoftIsOff
(interfaceVetoSoftThanMatched,
"VetoSoftIsOff",
"The vetoing of highest-mult. events with jets softer than matched ones is OFF.",
false);
}
void FxFxHandler::dofinish() {
QTildeShowerHandler::dofinish();
}
void FxFxHandler::doinit() {
//print error if HardProcID is not set in input file
if(ihrd_ == -999 && !hpdetect_) { cout << "Error: FxFxHandler:ihrd not set and FxFx:HardProcessDetection set to Manual!" << endl; exit(1); }
QTildeShowerHandler::doinit();
// Compute calorimeter edges in rapidity for GetJet algorithm.
ycmax_=etaclmax_+rclus_;
ycmin_=-ycmax_;
}
// Throws a veto according to MLM strategy ... when we finish writing it.
bool FxFxHandler::showerHardProcessVeto() const {
int debug_mode = 0;
if(vetoIsTurnedOff_) {
// cout << "Vetoing is turned OFF." << endl;
return false;
}
//if(debug_mode) { cout << "debug_mode = " << 5 << endl; }
// Skip veto for processes in which merging is not implemented:
if(ihrd_==7||ihrd_==8||ihrd_==13) {
ostringstream wstring;
wstring << "FxFxHandler::showerHardProcessVeto() - warning."
<< "MLM merging not implemented "
<< "processes 4Q (ihrd=7), QQh (ihrd=8), "
<< "(single) top (ihrd=13) \n";
generator()->logWarning( Exception(wstring.str(),
Exception::warning) );
return false;
}
// Fill preshowerISPs_ pair and preshowerFSPs_ particle pointer vector.
getPreshowerParticles();
// Fill showeredISHs_, showeredISPs and showeredRems pairs, as well as
// showeredFSPs_ particle pointer vector.
getShoweredParticles();
// Turn on some screen output debugging: 0 = none ---> 5 = very verbose.
doSanityChecks(debug_mode);
// Dimensions of each calorimter cell in y and phi.
dely_ = (ycmax_-ycmin_)/double(ncy_);
delphi_ = 2*M_PI/double(ncphi_);
// Fill partonsToMatch_ with only those pre-shower partons intended to
// used in jet-parton matching and fill particlesToCluster_ using only
// those final state particles (post-shower) which are supposed to go
// in the jet clustering used to do merging.
partonsToMatch_ = preshowerFSPs_;
particlesToCluster_ = showeredFSPs_ ;
// Filter out all but the 'extra' light-parton progenitors and their
// associated final state particles.
if(mergemode_ == 0 || mergemode_ == 1) { caldel_m(); }
else if(mergemode_ == 2) { caldel_mg(); }
double prob(1);
//if etclusfixed_ then set the etclus_ to the fixed chosen value
if(etclusfixed_) {
etclus_ = etclusmean_;
} else {
//else, if we wish to vary etclus_, we use the probability distribution
//choose a probability between 0 and 1
prob = rnd();
etclus_ = etclusran_(prob);
}
// Cluster particlesToCluster_ into jets with FastJet.
getFastJets(rclus_,etclus_,etaclmax_);
if(mergemode_ == 0) {
// Get npLO_ and npNLO_ for FxFx matching
getnpFxFx();
// print the npXLO_ values obtained
// cout << "HANDLER:\t\t\t\t" << npLO_ << "\t\t" << npNLO_ << endl;
//FxFx modifications start here.
// Sort partonsToMatch_ from high to low pT.
sort(partonsToMatch_.begin(),partonsToMatch_.end(),pTsortFunction);
// Count the number of jets.
int njets_found(pjet_.size());
// If the number of jets found is not equal to the number of partons in the Born
// (i.e., the number of partons in the S-event, or one less than the number of partons in an H-event),
// the jets cannot be matched and the event has to be rejected. The number of partons in the Born is written in the event file with a name “npNLO”
// if there are no jets to match and no jets have been found, do not veto.
if(njets_found == 0 && npNLO_ == 0) { /*cout << "njets_found = " << njets_found << " and npNLO = " << npNLO_ << ", accepting" << endl;*/ return false; }
//if the number of jets is smaller than npNLO -> reject the event.
if(njets_found < npNLO_) { /*cout << "njets_found = " << njets_found << " and npNLO = " << npNLO_ << ", rejecting" << endl;*/ return true; }
// For the maximum-multiplicity sample, the number of jets obtained does not have to be exactly equal to npNLO, it may also be larger;
if(njets_found > npNLO_ && npNLO_ != njets_) { /*cout << "njets_found = " << njets_found << " and npNLO = " << npNLO_ << ", rejecting" << endl;*/ return true; }
// Create the matrix-element jets.
// Cluster also the partons at the hard-matrix element level into jets with the same algorithm as above,
// but without the requirement of a minimal pT on the jets (or set it very small).
// By construction, for S-events you should find exactly npNLO jets, while for the H-events it is either npNLO or npNLO+1.
// Cluster partonsToMatch_ into jets with FastJet.
getFastJetsToMatch(rclus_);
//int me_njets_found(pjetME_.size());
// cout << "number of ME jets found = " << me_njets_found << "partons to match: " << partonsToMatch_.size() << endl;
// Match light progenitors to jets.
vector<int> jetToPartonMap(pjetME_.size(),-999);
Energy etmin(777e100*GeV);
// Match the jets.
// Try to match the “npNLO” hardest jets created post-shower with any of the jets pre-shower. Two jets are matched if the distance between them is smaller than 1.5*DeltaR.
// If not all the npNLO hardest shower jets are matched the event has to be rejected.
// Note that if the current event does not belong to the maximum multiplicity sample, this means that all the shower jets need to be matched, because the requirement above already rejects
// events that do not have npNLO shower jets.
// For those events, at the level of the matrix elements there can either be npNLO or npNLO+1 matrix-element jets, depending on S- or H-events and the kinematics of those partons.
// Still only the shower jets need to be matched, so an event should not be rejected if a matrix-element jet cannot be matched.
// For each parton, starting with the hardest one ...
for(int ixx=0; ixx<npNLO_; ixx++) {
// ... loop over all jets not already matched.
double DRmin(777e100);
int jetIndexForDRmin(-999);
for(unsigned int jxx=0; jxx<pjetME_.size(); jxx++) {
// ... and tag closest of the remaining ones
double DRpartonJet(partonJetDeltaR(pjetME_[ixx],pjet_[jxx]));
if(jetToPartonMap[jxx]<0&&DRpartonJet<DRmin) {
DRmin=DRpartonJet;
jetIndexForDRmin=jxx;
}
}
// If the parton-jet distance is less than the matching
// distance, the parton and jet match.
if(DRmin<rclus_*rclusfactor_&&jetIndexForDRmin>=0) {
jetToPartonMap[jetIndexForDRmin]=ixx;
if(ixx==0||etjet_[jetIndexForDRmin]<etmin)
etmin=etjet_[jetIndexForDRmin];
// Otherwise this parton is not matched so veto the event.
} else return true;
}
// Veto events where matched jets are softer than non-matched ones,
// in the inclusive (highestMultiplicity_ = true) mode, unless we
// are dealing with NLO input events.
if(npNLO_ == njets_ && vetoSoftThanMatched_) {
//cout << "highest mult. event being tested for softer jets than matched..." << endl;
for(unsigned int iyy=0; iyy<pjet_.size(); iyy++) {
//cout << "etjet_[iyy] = " << etjet_[iyy]/GeV << endl;
if(jetToPartonMap[iyy]<0&&etmin<etjet_[iyy]) { /*cout << "VETO!" << endl;*/ return true; }
}
}
if(!vetoHeavyQ_) {
//cout << "no heavy quark decay product veto!" << endl;
return false;
}
//end of FxFx part
// **************************************************************** //
// * Now look to the non-light partons for heavy quark processes. * //
// **************************************************************** //
if( (ihrd_<=2||ihrd_==6||ihrd_==10||ihrd_==15||ihrd_==16) || (hpdetect_==true && hvqfound==true) ) {
// Extract heavy quark progenitors and the radiation they
// produce and put it in the calorimeter.
caldel_hvq();
// Cluster particlesToCluster_ into jets with FastJet.
getFastJets(rclus_,etclus_,etaclmax_);
// If the radiation from the heavy quarks does not give rise
// to any jets we accept event.
if(pjet_.size() == 0) return false;
// If extra jets emerge from the jet clustering we only
// accept events where the jets formed by radiation from
// b and c quarks lies within drjmin_ of the heavy quark
// progenitor.
int nmjet(pjet_.size());
for(unsigned int ixx=0; ixx<pjet_.size(); ixx++) {
for(unsigned int jxx=0; jxx<partonsToMatch_.size(); jxx++) {
if(!(abs(partonsToMatch_[jxx]->id())==4||abs(partonsToMatch_[jxx]->id())==5)) continue;
if(partonJetDeltaR(partonsToMatch_[jxx],pjet_[ixx])<drjmin_) {
nmjet--; // Decrease the number of unmatched jets.
etjet_[ixx]=0*GeV; // Set jet ET to zero to indicate it is 'matched'.
}
}
}
// If every jet matched to _at_least_one_ progenitor accept the event.
if(nmjet<=0) return false;
}
}
/*****
*****
***** END of mergemode_ == 0 (i.e. FxFx MERGING BLOCK)
*****/
if(mergemode_ == 1 || mergemode_ == 2) {
// determine whether event is of highest multiplicity or not
unsigned long int njets_long = njets_;
if(partonsToMatch_.size()==njets_long) { highestMultiplicity_ = true; }
// cout << "jet finding gives pjet_.size() = " << pjet_.size() << endl;
// If there are less jets than partons then parton-jet matching is
// bound to fail: reject the event already. Also, if the input is
// an NLO event file it will 99.5% of the time contain a number of
// light partons in the F.S. equal to that in the real emission
// process in the NLO calculation, moreover, it has already
// effectively merged njets_-1 and njets jet events. So in that
// case we do not reject events on the grounds they have jet
// multiplicity less than partonsToMatch_.size() but rather less
// jets than partonsToMatch.size()-1; such events are better
// described by the lower-by-one-unit (partonsToMatch_.size()-1)
// of multiplicity NLO event file, or the lower-by-two-units
// (partonsToMatch_.size()-2) of multiplicity LO event file.
// If it is not jet production apply rejection criterion as above.
if(ihrd_!=9) {
if(pjet_.size() < partonsToMatch_.size()) return true;
}
// Otherwise, in the case of jet production allow the lowest
// contributing multiplicity process (just at NLO), namely,
// dijet production, to give rise to 1-jet and even 0-jet
// events, since these can contribute to, for example, the
// inclusive jet cross section i.e. in this case the rejection
// is only applied in the case of the next-to-lowest multiplicity
// processes (>2 parton events at LO and >3 parton events at NLO).
else {
// KH - March 5th
// Removed the following line giving special treatment
// also to the LO events, to maintain consistency with
// the fortran algorithm, at least for now. So now jet
// production at LO is being treated the same as all
// other processes.
// if(partonsToMatch_.size()==2 && pjet_.size()<2) return false;
if(pjet_.size() < partonsToMatch_.size()) return true;
}
// Sort partonsToMatch_ from high to low pT.
sort(partonsToMatch_.begin(),partonsToMatch_.end(),pTsortFunction);
// Match light progenitors to jets.
vector<int> jetToPartonMap(pjet_.size(),-999);
Energy etmin(777e100*GeV);
// For each parton, starting with the hardest one ...
for(unsigned int ixx=0; ixx<partonsToMatch_.size(); ixx++) {
// ... loop over all jets not already matched.
double DRmin(777e100);
int jetIndexForDRmin(-999);
for(unsigned int jxx=0; jxx<pjet_.size(); jxx++) {
// ... and tag closest of the remaining ones
double DRpartonJet(partonJetDeltaR(partonsToMatch_[ixx],pjet_[jxx]));
if(jetToPartonMap[jxx]<0&&DRpartonJet<DRmin) {
DRmin=DRpartonJet;
jetIndexForDRmin=jxx;
}
}
// If the parton-jet distance is less than the matching
// distance, the parton and jet match.
if(DRmin<rclus_*rclusfactor_&&jetIndexForDRmin>=0) {
jetToPartonMap[jetIndexForDRmin]=ixx;
if(ixx==0||etjet_[jetIndexForDRmin]<etmin)
etmin=etjet_[jetIndexForDRmin];
// Otherwise this parton is not matched so veto the event.
} else return true;
}
// Veto events with larger jet multiplicity from exclusive sample.
if(!highestMultiplicity_&&pjet_.size()>partonsToMatch_.size()) return true;
// Veto events where matched jets are softer than non-matched ones,
// in the inclusive (highestMultiplicity_ = true) mode, unless we
// are dealing with NLO input events.
if(highestMultiplicity_) {
for(unsigned int ixx=0; ixx<pjet_.size(); ixx++)
if(jetToPartonMap[ixx]<0&&etmin<etjet_[ixx]) return true;
}
if(!vetoHeavyQ_) {
//cout << "no heavy quark decay product veto!" << endl;
return false;
}
// **************************************************************** //
// * Now look to the non-light partons for heavy quark processes. * //
// **************************************************************** //
if( (ihrd_<=2||ihrd_==6||ihrd_==10||ihrd_==15||ihrd_==16) || (hpdetect_==true && hvqfound==true)) {
// Extract heavy quark progenitors and the radiation they
// produce and put it in the calorimeter.
caldel_hvq();
// Cluster particlesToCluster_ into jets with FastJet.
getFastJets(rclus_,etclus_,etaclmax_);
// If the radiation from the heavy quarks does not give rise
// to any jets we accept event.
if(pjet_.size() == 0) return false;
// If extra jets emerge from the jet clustering we only
// accept events where the jets formed by radiation from
// b and c quarks lies within drjmin_ of the heavy quark
// progenitor.
int nmjet(pjet_.size());
for(unsigned int ixx=0; ixx<pjet_.size(); ixx++) {
for(unsigned int jxx=0; jxx<partonsToMatch_.size(); jxx++) {
if(!(abs(partonsToMatch_[jxx]->id())==4||abs(partonsToMatch_[jxx]->id())==5)) continue;
if(partonJetDeltaR(partonsToMatch_[jxx],pjet_[ixx])<drjmin_) {
nmjet--; // Decrease the number of unmatched jets.
etjet_[ixx]=0*GeV; // Set jet ET to zero to indicate it is 'matched'.
}
}
}
// If every jet matched to _at_least_one_ progenitor accept the event.
if(nmjet<=0) return false;
else {
// If unmatched jets remain, reject the event if highestMultiplicity_!=1
if(!highestMultiplicity_) return true;
else {
// If unmatched jets remain and highestMultiplicity is true then check
// that these are softer than all the matched ones (from the light-parton
// matching round).
Energy etmax(0.*GeV);
for(unsigned int ixx=0; ixx<pjet_.size(); ixx++) etmax=max(etjet_[ixx],etmax);
if(etmax>etmin) return true;
}
}
}
}
// Otherwise we accept the event ...
return false;
}
/* Function that returns the R distance
between a particle and a jet. */
double FxFxHandler::partonJetDeltaR(ThePEG::tPPtr partonptr, LorentzMomentum jetmom) const {
LorentzMomentum partonmom(partonptr->momentum());
// Calculate DY, DPhi and then DR
double DY(partonmom.eta()-jetmom.eta());
double DPhi(partonmom.phi()-jetmom.phi());
if(DPhi>M_PI) DPhi=2*M_PI-DPhi;
double DR(sqrt(sqr(DY)+sqr(DPhi)));
return DR;
}
double FxFxHandler::partonJetDeltaR(LorentzMomentum jetmom1, LorentzMomentum jetmom2) const {
// Calculate DY, DPhi and then DR
double DY(jetmom1.eta()-jetmom2.eta());
double DPhi(jetmom1.phi()-jetmom2.phi());
if(DPhi>M_PI) DPhi=2*M_PI-DPhi;
double DR(sqrt(sqr(DY)+sqr(DPhi)));
return DR;
}
// Get FastJets
void FxFxHandler::getFastJets(double rjet, Energy ejcut, double etajcut) const {
vector<fastjet::PseudoJet> particlesToCluster;
for(unsigned int ipar=0; ipar<particlesToCluster_.size(); ipar++) {
double y(particlesToCluster_[ipar]->momentum().eta());
if(y>=ycmin_&&y<=ycmax_) {
int absId(abs(particlesToCluster_[ipar]->id()));
// If it's not a lepton / top / photon it may go in the jet finder.
if(!(absId>=11&&absId<=16) && absId!=6 && absId!=22) {
// input particles into fastjet pseudojet
fastjet::PseudoJet p(particlesToCluster_[ipar]->momentum().x()/GeV,
particlesToCluster_[ipar]->momentum().y()/GeV,
particlesToCluster_[ipar]->momentum().z()/GeV,
particlesToCluster_[ipar]->momentum().e()/GeV);
p.set_user_index(ipar);
particlesToCluster.push_back(p);
}
}
}
fastjet::RecombinationScheme recombinationScheme = fastjet::E_scheme;
fastjet::Strategy strategy = fastjet::Best;
double R(rjet);
fastjet::JetDefinition theJetDefinition;
switch (jetAlgorithm_) {
case -1: theJetDefinition=fastjet::JetDefinition(fastjet::antikt_algorithm,
R,
recombinationScheme,
strategy); break;
case 0: theJetDefinition=fastjet::JetDefinition(fastjet::cambridge_algorithm,
R,
recombinationScheme,
strategy); break;
case 1: theJetDefinition=fastjet::JetDefinition(fastjet::kt_algorithm,
R,
recombinationScheme,
strategy); break;
default: theJetDefinition=fastjet::JetDefinition(fastjet::cambridge_algorithm,
R,
recombinationScheme,
strategy); break;
}
fastjet::ClusterSequence fastjetEvent(particlesToCluster,theJetDefinition);
vector<fastjet::PseudoJet> inclusiveJets = fastjetEvent.inclusive_jets();
inclusiveJets = fastjet::sorted_by_pt(inclusiveJets);
// Fill the array of jet momenta for the rest of the veto procedure.
pjet_.clear();
pjet_.resize(inclusiveJets.size());
etjet_.clear();
etjet_.resize(inclusiveJets.size());
for(unsigned int ffj=0; ffj<pjet_.size();ffj++) {
pjet_[ffj] = Lorentz5Momentum(inclusiveJets[ffj].px()*GeV,
inclusiveJets[ffj].py()*GeV,
inclusiveJets[ffj].pz()*GeV,
inclusiveJets[ffj].e()*GeV);
pjet_[ffj].rescaleMass();
etjet_[ffj] = pjet_[ffj].et();
}
// Throw the jet away if it's outside required eta region or
// has transverse energy below ejcut.
for(unsigned int fj=0; fj<pjet_.size(); fj++)
if(etjet_[fj]<ejcut||fabs(pjet_[fj].eta())>etajcut) {
pjet_.erase(pjet_.begin()+fj);
etjet_.erase(etjet_.begin()+fj);
fj--;
}
// Sort jets from high to low ET.
vector<pair<Energy, Lorentz5Momentum> > etjet_pjet;
for(unsigned int ixx=0; ixx<etjet_.size(); ixx++)
etjet_pjet.push_back(make_pair(etjet_[ixx],pjet_[ixx]));
sort(etjet_pjet.begin(),etjet_pjet.end(),ETsortFunction);
for(unsigned int ixx=0; ixx<etjet_.size(); ixx++) {
etjet_[ixx]=etjet_pjet[ixx].first;
pjet_[ixx]=etjet_pjet[ixx].second;
}
return;
}
// Get FastJets from partonsToMatch_
void FxFxHandler::getFastJetsToMatch(double rjet) const {
vector<fastjet::PseudoJet> particlesToCluster;
for(unsigned int ipar=0; ipar<partonsToMatch_.size(); ipar++) {
double y(partonsToMatch_[ipar]->momentum().eta());
if(y>=ycmin_&&y<=ycmax_) {
int absId(abs(partonsToMatch_[ipar]->id()));
// If it's not a lepton / top / photon it may go in the jet finder.
if(!(absId>=11&&absId<=16) && absId!=6 && absId!=22) {
// input particles into fastjet pseudojet
fastjet::PseudoJet p(partonsToMatch_[ipar]->momentum().x()/GeV,
partonsToMatch_[ipar]->momentum().y()/GeV,
partonsToMatch_[ipar]->momentum().z()/GeV,
partonsToMatch_[ipar]->momentum().e()/GeV);
p.set_user_index(ipar);
particlesToCluster.push_back(p);
}
}
}
fastjet::RecombinationScheme recombinationScheme = fastjet::E_scheme;
fastjet::Strategy strategy = fastjet::Best;
double R(rjet);
fastjet::JetDefinition theJetDefinition;
switch (jetAlgorithm_) {
case -1: theJetDefinition=fastjet::JetDefinition(fastjet::antikt_algorithm,
R,
recombinationScheme,
strategy); break;
case 0: theJetDefinition=fastjet::JetDefinition(fastjet::cambridge_algorithm,
R,
recombinationScheme,
strategy); break;
case 1: theJetDefinition=fastjet::JetDefinition(fastjet::kt_algorithm,
R,
recombinationScheme,
strategy); break;
default: theJetDefinition=fastjet::JetDefinition(fastjet::cambridge_algorithm,
R,
recombinationScheme,
strategy); break;
}
fastjet::ClusterSequence fastjetEvent(particlesToCluster,theJetDefinition);
vector<fastjet::PseudoJet> inclusiveJets = fastjetEvent.inclusive_jets();
inclusiveJets = fastjet::sorted_by_pt(inclusiveJets);
// Fill the array of jet momenta for the rest of the veto procedure.
pjetME_.clear();
pjetME_.resize(inclusiveJets.size());
for(unsigned int ffj=0; ffj<pjetME_.size();ffj++) {
pjetME_[ffj] = Lorentz5Momentum(inclusiveJets[ffj].px()*GeV,
inclusiveJets[ffj].py()*GeV,
inclusiveJets[ffj].pz()*GeV,
inclusiveJets[ffj].e()*GeV);
pjetME_[ffj].rescaleMass();
}
return;
}
// Deletes particles from partonsToMatch_ and particlesToCluster_
// vectors so that these contain only the partons to match to the
// jets and the particles used to build jets respectively. By and
// large the candidates for deletion are: vector bosons and their
// decay products, Higgs bosons, photons as well as _primary_, i.e.
// present in the lowest multiplicity process, heavy quarks and
// any related decay products.
void FxFxHandler::getDescendents(PPtr theParticle) const {
ParticleVector theChildren(theParticle->children());
for (unsigned int ixx=0; ixx<theChildren.size(); ixx++)
if(theChildren[ixx]->children().size()==0)
tmpList_.push_back(theChildren[ixx]);
else
getDescendents(theChildren[ixx]);
return;
}
void FxFxHandler::caldel_m() const {
preshowerFSPsToDelete_.clear();
showeredFSPsToDelete_.clear();
hvqfound = false;
if(hpdetect_ && mergemode_!=2) {
for(unsigned int ixx=0; ixx<preshowerFSPs_.size(); ixx++) {
tmpList_.clear();
/* Exclude the top quarks and any children
they may have produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==6) {
hvqfound = true;
// cout << "preshowerFSPs_[ixx]->id() = " << preshowerFSPs_[ixx]->id() << " " << preshowerFSPs_[ixx]->momentum().perp2() << endl;
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]->parents()[0]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++) {
// cout << "tmpList_[jxx]->id() = " << tmpList_[jxx]->id() << " " << tmpList_[jxx]->momentum().perp2() << endl;
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
continue;
}
/* Exclude the v.bosons and any children they may
have produced from the jet parton matching. */
if( (abs(preshowerFSPs_[ixx]->parents()[0]->id())==23||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24||
abs(preshowerFSPs_[ixx]->id())==22||
abs(preshowerFSPs_[ixx]->id())==25|| (abs(preshowerFSPs_[ixx]->id()) < 17 && abs(preshowerFSPs_[ixx]->id()) > 10)) && (abs(preshowerFSPs_[ixx]->parents()[0]->id())!=6)) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
continue;
}
/* Exclude the bottom quarks and any children
they may have produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->id())==5&&ixx<2) {
hvqfound = true;
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
continue;
}
}
}
if(!hpdetect_) {
for(unsigned int ixx=0; ixx<preshowerFSPs_.size(); ixx++) {
tmpList_.clear();
if(ihrd_<=2) {
/* wqq... , zqq... */
/* Exclude the heavy quarks and any children they may
have produced as well as the v.boson and any children
it may have produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==23||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
if(abs(preshowerFSPs_[ixx]->id())==ihvy_&&ixx<2) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=4) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wqq / zqq process should have 4 particles to omit from"
<< "jet-parton matching for ihvy=" << ihvy_ << "." << Exception::eventerror;
}
} else if(ihrd_<=4) {
/* zjet... */
/* Exclude the v.boson and any children
it may have produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==23||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
/*if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=2) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "zjet process should have 2 particles to omit from"
<< "jet-parton matching." << Exception::eventerror;
}*/
} else if(ihrd_==5) {
/* vbjet... */
/* Exclude the v.bosons and any children they may
have produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==23||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24||
abs(preshowerFSPs_[ixx]->id())==22||
abs(preshowerFSPs_[ixx]->id())==25) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
} else if(ihrd_==6) {
/* 2Q... */
/* Exclude the heavy quarks and any children
they may have produced from the jet parton matching. */
if(ihvy_==6) {
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==6||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
// cout << "preshowerFSPs_[ixx]->id() = " << preshowerFSPs_[ixx]->id() << " " << preshowerFSPs_[ixx]->momentum().perp2() << endl;
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
}
if(abs(preshowerFSPs_[ixx]->parents()[0]->id())==6) {
getDescendents(preshowerFSPs_[ixx]->parents()[0]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++) {
// cout << "tmpList_[jxx]->id() = " << tmpList_[jxx]->id() << " " << tmpList_[jxx]->momentum().perp2() << endl;
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
}
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=6) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "2Q process should have 6 particles to omit from"
<< "jet-parton matching for ihvy=" << ihvy_ << "." << Exception::eventerror;
}
} else {
if(abs(preshowerFSPs_[ixx]->id())==ihvy_&&ixx<2) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=2) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "2Q process should have 2 particles to omit from"
<< "jet-parton matching for ihvy=" << ihvy_ << "." << Exception::eventerror;
}
}
} else if(ihrd_==7) {
/* 4Q... */
/* There are no light jets for this process, so nothing to match. */
} else if(ihrd_==9) {
/* Njet... */
} else if(ihrd_==10) {
/* wcjet... */
/* Exclude the charm quark and any children it may
have produced as well as the v.boson and any children
it may have produced from the jet parton matching. */
if((abs(preshowerFSPs_[ixx]->id())==4&&ixx<1)||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=3) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wcjet process should have 3 particles to omit from"
<< "jet-parton matching." << Exception::eventerror;
}
} else if(ihrd_==11) {
/* phjet... */
/* Exclude the hard photons from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->id())==22) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
unsigned int tmpUnsignedInt(nph_);
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=tmpUnsignedInt) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "phjet process should have " << nph_ << " particles to omit from"
<< "jet-parton matching." << Exception::eventerror;
}
} else if(ihrd_==12) {
/* hjet... */
/* Exclude the higgs and any children it may have
produced from the jet parton matching. */
if(abs(preshowerFSPs_[ixx]->id())==25) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=1) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "hjet process should have 1 particle to omit from"
<< "jet-parton matching." << Exception::eventerror;
}
} else if(ihrd_==14) {
/* wphjet... */
/* Exclude the v.boson and any children it may have
produced from the jet parton matching. */
// AND WHAT ABOUT THE PHOTON? <--- CHECK THIS WITH AlpGen GUYs.
if(abs(preshowerFSPs_[ixx]->id())==22||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
unsigned int tmpUnsignedInt(2+nph_);
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=tmpUnsignedInt) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wphjet process should have " << 2+nph_ << " particles to omit from"
<< "jet-parton matching." << Exception::eventerror;
}
} else if(ihrd_==15) {
/* wphqq... <--- N.B. if q = top, it is not decayed. */
/* Exclude the heavy quarks and any children they may
have produced as well as the v.boson and any children
it may have produced from the jet parton matching. */
// AND WHAT ABOUT THE PHOTON? <--- CHECK THIS WITH AlpGen GUYs.
if(abs(preshowerFSPs_[ixx]->id())==22||
(abs(preshowerFSPs_[ixx]->id())==ihvy_&&ixx==(preshowerFSPs_.size()-(2+nph_+1)))||
(abs(preshowerFSPs_[ixx]->id())==ihvy_&&ixx==(preshowerFSPs_.size()-(2+nph_+2)))||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
unsigned int tmpUnsignedInt(4+nph_);
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=tmpUnsignedInt) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wphjet process should have " << 4+nph_ << " particles to omit from"
<< "jet-parton matching." << Exception::eventerror;
}
} else if(ihrd_==16) {
/* 2Qph... <--- if Q is a top it will decay. */
/* Exclude the hard photons and any children they
may have produced from the jet parton matching
as well as the heavy quarks and any children it
may have produced. */
// AND WHAT ABOUT THE PHOTON?
if(ihvy_==6) {
if(abs(preshowerFSPs_[ixx]->id())==22||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==6||
abs(preshowerFSPs_[ixx]->parents()[0]->id())==24) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
unsigned int tmpUnsignedInt(6+nph_);
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=tmpUnsignedInt) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wphjet process should have " << 6+nph_ << " particles to omit from"
<< "jet-parton matching for ihvy=" << ihvy_ << "." << Exception::eventerror;
}
} else {
if(abs(preshowerFSPs_[ixx]->id())==22||
(abs(preshowerFSPs_[ixx]->id())==ihvy_&&ixx<2)) {
preshowerFSPsToDelete_.push_back(preshowerFSPs_[ixx]);
getDescendents(preshowerFSPs_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
unsigned int tmpUnsignedInt(2+nph_);
if(ixx==preshowerFSPs_.size()-1&&preshowerFSPsToDelete_.size()!=tmpUnsignedInt) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "wphjet process should have " << 2+nph_ << " particles to omit from"
<< "jet-parton matching for ihvy=" << ihvy_ << "." << Exception::eventerror;
}
}
}
}
}
// cout << "partonsToMatch_.size()= " << partonsToMatch_.size() << " preshowerFSPsToDelete_.size() = " << preshowerFSPsToDelete_.size() << endl;
// cout << "deleting preshowerFSPs" << endl;
for(unsigned int ixx=0; ixx<preshowerFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<partonsToMatch_.size(); jxx++) {
if(preshowerFSPsToDelete_[ixx]==partonsToMatch_[jxx]) {
// cout << "deleting " << preshowerFSPsToDelete_[ixx]->id() << " with parent " << preshowerFSPsToDelete_[ixx]->parents()[0]->id() << endl; // " energy = " << preshowerFSPsToDelete_[ixx]->momentum().e()*GeV << endl;
partonsToMatch_.erase(partonsToMatch_.begin()+jxx);
break;
}
}
}
//cout << "partonsToMatch_.size() (AFTER) = " << partonsToMatch_.size() << endl;
//cout << "deleting showeredFSPs" << endl;
for(unsigned int ixx=0; ixx<showeredFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<particlesToCluster_.size(); jxx++) {
if(showeredFSPsToDelete_[ixx]==particlesToCluster_[jxx]) {
// cout << "deleting " << showeredFSPsToDelete_[ixx]->id() << " with parent " << showeredFSPsToDelete_[ixx]->parents()[0]->id() << endl; //" energy = " << preshowerFSPsToDelete_[ixx]->momentum().e()*GeV << endl;
particlesToCluster_.erase(particlesToCluster_.begin()+jxx);
break;
}
}
}
// Sanity check!
if(partonsToMatch_.size()>particlesToCluster_.size()) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "No. of ME level partons to be matched to jets = "
<< partonsToMatch_.size() << "\n"
<< "No. of showered particles to build jets from = "
<< particlesToCluster_.size() << "\n"
<< "There should be at least as many partons to\n"
<< "cluster as there are partons to match to.\n"
<< Exception::eventerror;
}
// cout << "partonsToMatch_.size() (AFTER2) = " << partonsToMatch_.size() << endl;
// Acid test.
/* unsigned int tmpUnsignedInt(njets_);
if(!inputIsNLO_&&partonsToMatch_.size()!=tmpUnsignedInt) {
for(unsigned int ixx=0; ixx<partonsToMatch_.size(); ixx++) {
if(abs(partonsToMatch_[ixx]->id())>=6&&
abs(partonsToMatch_[ixx]->id())!=21)
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "Found a parton to match to which is not a quark or gluon!"
<< *partonsToMatch_[ixx] << "\n"
<< Exception::eventerror;
}
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "No. of ME level partons to be matched to jets = "
<< partonsToMatch_.size() << "\n"
<< "No. of light jets (njets) in AlpGen process = "
<< njets_ << "\n"
<< "These should be equal." << "\n"
<< Exception::eventerror;
} */
//cout << "partonsToMatch_.size() (AFTER3) = " << partonsToMatch_.size() << endl;
return;
}
// This looks for all descendents of a top up to but not including
// the W and b children.
void FxFxHandler::getTopRadiation(PPtr theParticle) const {
ParticleVector theChildren(theParticle->children());
for (unsigned int ixx=0; ixx<theChildren.size(); ixx++)
if(theChildren[ixx]->children().size()==0)
tmpList_.push_back(theChildren[ixx]);
else if(abs(theChildren[ixx]->id())==5||abs(theChildren[ixx]->id())==24)
return;
else
getTopRadiation(theChildren[ixx]);
return;
}
void FxFxHandler::caldel_mg() const {
preshowerFSPsToDelete_.clear();
showeredFSPsToDelete_.clear();
/*
* Get the MadGraph clustering information
* from the Les Houches event tags
*/
ptclust_.clear();
getptclust();
//for(unsigned int izz = 0; izz<ptclust_.size(); izz++) cout << "ptclust_[" << izz << "] = " << ptclust_[izz] << endl;
/*
* Get the COM energy of the colliding hadrons
*
*/
getECOM();
// cout << "ECOM_ = " << ECOM_ << endl;
for(unsigned int ixx=0; ixx<partonsToMatch_.size(); ixx++) {
if(ptclust_[ixx] == ECOM_){
preshowerFSPsToDelete_.push_back(partonsToMatch_[ixx]);
tmpList_.clear();
getDescendents(partonsToMatch_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
}
for(unsigned int ixx=0; ixx<preshowerFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<partonsToMatch_.size(); jxx++) {
if(preshowerFSPsToDelete_[ixx]==partonsToMatch_[jxx]) {
//cout << "deleting " << preshowerFSPsToDelete_[ixx]->id() << endl;
partonsToMatch_.erase(partonsToMatch_.begin()+jxx);
break;
}
}
}
for(unsigned int ixx=0; ixx<showeredFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<particlesToCluster_.size(); jxx++) {
if(showeredFSPsToDelete_[ixx]==particlesToCluster_[jxx]) {
// cout << "deleting " << showeredFSPsToDelete_[ixx]->id() << " with parent " << showeredFSPsToDelete_[ixx]->parents()[0]->id() << endl; //" energy = " << preshowerFSPsToDelete_[ixx]->momentum().e()*GeV << endl;
particlesToCluster_.erase(particlesToCluster_.begin()+jxx);
break;
}
}
}
// Sanity check!
if(partonsToMatch_.size()>particlesToCluster_.size()) {
throw Exception()
<< "FxFxHandler::caldel_m() - ERROR!\n"
<< "No. of ME level partons to be matched to jets = "
<< partonsToMatch_.size() << "\n"
<< "No. of showered particles to build jets from = "
<< particlesToCluster_.size() << "\n"
<< "There should be at least as many partons to\n"
<< "cluster as there are partons to match to.\n"
<< Exception::eventerror;
}
}
void FxFxHandler::caldel_hvq() const {
// Fill partonsToMatch_ with only those pre-shower partons intended to
// be used in heavy-quark-jet matching and fill particlesToCluster_ using
// only those final state particles (post-shower) which are supposed
// in the heavy-quark-jet clustering used to do merging. To begin with
// these are made from the corresponding sets of particles that were
// omitted from the initial jet-parton matching run.
partonsToMatch_ = preshowerFSPsToDelete_;
particlesToCluster_.resize(showeredFSPsToDelete_.size());
for(unsigned int ixx=0; ixx<showeredFSPsToDelete_.size(); ixx++)
particlesToCluster_[ixx] = showeredFSPsToDelete_[ixx];
// Reset the arrays of particles to delete so that the partonsToMatch_
// and particlesToCluster_ vectors can undergo further filtering.
preshowerFSPsToDelete_.clear();
showeredFSPsToDelete_.clear();
// Determine further particles in partonsToMatch_ and particlesToCluster_
// for deletion.
for(unsigned int ixx=0; ixx<partonsToMatch_.size(); ixx++) {
// If the progenitor particle is not a heavy
// quark we delete it and its descendents.
if(abs(partonsToMatch_[ixx]->id())<4||abs(partonsToMatch_[ixx]->id())>6) {
preshowerFSPsToDelete_.push_back(partonsToMatch_[ixx]);
tmpList_.clear();
getDescendents(partonsToMatch_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
// If the progenitor is a b quark from a top decay drop
// it & it's descendents too!
} else if(abs(partonsToMatch_[ixx]->id())==5&&
partonsToMatch_[ixx]->parents().size()>0&&
abs(partonsToMatch_[ixx]->parents()[0]->id())==6) {
preshowerFSPsToDelete_.push_back(partonsToMatch_[ixx]);
tmpList_.clear();
getDescendents(partonsToMatch_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
// If (it's a hvy quark not from a top decay and) it has a W/Z/H
// as a parent [ditto].
} else if(partonsToMatch_[ixx]->parents().size()>0&&
(abs(partonsToMatch_[ixx]->parents()[0]->id())==23||
abs(partonsToMatch_[ixx]->parents()[0]->id())==24||
abs(partonsToMatch_[ixx]->parents()[0]->id())==25)) {
preshowerFSPsToDelete_.push_back(partonsToMatch_[ixx]);
tmpList_.clear();
getDescendents(partonsToMatch_[ixx]);
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
showeredFSPsToDelete_.push_back(tmpList_[jxx]);
}
}
// Now do the necessary deleting from partonsToMatch_ and
// particlesToCluster_.
for(unsigned int ixx=0; ixx<preshowerFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<partonsToMatch_.size(); jxx++) {
if(preshowerFSPsToDelete_[ixx]==partonsToMatch_[jxx]) {
partonsToMatch_.erase(partonsToMatch_.begin()+jxx);
break;
}
}
}
for(unsigned int ixx=0; ixx<showeredFSPsToDelete_.size(); ixx++) {
for(unsigned int jxx=0; jxx<particlesToCluster_.size(); jxx++) {
if(showeredFSPsToDelete_[ixx]==particlesToCluster_[jxx]) {
particlesToCluster_.erase(particlesToCluster_.begin()+jxx);
break;
}
}
}
// Now we return to get the decaying top quarks and any
// radiation they produced.
ParticleVector intermediates(lastXCombPtr()->subProcess()->intermediates());
for(unsigned int ixx=0; ixx<intermediates.size(); ixx++) {
if(abs(intermediates[ixx]->id())==6) {
partonsToMatch_.push_back(intermediates[ixx]);
tmpList_.clear();
getTopRadiation(partonsToMatch_.back());
for(unsigned int jxx=0; jxx<tmpList_.size(); jxx++)
particlesToCluster_.push_back(tmpList_[jxx]);
}
}
// If there are any heavy quark progenitors we have to remove
// the final (showered) instance of them from particlesToCluster.
ParticleVector evolvedHeavyQuarks;
for(unsigned int ixx=0; ixx<partonsToMatch_.size(); ixx++) {
if(abs(partonsToMatch_[ixx]->id())>=4&&abs(partonsToMatch_[ixx]->id())<=6) {
theProgenitor = partonsToMatch_[ixx];
// Follow the heavy quark line down to where it stops branching.
while(theProgenitor->children().size()>0) {
theLastProgenitor = theProgenitor;
for(unsigned int jxx=0; jxx<theProgenitor->children().size(); jxx++) {
if(theProgenitor->children()[jxx]->id()==theProgenitor->id())
theProgenitor=theProgenitor->children()[jxx];
}
// If the progenitor had children but none of them had
// the same particle id as it, then it must have undergone
// a decay rather than a branching, i.e. it is the end of
// the evolution line, so,
if(theProgenitor==theLastProgenitor) break;
}
evolvedHeavyQuarks.push_back(theProgenitor);
}
}
// Now delete the evolved heavy quark from the particlesToCluster.
for(unsigned int ixx=0; ixx<evolvedHeavyQuarks.size(); ixx++) {
for(unsigned int jxx=0; jxx<particlesToCluster_.size(); jxx++) {
if(evolvedHeavyQuarks[ixx]==particlesToCluster_[jxx]) {
particlesToCluster_.erase(particlesToCluster_.begin()+jxx);
break;
}
}
}
return;
}
// get npLO_ and npNLO_
void FxFxHandler::getnpFxFx() const {
split_vector_type SplitVec;
// pull the optional weights from the current event
map<string,double> optionalEventWeights = eventHandler()->currentEvent()->optionalWeights();
// loop over the optional weights and find np values
for (map<string,double>::const_iterator it=optionalEventWeights.begin(); it!=optionalEventWeights.end(); ++it){
// split the line
boost::split( SplitVec, it->first, boost::is_any_of(" ") );
// if np is found, store the information
if(SplitVec[0] == "np") {
npLO_ = atof(SplitVec[1].c_str());
npNLO_ = atof(SplitVec[2].c_str());
}
}
return;
}
// get hadron COM energy
void FxFxHandler::getECOM() const {
split_vector_type SplitVec;
// pull the optional weights from the current event
map<string,double> optionalEventWeights = eventHandler()->currentEvent()->optionalWeights();
// loop over the optional weights and find np values
for (map<string,double>::const_iterator it=optionalEventWeights.begin(); it!=optionalEventWeights.end(); ++it){
// split the line
boost::split( SplitVec, it->first, boost::is_any_of(" ") );
// if np is found, store the information
if(SplitVec[0] == "ecom") {
ECOM_ = it->second;
}
}
return;
}
// get pt_clust information
void FxFxHandler::getptclust() const {
split_vector_type SplitVec;
// pull the optional weights from the current event
map<string,double> optionalEventWeights = eventHandler()->currentEvent()->optionalWeights();
// loop over the optional weights and find np values
string str_eq = "=";
string str_quote = "\"";
int countptc_(0);
for (map<string,double>::const_iterator it=optionalEventWeights.begin(); it!=optionalEventWeights.end(); ++it){
// split the line
double wgtid = it->second;
//cout << "wgtdid = " << wgtid << endl;
if(wgtid == -333) {
// cout << "it->first for -333 = " << it->first << endl;
boost::split( SplitVec, it->first, boost::is_any_of(" ") );
// if np is found, store the information
double ptclust(0.);
string stringtohandle("");
for(unsigned int i_ = 0; i_ < SplitVec.size(); ++i_) {
if(SplitVec[i_].find("pt_clust_") != std::string::npos) {
//cout << "pt_clust_ found in " << SplitVec[i_] << endl;
countptc_++;
// cout << "SplitVec[i_] = " << SplitVec[i_] << endl;
stringtohandle = SplitVec[i_];
stringtohandle.erase(0,10);
erase_substr(stringtohandle,str_eq);
erase_substr(stringtohandle,str_quote);
// cout << "stringtohandle = " << stringtohandle << endl;
ptclust = atof(stringtohandle.c_str());
ptclust_.push_back(ptclust);
}
}
}
}
return;
}
void FxFxHandler::getPreshowerParticles() const {
// LH file initial-state partons:
preshowerISPs_ = lastXCombPtr()->subProcess()->incoming();
// LH file final-state partICLEs:
preshowerFSPs_ = lastXCombPtr()->subProcess()->outgoing();
return;
}
void FxFxHandler::getShoweredParticles() const {
// Post-shower initial-state hadrons:
showeredISHs_ = eventHandler()->currentEvent()->incoming();
// Post-shower initial-state partons:
for(unsigned int ixx=0; ixx<(showeredISHs_.first)->children().size(); ixx++)
if(((showeredISHs_.first)->children()[ixx]->id())<6||
((showeredISHs_.first)->children()[ixx]->id())==21)
showeredISPs_.first=(showeredISHs_.first)->children()[ixx];
for(unsigned int ixx=0; ixx<(showeredISHs_.second)->children().size(); ixx++)
if(((showeredISHs_.second)->children()[ixx]->id())<6||
((showeredISHs_.second)->children()[ixx]->id())==21)
showeredISPs_.second=(showeredISHs_.second)->children()[ixx];
// Post-shower final-state partICLEs plus remnants (to be removed later):
showeredFSPs_ = eventHandler()->currentEvent()->getFinalState();
// Post-shower final-state remnants:
for(unsigned int ixx=0; ixx<showeredFSPs_.size(); ixx++) {
if(showeredFSPs_[ixx]->PDGName()=="Rem:p+"||
showeredFSPs_[ixx]->PDGName()=="Rem:pbar-") {
if(showeredFSPs_[ixx]->parents()[0]->parents()[0]==
showeredISHs_.first)
showeredRems_.first=showeredFSPs_[ixx];
else if(showeredFSPs_[ixx]->parents()[0]->parents()[0]==
showeredISHs_.second)
showeredRems_.second=showeredFSPs_[ixx];
}
}
// Now delete found remnants from the showeredFSPs vector for consistency.
for(unsigned int ixx=0; ixx<showeredFSPs_.size(); ixx++)
if(showeredFSPs_[ixx]->PDGName()=="Rem:p+")
showeredFSPs_.erase(showeredFSPs_.begin()+ixx);
for(unsigned int ixx=0; ixx<showeredFSPs_.size(); ixx++)
if(showeredFSPs_[ixx]->PDGName()=="Rem:pbar-")
showeredFSPs_.erase(showeredFSPs_.begin()+ixx);
sort(showeredFSPs_.begin(),showeredFSPs_.end(),recordEntry);
return;
}
void FxFxHandler::doSanityChecks(int debugLevel) const {
// When checking momentum conservation in the form
// p_in - p_out, any momentum component bigger / less
// than + / - epsilon will result in the p_in - p_out
// vector being flagged as "non-null", triggering a
// warning that momentum conservation is violated.
Energy epsilon(0.5*GeV);
if(debugLevel>=5) epsilon=1e-9*GeV;
// Print out what was found for the incoming and outgoing
// partons in the lastXCombPtr regardless.
if(debugLevel>=5) {
cout << "\n\n\n\n";
cout << "****************************************************" << endl;
cout << " The following are the hard subprocess momenta from " << "\n"
<< " lastXCombPtr and should be basically identical to " << "\n"
<< " the input LH file momenta." << "\n\n";
cout << " Incoming particles:" << "\n"
<< *(preshowerISPs_.first) << "\n"
<< *(preshowerISPs_.second) << endl;
cout << " Outgoing particles:" << endl;
for(unsigned int ixx=0; ixx<preshowerFSPs_.size(); ixx++)
cout << *(preshowerFSPs_[ixx]) << endl;
}
// Print out what was found for the incoming and outgoing
// partons after the shower.
if(debugLevel>=5) {
cout << "\n\n";
cout << "****************************************************" << endl;
cout << " The following are the particles left at the end of" << "\n"
<< " the showering step." << "\n\n";
cout << " Incoming hadrons:" << "\n"
<< *(showeredISHs_.first) << "\n"
<< *(showeredISHs_.second) << endl;
cout << " Incoming partons:" << "\n"
<< *(showeredISPs_.first) << "\n"
<< *(showeredISPs_.second) << endl;
cout << " Outgoing partons:" << endl;
for(unsigned int ixx=0; ixx<showeredFSPs_.size(); ixx++)
cout << *(showeredFSPs_[ixx]) << endl;
cout << " Outgoing remnants:" << "\n"
<< *(showeredRems_.first) << "\n"
<< *(showeredRems_.second) << endl;
}
// Check if we correctly identified all initial and final-state
// particles by testing momentum is conserved.
if(debugLevel>=4) {
Lorentz5Momentum tmpMom;
tmpMom += showeredISPs_.first->momentum();
tmpMom += showeredISPs_.second->momentum();
for(unsigned int ixx=0; ixx<showeredFSPs_.size(); ixx++)
tmpMom -= showeredFSPs_[ixx]->momentum();
if(!isMomLessThanEpsilon(tmpMom,epsilon))
cout << "Total parton mom.in - total parton mom.out = "
<< tmpMom/GeV << endl;
tmpMom = showeredISHs_.first->momentum()
- showeredRems_.first->momentum() -showeredISPs_.first->momentum();
if(!isMomLessThanEpsilon(tmpMom,epsilon))
cout << "First p_hadron-p_remnant-p_incoming " << tmpMom/GeV << endl;
tmpMom = showeredISHs_.second->momentum()
- showeredRems_.second->momentum()-showeredISPs_.second->momentum();
if(!isMomLessThanEpsilon(tmpMom,epsilon))
cout << "Second p_hadron-p_remnant-p_incoming " << tmpMom/GeV << endl;
}
// Check if what we found to be the remnant is consistent with
// what we identified as the parent incoming hadron i.e. p+
// goes with Rem:p+ and pbar- goes with Rem:pbar-.
if(debugLevel>=0) {
string tmpString;
tmpString=showeredRems_.first->PDGName();
tmpString=tmpString.substr(tmpString.find_first_of(":")+1,
string::npos);
if(showeredISHs_.first->PDGName()!=tmpString) {
cout << "FxFxHandler::showerHardProcessVeto" << "\n"
<< "Fatal error in pairing of remnant and parent hadron." << "\n"
<< "Remnant = " << *(showeredRems_.first) << "\n"
<< "Parent hadron = " << *(showeredISHs_.first)
<< endl;
cout << showeredISHs_.first->PDGName() << endl;
cout << tmpString << endl;
}
tmpString=showeredRems_.second->PDGName();
tmpString=tmpString.substr(tmpString.find_first_of(":")+1,
string::npos);
if(showeredISHs_.second->PDGName()!=tmpString) {
cout << "FxFxHandler::showerHardProcessVeto" << "\n"
<< "Fatal error in pairing of remnant and parent hadron." << "\n"
<< "Remnant = " << *(showeredRems_.second) << "\n"
<< "Parent hadron = " << *(showeredISHs_.second)
<< endl;
cout << showeredISHs_.second->PDGName() << endl;
cout << tmpString << endl;
}
}
return;
}
void FxFxHandler::printMomVec(vector<Lorentz5Momentum> momVec) {
cout << "\n\n";
// Label columns.
printf("%5s %9s %9s %9s %9s %9s %9s %9s %9s %9s\n",
"jet #",
"px","py","pz","E",
"eta","phi","pt","et","mass");
// Print out the details for each jet
for (unsigned int ixx=0; ixx<momVec.size(); ixx++) {
printf("%5u %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
ixx,
double(momVec[ixx].x()/GeV),double(momVec[ixx].y()/GeV),
double(momVec[ixx].z()/GeV),double(momVec[ixx].t()/GeV),
double(momVec[ixx].eta()) ,double(momVec[ixx].phi()),
double(momVec[ixx].perp()/GeV),
double(momVec[ixx].et()/GeV),
double(momVec[ixx].m()/GeV));
}
}
Energy FxFxHandler::etclusran_(double petc) const {
return (((2 * epsetclus_)/M_PI) * asin(2 * petc - 1) + etclusmean_);
}
void FxFxHandler::erase_substr(std::string& subject, const std::string& search) const {
size_t pos = 0;
while((pos = subject.find(search, pos)) != std::string::npos) {
subject.erase( pos, search.length() );
}
}
diff --git a/MatrixElement/FxFx/FxFxReader.h b/MatrixElement/FxFx/FxFxReader.h
--- a/MatrixElement/FxFx/FxFxReader.h
+++ b/MatrixElement/FxFx/FxFxReader.h
@@ -1,1016 +1,1016 @@
// -*- C++ -*-
//
// FxFxReader.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_FxFxReader_H
#define THEPEG_FxFxReader_H
// This is the declaration of the FxFxReader class.
#include "FxFx.h"
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Utilities/ObjectIndexer.h"
#include "ThePEG/Utilities/Exception.h"
#include "ThePEG/Utilities/XSecStat.h"
#include "ThePEG/PDF/PartonBinInstance.h"
#include "ThePEG/PDF/PartonBin.fh"
#include "ThePEG/MatrixElement/ReweightBase.h"
#include "FxFxEventHandler.fh"
#include "FxFxReader.fh"
#include "ThePEG/Utilities/CFile.h"
#include <cstdio>
#include <cstring>
namespace ThePEG {
/**
* FxFxReader is an abstract base class to be used for objects
* which reads event files or streams from matrix element
* generators. Derived classes must at least implement the open() and
* doReadEvent() methods to read in information about the whole run into
* the HEPRUP variable and next event into the HEPEUP variable
* respectively. Also the close() function to close the file or stream
* read must be implemented. Although these functions are named as if
* we are reading from event files, they could just as well implement
* the actual generation of events.
*
* After filling the HEPRUP and HEPEUP variables, which are protected
* and easily accesible from the sub-class, this base class will then
* be responsible for transforming this data to the ThePEG Event
* record in the getEvent() method. <code>FxFxReader</code>s can
* only be used inside FxFxEventHandler objects.
*
* In the initialization the virtual open() and scan() functions are
* called. Here the derived class must provide the information about
* the processes in the variables corresponding to the HEPRUP common
* block. Note that the IDWTUP is required to be +/- 1, and sub
* classes are required to change the information accordingly to
* ensure the correct corss section sampling. Note also that the
* controlling FxFxEventHandler may choose to generate weighted
* events even if IDWTUP is 1.
*
* Note that the information given per process in e.g. the XSECUP and
* XMAXUP vectors is not used by the FxFxEventHandler and by
* default the FxFxReader is not assumed to be able to actively
* choose between the sub-processes. Instead, the
* FxFxEventHandler can handle several FxFxReader objects
* and choose between them. However, a sub-class of FxFxReader
* may set the flag isActive, in which case it is assumed to be able
* to select between its sub-processes itself.
*
* The FxFxReader may be assigned a number ReweightBase objects
* which either completely reweights the events produced (in the
* reweights vector), or only biases the selection without influencing
* the cross section (in the preweights vector). Note that it is the
* responsibility of a sub-class to call the reweight() function and
* multiply the weight according to its return value (typically done
* in the readEvent() function).
*
* @see \ref FxFxReaderInterfaces "The interfaces"
* defined for FxFxReader.
* @see Event
* @see FxFxEventHandler
*/
class FxFxReader: public HandlerBase, public LastXCombInfo<> {
/**
* FxFxEventHandler should have access to our private parts.
*/
friend class FxFxEventHandler;
/**
* Map for accumulating statistics of cross sections per process
* number.
*/
typedef map<int,XSecStat> StatMap;
/**
* Map of XComb objects describing the incoming partons indexed by
* the corresponding PartonBin pair.
*/
typedef map<tcPBPair,XCombPtr> XCombMap;
/**
* A vector of pointers to ReweightBase objects.
*/
typedef vector<ReweightPtr> ReweightVector;
public:
/** @name Standard constructors and destructors. */
//@{
/**
* Default constructor. If the optional argument is true, the reader
* is assumed to be able to produce events on demand for a given
* process.
*/
FxFxReader(bool active = false);
/**
* Copy-constructor.
*/
FxFxReader(const FxFxReader &);
/**
* Destructor.
*/
virtual ~FxFxReader();
//@}
public:
/** @name Main virtual fuctions to be overridden in
* sub-classes. They are named as if we are reading from event
* files, but could equally well implement the actual generation of
* events. */
//@{
/**
* Open a file or stream with events and read in the run information
* into the heprup variable.
*/
virtual void open() = 0;
/**
* Read the next event from the file or stream into the
* corresponding protected variables. Return false if there is no
* more events.
*/
virtual bool doReadEvent() = 0;
/**
* Close the file or stream from which events have been read.
*/
virtual void close() = 0;
/**
* return the weight names
*/
// virtual vector<string> optWeightsNamesFunc();
virtual vector<string> optWeightsNamesFunc() = 0;
//virtual vector<string*> optWeightNamesFunc() = 0;
vector<string> optionalWeightsNames;
/**
* The ID (e.g. 100x, 2001) for the weight
*/
// vector<string> optionalWeightsNames;
//@}
/** @name Other important function which may be overridden in
* sub-classes which wants to bypass the basic HEPRUP or HEPEUP
* variables or otherwise facilitate the conversion to ThePEG
* objects. */
//@{
/**
* Initialize. This function is called by the FxFxEventHandler
* to which this object is assigned.
*/
virtual void initialize(FxFxEventHandler & eh);
/**
* Calls readEvent() or uncacheEvent() to read information into the
* FxFx common block variables. This function is called by the
* FxFxEventHandler if this reader has been selectod to
* produce an event.
*
* @return the weight asociated with this event. If negative weights
* are allowed it should be between -1 and 1, otherwise between 0
* and 1. If outside these limits the previously estimated maximum
* is violated. Note that the estimated maximum then should be
* updated from the outside.
*/
virtual double getEvent();
/**
* Calls doReadEvent() and performs pre-defined reweightings. A
* sub-class overrides this function it must make sure that the
* corresponding reweightings are done.
*/
virtual bool readEvent();
/**
* Skip \a n events. Used by FxFxEventHandler to make sure
* that a file is scanned an even number of times in case the events
* are not ramdomly distributed in the file.
*/
virtual void skip(long n);
/**
* Get an XComb object. Converts the information in the Les Houches
* common block variables to an XComb object describing the sub
* process. This is the way information is conveyed from the reader
* to the controlling FxFxEventHandler.
*/
tXCombPtr getXComb();
/**
* Get a SubProcess object corresponding to the information in the
* Les Houches common block variables.
*/
tSubProPtr getSubProcess();
/**
* Scan the file or stream to obtain information about cross section
* weights and particles etc. This function should fill the
* variables corresponding to the /HEPRUP/ common block. The
* function returns the number of events scanned.
*/
virtual long scan();
/**
* Take the information corresponding to the HEPRUP common block and
* initialize the statistics for this reader.
*/
virtual void initStat();
/**
* Reweights the current event using the reweights and preweights
* vectors. It is the responsibility of the sub-class to call this
* function after the HEPEUP information has been retrieved.
*/
double reweight();
/**
* Converts the information in the Les Houches common block
* variables into a Particle objects.
*/
virtual void fillEvent();
/**
* Removes the particles created in the last generated event,
* preparing to produce a new one.
*/
void reset();
/**
* Possibility for subclasses to recover from non-conformant
* settings of XMAXUP when an event file has been scanned with \a
* neve events. Should set weightScale so that the average XMAXUP
* times weightScale gives the cross section for a process. (This is
* needed for MadEvent).
*/
virtual void setWeightScale(long neve);
//@}
/** @name Access information about the current event. */
//@{
/**
* Return the size of this event in bytes. To be used for the cache
* file. \a npart is the number of particles. If \a npart is 0, the
* number is taken from NUP.
*/
static size_t eventSize(int N) {
return (N + 1)*sizeof(int) + // IDPRUP, ISTUP
(7*N + 4)*sizeof(double) + // XWGTUP, SCALUP, AQEDUP, AQCDUP, PUP,
// VTIMUP, SPINUP
N*sizeof(long) + // IDUP
2*N*sizeof(pair<int,int>) + // MOTHUP, ICOLUP
sizeof(pair<double,double>) + // XPDWUP.
2*sizeof(double); // lastweight and preweight
}
/**
* The current event weight given by XWGTUP times possible
* reweighting. Note that this is not necessarily the same as what
* is returned by getEvent(), which is scaled with the maximum
* weight.
*/
double eventWeight() const { return hepeup.XWGTUP*lastweight; }
/**
* Return the optional named weights associated to the current event.
*/
const map<string,double>& optionalEventWeights() const { return optionalWeights; }
/**
* Return the Les Houches event number associated with the current event
*/
const long& LHEEventNum() const { return LHEeventnum; }
/**
* Return the optional npLO and npNLO
*/
const int& optionalEventnpLO() const { return optionalnpLO; }
const int& optionalEventnpNLO() const { return optionalnpNLO; }
/**
* The pair of PartonBinInstance objects describing the current
* incoming partons in the event.
*/
const PBIPair & partonBinInstances() const { return thePartonBinInstances; }
/**
* Return the instances of the beam particles for the current event.
*/
const PPair & beams() const { return theBeams; }
/**
* Return the instances of the incoming particles to the sub process
* for the current event.
*/
const PPair & incoming() const { return theIncoming; }
/**
* Return the instances of the outgoing particles from the sub process
* for the current event.
*/
const PVector & outgoing() const { return theOutgoing; }
/**
* Return the instances of the intermediate particles in the sub
* process for the current event.
*/
const PVector & intermediates() const { return theIntermediates; }
/**
* If this reader is to be used (possibly together with others) for
* CKKW reweighting and veto, this should give the multiplicity of
* outgoing particles in the highest multiplicity matrix element in
* the group.
*/
int maxMultCKKW() const { return theMaxMultCKKW; }
/**
* If this reader is to be used (possibly together with others) for
* CKKW reweighting and veto, this should give the multiplicity of
* outgoing particles in the lowest multiplicity matrix element in
* the group.
*/
int minMultCKKW() const { return theMinMultCKKW; } //@}
/** @name Other inlined access functions. */
//@{
/**
* The number of events found in this reader. If less than zero the
* number of events are unlimited.
*/
long NEvents() const { return theNEvents; }
/**
* The number of events produced so far. Is reset to zero if an
* event file is reopened.
*/
long currentPosition() const { return position; }
/**
* The maximum number of events to scan to collect information about
* processes and cross sections. If less than 0, all events will be
* scanned.
*/
long maxScan() const { return theMaxScan; }
/**
* Return true if this reader is active.
*/
bool active() const { return isActive; }
/**
* True if negative weights may be produced.
*/
bool negativeWeights() const { return heprup.IDWTUP < 0; }
/**
* The collected cross section statistics for this reader.
*/
const XSecStat & xSecStats() const { return stats; }
/**
* Collected statistics about the individual processes.
*/
const StatMap & processStats() const { return statmap; }
/**
* Select the current event. It will later be rejected with a
* probability given by \a weight.
*/
void select(double weight) {
stats.select(weight);
statmap[hepeup.IDPRUP].select(weight);
}
/**
* Accept the current event assuming it was previously selcted.
*/
void accept() {
stats.accept();
statmap[hepeup.IDPRUP].accept();
}
/**
* Reject the current event assuming it was previously accepted.
*/
void reject(double w) {
stats.reject(w);
statmap[hepeup.IDPRUP].reject(w);
}
/**
* Increase the overestimated cross section for this reader.
*/
virtual void increaseMaxXSec(CrossSection maxxsec);
/**
* The PartonExtractor object used to construct remnants.
*/
tPExtrPtr partonExtractor() const { return thePartonExtractor; }
/**
* Return a possibly null pointer to a CascadeHandler to be used for
* CKKW-reweighting.
*/
tCascHdlPtr CKKWHandler() const { return theCKKW; }
/**
* The pairs of PartonBin objects describing the partons which can
* be extracted by the PartonExtractor object.
*/
const PartonPairVec & partonBins() const { return thePartonBins; }
/**
* The map of XComb objects indexed by the corresponding PartonBin
* pair.
*/
const XCombMap & xCombs() const { return theXCombs; }
/**
* The Cuts object to be used for this reader.
*/
const Cuts & cuts() const { return *theCuts; }
//@}
protected:
/** @name Functions for manipulating cache files. */
//@{
/**
* Name of file used to cache the events form the reader in a
* fast-readable form. If empty, no cache file will be generated.
*/
string cacheFileName() const { return theCacheFileName; }
/**
* Determines whether to apply cuts to events converting them to
* ThePEG format.
*/
bool cutEarly() const { return doCutEarly; }
/**
* File stream for the cache.
*/
CFile cacheFile() const { return theCacheFile;}
/**
* Open the cache file for reading.
*/
void openReadCacheFile();
/**
* Open the cache file for writing.
*/
void openWriteCacheFile();
/**
* Close the cache file;
*/
void closeCacheFile();
/**
* Write the current event to the cache file.
*/
void cacheEvent() const;
/**
* Read an event from the cache file. Return false if something went wrong.
*/
bool uncacheEvent();
/**
* Reopen a reader. If we have reached the end of an event file,
* reopen it and issue a warning if we have used up a large fraction
* of it.
*/
void reopen();
/**
* Helper function to write a variable to a memory location
*/
template <typename T>
static char * mwrite(char * pos, const T & t, size_t n = 1) {
std::memcpy(pos, &t, n*sizeof(T));
return pos + n*sizeof(T);
}
/**
* Helper function to read a variable from a memory location
*/
template <typename T>
static const char * mread(const char * pos, T & t, size_t n = 1) {
- std::memcpy(&t, pos, n*sizeof(T));
+ std::memcpy((void *)&t, pos, n*sizeof(T));
return pos + n*sizeof(T);
}
//@}
/** @name Auxilliary virtual methods which may be verridden by sub-classes. */
//@{
/**
* Check the existence of a pair of PartonBin objects corresponding
* to the current event.
*
* @return false if no pair of suitable PartonBin objects was found.
*/
virtual bool checkPartonBin();
/**
* Create instances of all particles in the event and store them
* in particleIndex.
*/
virtual void createParticles();
/**
* Using the already created particles create a pair of
* PartonBinInstance objects corresponding to the incoming
* partons. Return the corresponding PartonBin objects.
*/
virtual tcPBPair createPartonBinInstances();
/**
* Create instances of the incoming beams in the event and store
* them in particleIndex. If no beam particles are included in the
* event they are created from the run info.
*/
virtual void createBeams();
/**
* Go through the mother indices and connect up the Particles.
*/
virtual void connectMothers();
//@}
public:
/** @name Functions used by the persistent I/O system. */
//@{
/**
* Function used to write out object persistently.
* @param os the persistent output stream written to.
*/
void persistentOutput(PersistentOStream & os) const;
/**
* Function used to read in object persistently.
* @param is the persistent input stream read from.
* @param version the version number of the object when written.
*/
void persistentInput(PersistentIStream & is, int version);
//@}
/**
* Standard Init function used to initialize the interfaces.
*/
static void Init();
protected:
/** @name Set functions for some variables not in the Les Houches accord. */
//@{
/**
* The number of events in this reader. If less than zero the number
* of events is unlimited.
*/
void NEvents(long x) { theNEvents = x; }
/**
* The map of XComb objects indexed by the corresponding PartonBin
* pair.
*/
XCombMap & xCombs() { return theXCombs; }
//@}
/** @name Standard (and non-standard) Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
/**
* Initialize this object. Called in the run phase just before
* a run begins.
*/
virtual void doinitrun();
/**
* Finalize this object. Called in the run phase just after a
* run has ended. Used eg. to write out statistics.
*/
virtual void dofinish() {
close();
HandlerBase::dofinish();
}
/**
* Return true if this object needs to be initialized before all
* other objects because it needs to extract PDFs from the event file.
*/
virtual bool preInitialize() const;
/**
* Called from doinit() to extract PDFs from the event file and add
* the corresponding objects to the current EventGenerator.
*/
virtual void initPDFs();
//@}
protected:
/**
* The HEPRUP common block.
*/
HEPRUP heprup;
/**
* The HEPEUP common block.
*/
HEPEUP hepeup;
/**
* The ParticleData objects corresponding to the incoming particles.
*/
tcPDPair inData;
/**
* The PDFBase objects which has been used for the beam particle
* when generating the events being read. Specified in the interface
* or derived from PDFGUP and PDFSUP.
*/
pair<PDFPtr,PDFPtr> inPDF;
/**
* The PDFBase object to be used in the subsequent generation.
*/
pair<cPDFPtr,cPDFPtr> outPDF;
/**
* The PartonExtractor object used to construct remnants.
*/
PExtrPtr thePartonExtractor;
/**
* A pointer to a CascadeHandler to be used for CKKW-reweighting.
*/
tCascHdlPtr theCKKW;
/**
* The pairs of PartonBin objects describing the partons which can
* be extracted by the PartonExtractor object.
*/
PartonPairVec thePartonBins;
/**
* The map of XComb objects indexed by the corresponding PartonBin
* pair.
*/
XCombMap theXCombs;
/**
* The Cuts object to be used for this reader.
*/
CutsPtr theCuts;
/**
* The number of events in this reader. If less than zero the number
* of events is unlimited.
*/
long theNEvents;
/**
* The number of events produced by this reader so far. Is reset
* every time an event file is reopened.
*/
long position;
/**
* The number of times this reader has been reopened.
*/
int reopened;
/**
* The maximum number of events to scan to collect information about
* processes and cross sections. If less than 0, all events will be
* scanned.
*/
long theMaxScan;
/**
* Flag to tell whether we are in the process of scanning.
*/
bool scanning;
/**
* True if this is an active reader.
*/
bool isActive;
/**
* Name of file used to cache the events form the reader in a
* fast-readable form. If empty, no cache file will be generated.
*/
string theCacheFileName;
/**
* Determines whether to apply cuts to events before converting them
* to ThePEG format.
*/
bool doCutEarly;
/**
* Collect statistics for this reader.
*/
XSecStat stats;
/**
* Collect statistics for each individual process.
*/
StatMap statmap;
/**
* The pair of PartonBinInstance objects describing the current
* incoming partons in the event.
*/
PBIPair thePartonBinInstances;
/**
* Association between ColourLines and colour indices in the current
* translation.
*/
ObjectIndexer<long,ColourLine> colourIndex;
/**
* Association between Particles and indices in the current
* translation.
*/
ObjectIndexer<long,Particle> particleIndex;
/**
* The instances of the beam particles for the current event.
*/
PPair theBeams;
/**
* The instances of the incoming particles to the sub process for
* the current event.
*/
PPair theIncoming;
/**
* The instances of the outgoing particles from the sub process for
* the current event.
*/
PVector theOutgoing;
/**
* The instances of the intermediate particles in the sub process for
* the current event.
*/
PVector theIntermediates;
/**
* File stream for the cache.
*/
CFile theCacheFile;
/**
* The reweight objects modifying the weights of this reader.
*/
ReweightVector reweights;
/**
* The preweight objects modifying the weights of this reader.
*/
ReweightVector preweights;
/**
* The factor with which this reader was last pre-weighted.
*/
double preweight;
/**
* Should the event be reweighted by PDFs used by the PartonExtractor?
*/
bool reweightPDF;
/**
* Should PDFBase objects be constructed from the information in the
* event file in the initialization?
*/
bool doInitPDFs;
/**
* If this reader is to be used (possibly together with others) for
* CKKW reweighting and veto, this should give the multiplicity of
* outgoing particles in the highest multiplicity matrix element in
* the group.
*/
int theMaxMultCKKW;
/**
* If this reader is to be used (possibly together with others) for
* CKKW reweighting and veto, this should give the multiplicity of
* outgoing particles in the lowest multiplicity matrix element in
* the group.
*/
int theMinMultCKKW;
/**
* The weight multiplying the last read event due to PDF
* reweighting, CKKW reweighting or assigned reweight and preweight
* objects.
*/
double lastweight;
/**
* The optional weights associated to the last read events.
*/
map<string,double> optionalWeights;
/**
* The event number
*/
long LHEeventnum;
/**
* If the maximum cross section of this reader has been increased
* with increaseMaxXSec(), this is the total factor with which it
* has been increased.
*/
double maxFactor;
/**
* npLO for FxFx merging
*/
int optionalnpLO;
/**
* npNLO for FxFx merging
*/
int optionalnpNLO;
/**
* The (reweighted) XWGTUP value should be scaled with this cross
* section when compared to the overestimated cross section.
*/
CrossSection weightScale;
/**
* Individual scales for different sub-processes if reweighted.
*/
vector<double> xSecWeights;
/**
* Individual maximum weights for individual (possibly reweighted)
* processes.
*/
map<int,double> maxWeights;
/**
* Is set to true when getEvent() is called from skip(int).
*/
bool skipping;
/**
* Option for the treatment of the momenta supplied
*/
unsigned int theMomentumTreatment;
/**
* Set to true if warnings about possible weight incompatibilities
* should be issued.
*/
bool useWeightWarnings;
/**
* Option to allow reopening of the file
*/
bool theReOpenAllowed;
/**
* Use the spin information
*/
bool theIncludeSpin;
private:
/** Access function for the interface. */
void setBeamA(long id);
/** Access function for the interface. */
long getBeamA() const;
/** Access function for the interface. */
void setBeamB(long id);
/** Access function for the interface. */
long getBeamB() const;
/** Access function for the interface. */
void setEBeamA(Energy e);
/** Access function for the interface. */
Energy getEBeamA() const;
/** Access function for the interface. */
void setEBeamB(Energy e);
/** Access function for the interface. */
Energy getEBeamB() const;
/** Access function for the interface. */
void setPDFA(PDFPtr);
/** Access function for the interface. */
PDFPtr getPDFA() const;
/** Access function for the interface. */
void setPDFB(PDFPtr);
/** Access function for the interface. */
PDFPtr getPDFB() const;
private:
/**
* Describe an abstract base class with persistent data.
*/
static AbstractClassDescription<FxFxReader> initFxFxReader;
/**
* Private and non-existent assignment operator.
*/
FxFxReader & operator=(const FxFxReader &) = delete;
public:
/** @cond EXCEPTIONCLASSES */
/** Exception class used by FxFxReader in case inconsistencies
* are encountered. */
class FxFxInconsistencyError: public Exception {};
/** Exception class used by FxFxReader in case more events
than available are requested. */
class FxFxReopenWarning: public Exception {};
/** Exception class used by FxFxReader in case reopening an
event file fails. */
class FxFxReopenError: public Exception {};
/** Exception class used by FxFxReader in case there is
information missing in the initialization phase. */
class FxFxInitError: public InitException {};
/** @endcond */
};
/// Stream output for HEPEUP
ostream & operator<<(ostream & os, const HEPEUP & h);
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/**
* This template specialization informs ThePEG about the
* base class of FxFxReader.
*/
template <>
struct BaseClassTrait<FxFxReader,1>: public ClassTraitsType {
/** Typedef of the base class of FxFxReader. */
typedef HandlerBase NthBase;
};
/**
* This template specialization informs ThePEG about the name of the
* FxFxReader class and the shared object where it is
* defined.
*/
template <>
struct ClassTraits<FxFxReader>
: public ClassTraitsBase<FxFxReader> {
/**
* Return the class name.
*/
static string className() { return "Herwig::FxFxReader"; }
/**
* Return the name of the shared library to be loaded to get access
* to the FxFxReader class and every other class it uses
* (except the base class).
*/
static string library() { return "HwFxFx.so"; }
};
/** @endcond */
}
#endif /* THEPEG_FxFxReader_H */
diff --git a/Shower/QTilde/Dark/HalfHalfOneDarkSplitFn.cc b/Shower/QTilde/Dark/HalfHalfOneDarkSplitFn.cc
--- a/Shower/QTilde/Dark/HalfHalfOneDarkSplitFn.cc
+++ b/Shower/QTilde/Dark/HalfHalfOneDarkSplitFn.cc
@@ -1,171 +1,171 @@
// -*- C++ -*-
//
// HalfHalfOneDarkSplitFn.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the HalfHalfOneDarkSplitFn class.
//
#include "HalfHalfOneDarkSplitFn.h"
#include "HiddenValleyModel.h"
#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Utilities/DescribeClass.h"
#include <cassert>
using namespace Herwig;
DescribeNoPIOClass<HalfHalfOneDarkSplitFn,Herwig::Sudakov1to2FormFactor>
describeHalfHalfOneDarkSplitFn ("Herwig::HalfHalfOneDarkSplitFn","HwShower.so");
void HalfHalfOneDarkSplitFn::Init() {
// documentation
static ClassDocumentation<HalfHalfOneDarkSplitFn> documentation
("The HalfHalfOneDarkSplitFn class implements the dark coloured q -> qg splitting function");
}
bool HalfHalfOneDarkSplitFn::checkColours(const IdList & ids) const {
if(colourStructure()==TripletTripletOctet) {
if(ids[0]!=ids[1]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[2]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else if(colourStructure()==OctetOctetOctet) {
for(unsigned int ix=0;ix<3;++ix) {
if(ids[ix]->iColour()!=PDT::DarkColourAdjoint) return false;
}
return true;
}
else if(colourStructure()==OctetTripletTriplet) {
if(ids[0]->iColour()!=PDT::DarkColourAdjoint) return false;
if(ids[1]->iColour()==PDT::DarkColourFundamental&&
ids[2]->iColour()==PDT::DarkColourAntiFundamental)
return true;
if(ids[1]->iColour()==PDT::DarkColourAntiFundamental&&
ids[2]->iColour()==PDT::DarkColourFundamental)
return true;
return false;
}
else if(colourStructure()==TripletOctetTriplet) {
if(ids[0]!=ids[2]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[1]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else {
assert(false);
}
return false;
}
double HalfHalfOneDarkSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass, const RhoDMatrix & ) const {
double val = (1. + sqr(z))/(1.-z);
if(mass) {
Energy m = ids[0]->mass();
val -= 2.*sqr(m)/t;
}
return val;
}
double HalfHalfOneDarkSplitFn::overestimateP(const double z,
- const IdList & ids) const {
+ const IdList & ) const {
return 2./(1.-z);
}
double HalfHalfOneDarkSplitFn::ratioP(const double z, const Energy2 t,
- const IdList & ids, const bool mass, const RhoDMatrix & ) const {
+ const IdList & ids, const bool mass, const RhoDMatrix & ) const {
double val = 1. + sqr(z);
if(mass) {
Energy m = ids[0]->mass();
val -= 2.*sqr(m)*(1.-z)/t;
}
return 0.5*val;
}
double HalfHalfOneDarkSplitFn::integOverP(const double z,
- const IdList & ids,
- unsigned int PDFfactor) const {
+ const IdList & ,
+ unsigned int PDFfactor) const {
switch (PDFfactor) {
case 0:
return -2.*Math::log1m(z);
case 1:
return 2.*log(z/(1.-z));
case 2:
return 2./(1.-z);
case 3:
default:
throw Exception() << "HalfHalfOneDarkSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
-double HalfHalfOneDarkSplitFn::invIntegOverP(const double r, const IdList & ids,
- unsigned int PDFfactor) const {
+double HalfHalfOneDarkSplitFn::invIntegOverP(const double r, const IdList &,
+ unsigned int PDFfactor) const {
switch (PDFfactor) {
case 0:
return 1. - exp(- 0.5*r);
case 1:
return 1./(1.-exp(-0.5*r));
case 2:
return 1.-2./r;
case 3:
default:
throw Exception() << "HalfHalfOneDarkSplitFn::invIntegOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool HalfHalfOneDarkSplitFn::accept(const IdList &ids) const {
// 3 particles and in and out fermion same
if(ids.size()!=3 || ids[0]!=ids[1]) return false;
if(ids[0]->iSpin()!=PDT::Spin1Half ||
ids[2]->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}
vector<pair<int, Complex> >
HalfHalfOneDarkSplitFn::generatePhiForward(const double, const Energy2, const IdList & ,
const RhoDMatrix &) {
// no dependence on the spin density matrix, dependence on off-diagonal terms cancels
// and rest = splitting function for Tr(rho)=1 as required by defn
return {{ {0, 1.} }};
}
vector<pair<int, Complex> >
HalfHalfOneDarkSplitFn::generatePhiBackward(const double, const Energy2, const IdList & ,
const RhoDMatrix &) {
// no dependence on the spin density matrix, dependence on off-diagonal terms cancels
// and rest = splitting function for Tr(rho)=1 as required by defn
return {{ {0, 1.} }};
}
DecayMEPtr HalfHalfOneDarkSplitFn::matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi,
bool timeLike) {
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
Energy m = !timeLike ? ZERO : ids[0]->mass();
double mt = m/sqrt(t);
double root = sqrt(1.-(1.-z)*sqr(m)/z/t);
double romz = sqrt(1.-z);
double rz = sqrt(z);
Complex phase = exp(Complex(0.,1.)*phi);
(*kernal)(0,0,0) = -root/romz*phase;
(*kernal)(1,1,2) = -conj((*kernal)(0,0,0));
(*kernal)(0,0,2) = root/romz*z/phase;
(*kernal)(1,1,0) = -conj((*kernal)(0,0,2));
(*kernal)(1,0,2) = mt*(1.-z)/rz;
(*kernal)(0,1,0) = conj((*kernal)(1,0,2));
(*kernal)(0,1,2) = 0.;
(*kernal)(1,0,0) = 0.;
return kernal;
}
diff --git a/Shower/QTilde/Dark/OneHalfHalfDarkSplitFn.cc b/Shower/QTilde/Dark/OneHalfHalfDarkSplitFn.cc
--- a/Shower/QTilde/Dark/OneHalfHalfDarkSplitFn.cc
+++ b/Shower/QTilde/Dark/OneHalfHalfDarkSplitFn.cc
@@ -1,187 +1,187 @@
// -*- C++ -*-
//
// OneHalfHalfDarkSplitFn.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the OneHalfHalfDarkSplitFn class.
//
#include "OneHalfHalfDarkSplitFn.h"
#include "HiddenValleyModel.h"
#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Utilities/DescribeClass.h"
using namespace Herwig;
DescribeNoPIOClass<OneHalfHalfDarkSplitFn,Herwig::Sudakov1to2FormFactor>
describeOneHalfHalfDarkSplitFn ("Herwig::OneHalfHalfDarkSplitFn","HwShower.so");
void OneHalfHalfDarkSplitFn::Init() {
static ClassDocumentation<OneHalfHalfDarkSplitFn> documentation
("The OneHalfHalfDarkSplitFn class implements the splitting function for g->q qbar");
}
bool OneHalfHalfDarkSplitFn::checkColours(const IdList & ids) const {
if(colourStructure()==TripletTripletOctet) {
if(ids[0]!=ids[1]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[2]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else if(colourStructure()==OctetOctetOctet) {
for(unsigned int ix=0;ix<3;++ix) {
if(ids[ix]->iColour()!=PDT::DarkColourAdjoint) return false;
}
return true;
}
else if(colourStructure()==OctetTripletTriplet) {
if(ids[0]->iColour()!=PDT::DarkColourAdjoint) return false;
if(ids[1]->iColour()==PDT::DarkColourFundamental&&
ids[2]->iColour()==PDT::DarkColourAntiFundamental)
return true;
if(ids[1]->iColour()==PDT::DarkColourAntiFundamental&&
ids[2]->iColour()==PDT::DarkColourFundamental)
return true;
return false;
}
else if(colourStructure()==TripletOctetTriplet) {
if(ids[0]!=ids[2]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[1]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else {
assert(false);
}
return false;
}
double OneHalfHalfDarkSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass, const RhoDMatrix &) const {
double zz = z*(1.-z);
double val=1.-2.*zz;
if(mass) {
Energy m = ids[1]->mass();
val +=2.*sqr(m)/t;
}
return val;
}
double OneHalfHalfDarkSplitFn::overestimateP(const double,
- const IdList &ids) const {
+ const IdList &) const {
return 1.;
}
double OneHalfHalfDarkSplitFn::ratioP(const double z, const Energy2 t,
- const IdList &ids, const bool mass, const RhoDMatrix &) const {
+ const IdList &ids, const bool mass, const RhoDMatrix &) const {
double zz = z*(1.-z);
double val = 1.-2.*zz;
if(mass) {
Energy m = ids[1]->mass();
val+= 2.*sqr(m)/t;
}
return val;
}
-double OneHalfHalfDarkSplitFn::integOverP(const double z, const IdList & ids,
- unsigned int PDFfactor) const {
+double OneHalfHalfDarkSplitFn::integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return z;
case 1:
return log(z);
case 2:
return -log(1.-z);
case 3:
return log(z/(1.-z));
case 4:
return 2.*sqrt(z);
case 5:
return (2./3.)*z*sqrt(z);
default:
throw Exception() << "OneHalfHalfDarkSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double OneHalfHalfDarkSplitFn::invIntegOverP(const double r,
- const IdList & ids,
- unsigned int PDFfactor) const {
+ const IdList & ,
+ unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return r;
case 1:
return exp(r);
case 2:
return 1.-exp(-r);
case 3:
return 1./(1.+exp(-r));
case 4:
return 0.25*sqr(r);
case 5:
return pow(1.5*r,2./3.);
default:
throw Exception() << "OneHalfHalfDarkSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool OneHalfHalfDarkSplitFn::accept(const IdList &ids) const {
if(ids.size()!=3) return false;
if(ids[1]!=ids[2]->CC()) return false;
if(ids[1]->iSpin()!=PDT::Spin1Half) return false;
if(ids[0]->iSpin()!=PDT::Spin1) return false;
return OneHalfHalfDarkSplitFn::checkColours(ids);
}
vector<pair<int, Complex> >
OneHalfHalfDarkSplitFn::generatePhiForward(const double z, const Energy2 t, const IdList & ids,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double modRho = abs(rho(0,2));
Energy mq = ids[1]->mass();
Energy2 mq2 = sqr(mq);
double fact = z*(1.-z)-mq2/t;
double max = 1.+2.*fact*(-1.+2.*modRho);
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*(1.-2.*fact)/max));
output.push_back(make_pair(-2,2.*fact*rho(0,2)/max));
output.push_back(make_pair( 2,2.*fact*rho(2,0)/max));
return output;
}
vector<pair<int, Complex> >
OneHalfHalfDarkSplitFn::generatePhiBackward(const double, const Energy2, const IdList &,
const RhoDMatrix & ) {
// no dependance
return {{ {0, 1.} }};
}
DecayMEPtr OneHalfHalfDarkSplitFn::matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi,
bool timeLike) {
static const Complex ii(0.,1.);
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1Half,PDT::Spin1Half)));
double mt = !timeLike ? ZERO : ids[1]->mass()/sqrt(t);
double root =sqrt(1.-sqr(mt)/z/(1.-z));
(*kernal)(0,0,0) = mt/sqrt(z*(1.-z));
(*kernal)(2,1,1) = (*kernal)(0,0,0);
(*kernal)(0,0,1) = -z*root*exp(-ii*phi);
(*kernal)(2,1,0) = -conj((*kernal)(0,0,1));
(*kernal)(0,1,0) = (1.-z)*exp(-ii*phi)*root;
(*kernal)(2,0,1) = -conj((*kernal)(0,1,0));
(*kernal)(0,1,1) = 0.;
(*kernal)(2,0,0) = 0.;
return kernal;
}
diff --git a/Shower/QTilde/Dark/OneOneOneDarkSplitFn.cc b/Shower/QTilde/Dark/OneOneOneDarkSplitFn.cc
--- a/Shower/QTilde/Dark/OneOneOneDarkSplitFn.cc
+++ b/Shower/QTilde/Dark/OneOneOneDarkSplitFn.cc
@@ -1,167 +1,167 @@
// -*- C++ -*-
//
// OneOneOneDarkSplitFn.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the OneOneOneDarkSplitFn class.
//
#include "OneOneOneDarkSplitFn.h"
#include "HiddenValleyModel.h"
#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Utilities/DescribeClass.h"
using namespace Herwig;
DescribeNoPIOClass<OneOneOneDarkSplitFn,Herwig::Sudakov1to2FormFactor>
describeOneOneOneDarkSplitFn ("Herwig::OneOneOneDarkSplitFn","HwShower.so");
void OneOneOneDarkSplitFn::Init() {
static ClassDocumentation<OneOneOneDarkSplitFn> documentation
("The OneOneOneDarkSplitFn class implements the g -> gg splitting function");
}
bool OneOneOneDarkSplitFn::checkColours(const IdList & ids) const {
if(colourStructure()==TripletTripletOctet) {
if(ids[0]!=ids[1]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[2]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else if(colourStructure()==OctetOctetOctet) {
for(unsigned int ix=0;ix<3;++ix) {
if(ids[ix]->iColour()!=PDT::DarkColourAdjoint) return false;
}
return true;
}
else if(colourStructure()==OctetTripletTriplet) {
if(ids[0]->iColour()!=PDT::DarkColourAdjoint) return false;
if(ids[1]->iColour()==PDT::DarkColourFundamental&&
ids[2]->iColour()==PDT::DarkColourAntiFundamental)
return true;
if(ids[1]->iColour()==PDT::DarkColourAntiFundamental&&
ids[2]->iColour()==PDT::DarkColourFundamental)
return true;
return false;
}
else if(colourStructure()==TripletOctetTriplet) {
if(ids[0]!=ids[2]) return false;
if((ids[0]->iColour()==PDT::DarkColourFundamental||
ids[0]->iColour()==PDT::DarkColourAntiFundamental) &&
ids[1]->iColour()==PDT::DarkColourAdjoint) return true;
return false;
}
else {
assert(false);
}
return false;
}
double OneOneOneDarkSplitFn::P(const double z, const Energy2,
- const IdList & ids, const bool, const RhoDMatrix &)const {
+ const IdList & , const bool, const RhoDMatrix &)const {
return sqr(1.-z*(1.-z))/(z*(1.-z));
}
double OneOneOneDarkSplitFn::overestimateP(const double z,
- const IdList & ids) const {
+ const IdList & ) const {
return (1/z + 1/(1.-z));
}
double OneOneOneDarkSplitFn::ratioP(const double z, const Energy2,
- const IdList & , const bool, const RhoDMatrix &) const {
+ const IdList & , const bool, const RhoDMatrix &) const {
return sqr(1.-z*(1.-z));
}
double OneOneOneDarkSplitFn::invIntegOverP(const double r,
- const IdList & ids,
- unsigned int PDFfactor) const {
+ const IdList & ,
+ unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return 1./(1.+exp(-r));
case 1:
case 2:
case 3:
default:
throw Exception() << "OneOneOneDarkSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
-double OneOneOneDarkSplitFn::integOverP(const double z, const IdList & ids,
- unsigned int PDFfactor) const {
+double OneOneOneDarkSplitFn::integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
assert(z>0.&&z<1.);
return log(z/(1.-z));
case 1:
case 2:
case 3:
default:
throw Exception() << "OneOneOneDarkSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool OneOneOneDarkSplitFn::accept(const IdList & ids) const {
if(ids.size()!=3) return false;
for(unsigned int ix=0;ix<ids.size();++ix) {
if(ids[0]->iSpin()!=PDT::Spin1) return false;
}
return OneOneOneDarkSplitFn::checkColours(ids);
}
vector<pair<int, Complex> >
OneOneOneDarkSplitFn::generatePhiForward(const double z, const Energy2, const IdList &,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double modRho = abs(rho(0,2));
double max = 2.*z*modRho*(1.-z)+sqr(1.-(1.-z)*z)/(z*(1.-z));
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*sqr(1.-(1.-z)*z)/(z*(1.-z))/max));
output.push_back(make_pair(-2,-rho(0,2)*z*(1.-z)/max));
output.push_back(make_pair( 2,-rho(2,0)*z*(1.-z)/max));
return output;
}
vector<pair<int, Complex> >
OneOneOneDarkSplitFn::generatePhiBackward(const double z, const Energy2, const IdList &,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double diag = sqr(1 - (1 - z)*z)/(1 - z)/z;
double off = (1.-z)/z;
double max = 2.*abs(rho(0,2))*off+diag;
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0, (rho(0,0)+rho(2,2))*diag/max));
output.push_back(make_pair( 2,-rho(0,2) * off/max));
output.push_back(make_pair(-2,-rho(2,0) * off/max));
return output;
}
DecayMEPtr OneOneOneDarkSplitFn::matrixElement(const double z, const Energy2,
const IdList &, const double phi,
bool) {
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin1)));
double omz = 1.-z;
double root = sqrt(z*omz);
Complex phase = exp(Complex(0.,1.)*phi);
(*kernal)(0,0,0) = phase/root;
(*kernal)(2,2,2) = -conj((*kernal)(0,0,0));
(*kernal)(0,0,2) = -sqr(z)/root/phase;
(*kernal)(2,2,0) = -conj((*kernal)(0,0,2));
(*kernal)(0,2,0) = -sqr(omz)/root/phase;
(*kernal)(2,0,2) = -conj((*kernal)(0,2,0));
(*kernal)(0,2,2) = 0.;
(*kernal)(2,0,0) = 0.;
return kernal;
}
diff --git a/Shower/QTilde/Makefile.am b/Shower/QTilde/Makefile.am
--- a/Shower/QTilde/Makefile.am
+++ b/Shower/QTilde/Makefile.am
@@ -1,61 +1,61 @@
-SUBDIRS = Matching
+SUBDIRS = Matching SplittingFunctions/Onium
pkglib_LTLIBRARIES = HwShower.la
HwShower_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 30:0:0
HwShower_la_SOURCES = \
Couplings/ShowerAlphaQCD.h Couplings/ShowerAlphaQCD.cc \
Couplings/ShowerAlphaQED.h Couplings/ShowerAlphaQED.cc\
Couplings/ShowerAlphaQCDNP.h Couplings/ShowerAlphaQCDNP.cc\
QTildeShowerHandler.h QTildeShowerHandler.fh QTildeShowerHandler.cc \
SplittingFunctions/HalfHalfOneSplitFn.h SplittingFunctions/HalfHalfOneSplitFn.cc\
SplittingFunctions/HalfHalfOneEWSplitFn.h SplittingFunctions/HalfHalfOneEWSplitFn.cc\
SplittingFunctions/HalfHalfZeroEWSplitFn.h SplittingFunctions/HalfHalfZeroEWSplitFn.cc\
SplittingFunctions/OneOneOneEWSplitFn.h SplittingFunctions/OneOneOneEWSplitFn.cc\
SplittingFunctions/OneOneOneQEDSplitFn.h SplittingFunctions/OneOneOneQEDSplitFn.cc\
SplittingFunctions/OneOneZeroEWSplitFn.h SplittingFunctions/OneOneZeroEWSplitFn.cc\
SplittingFunctions/ZeroZeroZeroEWSplitFn.h SplittingFunctions/ZeroZeroZeroEWSplitFn.cc\
SplittingFunctions/OneZeroZeroEWSplitFn.h SplittingFunctions/OneZeroZeroEWSplitFn.cc\
SplittingFunctions/ZeroZeroOneEWSplitFn.h SplittingFunctions/ZeroZeroOneEWSplitFn.cc\
SplittingFunctions/OneOneOneSplitFn.h SplittingFunctions/OneOneOneSplitFn.cc\
SplittingFunctions/OneOneOneMassiveSplitFn.h SplittingFunctions/OneOneOneMassiveSplitFn.cc\
SplittingFunctions/ZeroZeroOneSplitFn.h SplittingFunctions/ZeroZeroOneSplitFn.cc\
SplittingFunctions/OneHalfHalfSplitFn.h SplittingFunctions/OneHalfHalfSplitFn.cc\
SplittingFunctions/HalfOneHalfSplitFn.h SplittingFunctions/HalfOneHalfSplitFn.cc\
SplittingFunctions/CMWOneOneOneSplitFn.h SplittingFunctions/CMWOneOneOneSplitFn.cc\
SplittingFunctions/CMWHalfHalfOneSplitFn.h SplittingFunctions/CMWHalfHalfOneSplitFn.cc\
Dark/EnumParticles.h Dark/HiddenValleyAlpha.cc Dark/HiddenValleyAlpha.h \
Dark/HiddenValleyModel.cc Dark/HiddenValleyModel.h \
Dark/HiddenValleyFFZPrimeVertex.cc Dark/HiddenValleyFFZPrimeVertex.h \
Dark/OneHalfHalfDarkSplitFn.cc Dark/OneHalfHalfDarkSplitFn.h \
Dark/OneOneOneDarkSplitFn.cc Dark/OneOneOneDarkSplitFn.h \
Dark/HalfHalfOneDarkSplitFn.cc Dark/HalfHalfOneDarkSplitFn.h \
Kinematics/Decay_QTildeShowerKinematics1to2.cc \
Kinematics/Decay_QTildeShowerKinematics1to2.h \
Kinematics/IS_QTildeShowerKinematics1to2.cc Kinematics/IS_QTildeShowerKinematics1to2.h \
Kinematics/FS_QTildeShowerKinematics1to2.cc Kinematics/FS_QTildeShowerKinematics1to2.h \
Kinematics/KinematicHelpers.h \
Kinematics/KinematicsReconstructor.cc \
Kinematics/KinematicsReconstructor.tcc \
Kinematics/KinematicsReconstructor.h \
Kinematics/KinematicsReconstructor.fh \
Base/HardTree.cc Base/HardTree.h Base/HardTree.fh \
Base/HardBranching.h Base/HardBranching.fh Base/HardBranching.cc\
Base/PartnerFinder.h Base/PartnerFinder.fh Base/PartnerFinder.cc \
Base/ShowerVeto.h Base/ShowerVeto.fh Base/ShowerVeto.cc \
Base/FullShowerVeto.h Base/FullShowerVeto.fh Base/FullShowerVeto.cc \
SplittingFunctions/SplittingGenerator.cc SplittingFunctions/SplittingGenerator.h\
SplittingFunctions/SplittingGenerator.fh \
Base/ShowerTree.h Base/ShowerTree.fh Base/ShowerTree.cc \
ShowerConfig.h ShowerConfig.cc \
Base/Branching.h \
Base/ShowerParticle.cc Base/ShowerParticle.fh Base/ShowerParticle.h \
Kinematics/ShowerKinematics.fh Kinematics/ShowerKinematics.h Kinematics/ShowerKinematics.cc \
Kinematics/ShowerBasis.fh Kinematics/ShowerBasis.h Kinematics/ShowerBasis.cc \
Base/ShowerProgenitor.fh Base/ShowerProgenitor.h \
SplittingFunctions/SudakovFormFactor.cc SplittingFunctions/SudakovFormFactor.h SplittingFunctions/SudakovFormFactor.fh \
SplittingFunctions/SudakovCutOff.cc SplittingFunctions/SudakovCutOff.h SplittingFunctions/SudakovCutOff.fh \
SplittingFunctions/PTCutOff.cc SplittingFunctions/PTCutOff.h \
SplittingFunctions/MassCutOff.cc SplittingFunctions/MassCutOff.h \
SplittingFunctions/VariableMassCutOff.cc SplittingFunctions/VariableMassCutOff.h \
SplittingFunctions/Sudakov1to2FormFactor.h SplittingFunctions/Sudakov1to2FormFactor.fh \
SplittingFunctions/Sudakov1to2FormFactor.cc \
Base/ShowerVertex.cc Base/ShowerVertex.fh Base/ShowerVertex.h
diff --git a/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.cc b/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.cc
--- a/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.cc
+++ b/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.cc
@@ -1,117 +1,117 @@
// -*- C++ -*-
//
// HalfOneHalfSplitFn.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the HalfOneHalfSplitFn class.
//
#include "HalfOneHalfSplitFn.h"
#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Utilities/DescribeClass.h"
#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
using namespace Herwig;
DescribeNoPIOClass<HalfOneHalfSplitFn,Herwig::Sudakov1to2FormFactor>
describeHalfOneHalfSplitFn ("Herwig::HalfOneHalfSplitFn","HwShower.so");
void HalfOneHalfSplitFn::Init() {
static ClassDocumentation<HalfOneHalfSplitFn> documentation
("The HalfOneHalfSplitFn class implements the splitting "
"function for q -> g q");
}
-double HalfOneHalfSplitFn::integOverP(const double z, const IdList & ids,
+double HalfOneHalfSplitFn::integOverP(const double z, const IdList &,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return 2.*log(z);
case 1:
return -2./z;
case 2:
return 2.*log(z/(1.-z));
case 3:
default:
throw Exception() << "HalfOneHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double HalfOneHalfSplitFn::invIntegOverP(const double r,
- const IdList & ids,
+ const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return exp(0.5*r);
case 1:
return -2./r;
case 2:
return 1./(1.+exp(-0.5*r));
case 3:
default:
throw Exception() << "HalfOneHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool HalfOneHalfSplitFn::accept(const IdList &ids) const {
// 3 particles and in and out fermion same
if(ids.size()!=3 || ids[0]!=ids[2]) return false;
if(ids[0]->iSpin()!=PDT::Spin1Half ||
ids[1]->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}
vector<pair<int, Complex> >
HalfOneHalfSplitFn::generatePhiForward(const double, const Energy2, const IdList & ,
const RhoDMatrix &) {
// no dependence on the spin density matrix, dependence on off-diagonal terms cancels
// and rest = splitting function for Tr(rho)=1 as required by defn
return {{ {0, 1.} }};
}
vector<pair<int, Complex> >
HalfOneHalfSplitFn::generatePhiBackward(const double z, const Energy2 t, const IdList & ids,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double mt = sqr(ids[0]->mass())/t;
double diag = (1.+sqr(1.-z))/z - 2.*mt;
double off = 2.*(1.-z)/z*(1.-mt*z/(1.-z));
double max = diag+2.*abs(rho(0,2))*off;
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0, (rho(0,0)+rho(2,2))*diag/max));
output.push_back(make_pair( 2, -rho(0,2) * off/max));
output.push_back(make_pair(-2, -rho(2,0) * off/max));
return output;
}
DecayMEPtr HalfOneHalfSplitFn::matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi,
bool timeLike) {
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1,PDT::Spin1Half)));
Energy m = !timeLike ? ZERO : ids[0]->mass();
double mt = m/sqrt(t);
double root = sqrt(1.-z*sqr(m)/(1.-z)/t);
double romz = sqrt(1.-z);
double rz = sqrt(z);
Complex phase = exp(-Complex(0.,1.)*phi);
(*kernal)(0,0,0) = -root/rz/phase;
(*kernal)(1,2,1) = -conj((*kernal)(0,0,0));
(*kernal)(0,2,0) = root/rz*(1.-z)*phase;
(*kernal)(1,0,1) = -conj((*kernal)(0,2,0));
(*kernal)(1,2,0) = mt*z/romz;
(*kernal)(0,0,1) = conj((*kernal)(1,2,0));
(*kernal)(0,2,1) = 0.;
(*kernal)(1,0,0) = 0.;
return kernal;
}
diff --git a/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.h b/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/HalfOneHalfSplitFn.h
@@ -1,180 +1,180 @@
// -*- C++ -*-
//
// HalfOneHalfSplitFn.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_HalfOneHalfSplitFn_H
#define HERWIG_HalfOneHalfSplitFn_H
//
// This is the declaration of the HalfOneHalfSplitFn class.
//
#include "Sudakov1to2FormFactor.h"
namespace Herwig {
using namespace ThePEG;
/** \ingroup Shower
*
* This classs provides the concrete implementation of the exact leading-order
* splitting function for \f$\frac12\to 1\frac12\f$.
*
* In this case the splitting function is given by
* \f[P(z,t) = C\left(\frac{2(1-z)+z^2}{z}-2\frac{m^2_q}t\right),\f]
* where \f$C\f$ is the corresponding colour factor.
* Our choice for the overestimate is
* \f[P_{\rm over}(z) = 2C\frac1z,\f]
* therefore the integral is
* \f[\int P_{\rm over}(z) {\rm d}z = 2C\ln z,\f]
* and its inverse is
* \f[\exp\left(\frac{r}{2C}\right).\f]
*
* @see SplittingFunction
*/
class HalfOneHalfSplitFn: public Sudakov1to2FormFactor {
public:
/**
* Concrete implementation of the method to determine whether this splitting
* function can be used for a given set of particles.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual bool accept(const IdList & ids) const;
/**
* Methods to return the splitting function.
*/
//@{
/**
* The concrete implementation of the overestimate of the splitting function,
* \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
*/
- virtual double overestimateP(const double z, const IdList & ids) const {
+ virtual double overestimateP(const double z, const IdList & ) const {
return 2./z;
}
/**
* The concrete implementation of the
* the ratio of the splitting function to the overestimate, i.e.
* \f$P(z,t)/P_{\rm over}(z)\f$.
* @param z The energy fraction.
* @param t The scale.
* @param ids The PDG codes for the particles in the splitting.
* @param mass Whether or not to include the mass dependent terms
* @param rho The spin density matrix
*/
virtual double ratioP(const double z, const Energy2 t, const IdList & ids,
- const bool mass, const RhoDMatrix & rho) const {
+ const bool mass, const RhoDMatrix &) const {
double val=2.*(1.-z)+sqr(z);
if(mass) {
Energy m=ids[0]->mass();
val -=2.*sqr(m)*z/t;
}
return 0.5*val;
}
/**
* The concrete implementation of the indefinite integral of the
* overestimated splitting function, \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double integOverP(const double z, const IdList & ids,
unsigned int PDFfactor=0) const;
/**
* The concrete implementation of the inverse of the indefinite integral.
* @param r Value of the splitting function to be inverted
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double invIntegOverP(const double r, const IdList & ids,
unsigned int PDFfactor=0) const;
//@}
/**
* Method to calculate the azimuthal angle for forward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiForward(const double z, const Energy2 t, const IdList & ids,
const RhoDMatrix &);
/**
* Method to calculate the azimuthal angle for backward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiBackward(const double z, const Energy2 t, const IdList & ids,
const RhoDMatrix &);
/**
* Calculate the matrix element for the splitting
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
*/
virtual DecayMEPtr matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi, bool timeLike);
public:
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const {return new_ptr(*this);}
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const {return new_ptr(*this);}
//@}
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
HalfOneHalfSplitFn & operator=(const HalfOneHalfSplitFn &) = delete;
};
}
#endif /* HERWIG_HalfOneHalfSplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/OneHalfHalfSplitFn.h b/Shower/QTilde/SplittingFunctions/OneHalfHalfSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/OneHalfHalfSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/OneHalfHalfSplitFn.h
@@ -1,195 +1,195 @@
// -*- C++ -*-
//
// OneHalfHalfSplitFn.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_OneHalfHalfSplitFn_H
#define HERWIG_OneHalfHalfSplitFn_H
//
// This is the declaration of the OneHalfHalfSplitFn class.
//
#include "Sudakov1to2FormFactor.h"
namespace Herwig {
using namespace ThePEG;
/**\ingroup Shower
*
* This class provides the concrete implementation of the exact leading-order
* splitting function for \f$1\to \frac12\frac12\f$.
*
* In this case the splitting function is given by
* \f[P(z,t) =C\left(1-2z(1-z)+2\frac{m_q^2}{t}\right),\f]
* where \f$C\f$ is the corresponding colour factor
* Our choice for the overestimate is
* \f[P_{\rm over}(z) = C,\f]
* therefore the integral is
* \f[\int P_{\rm over}(z) {\rm d}z =Cz,\f]
* and its inverse is
* \f[\frac{r}{C}\f]
*
* @see \ref OneHalfHalfSplitFnInterfaces "The interfaces"
* defined for OneHalfHalfSplitFn.
*/
class OneHalfHalfSplitFn: public Sudakov1to2FormFactor {
public:
/**
* Concrete implementation of the method to determine whether this splitting
* function can be used for a given set of particles.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual bool accept(const IdList & ids) const {
if(ids.size()!=3) return false;
if(ids[1]!=ids[2]->CC()) return false;
if(ids[1]->iSpin()!=PDT::Spin1Half) return false;
if(ids[0]->iSpin()!=PDT::Spin1) return false;
return true;
}
/**
* Methods to return the splitting function.
*/
//@{
/**
* The concrete implementation of the overestimate of the splitting function,
* \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
*/
- virtual double overestimateP(const double z, const IdList & ids) const {
+ virtual double overestimateP(const double , const IdList & ) const {
return 1.;
}
/**
* The concrete implementation of the
* the ratio of the splitting function to the overestimate, i.e.
* \f$P(z,\tilde{q}^2)/P_{\rm over}(z)\f$.
* @param z The energy fraction.
* @param t The scale.
* @param ids The PDG codes for the particles in the splitting.
* @param mass Whether or not to include the mass dependent terms
* @param rho The spin density matrix
*/
virtual double ratioP(const double z, const Energy2 t, const IdList & ids,
- const bool mass, const RhoDMatrix & rho) const {
+ const bool mass, const RhoDMatrix &) const {
double zz = z*(1.-z);
double val = 1.-2.*zz;
if(mass) {
Energy m = ids[1]->mass();
val+= 2.*sqr(m)/t;
}
return val;
}
/**
* The concrete implementation of the indefinite integral of the
* overestimated splitting function, \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double integOverP(const double z, const IdList & ids,
unsigned int PDFfactor=0) const;
/**
* The concrete implementation of the inverse of the indefinite integral.
* @param r Value of the splitting function to be inverted
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double invIntegOverP(const double r, const IdList & ids,
unsigned int PDFfactor=0) const;
//@}
/**
* Method to calculate the azimuthal angle
* @param particle The particle which is branching
* @param showerkin The ShowerKinematics object
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiForward(const double z, const Energy2 t, const IdList & ids,
const RhoDMatrix &);
/**
* Method to calculate the azimuthal angle
* @param particle The particle which is branching
* @param showerkin The ShowerKinematics object
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiBackward(const double, const Energy2, const IdList &,
const RhoDMatrix &) {
// no dependance
return {{ {0, 1.} }};
}
/**
* Calculate the matrix element for the splitting
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
*/
virtual DecayMEPtr matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi, bool timeLike);
public:
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const {return new_ptr(*this);}
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const {return new_ptr(*this);}
//@}
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
OneHalfHalfSplitFn & operator=(const OneHalfHalfSplitFn &) = delete;
};
}
#endif /* HERWIG_OneHalfHalfSplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/OneOneOneSplitFn.h b/Shower/QTilde/SplittingFunctions/OneOneOneSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/OneOneOneSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/OneOneOneSplitFn.h
@@ -1,225 +1,225 @@
// -*- C++ -*-
//
// OneOneOneSplitFn.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_OneOneOneSplitFn_H
#define HERWIG_OneOneOneSplitFn_H
//
// This is the declaration of the OneOneOneSplitFn class.
//
#include "Sudakov1to2FormFactor.h"
#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
namespace Herwig {
using namespace ThePEG;
/** \ingroup Shower
*
* This class provides the concrete implementation of the exact leading-order
* splitting function for \f$1\to 11\f$.
*
* In this case the splitting function is given by
* \f[P(z) =2C*\left(\frac{z}{1-z}+\frac{1-z}{z}+z(1-z)\right),\f]
* where \f$C=\f$ is the corresponding colour factor.
* Our choice for the overestimate is
* \f[P_{\rm over}(z) = 2C\left(\frac1z+\frac1{1-z}\right),\f]
* therefore the integral is
* \f[\int P_{\rm over}(z) {\rm d}z =2C\ln\left(\frac{z}{1-z}\right),\f]
* and its inverse is
* \f[\frac{\exp\left(\frac{r}{2C}\right)}{(1+\exp\left(\frac{r}{2C}\right)}\f]
*
*
* @see \ref OneOneOneSplitFnInterfaces "The interfaces"
* defined for OneOneOneSplitFn.
*/
class OneOneOneSplitFn: public Sudakov1to2FormFactor {
public:
/**
* Concrete implementation of the method to determine whether this splitting
* function can be used for a given set of particles.
* @param ids The PDG codes for the particles in the splitting.
*/
bool accept(const IdList & ids) const {
if(ids.size()!=3) return false;
for(unsigned int ix=0;ix<ids.size();++ix) {
if(ids[ix]->iSpin()!=PDT::Spin1) return false;
}
return true;
}
/**
* Methods to return the splitting function.
*/
//@{
/**
* The concrete implementation of the overestimate of the splitting function,
* \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
*/
- double overestimateP(const double z, const IdList & ids) const {
+ double overestimateP(const double z, const IdList &) const {
return 1/z + 1/(1.-z);
}
/**
* The concrete implementation of the
* the ratio of the splitting function to the overestimate, i.e.
* \f$P(z,t)/P_{\rm over}(z)\f$.
* @param z The energy fraction.
* @param t The scale.
* @param ids The PDG codes for the particles in the splitting.
* @param mass Whether or not to include the mass dependent terms
* @param rho The spin density matrix
*/
virtual double ratioP(const double z, const Energy2, const IdList &,
const bool, const RhoDMatrix &) const {
return sqr(1.-z*(1.-z));
}
/**
* The concrete implementation of the indefinite integral of the
* overestimated splitting function, \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double integOverP(const double z, const IdList &,
unsigned int PDFfactor=0) const {
assert(PDFfactor==0);
assert(z>0.&&z<1.);
return log(z/(1.-z));
}
/**
* The concrete implementation of the inverse of the indefinite integral.
* @param r Value of the splitting function to be inverted
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double invIntegOverP(const double r, const IdList &,
unsigned int PDFfactor=0) const {
assert(PDFfactor==0);
return 1./(1.+exp(-r));
}
//@}
/**
* Method to calculate the azimuthal angle for forward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
vector<pair<int,Complex> >
generatePhiForward(const double z, const Energy2, const IdList &,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double modRho = abs(rho(0,2));
double max = 2.*z*modRho*(1.-z)+sqr(1.-(1.-z)*z)/(z*(1.-z));
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*sqr(1.-(1.-z)*z)/(z*(1.-z))/max));
output.push_back(make_pair(-2,-rho(0,2)*z*(1.-z)/max));
output.push_back(make_pair( 2,-rho(2,0)*z*(1.-z)/max));
return output;
}
/**
* Method to calculate the azimuthal angle for backward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
vector<pair<int,Complex> >
generatePhiBackward(const double z, const Energy2, const IdList &,
const RhoDMatrix & rho) {
assert(rho.iSpin()==PDT::Spin1);
double diag = sqr(1 - (1 - z)*z)/(1 - z)/z;
double off = (1.-z)/z;
double max = 2.*abs(rho(0,2))*off+diag;
vector<pair<int, Complex> > output;
output.push_back(make_pair( 0, (rho(0,0)+rho(2,2))*diag/max));
output.push_back(make_pair( 2,-rho(0,2) * off/max));
output.push_back(make_pair(-2,-rho(2,0) * off/max));
return output;
}
/**
* Calculate the matrix element for the splitting
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
*/
virtual DecayMEPtr matrixElement(const double z, const Energy2,
const IdList &, const double phi, bool) {
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin1)));
double omz = 1.-z;
double root = sqrt(z*omz);
Complex phase = exp(Complex(0.,1.)*phi);
(*kernal)(0,0,0) = phase/root;
(*kernal)(2,2,2) = -conj((*kernal)(0,0,0));
(*kernal)(0,0,2) = -sqr(z)/root/phase;
(*kernal)(2,2,0) = -conj((*kernal)(0,0,2));
(*kernal)(0,2,0) = -sqr(omz)/root/phase;
(*kernal)(2,0,2) = -conj((*kernal)(0,2,0));
(*kernal)(0,2,2) = 0.;
(*kernal)(2,0,0) = 0.;
return kernal;
}
public:
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const {return new_ptr(*this);}
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const {return new_ptr(*this);}
//@}
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
OneOneOneSplitFn & operator=(const OneOneOneSplitFn &) = delete;
};
}
#endif /* HERWIG_OneOneOneSplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.cc
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the GtoG1S0SplitFn class.
+//
+
+#include "GtoG1S0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+IBPtr GtoG1S0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr GtoG1S0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void GtoG1S0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,0,0);
+ m_ = getParticleData(4+state_)->mass();
+}
+
+void GtoG1S0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << ounit(m_,GeV) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void GtoG1S0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> iunit(m_,GeV) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<GtoG1S0SplitFn,Sudakov1to2FormFactor>
+describeHerwigGtoG1S0SplitFn("Herwig::GtoG1S0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void GtoG1S0SplitFn::Init() {
+
+ static ClassDocumentation<GtoG1S0SplitFn> documentation
+ ("The GtoG1S0SplitFn class implemets the splitting function for g -> g Eta");
+
+ static Reference<GtoG1S0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &GtoG1S0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<GtoG1S0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &GtoG1S0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<GtoG1S0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &GtoG1S0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<GtoG1S0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &GtoG1S0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void GtoG1S0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy2 pre = O1_/9./m_;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 c = (upper - lower) * colourFactor() * pre * aS2 * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG1S0SplitFn.h
@@ -0,0 +1,310 @@
+// -*- C++ -*-
+#ifndef Herwig_GtoG1S0SplitFn_H
+#define Herwig_GtoG1S0SplitFn_H
+//
+// This is the declaration of the GtoG1S0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The GtoG1S0SplitFn class implements the colour singlet splitting function for \f$g\to g \eta_{c,b}\f$.
+ *
+ * @see \ref GtoG1S0SplitFnInterfaces "The interfaces"
+ * defined for GtoG1S0SplitFn.
+ */
+class GtoG1S0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ GtoG1S0SplitFn() : O1_(0.573*GeV*GeV2), state_(ccbar), n_(1), m_(1.2*GeV), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ for(unsigned int ix=0;ix<2;++ix) {
+ if(ids[ix]->id()!=ParticleID::g) return false;
+ }
+ // check onium state
+ int iq=4+state_;
+ long idtest = iq*110+1 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return 1/z + 1/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & , const bool, const RhoDMatrix &) const {
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ return 1.-2.*z+2.*sqr(z) -8.*r*z*(1.-2.*z) + 32.*sqr(r*z);
+ }
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double z, const Energy2 t, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(rho.iSpin()==PDT::Spin1);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double on = 0.5*(1.-2.*z*(1.-z)) - 4.*z*(1.-2.*z)*r + 16.*sqr(z*r);
+ double off = z*(1.-z) + 4.*z*(1.-2.*z)*r - 16.*sqr(z*r);
+ double max = on+ 2.*abs(rho(0,2))*off;
+ vector<pair<int, Complex> > output;
+ output.reserve(3);
+ output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*on/max));
+ output.push_back(make_pair(-2, rho(0,2)*off/max));
+ output.push_back(make_pair( 2, rho(2,0)*off/max));
+ return output;
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double z, const Energy2, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(false);
+ assert(rho.iSpin()==PDT::Spin1);
+ double diag = sqr(1 - (1 - z)*z)/(1 - z)/z;
+ double off = (1.-z)/z;
+ double max = 2.*abs(rho(0,2))*off+diag;
+ vector<pair<int, Complex> > output;
+ output.reserve(3);
+ output.push_back(make_pair( 0, (rho(0,0)+rho(2,2))*diag/max));
+ output.push_back(make_pair( 2,-rho(0,2) * off/max));
+ output.push_back(make_pair(-2,-rho(2,0) * off/max));
+ return output;
+ }
+
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList &, const double phi, bool) {
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin0)));
+ Complex ii(0.,1.);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ Complex phase = exp(2.*ii*phi);
+ (*kernal)(0,0,0) = z*(1.+4.*r);
+ (*kernal)(2,2,0) = -(*kernal)(0,0,0) ;
+ (*kernal)(0,2,0) = -(1.-z-4.*z*r)/phase;
+ (*kernal)(2,0,0) = -conj((*kernal)(0,2,0));
+ return kernal;
+ }
+
+protected:
+
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ GtoG1S0SplitFn & operator=(const GtoG1S0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * The quark mass
+ */
+ Energy m_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_GtoG1S0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.cc
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the GtoG3P0SplitFn class.
+//
+
+#include "GtoG3P0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double GtoG3P0SplitFn::pOver_ = 10.;
+
+IBPtr GtoG3P0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr GtoG3P0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void GtoG3P0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,0);
+ m_ = getParticleData(4+state_)->mass();
+}
+
+void GtoG3P0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2*GeV2) << ounit(m_,GeV) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void GtoG3P0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2*GeV2) >> iunit(m_,GeV) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<GtoG3P0SplitFn,Sudakov1to2FormFactor>
+describeHerwigGtoG3P0SplitFn("Herwig::GtoG3P0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void GtoG3P0SplitFn::Init() {
+
+ static ClassDocumentation<GtoG3P0SplitFn> documentation
+ ("The GtoG3P0SplitFn class implemets the splitting function for g -> g Eta");
+
+ static Reference<GtoG3P0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &GtoG3P0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<GtoG3P0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &GtoG3P0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<GtoG3P0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &GtoG3P0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<GtoG3P0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &GtoG3P0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void GtoG3P0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy2 pre = O1_/27./pow<3,1>(m_);
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 c = (upper - lower) * colourFactor() * pre * aS2 * enhance * detune * pOver_;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P0SplitFn.h
@@ -0,0 +1,311 @@
+// -*- C++ -*-
+#ifndef Herwig_GtoG3P0SplitFn_H
+#define Herwig_GtoG3P0SplitFn_H
+//
+// This is the declaration of the GtoG3P0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The GtoG3P0SplitFn class implements the colour singlet splitting function for \f$g\to g \chi_{0(c,b)}\f$.
+ *
+ * @see \ref GtoG3P0SplitFnInterfaces "The interfaces"
+ * defined for GtoG3P0SplitFn.
+ */
+class GtoG3P0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ GtoG3P0SplitFn() : O1_(0.573*GeV*GeV2*GeV2), state_(ccbar), n_(1), m_(1.2*GeV), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ for(unsigned int ix=0;ix<2;++ix) {
+ if(ids[ix]->id()!=ParticleID::g) return false;
+ }
+ // check onium state
+ int iq=4+state_;
+ long idtest = iq*110+10001 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return 1/z + 1/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & , const bool, const RhoDMatrix &) const {
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double ratio = 1 - 2*(1-z)*z -8*r*(2 + z*(-3 + 2*z)) + 32*sqr(r)*(2 - 3*sqr(z)) -512*pow(r,3)*(1-z)*z + 2048*pow(r,4)*sqr(z);
+ ratio /= pOver_;
+ if(ratio>1.) cerr << "problem in GtoG3P0 ratio violated " << ratio << " " << pOver_ << "\n";
+ return ratio;
+ }
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double z, const Energy2 t, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(rho.iSpin()==PDT::Spin1);
+ double r = sqr(m_)/t;
+ double on = 1.+.16*sqr(r)-8.*r*(1.-z)-2.*(1.-z)*z;
+ double off = -2*(1-4.*r-z)*z;
+ double max = on+ 2.*abs(rho(0,2)*off);
+ vector<pair<int, Complex> > output;
+ output.reserve(3);
+ output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*on/max));
+ output.push_back(make_pair(-2, rho(0,2)*off/max));
+ output.push_back(make_pair( 2, rho(2,0)*off/max));
+ return output;
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double, const Energy2, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(false);
+ assert(rho.iSpin()==PDT::Spin1);
+ vector<pair<int, Complex> > output;
+ return output;
+ }
+
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList &, const double phi, bool) {
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin0)));
+ Complex ii(0.,1.);
+ double r = sqr(m_)/t;
+ Complex phase = exp(2.*ii*phi);
+ (*kernal)(0,0,0) = z;
+ (*kernal)(2,2,0) = z;
+ (*kernal)(0,2,0) = (1.-4.*r-z)/phase;
+ (*kernal)(2,0,0) = (1.-4.*r-z)*phase;
+ return kernal;
+ }
+
+protected:
+
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ GtoG3P0SplitFn & operator=(const GtoG3P0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * The quark mass
+ */
+ Energy m_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+ /**
+ * Max of the spltting function
+ */
+ static const double pOver_;
+
+};
+
+}
+
+#endif /* Herwig_GtoG3P0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.cc
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the GtoG3P1SplitFn class.
+//
+
+#include "GtoG3P1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double GtoG3P1SplitFn::pOver_ = 10.;
+
+IBPtr GtoG3P1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr GtoG3P1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void GtoG3P1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,1);
+ m_ = getParticleData(4+state_)->mass();
+}
+
+void GtoG3P1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2*GeV2) << ounit(m_,GeV) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void GtoG3P1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2*GeV2) >> iunit(m_,GeV) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<GtoG3P1SplitFn,Sudakov1to2FormFactor>
+describeHerwigGtoG3P1SplitFn("Herwig::GtoG3P1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void GtoG3P1SplitFn::Init() {
+
+ static ClassDocumentation<GtoG3P1SplitFn> documentation
+ ("The GtoG3P1SplitFn class implemets the splitting function for g -> g Eta");
+
+ static Reference<GtoG3P1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &GtoG3P1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<GtoG3P1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &GtoG3P1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<GtoG3P1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &GtoG3P1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<GtoG3P1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &GtoG3P1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void GtoG3P1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy2 pre = 2.*O1_/27./pow<3,1>(m_);
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 c = (upper - lower) * colourFactor() * pre * aS2 * enhance * detune * pOver_;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P1SplitFn.h
@@ -0,0 +1,320 @@
+// -*- C++ -*-
+#ifndef Herwig_GtoG3P1SplitFn_H
+#define Herwig_GtoG3P1SplitFn_H
+//
+// This is the declaration of the GtoG3P1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The GtoG3P1SplitFn class implements the colour singlet splitting function for \f$g\to g \chi_{0(c,b)}\f$.
+ *
+ * @see \ref GtoG3P1SplitFnInterfaces "The interfaces"
+ * defined for GtoG3P1SplitFn.
+ */
+class GtoG3P1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ GtoG3P1SplitFn() : O1_(0.573*GeV*GeV2*GeV2), state_(ccbar), n_(1), m_(1.2*GeV), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ for(unsigned int ix=0;ix<2;++ix) {
+ if(ids[ix]->id()!=ParticleID::g) return false;
+ }
+ // check onium state
+ int iq=4+state_;
+ long idtest = iq*110+20003 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return 1/z + 1/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & , const bool, const RhoDMatrix &) const {
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double ratio = 1. - 2.*(1.-z)*z + 8*r*(1 + z*(-1 + 2*z)) + 16*sqr(r)*(1 + 2*z) + 128*pow(r,3)*(1 - 2*z)*z - 512*pow(r,4)*sqr(z);
+ ratio /= pOver_;
+ if(ratio>1.) cerr << "problem in GtoG3P1 ratio violated " << ratio << " " << pOver_ << "\n";
+ return ratio;
+ }
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double z, const Energy2 t, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(rho.iSpin()==PDT::Spin1);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double on = 1.-2.*(1.-4.*r)*z*(1.-z-4.*r*z);
+ double off = 2.*(1.-4.*r)*z*(1.-z-4.*r*z);
+ double max = on+ 2.*abs(rho(0,2)*off);
+ vector<pair<int, Complex> > output;
+ output.reserve(3);
+ output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*on/max));
+ output.push_back(make_pair(-2, rho(0,2)*off/max));
+ output.push_back(make_pair( 2, rho(2,0)*off/max));
+ return output;
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double, const Energy2, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(false);
+ assert(rho.iSpin()==PDT::Spin1);
+ vector<pair<int, Complex> > output;
+ return output;
+ }
+
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList &, const double phi, bool) {
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin1)));
+ Complex ii(0.,1.);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double rt = sqrt(r*z*(1.-z-4*r*z));
+ Complex phase = exp(ii*phi);
+ (*kernal)(0,0,0) = (2*sqrt(2)*phase*rt)/(-1 + z);
+ (*kernal)(0,0,1) = (z*(-1 + z + 4*r*(1 + z)))/(-1 + z);
+ (*kernal)(0,0,2) = (-2*sqrt(2)*z*rt)/(phase*(-1 + z));
+ (*kernal)(0,2,0) = (2*sqrt(2)*rt)/phase;
+ (*kernal)(0,2,1) = (-1 + z + 4*r*z)/sqr(phase);
+ (*kernal)(0,2,2) = 0.;
+ (*kernal)(2,0,0) = 0.;
+ (*kernal)(2,0,1) = -(sqr(phase)*(-1 + z + 4*r*z));
+ (*kernal)(2,0,2) = 2*sqrt(2)*phase*rt;
+ (*kernal)(2,2,0) = (-2*sqrt(2)*phase*z*rt)/(-1 + z);
+ (*kernal)(2,2,1) = -((z*(-1 + z + 4*r*(1 + z)))/(-1 + z));
+ (*kernal)(2,2,2) = (2*sqrt(2)*rt)/(phase*(-1 + z));
+ return kernal;
+ }
+
+protected:
+
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ GtoG3P1SplitFn & operator=(const GtoG3P1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * The quark mass
+ */
+ Energy m_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+ /**
+ * Max of the spltting function
+ */
+ static const double pOver_;
+
+};
+
+}
+
+#endif /* Herwig_GtoG3P1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.cc
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the GtoG3P2SplitFn class.
+//
+
+#include "GtoG3P2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double GtoG3P2SplitFn::pOver_ = 20.;
+
+IBPtr GtoG3P2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr GtoG3P2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void GtoG3P2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,2);
+ m_ = getParticleData(4+state_)->mass();
+}
+
+void GtoG3P2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2*GeV2) << ounit(m_,GeV) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void GtoG3P2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2*GeV2) >> iunit(m_,GeV) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<GtoG3P2SplitFn,Sudakov1to2FormFactor>
+describeHerwigGtoG3P2SplitFn("Herwig::GtoG3P2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void GtoG3P2SplitFn::Init() {
+
+ static ClassDocumentation<GtoG3P2SplitFn> documentation
+ ("The GtoG3P2SplitFn class implemets the splitting function for g -> g Eta");
+
+ static Reference<GtoG3P2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &GtoG3P2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<GtoG3P2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &GtoG3P2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<GtoG3P2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &GtoG3P2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<GtoG3P2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &GtoG3P2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void GtoG3P2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy2 pre = 2.*O1_/135./pow<3,1>(m_);
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 c = (upper - lower) * colourFactor() * pre * aS2 * enhance * detune * pOver_;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3P2SplitFn.h
@@ -0,0 +1,329 @@
+// -*- C++ -*-
+#ifndef Herwig_GtoG3P2SplitFn_H
+#define Herwig_GtoG3P2SplitFn_H
+//
+// This is the declaration of the GtoG3P2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The GtoG3P2SplitFn class implements the colour singlet splitting function for \f$g\to g \chi_{0(c,b)}\f$.
+ *
+ * @see \ref GtoG3P2SplitFnInterfaces "The interfaces"
+ * defined for GtoG3P2SplitFn.
+ */
+class GtoG3P2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ GtoG3P2SplitFn() : O1_(0.573*GeV*GeV2*GeV2), state_(ccbar), n_(1), m_(1.2*GeV), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ for(unsigned int ix=0;ix<2;++ix) {
+ if(ids[ix]->id()!=ParticleID::g) return false;
+ }
+ // check onium state
+ int iq=4+state_;
+ long idtest = iq*110+5 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return 1/z + 1/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & , const bool, const RhoDMatrix &) const {
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double ratio = 1 - 2*(1.-z)*z + 8*r*(1 + (3 - 2*z)*z) + 16*sqr(r)*(7 + 6*(1 - 2*z)*z) - 128*pow(r,3)*z*(1 + 2*z) + 512*pow(r,4)*sqr(z);
+ ratio /= pOver_;
+ if(ratio>1.) cerr << "problem in GtoG3P2 ratio violated " << ratio << " " << pOver_ << "\n";
+ return ratio;
+ }
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double z, const Energy2 t, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(rho.iSpin()==PDT::Spin1);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ double on = (1.+8.*r*(1+14.*r)-2.*(1.+4.*r)*(1.-16.*(1.-r)*r)*z*(1.-z-4.*r*z))/3.;
+ double off = 2.*(1.+4.*r)*(1.-16.*(1.-r)*r)*z*(1.-z-4.*r*z)/3.;
+ double max = on+ 2.*abs(rho(0,2)*off);
+ vector<pair<int, Complex> > output;
+ output.reserve(3);
+ output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*on/max));
+ output.push_back(make_pair(-2, rho(0,2)*off/max));
+ output.push_back(make_pair( 2, rho(2,0)*off/max));
+ output.reserve(1);
+ output.push_back(make_pair( 0,0.));
+ return output;
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double, const Energy2, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(false);
+ assert(rho.iSpin()==PDT::Spin1);
+ vector<pair<int, Complex> > output;
+ return output;
+ }
+
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList &, const double phi, bool) {
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin2)));
+ Complex ii(0.,1.);
+ double r = sqr(m_)/(t-4.*sqr(m_));
+ Complex phase = exp(ii*phi);
+ (*kernal)(0,0,0) = (4*sqrt(2)*sqr(phase)*r*(-1 + z + 4*r*z))/sqr(1.-z);
+ (*kernal)(0,0,1) = (-2*sqrt(2)*phase*sqrt(-(r*z*(-1 + z + 4*r*z)))*(-1 + z + 4*r*(1 + z)))/sqr(1.-z);
+ (*kernal)(0,0,2) = -((z*(sqr(1.-z) + 8*r*(-2 + z + sqr(z)) + 16*sqr(r)*(1 + z*(4 + z))))/(sqrt(3)*sqr(1.-z)));
+ (*kernal)(0,0,3) = (2*sqrt(2)*pow(z,1.5)*sqrt(-(r*(-1 + z + 4*r*z)))*(-1 + z + 4*r*(1 + z)))/(phase*sqr(1.-z));
+ (*kernal)(0,0,4) = (4*sqrt(2)*r*sqr(z)*(-1 + z + 4*r*z))/(sqr(phase)*sqr(1.-z));
+ (*kernal)(0,2,0) = -4*sqrt(2)*r*(1 + 4*r)*z;
+ (*kernal)(0,2,1) = (2*sqrt(2)*(1 + 4*r)*sqrt(-(r*z*(-1 + z + 4*r*z))))/phase;
+ (*kernal)(0,2,2) = ((1 + 4*r)*(-1 + z + 4*r*z))/(sqrt(3)*sqr(phase));
+ (*kernal)(0,2,3) = 0;
+ (*kernal)(0,2,4) = 0;
+ (*kernal)(2,0,0) = 0;
+ (*kernal)(2,0,1) = 0;
+ (*kernal)(2,0,2) = (sqr(phase)*(1 + 4*r)*(-1 + z + 4*r*z))/sqrt(3);
+ (*kernal)(2,0,3) = -2*sqrt(2)*phase*(1 + 4*r)*sqrt(-(r*z*(-1 + z + 4*r*z)));
+ (*kernal)(2,0,4) = -4*sqrt(2)*r*(1 + 4*r)*z;
+ (*kernal)(2,2,0) = (4*sqrt(2)*sqr(phase)*r*sqr(z)*(-1 + z + 4*r*z))/sqr(1.-z);
+ (*kernal)(2,2,1) = (-2*sqrt(2)*phase*pow(z,1.5)*sqrt(-(r*(-1 + z + 4*r*z)))*(-1 + z + 4*r*(1 + z)))/sqr(1.-z);
+ (*kernal)(2,2,2) = -((z*(sqr(1.-z) + 8*r*(-2 + z + sqr(z)) + 16*sqr(r)*(1 + z*(4 + z))))/(sqrt(3)*sqr(1.-z)));
+ (*kernal)(2,2,3) = (2*sqrt(2)*sqrt(-(r*z*(-1 + z + 4*r*z)))*(-1 + z + 4*r*(1 + z)))/(phase*sqr(1.-z));
+ (*kernal)(2,2,4) = (4*sqrt(2)*r*(-1 + z + 4*r*z))/(sqr(phase)*sqr(1.-z));
+ return kernal;
+ }
+
+protected:
+
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ GtoG3P2SplitFn & operator=(const GtoG3P2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * The quark mass
+ */
+ Energy m_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+ /**
+ * Max of the spltting function
+ */
+ static const double pOver_;
+
+};
+
+}
+
+#endif /* Herwig_GtoG3P2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.cc
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the GtoG3S1SplitFn class.
+//
+
+#include "GtoG3S1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double GtoG3S1SplitFn::ny_ = 2.;
+const double GtoG3S1SplitFn::maxP_ = 5e4;
+
+IBPtr GtoG3S1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr GtoG3S1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void GtoG3S1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,1,1);
+ m_ = getParticleData(4+state_)->mass();
+}
+
+void GtoG3S1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << ounit(m_,GeV) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void GtoG3S1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> iunit(m_,GeV) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<GtoG3S1SplitFn,Sudakov1to2FormFactor>
+ describeHerwigGtoG3S1SplitFn("Herwig::GtoG3S1SplitFn",
+ "HwOniumParameters.so HwOniumShower.so");
+
+void GtoG3S1SplitFn::Init() {
+
+ static ClassDocumentation<GtoG3S1SplitFn> documentation
+ ("The GtoG3S1SplitFn class implements the splitting function for g -> g JPsi");
+
+ static Reference<GtoG3S1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &GtoG3S1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<GtoG3S1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &GtoG3S1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<GtoG3S1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &GtoG3S1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<GtoG3S1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &GtoG3S1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void GtoG3S1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ // z limits
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ // y limits
+ double ymin = 1.5*pow(m_/sqrt(t1),2./3.);
+ double ylow = pow(ymin,1.-ny_)/(1.-ny_), yupp = 1./(1.-ny_);
+ // main function
+ Energy2 pre = O1_/3.*5./1296./Constants::pi/m_;
+ double aS3 = fixedAlphaS_ < 0 ? pow(alpha()->overestimateValue(),3) : pow(fixedAlphaS_,3);
+ Energy2 c = (upper - lower) * (yupp-ylow) *colourFactor() * pre * aS3 * enhance * detune;
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(UseRandom::rnd()));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+ // guess y
+ double rnd=UseRandom::rnd();
+ y_ = ylow+rnd*(yupp-ylow);
+ y_ = pow(y_*(1.-ny_),1./(1-ny_));
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/GtoG3S1SplitFn.h
@@ -0,0 +1,378 @@
+// -*- C++ -*-
+#ifndef Herwig_GtoG3S1SplitFn_H
+#define Herwig_GtoG3S1SplitFn_H
+//
+// This is the declaration of the GtoG3S1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+using namespace ThePEG;
+
+/**
+ * The documentation of the GtoG3S1SplitFn class implements the colour singlet spliting function for \f$g\to g J\Psi,\Upsilon\f$
+ *
+ * @see \ref GtoG3S1SplitFnInterfaces "The interfaces"
+ * defined for GtoG3S1SplitFn.
+ */
+class GtoG3S1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ GtoG3S1SplitFn() : O1_(0.573*GeV*GeV2), state_(ccbar), n_(1),
+ m_(1.2*GeV), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ for(unsigned int ix=0;ix<2;++ix) {
+ if(ids[ix]->id()!=ParticleID::g) return false;
+ }
+ // check onium state
+ int iq=4+state_;
+ long idtest = iq*110+3 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return maxP_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & , const bool, const RhoDMatrix &) const {
+ double r = 4.*sqr(m_)/t;
+ double ratio = I(z,r)/maxP_*pow(y_,ny_);
+ if(ratio>1.) cerr << "Overestimate violated " <<ratio << " " << z << " " << t/GeV2 << " " << y_ << "\n";
+ return ratio;
+ }
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return maxP_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/maxP_));
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double z, const Energy2 t, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(rho.iSpin()==PDT::Spin1);
+ // double r = sqr(m_)/(t-4.*sqr(m_));
+ // double on = 0.5*(1.-2.*z*(1.-z)) - 4.*z*(1.-2.*z)*r + 16.*sqr(z*r);
+ // double off = z*(1.-z) + 4.*z*(1.-2.*z)*r - 16.*sqr(z*r);
+ // double max = on+ 2.*abs(rho(0,2))*off;
+ // vector<pair<int, Complex> > output;
+ // output.reserve(3);
+ // output.push_back(make_pair( 0,(rho(0,0)+rho(2,2))*on/max));
+ // output.push_back(make_pair(-2, rho(0,2)*off/max));
+ // output.push_back(make_pair( 2, rho(2,0)*off/max));
+ // return output;
+ return vector<pair<int, Complex> >(1,make_pair(0,1.));
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double z, const Energy2, const IdList &,
+ const RhoDMatrix & rho) {
+ assert(false);
+ assert(rho.iSpin()==PDT::Spin1);
+ // double diag = sqr(1 - (1 - z)*z)/(1 - z)/z;
+ // double off = (1.-z)/z;
+ // double max = 2.*abs(rho(0,2))*off+diag;
+ // vector<pair<int, Complex> > output;
+ // output.reserve(3);
+ // output.push_back(make_pair( 0, (rho(0,0)+rho(2,2))*diag/max));
+ // output.push_back(make_pair( 2,-rho(0,2) * off/max));
+ // output.push_back(make_pair(-2,-rho(2,0) * off/max));
+ return vector<pair<int, Complex> >(1,make_pair(0,1.));
+ }
+
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList &, const double phi, bool) {
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1,PDT::Spin1,PDT::Spin1)));
+ // Complex ii(0.,1.);
+ // double r = sqr(m_)/(t-4.*sqr(m_));
+ // Complex phase = exp(2.*ii*phi);
+ // (*kernal)(0,0,0) = z*(1.+4.*r);
+ // (*kernal)(2,2,0) = -(*kernal)(0,0,0) ;
+ // (*kernal)(0,2,0) = -(1.-z-4.*z*r)/phase;
+ // (*kernal)(2,0,0) = -conj((*kernal)(0,2,0));
+ (*kernal)(0,0,0) = 1.;
+ (*kernal)(2,2,0) = 1.;
+ (*kernal)(0,0,1) = 1.;
+ (*kernal)(2,2,1) = 1.;
+ (*kernal)(0,0,2) = 1.;
+ (*kernal)(2,2,2) = 1.;
+ return kernal;
+ }
+ //@}
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+
+protected:
+
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return pow(alpha()->ratio(pt2, factor),3);
+ }
+ else {
+ return 1.;
+ }
+ }
+
+ /**
+ * Phase Space veto member to implement the \f$\Theta\f$ function as a veto
+ * so that the emission is within the allowed phase space.
+ * @param t The scale
+ * @param maxQ2 The maximum virtuality
+ * @return true if vetoed
+ */
+ virtual bool PSVeto(const Energy2 t) {
+ double r = 4.*sqr(m_)/z()/(1.-z())/t;
+ if ( y_>0.5*(1.+r) || y_<0.5*(r+sqr(1.-z()))/(1.-z()) ) return true;
+ return Sudakov1to2FormFactor::PSVeto(t);
+ }
+
+protected:
+
+ /**
+ * Integrand for the splitting function
+ */
+ double I(double zz, double r) const {
+ double z = 1.-zz;
+ double r2(sqr(r)),r3(r*r2);
+ double y2(sqr(y_)),y3(y2*y_),y4(y3*y_),y5(y4*y_),y6(y5*y_);
+ double f0 = r2*(1 + r)*(3 + 12*r + 13*r2) - 16*r2*(1 + r)*(1 + 3*r)*y_
+ - 2*r*(3 - 9*r - 21*r2 + 7*r3)* y2 + 8*r*(4 + 3*r + 3*r2)*y3
+ - 4*r*(9 - 3*r - 4*r2)*y4 - 16*(1 + 3*r + 3*r2)*y5 + 8*(6 + 7*r)*y6 - 32*y_*y6;
+ double f1 = -2*r*(1 + 5*r + 19*r2 + 7*r3)*y_ + 96*r2*(1 + r)*y2
+ + 8*(1 - 5*r - 22*r2 - 2*r3)*y3 + 16*r*(7 + 3*r)*y4 - 8*(5 + 7*r)*y5 + 32*y6;
+ double f2 = r*(1 + 5*r + 19*r2 + 7*r3) - 48*r2*(1 + r)*y_ - 4*(1 - 5*r - 22*r2 - 2*r3)*y2
+ - 8*r*(7 + 3*r)*y3 + 4*(5 + 7*r)*y4 - 16*y5;
+ double g0 = (1 - r)*r3*(3 + 24*r + 13*r2) - 4*r3*(7 - 3*r - 12*r2)*y_
+ - 2*r3*(17 + 22*r - 7*r2)*y2 + 4*r2*(13 + 5*r - 6*r2)*y3
+ - 8*r*(1 + 2*r + 5*r2 + 2*r3)*y4 - 8*r*(3 - 11*r - 6*r2)*y5 + 8*(1 - 2*r - 5*r2)*y6;
+ double g1 = -2*(1 - r)*r2*(1 + r)*(1 + 7*r)*y_ + 8*(1 - 4*r)*r2*(1 + 3*r)*y2
+ + 4*r*(1 + 10*r + 57*r2 + 4*r3)* y3 - 8*r*(1 + 29*r + 6*r2)*y4 - 8*(1 - 8*r - 5*r2)*y5;
+ double g2 = (1 - r)*r2*(1 + r)*(1 + 7*r) - 4*(1 - 4*r)*r2*(1 + 3*r)*y_
+ - 2*r*(1 + 10*r + 57*r2 + 4*r3)* y2 + 4*r*(1 + 29*r + 6*r2)*y3 + 4*(1 - 8*r - 5*r2)*y4;
+ double c1 = f0+z*f1+sqr(z)*f2;
+ double c2 = g0+z*g1+sqr(z)*g2;
+ double root = sqrt(-r + y2);
+ return (c1 + ((1 + r - 2*y_)*c2*log((-r + y_ + root)/(-r + y_ - root)))/(2.*(-r + y_)*root))
+ /(sqr(1 - y_)*sqr(-r + y_)*sqr(-r + y2));
+ }
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ GtoG3S1SplitFn & operator=(const GtoG3S1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * The quark mass
+ */
+ Energy m_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+ /**
+ * Maximum value for the overestimate
+ */
+ static const double maxP_;
+
+ /**
+ * Auxillary y variable
+ */
+ double y_;
+
+ /**
+ * Power for the samping of y
+ */
+ static const double ny_;
+
+};
+
+}
+
+#endif /* Herwig_GtoG3S1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/Makefile.am b/Shower/QTilde/SplittingFunctions/Onium/Makefile.am
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/Makefile.am
@@ -0,0 +1,31 @@
+pkglib_LTLIBRARIES = HwOniumShower.la
+
+HwOniumShower_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 1:0:0
+
+HwOniumShower_la_SOURCES = \
+GtoG1S0SplitFn.cc GtoG1S0SplitFn.h \
+GtoG3S1SplitFn.cc GtoG3S1SplitFn.h \
+GtoG3P0SplitFn.cc GtoG3P0SplitFn.h \
+GtoG3P1SplitFn.cc GtoG3P1SplitFn.h \
+GtoG3P2SplitFn.cc GtoG3P2SplitFn.h \
+QtoQP1S0SplitFn.cc QtoQP1S0SplitFn.h \
+QtoQ1S0SplitFn.cc QtoQ1S0SplitFn.h \
+QtoQP3S1SplitFn.cc QtoQP3S1SplitFn.h \
+QtoQ3S1SplitFn.cc QtoQ3S1SplitFn.h \
+QtoQP3P0SplitFn.cc QtoQP3P0SplitFn.h \
+QtoQ3P0SplitFn.cc QtoQ3P0SplitFn.h \
+QtoQPP1SplitFn.cc QtoQPP1SplitFn.h \
+QtoQ1P1SplitFn.cc QtoQ1P1SplitFn.h \
+QtoQ3P1SplitFn.cc QtoQ3P1SplitFn.h \
+QtoQP3P2SplitFn.cc QtoQP3P2SplitFn.h \
+QtoQ3P2SplitFn.cc QtoQ3P2SplitFn.h \
+QtoQ1D2SplitFn.cc QtoQ1D2SplitFn.h \
+QtoQ3D1SplitFn.cc QtoQ3D1SplitFn.h \
+QtoQ3D2SplitFn.cc QtoQ3D2SplitFn.h \
+QtoQ3D3SplitFn.cc QtoQ3D3SplitFn.h \
+QtoQPD2SplitFn.cc QtoQPD2SplitFn.h \
+QtoQP3D1SplitFn.cc QtoQP3D1SplitFn.h \
+QtoQP3D3SplitFn.cc QtoQP3D3SplitFn.h \
+QtoQBarQQ1SplitFn.cc QtoQBarQQ1SplitFn.h \
+QtoQPBarQQP0SplitFn.cc QtoQPBarQQP0SplitFn.h \
+QtoQPBarQQP1SplitFn.cc QtoQPBarQQP1SplitFn.h
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.cc
@@ -0,0 +1,160 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ1D2SplitFn class.
+//
+
+#include "QtoQ1D2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ1D2SplitFn::pOver_ = 20.;
+
+IBPtr QtoQ1D2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ1D2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ1D2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ1D2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ1D2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,0,2);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ1D2SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ1D2SplitFn("Herwig::QtoQ1D2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ1D2SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ1D2SplitFn> documentation
+ ("The QtoQ1D2SplitFn class implements the branching q-> q 1D2");
+
+ static Reference<QtoQ1D2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ1D2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ1D2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ1D2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ1D2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ1D2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ1D2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ1D2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ1D2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 4./405.*aS2*O1_/m/sqr(m*m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ1D2SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = 8*z*(73 - 42*z + 31*pow(z,2) - 44*pow(z,3) + 55*pow(z,4) - 10*pow(z,5) + pow(z,6))/(3.*pow(1 + z,6));
+ double W1 =-128.*(-2 + 39*z - 8*pow(z,2) - 26*pow(z,3) + 6*pow(z,4) + 7*pow(z,5))/(3.*pow(1 + z,4));
+ double W2 =-128.*(22 - 113*z - 63*pow(z,2) + 105*pow(z,3) + pow(z,4))/(3.*pow(1 + z,3));
+ double W3 = 10240.*(1.-2*z)/(3.*(1.+z));
+ double W4 =-8192./3.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ1D2SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ1D2SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ1D2SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.); Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r23 = sqrt(2./3.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin2)));
+ (*kernal)(0,0,0)=-16.*sqr(phase)*r*(2*sqr(r)*(-1 + z)*pow(1 + z,3) + sqr(z)*(3 - 4*z + sqr(z)) + r*z*(-1 - 7*z - 3*sqr(z) + 3*pow(z,3)))/(sqr(1.-z)*rz*(1 + z));
+ (*kernal)(0,0,1)= 16.*pT*phase*r*(-2*(-1 + z)*z + 4*sqr(r)*(-1 + z)*pow(1 + z,3) + r*sqr(1.+z)*(1 - 8*z + 3*sqr(z)))/(m*rz*sqr(1.-sqr(z)));
+ (*kernal)(0,0,2)= 2.*r23*(48*pow(r,3)*(-1 + z)*pow(1 + z,5) + sqr(1.-z)*z*(-7 + 3*z - 5*sqr(z) + pow(z,3)) + 2*r*pow(1 + z,3)*(-1 + 19*z - 23*sqr(z) + 5*pow(z,3)) + 8*sqr(r)*pow(1 + z,3)*(2 - 9*z - 12*sqr(z) + 7*pow(z,3)))/(sqr(1.-z)*rz*pow(1 + z,3));
+ (*kernal)(0,0,3)=-16.*pT*r*(-2*(-1 + z)*z + 4*sqr(r)*(-1 + z)*pow(1 + z,3) + r*sqr(1.+z)*(1 - 8*z + 3*sqr(z)))/(m*phase*rz*sqr(1.-sqr(z)));
+ (*kernal)(0,0,4)=-16.*r*(2*sqr(r)*(-1 + z)*pow(1 + z,3) + sqr(z)*(3 - 4*z + sqr(z)) + r*z*(-1 - 7*z - 3*sqr(z) + 3*pow(z,3)))/(sqr(phase)*sqr(1.-z)*rz*(1 + z));
+ (*kernal)(0,1,0)= 16.*pT*phase*r*(sqr(1.-z)*z + 2*sqr(r)*pow(1 + z,3) + 2*r*z*(-1 + sqr(z)))/(m*sqr(1.-z)*rz*(1 + z));
+ (*kernal)(0,1,1)= 8.*(pow(-1 + z,3)*z + 8*pow(r,3)*pow(1 + z,5) + 4*r*z*sqr(1.-sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-1 - 4*z + 5*sqr(z)))/(rz*sqr(1.-sqr(z)));
+ (*kernal)(0,1,2)=(-4*r23*pT*r*(24*sqr(r)*pow(1 + z,3) + sqr(1.-z)*(1 + 3*z) + 8*r*(-1 - 2*z + sqr(z) + 2*pow(z,3))))/(m*phase*sqr(1.-z)*rz*(1 + z));
+ (*kernal)(0,1,3)=(-16.*r*(sqr(1.-z)*z + 4*sqr(r)*pow(1 + z,3) + r*(-1 - 5*z + sqr(z) + 5*pow(z,3))))/(sqr(phase)*sqr(1.-z)*rz);
+ (*kernal)(0,1,4)=(32*pT*sqr(r)*((-1 + z)*z + r*sqr(1.+z)))/(m*pow(phase,3)*sqr(1.-z)*rz);
+ (*kernal)(1,0,0)=(32*pT*pow(phase,3)*sqr(r)*((-1 + z)*z + r*sqr(1.+z)))/(m*sqr(1.-z)*rz);
+ (*kernal)(1,0,1)=(16.*sqr(phase)*r*(sqr(1.-z)*z + 4*sqr(r)*pow(1 + z,3) + r*(-1 - 5*z + sqr(z) + 5*pow(z,3))))/(sqr(1.-z)*rz);
+ (*kernal)(1,0,2)=(-4*r23*pT*phase*r*(24*sqr(r)*pow(1 + z,3) + sqr(1.-z)*(1 + 3*z) + 8*r*(-1 - 2*z + sqr(z) + 2*pow(z,3))))/(m*sqr(1.-z)*rz*(1 + z));
+ (*kernal)(1,0,3)=(-8*(pow(-1 + z,3)*z + 8*pow(r,3)*pow(1 + z,5) + 4*r*z*sqr(1.-sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-1 - 4*z + 5*sqr(z))))/(rz*sqr(1.-sqr(z)));
+ (*kernal)(1,0,4)=(16.*pT*r*(sqr(1.-z)*z + 2*sqr(r)*pow(1 + z,3) + 2*r*z*(-1 + sqr(z))))/(m*phase*sqr(1.-z)*rz*(1 + z));
+ (*kernal)(1,1,0)=(16.*sqr(phase)*r*(2*sqr(r)*(-1 + z)*pow(1 + z,3) + sqr(z)*(3 - 4*z + sqr(z)) + r*z*(-1 - 7*z - 3*sqr(z) + 3*pow(z,3))))/(sqr(1.-z)*rz*(1 + z));
+ (*kernal)(1,1,1)=(-16.*pT*phase*r*(-2*(-1 + z)*z + 4*sqr(r)*(-1 + z)*pow(1 + z,3) + r*sqr(1.+z)*(1 - 8*z + 3*sqr(z))))/(m*rz*sqr(1.-sqr(z)));
+ (*kernal)(1,1,2)=(-2*r23*(48*pow(r,3)*(-1 + z)*pow(1 + z,5) + sqr(1.-z)*z*(-7 + 3*z - 5*sqr(z) + pow(z,3)) + 2*r*pow(1 + z,3)*(-1 + 19*z - 23*sqr(z) + 5*pow(z,3)) + 8*sqr(r)*pow(1 + z,3)*(2 - 9*z - 12*sqr(z) + 7*pow(z,3))))/(sqr(1.-z)*rz*pow(1 + z,3));
+ (*kernal)(1,1,3)=(16.*pT*r*(-2*(-1 + z)*z + 4*sqr(r)*(-1 + z)*pow(1 + z,3) + r*sqr(1.+z)*(1 - 8*z + 3*sqr(z))))/(m*phase*rz*sqr(1.-sqr(z)));
+ (*kernal)(1,1,4)=(16.*r*(2*sqr(r)*(-1 + z)*pow(1 + z,3) + sqr(z)*(3 - 4*z + sqr(z)) + r*z*(-1 - 7*z - 3*sqr(z) + 3*pow(z,3))))/(sqr(phase)*sqr(1.-z)*rz*(1 + z));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1D2SplitFn.h
@@ -0,0 +1,279 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ1D2SplitFn_H
+#define Herwig_QtoQ1D2SplitFn_H
+//
+// This is the declaration of the QtoQ1D2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ1D2SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^1D_2)\f$.
+ *
+ * @see \ref QtoQ1D2SplitFnInterfaces "The interfaces"
+ * defined for QtoQ1D2SplitFn.
+ */
+class QtoQ1D2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ1D2SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+5 + 10000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ1D2SplitFn & operator=(const QtoQ1D2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ1D2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.cc
@@ -0,0 +1,176 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ1P1SplitFn class.
+//
+
+#include "QtoQ1P1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ1P1SplitFn::pOver_ = 1.;
+
+IBPtr QtoQ1P1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ1P1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ1P1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ1P1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ1P1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,0,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ1P1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ1P1SplitFn("Herwig::QtoQ1P1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ1P1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ1P1SplitFn> documentation
+ ("The QtoQ1P1SplitFn class implements the branching q-> q P1");
+
+ static Reference<QtoQ1P1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ1P1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ1P1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ1P1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ1P1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ1P1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ1P1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ1P1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+}
+
+void QtoQ1P1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 64./243.*aS2*O1_/m/sqr(m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ1P1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = 0.25*z*(33.-20.*z-2.*sqr(z)-4.*pow(z,3)+9.*pow(z,4))/pow(1.+z,4);
+ double W1 = (6.-44.*z+30.*sqr(z))/sqr(1.+z);
+ double W2 = 12.*(-3.+5.*z)/(1+z);
+ double W3 = 32.;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ // cerr << "testing values " << " " << z << " " << W0 << " " << W1 << " " << W2 << " " << W3 << "\n";
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ1P1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ1P1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ1P1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.); Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r2 = sqrt(2.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0) = ii*r2*phase*pT/m/rz*r*(2.*r+(3.-z)*z/(1.-z)/(1.+z));
+ (*kernal)(0,0,1) = ii/rz*(4.*sqr(r)*(1.+z)-0.5*z*(5.-2.*z+sqr(z))/sqr(1.+z)-r*(1.-8.*z+3.*sqr(z))/(1.-z));
+ (*kernal)(0,0,2) =-ii*r2*pT/m*r/phase/rz*(2.*r+(3.-z)*z/(1.-z)/(1.+z));
+ (*kernal)(0,1,0) = ii*r2/rz*(2.*r*z-(1.-z)*z/(1.+z)-2.*sqr(r)*sqr(1.+z)/(1.-z));
+ (*kernal)(0,1,1) =-ii*pT*r/phase/m/rz*(1.-4.*r*(1.+z)/(1.-z));
+ (*kernal)(0,1,2) =-2.*ii*r2*r/sqr(phase)/rz*(z-r*sqr(1.+z)/(1.-z));
+ (*kernal)(1,0,0) = 2.*ii*r2*sqr(phase)*r/rz*(z-r*sqr(1.+z)/(1.-z));
+ (*kernal)(1,0,1) = -ii*phase*pT/m*r/rz*(1.-4.*r*(1.+z)/(1.-z));
+ (*kernal)(1,0,2) = ii*r2/rz*(-2.*r*z +z*(1.-z)/(1 + z)+2.*sqr(r)*sqr(1.+z)/(1.-z));
+ (*kernal)(1,1,0) =-ii*r2*phase*pT/m/rz*r*(2.*r+z*(3.-z)/(1.-z)/(1.+z));
+ (*kernal)(1,1,1) = ii/rz*(-4.*sqr(r)*(1.+z)+0.5*z*(5.-2.*z+sqr(z))/sqr(1.+z)+r*(1.-8.*z+3.*sqr(z))/(1.-z));
+ (*kernal)(1,1,2) = ii*r2*pT/m/phase/rz*r*(2.*r+(3.-z)*z/(1.-z)/(1.+z));
+
+
+ // DecayMEPtr test(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ // (*test)(0,0,0) =(Complex(0,2)*sqrt(2)*phase*pT*pow(r,2))/(m*sqrt(z)) + (Complex(0,1)*sqrt(2)*phase*pT*r*(-3 + z)*sqrt(z))/(m*(-1 + z)*(1 + z));
+ // (*test)(0,0,1) =(Complex(0,4)*pow(r,2)*(1 + z))/sqrt(z) - (Complex(0,0.5)*sqrt(z)*(5 - 2*z + pow(z,2)))/pow(1 + z,2) + (Complex(0,1)*r*(1 - 8*z + 3*pow(z,2)))/((-1 + z)*sqrt(z));
+ // (*test)(0,0,2) =(Complex(0,-2)*sqrt(2)*pT*pow(r,2))/(phase*m*sqrt(z)) - (Complex(0,1)*sqrt(2)*pT*r*(-3 + z)*sqrt(z))/(phase*m*(-1 + z)*(1 + z));
+ // (*test)(0,1,0) =Complex(0,2)*sqrt(2)*r*sqrt(z) + (Complex(0,1)*sqrt(2)*(-1 + z)*sqrt(z))/(1 + z) + (Complex(0,2)*sqrt(2)*pow(r,2)*pow(1 + z,2))/((-1 + z)*sqrt(z));
+ // (*test)(0,1,1) =(Complex(0,-1)*pT*r)/(phase*m*sqrt(z)) - (Complex(0,4)*pT*pow(r,2)*(1 + z))/(phase*m*(-1 + z)*sqrt(z));
+ // (*test)(0,1,2) =(Complex(0,-2)*sqrt(2)*r*sqrt(z))/sqr(phase) - (Complex(0,2)*sqrt(2)*pow(r,2)*pow(1 + z,2))/(sqr(phase)*(-1 + z)*sqrt(z));
+ // (*test)(1,0,0) =Complex(0,2)*sqrt(2)*sqr(phase)*r*sqrt(z) + (Complex(0,2)*sqrt(2)*sqr(phase)*pow(r,2)*pow(1 + z,2))/((-1 + z)*sqrt(z));
+ // (*test)(1,0,1) =(Complex(0,-1)*phase*pT*r)/(m*sqrt(z)) - (Complex(0,4)*phase*pT*pow(r,2)*(1 + z))/(m*(-1 + z)*sqrt(z));
+ // (*test)(1,0,2) =Complex(0,-2)*sqrt(2)*r*sqrt(z) - (Complex(0,1)*sqrt(2)*(-1 + z)*sqrt(z))/(1 + z) - (Complex(0,2)*sqrt(2)*pow(r,2)*pow(1 + z,2))/((-1 + z)*sqrt(z));
+ // (*test)(1,1,0) =(Complex(0,-2)*sqrt(2)*phase*pT*pow(r,2))/(m*sqrt(z)) - (Complex(0,1)*sqrt(2)*phase*pT*r*(-3 + z)*sqrt(z))/(m*(-1 + z)*(1 + z));
+ // (*test)(1,1,1) =(Complex(0,-4)*pow(r,2)*(1 + z))/sqrt(z) + (Complex(0,0.5)*sqrt(z)*(5 - 2*z + pow(z,2)))/pow(1 + z,2) - (Complex(0,1)*r*(1 - 8*z + 3*pow(z,2)))/((-1 + z)*sqrt(z));
+ // (*test)(1,1,2) =(Complex(0,2)*sqrt(2)*pT*pow(r,2))/(phase*m*sqrt(z)) + (Complex(0,1)*sqrt(2)*pT*r*(-3 + z)*sqrt(z))/(phase*m*(-1 + z)*(1 + z));
+ // // testing code
+ // cerr << "testing in kernal " << " " << z << " " << r << " " << pT/m << " " << phi << "\n";
+ // for(unsigned int ih1=0;ih1<2;++ih1) {
+ // for(unsigned int ih2=0;ih2<2;++ih2) {
+ // for(unsigned int ih3=0;ih3<3;++ih3) {
+ // cerr << ih1 << " " << ih2 << " " << ih3 << " " << (*kernal)(ih1,ih2,ih3) << "\n";
+ // cerr << "testing diff " << abs((*kernal)(ih1,ih2,ih3)-(*test)(ih1,ih2,ih3)) << "\n";
+ // }
+ // }
+ // }
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1P1SplitFn.h
@@ -0,0 +1,279 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ1P1SplitFn_H
+#define Herwig_QtoQ1P1SplitFn_H
+//
+// This is the declaration of the QtoQ1P1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ1P1SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^1P_1)\f$.
+ *
+ * @see \ref QtoQ1P1SplitFnInterfaces "The interfaces"
+ * defined for QtoQ1P1SplitFn.
+ */
+class QtoQ1P1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ1P1SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+3 + 10000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ1P1SplitFn & operator=(const QtoQ1P1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ1P1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.cc
@@ -0,0 +1,140 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ1S0SplitFn class.
+//
+
+#include "QtoQ1S0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ1S0SplitFn::pOver_ = 3.;
+
+IBPtr QtoQ1S0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ1S0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ1S0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ1S0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ1S0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,0,0);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ1S0SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ1S0SplitFn("Herwig::QtoQ1S0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ1S0SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ1S0SplitFn> documentation
+ ("The QtoQ1S0SplitFn class implements the branching q-> q 1S0");
+
+ static Reference<QtoQ1S0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ1S0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ1S0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ1S0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ1S0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ1S0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ1S0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ1S0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ1S0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 16./81.*aS2 * O1_ / m;
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ1S0SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double ratio = ( sqr(3.-z)*z/sqr(1.+z) + 16.*r*(1.-z)/(1.+z) -16.*sqr(r))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ1S0SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ1S0SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ1S0SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double rz=sqrt(z);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin0)));
+ (*kernal)(0,0,0) =-((3.-z)*z + 2.*r*(1.-sqr(z)))/rz/(1.+z);
+ (*kernal)(1,1,0) =-(*kernal)(0,0,0);
+ (*kernal)(0,1,0) = -2.*double(pT/m)*r/rz/phase;
+ (*kernal)(1,0,0) = conj((*kernal)(0,1,0));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ1S0SplitFn.h
@@ -0,0 +1,282 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ1S0SplitFn_H
+#define Herwig_QtoQ1S0SplitFn_H
+//
+// This is the declaration of the QtoQ1S0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ1S0SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^1S_0)\f$
+ *
+ * @see \ref QtoQ1S0SplitFnInterfaces "The interfaces"
+ * defined for QtoQ1S0SplitFn.
+ */
+class QtoQ1S0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ1S0SplitFn() : O1_(0.573*GeV*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+1 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ1S0SplitFn & operator=(const QtoQ1S0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ1S0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.cc
@@ -0,0 +1,152 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3D1SplitFn class.
+//
+
+#include "QtoQ3D1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3D1SplitFn::pOver_ = 10.;
+
+IBPtr QtoQ3D1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3D1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3D1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3D1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3D1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,1,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3D1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3D1SplitFn("Herwig::QtoQ3D1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3D1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3D1SplitFn> documentation
+ ("The QtoQ3D1SplitFn class implements the branching q-> q 3D1");
+
+ static Reference<QtoQ3D1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3D1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3D1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3D1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3D1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3D1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3D1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3D1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3D1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 4./243.*aS2*O1_/m/sqr(m*m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3D1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = 4.*z*(73 - 82*z + 1071*sqr(z) - 412*pow(z,3) - 105*pow(z,4) + 14*pow(z,5) + 17*pow(z,6))/(15.*pow(1 + z,6));
+ double W1 =-8.*(-673 + 677*z + 974*sqr(z) + 994*pow(z,3) + 275*pow(z,4) + 57*pow(z,5))/(15.*pow(1 + z,4));
+ double W2 =-64.*(557 - 305*z - 885*sqr(z) + 197*pow(z,3) + 28*pow(z,4))/(15.*pow(1 + z,3));
+ double W3 =-256.*(-211 + 178*z + 29*sqr(z))/(15.*(1 + z));
+ double W4 =-8192./5.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3D1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3D1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3D1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.); Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r215 = sqrt(2./15.), r15 = sqrt(15.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0)=(-2*r215*pT*phase*r*(17 - 5*z + 7*sqr(z) + 5*pow(z,3) + 22*r*(-3 + z)*pow(1 + z,2) + 48*sqr(r)*pow(1 + z,3)))/(m*(-1 + z)*rz*pow(1 + z,2));
+ (*kernal)(0,0,1)=(-2*(96*pow(r,3)*pow(1 + z,5) + 4*r*pow(1 + z,3)*(5 + z) + 4*sqr(r)*pow(1 + z,3)*(-31 - 30*z + 17*sqr(z)) - z*(1 + 30*z - 36*sqr(z) + 2*pow(z,3) + 3*pow(z,4))))/(r15*(-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(0,0,2)=(4*r215*pT*r*(24*sqr(r)*pow(1 + z,3) + r*pow(1 + z,2)*(-25 + 3*z) + z*(-1 + 12*z + sqr(z))))/(m*phase*(-1 + z)*rz*pow(1 + z,2));
+ (*kernal)(0,1,0)=(2*r215*(48*pow(r,3)*pow(1 + z,5) + 2*pow(-1 + z,2)*z*(3 + sqr(z)) + r*pow(1 + z,3)*(17 - 18*z + sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-33 - 34*z + 15*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(0,1,1)=(-8*pT*r*(5 - 4*z + sqr(z) - 2*pow(z,3) + 24*sqr(r)*pow(1 + z,3) + r*pow(1 + z,2)*(-31 + 5*z)))/(r15*m*phase*(-1 + z)*rz*pow(1 + z,2));
+ (*kernal)(0,1,2)=(-4*r215*r*(24*sqr(r)*pow(1 + z,3) - z*(-25 + 24*z + sqr(z)) + r*(-25 - 75*z - 27*sqr(z) + 23*pow(z,3))))/(sqr(phase)*rz*(-1 + sqr(z)));
+ (*kernal)(1,0,0)=(-4*r215*sqr(phase)*r*(24*sqr(r)*pow(1 + z,3) - z*(-25 + 24*z + sqr(z)) + r*(-25 - 75*z - 27*sqr(z) + 23*pow(z,3))))/(rz*(-1 + sqr(z)));
+ (*kernal)(1,0,1)=(8*pT*phase*r*(5 - 4*z + sqr(z) - 2*pow(z,3) + 24*sqr(r)*pow(1 + z,3) + r*pow(1 + z,2)*(-31 + 5*z)))/(r15*m*(-1 + z)*rz*pow(1 + z,2));
+ (*kernal)(1,0,2)=(2*r215*(48*pow(r,3)*pow(1 + z,5) + 2*pow(-1 + z,2)*z*(3 + sqr(z)) + r*pow(1 + z,3)*(17 - 18*z + sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-33 - 34*z + 15*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(1,1,0)=(-4*r215*pT*phase*r*(24*sqr(r)*pow(1 + z,3) + r*pow(1 + z,2)*(-25 + 3*z) + z*(-1 + 12*z + sqr(z))))/(m*(-1 + z)*rz*pow(1 + z,2));
+ (*kernal)(1,1,1)=(-2*(96*pow(r,3)*pow(1 + z,5) + 4*r*pow(1 + z,3)*(5 + z) + 4*sqr(r)*pow(1 + z,3)*(-31 - 30*z + 17*sqr(z)) - z*(1 + 30*z - 36*sqr(z) + 2*pow(z,3) + 3*pow(z,4))))/(r15*(-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(1,1,2)=(2*r215*pT*r*(17 - 5*z + 7*sqr(z) + 5*pow(z,3) + 22*r*(-3 + z)*pow(1 + z,2) + 48*sqr(r)*pow(1 + z,3)))/(m*phase*(-1 + z)*rz*pow(1 + z,2));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D1SplitFn.h
@@ -0,0 +1,278 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3D1SplitFn_H
+#define Herwig_QtoQ3D1SplitFn_H
+//
+// This is the declaration of the QtoQ3D1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3D1SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3D_1)\f$.
+ *
+ * @see \ref QtoQ3D1SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3D1SplitFn.
+ */
+class QtoQ3D1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ3D1SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+3 + 30000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3D1SplitFn & operator=(const QtoQ3D1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQ3D1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.cc
@@ -0,0 +1,161 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3D2SplitFn class.
+//
+
+#include "QtoQ3D2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3D2SplitFn::pOver_ = 15.;
+
+IBPtr QtoQ3D2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3D2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3D2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3D2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3D2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,1,2);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3D2SplitFn,Sudakov1to2FormFactor>
+ describeHerwigQtoQ3D2SplitFn("Herwig::QtoQ3D2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3D2SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3D2SplitFn> documentation
+ ("The QtoQ3D2SplitFn class implements the branching q-> q 3D2");
+
+ static Reference<QtoQ3D2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3D2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3D2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3D2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3D2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3D2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3D2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3D2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3D2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 4./405.*aS2*O1_/m/sqr(m*m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3D2SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = 4.*z*(147 - 54*z + 117*sqr(z) - 84*pow(z,3) + 77*pow(z,4) - 22*pow(z,5) + 11*pow(z,6))/(3.*pow(1 + z,6));
+ double W1 = 8.*(61 - 621*z - 166*sqr(z) + 126*pow(z,3) + 9*pow(z,4) + 15*pow(z,5))/(3.*pow(1 + z,4));
+ double W2 = 256.*(-19 + 59*z + 66*sqr(z) - 23*pow(z,3) + 5*pow(z,4))/(3.*pow(1 + z,3));
+ double W3 =-256.*(-47 + 74*z + sqr(z))/(3.*(1 + z));
+ double W4 =-8192./3.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3D2SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3D2SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3D2SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.); Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r23 = sqrt(2./3.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin2)));
+ (*kernal)(0,0,0)=(8*r23*sqr(phase)*r*(8*sqr(r)*pow(1 + z,3) + z*(5 - 6*z + 3*sqr(z) - 2*pow(z,3)) - r*(5 + 17*z + 5*sqr(z) - 5*pow(z,3) + 2*pow(z,4))))/(sqr(1.-z)*rz*(1 + z));
+ (*kernal)(0,0,1)=(-2*r23*pT*phase*r*(5 + 6*z - 14*pow(z,3) + 3*pow(z,4) + 16*sqr(r)*pow(1 + z,3)*(3 + z) + 2*r*sqr(1.+z)*(-17 - 8*z + sqr(z))))/(m*rz*pow(-1 + sqr(z),2));
+ (*kernal)(0,0,2)=(-64*pow(r,3)*pow(1 + z,5) + 2*sqr(1.-z)*z*(5 - 2*z + sqr(z)) - 8*sqr(r)*pow(1 + z,3)*(-5 - 14*z + 7*sqr(z)) - 4*r*sqr(1.+z)*(1 + 13*z - 17*sqr(z) + 3*pow(z,3)))/(rz*pow(-1 + sqr(z),2));
+ (*kernal)(0,0,3)=(4*r23*pT*r*(8*sqr(r)*pow(1 + z,3)*(1 + 3*z) + r*sqr(1.+z)*(-3 - 32*z + 11*sqr(z)) + z*(9 - 5*z - 5*sqr(z) + pow(z,3))))/(m*phase*rz*pow(-1 + sqr(z),2));
+ (*kernal)(0,0,4)=(8*r23*r*rz*(8*sqr(r)*pow(1 + z,3) + z*(7 - 8*z + sqr(z)) + r*(-7 - 21*z - 5*sqr(z) + 9*pow(z,3))))/(sqr(phase)*sqr(1.-z)*(1 + z));
+ (*kernal)(0,1,0)=(-8*r23*pT*phase*r*(8*sqr(r)*pow(1 + z,3) + r*sqr(1.+z)*(-5 + 7*z) + z*(-3 + 2*z + sqr(z))))/(m*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(0,1,1)=(-2*r23*(48*pow(r,3)*pow(1 + z,5) + 2*sqr(1.-z)*z*(3 + sqr(z)) + r*pow(1 + z,3)*(5 - 22*z + 17*sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-17 - 2*z + 31*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(0,1,2)=(4*pT*r*(1 - 5*z + 3*sqr(z) + pow(z,3) + 16*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-5 + 7*z)))/(m*phase*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(0,1,3)=(4*r23*r*(8*sqr(r)*pow(1 + z,3) + z*(3 - 8*z + 5*sqr(z)) + r*(-3 - 9*z + 7*sqr(z) + 13*pow(z,3))))/(sqr(phase)*rz*(-1 + sqr(z)));
+ (*kernal)(0,1,4)=0;
+ (*kernal)(1,0,0)=0;
+ (*kernal)(1,0,1)=(-4*r23*sqr(phase)*r*(8*sqr(r)*pow(1 + z,3) + z*(3 - 8*z + 5*sqr(z)) + r*(-3 - 9*z + 7*sqr(z) + 13*pow(z,3))))/(rz*(-1 + sqr(z)));
+ (*kernal)(1,0,2)=(4*pT*phase*r*(1 - 5*z + 3*sqr(z) + pow(z,3) + 16*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-5 + 7*z)))/(m*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(1,0,3)=(2*r23*(48*pow(r,3)*pow(1 + z,5) + 2*sqr(1.-z)*z*(3 + sqr(z)) + r*pow(1 + z,3)*(5 - 22*z + 17*sqr(z)) + 2*sqr(r)*pow(1 + z,3)*(-17 - 2*z + 31*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(1,0,4)=(-8*r23*pT*r*(8*sqr(r)*pow(1 + z,3) + r*sqr(1.+z)*(-5 + 7*z) + z*(-3 + 2*z + sqr(z))))/(m*phase*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(1,1,0)=(-8*r23*sqr(phase)*r*rz*(8*sqr(r)*pow(1 + z,3) + z*(7 - 8*z + sqr(z)) + r*(-7 - 21*z - 5*sqr(z) + 9*pow(z,3))))/(sqr(1.-z)*(1 + z));
+ (*kernal)(1,1,1)=(4*r23*pT*phase*r*(8*sqr(r)*pow(1 + z,3)*(1 + 3*z) + r*sqr(1.+z)*(-3 - 32*z + 11*sqr(z)) + z*(9 - 5*z - 5*sqr(z) + pow(z,3))))/(m*rz*pow(-1 + sqr(z),2));
+ (*kernal)(1,1,2)=(64*pow(r,3)*pow(1 + z,5) - 2*sqr(1.-z)*z*(5 - 2*z + sqr(z)) + 8*sqr(r)*pow(1 + z,3)*(-5 - 14*z + 7*sqr(z)) + 4*r*sqr(1.+z)*(1 + 13*z - 17*sqr(z) + 3*pow(z,3)))/(rz*pow(-1 + sqr(z),2));
+ (*kernal)(1,1,3)=(-2*r23*pT*r*(5 + 6*z - 14*pow(z,3) + 3*pow(z,4) + 16*sqr(r)*pow(1 + z,3)*(3 + z) + 2*r*sqr(1.+z)*(-17 - 8*z + sqr(z))))/(m*phase*rz*pow(-1 + sqr(z),2));
+ (*kernal)(1,1,4)=(-8*r23*r*(8*sqr(r)*pow(1 + z,3) + z*(5 - 6*z + 3*sqr(z) - 2*pow(z,3)) - r*(5 + 17*z + 5*sqr(z) - 5*pow(z,3) + 2*pow(z,4))))/(sqr(phase)*sqr(1.-z)*rz*(1 + z));
+ return kernal;
+}
+
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D2SplitFn.h
@@ -0,0 +1,278 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3D2SplitFn_H
+#define Herwig_QtoQ3D2SplitFn_H
+//
+// This is the declaration of the QtoQ3D2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3D2SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3D_2)\f$.
+ *
+ * @see \ref QtoQ3D2SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3D2SplitFn.
+ */
+class QtoQ3D2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ3D2SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+5 + 20000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3D2SplitFn & operator=(const QtoQ3D2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQ3D2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.cc
@@ -0,0 +1,170 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3D3SplitFn class.
+//
+
+#include "QtoQ3D3SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3D3SplitFn::pOver_ = 10.;
+
+IBPtr QtoQ3D3SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3D3SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3D3SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3D3SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3D3SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,1,3);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3D3SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3D3SplitFn("Herwig::QtoQ3D3SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3D3SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3D3SplitFn> documentation
+ ("The QtoQ3D3SplitFn class implements the branching q-> q 3D3");
+
+ static Reference<QtoQ3D3SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3D3SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3D3SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3D3SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3D3SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3D3SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3D3SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3D3SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3D3SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 4./567.*aS2*O1_/m/sqr(m*m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3D3SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = 8.*z*(291 - 414*z + 477*sqr(z) - 324*pow(z,3) + 205*pow(z,4) - 62*pow(z,5) + 19*pow(z,6))/(15.*pow(1 + z,6));
+ double W1 = 128.*(7 - 183*z + 119*sqr(z) + 39*pow(z,3) - 90*pow(z,4) + 12*pow(z,5))/(15.*pow(1 + z,4));
+ double W2 = 128.*(-89 + 670*z + 240*sqr(z) - 514*pow(z,3) + 229*pow(z,4))/(15.*pow(1 + z,3));
+ double W3 = 512.*(97 - 286*z + 37*sqr(z))/(15.*(1 + z));
+ double W4 =-57344./15.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3D3SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3D3SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3D3SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.); Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r2=sqrt(2.), r3=sqrt(3.);
+ double r215 = sqrt(2./15.);
+ double r410= sqrt(0.4);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(GeneralDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin3)));
+ (*kernal)(0,0,0)=-32.*r2*pT*pow(phase,3)*sqr(r)*((-1 + z)*z + r*sqr(1.+z))/(m*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,1)=-16.*sqr(phase)*r*(8*sqr(r)*pow(1 + z,3)*(1 + 2*z) - sqr(1.-z)*z*(-2 - 5*z + sqr(z)) - r*(2 + 15*z + 18*sqr(z) - 16*pow(z,3) - 20*pow(z,4) + pow(z,5)))/(r3*pow(-1 + z,3)*rz*(1 + z));
+ (*kernal)(0,0,2)=(8*r215*pT*phase*r*(sqr(1.-z)*(1 + 10*z + sqr(z)) + 4*sqr(r)*pow(1 + z,3)*(6 + 23*z + sqr(z)) - 4*r*sqr(1.+z)*(2 + 12*z - 15*sqr(z) + pow(z,3))))/(m*pow(-1 + z,3)*rz*sqr(1.+z));
+ (*kernal)(0,0,3)=(2*r410*(48*r*sqr(1.-z)*z*pow(1 + z,3) + 32*pow(r,3)*pow(1 + z,5)*(1 + 8*z + sqr(z)) - pow(-1 + z,3)*z*(-7 + 3*z - 5*sqr(z) + pow(z,3)) + 8*sqr(r)*pow(1 + z,3)*(-1 - 23*z - 9*sqr(z) + 31*pow(z,3) + 2*pow(z,4))))/(rz*pow(-1 + sqr(z),3));
+ (*kernal)(0,0,4)=(-8*r215*pT*r*(sqr(1.-z)*z*(9 + 2*z + sqr(z)) + 4*r*z*sqr(1.+z)*(-13 + 11*z + 2*sqr(z)) + 4*sqr(r)*pow(1 + z,3)*(1 + 23*z + 6*sqr(z))))/(m*phase*pow(-1 + z,3)*rz*sqr(1.+z));
+ (*kernal)(0,0,5)=(-16*r*rz*(8*sqr(r)*pow(1 + z,3)*(2 + z) + sqr(1.-z)*z*(5 + z) + r*(-5 - 22*z - 4*sqr(z) + 22*pow(z,3) + 9*pow(z,4))))/(r3*sqr(phase)*pow(-1 + z,3)*(1 + z));
+ (*kernal)(0,0,6)=(32*r2*pT*sqr(r)*rz*((-1 + z)*z + r*sqr(1.+z)))/(m*pow(phase,3)*pow(-1 + z,3));
+ (*kernal)(0,1,0)=(32*r2*sqr(phase)*r*((-1 + z)*sqr(z) + 2*r*sqr(z)*(1 + z) + sqr(r)*pow(1 + z,3)))/(rz*(-1 + sqr(z)));
+ (*kernal)(0,1,1)=(-16*pT*phase*r*(8*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-1 + 5*z) + z*(-3 + 2*z + sqr(z))))/(r3*m*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(0,1,2)=(-8*r215*(24*pow(r,3)*pow(1 + z,5) + sqr(1.-z)*z*(3 + sqr(z)) + 8*sqr(r)*pow(1 + z,3)*(-1 + 2*z + 5*sqr(z)) + r*pow(1 + z,3)*(1 - 14*z + 13*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(0,1,3)=(8*r410*pT*r*(8*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-1 + 5*z) + z*(-3 + 2*z + sqr(z))))/(m*phase*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(0,1,4)=(32*r215*r*((-1 + z)*sqr(z) + 2*r*sqr(z)*(1 + z) + sqr(r)*pow(1 + z,3)))/(sqr(phase)*rz*(-1 + sqr(z)));
+ (*kernal)(0,1,5)=0;
+ (*kernal)(0,1,6)=0;
+ (*kernal)(1,0,0)=0;
+ (*kernal)(1,0,1)=0;
+ (*kernal)(1,0,2)=(32*r215*sqr(phase)*r*((-1 + z)*sqr(z) + 2*r*sqr(z)*(1 + z) + sqr(r)*pow(1 + z,3)))/(rz*(-1 + sqr(z)));
+ (*kernal)(1,0,3)=(-8*r410*pT*phase*r*(8*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-1 + 5*z) + z*(-3 + 2*z + sqr(z))))/(m*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(1,0,4)=(-8*r215*(24*pow(r,3)*pow(1 + z,5) + sqr(1.-z)*z*(3 + sqr(z)) + 8*sqr(r)*pow(1 + z,3)*(-1 + 2*z + 5*sqr(z)) + r*pow(1 + z,3)*(1 - 14*z + 13*sqr(z))))/((-1 + z)*rz*pow(1 + z,3));
+ (*kernal)(1,0,5)=(16*pT*r*(8*sqr(r)*pow(1 + z,3) + 2*r*sqr(1.+z)*(-1 + 5*z) + z*(-3 + 2*z + sqr(z))))/(r3*m*phase*(-1 + z)*rz*sqr(1.+z));
+ (*kernal)(1,0,6)=(32*r2*r*((-1 + z)*sqr(z) + 2*r*sqr(z)*(1 + z) + sqr(r)*pow(1 + z,3)))/(sqr(phase)*rz*(-1 + sqr(z)));
+ (*kernal)(1,1,0)=-32.*r2*pT*pow(phase,3)*sqr(r)*rz*((-1 + z)*z + r*sqr(1.+z))/(m*pow(-1 + z,3));
+ (*kernal)(1,1,1)=-16.*sqr(phase)*r*rz*(8*sqr(r)*pow(1 + z,3)*(2 + z) + sqr(1.-z)*z*(5 + z) + r*(-5 - 22*z - 4*sqr(z) + 22*pow(z,3) + 9*pow(z,4)))/(r3*pow(-1 + z,3)*(1 + z));
+ (*kernal)(1,1,2)=(8*r215*pT*phase*r*(sqr(1.-z)*z*(9 + 2*z + sqr(z)) + 4*r*z*sqr(1.+z)*(-13 + 11*z + 2*sqr(z)) + 4*sqr(r)*pow(1 + z,3)*(1 + 23*z + 6*sqr(z))))/(m*pow(-1 + z,3)*rz*sqr(1.+z));
+ (*kernal)(1,1,3)=(2*r410*(48*r*sqr(1.-z)*z*pow(1 + z,3) + 32*pow(r,3)*pow(1 + z,5)*(1 + 8*z + sqr(z)) - pow(-1 + z,3)*z*(-7 + 3*z - 5*sqr(z) + pow(z,3)) + 8*sqr(r)*pow(1 + z,3)*(-1 - 23*z - 9*sqr(z) + 31*pow(z,3) + 2*pow(z,4))))/(rz*pow(-1 + sqr(z),3));
+ (*kernal)(1,1,4)=(-8*r215*pT*r*(sqr(1.-z)*(1 + 10*z + sqr(z)) + 4*sqr(r)*pow(1 + z,3)*(6 + 23*z + sqr(z)) - 4*r*sqr(1.+z)*(2 + 12*z - 15*sqr(z) + pow(z,3))))/(m*phase*pow(-1 + z,3)*rz*sqr(1.+z));
+ (*kernal)(1,1,5)=(-16*r*(8*sqr(r)*pow(1 + z,3)*(1 + 2*z) - sqr(1.-z)*z*(-2 - 5*z + sqr(z)) - r*(2 + 15*z + 18*sqr(z) - 16*pow(z,3) - 20*pow(z,4) + pow(z,5))))/(r3*sqr(phase)*pow(-1 + z,3)*rz*(1 + z));
+ (*kernal)(1,1,6)=(32*r2*pT*sqr(r)*((-1 + z)*z + r*sqr(1.+z)))/(m*pow(phase,3)*pow(-1 + z,3)*rz);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3D3SplitFn.h
@@ -0,0 +1,278 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3D3SplitFn_H
+#define Herwig_QtoQ3D3SplitFn_H
+//
+// This is the declaration of the QtoQ3D3SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/GeneralDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3D3SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3D_3)\f$.
+ *
+ * @see \ref QtoQ3D3SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3D3SplitFn.
+ */
+class QtoQ3D3SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ3D3SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110 + 7 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3D3SplitFn & operator=(const QtoQ3D3SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQ3D3SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.cc
@@ -0,0 +1,144 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3P0SplitFn class.
+//
+
+#include "QtoQ3P0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3P0SplitFn::pOver_ = 2.;
+
+IBPtr QtoQ3P0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3P0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3P0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3P0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3P0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,0);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3P0SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3P0SplitFn("Herwig::QtoQ3P0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3P0SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3P0SplitFn> documentation
+ ("The QtoQ3P0SplitFn class implements the branching q-> q 3P0");
+
+ static Reference<QtoQ3P0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3P0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3P0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3P0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3P0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3P0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3P0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3P0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3P0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 64./81.*aS2*O1_/m/sqr(m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3P0SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = z*sqr(5.-2.*z+sqr(z))/(12.*pow(1+z,4));
+ double W1 = 2.*(33.-12.*z-7.*sqr(z)-2.*pow(z,3))/(3.*sqr(1+z));
+ double W2 = 4.*(-23.+3.*z+2.*sqr(z))/(3.*(1.+z));
+ double W3 = 32./3.;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ // cerr << "testing values " << " " << z << " " << W0 << " " << W1 << " " << W2 << " " << W3 << "\n";
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3P0SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3P0SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3P0SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ // calculate the kernal N.B. prefactor 1./sqrt(3.)/sqrt(z) removed
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin0)));
+ (*kernal)(0,0,0) = 0.5*z*(z*(z-2.)+5.)/sqr(1.+z)+6.*r-4.*sqr(r)*(1.+z);
+ (*kernal)(1,1,0) = (*kernal)(0,0,0);
+ (*kernal)(0,1,0) = 2.*double(pT/m)*r/phase*((z+3.)/(1.+z)-2.*r);
+ (*kernal)(1,0,0) = -conj((*kernal)(0,1,0));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P0SplitFn.h
@@ -0,0 +1,282 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3P0SplitFn_H
+#define Herwig_QtoQ3P0SplitFn_H
+//
+// This is the declaration of the QtoQ3P0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3P0SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3P_0)\f$
+ *
+ * @see \ref QtoQ3P0SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3P0SplitFn.
+ */
+class QtoQ3P0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQ3P0SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+ //@}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+1 + 10000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3P0SplitFn & operator=(const QtoQ3P0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ3P0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.cc
@@ -0,0 +1,180 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3P1SplitFn class.
+//
+
+#include "QtoQ3P1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3P1SplitFn::pOver_ = 1.5;
+
+IBPtr QtoQ3P1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3P1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3P1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3P1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3P1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3P1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3P1SplitFn("Herwig::QtoQ3P1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3P1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3P1SplitFn> documentation
+ ("The QtoQ3P1SplitFn class implements the branching q-> q 3P1");
+
+ static Parameter<QtoQ3P1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3P1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Reference<QtoQ3P1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3P1SplitFn::params_, false, false, true, false, false);
+
+ static Switch<QtoQ3P1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3P1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3P1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3P1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+}
+
+void QtoQ3P1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 64./243.*aS2*O1_/m/sqr(m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3P1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0= 0.5*z*(17.-4.*z+6.*sqr(z)-4.*pow(z,3)+pow(z,4))/pow(1.+z,4);
+ double W1 = (17.-55.*z+7.*sqr(z)-pow(z,3))/sqr(1.+z);
+ double W2 =-4./(1.+z)*(12.-13.*z-sqr(z));
+ double W3 = 32.;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3P1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3P1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3P1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ double rz = sqrt(z), r2 = sqrt(2.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+
+ (*kernal)(0,0,0) = ii*phase*pT/m/rz*r/(1.-z)*(4.*r-(3.+sqr(z))/(1.+z));
+ (*kernal)(0,0,1) =-ii/rz/r2*((-3.+z)*z/(1.+z) - 4.*sqr(r)*sqr(1.+z)/(1.-z) + 2.*r*(1.+4.*z-sqr(z))/(1.-z));
+ (*kernal)(0,0,2) =-4.*ii*pT/m*r*rz/phase/(1.-z)*(r-1./(1.+z));
+ (*kernal)(0,1,0) = ii/rz*(3.*r*(1.-z)+2.*(1.-z)*z/sqr(1.+z)-4.*sqr(r)*(1.+z));
+ (*kernal)(0,1,1) = ii*r2*pT/m/rz/phase*r*(2.*r-(1.-z)/(1.+z));
+ (*kernal)(0,1,2) = 0;
+ (*kernal)(1,0,0) = 0;
+ (*kernal)(1,0,1) = ii*r2*pT/m/rz*phase*r*(2.*r-(1.-z)/(1.+z));
+ (*kernal)(1,0,2) =-ii/rz*(3.*r*(1.-z)+2.*(1.-z)*z/sqr(1.+z)-4.*sqr(r)*(1.+z));
+ (*kernal)(1,1,0) =-4.*ii*phase*pT/m*r*rz/(1.-z)*(r-1./(1.+z));
+ (*kernal)(1,1,1) = ii/rz/r2*((-3.+z)*z/(1.+z) -4.*sqr(r)*sqr(1.+z)/(1.-z) + 2.*r*(1.+4*z-sqr(z))/(1.-z));
+ (*kernal)(1,1,2) = ii/phase*pT/m/rz*r/(1.-z)*(4.*r-(3.+sqr(z))/(1.+z));
+
+
+
+ // // testing code
+ // DecayMEPtr test(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ // (*test)(0,0,0) =(Complex(0,4)*phase*pT*pow(r,2))/(sqrt(z)*(m - m*z)) + (Complex(0,1)*phase*pT*r*(3 + pow(z,2)))/(m*(-1 + z)*sqrt(z)*(1 + z));
+ // (*test)(0,0,1) =(Complex(0,-1)*(-3 + z)*sqrt(z))/(sqrt(2)*(1 + z)) - (Complex(0,2)*sqrt(2)*pow(r,2)*pow(1 + z,2))/((-1 + z)*sqrt(z)) - (Complex(0,1)*sqrt(2)*r*(-1 - 4*z + pow(z,2)))/((-1 + z)*sqrt(z));
+ // (*test)(0,0,2) =(Complex(0,4)*pT*pow(r,2)*sqrt(z))/(phase*m*(-1 + z)) + (Complex(0,4)*pT*r*sqrt(z))/(phase*(m - m*pow(z,2)));
+ // (*test)(0,1,0) =(Complex(0,-3)*r*(-1 + z))/sqrt(z) - (Complex(0,2)*(-1 + z)*sqrt(z))/pow(1 + z,2) - (Complex(0,4)*pow(r,2)*(1 + z))/sqrt(z);
+ // (*test)(0,1,1) =(Complex(0,2)*sqrt(2)*pT*pow(r,2))/(phase*m*sqrt(z)) + (Complex(0,1)*sqrt(2)*pT*r*(-1 + z))/(phase*m*sqrt(z)*(1 + z));
+ // (*test)(0,1,2) =0;
+ // (*test)(1,0,0) =0;
+ // (*test)(1,0,1) =(Complex(0,2)*sqrt(2)*phase*pT*pow(r,2))/(m*sqrt(z)) + (Complex(0,1)*sqrt(2)*phase*pT*r*(-1 + z))/(m*sqrt(z)*(1 + z));
+ // (*test)(1,0,2) =(Complex(0,3)*r*(-1 + z))/sqrt(z) + (Complex(0,2)*(-1 + z)*sqrt(z))/pow(1 + z,2) + (Complex(0,4)*pow(r,2)*(1 + z))/sqrt(z);
+ // (*test)(1,1,0) =(Complex(0,4)*phase*pT*pow(r,2)*sqrt(z))/(m*(-1 + z)) + (Complex(0,4)*phase*pT*r*sqrt(z))/(m - m*pow(z,2));
+ // (*test)(1,1,1) =(Complex(0,1)*(-3 + z)*sqrt(z))/(sqrt(2)*(1 + z)) + (Complex(0,2)*sqrt(2)*pow(r,2)*pow(1 + z,2))/((-1 + z)*sqrt(z)) + (Complex(0,1)*sqrt(2)*r*(-1 - 4*z + pow(z,2)))/((-1 + z)*sqrt(z));
+ // (*test)(1,1,2) =(Complex(0,4)*pT*pow(r,2))/(phase*sqrt(z)*(m - m*z)) + (Complex(0,1)*pT*r*(3 + pow(z,2)))/(phase*m*(-1 + z)*sqrt(z)*(1 + z));
+
+
+ // cerr << "testing in kernal " << " " << z << " " << r << " " << pT/m << " " << phi << "\n";
+ // for(unsigned int ih1=0;ih1<2;++ih1) {
+ // for(unsigned int ih2=0;ih2<2;++ih2) {
+ // for(unsigned int ih3=0;ih3<3;++ih3) {
+ // cerr << ih1 << " " << ih2 << " " << ih3 << " " << (*kernal)(ih1,ih2,ih3) << "\n";
+ // cerr << "testing diff " << abs((*kernal)(ih1,ih2,ih3)-(*test)(ih1,ih2,ih3)) << "\n";
+ // }
+ // }
+ // }
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P1SplitFn.h
@@ -0,0 +1,283 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3P1SplitFn_H
+#define Herwig_QtoQ3P1SplitFn_H
+//
+// This is the declaration of the QtoQ3P1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3P1SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q}(P_1)'\f$,
+ * in this case there is mixing between the $\phanton{A}^1P_1$ and $\phanton{A}^3P_1$ states
+ *
+ * @see \ref QtoQ3P1SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3P1SplitFn.
+ */
+class QtoQ3P1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQ3P1SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+ //@}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+3 + 20000 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3P1SplitFn & operator=(const QtoQ3P1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ3P1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.cc
@@ -0,0 +1,163 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3P2SplitFn class.
+//
+
+#include "QtoQ3P2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3P2SplitFn::pOver_ = 1.;
+
+IBPtr QtoQ3P2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3P2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3P2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQ3P2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3P2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,2);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3P2SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3P2SplitFn("Herwig::QtoQ3P2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3P2SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3P2SplitFn> documentation
+ ("The QtoQ3P2SplitFn class implements the branching q-> q 3P2");
+
+ static Reference<QtoQ3P2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3P2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3P2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3P2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3P2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3P2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3P2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3P2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3P2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy m = ids[0]->mass();
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 64./405.*aS2*O1_/m/sqr(m);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3P2SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = z*(49.-68.*z+38.*sqr(z)-4.*z*sqr(z)+pow(z,4))/(6.*pow(1.+z,4));
+ double W1 = (15.-165.*z+161.*sqr(z)-59.*z*sqr(z))/(3.*sqr(1.+z));
+ double W2 = -4.*(28.-81.*z+11.*sqr(z))/(3.*(1.+z));
+ double W3 = 160./3.;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3P2SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3P2SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3P2SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double rz=sqrt(z);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin2)));
+ (*kernal)(0,0,0) = -ii*sqr(phase)*4.*r/rz/(1.-z)*(r*sqr(1.+z)/(1.-z)-z);
+ (*kernal)(0,0,1) = ii*phase*double(pT/m)*r/rz/(1.-z)*(-(1.+4.*z-sqr(z))/(1.+z)
+ + 4.*r*(1+3.*z)/(1.-z));
+ (*kernal)(0,0,2) = ii/sqrt(6.)/rz*(z*(5.-2.*z+sqr(z))/sqr(1.+z)-24.*z*r/(1.-z)
+ + sqr(r)*4.*(1+11.*z+11.*sqr(z)+pow(z,3))/sqr(1.-z));
+ (*kernal)(0,0,3) = ii/phase*double(pT/m)*r*rz*4./(1.-z)*(1./(1.+z)-r*(3.+z)/(1.-z));
+ (*kernal)(0,0,4) =-ii/sqr(phase)*4.*r/(1.-z)*rz*(r*sqr(1.+z)/(1.-z)-z);
+ (*kernal)(0,1,0) =-ii*phase*double(pT/m)/rz*4.*r*(z/(1.+z)+r);
+ (*kernal)(0,1,1) = ii/rz*(2.*(1.-z)*z/sqr(1.+z)+r*(1-5.*z)-4.*sqr(r)*(1.+z));
+ (*kernal)(0,1,2) = ii*double(pT/m)/sqrt(6.)/phase*4.*r/rz*(r+z/(1.+z));
+ (*kernal)(0,1,3) = 0.;
+ (*kernal)(0,1,4) = 0.;
+ (*kernal)(1,0,0) = 0.;
+ (*kernal)(1,0,1) = 0.;
+ (*kernal)(1,0,2) =-ii*double(pT/m)/sqrt(6.)*phase*4.*r/rz*(r+z/(1.+z));
+ (*kernal)(1,0,3) =+ii/rz*(2.*(1.-z)*z/sqr(1.+z)+r*(1.-5.*z)-4.*sqr(r)*(1.+z));
+ (*kernal)(1,0,4) = ii/phase*double(pT/m)/rz*4.*r*(z/(1.+z)+r);
+ (*kernal)(1,1,0) =-ii*sqr(phase)*4.*r/(1.-z)*rz*(r*sqr(1.+z)/(1.-z)-z);
+ (*kernal)(1,1,1) = ii*phase*double(pT/m)*4.*r*rz/(1.-z)*(-1./(1.+z) + r*(3.+z)/(1.-z));
+ (*kernal)(1,1,2) = ii/sqrt(6.)/rz* (z*(5.-2.*z+sqr(z))/sqr(1.+z) -24.*r*z/(1.-z)
+ +4.*sqr(r)*(1.+11.*z+11.*sqr(z)+pow(z,3))/sqr(1.-z));
+ (*kernal)(1,1,3) = -ii/phase*double(pT/m)*r/rz/(1.-z)*(-(1.+4.*z-sqr(z))/(1.+z)+4.*r*(1.+3*z)/(1.-z));
+ (*kernal)(1,1,4) =-ii/sqr(phase)*4.*r/rz/(1.-z)*(r*sqr(1.+z)/(1.-z)-z);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3P2SplitFn.h
@@ -0,0 +1,282 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3P2SplitFn_H
+#define Herwig_QtoQ3P2SplitFn_H
+//
+// This is the declaration of the QtoQ3P2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3P2SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3P_2)\f$
+ *
+ * @see \ref QtoQ3P2SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3P2SplitFn.
+ */
+class QtoQ3P2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQ3P2SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+ //@}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+5 + (n_-1)*100000;
+ if(ids[2]->id() != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3P2SplitFn & operator=(const QtoQ3P2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ3P2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.cc
@@ -0,0 +1,155 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQ3S1SplitFn class.
+//
+
+#include "QtoQ3S1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQ3S1SplitFn::pOver_ = 3.;
+
+IBPtr QtoQ3S1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQ3S1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQ3S1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+
+}
+
+void QtoQ3S1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQ3S1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,1,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQ3S1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQ3S1SplitFn("Herwig::QtoQ3S1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQ3S1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQ3S1SplitFn> documentation
+ ("The QtoQ3S1SplitFn class implements the branching q-> q 3S1");
+
+ static Reference<QtoQ3S1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQ3S1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQ3S1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQ3S1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQ3S1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQ3S1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+
+ static Parameter<QtoQ3S1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQ3S1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQ3S1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./243.*aS2 * O1_ / M / sqr(a2);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQ3S1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = z*(17.-22.*z+9.*sqr(z))/sqr(1.+z);
+ double W1 = 8*(3.-8.*z+sqr(z))/(1+z);
+ double W2 = -48.;
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQ3S1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQ3S1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQ3S1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double rz=sqrt(z);
+ double r2=sqrt(2.);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0) = -2.*r2*phase*double(pT/m)*r/((1.-z)*rz);
+ (*kernal)(0,0,1) = rz*((3.-z)/(1.+z)-8.*r/(1.-z));
+ (*kernal)(0,0,2) = 2.*r2*double(pT/m)*r*rz/(phase*(1.-z));
+ (*kernal)(0,1,0) = 2.*r2*(1.-z)/(1.+z)*(z + r*(1.+z))/rz;
+ (*kernal)(0,1,1) = 0.;
+ (*kernal)(0,1,2) = 0.;
+ (*kernal)(1,0,0) = 0.;
+ (*kernal)(1,0,1) = 0.;
+ (*kernal)(1,0,2) = 2.*r2*(1.-z)/(1.+z)*(z + r*(1.+z))/rz;
+ (*kernal)(1,1,0) = -2.*r2*r*phase*double(pT/m)*rz/(1.-z);
+ (*kernal)(1,1,1) = rz*((3.-z)/(1.+z)-8.*r/(1.-z));
+ (*kernal)(1,1,2) = 4.*r*r2*0.5*double(pT/m)/(phase*(1.-z)*rz);
+ return kernal;
+}
+
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQ3S1SplitFn.h
@@ -0,0 +1,281 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQ3S1SplitFn_H
+#define Herwig_QtoQ3S1SplitFn_H
+//
+// This is the declaration of the QtoQ3S1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQ3S1SplitFn class implements the splitting function for \f$q\to q M_q\bar{q}(^3S_1)\f$
+ *
+ * @see \ref QtoQ3S1SplitFnInterfaces "The interfaces"
+ * defined for QtoQ3S1SplitFn.
+ */
+class QtoQ3S1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQ3S1SplitFn() : O1_(0.573*GeV*GeV2), state_(ccbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // incoming and quark quark the same
+ if(ids[0]!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=4+state_) return false;
+ // construct the meson PDG code from quark ids and check it
+ long idtest = ids[0]->id()*110+3 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQ3S1SplitFn & operator=(const QtoQ3S1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQ3S1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.cc
@@ -0,0 +1,154 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQBarQQ1SplitFn class.
+//
+
+#include "QtoQBarQQ1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQBarQQ1SplitFn::pOver_ = 3.;
+
+IBPtr QtoQBarQQ1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQBarQQ1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQBarQQ1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(R02_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQBarQQ1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(R02_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQBarQQ1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ R02_ = params_->radialWaveFunctionSquared(state_,n_);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQBarQQ1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQBarQQ1SplitFn("Herwig::QtoQBarQQ1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQBarQQ1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQBarQQ1SplitFn> documentation
+ ("The QtoQBarQQ1SplitFn class implements the branching q-> qbar qq_1");
+
+ static Reference<QtoQBarQQ1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQBarQQ1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQBarQQ1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQBarQQ1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQBarQQ1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQBarQQ1SplitFn::state_, cc, false, false);
+ static SwitchOption interfaceStatecc
+ (interfaceState,
+ "cc",
+ "cc diquark",
+ cc);
+ static SwitchOption interfaceStatebb
+ (interfaceState,
+ "bb",
+ "bb diquark",
+ bb);
+
+ static Parameter<QtoQBarQQ1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQBarQQ1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQBarQQ1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 2./9.*aS2*R02_/sqr(a2)/M/Constants::pi;
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQBarQQ1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double W0 = z*(17.-22.*z+9.*sqr(z))/sqr(1.+z);
+ double W1 = 8*(3.-8.*z+sqr(z))/(1+z);
+ double W2 = -48.;
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQBarQQ1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQBarQQ1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQBarQQ1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m = ids[0]->mass();
+ double r = sqr(m)/t;
+ double rz=sqrt(z);
+ double r2=sqrt(2.);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t-sqr(m*(1.+z)));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,1,0) = -2.*r2*phase*double(pT/m)*r/((1.-z)*rz);
+ (*kernal)(0,1,1) = rz*((3.-z)/(1.+z)-8.*r/(1.-z));
+ (*kernal)(0,1,2) = 2.*r2*double(pT/m)*r*rz/(phase*(1.-z));
+ (*kernal)(0,0,0) = 2.*r2*(1.-z)/(1.+z)*(z + r*(1.+z))/rz;
+ (*kernal)(0,0,1) = 0.;
+ (*kernal)(0,0,2) = 0.;
+ (*kernal)(1,1,0) = 0.;
+ (*kernal)(1,1,1) = 0.;
+ (*kernal)(1,1,2) = 2.*r2*(1.-z)/(1.+z)*(z + r*(1.+z))/rz;
+ (*kernal)(1,0,0) = -2.*r2*r*phase*double(pT/m)*rz/(1.-z);
+ (*kernal)(1,0,1) = rz*((3.-z)/(1.+z)-8.*r/(1.-z));
+ (*kernal)(1,0,2) = 4.*r*r2*0.5*double(pT/m)/(phase*(1.-z)*rz);
+ return kernal;
+}
+
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQBarQQ1SplitFn.h
@@ -0,0 +1,284 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQBarQQ1SplitFn_H
+#define Herwig_QtoQBarQQ1SplitFn_H
+//
+// This is the declaration of the QtoQBarQQ1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQBarQQ1SplitFn class implements the splitting function for \f$q\to \bar{q} {qq}_1\f$
+ *
+ * @see \ref QtoQBarQQ1SplitFnInterfaces "The interfaces"
+ * defined for QtoQBarQQ1SplitFn.
+ */
+class QtoQBarQQ1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQBarQQ1SplitFn() : R02_(pow<3,1>(0.41*GeV)), state_(cc), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // check q and qbar
+ if(ids[0]->CC()!=ids[1]) return false;
+ // quark matches state specified
+ if(ids[0]->id()!=1+state_) return false;
+ // construct the diquark PDG code from quark ids and check it
+ long idtest = ids[0]->id()*1100+3 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQBarQQ1SplitFn & operator=(const QtoQBarQQ1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 R02_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQBarQQ1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.cc
@@ -0,0 +1,153 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP1S0SplitFn class.
+//
+
+#include "QtoQP1S0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP1S0SplitFn::pOver_ = 3.;
+
+IBPtr QtoQP1S0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP1S0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP1S0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP1S0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP1S0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,0,0);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP1S0SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP1S0SplitFn("Herwig::QtoQP1S0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP1S0SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP1S0SplitFn> documentation
+ ("The QtoQP1S0SplitFn class implements the branching q-> q' 1S0");
+
+ static Reference<QtoQP1S0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP1S0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP1S0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP1S0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP1S0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP1S0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP1S0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP1S0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP1S0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./81.*aS2 * O1_ / M / sqr(a2);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP1S0SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = sqr(1.+(1.-a1)*(1.-z))*z/sqr(1.-a1*(1.-z));
+ double W1 = (-2.*sqr(a1*z)+2.*sqr(a1)+a1*sqr(z)+2.*a1*z-7.*a1-3.*z+5)/(1.-a1*(1.-z));
+ double W2 = -4.*a1*(1.-a1);
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP1S0SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP1S0SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP1S0SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ double rz=sqrt(z);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin0)));
+ (*kernal)(0,0,0) = -(1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z)) - r*(1.-a1-a1*z)/rz;
+ (*kernal)(1,1,0) = -(*kernal)(0,0,0);
+ (*kernal)(0,1,0) = -double(pT/M)*r/rz/phase;
+ (*kernal)(1,0,0) = conj((*kernal)(0,1,0));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP1S0SplitFn.h
@@ -0,0 +1,287 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP1S0SplitFn_H
+#define Herwig_QtoQP1S0SplitFn_H
+//
+// This is the declaration of the QtoQP1S0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP1S0SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^1S_0)\f$
+ *
+ * @see \ref QtoQP1S0SplitFnInterfaces "The interfaces"
+ * defined for QtoQP1S0SplitFn.
+ */
+class QtoQP1S0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQP1S0SplitFn() : O1_(0.573*GeV*GeV2), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+1 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP1S0SplitFn & operator=(const QtoQP1S0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQP1S0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.cc
@@ -0,0 +1,177 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP3D1SplitFn class.
+//
+
+#include "QtoQP3D1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP3D1SplitFn::pOver_ = 25.;
+
+IBPtr QtoQP3D1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP3D1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP3D1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP3D1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP3D1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,1,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP3D1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP3D1SplitFn("Herwig::QtoQP3D1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP3D1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP3D1SplitFn> documentation
+ ("The QtoQP3D1SplitFn class implements the branching q-> q' 3D1");
+
+ static Reference<QtoQP3D1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP3D1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP3D1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP3D1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP3D1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP3D1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP3D1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP3D1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP3D1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./243.*aS2*O1_/pow(a2,4)/M/sqr(M*M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP3D1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ // coefficients
+ double W0 = z*(32*pow(a1,8)*pow(-1 + z,6) - 16*pow(a1,7)*pow(-1 + z,5)*(-19 + 7*z) +
+ 2*pow(a1,6)*pow(-1 + z,4)*(641 + z*(-498 + 97*z)) - 4*pow(a1,5)*pow(-1 + z,3)*(-777 + z*(912 + z*(-337 + 42*z))) +
+ 2*pow(a1,4)*pow(-1 + z,2)*(2361 + z*(-3644 + z*(1915 - 422*z + 30*pow(z,2)))) -
+ 4*pow(a1,3)*(-2 + z)*(-1 + z)*(575 + z*(-807 + z*(343 + z*(-65 + 2*z)))) + 25*(6 + z*(-8 + z*(11 + z*(-10 + 3*z)))) +
+ 10*a1*(-98 + z*(172 + z*(-151 + z*(103 + z*(-37 + 3*z))))) + pow(a1,2)*(2806 + z*(-6432 + z*(5701 + z*(-2756 + z*(814 + z*(-104 + 3*z)))))))/
+ (120.*pow(-1 + a1,2)*pow(a1,2)*pow(1 + a1*(-1 + z),6));
+ double W1 = (-64*pow(a1,7)*(-2 + z)*pow(-1 + z,4) + 16*pow(a1,6)*pow(-1 + z,3)*(9 + z + 6*pow(z,2)) - 25*(-51 + z*(115 + 2*z*(-31 + 9*z))) +
+ 4*pow(a1,5)*pow(-1 + z,2)*(-531 + z*(1201 + z*(-633 + 59*z))) - 20*a1*(326 + z*(-836 + z*(634 + z*(-193 + 21*z)))) -
+ pow(a1,4)*(-1 + z)*(8651 + z*(-23336 + z*(20078 + z*(-6224 + 575*z)))) +
+ 2*pow(a1,2)*(6849 + z*(-19877 + z*(19126 + z*(-7502 - 57*(-21 + z)*z)))) +
+ 4*pow(a1,3)*(-3741 + z*(12251 + z*(-14204 + z*(7076 + z*(-1471 + 105*z))))))/(120.*pow(-1 + a1,2)*pow(a1,2)*pow(1 + a1*(-1 + z),4));
+ double W2 =(-741 - 45/(-1 + a1) + 2*a1*(675 + 4*a1*(-169 + 88*a1)) + (192*pow(-1 + a1,2))/pow(1 + a1*(-1 + z),3) -
+ (72*(-1 + a1)*(-29 + 4*a1))/pow(1 + a1*(-1 + z),2) + (24*(108 + a1*(-121 + 28*a1)))/(1 + a1*(-1 + z)) +
+ (a1*(333 + 2*a1*(-357 + 20*a1*(7 + 2*a1)))*z)/(-1 + a1))/(60.*pow(a1,3));
+ double W3 =4*(30 + a1*(149 - 183*z + a1*(-235 + 8*a1*(-7 + z)*(-1 + z) + 11*(20 - 3*z)*z)))/(15.*a1*(1 + a1*(-1 + z)));
+ double W4 =-128*(1.-a1)*a1/5.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP3D1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP3D1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP3D1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ double rz = sqrt(z);
+ double r15 = sqrt(15.);
+ double r30= sqrt(30.);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0)=(pT*phase*r*(-48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)) + (r*(-15 + a1*(-29 + 4*a1*(15 + 4*a1*(-1 + z) - 13*z) + 33*z)))/(-1 + a1) + (8*pow(a1,3)*(-2 + z)*sqr(1.-z) + 5*(5 + 3*(-2 + z)*z) - sqr(a1)*(-1 + z)*(57 + z*(-58 + 17*z)) + a1*(-66 + z*(105 + z*(-56 + 9*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),2))))/(2.*r30*a1*M*(-1 + z)*rz);
+ (*kernal)(0,0,1)=((-48*sqr(a1)*pow(r,3)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (r*(15 - 29*a1 - 8*pow(a1,3)*sqr(1.-z) + a1*(38 - 17*z)*z + 5*(-2 + z)*z + 2*sqr(a1)*(-1 + z)*(-11 + 9*z)))/((-1 + a1)*(-1 + z)) + (z*(5 - 4*pow(a1,4)*pow(-1 + z,3) - 5*(-1 + z)*z + pow(a1,3)*sqr(1.-z)*(-19 + 7*z) - a1*(3 + z)*(7 + (-7 + z)*z) - sqr(a1)*(-1 + z)*(31 + z*(-21 + 2*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),3)) + (sqr(r)*(-15 + a1*(-6 + 10*z + a1*(65 - 52*a1*sqr(1.-z) + 8*sqr(a1)*sqr(1.-z) + z*(-98 + 41*z)))))/((-1 + a1)*(-1 + z)))/(2.*r15*a1*rz);
+ (*kernal)(0,0,2)=(pT*r*(48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)) + (z*(-5*(1 + z) + a1*(21 - 8*a1*(-3 + z)*(-1 + z) + 8*sqr(a1)*sqr(1.-z) + (-14 + z)*z)))/((-1 + a1)*pow(1 + a1*(-1 + z),2)) + (r*(15 + a1*(13 - 17*z + 4*a1*(-11 - 4*a1*(-1 + z) + 9*z))))/(-1 + a1)))/(2.*r30*a1*M*phase*(-1 + z)*rz);
+ (*kernal)(0,1,0)=((48*sqr(a1)*pow(r,3)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (r*(-5*(-5 + z) + a1*(-41 + 16*a1 + 9*z)))/(-1 + a1) + ((-1 + z)*z*(5*(-2 + z) + a1*(28 + 8*sqr(a1)*sqr(1.-z) + (-23 + z)*z - 2*a1*(-1 + z)*(-13 + 4*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),3)) + (sqr(r)*(15 + a1*(14 - 10*z + a1*(-89 - 16*sqr(a1)*sqr(1.-z) + (114 - 41*z)*z + 4*a1*(-1 + z)*(-19 + 15*z)))))/((-1 + a1)*(-1 + z)))/(2.*r30*a1*rz);
+ (*kernal)(0,1,1)=(pT*r*((-48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)))/(-1 + z) + (r*(-15 + a1*(-21 + 4*a1*(11 + 2*a1*(-1 + z) - 7*z) + 17*z)))/((-1 + a1)*(-1 + z)) + (5*(-3 + z) + a1*(44 - 8*pow(a1,3)*sqr(1.-z) - z*(27 + z) + 2*sqr(a1)*(-1 + z)*(-15 + 7*z) + a1*(-51 + (50 - 7*z)*z)))/((-1 + a1)*pow(1 + a1*(-1 + z),2))))/(2.*r15*a1*M*phase*rz);
+ (*kernal)(0,1,2)=(r*((-48*sqr(a1)*sqr(r)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (z*(-15 + a1*(-13 + 4*a1*(11 + 4*a1*(-1 + z) - 7*z) + 9*z)))/((-1 + a1)*(1 + a1*(-1 + z))) + (r*(-15 + a1*(2 - 6*z + a1*(57 + 16*sqr(a1)*sqr(1.-z) - 4*a1*(-1 + z)*(-15 + 19*z) + z*(-98 + 57*z)))))/((-1 + a1)*(-1 + z))))/(2.*r30*a1*pow(phase,2)*rz);
+ (*kernal)(1,0,0)=(pow(phase,2)*r*((-48*sqr(a1)*sqr(r)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (z*(-15 + a1*(-13 + 4*a1*(11 + 4*a1*(-1 + z) - 7*z) + 9*z)))/((-1 + a1)*(1 + a1*(-1 + z))) + (r*(-15 + a1*(2 - 6*z + a1*(57 + 16*sqr(a1)*sqr(1.-z) - 4*a1*(-1 + z)*(-15 + 19*z) + z*(-98 + 57*z)))))/((-1 + a1)*(-1 + z))))/(2.*r30*a1*rz);
+ (*kernal)(1,0,1)=(pT*phase*r*((48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)))/(-1 + z) - (r*(-15 + a1*(-21 + 4*a1*(11 + 2*a1*(-1 + z) - 7*z) + 17*z)))/((-1 + a1)*(-1 + z)) + (-5*(-3 + z) + a1*(-44 + 8*pow(a1,3)*sqr(1.-z) + z*(27 + z) - 2*sqr(a1)*(-1 + z)*(-15 + 7*z) + a1*(51 + z*(-50 + 7*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),2))))/(2.*r15*a1*M*rz);
+ (*kernal)(1,0,2)=((48*sqr(a1)*pow(r,3)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (r*(-5*(-5 + z) + a1*(-41 + 16*a1 + 9*z)))/(-1 + a1) + ((-1 + z)*z*(5*(-2 + z) + a1*(28 + 8*sqr(a1)*sqr(1.-z) + (-23 + z)*z - 2*a1*(-1 + z)*(-13 + 4*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),3)) + (sqr(r)*(15 + a1*(14 - 10*z + a1*(-89 - 16*sqr(a1)*sqr(1.-z) + (114 - 41*z)*z + 4*a1*(-1 + z)*(-19 + 15*z)))))/((-1 + a1)*(-1 + z)))/(2.*r30*a1*rz);
+ (*kernal)(1,1,0)=(pT*phase*r*(-48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)) + (r*(-15 + a1*(-13 + 4*a1*(11 + 4*a1*(-1 + z) - 9*z) + 17*z)))/(-1 + a1) - (z*(-5*(1 + z) + a1*(21 - 8*a1*(-3 + z)*(-1 + z) + 8*sqr(a1)*sqr(1.-z) + (-14 + z)*z)))/((-1 + a1)*pow(1 + a1*(-1 + z),2))))/(2.*r30*a1*M*(-1 + z)*rz);
+ (*kernal)(1,1,1)=((-48*sqr(a1)*pow(r,3)*pow(1 + a1*(-1 + z),2))/(-1 + z) + (r*(15 - 29*a1 - 8*pow(a1,3)*sqr(1.-z) + a1*(38 - 17*z)*z + 5*(-2 + z)*z + 2*sqr(a1)*(-1 + z)*(-11 + 9*z)))/((-1 + a1)*(-1 + z)) + (z*(5 - 4*pow(a1,4)*pow(-1 + z,3) - 5*(-1 + z)*z + pow(a1,3)*sqr(1.-z)*(-19 + 7*z) - a1*(3 + z)*(7 + (-7 + z)*z) - sqr(a1)*(-1 + z)*(31 + z*(-21 + 2*z))))/((-1 + a1)*pow(1 + a1*(-1 + z),3)) + (sqr(r)*(-15 + a1*(-6 + 10*z + a1*(65 - 52*a1*sqr(1.-z) + 8*sqr(a1)*sqr(1.-z) + z*(-98 + 41*z)))))/((-1 + a1)*(-1 + z)))/(2.*r15*a1*rz);
+ (*kernal)(1,1,2)=(pT*r*(48*sqr(a1)*sqr(r)*(1 + a1*(-1 + z)) + (r*(15 + a1*(29 - 33*z + 4*a1*(-15 - 4*a1*(-1 + z) + 13*z))))/(-1 + a1) + (-8*pow(a1,3)*(-2 + z)*sqr(1.-z) - 5*(5 + 3*(-2 + z)*z) + sqr(a1)*(-1 + z)*(57 + z*(-58 + 17*z)) + a1*(66 + z*(-105 + (56 - 9*z)*z)))/((-1 + a1)*pow(1 + a1*(-1 + z),2))))/(2.*r30*a1*M*phase*(-1 + z)*rz);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D1SplitFn.h
@@ -0,0 +1,285 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP3D1SplitFn_H
+#define Herwig_QtoQP3D1SplitFn_H
+//
+// This is the declaration of the QtoQP3D1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP3D1SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^3D_1)\f$,
+ *
+ * @see \ref QtoQP3D1SplitFnInterfaces "The interfaces"
+ * defined for QtoQP3D1SplitFn.
+ */
+class QtoQP3D1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQP3D1SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+3 + 30000 + (n_-1)*100000;
+ if( abs(ids[2]->id()) != idtest ) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP3D1SplitFn & operator=(const QtoQP3D1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQP3D1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.cc
@@ -0,0 +1,192 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP3D3SplitFn class.
+//
+
+#include "QtoQP3D3SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP3D3SplitFn::pOver_ = 100.;
+
+IBPtr QtoQP3D3SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP3D3SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP3D3SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP3D3SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP3D3SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,1,3);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP3D3SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP3D3SplitFn("Herwig::QtoQP3D3SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP3D3SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP3D3SplitFn> documentation
+ ("The QtoQP3D3SplitFn class implements the branching q-> q' 3D3");
+
+ static Reference<QtoQP3D3SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP3D3SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP3D3SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP3D3SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP3D3SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP3D3SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP3D3SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP3D3SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP3D3SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./567.*aS2*O1_/pow(a2,4)/M/sqr(M*M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP3D3SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ // coefficients
+ double W0 = 2.*z*(84 - 18*pow(a1,5)*(-2 + z)*pow(-1 + z,5) + 3*pow(a1,6)*pow(-1 + z,6) - 288*z + 444*sqr(z) - 384*pow(z,3) +
+ 196*pow(z,4) - 56*pow(z,5) + 7*pow(z,6) + 9*pow(a1,4)*pow(-1 + z,4)*(22 - 26*z + 9*sqr(z)) -
+ 6*pow(a1,3)*pow(-1 + z,3)*(-82 + 147*z - 97*sqr(z) + 22*pow(z,3)) +
+ 3*sqr(a1)*pow(-1 + z,2)*(201 - 474*z + 455*sqr(z) - 202*pow(z,3) + 35*pow(z,4)) -
+ 6*a1*(60 - 234*z + 392*sqr(z) - 361*pow(z,3) + 192*pow(z,4) - 56*pow(z,5) + 7*pow(z,6)))/(15.*pow(-1 + a1,2)*pow(1 + a1*(-1 + z),6));
+ double W1 =-2.*(-7 + 6*pow(a1,5)*(-7 + z)*pow(-1 + z,4) + 421*z - 813*sqr(z) + 611*pow(z,3) -
+ 191*pow(z,4) + 21*pow(z,5) + pow(a1,4)*pow(-1 + z,3)*(-161 + 16*z + sqr(z)) -
+ 4*pow(a1,3)*pow(-1 + z,2)*(56 + 104*z - 157*sqr(z) + 51*pow(z,3)) -
+ 2*a1*(7 + 643*z - 1547*sqr(z) + 1393*pow(z,3) - 563*pow(z,4) + 85*pow(z,5)) +
+ 3*sqr(a1)*(42 + 386*z - 1257*sqr(z) + 1351*pow(z,3) - 637*pow(z,4) + 115*pow(z,5)))/(15.*pow(-1 + a1,2)*pow(1 + a1*(-1 + z),4));
+ double W2 =-2.*(-62 + 857*z - 750*sqr(z) + 175*pow(z,3) + 4*pow(a1,4)*pow(-1 + z,3)*(-58 + 15*z) -
+ 2*pow(a1,3)*pow(-1 + z,2)*(317 - 124*z + 65*sqr(z)) + sqr(a1)*(510 + 93*z - 1383*sqr(z) + 963*pow(z,3) - 183*pow(z,4)) +
+ a1*(-46 - 1710*z + 2517*sqr(z) - 1164*pow(z,3) + 231*pow(z,4)))/(15.*(-1 + a1)*pow(1 + a1*(-1 + z),3));
+ double W3 =-8.*(-33 + 161*z + a1*(-95 + 40*z - 49*sqr(z)) + 8*sqr(a1)*(16 - 19*z + 3*sqr(z)))/(15.*(1 + a1*(-1 + z)));
+ double W4 = 896.*(-1 + a1)*a1/15.;
+ double ratio = (W0+r*(W1+r*(W2+r*(W3+r*W4))))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP3D3SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP3D3SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP3D3SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ double rz = sqrt(z), r2=sqrt(2.), r3=sqrt(3.);
+ double r215 = sqrt(2./15.);
+ double r410= sqrt(0.4);
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(GeneralDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin3)));
+ (*kernal)(0,0,0)=2.*r2*pT*pow(phase,3)*sqr(r)*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z)/((-1 + a1)*M*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,1)=2.*sqr(phase)*r*(pow(r + a1*r*(-1 + z),2)*(5 + 2*pow(a1,2)*pow(-1 + z,2) + z - a1*(7 - 8*z + sqr(z))) + (pow(-1 + z,2)*z*(2 + 2*z - sqr(z) + a1*(-2 + z + sqr(z))))/(1 + a1*(-1 + z)) + r*(-1 + z)*(2 + 7*z + pow(a1,2)*pow(-1 + z,2)*(2 + 3*z) - 2*a1*(2 + 3*z - 6*sqr(z) + pow(z,3))))/(r3*(-1 + a1)*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,2)=(2*r215*pT*phase*r*(-(r*(-1 + z)*(6 + 4*pow(a1,2)*pow(-1 + z,2) + 12*z - 3*sqr(z) + 2*a1*(-5 + 4*z + sqr(z)))) - sqr(r)*(8*pow(a1,3)*pow(-1 + z,3) + 5*(2 + z) - pow(a1,2)*pow(-1 + z,2)*(-26 + 3*z) + 2*a1*(-14 + 13*z + sqr(z))) - (pow(-1 + z,2)*(1 + 5*z - 4*sqr(z) + pow(z,3) + pow(a1,2)*pow(-1 + z,2)*(1 + 2*z) - a1*(2 + 5*z - 10*sqr(z) + 3*pow(z,3))))/pow(1 + a1*(-1 + z),2)))/((-1 + a1)*M*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,3)=(r410*(-((r*(1 + 2*pow(a1,2)*pow(-1 + z,2) + 13*z - 2*sqr(z) + 3*a1*(-1 + sqr(z))))/(-1 + z)) - (2*pow(r,3)*pow(1 + a1*(-1 + z),2)*(6*pow(a1,2)*pow(-1 + z,2) + 5*(1 + z) - a1*(11 - 12*z + sqr(z))))/pow(-1 + z,3) - (2*sqr(r)*(3 + 4*pow(a1,3)*pow(-1 + z,3) + 12*z + pow(a1,2)*pow(-1 + z,2)*(11 + 4*z) - 2*a1*(5 + 3*z - 9*sqr(z) + pow(z,3))))/pow(-1 + z,2) + (z*(-4 + 3*pow(a1,2)*(-2 + z)*pow(-1 + z,2) - pow(a1,3)*pow(-1 + z,3) + 6*z - 4*sqr(z) + pow(z,3) - 3*a1*(-3 + 6*z - 4*sqr(z) + pow(z,3))))/pow(1 + a1*(-1 + z),3)))/((-1 + a1)*rz);
+ (*kernal)(0,0,4)=(2*r215*pT*r*(r*(-1 + z)*(2 + 4*pow(a1,2)*pow(-1 + z,2) + 15*z - 2*sqr(z) + 6*a1*(-1 + sqr(z))) + (pow(-1 + z,2)*z*(6 + 3*pow(a1,2)*pow(-1 + z,2) - 4*z + sqr(z) - 3*a1*(3 - 4*z + sqr(z))))/pow(1 + a1*(-1 + z),2) + sqr(r)*(5 + 8*pow(a1,3)*pow(-1 + z,3) + 10*z + pow(a1,2)*pow(-1 + z,2)*(21 + 2*z) + 6*a1*(-3 + z + 2*sqr(z)))))/((-1 + a1)*M*phase*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,5)=(2*r*(((4 + 3*a1*(-1 + z) - z)*pow(-1 + z,2)*sqr(z))/(1 + a1*(-1 + z)) + pow(r + a1*r*(-1 + z),2)*(1 + 2*pow(a1,2)*pow(-1 + z,2) + 5*z + 3*a1*(-1 + sqr(z))) + r*(-1 + z)*z*(5 + 5*pow(a1,2)*pow(-1 + z,2) + 4*z + 2*a1*(-5 + 4*z + sqr(z)))))/(r3*(-1 + a1)*sqr(phase)*pow(-1 + z,3)*rz);
+ (*kernal)(0,0,6)=(-2*r2*pT*sqr(r)*rz*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z))/((-1 + a1)*M*pow(phase,3)*pow(-1 + z,3));
+ (*kernal)(0,1,0)=(-2*r2*sqr(phase)*r*(2*a1*r*(1 + a1*(-1 + z))*(-1 + z)*sqr(z) + pow(-1 + z,2)*sqr(z) + sqr(r)*pow(1 + a1*(-1 + z),3)*(-1 + a1 + a1*z)))/((-1 + a1)*(1 + a1*(-1 + z))*pow(-1 + z,2)*rz);
+ (*kernal)(0,1,1)=(2*pT*phase*r*(((3 + 3*a1*(-1 + z) - z)*z)/pow(1 + a1*(-1 + z),2) + (r*(-2 + 3*z + a1*(2 + 4*z)))/(-1 + z) + (sqr(r)*(-5 - 2*a1*(-6 + z) + 2*pow(a1,3)*pow(-1 + z,2) + 3*pow(a1,2)*(-3 + 2*z + sqr(z))))/pow(-1 + z,2)))/(r3*(-1 + a1)*M*rz);
+ (*kernal)(0,1,2)=(2*r215*(r*(-1 + a1 + 4*z + 5*a1*z) + (2*pow(r,3)*pow(1 + a1*(-1 + z),2)*(-5 + 4*pow(a1,2)*(-1 + z) + a1*(9 + z)))/pow(-1 + z,2) + ((-1 + z)*z*(3 + 3*pow(a1,2)*pow(-1 + z,2) - 3*z + sqr(z) - 3*a1*(2 - 3*z + sqr(z))))/pow(1 + a1*(-1 + z),3) + (2*sqr(r)*(-3 + 2*pow(a1,3)*pow(-1 + z,2) + 2*a1*(4 + z + sqr(z)) + pow(a1,2)*(-7 + 2*z + 5*sqr(z))))/(-1 + z)))/((-1 + a1)*rz);
+ (*kernal)(0,1,3)=(r410*pT*r*((-2*r*(-3 + 4*pow(a1,2)*(-1 + z) + z + a1*(7 + z)))/(-1 + z) - (2*sqr(r)*(-5 + a1*(16 - 6*z) + 6*pow(a1,3)*pow(-1 + z,2) - pow(a1,2)*(17 - 18*z + sqr(z))))/pow(-1 + z,2) + (1 - 2*pow(a1,3)*pow(-1 + z,2) - 3*z + sqr(z) + a1*(-4 + 5*z - 3*sqr(z)) + pow(a1,2)*(5 - 6*z + sqr(z)))/pow(1 + a1*(-1 + z),2)))/((-1 + a1)*M*phase*rz);
+ (*kernal)(0,1,4)=(2*r215*r*(-(((-5 + a1*(13 - 3*z) + 8*pow(a1,2)*(-1 + z))*pow(r + a1*r*(-1 + z),2))/pow(-1 + z,2)) - (z*(-2 - 2*a1*(-3 + z) + 4*pow(a1,2)*(-1 + z) + z))/(1 + a1*(-1 + z)) - (2*r*(-1 + 2*pow(a1,3)*pow(-1 + z,2) - 2*z + a1*(4 + 4*z - sqr(z)) + pow(a1,2)*(-5 + 2*z + 3*sqr(z))))/(-1 + z)))/((-1 + a1)*sqr(phase)*rz);
+ (*kernal)(0,1,5)=(2*(-1 + 2*a1)*pT*sqr(r)*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z))/(r3*(-1 + a1)*M*pow(phase,3)*pow(-1 + z,2)*rz);
+ (*kernal)(0,1,6)=0;
+ (*kernal)(1,0,0)=0;
+ (*kernal)(1,0,1)=(-2*(-1 + 2*a1)*pT*pow(phase,3)*sqr(r)*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z))/(r3*(-1 + a1)*M*pow(-1 + z,2)*rz);
+ (*kernal)(1,0,2)=(2*r215*sqr(phase)*r*(-(((-5 + a1*(13 - 3*z) + 8*pow(a1,2)*(-1 + z))*pow(r + a1*r*(-1 + z),2))/pow(-1 + z,2)) - (z*(-2 - 2*a1*(-3 + z) + 4*pow(a1,2)*(-1 + z) + z))/(1 + a1*(-1 + z)) - (2*r*(-1 + 2*pow(a1,3)*pow(-1 + z,2) - 2*z + a1*(4 + 4*z - sqr(z)) + pow(a1,2)*(-5 + 2*z + 3*sqr(z))))/(-1 + z)))/((-1 + a1)*rz);
+ (*kernal)(1,0,3)=(r410*pT*phase*r*((2*r*(-3 + 4*pow(a1,2)*(-1 + z) + z + a1*(7 + z)))/(-1 + z) + (2*sqr(r)*(-5 + a1*(16 - 6*z) + 6*pow(a1,3)*pow(-1 + z,2) - pow(a1,2)*(17 - 18*z + sqr(z))))/pow(-1 + z,2) + (-1 + 2*pow(a1,3)*pow(-1 + z,2) + 3*z - sqr(z) - pow(a1,2)*(5 - 6*z + sqr(z)) + a1*(4 - 5*z + 3*sqr(z)))/pow(1 + a1*(-1 + z),2)))/((-1 + a1)*M*rz);
+ (*kernal)(1,0,4)=(2*r215*(r*(-1 + a1 + 4*z + 5*a1*z) + (2*pow(r,3)*pow(1 + a1*(-1 + z),2)*(-5 + 4*pow(a1,2)*(-1 + z) + a1*(9 + z)))/pow(-1 + z,2) + ((-1 + z)*z*(3 + 3*pow(a1,2)*pow(-1 + z,2) - 3*z + sqr(z) - 3*a1*(2 - 3*z + sqr(z))))/pow(1 + a1*(-1 + z),3) + (2*sqr(r)*(-3 + 2*pow(a1,3)*pow(-1 + z,2) + 2*a1*(4 + z + sqr(z)) + pow(a1,2)*(-7 + 2*z + 5*sqr(z))))/(-1 + z)))/((-1 + a1)*rz);
+ (*kernal)(1,0,5)=(2*pT*r*(-(((3 + 3*a1*(-1 + z) - z)*z)/pow(1 + a1*(-1 + z),2)) - (r*(-2 + 3*z + a1*(2 + 4*z)))/(-1 + z) - (sqr(r)*(-5 - 2*a1*(-6 + z) + 2*pow(a1,3)*pow(-1 + z,2) + 3*pow(a1,2)*(-3 + 2*z + sqr(z))))/pow(-1 + z,2)))/(r3*(-1 + a1)*M*phase*rz);
+ (*kernal)(1,0,6)=(-2*r2*r*(2*a1*r*(1 + a1*(-1 + z))*(-1 + z)*sqr(z) + pow(-1 + z,2)*sqr(z) + sqr(r)*pow(1 + a1*(-1 + z),3)*(-1 + a1 + a1*z)))/((-1 + a1)*sqr(phase)*(1 + a1*(-1 + z))*pow(-1 + z,2)*rz);
+ (*kernal)(1,1,0)=(2*r2*pT*pow(phase,3)*sqr(r)*rz*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z))/((-1 + a1)*M*pow(-1 + z,3));
+ (*kernal)(1,1,1)=2.*sqr(phase)*r*(((4 + 3*a1*(-1 + z) - z)*pow(-1 + z,2)*sqr(z))/(1 + a1*(-1 + z)) + pow(r + a1*r*(-1 + z),2)*(1 + 2*pow(a1,2)*pow(-1 + z,2) + 5*z + 3*a1*(-1 + sqr(z))) + r*(-1 + z)*z*(5 + 5*pow(a1,2)*pow(-1 + z,2) + 4*z + 2*a1*(-5 + 4*z + sqr(z))))/(r3*(-1 + a1)*pow(-1 + z,3)*rz);
+ (*kernal)(1,1,2)=(2*r215*pT*phase*r*(-(r*(-1 + z)*(2 + 4*pow(a1,2)*pow(-1 + z,2) + 15*z - 2*sqr(z) + 6*a1*(-1 + sqr(z)))) - (pow(-1 + z,2)*z*(6 + 3*pow(a1,2)*pow(-1 + z,2) - 4*z + sqr(z) - 3*a1*(3 - 4*z + sqr(z))))/pow(1 + a1*(-1 + z),2) - sqr(r)*(5 + 8*pow(a1,3)*pow(-1 + z,3) + 10*z + pow(a1,2)*pow(-1 + z,2)*(21 + 2*z) + 6*a1*(-3 + z + 2*sqr(z)))))/((-1 + a1)*M*pow(-1 + z,3)*rz);
+ (*kernal)(1,1,3)=(r410*(-((r*(1 + 2*pow(a1,2)*pow(-1 + z,2) + 13*z - 2*sqr(z) + 3*a1*(-1 + sqr(z))))/(-1 + z)) - (2*pow(r,3)*pow(1 + a1*(-1 + z),2)*(6*pow(a1,2)*pow(-1 + z,2) + 5*(1 + z) - a1*(11 - 12*z + sqr(z))))/pow(-1 + z,3) - (2*sqr(r)*(3 + 4*pow(a1,3)*pow(-1 + z,3) + 12*z + pow(a1,2)*pow(-1 + z,2)*(11 + 4*z) - 2*a1*(5 + 3*z - 9*sqr(z) + pow(z,3))))/pow(-1 + z,2) + (z*(-4 + 3*pow(a1,2)*(-2 + z)*pow(-1 + z,2) - pow(a1,3)*pow(-1 + z,3) + 6*z - 4*sqr(z) + pow(z,3) - 3*a1*(-3 + 6*z - 4*sqr(z) + pow(z,3))))/pow(1 + a1*(-1 + z),3)))/((-1 + a1)*rz);
+ (*kernal)(1,1,4)=(2*r215*pT*r*(r*(-1 + z)*(6 + 4*pow(a1,2)*pow(-1 + z,2) + 12*z - 3*sqr(z) + 2*a1*(-5 + 4*z + sqr(z))) + sqr(r)*(8*pow(a1,3)*pow(-1 + z,3) + 5*(2 + z) - pow(a1,2)*pow(-1 + z,2)*(-26 + 3*z) + 2*a1*(-14 + 13*z + sqr(z))) + (pow(-1 + z,2)*(1 + 5*z - 4*sqr(z) + pow(z,3) + pow(a1,2)*pow(-1 + z,2)*(1 + 2*z) - a1*(2 + 5*z - 10*sqr(z) + 3*pow(z,3))))/pow(1 + a1*(-1 + z),2)))/((-1 + a1)*M*phase*pow(-1 + z,3)*rz);
+ (*kernal)(1,1,5)=(2*r*(pow(r + a1*r*(-1 + z),2)*(5 + 2*pow(a1,2)*pow(-1 + z,2) + z - a1*(7 - 8*z + sqr(z))) + (pow(-1 + z,2)*z*(2 + 2*z - sqr(z) + a1*(-2 + z + sqr(z))))/(1 + a1*(-1 + z)) + r*(-1 + z)*(2 + 7*z + pow(a1,2)*pow(-1 + z,2)*(2 + 3*z) - 2*a1*(2 + 3*z - 6*sqr(z) + pow(z,3)))))/(r3*(-1 + a1)*sqr(phase)*pow(-1 + z,3)*rz);
+ (*kernal)(1,1,6)=(-2*r2*pT*sqr(r)*(r*pow(1 + a1*(-1 + z),2) + (-1 + z)*z))/((-1 + a1)*M*pow(phase,3)*pow(-1 + z,3)*rz);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3D3SplitFn.h
@@ -0,0 +1,285 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP3D3SplitFn_H
+#define Herwig_QtoQP3D3SplitFn_H
+//
+// This is the declaration of the QtoQP3D3SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/GeneralDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP3D3SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^3D_3)\f$,
+ *
+ * @see \ref QtoQP3D3SplitFnInterfaces "The interfaces"
+ * defined for QtoQP3D3SplitFn.
+ */
+class QtoQP3D3SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQP3D3SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+7 + (n_-1)*100000;
+ if( abs(ids[2]->id()) != idtest ) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP3D3SplitFn & operator=(const QtoQP3D3SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQP3D3SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.cc
@@ -0,0 +1,163 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP3P0SplitFn class.
+//
+
+#include "QtoQP3P0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP3P0SplitFn::pOver_ = 1.;
+
+IBPtr QtoQP3P0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP3P0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP3P0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP3P0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP3P0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,0);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP3P0SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP3P0SplitFn("Herwig::QtoQP3P0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP3P0SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP3P0SplitFn> documentation
+ ("The QtoQP3P0SplitFn class implements the branching q-> q' 3P0");
+
+ static Reference<QtoQP3P0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP3P0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP3P0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP3P0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP3P0SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP3P0SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP3P0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP3P0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP3P0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 32./81.*aS2*O1_/pow(a2,4)/M/sqr(M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP3P0SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = z*sqr( 3.*(-2.+z) +
+ a1*(15.-12.*z+sqr(z) +
+ a1*((-13.+18.*z-5.*sqr(z)) +
+ 4.*a1*sqr(1.-z))))/(48.*sqr(a1*sqr(1.-a1*(1.-z))));
+ double W1 = (45.-27*z + a1*(6.*(6.-13.*z+5.*sqr(z)) +
+ a1*(-407.+591.*z-233.*sqr(z)+9.*z*sqr(z) +
+ a1*(590.-998.*z+498.*sqr(z)-58.*z*sqr(z) +
+ 8.*a1*(-41.+84.*z-53.*sqr(z)+10.*z*sqr(z) +
+ 4.*a1*sqr(1.-z)*(2.-z))))))/(48.*sqr(a1)*sqr(1 - a1*(1 - z)));
+ double W2 = (1.-a1)*(-3.+a1*((-22.+12.*z) +
+ a1*((41.-30.*z+3.*sqr(z)) +
+ 2.*a1*(-8.+9.*z-sqr(z)))))/(6.*a1*(1 - a1*(1 - z)));
+ double W3 = 4./3.*sqr(1.-a1)*a1;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP3P0SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP3P0SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP3P0SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal N.B. prefactor 1./4./sqrt(3.)/sqrt(z) removed
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin0)));
+ (*kernal)(0,0,0) = z*(6.-3.*z-a1*(15.-a1*(13.-5.*z)*(1.-z)+4.*sqr(a1)*sqr(1.-z)-(12.-z)*z))/(a1*sqr(1.-a1*(1.-z)))
+ +r*(3.+(1.-2.*a1)*a1*(7.-4.*a1*(1.-z)-5.*z))/a1 - 8.*(1.-a1)*a1*sqr(r)*(1.-a1*(1.-z));
+ (*kernal)(1,1,0) = (*kernal)(0,0,0);
+ (*kernal)(0,1,0) = double(pT/M)*r/phase*(-8.*(1.-a1)*a1*r+(3.+a1*(7.-2.*a1*(9.-4.*a1*(1.-z)-5.*z)-z))/(a1*(1.-a1*(1.-z))));
+ (*kernal)(1,0,0) = -conj((*kernal)(0,1,0));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P0SplitFn.h
@@ -0,0 +1,288 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP3P0SplitFn_H
+#define Herwig_QtoQP3P0SplitFn_H
+//
+// This is the declaration of the QtoQP3P0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP3P0SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^3P_0)\f$
+ *
+ * @see \ref QtoQP3P0SplitFnInterfaces "The interfaces"
+ * defined for QtoQP3P0SplitFn.
+ */
+class QtoQP3P0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQP3P0SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+ //@}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest =id1*100+id2*10+1 + 10000 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP3P0SplitFn & operator=(const QtoQP3P0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQP3P0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.cc
@@ -0,0 +1,190 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP3P2SplitFn class.
+//
+
+#include "QtoQP3P2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP3P2SplitFn::pOver_ = 2.;
+
+IBPtr QtoQP3P2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP3P2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP3P2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP3P2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP3P2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,1,2);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP3P2SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP3P2SplitFn("Herwig::QtoQP3P2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP3P2SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP3P2SplitFn> documentation
+ ("The QtoQP3P2SplitFn class implements the branching q-> q' 3P2");
+
+ static Reference<QtoQP3P2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP3P2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP3P2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP3P2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP3P2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP3P2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP3P2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP3P2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP3P2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 32./405.*aS2*O1_/pow(a2,4)/M/sqr(M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP3P2SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = z*(30.-72.*z+69*sqr(z)-30.*z*sqr(z)+5.*sqr(sqr(z))
+ +a1*( -4.*(18.-51.*z+55.*sqr(z)-27*z*sqr(z)+5.*sqr(sqr(z)))
+ +a1*( +4.*sqr(1.-z)*(14.-17.*z+6.*sqr(z))
+ +a1*(-8.*pow(1.-z,3)*(2.-z) + 2.*a1*pow(1.-z,4) ))))/(12.*pow(1.-a1*(1.-z),4));
+ double W1 = (5.-z*(93.-98*z+30.*sqr(z))
+ +a1*(+ 2.*(5.+46.*z-57.*sqr(z)+14.*z*sqr(z))
+ + a1*( -35.+45.*z-17.*sqr(z)+7.*z*sqr(z)
+ +4.*a1*sqr(1.-z)*(5.-z))))/(12.*sqr(1.-a1*(1.-z)));
+ double W2 = (1.-a1)*(-11.+45.*z + a1*(3.*z*(4.-5.*z)-23. + 2.*a1*(17.-4.*z)*(1.-z)))/(6.*(1.-a1*(1.-z)));
+ double W3 = 20.*sqr(1.-a1)*a1/3.;
+ double ratio = (W0+r*(W1+r*(W2+r*W3)))/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP3P2SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP3P2SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP3P2SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ double rz=sqrt(z);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin2)));
+ (*kernal)(0,0,0) = -ii*sqr(phase)*r/rz/(1.-z)*(r*sqr(1.-a1*(1.-z))/(1.-z)-z);
+ (*kernal)(0,0,1) = 0.5*ii*phase*double(pT/M)*r/rz/(1.-z)*(-(1.+2.*z-sqr(z)+a1*(-1.+sqr(z)))/(1.-a1*(1.-z))
+ + r*(3.+2.*sqr(a1)*sqr(1.-z)+z-a1*(5.-6.*z+sqr(z)))/(1.-z));
+ (*kernal)(0,0,2) = ii/sqrt(6.)/rz*(z*(3.+sqr(a1)*sqr(1.-z)-3.*z+sqr(z)-2.*a1*(2.-3.*z+sqr(z)))/sqr(1.-a1*(1.-z))
+ -r*(1 + 2*sqr(a1)*sqr(1.-z) + 6*z - sqr(z) + a1*(-3 + 2*z + sqr(z)))/(1.-z)
+ + sqr(r)*(-sqr(a1)*(-11.+z)*sqr(1.-z)-4.*pow(a1,3)*pow(1.-z,3)+3.*(1.+z)+2.*a1*(-5.+4.*z+sqr(z)))/sqr(1.-z));
+ (*kernal)(0,0,3) = -0.5*ii/phase*double(pT/M)*r/rz/(1.-z)*( -(3.-2*a1*(1.-z)-z)*z/((1.-a1*(1.-z)))
+ + r*(1.+2.*sqr(a1)*sqr(1.-z)+3.*z+a1*(-3.+2.*z+sqr(z)))/(1.-z));
+ (*kernal)(0,0,4) =-ii/sqr(phase)*r/(1.-z)*rz*( r*sqr(1.-a1*(1.-z))/(1.-z) - z);
+ (*kernal)(0,1,0) =-ii*phase*double(pT/M)/rz*r*( z/(1.-a1*(1.-z)) + r*(1.-a1-a1*z)/(1.-z));
+ (*kernal)(0,1,1) = 0.5*ii/rz*((2.-2.*a1*(1.-z)-z)*(1.-z)*z/sqr(1.-a1*(1.-z))
+ +r*(1.-a1-z-3.*a1*z)
+ +sqr(r)*(-3.-2.*a1*(-4.+z)+2.*pow(a1,3)*sqr(1.-z)+sqr(a1)*(-7.+6.*z+sqr(z)))/(1.-z));
+ (*kernal)(0,1,2) = ii*double(pT/M)/sqrt(6.)/phase*r/rz*(r*(3.-a1*(7.-z)+4.*sqr(a1)*(1.-z))/(1.-z)
+ +(-1.+a1*(3.-z)-2.*sqr(a1)*(1.-z)+z)/(1.-a1*(1.-z)));
+ (*kernal)(0,1,3) = 0.5*ii*(1.-2.*a1)/sqr(phase)*r/rz*(r*sqr(1.-a1*(1.-z))/(1.-z)-z);
+ (*kernal)(0,1,4) = 0.;
+ (*kernal)(1,0,0) = 0.;
+ (*kernal)(1,0,1) = 0.5*ii*(1.-2.*a1)*sqr(phase)*r/rz*(r*sqr(1.-a1*(1.-z))/(1.-z)-z);
+ (*kernal)(1,0,2) =-ii*double(pT/M)/sqrt(6.)*phase*r/rz*(r*(3.-a1*(7.-z)+4.*sqr(a1)*(1.-z))/(1.-z)
+ +(-1.+a1*(3.-z)-2.*sqr(a1)*(1.-z)+z)/(1.-a1*(1.-z)));
+ (*kernal)(1,0,3) =+0.5*ii/rz*((2.-2.*a1*(1.-z)-z)*(1.-z)*z/sqr(1.-a1*(1.-z))
+ +r*(1.-a1-z-3.*a1*z)
+ +sqr(r)*(-3.-2.*a1*(-4.+z)+2.*pow(a1,3)*sqr(1.-z)+sqr(a1)*(-7.+6.*z+sqr(z)))/(1.-z));
+ (*kernal)(1,0,4) = ii/phase*double(pT/M)/rz*r*( z/(1.-a1*(1.-z)) + r*(1.-a1-a1*z)/(1.-z));
+ (*kernal)(1,1,0) =-ii*sqr(phase)*r/(1.-z)*rz*( r*sqr(1.-a1*(1.-z))/(1.-z) - z);
+ (*kernal)(1,1,1) = 0.5*ii*phase*double(pT/M)*r/rz/(1.-z)*(-(3.-2.*a1*(1.-z)-z)*z/(1.-a1*(1.-z))
+ + r*(1.+2.*sqr(a1)*sqr(1.-z)+3.*z+a1*(-3.+2.*z+sqr(z)))/(1.-z));
+ (*kernal)(1,1,2) = ii/sqrt(6.)/rz* (z*(3.+sqr(a1)*sqr(1.-z)-3.*z+sqr(z)-2.*a1*(2.-3.*z+sqr(z)))/sqr(1.-a1*(1.-z))
+ -r*(1.+2.*sqr(a1)*sqr(1.-z)+6.*z-sqr(z)+a1*(-3.+2.*z+sqr(z)))/(1.-z)
+ +sqr(r)*(-(sqr(a1)*(-11.+z)*sqr(1.-z))-4.*pow(a1,3)*pow(1.-z,3)+3.*(1.+z)+2.*a1*(-5.+4.*z+sqr(z)))/(sqr(1.-z)));
+ (*kernal)(1,1,3) = -0.5*ii/phase*double(pT/M)*r/rz/(1.-z)*(-(1.+2.*z-sqr(z)+a1*(-1.+sqr(z)))/(1.-a1*(1.-z))
+ +r*(3.+2.*sqr(a1)*sqr(1.-z)+z-a1*(5.-6.*z+sqr(z)))/(1.-z));
+ (*kernal)(1,1,4) =-ii/sqr(phase)*r/rz/(1.-z)*(r*sqr(1.-a1*(1.-z))/(1.-z)-z);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3P2SplitFn.h
@@ -0,0 +1,288 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP3P2SplitFn_H
+#define Herwig_QtoQP3P2SplitFn_H
+//
+// This is the declaration of the QtoQP3P2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP3P2SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^3P_2)\f$
+ *
+ * @see \ref QtoQP3P2SplitFnInterfaces "The interfaces"
+ * defined for QtoQP3P2SplitFn.
+ */
+class QtoQP3P2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /** @name Standard constructors and destructors. */
+ //@{
+ /**
+ * The default constructor.
+ */
+ QtoQP3P2SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+ //@}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+5 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP3P2SplitFn & operator=(const QtoQP3P2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQP3P2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.cc
@@ -0,0 +1,162 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQP3S1SplitFn class.
+//
+
+#include "QtoQP3S1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQP3S1SplitFn::pOver_ = 6.;
+
+IBPtr QtoQP3S1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQP3S1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQP3S1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQP3S1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQP3S1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<0>(state_,n_,1,1);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQP3S1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQP3S1SplitFn("Herwig::QtoQP3S1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQP3S1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQP3S1SplitFn> documentation
+ ("The QtoQP3S1SplitFn class implements the branching q-> q' 3S1");
+
+ static Reference<QtoQP3S1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQP3S1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQP3S1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQP3S1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQP3S1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQP3S1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQP3S1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQP3S1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQP3S1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./243.*aS2 * O1_ / M / sqr(a2);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQP3S1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = z*(6.+sqr(a1*(1.-z))+2.*a1*(1.-z)*(z-2.)+ z*(3.*z-8.))/sqr(1.-a1*(1.-z));
+ double W1 = (3.+2.*sqr(a1)*(1.-z)*(z-3.)-9.*z+a1*(3.-2.*z+3.*sqr(z)))/(1.-a1*(1.-z));
+ double W2 = -12.*(1.-a1)*a1;
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQP3S1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQP3S1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQP3S1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ double rz=sqrt(z);
+ double r2=sqrt(2.);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0) = -r2*phase*double(pT/M)*r/((1 - z)*rz);
+ (*kernal)(0,0,1) = (1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z)) - r*(1.+a1*(-2.+(-1.+2.*a1)*(1.-z))*(1.-z)+z)/((1 - z)*rz);
+ (*kernal)(0,0,2) = (r2*double(pT/M)*r*rz)/(phase*(1 - z));
+ (*kernal)(0,1,0) = r2*( (1.-z)*rz/(1.-a1*(1.-z)) + r*(1.-a1*(1.+z))/rz);
+ (*kernal)(0,1,1) = (-1.+2.*a1)*double(pT/M)*r/(phase*rz);
+ (*kernal)(0,1,2) = 0.;
+ (*kernal)(1,0,0) = 0.;
+ (*kernal)(1,0,1) = ((1.-2.*a1)*phase*double(pT/M)*r)/rz;
+ (*kernal)(1,0,2) = r2*((1.-z)*rz/(1.-a1*(1.-z)) + r*(1.-a1*(1.+z))/rz);
+ (*kernal)(1,1,0) = -r2*r*phase*double(pT/M)*rz/(1 - z);
+ (*kernal)(1,1,1) = r*(-1-a1*(-2.+(-1.+2.*a1)*(1.-z))*(1.-z) - z)/((1 - z)*rz) + (1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z));
+ (*kernal)(1,1,2) = r*r2*double(pT/M)/(phase*(1.-z)*rz);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQP3S1SplitFn.h
@@ -0,0 +1,289 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQP3S1SplitFn_H
+#define Herwig_QtoQP3S1SplitFn_H
+//
+// This is the declaration of the QtoQP3S1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQP3S1SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(^3S_1)\f$
+ *
+ * @see \ref QtoQP3S1SplitFnInterfaces "The interfaces"
+ * defined for QtoQP3S1SplitFn.
+ */
+class QtoQP3S1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQP3S1SplitFn() : O1_(0.573*GeV*GeV2), state_(bcbar), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+3;
+ idtest += (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQP3S1SplitFn & operator=(const QtoQP3S1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQP3S1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.cc
@@ -0,0 +1,132 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQPBarQQP0SplitFn class.
+//
+
+#include "QtoQPBarQQP0SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+
+using namespace Herwig;
+
+const double QtoQPBarQQP0SplitFn::pOver_ = 3.;
+
+IBPtr QtoQPBarQQP0SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQPBarQQP0SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQPBarQQP0SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(R02_,GeV*GeV2) << n_ << fixedAlphaS_;
+}
+
+void QtoQPBarQQP0SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(R02_,GeV*GeV2) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQPBarQQP0SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ R02_ = params_->radialWaveFunctionSquared(bc,n_);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQPBarQQP0SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQPBarQQP0SplitFn("Herwig::QtoQPBarQQP0SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQPBarQQP0SplitFn::Init() {
+
+ static ClassDocumentation<QtoQPBarQQP0SplitFn> documentation
+ ("The QtoQPBarQQP0SplitFn class implements the splitting function for q -> qbar' (qq')_0");
+
+ static Reference<QtoQPBarQQP0SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQPBarQQP0SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQPBarQQP0SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQPBarQQP0SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Parameter<QtoQPBarQQP0SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQPBarQQP0SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQPBarQQP0SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 1./9.*aS2*R02_/sqr(a2)/M/Constants::pi;
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQPBarQQP0SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = sqr(1.+(1.-a1)*(1.-z))*z/sqr(1.-a1*(1.-z));
+ double W1 = (-2.*sqr(a1*z)+2.*sqr(a1)+a1*sqr(z)+2.*a1*z-7.*a1-3.*z+5)/(1.-a1*(1.-z));
+ double W2 = -4.*a1*(1.-a1);
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQPBarQQP0SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQPBarQQP0SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQPBarQQP0SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ double rz=sqrt(z);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin0)));
+ (*kernal)(0,1,0) = -(1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z)) - r*(1.-a1-a1*z)/rz;
+ (*kernal)(1,0,0) = -(*kernal)(0,1,0);
+ (*kernal)(0,0,0) = -double(pT/M)*r/rz/phase;
+ (*kernal)(1,1,0) = conj((*kernal)(0,0,0));
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP0SplitFn.h
@@ -0,0 +1,276 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQPBarQQP0SplitFn_H
+#define Herwig_QtoQPBarQQP0SplitFn_H
+//
+// This is the declaration of the QtoQPBarQQP0SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQPBarQQP0SplitFn class implements the splitting function for \f$q\to \bar{q'} {qq'}_0\f$
+ *
+ * @see \ref QtoQPBarQQP0SplitFnInterfaces "The interfaces"
+ * defined for QtoQPBarQQP0SplitFn.
+ */
+class QtoQPBarQQP0SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQPBarQQP0SplitFn() : R02_(pow<3,1>(0.41*GeV)), n_(1), fixedAlphaS_(-1.)
+ {}
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=abs(ids[1]->id());
+ if(id1<id2) swap(id1,id2);
+ if(id1!=5||id2!=4) return false;
+ long idtest = id1*1000+id2*100+1 + (n_-1)*100000;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQPBarQQP0SplitFn & operator=(const QtoQPBarQQP0SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 R02_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQPBarQQP0SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.cc
@@ -0,0 +1,164 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQPBarQQP1SplitFn class.
+//
+
+#include "QtoQPBarQQP1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQPBarQQP1SplitFn::pOver_ = 6.;
+
+IBPtr QtoQPBarQQP1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQPBarQQP1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQPBarQQP1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(R02_,GeV*GeV2) << oenum(state_) << n_ << fixedAlphaS_;
+}
+
+void QtoQPBarQQP1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(R02_,GeV*GeV2) >> ienum(state_) >> n_ >> fixedAlphaS_;
+}
+
+void QtoQPBarQQP1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ R02_ = params_->radialWaveFunctionSquared(state_,n_);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQPBarQQP1SplitFn,Sudakov1to2FormFactor>
+ describeHerwigQtoQPBarQQP1SplitFn("Herwig::QtoQPBarQQP1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQPBarQQP1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQPBarQQP1SplitFn> documentation
+ ("The QtoQPBarQQP1SplitFn class implements the splitting function for q -> qbar' (qq')_1");
+
+ static Reference<QtoQPBarQQP1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQPBarQQP1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQPBarQQP1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQPBarQQP1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQPBarQQP1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQPBarQQP1SplitFn::state_, cc, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "cc",
+ "cc diquark",
+ cc);
+ static SwitchOption interfaceStatebb
+ (interfaceState,
+ "bb",
+ "bb diquark",
+ bb);
+ static SwitchOption interfaceStatebc
+ (interfaceState,
+ "bc",
+ "bc diquark",
+ bc);
+
+ static Parameter<QtoQPBarQQP1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQPBarQQP1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQPBarQQP1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 1./9.*aS2*R02_/sqr(a2)/M/Constants::pi;
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQPBarQQP1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ double W0 = z*(6.+sqr(a1*(1.-z))+2.*a1*(1.-z)*(z-2.)+ z*(3.*z-8.))/sqr(1.-a1*(1.-z));
+ double W1 = (3.+2.*sqr(a1)*(1.-z)*(z-3.)-9.*z+a1*(3.-2.*z+3.*sqr(z)))/(1.-a1*(1.-z));
+ double W2 = -12.*(1.-a1)*a1;
+ double ratio =(W0+r*W1+sqr(r)*W2)/pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQPBarQQP1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQPBarQQP1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQPBarQQP1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ double rz=sqrt(z);
+ double r2=sqrt(2.);
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,1,0) = -r2*phase*double(pT/M)*r/((1 - z)*rz);
+ (*kernal)(0,1,1) = (1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z)) - r*(1.+a1*(-2.+(-1.+2.*a1)*(1.-z))*(1.-z)+z)/((1 - z)*rz);
+ (*kernal)(0,1,2) = (r2*double(pT/M)*r*rz)/(phase*(1 - z));
+ (*kernal)(0,0,0) = r2*( (1.-z)*rz/(1.-a1*(1.-z)) + r*(1.-a1*(1.+z))/rz);
+ (*kernal)(0,0,1) = (-1.+2.*a1)*double(pT/M)*r/(phase*rz);
+ (*kernal)(0,0,2) = 0.;
+ (*kernal)(1,1,0) = 0.;
+ (*kernal)(1,1,1) = ((1.-2.*a1)*phase*double(pT/M)*r)/rz;
+ (*kernal)(1,1,2) = r2*((1.-z)*rz/(1.-a1*(1.-z)) + r*(1.-a1*(1.+z))/rz);
+ (*kernal)(1,0,0) = -r2*r*phase*double(pT/M)*rz/(1 - z);
+ (*kernal)(1,0,1) = r*(-1-a1*(-2.+(-1.+2.*a1)*(1.-z))*(1.-z) - z)/((1 - z)*rz) + (1.+(1.-a1)*(1.-z))*rz/(1.-a1*(1.-z));
+ (*kernal)(1,0,2) = r*r2*double(pT/M)/(phase*(1.-z)*rz);
+ return kernal;
+}
+
+
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPBarQQP1SplitFn.h
@@ -0,0 +1,287 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQPBarQQP1SplitFn_H
+#define Herwig_QtoQPBarQQP1SplitFn_H
+//
+// This is the declaration of the QtoQPBarQQP1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQPBarQQP1SplitFn class implements the splitting function for \f$q\to \bar{q'} {qq'}_1\f$
+ *
+ * @see \ref QtoQPBarQQP1SplitFnInterfaces "The interfaces"
+ * defined for QtoQPBarQQP1SplitFn.
+ */
+class QtoQPBarQQP1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQPBarQQP1SplitFn() : R02_(pow<3,1>(0.41*GeV)), state_(bc), n_(1), fixedAlphaS_(-1.)
+ {}
+
+
+public:
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=abs(ids[1]->id());
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=1+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=5) return false;
+ }
+ long idtest = id1*1000+id2*100+3;
+ if(abs(ids[2]->id()) != idtest) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQPBarQQP1SplitFn & operator=(const QtoQPBarQQP1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy3 R02_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+};
+
+}
+
+#endif /* Herwig_QtoQPBarQQP1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.cc
@@ -0,0 +1,279 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQPD2SplitFn class.
+//
+
+#include "QtoQPD2SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQPD2SplitFn::pOver_ = 100.;
+
+IBPtr QtoQPD2SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQPD2SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQPD2SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV*GeV2)) << oenum(state_) << n_ << sTheta_ << cTheta_ << fixedAlphaS_;
+}
+
+void QtoQPD2SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV*GeV2)) >> ienum(state_) >> n_ >> sTheta_ >> cTheta_ >> fixedAlphaS_;
+}
+
+void QtoQPD2SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<2>(state_,n_,0,2);
+ double theta = state_==bcbar ? params_->singletTripletMixing(n_,2) : 0.;
+ sTheta_ = sin(theta);
+ cTheta_ = cos(theta);
+}
+
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQPD2SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQPD2SplitFn("Herwig::QtoQPD2SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQPD2SplitFn::Init() {
+
+ static ClassDocumentation<QtoQPD2SplitFn> documentation
+ ("The QtoQPD2SplitFn class implements the branching q-> q' D2");
+
+ static Reference<QtoQPD2SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQPD2SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQPD2SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQPD2SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQPD2SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQPD2SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQPD2SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQPD2SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQPD2SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 8./405.*aS2*O1_/pow(a2,4)/M/sqr(M*M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+
+double QtoQPD2SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ // 1D2 coefficients
+ double W1D2[5];
+ W1D2[0] = z*(30 + 2*pow(a1,6)*pow(-1 + z,6) - 4*pow(a1,5)*pow(-1 + z,5)*(1 + 2*z) +
+ (-3 + z)*z*(24 + 5*(-3 + z)*z) + 6*pow(a1,4)*pow(-1 + z,4)*(-1 - 2*z + 4*pow(z,2)) -
+ 4*pow(a1,3)*(-2 + z)*pow(-1 + z,3)*(7 + z*(-4 + 5*z)) + 2*a1*(-1 + z)*(54 + z*(-102 + z*(73 + (-20 + z)*z))) +
+ pow(a1,2)*sqr(1.-z)*(134 + z*(-188 + z*(109 + 5*(-6 + z)*z))))/
+ (12.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),6));
+ W1D2[1] =(5 - 4*pow(a1,6)*pow(-1 + z,4)*(-15 + 11*z) + z*(-93 + 98*z - 30*pow(z,2)) +
+ 8*pow(a1,5)*pow(-1 + z,3)*(31 + z*(-46 + 11*z)) - pow(a1,4)*sqr(1.-z)*(-397 + z*(771 + z*(-319 + 41*z))) -
+ 4*a1*(7 + z*(-53 + z*(52 + 7*(-3 + z)*z))) + 4*pow(a1,3)*(-1 + z)*(77 + z*(-162 + z*(54 + 5*z*(2 + z)))) -
+ 2*pow(a1,2)*(-61 + z*(169 + z*(-58 + z*(-54 + z + 11*pow(z,2))))))/
+ (12.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),4));
+ W1D2[2] =((224 + a1*(-133 + 2*a1*(-155 + 16*a1*(5 + a1))))/(-1 + a1) + (32*pow(-1 + a1,2))/pow(1.-a1*(1.-z),3) +
+ (12*(-1 + a1)*(23 + 8*a1))/sqr(1.-a1*(1.-z)) + (468 - 48*a1*(1 + 6*a1))/(1.-a1*(1.-z)) -
+ (a1*(57 + 2*a1*(-81 + 8*a1*(5 + a1)))*z)/(-1 + a1))/(6.*pow(a1,3));
+ W1D2[3] = (16*(1 + a1*(4 - 13*z + a1*(-2*a1*(-3 + z)*(-1 + z) + pow(1 + z,2)))))/(3.*a1*(1.-a1*(1.-z)));
+ W1D2[4] = -128*(1.-a1)*a1/3.;
+ // 3D2 coefficients
+ double W3D2[5];
+ W3D2[0]=z*(90 + 6*pow(a1,6)*pow(-1 + z,6) - 12*pow(a1,5)*pow(-1 + z,5)*(-5 + 2*z) +
+ 18*pow(a1,4)*pow(-1 + z,4)*(15 + 2*(-5 + z)*z) + 3*(-3 + z)*z*(24 + 5*(-3 + z)*z) -
+ 12*pow(a1,3)*pow(-1 + z,3)*(-50 + z*(51 + z*(-15 + 2*z))) + 6*a1*(-1 + z)*(66 + z*(-126 + z*(87 + (-22 + z)*z))) +
+ pow(a1,2)*sqr(1.-z)*(690 + z*(-996 + z*(459 + z*(-66 + 7*z)))))/
+ (24.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),6));
+ W3D2[1] = (-16*pow(a1,6)*pow(-1 + z,5) + 20*pow(a1,5)*pow(-1 + z,4)*(1 + 3*z) -
+ 3*pow(a1,4)*pow(-1 + z,3)*(-75 + z*(26 + 57*z)) + 3*(5 + z*(-93 + 98*z - 30*pow(z,2))) +
+ 4*pow(a1,3)*sqr(1.-z)*(95 + z*(-75 + z*(-69 + 41*z))) - 12*a1*(-2 + z*(-52 + z*(90 + z*(-47 + 7*z)))) -
+ 2*pow(a1,2)*(-1 + z)*(-115 + z*(-84 + z*(306 + z*(-172 + 21*z)))))/
+ (24.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),4));
+ W3D2[2]= (33 - 135*z + a1*(51 + 32*pow(a1,5)*pow(-1 + z,3) - 90*z + 99*pow(z,2) -
+ 16*pow(a1,4)*sqr(1.-z)*(4 + (-11 + z)*z) + 6*pow(a1,3)*(-1 + z)*(-39 + z*(103 + (-49 + z)*z)) +
+ a1*(-191 + 37*z*(17 + 7*(-3 + z)*z)) + pow(a1,2)*(-31 + 3*z*(16 + z*(98 - z*(80 + 13*z))))))/
+ (12.*(-1 + a1)*pow(a1,2)*pow(1.-a1*(1.-z),3));
+ W3D2[3] = 4.*(27.-54./a1+16.*a1+60.*(1.-a1)/(a1*(1.-a1*(1.-z)))-z)/3.;
+ W3D2[4] = -128.*(1.-a1)*a1/3.;
+ // mixing coefficients
+ double Wmixed[5];
+ Wmixed[0] = (z*(-30 + 2*pow(a1,5)*pow(-1 + z,5) - 2*pow(a1,4)*pow(-1 + z,4)*(-3 + 4*z) -
+ (-3 + z)*z*(24 + 5*(-3 + z)*z) + 4*pow(a1,3)*pow(-1 + z,3)*(-6 + z*(-1 + 3*z)) -
+ 2*pow(a1,2)*sqr(1.-z)*(44 + z*(-44 + 5*z*(1 + z))) + a1*(-1 + z)*(-90 + z*(156 + z*(-91 + 3*z*(4 + z))))))/
+ (2.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),5));
+ Wmixed[1] = (-5 - 8*pow(a1,5)*(-2 + z)*pow(-1 + z,3) + z*(93 - 98*z + 30*pow(z,2)) +
+ 2*pow(a1,4)*sqr(1.-z)*(29 + z*(-50 + 33*z)) - pow(a1,3)*(-1 + z)*(-73 + z*(265 + z*(-311 + 95*z))) +
+ a1*(5 - z*(112 + z*(-93 + 2*z*(4 + z)))) + pow(a1,2)*(31 + z*(-159 + z*(329 + z*(-233 + 40*z)))))/
+ (2.*pow(-1 + a1,2)*pow(a1,2)*pow(1.-a1*(1.-z),3));
+ Wmixed[2] = (-11 + 45*z + a1*(8 - 8*pow(a1,4)*pow(-1 + z,3) + 20*z - 78*pow(z,2) + 2*pow(a1,3)*sqr(1.-z)*(7 + 5*z) +
+ 6*pow(a1,2)*(-1 + z)*(11 + z*(-13 + 14*z)) + a1*(47 + z*(-167 + 5*(47 - 15*z)*z))))/
+ ((-1 + a1)*pow(a1,2)*sqr(1.-a1*(1.-z)));
+ Wmixed[3] = 16*(1 - 2/a1 - 2*a1*(-1 + z) + 5*z);
+ Wmixed[4] = 0.;
+ double ratio = 0., rr=1.;
+ int itest = (abs(ids[2]->id())%100000)/10000;
+ double mix1 = itest==1 ? sTheta_ : cTheta_;
+ double mix2 = itest==1 ? cTheta_ : -sTheta_;
+ double ors=sqrt(1./6.);
+ for(unsigned int ix=0;ix<5;++ix) {
+ ratio += rr*(sqr(mix1)*W1D2[ix]+sqr(mix2)*W3D2[ix]+ors*mix1*mix2*Wmixed[ix]);
+ rr*=r;
+ }
+ ratio /= pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQPD2SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQPD2SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQPD2SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ double rz = sqrt(z);
+ double r6 = sqrt(6.);
+ double r23= sqrt(2./3.);
+ int itest = (abs(ids[2]->id())%100000)/10000;
+ double mix1 = itest==1 ? sTheta_ : cTheta_;
+ double mix2 = itest==1 ? cTheta_ : -sTheta_;
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin2)));
+ (*kernal)(0,0,0) =
+ mix1*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-1 + sqr(a1)*(4*r - 2*sqr(1.-z)) + 2*pow(a1,3)*r*(-1 + sqr(z)) + a1*(3 - 2*r - 5*z + 2*sqr(z)))/
+ ((-1 + a1)*a1*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -mix2*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-3 + 4*sqr(a1)*sqr(1.-z) + 8*pow(a1,4)*r*sqr(1.-z) + a1*(-1 + 4*r + 5*z - 4*sqr(z)) - 4*pow(a1,3)*r*(3 - 4*z + sqr(z)))/(r6*(-1 + a1)*a1*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,0,1) =
+ -0.5*(pT*mix1*r*phase*(1 + z - 3*sqr(z) + pow(z,3) + 8*pow(a1,5)*sqr(r)*pow(-1 + z,3)*(1 + z) - r*(3 + z) + 2*pow(a1,4)*r*sqr(1.-z)*(-5 + 6*z - sqr(z) + 8*r*(2 + z)) - a1*(8*sqr(r) + r*(-19 + 24*z - 5*sqr(z)) + sqr(1.-z)*(4 - z + sqr(z))) + pow(a1,3)*(-1 + z)*(48*sqr(r) - 2*pow(-1 + z,3) + r*(-33 + 57*z - 31*sqr(z) + 7*pow(z,3))) + sqr(a1)*(-16*sqr(r)*(-2 + z) + pow(-1 + z,3)*(-5 + 3*z) + r*(-39 + 83*z - 57*sqr(z) + 13*pow(z,3)))))/((-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)+
+ pT*mix2*r*phase*(16*pow(a1,6)*sqr(r)*pow(-1 + z,4) + 8*pow(a1,5)*r*pow(-1 + z,3)*(-1 + 6*r + z) + 4*pow(a1,4)*r*sqr(1.-z)*(-3 + 2*z + sqr(z) + 4*r*(2 + z)) + 3*(1 + z - 3*sqr(z) + pow(z,3) - r*(3 + z)) + a1*(16*sqr(r) - 3*r*(-5 + 2*z + 3*sqr(z)) + sqr(1.-z)*(-2 - 15*z + 5*sqr(z))) - sqr(a1)*(-1 + z)*(-48*sqr(r) + sqr(1.-z)*(-5 + 9*z) + r*(1 - 10*z + 9*sqr(z))) + pow(a1,3)*(-1 + z)*(4*pow(-1 + z,3) + 16*sqr(r)*(-2 + 3*z) + r*(3 - 17*z + 17*sqr(z) - 3*pow(z,3))))/(2.*r6*(-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,0,2) =
+ -((mix1*(12*a1*pow(r,3)*pow(1.-a1*(1.-z),5)*(-1 + a1 + a1*z) + r*pow(1.-a1*(1.-z),3)*(-1 + z)*(-1 + 4*sqr(a1)*(-1 + z) - 6*z + sqr(z) + a1*(5 - 8*z + 3*sqr(z))) + sqr(1.-z)*z*(-3 + pow(a1,3)*pow(-1 + z,3) + 3*z - sqr(z) - sqr(a1)*sqr(1.-z)*(1 + 2*z) + a1*(5 - 6*z + pow(z,3))) + sqr(r)*pow(1.-a1*(1.-z),3)*(-3*(1 + z) + 2*pow(a1,3)*sqr(1.-z)*(7 + z) + 2*a1*(10 - 11*z + sqr(z)) + sqr(a1)*(-31 + 51*z - 33*sqr(z) + 13*pow(z,3)))))/(r6*(-1 + a1)*a1*pow(1.-a1*(1.-z),3)*sqr(1.-z)*rz))+
+ mix2*(8*a1*pow(r,3)*pow(1.-a1*(1.-z),5) + r*sqr(1.-a1*(1.-z))*(-1 + z)*(-1 + a1*sqr(1.-z) - 6*z + sqr(z)) - sqr(1.-z)*z*(3 + sqr(a1)*sqr(1.-z) - 3*z + sqr(z) - 2*a1*(2 - 3*z + sqr(z))) + sqr(r)*pow(1.-a1*(1.-z),3)*(4*sqr(a1)*sqr(1.-z) - 3*(1 + z) + a1*(-1 - 4*z + 5*sqr(z))))/(2.*(-1 + a1)*a1*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,0,3) =
+ pT*mix1*r*(8*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(-1 + a1 + a1*z) + (-1 + z)*z*(-3 + a1 + 2*sqr(a1)*sqr(1.-z) + z - a1*sqr(z)) + r*sqr(1.-a1*(1.-z))*(-1 - 3*z + 2*sqr(a1)*(-3 + 2*z + sqr(z)) + a1*(7 - 12*z + 5*sqr(z))))/(2.*(-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)+
+ pT*mix2*r*(16*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(-1 - 2*a1*(-1 + z) + sqr(a1)*(-1 + z)) + r*sqr(1.-a1*(1.-z))*(3 - 12*sqr(a1)*sqr(1.-z) + 8*pow(a1,3)*sqr(1.-z) + 9*z + a1*(1 + 6*z - 7*sqr(z))) - (-1 + z)*z*(3*(-3 + z) + a1*(9 - 10*z + sqr(z))))/(2.*r6*(-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,0,4) = mix1*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-2*a1*r + 4*sqr(a1)*r - z + a1*(-1 + z)*z + 2*pow(a1,3)*r*(-1 + sqr(z)))/((-1 + a1)*a1*pow(phase,2)*(1.-a1*(1.-z))*sqr(1.-z)*rz) +
+ mix2*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-16*sqr(a1)*r*(-1 + z) + 8*pow(a1,4)*r*sqr(1.-z) + 3*z + a1*(-4*r + z - sqr(z)) - 4*pow(a1,3)*r*(5 - 8*z + 3*sqr(z)))/(r6*(-1 + a1)*a1*pow(phase,2)*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,1,0) =
+ -pT*mix1*r*phase*(2*a1*sqr(r)*pow(1.-a1*(1.-z),3) + sqr(1.-z)*z + r*(-1 + z)*(-1 + 4*a1 + 2*pow(a1,3)*sqr(1.-z) + sqr(a1)*(-5 + 4*z + sqr(z))))/((-1 + a1)*a1*M*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -pT*mix2*r*phase*(-((3 + a1*(-3 + z))*sqr(1.-z)*z) + r*sqr(1.-a1*(1.-z))*(-1 + z)*(3 + a1 + 4*sqr(a1)*(-1 + z) - 9*a1*z) + 4*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(1 + a1 + 2*sqr(a1)*(-1 + z) - 3*a1*z))/(r6*(-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,1,1) =
+ -0.5*mix1*(8*a1*pow(r,3)*pow(1.-a1*(1.-z),5) + (2 + 2*a1*(-1 + z) - z)*pow(-1 + z,3)*z + r*sqr(1.-a1*(1.-z))*sqr(1.-z)*(-1 + 2*sqr(a1)*(-1 + z) + z + a1*(3 + 5*z)) + sqr(r)*pow(1.-a1*(1.-z),3)*(-1 + z)*(-3 + 10*sqr(a1)*(-1 + z) + a1*(13 + 5*z)))/((-1 + a1)*a1*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -0.5*mix2*(r*pow(1.-a1*(1.-z),3)*sqr(1.-z)*(3 + a1 + 4*sqr(a1)*(-1 + z) - 3*z - 13*a1*z) + 16*a1*pow(r,3)*pow(1.-a1*(1.-z),5)*(1 + sqr(a1)*(-1 + z) - 2*a1*z) - pow(-1 + z,3)*z*(6 - 6*sqr(a1)*(-1 + z) - 3*z + a1*(-12 + 9*z + sqr(z))) + sqr(r)*pow(1.-a1*(1.-z),3)*(9*(-1 + z) - 4*pow(a1,3)*pow(-1 + z,3) + 8*pow(a1,4)*pow(-1 + z,3) - 6*a1*(-1 + sqr(z)) + sqr(a1)*(7 - 21*z + 45*sqr(z) - 31*pow(z,3))))/(r6*(-1 + a1)*a1*pow(1.-a1*(1.-z),3)*sqr(1.-z)*rz);
+ (*kernal)(0,1,2) =
+ pT*mix1*r*((-3*r + sqr(1.-z))*(-1 + z) + 12*pow(a1,4)*sqr(r)*pow(-1 + z,3) + 2*pow(a1,3)*r*sqr(1.-z)*(-7 + 18*r + 7*z) + a1*(12*sqr(r) - (-5 + z)*sqr(1.-z) - 2*r*(10 - 11*z + sqr(z))) + sqr(a1)*(-1 + z)*(36*sqr(r) + 4*sqr(1.-z) + r*(-31 + 30*z + sqr(z))))/(r6*(-1 + a1)*a1*M*phase*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -0.5*pT*mix2*r*((-3*r + sqr(1.-z))*(-1 + z) + 8*pow(a1,5)*sqr(r)*pow(-1 + z,3)*(1 + z) + pow(a1,3)*r*(-1 + z)*(-9 + 48*r + 7*z - 3*sqr(z) + 5*pow(z,3)) + 4*pow(a1,4)*r*sqr(1.-z)*(-1 + sqr(z) + 4*r*(2 + z)) - a1*(8*sqr(r) + r*(5 - 6*z + sqr(z)) + sqr(1.-z)*(-2 - z + sqr(z))) + sqr(a1)*(-16*sqr(r)*(-2 + z) + pow(-1 + z,3)*(1 + 3*z) + r*(-3 + 5*z - 9*sqr(z) + 7*pow(z,3))))/((-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,1,3) =
+ mix1*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(1 + 8*sqr(a1)*r*(-1 + z) - z + a1*(-6 + 8*r + 6*z))/(2.*(-1 + a1)*a1*pow(phase,2)*sqr(1.-z)*rz)-
+ 0.5*mix2*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(3 + 16*pow(a1,4)*r*sqr(1.-z) - 3*z - 4*sqr(a1)*(-3 + z)*(-1 + 4*r + z) + 8*pow(a1,3)*(-1 + z)*(-1 + 6*r + z) + a1*(1 - 16*r - 6*z + 5*sqr(z)))/(r6*(-1 + a1)*a1*pow(phase,2)*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(0,1,4) =
+ -2*pT*mix1*sqr(r)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)/((-1 + a1)*pow(phase,3)*M*sqr(1.-z)*rz)+
+ 2*r23*(-1 + 2*a1)*pT*mix2*sqr(r)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)/((-1 + a1)*pow(phase,3)*M*sqr(1.-z)*rz);
+ (*kernal)(1,0,0) =
+ -2.*phase*sqr(phase)*double(pT/M)*mix1*sqr(r)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)/((-1 + a1)*sqr(1.-z)*rz)+
+ 2*r23*(-1 + 2*a1)*pow(phase,3)*pT*mix2*sqr(r)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)/((-1 + a1)*M*sqr(1.-z)*rz);
+ (*kernal)(1,0,1) =
+ -0.5*(mix1*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(1 + 8*sqr(a1)*r*(-1 + z) - z + a1*(-6 + 8*r + 6*z)))/((-1 + a1)*a1*sqr(1.-z)*rz)+
+ mix2*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(3 + 16*pow(a1,4)*r*sqr(1.-z) - 3*z - 4*sqr(a1)*(-3 + z)*(-1 + 4*r + z) + 8*pow(a1,3)*(-1 + z)*(-1 + 6*r + z) + a1*(1 - 16*r - 6*z + 5*sqr(z)))/(2.*r6*(-1 + a1)*a1*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,0,2) =
+ pT*mix1*r*phase*((-3*r + sqr(1.-z))*(-1 + z) + 12*pow(a1,4)*sqr(r)*pow(-1 + z,3) + 2*pow(a1,3)*r*sqr(1.-z)*(-7 + 18*r + 7*z) + a1*(12*sqr(r) - (-5 + z)*sqr(1.-z) - 2*r*(10 - 11*z + sqr(z))) + sqr(a1)*(-1 + z)*(36*sqr(r) + 4*sqr(1.-z) + r*(-31 + 30*z + sqr(z))))/(r6*(-1 + a1)*a1*M*(1.-a1*(1.-z))*sqr(1.-z)*rz)-
+ 0.5*pT*mix2*r*phase*((-3*r + sqr(1.-z))*(-1 + z) + 8*pow(a1,5)*sqr(r)*pow(-1 + z,3)*(1 + z) + pow(a1,3)*r*(-1 + z)*(-9 + 48*r + 7*z - 3*sqr(z) + 5*pow(z,3)) + 4*pow(a1,4)*r*sqr(1.-z)*(-1 + sqr(z) + 4*r*(2 + z)) - a1*(8*sqr(r) + r*(5 - 6*z + sqr(z)) + sqr(1.-z)*(-2 - z + sqr(z))) + sqr(a1)*(-16*sqr(r)*(-2 + z) + pow(-1 + z,3)*(1 + 3*z) + r*(-3 + 5*z - 9*sqr(z) + 7*pow(z,3))))/((-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)
+;
+ (*kernal)(1,0,3) =
+ mix1*(8*a1*pow(r,3)*pow(1.-a1*(1.-z),5) + (2 + 2*a1*(-1 + z) - z)*pow(-1 + z,3)*z + r*sqr(1.-a1*(1.-z))*sqr(1.-z)*(-1 + 2*sqr(a1)*(-1 + z) + z + a1*(3 + 5*z)) + sqr(r)*pow(1.-a1*(1.-z),3)*(-1 + z)*(-3 + 10*sqr(a1)*(-1 + z) + a1*(13 + 5*z)))/(2.*(-1 + a1)*a1*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)+
+ mix2*(r*pow(1.-a1*(1.-z),3)*sqr(1.-z)*(3 + a1 + 4*sqr(a1)*(-1 + z) - 3*z - 13*a1*z) + 16*a1*pow(r,3)*pow(1.-a1*(1.-z),5)*(1 + sqr(a1)*(-1 + z) - 2*a1*z) - pow(-1 + z,3)*z*(6 - 6*sqr(a1)*(-1 + z) - 3*z + a1*(-12 + 9*z + sqr(z))) + sqr(r)*pow(1.-a1*(1.-z),3)*(9*(-1 + z) - 4*pow(a1,3)*pow(-1 + z,3) + 8*pow(a1,4)*pow(-1 + z,3) - 6*a1*(-1 + sqr(z)) + sqr(a1)*(7 - 21*z + 45*sqr(z) - 31*pow(z,3))))/(2.*r6*(-1 + a1)*a1*pow(1.-a1*(1.-z),3)*sqr(1.-z)*rz);
+ (*kernal)(1,0,4) =
+ -pT*mix1*r*(2*a1*sqr(r)*pow(1.-a1*(1.-z),3) + sqr(1.-z)*z + r*(-1 + z)*(-1 + 4*a1 + 2*pow(a1,3)*sqr(1.-z) + sqr(a1)*(-5 + 4*z + sqr(z))))/((-1 + a1)*a1*M*phase*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -pT*mix2*r*(-((3 + a1*(-3 + z))*sqr(1.-z)*z) + r*sqr(1.-a1*(1.-z))*(-1 + z)*(3 + a1 + 4*sqr(a1)*(-1 + z) - 9*a1*z) + 4*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(1 + a1 + 2*sqr(a1)*(-1 + z) - 3*a1*z))/
+ (r6*(-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,1,0) =
+ -mix1*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-2*a1*r + 4*sqr(a1)*r - z + a1*(-1 + z)*z + 2*pow(a1,3)*r*(-1 + sqr(z)))/((-1 + a1)*a1*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ -mix2*r*pow(phase,2)*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-16*sqr(a1)*r*(-1 + z) + 8*pow(a1,4)*r*sqr(1.-z) + 3*z + a1*(-4*r + z - sqr(z)) - 4*pow(a1,3)*r*(5 - 8*z + 3*sqr(z)))/(r6*(-1 + a1)*a1*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,1,1) =
+ pT*mix1*r*phase*(8*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(-1 + a1 + a1*z) + (-1 + z)*z*(-3 + a1 + 2*sqr(a1)*sqr(1.-z) + z - a1*sqr(z)) + r*sqr(1.-a1*(1.-z))*(-1 - 3*z + 2*sqr(a1)*(-3 + 2*z + sqr(z)) + a1*(7 - 12*z + 5*sqr(z))))/(2.*(-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)+
+ pT*mix2*r*phase*(16*a1*sqr(r)*pow(1.-a1*(1.-z),3)*(-1 - 2*a1*(-1 + z) + sqr(a1)*(-1 + z)) + r*sqr(1.-a1*(1.-z))*(3 - 12*sqr(a1)*sqr(1.-z) + 8*pow(a1,3)*sqr(1.-z) + 9*z + a1*(1 + 6*z - 7*sqr(z))) - (-1 + z)*z*(3*(-3 + z) + a1*(9 - 10*z + sqr(z))))/(2.*r6*(-1 + a1)*a1*M*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,1,2) =
+ mix1*(12*a1*pow(r,3)*pow(1.-a1*(1.-z),5)*(-1 + a1 + a1*z) + r*pow(1.-a1*(1.-z),3)*(-1 + z)*(-1 + 4*sqr(a1)*(-1 + z) - 6*z + sqr(z) + a1*(5 - 8*z + 3*sqr(z))) + sqr(1.-z)*z*(-3 + pow(a1,3)*pow(-1 + z,3) + 3*z - sqr(z) - sqr(a1)*sqr(1.-z)*(1 + 2*z) + a1*(5 - 6*z + pow(z,3))) + sqr(r)*pow(1.-a1*(1.-z),3)*(-3*(1 + z) + 2*pow(a1,3)*sqr(1.-z)*(7 + z) + 2*a1*(10 - 11*z + sqr(z)) + sqr(a1)*(-31 + 51*z - 33*sqr(z) + 13*pow(z,3))))/(r6*(-1 + a1)*a1*pow(1.-a1*(1.-z),3)*sqr(1.-z)*rz)
+ -0.5*mix2*(8*a1*pow(r,3)*pow(1.-a1*(1.-z),5) + r*sqr(1.-a1*(1.-z))*(-1 + z)*(-1 + a1*sqr(1.-z) - 6*z + sqr(z)) - sqr(1.-z)*z*(3 + sqr(a1)*sqr(1.-z) - 3*z + sqr(z) - 2*a1*(2 - 3*z + sqr(z))) + sqr(r)*pow(1.-a1*(1.-z),3)*(4*sqr(a1)*sqr(1.-z) - 3*(1 + z) + a1*(-1 - 4*z + 5*sqr(z))))/((-1 + a1)*a1*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,1,3) =
+ -0.5*pT*mix1*r*(1 + z - 3*sqr(z) + pow(z,3) + 8*pow(a1,5)*sqr(r)*pow(-1 + z,3)*(1 + z) - r*(3 + z) + 2*pow(a1,4)*r*sqr(1.-z)*(-5 + 6*z - sqr(z) + 8*r*(2 + z)) - a1*(8*sqr(r) + r*(-19 + 24*z - 5*sqr(z)) + sqr(1.-z)*(4 - z + sqr(z))) + pow(a1,3)*(-1 + z)*(48*sqr(r) - 2*pow(-1 + z,3) + r*(-33 + 57*z - 31*sqr(z) + 7*pow(z,3))) + sqr(a1)*(-16*sqr(r)*(-2 + z) + pow(-1 + z,3)*(-5 + 3*z) + r*(-39 + 83*z - 57*sqr(z) + 13*pow(z,3))))/((-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ +pT*mix2*r*(16*pow(a1,6)*sqr(r)*pow(-1 + z,4) + 8*pow(a1,5)*r*pow(-1 + z,3)*(-1 + 6*r + z) + 4*pow(a1,4)*r*sqr(1.-z)*(-3 + 2*z + sqr(z) + 4*r*(2 + z)) + 3*(1 + z - 3*sqr(z) + pow(z,3) - r*(3 + z)) + a1*(16*sqr(r) - 3*r*(-5 + 2*z + 3*sqr(z)) + sqr(1.-z)*(-2 - 15*z + 5*sqr(z))) - sqr(a1)*(-1 + z)*(-48*sqr(r) + sqr(1.-z)*(-5 + 9*z) + r*(1 - 10*z + 9*sqr(z))) + pow(a1,3)*(-1 + z)*(4*pow(-1 + z,3) + 16*sqr(r)*(-2 + 3*z) + r*(3 - 17*z + 17*sqr(z) - 3*pow(z,3))))/(2.*r6*(-1 + a1)*a1*M*phase*sqr(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ (*kernal)(1,1,4) =
+ -mix1*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-1 + sqr(a1)*(4*r - 2*sqr(1.-z)) + 2*pow(a1,3)*r*(-1 + sqr(z)) + a1*(3 - 2*r - 5*z + 2*sqr(z)))/
+ ((-1 + a1)*a1*pow(phase,2)*(1.-a1*(1.-z))*sqr(1.-z)*rz)
+ +mix2*r*(r*sqr(1.-a1*(1.-z)) + (-1 + z)*z)*(-3 + 4*sqr(a1)*sqr(1.-z) + 8*pow(a1,4)*r*sqr(1.-z) + a1*(-1 + 4*r + 5*z - 4*sqr(z)) - 4*pow(a1,3)*r*(3 - 4*z + sqr(z)))/
+ (r6*(-1 + a1)*a1*pow(phase,2)*(1.-a1*(1.-z))*sqr(1.-z)*rz);
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPD2SplitFn.h
@@ -0,0 +1,304 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQPD2SplitFn_H
+#define Herwig_QtoQPD2SplitFn_H
+//
+// This is the declaration of the QtoQPD2SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQPD2SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(D_2)\f$,
+ * in this case there is mixing between the $\phanton{A}^1D_2$ and $\phanton{A}^3D_2$ states
+ *
+ * @see \ref QtoQPD2SplitFnInterfaces "The interfaces"
+ * defined for QtoQPD2SplitFn.
+ */
+class QtoQPD2SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQPD2SplitFn() : O1_(0.131*GeV*pow<3,1>(GeV2)), state_(bcbar), n_(1), theta_(34.4),
+ sTheta_(0.564967), cTheta_(0.825113), fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+5 + (n_-1)*100000;
+ if(((abs(ids[2]->id()) != idtest + 10000) &&
+ (abs(ids[2]->id()) != idtest + 20000) )) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQPD2SplitFn & operator=(const QtoQPD2SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy7 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Mixing angle between the $\phanton{A}^1P_1$ and $\phanton{A}^3P_1$ states
+ *
+ */
+ double theta_;
+
+ /**
+ * Sin of the mixing angle
+ */
+ double sTheta_;
+
+ /**
+ * Sin of the mixing angle
+ */
+ double cTheta_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQPD2SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.cc b/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.cc
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.cc
@@ -0,0 +1,289 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the QtoQPP1SplitFn class.
+//
+
+#include "QtoQPP1SplitFn.h"
+#include "ThePEG/Interface/ClassDocumentation.h"
+#include "ThePEG/Interface/Reference.h"
+#include "ThePEG/Interface/Parameter.h"
+#include "ThePEG/Interface/Switch.h"
+#include "ThePEG/EventRecord/Particle.h"
+#include "ThePEG/Repository/UseRandom.h"
+#include "ThePEG/Repository/EventGenerator.h"
+#include "ThePEG/Utilities/DescribeClass.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/Utilities/EnumIO.h"
+
+using namespace Herwig;
+
+const double QtoQPP1SplitFn::pOver_ = 2.;
+
+IBPtr QtoQPP1SplitFn::clone() const {
+ return new_ptr(*this);
+}
+
+IBPtr QtoQPP1SplitFn::fullclone() const {
+ return new_ptr(*this);
+}
+
+void QtoQPP1SplitFn::persistentOutput(PersistentOStream & os) const {
+ os << params_ << ounit(O1_,GeV*sqr(GeV2)) << oenum(state_) << n_ << theta_ << sTheta_ << cTheta_ << fixedAlphaS_;
+}
+
+void QtoQPP1SplitFn::persistentInput(PersistentIStream & is, int) {
+ is >> params_ >> iunit(O1_,GeV*sqr(GeV2)) >> ienum(state_) >> n_ >> theta_ >> sTheta_ >> cTheta_ >> fixedAlphaS_;
+}
+
+void QtoQPP1SplitFn::doinit() {
+ Sudakov1to2FormFactor::doinit();
+ O1_ = params_->singletMEProduction<1>(state_,n_,0,1);
+ double theta = state_==bcbar ? params_->singletTripletMixing(n_,1) : 0.;
+ sTheta_ = sin(theta);
+ cTheta_ = cos(theta);
+}
+
+// The following static variable is needed for the type
+// description system in ThePEG.
+DescribeClass<QtoQPP1SplitFn,Sudakov1to2FormFactor>
+describeHerwigQtoQPP1SplitFn("Herwig::QtoQPP1SplitFn", "HwOniumParameters.so HwOniumShower.so");
+
+void QtoQPP1SplitFn::Init() {
+
+ static ClassDocumentation<QtoQPP1SplitFn> documentation
+ ("The QtoQPP1SplitFn class implements the branching q-> q' P1");
+
+ static Reference<QtoQPP1SplitFn,OniumParameters> interfaceParameters
+ ("Parameters",
+ "Quarkonium parameters",
+ &QtoQPP1SplitFn::params_, false, false, true, false, false);
+
+ static Parameter<QtoQPP1SplitFn,double> interfacefixedAlphaS_
+ ("FixedAlphaS",
+ "Fixed value of alpha_S to use, if negative running alpha_S is used.",
+ &QtoQPP1SplitFn::fixedAlphaS_, -1.0, -10.0, 10.0,
+ false, false, Interface::limited);
+
+ static Switch<QtoQPP1SplitFn,OniumState> interfaceState
+ ("State",
+ "The type of onium state",
+ &QtoQPP1SplitFn::state_, ccbar, false, false);
+ static SwitchOption interfaceStateccbar
+ (interfaceState,
+ "ccbar",
+ "Charmonium state",
+ ccbar);
+ static SwitchOption interfaceStatebbbar
+ (interfaceState,
+ "bbbar",
+ "Bottomonium state",
+ bbbar);
+ static SwitchOption interfaceStatebcbar
+ (interfaceState,
+ "bcbar",
+ "B_c state",
+ bcbar);
+
+ static Parameter<QtoQPP1SplitFn,unsigned int> interfacePrincipalQuantumNumber
+ ("PrincipalQuantumNumber",
+ "The principle quantum number of the states",
+ &QtoQPP1SplitFn::n_, 1, 1, 10,
+ false, false, Interface::limited);
+
+}
+
+void QtoQPP1SplitFn::guesstz(Energy2 t1,unsigned int iopt,
+ const IdList &ids,
+ double enhance,bool ident,
+ double detune,
+ Energy2 &t_main, double &z_main) {
+ unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
+ double lower = integOverP(zLimits().first ,ids,pdfopt);
+ double upper = integOverP(zLimits().second,ids,pdfopt);
+ Energy M = ids[0]->mass()+ids[1]->mass();
+ double a2 = ids[1]->mass()/M;
+ double aS2 = fixedAlphaS_ < 0 ? sqr(alpha()->overestimateValue()) : sqr(fixedAlphaS_);
+ Energy2 pre = 32./243.*aS2*O1_/pow(a2,4)/M/sqr(M);
+ Energy2 c = (upper - lower) * colourFactor() * pre * enhance * detune;
+ double r = UseRandom::rnd();
+ assert(iopt<=2);
+ if(iopt==1) {
+ c *= pdfMax();
+ //symmetry of FS gluon splitting
+ if(ident) c*= 2;
+ }
+ else if(iopt==2) c*=-1.;
+ // guess t
+ t_main = t1/(1.-t1/c*log(r));
+ // guess z
+ z_main = invIntegOverP(lower + UseRandom::rnd()*(upper - lower),ids,pdfopt);
+}
+
+double QtoQPP1SplitFn::ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M;
+ double r = sqr(M)/t;
+ // 1P1 coefficients
+ double W1P1[4];
+ W1P1[0] = z*(6.-8.*z+3.*sqr(z)
+ +a1*(+2.*(-4.+7.*z-4.*sqr(z)+pow(z,3))
+ +sqr(1.-z)*a1*((-1.+3*sqr(z))+a1*(1.-z)*(2.*(1.+z) +a1*(1.-z)))))/
+ (16.*sqr(a1)*pow(1.-a1*(1.-z),4));
+ W1P1[1] = (3.-9.*z
+ +a1*(+2.*(-8.+9.*z+5.*sqr(z))
+ +a1*(55 - 123*z + 73*sqr(z) - 13*pow(z,3)
+ +2.*a1*(-37 + 101*z - 83*sqr(z) + 19*pow(z,3)
+ -4.*a1*sqr(1.-z)*(-4.+3*z)))))/(16.*sqr(a1)*pow(1 + a1*(-1 + z),2));
+ W1P1[2] = -0.5*((-1 + a1)*(-1 + 2*a1*(-2 + 5*z) + 2*pow(a1,3)* (2 - 3*z + sqr(z)) - sqr(a1)* (-1 + 2*z + sqr(z))))/(a1*(1.-a1*(1.-z)));
+ W1P1[3] = 4*sqr(1.-a1)*a1;
+ // 3P1 coefficients
+ double W3P1[4];
+ W3P1[0]=z*(6 + sqr(a1)*(-5 + z)*(-3 + z)*sqr(1.-z) - 2*pow(a1,3)*(-3 + z)*pow(-1 + z,3) + pow(a1,4)*pow(-1 + z,4) +
+ z*(-8 + 3*z) + 2*a1*(-1 + z)*(8 + (-7 + z)*z))/(8.*sqr(a1)*pow(1 + a1*(-1 + z),4));
+ W3P1[1]=(3 - 9*z + a1*(4 - 2*pow(a1,3)*pow(-1 + z,3) + 10*(-1 + z)*z + 2*sqr(a1)*sqr(1.-z)*(3 + z) - a1*(-1 + z)*(-15 + z*(20 + z))))/
+ (8.*sqr(a1)*sqr(1.-a1*(1.-z)));
+ W3P1[2]=((-1 + a1)*(2 + a1*(5 - 11*z + a1*(-5 + 2*a1*(-1 + z) - (-8 + z)*z))))/(2.*a1*(1 + a1*(-1 + z)));
+ W3P1[3]=4.*sqr(1.-a1)*a1;
+ // mixing coefficients
+ double Wmixed[4];
+ Wmixed[0] = z*(-6.+(8.-3.*z)*z
+ +a1*(6 + z*(-8 + z + sqr(z))
+ +a1*sqr(1.-z)*((1.-2.*z)-a1*(1.-z))))/
+ (4.*sqr(a1)*pow(1.-a1*(1.-z),3));
+ Wmixed[1] = (-3.+9.*z
+ +a1*(- 2.*(1.+z)*(-3.+5.*z)
+ + a1*(5.+z*(-25.+(35.-11.*z)*z)
+ -4.*a1*(1.-z)*(2*(2.+z*(-3.+2*z))
+ +a1*(1.-z)*(-2.+z)))))/(4.*sqr(a1)*sqr(1-a1*(1.-z)));
+ Wmixed[2] = 2./a1*(1. - 2.*a1*(1.+z) + 3.*sqr(a1)*z + pow(a1,3)*(1.-z));
+
+
+ Wmixed[3] = 0.;
+ double ratio = 0., rr=1.;
+ int itest = (abs(ids[2]->id())%100000)/10000;
+ double mix1 = itest==1 ? sTheta_ : cTheta_;
+ double mix2 = itest==1 ? cTheta_ : -sTheta_;
+ double ort=sqrt(0.5);
+ for(unsigned int ix=0;ix<4;++ix) {
+ ratio += rr*(sqr(mix1)*W1P1[ix]+sqr(mix2)*W3P1[ix]+ort*mix1*mix2*Wmixed[ix]);
+ rr*=r;
+ }
+ ratio /= pOver_;
+ if(ratio>1.) cerr << "ratio greater than 1 in QtoQPP1SplitFn " << ratio << "\n";
+ if(ratio<0.) cerr << "ratio negative in QtoQPP1SplitFn " << ratio << "\n";
+ return ratio;
+}
+
+DecayMEPtr QtoQPP1SplitFn::matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool) {
+ Energy m1 = ids[0]->mass();
+ Energy M = m1 + ids[1]->mass();
+ double a1 = m1/M, a2=1-a1;
+ double r = sqr(M)/t;
+ Complex ii(0.,1.);
+ Complex phase = exp(ii*phi);
+ Energy pT = sqrt(z*(1.-z)*t+sqr(M)*(sqr(a1)*z*(1.-z)-sqr(a2)*(1.-z)-z));
+ double rz = sqrt(z);
+ double r2 = sqrt(2.);
+ int itest = (abs(ids[2]->id())%100000)/10000;
+ double mix1 = itest==1 ? sTheta_ : cTheta_;
+ double mix2 = itest==1 ? cTheta_ : -sTheta_;
+ // calculate the kernal
+ DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ (*kernal)(0,0,0) = ii*phase*double(pT/M)*r/(1.-z)/rz/r2/a1*
+ (-mix1 *(r*a1*(-1.+a1*(1.+z))
+ -0.5*(1.+2.*sqr(a1)*sqr(1.-z)+a1*(-3.+5.*z-2.*sqr(z)))/(1.-a1*(1.-z)))
+ +mix2/r2*(r*a1*(1.+a1*(1.-z)-2.*sqr(a1)*(1.-z))
+ +(-1.+sqr(a1)*sqr(1.-z)+a1*(1.-z)*z)/(1.-a1*(1.-z))));
+ (*kernal)(0,0,1) = ii/rz/a1*
+ (mix1*(sqr(r)*a1*(1.-a1*(1.-z))*(1.-a1*(1.+z))/(1.-z)
+ + 0.25*z*(-2.+a1+sqr(a1)*sqr(1.-z)+z-a1*sqr(z))/sqr(1.-a1*(1.-z))
+ - 0.25*r*(-1.-z+a1*(1.-z)*(5.-4.*a1-3.*z))/(1.-z))
+ +mix2/r2*(+ sqr(r)*a1*sqr(1.-a1*(1.-z))/(1.-z)
+ + 0.5*r*(-1.+a1*sqr(1.-z)-z)/(1.-z)
+ + 0.5*(2.-a1*(1.-z)-z)*z/(1.-a1*(1.-z))));
+ (*kernal)(0,0,2) = ii*double(pT/M)/phase*r/rz/r2/(1.-z)/a1*
+ (mix1 *(-0.5*(1.+a1*(1.-z))*z/(1.-a1*(1.-z))-r*a1*(1.-a1*(1.+z)))-
+ mix2/r2*(r*a1*(1.+a1*(-3.+2*a1)*(1.-z))-z/(1.-a1*(1.-z))));
+ (*kernal)(0,1,0) = ii/rz/a1/r2*
+ (mix1*(- sqr(r)*a1*sqr(1.-a1*(1.-z))/(1.-z)
+ - 0.5*(1.-z)*z/(1.-a1*(1.-z))
+ + 0.5*r*(-1.+a1*(3.-2*a1*(1.-z)+z)))
+ +mix2/r2*(r*(1.-sqr(a1)*(1.-z)-2.*a1*z) + (1.-a1)*(1.-z)*z/sqr(1.-a1*(1.-z))
+ -sqr(r)*a1*(1.-a1*(1.-z))*(1.+a1-2.*sqr(a1)*(1.-z)-3.*a1*z)/(1.-z)));
+ (*kernal)(0,1,1) = ii*r*double(pT/M)/phase/rz/a1*
+ (mix1 *(0.25*(1.-4.*a1)+r*a1*(1.-a1*(1.-z))/(1.-z))-
+ mix2/r2*(1.-a1*(1.+z))*(0.5/(1.-a1*(1.-z))-r*a1/(1.-z)));
+ (*kernal)(0,1,2) = ii/sqr(phase)*r/rz/r2*
+ (mix1*(r*sqr(1.-a1*(1.-z))/(1.-z)-z)
+ -mix2/r2*(1.-2.*a1)*(-r*sqr(1.-a1*(1.-z))/(1.-z)+z));
+ (*kernal)(1,0,0) = -sqr(phase)*ii*r/rz/r2*
+ ( mix1 *(r*sqr(1.-a1*(1.-z))/(1.-z)-z) +
+ mix2/r2*(1.-2*a1)*(r*sqr(1.-a1*(1.-z))/(1.-z)-z));
+ (*kernal)(1,0,1) = ii*phase*double(pT/M)*r/rz/a1*
+ (mix1*((-0.25*(-1 + 4*a1)) - r*a1*(1.-a1*(1.-z))/((-1 + z)))-
+ mix2*(1.-a1*(1.+z))/r2*(0.5/(1.-a1*(1.-z))- r*a1/(1.-z)));
+ (*kernal)(1,0,2) = ii/rz/a1/r2*
+ (mix1 *(+sqr(r)*a1*sqr(1.-a1*(1.-z))/(1.-z)
+ +0.5*(1.-z)*z/(1.-a1*(1.-z))
+ -0.5*r*(-1.+a1*(3.-2.*a1*(1.-z)+z)))
+ -mix2/r2*(r*(1.+sqr(a1)*(-1 + z)-2.*a1*z)
+ +(1.-a1)*(1.-z)*z/sqr(1.-a1*(1.-z))
+ +sqr(r)*a1*(1.-a1*(1.-z))*(1 + a1 + 2*sqr(a1)*(-1 + z) - 3*a1*z)/((-1 + z))));
+ (*kernal)(1,1,0) = ii*phase*pT/M*r/rz/(1.-z)/r2*
+ (-mix1/a1*(0.5*(1.+a1*(1.-z))*z/(1.-a1*(1.-z))+r*a1*(1.-a1*(1.+z)))
+ +mix2/r2*(r*(-1.+3.*a1*(1.-z)-2.*sqr(a1)*(1.-z))+z/(a1*(1.-a1*(1.-z)))));
+ (*kernal)(1,1,1) = ii/rz/a1*
+ (mix1*(-sqr(r)*a1*(1.-a1*(1.-z))*(1.-a1*(1.+z))/(1.-z)
+ -0.25*z*(-2.+a1+sqr(a1)*sqr(1.-z)+z-a1*sqr(z))/sqr(1.-a1*(1.-z))
+ +0.25*r*(-1.-z+a1*(1.-z)*(5.-4.*a1-3.*z))/(1.-z))
+ -mix2/r2*(sqr(r)*a1*sqr(1.-a1*(1.-z))/(1.-z)
+ + 0.5*r*(-1.+a1*sqr(1.-z)-z)/(1.-z)
+ + 0.5*(2.-a1*(1.-z)-z)*z/(1.-a1*(1.-z))));
+ (*kernal)(1,1,2) = ii*double(pT/M)/phase*r/rz/(1.-z)/r2/a1*
+ (mix1*(0.5*(1.-a1*(3.-2.*a1*(1.-z)-2.*z)*(1.-z))/(1.-a1*(1.-z))
+ + a1*r*(1.-a1*(1.+z)))
+ +mix2/r2*(a1*r*(1.+a1*(1.-2.*a1)*(1.-z))
+ +(-1 + a1*(a1*(-1 + z) - z)*(-1 + z))/(1.-a1*(1.-z))));
+ // testing code
+ // DecayMEPtr test1P1(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ // (*test1P1)(0,0,0) =(Complex(0,1)*phase*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*M*(-1 + z)*rz) - (Complex(0,0.5)*phase*pT*r*(1 + 2*pow(a1,2)*pow(-1 + z,2) + a1*(-3 + 5*z - 2*pow(z,2))))/(r2*a1*M*(1 + a1*(-1 + z))*(-1 + z)*rz);
+ // (*test1P1)(0,0,1) =(Complex(0,1)*pow(r,2)*(1 + a1*(-1 + z))*(-1 + a1 + a1*z))/((-1 + z)*rz) + (Complex(0,0.25)*rz*(-2 + a1 + pow(a1,2)*pow(-1 + z,2) + z - a1*pow(z,2)))/(a1*pow(1 + a1*(-1 + z),2)) + (Complex(0,0.25)*r*(-1 - z + a1*(-1 + z)*(-5 + 4*a1 + 3*z)))/(a1*(-1 + z)*rz);
+ // (*test1P1)(0,0,2) =(Complex(0,-0.5)*pT*r*(-1 + a1*(-1 + z))*rz)/(r2*a1*phase*M*(1 + a1*(-1 + z))*(-1 + z)) - (Complex(0,1)*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*phase*M*(-1 + z)*rz);
+ // (*test1P1)(0,1,0) =(Complex(0,1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*(-1 + z)*rz) + (Complex(0,0.5)*(-1 + z)*rz)/(r2*a1*(1 + a1*(-1 + z))) + (Complex(0,0.5)*r*(-1 + a1*(3 + 2*a1*(-1 + z) + z)))/(r2*a1*rz);
+ // (*test1P1)(0,1,1) =(Complex(0,0.25)*(1 - 4*a1)*pT*r)/(a1*phase*M*rz) - (Complex(0,1)*pT*pow(r,2)*(1 + a1*(-1 + z)))/(phase*M*(-1 + z)*rz);
+ // (*test1P1)(0,1,2) =(Complex(0,-1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*sqr(phase)*(-1 + z)*rz) - (Complex(0,1)*r*rz)/(r2*sqr(phase));
+ // (*test1P1)(1,0,0) =(Complex(0,1)*sqr(phase)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*(-1 + z)*rz) + (Complex(0,1)*sqr(phase)*r*rz)/r2;
+ // (*test1P1)(1,0,1) =(Complex(0,-0.25)*(-1 + 4*a1)*phase*pT*r)/(a1*M*rz) - (Complex(0,1)*phase*pT*pow(r,2)*(1 + a1*(-1 + z)))/(M*(-1 + z)*rz);
+ // (*test1P1)(1,0,2) =(Complex(0,-1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*(-1 + z)*rz) - (Complex(0,0.5)*(-1 + z)*rz)/(r2*a1*(1 + a1*(-1 + z))) - (Complex(0,0.5)*r*(-1 + a1*(3 + 2*a1*(-1 + z) + z)))/(r2*a1*rz);
+ // (*test1P1)(1,1,0) =(Complex(0,-0.5)*phase*pT*r*(-1 + a1*(-1 + z))*rz)/(r2*a1*M*(1 + a1*(-1 + z))*(-1 + z)) - (Complex(0,1)*phase*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*M*(-1 + z)*rz);
+ // (*test1P1)(1,1,1) =(Complex(0,-1)*pow(r,2)*(1 + a1*(-1 + z))*(-1 + a1 + a1*z))/((-1 + z)*rz) - (Complex(0,0.25)*rz*(-2 + a1 + pow(a1,2)*pow(-1 + z,2) + z - a1*pow(z,2)))/(a1*pow(1 + a1*(-1 + z),2)) - (Complex(0,0.25)*r*(-1 - z + a1*(-1 + z)*(-5 + 4*a1 + 3*z)))/(a1*(-1 + z)*rz);
+ // (*test1P1)(1,1,2) =(Complex(0,-0.5)*pT*r*(1 + a1*(3 + 2*a1*(-1 + z) - 2*z)*(-1 + z)))/(r2*a1*phase*M*(1 + a1*(-1 + z))*(-1 + z)*rz) + (Complex(0,1)*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*phase*M*(-1 + z)*rz);
+ // DecayMEPtr test3P1(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1)));
+ // (*test3P1)(0,0,0) = (Complex(0,-0.5)*phase*pT*pow(r,2)*(1 + a1 + 2*pow(a1,2)*(-1 + z) - a1*z))/(M*(-1 + z)*rz) - (Complex(0,0.5)*phase*pT*r*(-1 + pow(a1,2)*pow(-1 + z,2) - a1*(-1 + z)*z))/(a1*M*(1 + a1*(-1 + z))*(-1 + z)*rz);
+ // (*test3P1)(0,0,1) = (Complex(0,-1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*(-1 + z)*rz) - (Complex(0,0.5)*r*(-1 + a1*pow(-1 + z,2) - z))/(r2*a1*(-1 + z)*rz) + (Complex(0,0.5)*(2 + a1*(-1 + z) - z)*rz)/(r2*a1*(1 + a1*(-1 + z)));
+ // (*test3P1)(0,0,2) = (Complex(0,-0.5)*pT*pow(r,2)*(-1 + a1*(-3 + 2*a1)*(-1 + z)))/(phase*M*(-1 + z)*rz) - (Complex(0,0.5)*pT*r*rz)/(a1*phase*M*(1 + a1*(-1 + z))*(-1 + z));
+ // (*test3P1)(0,1,0) = (Complex(0,0.5)*r*(1/a1 + a1*(-1 + z) - 2*z))/rz + (Complex(0,0.5)*(-1 + a1)*(-1 + z)*rz)/(a1*pow(1 + a1*(-1 + z),2)) + (Complex(0,0.5)*pow(r,2)*(1 + a1*(-1 + z))*(1 + a1 + 2*pow(a1,2)*(-1 + z) - 3*a1*z))/((-1 + z)*rz);
+ // (*test3P1)(0,1,1) = (Complex(0,0.5)*pT*r*(-1 + a1 + a1*z))/(r2*a1*phase*M*(1 + a1*(-1 + z))*rz) + (Complex(0,1)*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*phase*M*(-1 + z)*rz);
+ // (*test3P1)(0,1,2) = (Complex(0,0.5)*(-1 + 2*a1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(sqr(phase)*(-1 + z)*rz) + (Complex(0,0.5)*(-1 + 2*a1)*r*rz)/sqr(phase);
+ // (*test3P1)(1,0,0) = (Complex(0,-0.5)*(-1 + 2*a1)*sqr(phase)*pow(r,2)*pow(1 + a1*(-1 + z),2))/((-1 + z)*rz) - Complex(0,0.5)*(-1 + 2*a1)*sqr(phase)*r*rz;
+ // (*test3P1)(1,0,1) = (Complex(0,0.5)*phase*pT*r*(-1 + a1 + a1*z))/(r2*a1*M*(1 + a1*(-1 + z))*rz) + (Complex(0,1)*phase*pT*pow(r,2)*(-1 + a1 + a1*z))/(r2*M*(-1 + z)*rz);
+ // (*test3P1)(1,0,2) = (Complex(0,-0.5)*r*(1/a1 + a1*(-1 + z) - 2*z))/rz - (Complex(0,0.5)*(-1 + a1)*(-1 + z)*rz)/(a1*pow(1 + a1*(-1 + z),2)) - (Complex(0,0.5)*pow(r,2)*(1 + a1*(-1 + z))*(1 + a1 + 2*pow(a1,2)*(-1 + z) - 3*a1*z))/((-1 + z)*rz);
+ // (*test3P1)(1,1,0) = (Complex(0,-0.5)*phase*pT*pow(r,2)*(-1 - 3*a1*(-1 + z) + 2*pow(a1,2)*(-1 + z)))/(M*(-1 + z)*rz) - (Complex(0,0.5)*phase*pT*r*rz)/(a1*M*(1 + a1*(-1 + z))*(-1 + z));
+ // (*test3P1)(1,1,1) = (Complex(0,1)*pow(r,2)*pow(1 + a1*(-1 + z),2))/(r2*(-1 + z)*rz) + (Complex(0,0.5)*r*(-1 + a1*pow(-1 + z,2) - z))/(r2*a1*(-1 + z)*rz) - (Complex(0,0.5)*(2 + a1*(-1 + z) - z)*rz)/(r2*a1*(1 + a1*(-1 + z)));
+ // (*test3P1)(1,1,2) = (Complex(0,-0.5)*pT*pow(r,2)*(1 + a1*(-1 + 2*a1)*(-1 + z)))/(phase*M*(-1 + z)*rz) - (Complex(0,0.5)*pT*r*(-1 + a1*(a1*(-1 + z) - z)*(-1 + z)))/(a1*phase*M*(1 + a1*(-1 + z))*(-1 + z)*rz);
+ // cerr << "testing in kernal " << a1 << " " << z << " " << r << " " << pT/M << " " << phi << "\n";
+ // for(unsigned int ih1=0;ih1<2;++ih1) {
+ // for(unsigned int ih2=0;ih2<2;++ih2) {
+ // for(unsigned int ih3=0;ih3<3;++ih3) {
+ // cerr << ih1 << " " << ih2 << " " << ih3 << " " << (*kernal)(ih1,ih2,ih3) << "\n";
+ // cerr << "testing diff " << abs((*kernal)(ih1,ih2,ih3)-mix1*(*test1P1)(ih1,ih2,ih3)-mix2*(*test3P1)(ih1,ih2,ih3)) << "\n";
+ // }
+ // }
+ // }
+ return kernal;
+}
diff --git a/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.h b/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.h
new file mode 100644
--- /dev/null
+++ b/Shower/QTilde/SplittingFunctions/Onium/QtoQPP1SplitFn.h
@@ -0,0 +1,304 @@
+// -*- C++ -*-
+#ifndef Herwig_QtoQPP1SplitFn_H
+#define Herwig_QtoQPP1SplitFn_H
+//
+// This is the declaration of the QtoQPP1SplitFn class.
+//
+
+#include "Herwig/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.h"
+#include "Herwig/Shower/ShowerHandler.h"
+#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
+#include "Herwig/MatrixElement/Onium/OniumParameters.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * The QtoQPP1SplitFn class implements the splitting function for \f$q\to q' M_q\bar{q'}(P_1)\f$,
+ * in this case there is mixing between the $\phanton{A}^1P_1$ and $\phanton{A}^3P_1$ states
+ *
+ * @see \ref QtoQPP1SplitFnInterfaces "The interfaces"
+ * defined for QtoQPP1SplitFn.
+ */
+class QtoQPP1SplitFn: public Sudakov1to2FormFactor {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ QtoQPP1SplitFn() : O1_(0.794*GeV*GeV2*GeV2), state_(bcbar), n_(1), theta_(25.),
+ sTheta_(0.422618), cTheta_(0.906308),fixedAlphaS_(-1.)
+ {}
+
+ /**
+ * Concrete implementation of the method to determine whether this splitting
+ * function can be used for a given set of particles.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ bool accept(const IdList & ids) const {
+ if(ids.size()!=3) return false;
+ // construct the meson PDG code from quark ids and check it
+ long id1=ids[0]->id();
+ long id2=ids[1]->id();
+ if(id1<id2) swap(id1,id2);
+ // quark matches state specified
+ if(id1==id2) {
+ if(id1!=4+state_) return false;
+ }
+ else {
+ if(id1!=5||id2!=4||state_!=2) return false;
+ }
+ long idtest = id1*100+id2*10+3 + (n_-1)*100000;
+ if(((abs(ids[2]->id()) != idtest + 10000) &&
+ (abs(ids[2]->id()) != idtest + 20000) )) return false;
+ // charge conservation
+ if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge()) return false;
+ // looks OK
+ return true;
+ }
+
+ /**
+ * Methods to return the splitting function.
+ */
+ //@{
+ /**
+ * Value of the energy fraction and value of the scale for the veto algorithm
+ * @param iopt The option for calculating z
+ * @param ids The PDG codes of the particles in the splitting
+ * - 0 is final-state
+ * - 1 is initial-state for the hard process
+ * - 2 is initial-state for particle decays
+ * @param t1 The starting valoe of the scale
+ * @param enhance The radiation enhancement factor
+ * @param identical Whether or not the outgoing particles are identical
+ * @param t_main rerurns the value of the energy fraction for the veto algorithm
+ * @param z_main returns the value of the scale for the veto algorithm
+ */
+ virtual void guesstz(Energy2 t1,unsigned int iopt, const IdList &ids,
+ double enhance,bool ident,
+ double detune, Energy2 &t_main, double &z_main);
+
+ /**
+ * The concrete implementation of the overestimate of the splitting function,
+ * \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ */
+ double overestimateP(const double z, const IdList &) const {
+ return pOver_/z/(1.-z);
+ }
+
+ /**
+ * The concrete implementation of the
+ * the ratio of the splitting function to the overestimate, i.e.
+ * \f$P(z,t)/P_{\rm over}(z)\f$.
+ * @param z The energy fraction.
+ * @param t The scale.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param mass Whether or not to include the mass dependent terms
+ * @param rho The spin density matrix
+ */
+ double ratioP(const double z, const Energy2 t,
+ const IdList & ids, const bool, const RhoDMatrix &) const;
+
+ /**
+ * The concrete implementation of the indefinite integral of the
+ * overestimated splitting function, \f$P_{\rm over}\f$.
+ * @param z The energy fraction.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double integOverP(const double z, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0 && z>0. && z<1.);
+ return pOver_*log(z/(1.-z));
+ }
+
+ /**
+ * The concrete implementation of the inverse of the indefinite integral.
+ * @param r Value of the splitting function to be inverted
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param PDFfactor Which additional factor to include for the PDF
+ * 0 is no additional factor,
+ * 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
+ */
+ double invIntegOverP(const double r, const IdList & ,
+ unsigned int PDFfactor=0) const {
+ assert(PDFfactor==0);
+ return 1./(1.+exp(-r/pOver_));
+ }
+ //@}
+
+ /**
+ * Method to calculate the azimuthal angle for forward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiForward(const double , const Energy2 , const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Method to calculate the azimuthal angle for backward evolution
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ * @return The weight
+ */
+ vector<pair<int,Complex> >
+ generatePhiBackward(const double , const Energy2, const IdList &,
+ const RhoDMatrix & ) {
+ return {{ {0, 1.} }};
+ }
+
+ /**
+ * Calculate the matrix element for the splitting
+ * @param z The energy fraction
+ * @param t The scale \f$t=2p_j\cdot p_k\f$.
+ * @param ids The PDG codes for the particles in the splitting.
+ * @param The azimuthal angle, \f$\phi\f$.
+ */
+ DecayMEPtr matrixElement(const double z, const Energy2 t,
+ const IdList & ids, const double phi, bool);
+
+protected:
+
+ /**
+ * Implementation of the \f$\alpha_S\f$ veto
+ */
+ double alphaSVetoRatio(Energy2 pt2, double factor) const {
+ if(fixedAlphaS_<0.) {
+ factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
+ return sqr(alpha()->ratio(pt2, factor));
+ }
+ else {
+ return 1.;
+ }
+ }
+
+public:
+
+ /** @name Functions used by the persistent I/O system. */
+ //@{
+ /**
+ * Function used to write out object persistently.
+ * @param os the persistent output stream written to.
+ */
+ void persistentOutput(PersistentOStream & os) const;
+
+ /**
+ * Function used to read in object persistently.
+ * @param is the persistent input stream read from.
+ * @param version the version number of the object when written.
+ */
+ void persistentInput(PersistentIStream & is, int version);
+ //@}
+
+ /**
+ * The standard Init function used to initialize the interfaces.
+ * Called exactly once for each class by the class description system
+ * before the main function starts or
+ * when this class is dynamically loaded.
+ */
+ static void Init();
+
+protected:
+
+ /** @name Clone Methods. */
+ //@{
+ /**
+ * Make a simple clone of this object.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr clone() const;
+
+ /** Make a clone of this object, possibly modifying the cloned object
+ * to make it sane.
+ * @return a pointer to the new object.
+ */
+ virtual IBPtr fullclone() const;
+ //@}
+
+protected:
+
+ /** @name Standard Interfaced functions. */
+ //@{
+ /**
+ * Initialize this object after the setup phase before saving an
+ * EventGenerator to disk.
+ * @throws InitException if object could not be initialized properly.
+ */
+ virtual void doinit();
+ //@}
+
+private:
+
+ /**
+ * The assignment operator is private and must never be called.
+ * In fact, it should not even be implemented.
+ */
+ QtoQPP1SplitFn & operator=(const QtoQPP1SplitFn &) = delete;
+
+private:
+
+ /**
+ * Access to the parameters for the quarkonium states
+ */
+ OniumParametersPtr params_;
+
+ /**
+ * The \f$O_1\f$ colour-singlet coefficient
+ */
+ Energy5 O1_;
+
+ /**
+ * Type of state
+ */
+ OniumState state_;
+
+ /**
+ * Principal quantum number
+ */
+ unsigned int n_;
+
+ /**
+ * Mixing angle between the $\phantom{A}^1P_1$ and $\phantom{A}^3P_1$ states
+ *
+ */
+ double theta_;
+
+ /**
+ * Sin of the mixing angle
+ */
+ double sTheta_;
+
+ /**
+ * Sin of the mixing angle
+ */
+ double cTheta_;
+
+ /**
+ * Overestimate of the splitting function
+ **/
+ static const double pOver_;
+
+ /**
+ * Fixed value of \f$\alpha_S\f$
+ */
+ double fixedAlphaS_;
+
+};
+
+}
+
+#endif /* Herwig_QtoQPP1SplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.cc b/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.cc
--- a/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.cc
+++ b/Shower/QTilde/SplittingFunctions/Sudakov1to2FormFactor.cc
@@ -1,2253 +1,2312 @@
// -*- C++ -*-
//
// Sudakov1to2FormFactor.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the Sudakov1to2FormFactor class.
//
#include "Sudakov1to2FormFactor.h"
#include "Herwig/Shower/QTilde/QTildeShowerHandler.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Utilities/DescribeClass.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Utilities/EnumIO.h"
#include "Herwig/Shower/QTilde/Base/ShowerParticle.h"
#include "Herwig/Shower/QTilde/Kinematics/FS_QTildeShowerKinematics1to2.h"
#include "Herwig/Shower/QTilde/Kinematics/IS_QTildeShowerKinematics1to2.h"
#include "Herwig/Shower/QTilde/Kinematics/Decay_QTildeShowerKinematics1to2.h"
#include "Herwig/Shower/QTilde/Kinematics/KinematicHelpers.h"
#include "SudakovCutOff.h"
#include <array>
using std::array;
using namespace Herwig;
DescribeAbstractClass<Sudakov1to2FormFactor,SudakovFormFactor>
describeSudakov1to2FormFactor ("Herwig::Sudakov1to2FormFactor","HwShower.so");
void Sudakov1to2FormFactor::persistentOutput(PersistentOStream & os) const {
os << cutoff_ << scaleChoice_ << strictAO_<< colourFactor_
<< enhancementFactor_;
}
void Sudakov1to2FormFactor::persistentInput(PersistentIStream & is, int) {
is >> cutoff_ >> scaleChoice_ >> strictAO_ >> colourFactor_
>> enhancementFactor_;
}
void Sudakov1to2FormFactor::Init() {
static ClassDocumentation<Sudakov1to2FormFactor> documentation
("The Sudakov1to2FormFactor class is the base class for the implementation of Sudakov"
" form factors for 1->2 branchings in Herwig");
static Reference<Sudakov1to2FormFactor,SudakovCutOff>
interfaceCutoff("Cutoff",
"A reference to the SudakovCutOff object",
&Herwig::Sudakov1to2FormFactor::cutoff_,
false, false, true, false);
static Switch<Sudakov1to2FormFactor,unsigned int> interfaceScaleChoice
("ScaleChoice",
"The scale choice to be used",
&Sudakov1to2FormFactor::scaleChoice_, 2, false, false);
static SwitchOption interfaceScaleChoicepT
(interfaceScaleChoice,
"pT",
"pT of the branching",
0);
static SwitchOption interfaceScaleChoiceQ2
(interfaceScaleChoice,
"Q2",
"Q2 of the branching",
1);
static SwitchOption interfaceScaleChoiceFromAngularOrdering
(interfaceScaleChoice,
"FromAngularOrdering",
"If angular order use pT, otherwise Q2",
2);
static Switch<Sudakov1to2FormFactor,bool> interfaceStrictAO
("StrictAO",
"Whether or not to apply strict angular-ordering,"
" i.e. for QED even in QCD emission, and vice versa",
&Sudakov1to2FormFactor::strictAO_, true, false, false);
static SwitchOption interfaceStrictAOYes
(interfaceStrictAO,
"Yes",
"Apply strict ordering",
true);
static SwitchOption interfaceStrictAONo
(interfaceStrictAO,
"No",
"Don't apply strict ordering",
false);
static Parameter<Sudakov1to2FormFactor,double> interfaceEnhancementFactor
("EnhancementFactor",
"Factor by which to enhance the splitting, compenstated by weight events.",
&Sudakov1to2FormFactor::enhancementFactor_, 1., 0.0, 1e8,
false, false, Interface::limited);
}
void Sudakov1to2FormFactor::guesstz(Energy2 t1,unsigned int iopt,
const IdList &ids,
double enhance,bool ident,
double detune,
Energy2 &t_main, double &z_main){
unsigned int pdfopt = iopt!=1 ? 0 : pdfFactor();
double lower = integOverP(zlimits_.first ,ids,pdfopt);
double upper = integOverP(zlimits_.second,ids,pdfopt);
double c = 1./((upper - lower) * colourFactor()
* alpha()->showerOverestimateValue()/Constants::twopi*enhance*detune);
double r = UseRandom::rnd();
assert(iopt<=2);
if(iopt==1) {
c/=pdfMax();
//symmetry of FS gluon splitting
if(ident) c*=0.5;
}
else if(iopt==2) c*=-1.;
// guessing t
if(iopt!=2 || c*log(r)<log(Constants::MaxEnergy2/t1)) {
t_main = t1*pow(r,c);
}
else
t_main = Constants::MaxEnergy2;
// guessing z
z_main = invIntegOverP(lower + UseRandom::rnd()
*(upper - lower),ids,pdfopt);
}
bool Sudakov1to2FormFactor::guessTimeLike(Energy2 &t,Energy2 tmin,double enhance,
double detune) {
Energy2 told = t;
// calculate limits on z and if lower>upper return
if(!computeTimeLikeLimits(t)) return false;
// guess values of t and z
guesstz(told,0,ids_,enhance,ids_[1]==ids_[2],detune,t,z_);
// actual values for z-limits
if(!computeTimeLikeLimits(t)) return false;
if(t<tmin) {
t=-1.0*GeV2;
return false;
}
else
return true;
}
bool Sudakov1to2FormFactor::guessSpaceLike(Energy2 &t, Energy2 tmin, const double x,
double enhance,
double detune) {
Energy2 told = t;
// calculate limits on z if lower>upper return
if(!computeSpaceLikeLimits(t,x)) return false;
// guess values of t and z
guesstz(told,1,ids_,enhance,ids_[1]==ids_[2],detune,t,z_);
// actual values for z-limits
if(!computeSpaceLikeLimits(t,x)) return false;
if(t<tmin) {
t=-1.0*GeV2;
return false;
}
else
return true;
}
bool Sudakov1to2FormFactor::PSVeto(const Energy2 t) {
// still inside PS, return true if outside
// check vs overestimated limits
if (z() < zlimits_.first || z() > zlimits_.second) return true;
Energy2 m02 = (ids_[0]->id()!=ParticleID::g && ids_[0]->id()!=ParticleID::gamma) ?
masssquared_[0] : Energy2();
Energy2 pt2 = QTildeKinematics::pT2_FSR(t,z(),m02,masssquared_[1],masssquared_[2],
masssquared_[1],masssquared_[2]);
// if pt2<0 veto
if (pt2<cutoff_->pT2min()) return true;
// otherwise calculate pt and return
pT_ = sqrt(pt2);
return false;
}
ShoKinPtr Sudakov1to2FormFactor::generateNextTimeBranching(const Energy startingScale,
const IdList &ids,
const RhoDMatrix & rho,
double enhance,
double detuning) {
// First reset the internal kinematics variables that can
// have been eventually set in the previous call to the method.
q_ = ZERO;
z_ = 0.;
phi_ = 0.;
// perform initialization
Energy2 tmax(sqr(startingScale)),tmin;
initialize(ids,tmin);
// check max > min
if(tmax<=tmin) return ShoKinPtr();
// calculate next value of t using veto algorithm
Energy2 t(tmax);
// no shower variations to calculate
if((!ShowerHandler::currentHandlerIsSet() ||
ShowerHandler::currentHandler()->showerVariations().empty()) &&
enhancementFactor_==1.) {
// Without variations do the usual Veto algorithm
// No need for more if-statements in this loop.
do {
if(!guessTimeLike(t,tmin,enhance,detuning)) break;
}
while(PSVeto(t) ||
SplittingFnVeto(z()*(1.-z())*t,ids,true,rho,detuning) ||
alphaSVeto(pTScale() ? sqr(z()*(1.-z()))*t : z()*(1.-z())*t));
}
else {
bool alphaRew(true),PSRew(true),SplitRew(true);
do {
// generate trial emission
if(!guessTimeLike(t,tmin,enhance*enhancementFactor_,detuning)) break;
// check in phase space
PSRew=PSVeto(t);
if (PSRew) continue;
// alpha_S and splitting function vetos
SplitRew=SplittingFnVeto(z()*(1.-z())*t,ids,true,rho,detuning);
alphaRew=alphaSVeto(pTScale() ? sqr(z()*(1.-z()))*t : z()*(1.-z())*t);
double factor=alphaSVetoRatio(pTScale() ? sqr(z()*(1.-z()))*t : z()*(1.-z())*t,1.)*
SplittingFnVetoRatio(z()*(1.-z())*t,ids,true,rho,detuning);
// access the shower handler
tShowerHandlerPtr ch = ShowerHandler::currentHandler();
if( !(SplitRew || alphaRew) ) {
//Emission
q_ = t > ZERO ? Energy(sqrt(t)) : -1.*MeV;
if (q_ <= ZERO) break;
}
// loop over the variations
for ( map<string,ShowerVariation>::const_iterator var =
ch->showerVariations().begin();
var != ch->showerVariations().end(); ++var ) {
if ( ( ch->firstInteraction() && var->second.firstInteraction ) ||
( !ch->firstInteraction() && var->second.secondaryInteractions ) ) {
double newfactor = alphaSVetoRatio(pTScale() ?
sqr(z()*(1.-z()))*t :
z()*(1.-z())*t,var->second.renormalizationScaleFactor)
* SplittingFnVetoRatio(z()*(1.-z())*t,ids,true,rho,detuning);
double varied;
if ( SplitRew || alphaRew ) {
// No Emission
varied = (1. - newfactor) / (1. - factor);
} else {
// Emission
varied = newfactor / factor;
}
map<string,double>::iterator wi = ch->currentWeights().find(var->first);
if ( wi != ch->currentWeights().end() )
wi->second *= varied;
else {
assert(false);
//ch->currentWeights()[var->first] = varied;
}
}
}
// for the enhancement adjust the central weight
if(enhancementFactor_!=1.) {
double varied;
// No Emission
if ( SplitRew || alphaRew ) {
varied = (1. - factor/enhancementFactor_) / (1. - factor);
}
// Emission
else {
varied = 1./enhancementFactor_;
}
ch->reweight(ch->reweight()*varied);
}
}
while(PSRew || SplitRew || alphaRew);
}
q_ = t > ZERO ? Energy(sqrt(t)) : -1.*MeV;
if(q_ < ZERO) return ShoKinPtr();
// return the ShowerKinematics object
return new_ptr(FS_QTildeShowerKinematics1to2(q_,z(),phi(),pT(),this));
}
ShoKinPtr Sudakov1to2FormFactor::
generateNextSpaceBranching(const Energy startingQ,
const IdList &ids,
double x,
const RhoDMatrix & rho,
double enhance,
Ptr<BeamParticleData>::transient_const_pointer beam,
double detuning) {
// First reset the internal kinematics variables that can
// have been eventually set in the previous call to the method.
q_ = ZERO;
z_ = 0.;
phi_ = 0.;
// perform the initialization
Energy2 tmax(sqr(startingQ)),tmin;
initialize(ids,tmin);
// check max > min
if(tmax<=tmin) return ShoKinPtr();
// calculate next value of t using veto algorithm
Energy2 t(tmax),pt2(ZERO);
// no shower variations
if(!ShowerHandler::currentHandlerIsSet() ||
ShowerHandler::currentHandler()->showerVariations().empty()){
// Without variations do the usual Veto algorithm
// No need for more if-statements in this loop.
do {
if(!guessSpaceLike(t,tmin,x,enhance,detuning)) break;
pt2 = QTildeKinematics::pT2_ISR(t,z(),masssquared_[2]);
}
while(pt2 < cutoff_->pT2min()||
z() > zlimits_.second||
SplittingFnVeto((1.-z())*t/z(),ids,false,rho,detuning)||
alphaSVeto(pTScale() ? sqr(1.-z())*t : (1.-z())*t)||
PDFVeto(t,x,z(),ids[0],ids[1],beam));
}
// shower variations
else {
bool alphaRew(true),PDFRew(true),ptRew(true),zRew(true),SplitRew(true);
do {
if(!guessSpaceLike(t,tmin,x,enhance,detuning)) break;
pt2 = QTildeKinematics::pT2_ISR(t,z(),masssquared_[2]);
ptRew=pt2 < cutoff_->pT2min();
zRew=z() > zlimits_.second;
if (ptRew||zRew) continue;
SplitRew=SplittingFnVeto((1.-z())*t/z(),ids,false,rho,detuning);
alphaRew=alphaSVeto(pTScale() ? sqr(1.-z())*t : (1.-z())*t);
PDFRew=PDFVeto(t,x,z(),ids[0],ids[1],beam);
double factor=PDFVetoRatio(t,x,z(),ids[0],ids[1],beam,1.)*
alphaSVetoRatio(pTScale() ? sqr(1.-z())*t : (1.-z())*t,1.)*
SplittingFnVetoRatio((1.-z())*t/z(),ids,false,rho,detuning);
tShowerHandlerPtr ch = ShowerHandler::currentHandler();
if( !(PDFRew || SplitRew || alphaRew) ) {
//Emission
q_ = t > ZERO ? Energy(sqrt(t)) : -1.*MeV;
if (q_ <= ZERO) break;
}
for ( map<string,ShowerVariation>::const_iterator var =
ch->showerVariations().begin();
var != ch->showerVariations().end(); ++var ) {
if ( ( ch->firstInteraction() && var->second.firstInteraction ) ||
( !ch->firstInteraction() && var->second.secondaryInteractions ) ) {
double newfactor = PDFVetoRatio(t,x,z(),ids[0],ids[1],beam,var->second.factorizationScaleFactor)*
alphaSVetoRatio(pTScale() ?
sqr(1.-z())*t : (1.-z())*t,var->second.renormalizationScaleFactor)
*SplittingFnVetoRatio((1.-z())*t/z(),ids,false,rho,detuning);
double varied;
if( PDFRew || SplitRew || alphaRew) {
// No Emission
varied = (1. - newfactor) / (1. - factor);
} else {
// Emission
varied = newfactor / factor;
}
map<string,double>::iterator wi = ch->currentWeights().find(var->first);
if ( wi != ch->currentWeights().end() )
wi->second *= varied;
else {
assert(false);
//ch->currentWeights()[var->first] = varied;
}
}
}
}
while( PDFRew || SplitRew || alphaRew);
}
if(t > ZERO && zlimits_.first < zlimits_.second) q_ = sqrt(t);
else return ShoKinPtr();
pT_ = sqrt(pt2);
// create the ShowerKinematics and return it
return new_ptr(IS_QTildeShowerKinematics1to2(q_,z(),phi(),pT(),this));
}
void Sudakov1to2FormFactor::initialize(const IdList & ids, Energy2 & tmin) {
ids_=ids;
tmin = 4.*cutoff_->pT2min();
masses_ = cutoff_->virtualMasses(ids);
masssquared_.clear();
for(unsigned int ix=0;ix<masses_.size();++ix) {
masssquared_.push_back(sqr(masses_[ix]));
if(ix>0) tmin=max(masssquared_[ix],tmin);
}
}
ShoKinPtr Sudakov1to2FormFactor::generateNextDecayBranching(const Energy startingScale,
const Energy stoppingScale,
const Energy minmass,
const IdList &ids,
const RhoDMatrix & rho,
double enhance,
double detuning) {
// First reset the internal kinematics variables that can
// have been eventually set in the previous call to this method.
q_ = Constants::MaxEnergy;
z_ = 0.;
phi_ = 0.;
// perform initialisation
Energy2 tmax(sqr(stoppingScale)),tmin;
initialize(ids,tmin);
tmin=sqr(startingScale);
// check some branching possible
if(tmax<=tmin) return ShoKinPtr();
// perform the evolution
Energy2 t(tmin),pt2(-MeV2);
do {
if(!guessDecay(t,tmax,minmass,enhance,detuning)) break;
pt2 = QTildeKinematics::pT2_Decay(t,z(),masssquared_[0],masssquared_[2]);
}
while(SplittingFnVeto((1.-z())*t/z(),ids,true,rho,detuning)||
alphaSVeto(pTScale() ? sqr(1.-z())*t : (1.-z())*t ) ||
pt2<cutoff_->pT2min() ||
t*(1.-z())>masssquared_[0]-sqr(minmass));
if(t > ZERO) {
q_ = sqrt(t);
pT_ = sqrt(pt2);
}
else return ShoKinPtr();
phi_ = 0.;
// create the ShowerKinematics object
return new_ptr(Decay_QTildeShowerKinematics1to2(q_,z(),phi(),pT(),this));
}
bool Sudakov1to2FormFactor::guessDecay(Energy2 &t,Energy2 tmax, Energy minmass,
double enhance, double detune) {
minmass = max(minmass,GeV);
// previous scale
Energy2 told = t;
// overestimated limits on z
if(tmax<masssquared_[0]) {
t=-1.0*GeV2;
return false;
}
Energy2 tm2 = tmax-masssquared_[0];
Energy tm = sqrt(tm2);
zlimits_ = make_pair(sqr(minmass/masses_[0]),
1.-sqrt(masssquared_[2]+cutoff_->pT2min()+
0.25*sqr(masssquared_[2])/tm2)/tm
+0.5*masssquared_[2]/tm2);
if(zlimits_.second<zlimits_.first) {
t=-1.0*GeV2;
return false;
}
// guess values of t and z
guesstz(told,2,ids_,enhance,ids_[1]==ids_[2],detune,t,z_);
// actual values for z-limits
if(t<masssquared_[0]) {
t=-1.0*GeV2;
return false;
}
tm2 = t-masssquared_[0];
tm = sqrt(tm2);
zlimits_ = make_pair(sqr(minmass/masses_[0]),
1.-sqrt(masssquared_[2]+cutoff_->pT2min()+
0.25*sqr(masssquared_[2])/tm2)/tm
+0.5*masssquared_[2]/tm2);
if(t>tmax||zlimits_.second<zlimits_.first) {
t=-1.0*GeV2;
return false;
}
else
return true;
}
bool Sudakov1to2FormFactor::computeTimeLikeLimits(Energy2 & t) {
if (t < 1e-20 * GeV2) {
t=-1.*GeV2;
return false;
}
const Energy2 pT2min = cutoff_->pT2min();
// special case for gluon radiating
if(ids_[0]->id()==ParticleID::g||ids_[0]->id()==ParticleID::gamma) {
// no emission possible
if(t<16.*(masssquared_[1]+pT2min)) {
t=-1.*GeV2;
return false;
}
// overestimate of the limits
zlimits_.first = 0.5*(1.-sqrt(1.-4.*sqrt((masssquared_[1]+pT2min)/t)));
zlimits_.second = 1.-zlimits_.first;
}
// special case for radiated particle is gluon
else if(ids_[2]->id()==ParticleID::g||ids_[2]->id()==ParticleID::gamma) {
zlimits_.first = sqrt((masssquared_[1]+pT2min)/t);
zlimits_.second = 1.-sqrt((masssquared_[2]+pT2min)/t);
}
else if(ids_[1]->id()==ParticleID::g||ids_[1]->id()==ParticleID::gamma) {
zlimits_.second = sqrt((masssquared_[2]+pT2min)/t);
zlimits_.first = 1.-sqrt((masssquared_[1]+pT2min)/t);
}
else {
zlimits_.first = (masssquared_[1]+pT2min)/t;
zlimits_.second = 1.-(masssquared_[2]+pT2min)/t;
}
if(zlimits_.first>=zlimits_.second) {
t=-1.*GeV2;
return false;
}
return true;
}
bool Sudakov1to2FormFactor::computeSpaceLikeLimits(Energy2 & t, double x) {
if (t < 1e-20 * GeV2) {
t=-1.*GeV2;
return false;
}
// compute the limits
zlimits_.first = x;
double yy = 1.+0.5*masssquared_[2]/t;
zlimits_.second = yy - sqrt(sqr(yy)-1.+cutoff_->pT2min()/t);
// return false if lower>upper
if(zlimits_.second<zlimits_.first) {
t=-1.*GeV2;
return false;
}
else
return true;
}
namespace {
tShowerParticlePtr findCorrelationPartner(ShowerParticle & particle,
bool forward,
ShowerInteraction inter) {
tPPtr child = &particle;
tShowerParticlePtr mother;
if(forward) {
mother = !particle.parents().empty() ?
dynamic_ptr_cast<tShowerParticlePtr>(particle.parents()[0]) : tShowerParticlePtr();
}
else {
mother = particle.children().size()==2 ?
dynamic_ptr_cast<tShowerParticlePtr>(&particle) : tShowerParticlePtr();
}
tShowerParticlePtr partner;
while(mother) {
tPPtr otherChild;
if(forward) {
for (unsigned int ix=0;ix<mother->children().size();++ix) {
if(mother->children()[ix]!=child) {
otherChild = mother->children()[ix];
break;
}
}
}
else {
otherChild = mother->children()[1];
}
tShowerParticlePtr other = dynamic_ptr_cast<tShowerParticlePtr>(otherChild);
if((inter==ShowerInteraction::QCD && otherChild->dataPtr()->coloured()) ||
(inter==ShowerInteraction::QED && otherChild->dataPtr()->charged())) {
partner = other;
break;
}
if(forward && !other->isFinalState()) {
partner = dynamic_ptr_cast<tShowerParticlePtr>(mother);
break;
}
child = mother;
if(forward) {
mother = ! mother->parents().empty() ?
dynamic_ptr_cast<tShowerParticlePtr>(mother->parents()[0]) : tShowerParticlePtr();
}
else {
if(mother->children()[0]->children().size()!=2)
break;
tShowerParticlePtr mtemp =
dynamic_ptr_cast<tShowerParticlePtr>(mother->children()[0]);
if(!mtemp)
break;
else
mother=mtemp;
}
}
if(!partner) {
if(forward) {
partner = dynamic_ptr_cast<tShowerParticlePtr>( child)->partner();
}
else {
if(mother) {
tShowerParticlePtr parent;
if(!mother->children().empty()) {
parent = dynamic_ptr_cast<tShowerParticlePtr>(mother->children()[0]);
}
if(!parent) {
parent = dynamic_ptr_cast<tShowerParticlePtr>(mother);
}
partner = parent->partner();
}
else {
partner = dynamic_ptr_cast<tShowerParticlePtr>(&particle)->partner();
}
}
}
return partner;
}
pair<double,double> softPhiMin(double phi0, double phi1, double A, double B, double C, double D) {
double c01 = cos(phi0 - phi1);
double s01 = sin(phi0 - phi1);
double s012(sqr(s01)), c012(sqr(c01));
double A2(A*A), B2(B*B), C2(C*C), D2(D*D);
if(abs(B/A)<1e-10 && abs(D/C)<1e-10) return make_pair(phi0,phi0+Constants::pi);
double root = sqr(B2)*C2*D2*sqr(s012) + 2.*A*B2*B*C2*C*D*c01*s012 + 2.*A*B2*B*C*D2*D*c01*s012
+ 4.*A2*B2*C2*D2*c012 - A2*B2*C2*D2*s012 - A2*B2*sqr(D2)*s012 - sqr(B2)*sqr(C2)*s012
- sqr(B2)*C2*D2*s012 - 4.*A2*A*B*C*D2*D*c01 - 4.*A*B2*B*C2*C*D*c01 + sqr(A2)*sqr(D2)
+ 2.*A2*B2*C2*D2 + sqr(B2)*sqr(C2);
if(root<0.) return make_pair(phi0,phi0+Constants::pi);
root = sqrt(root);
double denom = (-2.*A*B*C*D*c01 + A2*D2 + B2*C2);
double denom2 = (-B*C*c01 + A*D);
double num = B2*C*D*s012;
double y1 = B*s01*(-C*(num + root) + D*denom) / denom2;
double y2 = B*s01*(-C*(num - root) + D*denom) / denom2;
double x1 = -(num + root );
double x2 = -(num - root );
if(denom<0.) {
y1*=-1.;
y2*=-1.;
x1*=-1.;
x2*=-1.;
}
return make_pair(atan2(y1,x1) + phi0,atan2(y2,x2) + phi0);
}
}
double Sudakov1to2FormFactor::generatePhiForward(ShowerParticle & particle,
const IdList & ids,
ShoKinPtr kinematics,
const RhoDMatrix & rho) {
// no correlations, return flat phi
if(ShowerHandler::currentHandlerIsSet() &&
! dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->correlations())
return Constants::twopi*UseRandom::rnd();
// get the kinematic variables
double z = kinematics->z();
Energy2 t = z*(1.-z)*sqr(kinematics->scale());
Energy pT = kinematics->pT();
// if soft correlations
Energy2 pipj,pik;
bool canBeSoft[2] = {ids[1]->id()==ParticleID::g || ids[1]->id()==ParticleID::gamma,
ids[2]->id()==ParticleID::g || ids[2]->id()==ParticleID::gamma };
array<Energy2,3> pjk;
array<Energy,3> Ek;
Energy Ei,Ej;
Energy2 m12(ZERO),m22(ZERO);
InvEnergy2 aziMax(ZERO);
bool softAllowed = (!ShowerHandler::currentHandlerIsSet() ||
dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()) &&
(canBeSoft[0] || canBeSoft[1]);
if(softAllowed) {
// find the partner for the soft correlations
tShowerParticlePtr partner=findCorrelationPartner(particle,true,interactionType());
// remember we want the softer gluon
bool swapOrder = !canBeSoft[1] || (canBeSoft[0] && canBeSoft[1] && z < 0.5);
double zFact = !swapOrder ? (1.-z) : z;
// compute the transforms to the shower reference frame
// first the boost
Lorentz5Momentum pVect = particle.showerBasis()->pVector();
Lorentz5Momentum nVect = particle.showerBasis()->nVector();
Boost beta_bb;
if(particle.showerBasis()->frame()==ShowerBasis::BackToBack) {
beta_bb = -(pVect + nVect).boostVector();
}
else if(particle.showerBasis()->frame()==ShowerBasis::Rest) {
beta_bb = -pVect.boostVector();
}
else
assert(false);
pVect.boost(beta_bb);
nVect.boost(beta_bb);
Axis axis;
if(particle.showerBasis()->frame()==ShowerBasis::BackToBack) {
axis = pVect.vect().unit();
}
else if(particle.showerBasis()->frame()==ShowerBasis::Rest) {
axis = nVect.vect().unit();
}
else
assert(false);
// and then the rotation
LorentzRotation rot;
if(axis.perp2()>0.) {
double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
rot.rotate(acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
}
else if(axis.z()<0.) {
rot.rotate(Constants::pi,Axis(1.,0.,0.));
}
rot.invert();
pVect *= rot;
nVect *= rot;
// shower parameters
Energy2 pn = pVect*nVect, m2 = pVect.m2();
double alpha0 = particle.showerParameters().alpha;
double beta0 = 0.5/alpha0/pn*
(sqr(particle.dataPtr()->mass())-sqr(alpha0)*m2+sqr(particle.showerParameters().pt));
Lorentz5Momentum qperp0(particle.showerParameters().ptx,
particle.showerParameters().pty,ZERO,ZERO);
assert(partner);
Lorentz5Momentum pj = partner->momentum();
pj.boost(beta_bb);
pj *= rot;
// compute the two phi independent dot products
pik = 0.5*zFact*(sqr(alpha0)*m2 - sqr(particle.showerParameters().pt) + 2.*alpha0*beta0*pn )
+0.5*sqr(pT)/zFact;
Energy2 dot1 = pj*pVect;
Energy2 dot2 = pj*nVect;
Energy2 dot3 = pj*qperp0;
pipj = alpha0*dot1+beta0*dot2+dot3;
// compute the constants for the phi dependent dot product
pjk[0] = zFact*(alpha0*dot1+dot3-0.5*dot2/pn*(alpha0*m2-sqr(particle.showerParameters().pt)/alpha0))
+0.5*sqr(pT)*dot2/pn/zFact/alpha0;
pjk[1] = (pj.x() - dot2/alpha0/pn*qperp0.x())*pT;
pjk[2] = (pj.y() - dot2/alpha0/pn*qperp0.y())*pT;
m12 = sqr(particle.dataPtr()->mass());
m22 = sqr(partner->dataPtr()->mass());
if(swapOrder) {
pjk[1] *= -1.;
pjk[2] *= -1.;
}
Ek[0] = zFact*(alpha0*pVect.t()-0.5*nVect.t()/pn*(alpha0*m2-sqr(particle.showerParameters().pt)/alpha0))
+0.5*sqr(pT)*nVect.t()/pn/zFact/alpha0;
Ek[1] = -nVect.t()/alpha0/pn*qperp0.x()*pT;
Ek[2] = -nVect.t()/alpha0/pn*qperp0.y()*pT;
if(swapOrder) {
Ek[1] *= -1.;
Ek[2] *= -1.;
}
Energy mag2=sqrt(sqr(Ek[1])+sqr(Ek[2]));
Ei = alpha0*pVect.t()+beta0*nVect.t();
Ej = pj.t();
double phi0 = atan2(-pjk[2],-pjk[1]);
if(phi0<0.) phi0 += Constants::twopi;
double phi1 = atan2(-Ek[2],-Ek[1]);
if(phi1<0.) phi1 += Constants::twopi;
double xi_min = pik/Ei/(Ek[0]+mag2), xi_max = pik/Ei/(Ek[0]-mag2), xi_ij = pipj/Ei/Ej;
if(xi_min>xi_max) swap(xi_min,xi_max);
if(xi_min>xi_ij) softAllowed = false;
Energy2 mag = sqrt(sqr(pjk[1])+sqr(pjk[2]));
if(!ShowerHandler::currentHandlerIsSet() ||
dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
double A = (pipj*Ek[0]- Ej*pik)/Ej/sqr(Ej);
double B = -sqrt(sqr(pipj)*(sqr(Ek[1])+sqr(Ek[2])))/Ej/sqr(Ej);
double C = pjk[0]/sqr(Ej);
double D = -sqrt(sqr(pjk[1])+sqr(pjk[2]))/sqr(Ej);
pair<double,double> minima = softPhiMin(phi0,phi1,A,B,C,D);
aziMax = 0.5/pik/(Ek[0]-mag2)*(Ei-m12*(Ek[0]-mag2)/pik + max(Ej*(A+B*cos(minima.first -phi1))/(C+D*cos(minima.first -phi0)),
Ej*(A+B*cos(minima.second-phi1))/(C+D*cos(minima.second-phi0))));
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
aziMax = -m12/sqr(pik) -m22/sqr(pjk[0]+mag) +2.*pipj/pik/(pjk[0]-mag);
}
else
assert(false);
}
// if spin correlations
vector<pair<int,Complex> > wgts;
if(!ShowerHandler::currentHandlerIsSet() ||
dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->spinCorrelations()) {
// calculate the weights
wgts = generatePhiForward(z,t,ids,rho);
}
else {
wgts = {{ {0, 1.} }};
}
// generate the azimuthal angle
double phi,wgt;
static const Complex ii(0.,1.);
unsigned int ntry(0);
double phiMax(0.),wgtMax(0.);
do {
phi = Constants::twopi*UseRandom::rnd();
// first the spin correlations bit (gives 1 if correlations off)
Complex spinWgt = 0.;
for(unsigned int ix=0;ix<wgts.size();++ix) {
if(wgts[ix].first==0)
spinWgt += wgts[ix].second;
else
spinWgt += exp(double(wgts[ix].first)*ii*phi)*wgts[ix].second;
}
wgt = spinWgt.real();
if(wgt-1.>1e-10) {
generator()->log() << "Forward spin weight problem " << wgt << " " << wgt-1.
<< " " << ids[0]->id() << " " << ids[1]->id() << " " << ids[2]->id() << " " << " " << phi << "\n";
generator()->log() << "Weights \n";
for(unsigned int ix=0;ix<wgts.size();++ix)
generator()->log() << wgts[ix].first << " " << wgts[ix].second << "\n";
}
// soft correlations bit
double aziWgt = 1.;
if(softAllowed) {
Energy2 dot = pjk[0]+pjk[1]*cos(phi)+pjk[2]*sin(phi);
Energy Eg = Ek[0]+Ek[1]*cos(phi)+Ek[2]*sin(phi);
if(pipj*Eg>pik*Ej) {
if(!ShowerHandler::currentHandlerIsSet() ||
dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
aziWgt = max(ZERO,0.5/pik/Eg*(Ei-m12*Eg/pik + (pipj*Eg - Ej*pik)/dot)/aziMax);
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
aziWgt = (-m12/sqr(pik) -m22/sqr(dot) +2.*pipj/pik/dot)/aziMax;
}
if(aziWgt-1.>1e-10||aziWgt<-1e-10) {
generator()->log() << "Forward soft weight problem " << aziWgt << " " << aziWgt-1.
<< " " << ids[0]->id() << " " << ids[1]->id() << " " << ids[2]->id() << " " << " " << phi << "\n";
}
}
else {
aziWgt = 0.;
}
}
wgt *= aziWgt;
if(wgt>wgtMax) {
phiMax = phi;
wgtMax = wgt;
}
++ntry;
}
while(wgt<UseRandom::rnd()&&ntry<10000);
if(ntry==10000) {
generator()->log() << "Too many tries to generate phi in forward evolution\n";
phi = phiMax;
}
// return the azimuthal angle
return phi;
}
double Sudakov1to2FormFactor::generatePhiBackward(ShowerParticle & particle,
const IdList & ids,
ShoKinPtr kinematics,
const RhoDMatrix & rho) {
// no correlations, return flat phi
if(! dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->correlations())
return Constants::twopi*UseRandom::rnd();
// get the kinematic variables
double z = kinematics->z();
Energy2 t = (1.-z)*sqr(kinematics->scale())/z;
Energy pT = kinematics->pT();
// if soft correlations
bool softAllowed = dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations() &&
(ids[2]->id()==ParticleID::g || ids[2]->id()==ParticleID::gamma);
Energy2 pipj,pik,m12(ZERO),m22(ZERO);
array<Energy2,3> pjk;
Energy Ei,Ej,Ek;
InvEnergy2 aziMax(ZERO);
if(softAllowed) {
// find the partner for the soft correlations
tShowerParticlePtr partner=findCorrelationPartner(particle,false,interactionType());
double zFact = (1.-z);
// compute the transforms to the shower reference frame
// first the boost
Lorentz5Momentum pVect = particle.showerBasis()->pVector();
Lorentz5Momentum nVect = particle.showerBasis()->nVector();
assert(particle.showerBasis()->frame()==ShowerBasis::BackToBack);
Boost beta_bb = -(pVect + nVect).boostVector();
pVect.boost(beta_bb);
nVect.boost(beta_bb);
Axis axis = pVect.vect().unit();
// and then the rotation
LorentzRotation rot;
if(axis.perp2()>0.) {
double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
rot.rotate(acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
}
else if(axis.z()<0.) {
rot.rotate(Constants::pi,Axis(1.,0.,0.));
}
rot.invert();
pVect *= rot;
nVect *= rot;
// shower parameters
Energy2 pn = pVect*nVect;
Energy2 m2 = pVect.m2();
double alpha0 = particle.x();
double beta0 = -0.5/alpha0/pn*sqr(alpha0)*m2;
Lorentz5Momentum pj = partner->momentum();
pj.boost(beta_bb);
pj *= rot;
double beta2 = 0.5*(1.-zFact)*(sqr(alpha0*zFact/(1.-zFact))*m2+sqr(pT))/alpha0/zFact/pn;
// compute the two phi independent dot products
Energy2 dot1 = pj*pVect;
Energy2 dot2 = pj*nVect;
pipj = alpha0*dot1+beta0*dot2;
pik = alpha0*(alpha0*zFact/(1.-zFact)*m2+pn*(beta2+zFact/(1.-zFact)*beta0));
// compute the constants for the phi dependent dot product
pjk[0] = alpha0*zFact/(1.-zFact)*dot1+beta2*dot2;
pjk[1] = pj.x()*pT;
pjk[2] = pj.y()*pT;
m12 = ZERO;
m22 = sqr(partner->dataPtr()->mass());
Energy2 mag = sqrt(sqr(pjk[1])+sqr(pjk[2]));
if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
aziMax = -m12/sqr(pik) -m22/sqr(pjk[0]+mag) +2.*pipj/pik/(pjk[0]-mag);
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
Ek = alpha0*zFact/(1.-zFact)*pVect.t()+beta2*nVect.t();
Ei = alpha0*pVect.t()+beta0*nVect.t();
Ej = pj.t();
if(pipj*Ek> Ej*pik) {
aziMax = 0.5/pik/Ek*(Ei-m12*Ek/pik + (pipj*Ek- Ej*pik)/(pjk[0]-mag));
}
else {
aziMax = 0.5/pik/Ek*(Ei-m12*Ek/pik);
}
}
else {
assert(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==0);
}
}
// if spin correlations
vector<pair<int,Complex> > wgts;
if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->spinCorrelations()) {
// get the weights
wgts = generatePhiBackward(z,t,ids,rho);
}
else {
wgts = {{ {0, 1.} }};
}
// generate the azimuthal angle
double phi,wgt;
static const Complex ii(0.,1.);
unsigned int ntry(0);
double phiMax(0.),wgtMax(0.);
do {
phi = Constants::twopi*UseRandom::rnd();
Complex spinWgt = 0.;
for(unsigned int ix=0;ix<wgts.size();++ix) {
if(wgts[ix].first==0)
spinWgt += wgts[ix].second;
else
spinWgt += exp(double(wgts[ix].first)*ii*phi)*wgts[ix].second;
}
wgt = spinWgt.real();
if(wgt-1.>1e-10) {
generator()->log() << "Backward weight problem " << wgt << " " << wgt-1.
<< " " << ids[0]->id() << " " << ids[1]->id() << " " << ids[2]->id() << " " << " " << z << " " << phi << "\n";
generator()->log() << "Weights \n";
for(unsigned int ix=0;ix<wgts.size();++ix)
generator()->log() << wgts[ix].first << " " << wgts[ix].second << "\n";
}
// soft correlations bit
double aziWgt = 1.;
if(softAllowed) {
Energy2 dot = pjk[0]+pjk[1]*cos(phi)+pjk[2]*sin(phi);
if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
aziWgt = (-m12/sqr(pik) -m22/sqr(dot) +2.*pipj/pik/dot)/aziMax;
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
aziWgt = max(ZERO,0.5/pik/Ek*(Ei-m12*Ek/pik + pipj*Ek/dot - Ej*pik/dot)/aziMax);
}
if(aziWgt-1.>1e-10||aziWgt<-1e-10) {
generator()->log() << "Backward soft weight problem " << aziWgt << " " << aziWgt-1.
<< " " << ids[0]->id() << " " << ids[1]->id() << " " << ids[2]->id() << " " << " " << phi << "\n";
}
}
wgt *= aziWgt;
if(wgt>wgtMax) {
phiMax = phi;
wgtMax = wgt;
}
++ntry;
}
while(wgt<UseRandom::rnd()&&ntry<10000);
if(ntry==10000) {
generator()->log() << "Too many tries to generate phi in backward evolution\n";
phi = phiMax;
}
// return the azimuthal angle
return phi;
}
double Sudakov1to2FormFactor::generatePhiDecay(ShowerParticle & particle,
const IdList & ids,
ShoKinPtr kinematics,
const RhoDMatrix &) {
// only soft correlations in this case
// no correlations, return flat phi
if( !(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations() &&
(ids[2]->id()==ParticleID::g || ids[2]->id()==ParticleID::gamma )))
return Constants::twopi*UseRandom::rnd();
// get the kinematic variables
double z = kinematics->z();
Energy pT = kinematics->pT();
// if soft correlations
// find the partner for the soft correlations
tShowerParticlePtr partner = findCorrelationPartner(particle,true,interactionType());
double zFact(1.-z);
// compute the transforms to the shower reference frame
// first the boost
Lorentz5Momentum pVect = particle.showerBasis()->pVector();
Lorentz5Momentum nVect = particle.showerBasis()->nVector();
assert(particle.showerBasis()->frame()==ShowerBasis::Rest);
Boost beta_bb = -pVect.boostVector();
pVect.boost(beta_bb);
nVect.boost(beta_bb);
Axis axis = nVect.vect().unit();
// and then the rotation
LorentzRotation rot;
if(axis.perp2()>0.) {
double sinth(sqrt(sqr(axis.x())+sqr(axis.y())));
rot.rotate(acos(axis.z()),Axis(-axis.y()/sinth,axis.x()/sinth,0.));
}
else if(axis.z()<0.) {
rot.rotate(Constants::pi,Axis(1.,0.,0.));
}
rot.invert();
pVect *= rot;
nVect *= rot;
// shower parameters
Energy2 pn = pVect*nVect;
Energy2 m2 = pVect.m2();
double alpha0 = particle.showerParameters().alpha;
double beta0 = 0.5/alpha0/pn*
(sqr(particle.dataPtr()->mass())-sqr(alpha0)*m2+sqr(particle.showerParameters().pt));
Lorentz5Momentum qperp0(particle.showerParameters().ptx,
particle.showerParameters().pty,ZERO,ZERO);
Lorentz5Momentum pj = partner->momentum();
pj.boost(beta_bb);
pj *= rot;
// compute the two phi independent dot products
Energy2 pik = 0.5*zFact*(sqr(alpha0)*m2 - sqr(particle.showerParameters().pt) + 2.*alpha0*beta0*pn )
+0.5*sqr(pT)/zFact;
Energy2 dot1 = pj*pVect;
Energy2 dot2 = pj*nVect;
Energy2 dot3 = pj*qperp0;
Energy2 pipj = alpha0*dot1+beta0*dot2+dot3;
// compute the constants for the phi dependent dot product
array<Energy2,3> pjk;
pjk[0] = zFact*(alpha0*dot1+dot3-0.5*dot2/pn*(alpha0*m2-sqr(particle.showerParameters().pt)/alpha0))
+0.5*sqr(pT)*dot2/pn/zFact/alpha0;
pjk[1] = (pj.x() - dot2/alpha0/pn*qperp0.x())*pT;
pjk[2] = (pj.y() - dot2/alpha0/pn*qperp0.y())*pT;
Energy2 m12 = sqr(particle.dataPtr()->mass());
Energy2 m22 = sqr(partner->dataPtr()->mass());
Energy2 mag = sqrt(sqr(pjk[1])+sqr(pjk[2]));
InvEnergy2 aziMax;
array<Energy,3> Ek;
Energy Ei,Ej;
if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
aziMax = -m12/sqr(pik) -m22/sqr(pjk[0]+mag) +2.*pipj/pik/(pjk[0]-mag);
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
Ek[0] = zFact*(alpha0*pVect.t()+-0.5*nVect.t()/pn*(alpha0*m2-sqr(particle.showerParameters().pt)/alpha0))
+0.5*sqr(pT)*nVect.t()/pn/zFact/alpha0;
Ek[1] = -nVect.t()/alpha0/pn*qperp0.x()*pT;
Ek[2] = -nVect.t()/alpha0/pn*qperp0.y()*pT;
Energy mag2=sqrt(sqr(Ek[1])+sqr(Ek[2]));
Ei = alpha0*pVect.t()+beta0*nVect.t();
Ej = pj.t();
aziMax = 0.5/pik/(Ek[0]-mag2)*(Ei-m12*(Ek[0]-mag2)/pik + pipj*(Ek[0]+mag2)/(pjk[0]-mag) - Ej*pik/(pjk[0]-mag) );
}
else
assert(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==0);
// generate the azimuthal angle
double phi,wgt(0.);
unsigned int ntry(0);
double phiMax(0.),wgtMax(0.);
do {
phi = Constants::twopi*UseRandom::rnd();
Energy2 dot = pjk[0]+pjk[1]*cos(phi)+pjk[2]*sin(phi);
if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==1) {
wgt = (-m12/sqr(pik) -m22/sqr(dot) +2.*pipj/pik/dot)/aziMax;
}
else if(dynamic_ptr_cast<tcQTildeShowerHandlerPtr>(ShowerHandler::currentHandler())->softCorrelations()==2) {
if(qperp0.m2()==ZERO) {
wgt = 1.;
}
else {
Energy Eg = Ek[0]+Ek[1]*cos(phi)+Ek[2]*sin(phi);
wgt = max(ZERO,0.5/pik/Eg*(Ei-m12*Eg/pik + (pipj*Eg - Ej*pik)/dot)/aziMax);
}
}
if(wgt-1.>1e-10||wgt<-1e-10) {
generator()->log() << "Decay soft weight problem " << wgt << " " << wgt-1.
<< " " << ids[0]->id() << " " << ids[1]->id() << " " << ids[2]->id() << " " << " " << phi << "\n";
}
if(wgt>wgtMax) {
phiMax = phi;
wgtMax = wgt;
}
++ntry;
}
while(wgt<UseRandom::rnd()&&ntry<10000);
if(ntry==10000) {
phi = phiMax;
generator()->log() << "Too many tries to generate phi\n";
}
// return the azimuthal angle
return phi;
}
Energy Sudakov1to2FormFactor::calculateScale(double zin, Energy pt, IdList ids,
unsigned int iopt) {
Energy2 tmin;
initialize(ids,tmin);
// final-state branching
if(iopt==0) {
Energy2 scale=(sqr(pt)+masssquared_[1]*(1.-zin)+masssquared_[2]*zin);
if(ids[0]->id()!=ParticleID::g) scale -= zin*(1.-zin)*masssquared_[0];
scale /= sqr(zin*(1-zin));
return scale<=ZERO ? sqrt(tmin) : sqrt(scale);
}
else if(iopt==1) {
Energy2 scale=(sqr(pt)+zin*masssquared_[2])/sqr(1.-zin);
return scale<=ZERO ? sqrt(tmin) : sqrt(scale);
}
else if(iopt==2) {
Energy2 scale = (sqr(pt)+zin*masssquared_[2])/sqr(1.-zin)+masssquared_[0];
return scale<=ZERO ? sqrt(tmin) : sqrt(scale);
}
else {
throw Exception() << "Unknown option in Sudakov1to2FormFactor::calculateScale() "
<< "iopt = " << iopt << Exception::runerror;
}
}
void Sudakov1to2FormFactor::colourConnection(tShowerParticlePtr parent,
tShowerParticlePtr first,
tShowerParticlePtr second,
ShowerPartnerType partnerType,
const bool back) const {
if(colourStructure()==TripletTripletOctet) {
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// ensure input consistency
assert(( cparent.first && !cparent.second &&
partnerType==ShowerPartnerType::QCDColourLine) ||
(!cparent.first && cparent.second &&
partnerType==ShowerPartnerType::QCDAntiColourLine) ||
( cparent.first && !cparent.second &&
partnerType==ShowerPartnerType::DARKColourLine) ||
(!cparent.first && cparent.second &&
partnerType==ShowerPartnerType::DARKAntiColourLine));
// q -> q g
if(cparent.first) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(second);
newline->addColoured ( first);
newline->addAntiColoured (second);
}
// qbar -> qbar g
else {
ColinePtr newline=new_ptr(ColourLine());
cparent.second->addAntiColoured(second);
newline->addColoured(second);
newline->addAntiColoured(first);
}
// Set progenitor
first->progenitor(parent->progenitor());
second->progenitor(parent->progenitor());
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// ensure input consistency
assert(( cfirst.first && !cfirst.second &&
partnerType==ShowerPartnerType::QCDColourLine) ||
( !cfirst.first && cfirst.second &&
partnerType==ShowerPartnerType::QCDAntiColourLine) ||
( cfirst.first && !cfirst.second &&
partnerType==ShowerPartnerType::DARKColourLine) ||
( !cfirst.first && cfirst.second &&
partnerType==ShowerPartnerType::DARKAntiColourLine));
// q -> q g
if(cfirst.first) {
ColinePtr newline=new_ptr(ColourLine());
cfirst.first->addAntiColoured(second);
newline->addColoured(second);
newline->addColoured(parent);
}
// qbar -> qbar g
else {
ColinePtr newline=new_ptr(ColourLine());
cfirst.second->addColoured(second);
newline->addAntiColoured(second);
newline->addAntiColoured(parent);
}
// Set progenitor
parent->progenitor(first->progenitor());
second->progenitor(first->progenitor());
}
}
else if(colourStructure()==OctetOctetOctet) {
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// ensure input consistency
assert(cparent.first&&cparent.second);
// ensure first gluon is hardest
if(first->id()==second->id() && parent->showerKinematics()->z()<0.5)
swap(first,second);
// colour line radiates
if(partnerType==ShowerPartnerType::QCDColourLine ||
partnerType==ShowerPartnerType::DARKColourLine) {
// The colour line is radiating
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(second);
cparent.second->addAntiColoured(first);
newline->addColoured(first);
newline->addAntiColoured(second);
}
// anti colour line radiates
else if(partnerType==ShowerPartnerType::QCDAntiColourLine ||
partnerType==ShowerPartnerType::DARKAntiColourLine) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(first);
cparent.second->addAntiColoured(second);
newline->addColoured(second);
newline->addAntiColoured(first);
}
else
assert(false);
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// ensure input consistency
assert(cfirst.first&&cfirst.second);
// The colour line is radiating
if(partnerType==ShowerPartnerType::QCDColourLine ||
partnerType==ShowerPartnerType::DARKColourLine) {
ColinePtr newline=new_ptr(ColourLine());
cfirst.first->addAntiColoured(second);
cfirst.second->addAntiColoured(parent);
newline->addColoured(parent);
newline->addColoured(second);
}
// anti colour line radiates
else if(partnerType==ShowerPartnerType::QCDAntiColourLine ||
partnerType==ShowerPartnerType::DARKAntiColourLine) {
ColinePtr newline=new_ptr(ColourLine());
cfirst.first->addColoured(parent);
cfirst.second->addColoured(second);
newline->addAntiColoured(second);
newline->addAntiColoured(parent);
}
else
assert(false);
}
}
else if(colourStructure() == OctetTripletTriplet) {
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// ensure input consistency
assert(cparent.first&&cparent.second);
cparent.first ->addColoured ( first);
cparent.second->addAntiColoured(second);
// Set progenitor
first->progenitor(parent->progenitor());
second->progenitor(parent->progenitor());
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// ensure input consistency
assert(( cfirst.first && !cfirst.second) ||
(!cfirst.first && cfirst.second));
// g -> q qbar
if(cfirst.first) {
ColinePtr newline=new_ptr(ColourLine());
cfirst.first->addColoured(parent);
newline->addAntiColoured(second);
newline->addAntiColoured(parent);
}
// g -> qbar q
else {
ColinePtr newline=new_ptr(ColourLine());
cfirst.second->addAntiColoured(parent);
newline->addColoured(second);
newline->addColoured(parent);
}
// Set progenitor
parent->progenitor(first->progenitor());
second->progenitor(first->progenitor());
}
}
else if(colourStructure() == TripletOctetTriplet) {
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// ensure input consistency
assert(( cparent.first && !cparent.second) ||
(!cparent.first && cparent.second));
// q -> g q
if(cparent.first) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(first);
newline->addColoured (second);
newline->addAntiColoured( first);
}
// qbar -> g qbar
else {
ColinePtr newline=new_ptr(ColourLine());
cparent.second->addAntiColoured(first);
newline->addColoured ( first);
newline->addAntiColoured(second);
}
// Set progenitor
first->progenitor(parent->progenitor());
second->progenitor(parent->progenitor());
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// ensure input consistency
assert(cfirst.first&&cfirst.second);
// q -> g q
if(parent->id()>0) {
cfirst.first ->addColoured(parent);
cfirst.second->addColoured(second);
}
else {
cfirst.first ->addAntiColoured(second);
cfirst.second->addAntiColoured(parent);
}
// Set progenitor
parent->progenitor(first->progenitor());
second->progenitor(first->progenitor());
}
}
else if(colourStructure()==SextetSextetOctet) {
//make sure we're not doing backward evolution
assert(!back);
//make sure something sensible
assert(parent->colourLine() || parent->antiColourLine());
//get the colour lines or anti-colour lines
bool isAntiColour=true;
ColinePair cparent;
if(parent->colourLine()) {
cparent = ColinePair(const_ptr_cast<tColinePtr>(parent->colourInfo()->colourLines()[0]),
const_ptr_cast<tColinePtr>(parent->colourInfo()->colourLines()[1]));
isAntiColour=false;
}
else {
cparent = ColinePair(const_ptr_cast<tColinePtr>(parent->colourInfo()->antiColourLines()[0]),
const_ptr_cast<tColinePtr>(parent->colourInfo()->antiColourLines()[1]));
}
//check for sensible input
// assert(cparent.first && cparent.second);
// sextet has 2 colour lines
if(!isAntiColour) {
//pick at random which of the colour topolgies to take
double topology = UseRandom::rnd();
if(topology < 0.25) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(second);
cparent.second->addColoured(first);
newline->addColoured(first);
newline->addAntiColoured(second);
}
else if(topology >=0.25 && topology < 0.5) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(first);
cparent.second->addColoured(second);
newline->addColoured(first);
newline->addAntiColoured(second);
}
else if(topology >= 0.5 && topology < 0.75) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(second);
cparent.second->addColoured(first);
newline->addColoured(first);
newline->addAntiColoured(second);
}
else {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addColoured(first);
cparent.second->addColoured(second);
newline->addColoured(first);
newline->addAntiColoured(second);
}
}
// sextet has 2 anti-colour lines
else {
double topology = UseRandom::rnd();
if(topology < 0.25){
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addAntiColoured(second);
cparent.second->addAntiColoured(first);
newline->addAntiColoured(first);
newline->addColoured(second);
}
else if(topology >=0.25 && topology < 0.5) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addAntiColoured(first);
cparent.second->addAntiColoured(second);
newline->addAntiColoured(first);
newline->addColoured(second);
}
else if(topology >= 0.5 && topology < 0.75) {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addAntiColoured(second);
cparent.second->addAntiColoured(first);
newline->addAntiColoured(first);
newline->addColoured(second);
}
else {
ColinePtr newline=new_ptr(ColourLine());
cparent.first->addAntiColoured(first);
cparent.second->addAntiColoured(second);
newline->addAntiColoured(first);
newline->addColoured(second);
}
}
}
+ else if(colourStructure() == OctetOctetSinglet) {
+ if(!back) {
+ ColinePair cparent = ColinePair(parent->colourLine(),
+ parent->antiColourLine());
+ cparent.first->addColoured(first);
+ cparent.second->addAntiColoured(first);
+ }
+ else {
+ ColinePair cfirst = ColinePair(first->colourLine(),
+ first->antiColourLine());
+ cfirst.first->addColoured(parent);
+ cfirst.second->addAntiColoured(parent);
+ }
+ }
+ else if(colourStructure() == TripletTripletSinglet) {
+ if(!back) {
+ ColinePair cparent = ColinePair(parent->colourLine(),
+ parent->antiColourLine());
+ // q -> q
+ if(cparent.first) {
+ cparent.first->addColoured(first);
+ }
+ // qbar -> qbar
+ if(cparent.second) {
+ cparent.second->addAntiColoured(first);
+ }
+ }
+ else {
+ ColinePair cfirst = ColinePair(first->colourLine(),
+ first->antiColourLine());
+ // q -> q
+ if(cfirst.first) {
+ cfirst.first->addColoured(parent);
+ }
+ // qbar -> qbar
+ if(cfirst.second) {
+ cfirst.second->addAntiColoured(parent);
+ }
+ }
+ }
+ else if(colourStructure() == Epsilon) {
+ if(!back) {
+ ColinePair newlines(new_ptr(ColourLine()),new_ptr(ColourLine()));
+ if(parent->colourLine()) {
+ newlines.first ->addAntiColoured(first );
+ newlines.second->addAntiColoured(second);
+ parent->colourLine()->setSinkNeighbours(newlines.first,
+ newlines.second);
+ }
+ else if(parent->antiColourLine()) {
+ newlines.first ->addColoured(first );
+ newlines.second->addColoured(second);
+ parent->antiColourLine()->setSourceNeighbours(newlines.first,
+ newlines.second);
+ }
+ }
+ else
+ assert(false);
+ }
else if(colourStructure() == ChargedChargedNeutral) {
if(!parent->data().coloured()) return;
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// q -> q g
if(cparent.first) {
cparent.first->addColoured(first);
}
// qbar -> qbar g
if(cparent.second) {
cparent.second->addAntiColoured(first);
}
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// q -> q g
if(cfirst.first) {
cfirst.first->addColoured(parent);
}
// qbar -> qbar g
if(cfirst.second) {
cfirst.second->addAntiColoured(parent);
}
}
}
else if(colourStructure() == ChargedNeutralCharged) {
if(!parent->data().coloured()) return;
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// q -> q g
if(cparent.first) {
cparent.first->addColoured(second);
}
// qbar -> qbar g
if(cparent.second) {
cparent.second->addAntiColoured(second);
}
}
else {
if (second->dataPtr()->iColour()==PDT::Colour3 ) {
ColinePtr newline=new_ptr(ColourLine());
newline->addColoured(second);
newline->addColoured(parent);
}
else if (second->dataPtr()->iColour()==PDT::Colour3bar ) {
ColinePtr newline=new_ptr(ColourLine());
newline->addAntiColoured(second);
newline->addAntiColoured(parent);
}
}
}
else if(colourStructure() == NeutralChargedCharged ) {
if(!back) {
if(first->dataPtr()->coloured()) {
ColinePtr newline=new_ptr(ColourLine());
if(first->dataPtr()->iColour()==PDT::Colour3) {
newline->addColoured (first );
newline->addAntiColoured(second);
}
else if (first->dataPtr()->iColour()==PDT::Colour3bar) {
newline->addColoured (second);
newline->addAntiColoured(first );
}
else if(parent->dataPtr()->coloured()||
first ->dataPtr()->coloured()||
second->dataPtr()->coloured())
assert(false);
}
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// gamma -> q qbar
if(cfirst.first) {
cfirst.first->addAntiColoured(second);
}
// gamma -> qbar q
else if(cfirst.second) {
cfirst.second->addColoured(second);
}
else if(parent->dataPtr()->coloured()||
first ->dataPtr()->coloured()||
second->dataPtr()->coloured())
assert(false);
}
}
else if(colourStructure() == EW) {
if(!parent->data().coloured()) return;
if(!back) {
ColinePair cparent = ColinePair(parent->colourLine(),
parent->antiColourLine());
// q -> q g
if(cparent.first) {
cparent.first->addColoured(first);
}
// qbar -> qbar g
if(cparent.second) {
cparent.second->addAntiColoured(first);
}
}
else {
ColinePair cfirst = ColinePair(first->colourLine(),
first->antiColourLine());
// q -> q g
if(cfirst.first) {
cfirst.first->addColoured(parent);
}
// qbar -> qbar g
if(cfirst.second) {
cfirst.second->addAntiColoured(parent);
}
}
}
else {
assert(false);
}
}
namespace {
bool hasColour(tPPtr p) {
PDT::Colour colour = p->dataPtr()->iColour();
return colour==PDT::Colour3 || colour==PDT::Colour8 || colour == PDT::Colour6||
colour==PDT::DarkColourFundamental || colour==PDT::DarkColourAdjoint;
}
bool hasAntiColour(tPPtr p) {
PDT::Colour colour = p->dataPtr()->iColour();
return colour==PDT::Colour3bar || colour==PDT::Colour8 || colour == PDT::Colour6bar ||
colour==PDT::DarkColourAntiFundamental || colour==PDT::DarkColourAdjoint;
}
}
void Sudakov1to2FormFactor::evaluateFinalStateScales(ShowerPartnerType partnerType,
Energy scale, double z,
tShowerParticlePtr parent,
tShowerParticlePtr emitter,
tShowerParticlePtr emitted) {
// identify emitter and emitted
double zEmitter = z, zEmitted = 1.-z;
bool bosonSplitting(false);
// special for g -> gg, particle highest z is emitter
if(emitter->id() == emitted->id() && emitter->id() == parent->id() &&
zEmitted > zEmitter) {
swap(zEmitted,zEmitter);
swap( emitted, emitter);
}
// otherwise if particle ID same
else if(emitted->id()==parent->id()) {
swap(zEmitted,zEmitter);
swap( emitted, emitter);
}
// no real emitter/emitted
else if(emitter->id()!=parent->id()) {
bosonSplitting = true;
}
// may need to add angularOrder flag here
// now the various scales
// QED
if(partnerType==ShowerPartnerType::QED) {
assert(colourStructure()==ChargedChargedNeutral ||
colourStructure()==ChargedNeutralCharged ||
colourStructure()==NeutralChargedCharged ||
colourStructure()==EW);
// normal case
if(!bosonSplitting) {
assert(colourStructure()==ChargedChargedNeutral ||
colourStructure()==ChargedNeutralCharged);
// set the scales
// emitter
emitter->scales().QED = zEmitter*scale;
emitter->scales().QED_noAO = scale;
if(strictAO_) {
emitter->scales().QCD_c = min(zEmitter*scale,parent->scales().QCD_c );
emitter->scales().DARK_c = min(zEmitter*scale,parent->scales().DARK_c );
}
else {
emitter->scales().QCD_c = min( scale,parent->scales().QCD_c );
emitter->scales().DARK_c = min( scale,parent->scales().DARK_c );
}
emitter->scales().QCD_c_noAO = min(scale,parent->scales().QCD_c_noAO);
emitter->scales().DARK_c_noAO = min(scale,parent->scales().DARK_c_noAO);
if(strictAO_) {
emitter->scales().QCD_ac = min(zEmitter*scale,parent->scales().QCD_ac );
emitter->scales().DARK_ac = min(zEmitter*scale,parent->scales().DARK_ac);
}
else {
emitter->scales().QCD_ac = min( scale,parent->scales().QCD_ac );
emitter->scales().DARK_ac = min( scale,parent->scales().DARK_ac);
}
emitter->scales().QCD_ac_noAO = min(scale,parent->scales().QCD_ac_noAO );
emitter->scales().DARK_ac_noAO = min(scale,parent->scales().DARK_ac_noAO);
emitter->scales().EW = min(scale,parent->scales().EW );
// emitted
emitted->scales().QED = zEmitted*scale;
emitted->scales().QED_noAO = scale;
emitted->scales().QCD_c = ZERO;
emitted->scales().QCD_c_noAO = ZERO;
emitted->scales().QCD_ac = ZERO;
emitted->scales().QCD_ac_noAO = ZERO;
emitted->scales().DARK_c = zEmitted*scale;
emitted->scales().DARK_c_noAO = scale;
emitted->scales().DARK_ac = zEmitted*scale;
emitted->scales().DARK_ac_noAO = scale;
emitted->scales().EW = min(scale,parent->scales().EW );
}
// gamma -> f fbar
else {
if (parent->id()==22 && abs(emitter->id())==24 && emitter->id() == - emitted->id())
;
else
assert(colourStructure()==NeutralChargedCharged || colourStructure()==EW);
// emitter
emitter->scales().QED = zEmitter*scale;
emitter->scales().QED_noAO = scale;
if(hasColour(emitter)) {
emitter->scales().QCD_c = zEmitter*scale;
emitter->scales().QCD_c_noAO = scale;
emitter->scales().DARK_c = zEmitter*scale;
emitter->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(emitter)) {
emitter->scales().QCD_ac = zEmitter*scale;
emitter->scales().QCD_ac_noAO = scale;
emitter->scales().DARK_ac = zEmitter*scale;
emitter->scales().DARK_ac_noAO= scale;
}
emitter->scales().EW = zEmitter*scale;
// emitted
emitted->scales().QED = zEmitted*scale;
emitted->scales().QED_noAO = scale;
if(hasColour(emitted)) {
emitted->scales().QCD_c = zEmitted*scale;
emitted->scales().QCD_c_noAO = scale;
emitted->scales().DARK_c = zEmitted*scale;
emitted->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(emitted)) {
emitted->scales().QCD_ac = zEmitted*scale;
emitted->scales().QCD_ac_noAO = scale;
emitted->scales().DARK_ac = zEmitted*scale;
emitted->scales().DARK_ac_noAO= scale;
}
emitted->scales().EW = zEmitted*scale;
}
}
// QCD
else if (partnerType==ShowerPartnerType::QCDColourLine ||
partnerType==ShowerPartnerType::QCDAntiColourLine) {
// normal case eg q -> q g and g -> g g
if(!bosonSplitting) {
if(strictAO_)
emitter->scales().QED = min(zEmitter*scale,parent->scales().QED );
else
emitter->scales().QED = min( scale,parent->scales().QED );
emitter->scales().QED_noAO = min(scale,parent->scales().QED_noAO);
emitter->scales().EW = min(scale,parent->scales().EW );
if(partnerType==ShowerPartnerType::QCDColourLine) {
emitter->scales().QCD_c = zEmitter*scale;
emitter->scales().QCD_c_noAO = scale;
emitter->scales().QCD_ac = min(zEmitter*scale,parent->scales().QCD_ac );
emitter->scales().QCD_ac_noAO = min( scale,parent->scales().QCD_ac_noAO );
emitter->scales().DARK_c = zEmitter*scale;
emitter->scales().DARK_c_noAO = scale;
emitter->scales().DARK_ac = min(zEmitter*scale,parent->scales().DARK_ac );
emitter->scales().DARK_ac_noAO= min( scale,parent->scales().DARK_ac_noAO);
}
else {
emitter->scales().QCD_c = min(zEmitter*scale,parent->scales().QCD_c );
emitter->scales().QCD_c_noAO = min( scale,parent->scales().QCD_c_noAO );
emitter->scales().QCD_ac = zEmitter*scale;
emitter->scales().QCD_ac_noAO = scale;
emitter->scales().DARK_c = min(zEmitter*scale,parent->scales().DARK_c );
emitter->scales().DARK_c_noAO = min( scale,parent->scales().DARK_c_noAO);
emitter->scales().DARK_ac = zEmitter*scale;
emitter->scales().DARK_ac_noAO= scale;
}
// emitted
emitted->scales().QED = ZERO;
emitted->scales().QED_noAO = ZERO;
emitted->scales().QCD_c = zEmitted*scale;
emitted->scales().QCD_c_noAO = scale;
emitted->scales().QCD_ac = zEmitted*scale;
emitted->scales().QCD_ac_noAO = scale;
emitted->scales().EW = min(scale,parent->scales().EW );
emitted->scales().DARK_c = ZERO;
emitted->scales().DARK_c_noAO = ZERO;
emitted->scales().DARK_ac = ZERO;
emitted->scales().DARK_ac_noAO= ZERO;
}
// g -> q qbar
else {
// emitter
if(emitter->dataPtr()->charged()) {
emitter->scales().QED = zEmitter*scale;
emitter->scales().QED_noAO = scale;
}
emitter->scales().EW = zEmitter*scale;
emitter->scales().QCD_c = zEmitter*scale;
emitter->scales().QCD_c_noAO = scale;
emitter->scales().QCD_ac = zEmitter*scale;
emitter->scales().QCD_ac_noAO = scale;
emitter->scales().DARK_c = zEmitter*scale;
emitter->scales().DARK_c_noAO = scale;
emitter->scales().DARK_ac = zEmitter*scale;
emitter->scales().DARK_ac_noAO = scale;
// emitted
if(emitted->dataPtr()->charged()) {
emitted->scales().QED = zEmitted*scale;
emitted->scales().QED_noAO = scale;
}
emitted->scales().EW = zEmitted*scale;
emitted->scales().QCD_c = zEmitted*scale;
emitted->scales().QCD_c_noAO = scale;
emitted->scales().QCD_ac = zEmitted*scale;
emitted->scales().QCD_ac_noAO = scale;
emitted->scales().DARK_c = zEmitted*scale;
emitted->scales().DARK_c_noAO = scale;
emitted->scales().DARK_ac = zEmitted*scale;
emitted->scales().DARK_ac_noAO= scale;
}
}
else if(partnerType==ShowerPartnerType::EW) {
// EW
emitter->scales().EW = zEmitter*scale;
emitted->scales().EW = zEmitted*scale;
// QED
// W radiation AO
if(emitted->dataPtr()->charged()) {
emitter->scales().QED = zEmitter*scale;
emitter->scales().QED_noAO = scale;
emitted->scales().QED = zEmitted*scale;
emitted->scales().QED_noAO = scale;
}
// Z don't
else {
emitter->scales().QED = min(scale,parent->scales().QED );
emitter->scales().QED_noAO = min(scale,parent->scales().QED_noAO);
emitted->scales().QED = ZERO;
emitted->scales().QED_noAO = ZERO;
}
// QCD
emitter->scales().QCD_c = min(scale,parent->scales().QCD_c );
emitter->scales().QCD_c_noAO = min(scale,parent->scales().QCD_c_noAO );
emitter->scales().QCD_ac = min(scale,parent->scales().QCD_ac );
emitter->scales().QCD_ac_noAO = min(scale,parent->scales().QCD_ac_noAO);
emitted->scales().QCD_c = ZERO;
emitted->scales().QCD_c_noAO = ZERO;
emitted->scales().QCD_ac = ZERO;
emitted->scales().QCD_ac_noAO = ZERO;
}
// DARK
else if (partnerType==ShowerPartnerType::DARKColourLine ||
partnerType==ShowerPartnerType::DARKAntiColourLine) {
// normal case eg q -> q g and g -> g g
if(!bosonSplitting) {
if(strictAO_)
emitter->scales().QED = min(zEmitter*scale,parent->scales().QED );
else
emitter->scales().QED = min( scale,parent->scales().QED );
emitter->scales().QED_noAO = min(scale,parent->scales().QED_noAO);
if(partnerType==ShowerPartnerType::QCDColourLine) {
emitter->scales().QCD_c = zEmitter*scale;
emitter->scales().QCD_c_noAO = scale;
emitter->scales().QCD_ac = min(zEmitter*scale,parent->scales().QCD_ac );
emitter->scales().QCD_ac_noAO = min( scale,parent->scales().QCD_ac_noAO);
emitter->scales().DARK_c = zEmitter*scale;
emitter->scales().DARK_c_noAO = scale;
emitter->scales().DARK_ac = min(zEmitter*scale,parent->scales().DARK_ac );
emitter->scales().DARK_ac_noAO= min( scale,parent->scales().DARK_ac_noAO);
}
else {
emitter->scales().QCD_c = min(zEmitter*scale,parent->scales().QCD_c );
emitter->scales().QCD_c_noAO = min( scale,parent->scales().QCD_c_noAO );
emitter->scales().QCD_ac = zEmitter*scale;
emitter->scales().QCD_ac_noAO = scale;
emitter->scales().DARK_c = min(zEmitter*scale,parent->scales().DARK_c );
emitter->scales().DARK_c_noAO = min( scale,parent->scales().DARK_c_noAO);
emitter->scales().DARK_ac = zEmitter*scale;
emitter->scales().DARK_ac_noAO= scale;
}
// emitted
emitted->scales().QED = ZERO;
emitted->scales().QED_noAO = ZERO;
emitted->scales().QCD_c = ZERO;
emitted->scales().QCD_c_noAO = ZERO;
emitted->scales().QCD_ac = ZERO;
emitted->scales().QCD_ac_noAO = ZERO;
emitted->scales().DARK_c = zEmitted*scale;
emitted->scales().DARK_c_noAO = scale;
emitted->scales().DARK_ac = zEmitted*scale;
emitted->scales().DARK_ac_noAO= scale;
}
// g -> q qbar
else {
// emitter
if(emitter->dataPtr()->charged()) {
emitter->scales().QED = zEmitter*scale;
emitter->scales().QED_noAO = scale;
}
emitter->scales().QCD_c = zEmitter*scale;
emitter->scales().QCD_c_noAO = scale;
emitter->scales().QCD_ac = zEmitter*scale;
emitter->scales().QCD_ac_noAO = scale;
emitter->scales().DARK_c = zEmitter*scale;
emitter->scales().DARK_c_noAO = scale;
emitter->scales().DARK_ac = zEmitter*scale;
emitter->scales().DARK_ac_noAO= scale;
// emitted
if(emitted->dataPtr()->charged()) {
emitted->scales().QED = zEmitted*scale;
emitted->scales().QED_noAO = scale;
}
emitted->scales().QCD_c = zEmitted*scale;
emitted->scales().QCD_c_noAO = scale;
emitted->scales().QCD_ac = zEmitted*scale;
emitted->scales().QCD_ac_noAO = scale;
emitted->scales().DARK_c = zEmitted*scale;
emitted->scales().DARK_c_noAO = scale;
emitted->scales().DARK_ac = zEmitted*scale;
emitted->scales().DARK_ac_noAO= scale;
}
}
//shouldn't be anything else
else
assert(false);
}
void Sudakov1to2FormFactor::evaluateInitialStateScales(ShowerPartnerType partnerType,
Energy scale, double z,
tShowerParticlePtr parent,
tShowerParticlePtr spacelike,
tShowerParticlePtr timelike) {
// scale for time-like child
Energy AOScale = (1.-z)*scale;
// QED
if(partnerType==ShowerPartnerType::QED) {
if(parent->id()==spacelike->id()) {
// parent
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
parent ->scales().QCD_c = min(scale,spacelike->scales().QCD_c );
parent ->scales().QCD_c_noAO = min(scale,spacelike->scales().QCD_c_noAO );
parent ->scales().QCD_ac = min(scale,spacelike->scales().QCD_ac );
parent ->scales().QCD_ac_noAO = min(scale,spacelike->scales().QCD_ac_noAO);
parent ->scales().DARK_c = min(scale,spacelike->scales().DARK_c );
parent ->scales().DARK_c_noAO = min(scale,spacelike->scales().DARK_c_noAO );
parent ->scales().DARK_ac = min(scale,spacelike->scales().DARK_ac );
parent ->scales().DARK_ac_noAO= min(scale,spacelike->scales().DARK_ac_noAO);
// timelike
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
timelike->scales().QCD_c = ZERO;
timelike->scales().QCD_c_noAO = ZERO;
timelike->scales().QCD_ac = ZERO;
timelike->scales().QCD_ac_noAO = ZERO;
timelike->scales().DARK_c = ZERO;
timelike->scales().DARK_c_noAO = ZERO;
timelike->scales().DARK_ac = ZERO;
timelike->scales().DARK_ac_noAO= ZERO;
}
else if(parent->id()==timelike->id()) {
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
if(hasColour(parent)) {
parent ->scales().QCD_c = scale;
parent ->scales().QCD_c_noAO = scale;
parent ->scales().DARK_c = scale;
parent ->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(parent)) {
parent ->scales().QCD_ac = scale;
parent ->scales().QCD_ac_noAO = scale;
parent ->scales().DARK_ac = scale;
parent ->scales().DARK_ac_noAO= scale;
}
// timelike
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
if(hasColour(timelike)) {
timelike->scales().QCD_c = AOScale;
timelike->scales().QCD_c_noAO = scale;
timelike->scales().DARK_c = AOScale;
timelike->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(timelike)) {
timelike->scales().QCD_ac = AOScale;
timelike->scales().QCD_ac_noAO = scale;
timelike->scales().DARK_ac = AOScale;
timelike->scales().DARK_ac_noAO= scale;
}
}
else {
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
parent ->scales().QCD_c = ZERO ;
parent ->scales().QCD_c_noAO = ZERO ;
parent ->scales().QCD_ac = ZERO ;
parent ->scales().QCD_ac_noAO = ZERO ;
parent ->scales().DARK_c = ZERO ;
parent ->scales().DARK_c_noAO = ZERO ;
parent ->scales().DARK_ac = ZERO ;
parent ->scales().DARK_ac_noAO= ZERO ;
// timelike
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
if(hasColour(timelike)) {
timelike->scales().QCD_c = min(AOScale,spacelike->scales().QCD_ac );
timelike->scales().QCD_c_noAO = min( scale,spacelike->scales().QCD_ac_noAO );
timelike->scales().DARK_c = min(AOScale,spacelike->scales().DARK_ac );
timelike->scales().DARK_c_noAO = min( scale,spacelike->scales().DARK_ac_noAO);
}
if(hasAntiColour(timelike)) {
timelike->scales().QCD_ac = min(AOScale,spacelike->scales().QCD_c );
timelike->scales().QCD_ac_noAO = min( scale,spacelike->scales().QCD_c_noAO );
timelike->scales().DARK_ac = min(AOScale,spacelike->scales().DARK_c );
timelike->scales().DARK_ac_noAO= min( scale,spacelike->scales().DARK_c_noAO );
}
}
}
// QCD
else if (partnerType==ShowerPartnerType::QCDColourLine ||
partnerType==ShowerPartnerType::QCDAntiColourLine) {
// timelike
if(timelike->dataPtr()->charged()) {
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
}
if(hasColour(timelike)) {
timelike->scales().QCD_c = AOScale;
timelike->scales().QCD_c_noAO = scale;
timelike->scales().DARK_c = AOScale;
timelike->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(timelike)) {
timelike->scales().QCD_ac = AOScale;
timelike->scales().QCD_ac_noAO = scale;
timelike->scales().DARK_ac = AOScale;
timelike->scales().DARK_ac_noAO= scale;
}
if(parent->id()==spacelike->id()) {
parent ->scales().QED = min(scale,spacelike->scales().QED );
parent ->scales().QED_noAO = min(scale,spacelike->scales().QED_noAO );
parent ->scales().QCD_c = min(scale,spacelike->scales().QCD_c );
parent ->scales().QCD_c_noAO = min(scale,spacelike->scales().QCD_c_noAO );
parent ->scales().QCD_ac = min(scale,spacelike->scales().QCD_ac );
parent ->scales().QCD_ac_noAO = min(scale,spacelike->scales().QCD_ac_noAO);
parent ->scales().DARK_c = min(scale,spacelike->scales().DARK_c );
parent ->scales().DARK_c_noAO = min(scale,spacelike->scales().DARK_c_noAO );
parent ->scales().DARK_ac = min(scale,spacelike->scales().DARK_ac );
parent ->scales().DARK_ac_noAO= min(scale,spacelike->scales().DARK_ac_noAO);
}
else {
if(parent->dataPtr()->charged()) {
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
}
if(hasColour(parent)) {
parent ->scales().QCD_c = scale;
parent ->scales().QCD_c_noAO = scale;
parent ->scales().DARK_c = scale;
parent ->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(parent)) {
parent ->scales().QCD_ac = scale;
parent ->scales().QCD_ac_noAO = scale;
parent ->scales().DARK_ac = scale;
parent ->scales().DARK_ac_noAO= scale;
}
}
}
else if(partnerType==ShowerPartnerType::EW) {
if(abs(spacelike->id())!=ParticleID::Wplus &&
spacelike->id() !=ParticleID::Z0 ) {
// QCD scales
parent ->scales().QCD_c = min(scale,spacelike->scales().QCD_c );
parent ->scales().QCD_c_noAO = min(scale,spacelike->scales().QCD_c_noAO );
parent ->scales().QCD_ac = min(scale,spacelike->scales().QCD_ac );
parent ->scales().QCD_ac_noAO = min(scale,spacelike->scales().QCD_ac_noAO);
timelike->scales().QCD_c = ZERO;
timelike->scales().QCD_c_noAO = ZERO;
timelike->scales().QCD_ac = ZERO;
timelike->scales().QCD_ac_noAO = ZERO;
// QED scales
if(timelike->id()==ParticleID::Z0) {
parent ->scales().QED = min(scale,spacelike->scales().QED );
parent ->scales().QED_noAO = min(scale,spacelike->scales().QED_noAO );
timelike->scales().QED = ZERO;
timelike->scales().QED_noAO = ZERO;
}
else {
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
}
// EW scales
parent ->scales().EW = scale;
timelike->scales().EW = AOScale;
}
else assert(false);
}
// DARK
else if(partnerType==ShowerPartnerType::DARKColourLine ||
partnerType==ShowerPartnerType::DARKAntiColourLine ) {
// timelike
if(timelike->dataPtr()->charged()) {
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
}
if(hasColour(timelike)) {
timelike->scales().QCD_c = AOScale;
timelike->scales().QCD_c_noAO = scale;
timelike->scales().DARK_c = AOScale;
timelike->scales().DARK_c_noAO = scale;
}
if(hasAntiColour(timelike)) {
timelike->scales().QCD_ac = AOScale;
timelike->scales().QCD_ac_noAO = scale;
timelike->scales().DARK_ac = AOScale;
timelike->scales().DARK_ac_noAO= scale;
}
if(parent->id()==spacelike->id()) {
parent ->scales().QED = min(scale,spacelike->scales().QED );
parent ->scales().QED_noAO = min(scale,spacelike->scales().QED_noAO );
parent ->scales().QCD_c = min(scale,spacelike->scales().QCD_c );
parent ->scales().QCD_c_noAO = min(scale,spacelike->scales().QCD_c_noAO );
parent ->scales().QCD_ac = min(scale,spacelike->scales().QCD_ac );
parent ->scales().QCD_ac_noAO = min(scale,spacelike->scales().QCD_ac_noAO );
parent ->scales().DARK_c = min(scale,spacelike->scales().DARK_c );
parent ->scales().DARK_c_noAO = min(scale,spacelike->scales().DARK_c_noAO );
parent ->scales().DARK_ac = min(scale,spacelike->scales().DARK_ac );
parent ->scales().DARK_ac_noAO= min(scale,spacelike->scales().DARK_ac_noAO);
}
else {
if(parent->dataPtr()->charged()) {
parent ->scales().QED = scale;
parent ->scales().QED_noAO = scale;
}
if(hasColour(parent)) {
parent ->scales().QCD_c = scale;
parent ->scales().QCD_c_noAO = scale;
parent ->scales().DARK_c = scale;
parent ->scales().DARK_c_noAO= scale;
}
if(hasAntiColour(parent)) {
parent ->scales().QCD_ac = scale;
parent ->scales().QCD_ac_noAO = scale;
parent ->scales().DARK_ac = scale;
parent ->scales().DARK_ac_noAO= scale;
}
}
}
else
assert(false);
}
void Sudakov1to2FormFactor::evaluateDecayScales(ShowerPartnerType partnerType,
Energy scale, double z,
tShowerParticlePtr parent,
tShowerParticlePtr spacelike,
tShowerParticlePtr timelike) {
assert(parent->id()==spacelike->id());
// angular-ordered scale for 2nd child
Energy AOScale = (1.-z)*scale;
// QED
if(partnerType==ShowerPartnerType::QED) {
// timelike
timelike->scales().QED = AOScale;
timelike->scales().QED_noAO = scale;
timelike->scales().QCD_c = ZERO;
timelike->scales().QCD_c_noAO = ZERO;
timelike->scales().QCD_ac = ZERO;
timelike->scales().QCD_ac_noAO = ZERO;
timelike->scales().EW = ZERO;
timelike->scales().DARK_c = ZERO;
timelike->scales().DARK_c_noAO = ZERO;
timelike->scales().DARK_ac = ZERO;
timelike->scales().DARK_ac_noAO= ZERO;
// spacelike
spacelike->scales().QED = scale;
spacelike->scales().QED_noAO = scale;
spacelike->scales().EW = max(scale,parent->scales().EW );
}
// QCD
else if(partnerType==ShowerPartnerType::QCDColourLine ||
partnerType==ShowerPartnerType::QCDAntiColourLine) {
// timelike
timelike->scales().QED = ZERO;
timelike->scales().QED_noAO = ZERO;
timelike->scales().QCD_c = AOScale;
timelike->scales().QCD_c_noAO = scale;
timelike->scales().QCD_ac = AOScale;
timelike->scales().QCD_ac_noAO = scale;
timelike->scales().EW = ZERO;
timelike->scales().DARK_c = ZERO;
timelike->scales().DARK_c_noAO = ZERO;
timelike->scales().DARK_ac = ZERO;
timelike->scales().DARK_ac_noAO= ZERO;
// spacelike
spacelike->scales().QED = max(scale,parent->scales().QED );
spacelike->scales().QED_noAO = max(scale,parent->scales().QED_noAO );
spacelike->scales().EW = max(scale,parent->scales().EW );
}
else if(partnerType==ShowerPartnerType::EW) {
// EW
timelike->scales().EW = AOScale;
spacelike->scales().EW = max(scale,parent->scales().EW );
// QCD
timelike->scales().QCD_c = ZERO;
timelike->scales().QCD_c_noAO = ZERO;
timelike->scales().QCD_ac = ZERO;
timelike->scales().QCD_ac_noAO = ZERO;
timelike->scales().EW = ZERO;
// QED
timelike->scales().QED = ZERO;
timelike->scales().QED_noAO = ZERO;
spacelike->scales().QED = max(scale,parent->scales().QED );
spacelike->scales().QED_noAO = max(scale,parent->scales().QED_noAO );
}
//DARK
else if(partnerType==ShowerPartnerType::DARKColourLine ||
partnerType==ShowerPartnerType::DARKAntiColourLine ) {
// timelike
timelike->scales().QED = ZERO;
timelike->scales().QED_noAO = ZERO;
timelike->scales().QCD_c = ZERO;
timelike->scales().QCD_c_noAO = ZERO;
timelike->scales().QCD_ac = ZERO;
timelike->scales().QCD_ac_noAO = ZERO;
timelike->scales().DARK_c = AOScale;
timelike->scales().DARK_c_noAO = scale;
timelike->scales().DARK_ac = AOScale;
timelike->scales().DARK_ac_noAO = scale;
// spacelike
spacelike->scales().QED = max(scale,parent->scales().QED );
spacelike->scales().QED_noAO = max(scale,parent->scales().QED_noAO );
}
//shouldn't be anything else
else
assert(false);
spacelike->scales().QCD_c = max(scale,parent->scales().QCD_c );
spacelike->scales().QCD_c_noAO = max(scale,parent->scales().QCD_c_noAO );
spacelike->scales().QCD_ac = max(scale,parent->scales().QCD_ac );
spacelike->scales().QCD_ac_noAO = max(scale,parent->scales().QCD_ac_noAO);
spacelike->scales().DARK_c = max(scale,parent->scales().DARK_c );
spacelike->scales().DARK_c_noAO = max(scale,parent->scales().DARK_c_noAO );
spacelike->scales().DARK_ac = max(scale,parent->scales().DARK_ac );
spacelike->scales().DARK_ac_noAO= max(scale,parent->scales().DARK_ac_noAO);
}
void Sudakov1to2FormFactor::doinit() {
SudakovFormFactor::doinit();
assert(interactionType()!=ShowerInteraction::UNDEFINED);
assert((colourStructure()>0&&(interactionType()==ShowerInteraction::QCD ||
interactionType()==ShowerInteraction::DARK)) ||
(colourStructure()<0&&(interactionType()==ShowerInteraction::QED ||
interactionType()==ShowerInteraction::EW)) );
// compute the colour factors if need
if(colourStructure()==TripletTripletOctet) {
colourFactor_ = 4./3.;
}
else if(colourStructure()==OctetOctetOctet) {
colourFactor_ = 3.;
}
else if(colourStructure()==OctetTripletTriplet) {
colourFactor_ = 0.5;
}
else if(colourStructure()==TripletOctetTriplet) {
colourFactor_ = 4./3.;
}
else if(colourStructure() == TripletTripletSinglet ||
colourStructure() == OctetOctetSinglet ||
colourStructure() == Epsilon ) {
colourFactor_ = 1.;
}
else if(colourStructure()==SextetSextetOctet) {
colourFactor_ = 10./3.;
}
else if(colourStructure()<0) {
colourFactor_ = 1.;
}
else {
assert(false);
}
}
double Sudakov1to2FormFactor::colourFactor() const {
if(colourStructure()>0)
return colourFactor_;
else if(colourStructure()<0) {
if(colourStructure()==ChargedChargedNeutral ||
colourStructure()==ChargedNeutralCharged) {
return sqr(double(ids_[0]->iCharge())/3.);
}
else if(colourStructure()==NeutralChargedCharged) {
double fact = sqr(double(ids_[1]->iCharge())/3.);
if(ids_[1]->coloured())
fact *= abs(double(ids_[1]->iColour()));
return fact;
}
else if(colourStructure()==EW) {
return 1.;
}
else {
assert(false);
return 0.;
}
}
else {
assert(false);
return 0.;
}
}
diff --git a/Shower/QTilde/SplittingFunctions/SudakovFormFactor.cc b/Shower/QTilde/SplittingFunctions/SudakovFormFactor.cc
--- a/Shower/QTilde/SplittingFunctions/SudakovFormFactor.cc
+++ b/Shower/QTilde/SplittingFunctions/SudakovFormFactor.cc
@@ -1,337 +1,377 @@
// -*- C++ -*-
//
// SudakovFormFactor.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the SudakovFormFactor class.
//
#include "SudakovFormFactor.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Utilities/DescribeClass.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Utilities/EnumIO.h"
#include "Herwig/Shower/QTilde/QTildeShowerHandler.h"
using namespace Herwig;
void SudakovFormFactor::persistentOutput(PersistentOStream & os) const {
os << alpha_ << pdfMax_ << pdfFactor_ << angularOrdered_
<< oenum(interactionType_) << oenum(colourStructure_) << particles_;
}
void SudakovFormFactor::persistentInput(PersistentIStream & is, int) {
is >> alpha_ >> pdfMax_ >> pdfFactor_ >> angularOrdered_
>> ienum(interactionType_) >> ienum(colourStructure_) >> particles_;
}
// The following static variable is needed for the type
// description system in ThePEG.
DescribeAbstractClass<SudakovFormFactor,Interfaced>
describeHerwigSudakovFormFactor("Herwig::SudakovFormFactor", "HwShower.so");
void SudakovFormFactor::Init() {
static ClassDocumentation<SudakovFormFactor> documentation
("The SudakovFormFactor class is the base class for the implementation of Sudakov"
" form factors in Herwig");
static Reference<SudakovFormFactor,ShowerAlpha>
interfaceAlpha("Alpha",
"A reference to the Alpha object",
&Herwig::SudakovFormFactor::alpha_,
false, false, true, false);
static Switch<SudakovFormFactor,ShowerInteraction>
interfaceInteractionType
("InteractionType",
"Type of the interaction",
&SudakovFormFactor::interactionType_,
ShowerInteraction::UNDEFINED, false, false);
static SwitchOption interfaceInteractionTypeQCD
(interfaceInteractionType,
"QCD","QCD",ShowerInteraction::QCD);
static SwitchOption interfaceInteractionTypeQED
(interfaceInteractionType,
"QED","QED",ShowerInteraction::QED);
static SwitchOption interfaceInteractionTypeEW
(interfaceInteractionType,
"EW","EW",ShowerInteraction::EW);
static SwitchOption interfaceInteractionTypeDARK
(interfaceInteractionType,
"DARK","DARK",ShowerInteraction::DARK);
static Switch<SudakovFormFactor,bool> interfaceAngularOrdered
("AngularOrdered",
"Whether or not this interaction is angular ordered, "
"normally only g->q qbar and gamma-> f fbar are the only ones which aren't.",
&SudakovFormFactor::angularOrdered_, true, false, false);
static SwitchOption interfaceAngularOrderedYes
(interfaceAngularOrdered,
"Yes",
"Interaction is angular ordered",
true);
static SwitchOption interfaceAngularOrderedNo
(interfaceAngularOrdered,
"No",
"Interaction isn't angular ordered",
false);
static Switch<SudakovFormFactor,ColourStructure> interfaceColourStructure
("ColourStructure",
"The colour structure for the splitting function",
&SudakovFormFactor::colourStructure_, Undefined, false, false);
static SwitchOption interfaceColourStructureTripletTripletOctet
(interfaceColourStructure,
"TripletTripletOctet",
"3 -> 3 8",
TripletTripletOctet);
static SwitchOption interfaceColourStructureOctetOctetOctet
(interfaceColourStructure,
"OctetOctetOctet",
"8 -> 8 8",
OctetOctetOctet);
static SwitchOption interfaceColourStructureOctetTripletTriplet
(interfaceColourStructure,
"OctetTripletTriplet",
"8 -> 3 3bar",
OctetTripletTriplet);
static SwitchOption interfaceColourStructureTripletOctetTriplet
(interfaceColourStructure,
"TripletOctetTriplet",
"3 -> 8 3",
TripletOctetTriplet);
static SwitchOption interfaceColourStructureSextetSextetOctet
(interfaceColourStructure,
"SextetSextetOctet",
"6 -> 6 8",
SextetSextetOctet);
-
+ static SwitchOption interfaceColourStructureTripletTripletSinglet
+ (interfaceColourStructure,
+ "TripletTripletSinglet",
+ "3 -> 3 1",
+ TripletTripletSinglet);
+ static SwitchOption interfaceColourStructureOctetOctetSinglet
+ (interfaceColourStructure,
+ "OctetOctetSinglet",
+ "8 -> 8 1",
+ OctetOctetSinglet);
+ static SwitchOption interfaceColourStructureEpsilon
+ (interfaceColourStructure,
+ "Epsilon",
+ "3 -> 3 3",
+ Epsilon);
+ static SwitchOption interfaceColourStructureOctetSinglet
+ (interfaceColourStructure,
+ "OctetSinglet",
+ "8 -> 8 1",
+ OctetSinglet);
static SwitchOption interfaceColourStructureChargedChargedNeutral
(interfaceColourStructure,
"ChargedChargedNeutral",
"q -> q 0",
ChargedChargedNeutral);
static SwitchOption interfaceColourStructureNeutralChargedCharged
(interfaceColourStructure,
"NeutralChargedCharged",
"0 -> q qbar",
NeutralChargedCharged);
static SwitchOption interfaceColourStructureChargedNeutralCharged
(interfaceColourStructure,
"ChargedNeutralCharged",
"q -> 0 q",
ChargedNeutralCharged);
static SwitchOption interfaceColourStructureEW
(interfaceColourStructure,
"EW",
"q -> q W/Z, q -> q h0, V -> V' V'', V -> V H",
EW);
static Parameter<SudakovFormFactor,double> interfacePDFMax
("PDFmax",
"Maximum value of PDF weight. ",
&SudakovFormFactor::pdfMax_, 35.0, 1.0, 1000000.0,
false, false, Interface::limited);
static Switch<SudakovFormFactor,unsigned int> interfacePDFFactor
("PDFFactor",
"Include additional factors in the overestimate for the PDFs",
&SudakovFormFactor::pdfFactor_, 0, false, false);
static SwitchOption interfacePDFFactorNo
(interfacePDFFactor,
"No",
"Don't include any factors",
0);
static SwitchOption interfacePDFFactorOverZ
(interfacePDFFactor,
"OverZ",
"Include an additional factor of 1/z",
1);
static SwitchOption interfacePDFFactorOverOneMinusZ
(interfacePDFFactor,
"OverOneMinusZ",
"Include an additional factor of 1/(1-z)",
2);
static SwitchOption interfacePDFFactorOverZOneMinusZ
(interfacePDFFactor,
"OverZOneMinusZ",
"Include an additional factor of 1/z/(1-z)",
3);
static SwitchOption interfacePDFFactorOverRootZ
(interfacePDFFactor,
"OverRootZ",
"Include an additional factor of 1/sqrt(z)",
4);
static SwitchOption interfacePDFFactorRootZ
(interfacePDFFactor,
"RootZ",
"Include an additional factor of sqrt(z)",
5);
}
bool SudakovFormFactor::checkColours(const IdList & ids) const {
if(colourStructure_==TripletTripletOctet) {
if(ids[0]!=ids[1]) return false;
if((ids[0]->iColour()==PDT::Colour3||ids[0]->iColour()==PDT::Colour3bar) &&
ids[2]->iColour()==PDT::Colour8) return true;
return false;
}
else if(colourStructure_==OctetOctetOctet) {
for(unsigned int ix=0;ix<3;++ix) {
if(ids[ix]->iColour()!=PDT::Colour8) return false;
}
return true;
}
else if(colourStructure_==OctetTripletTriplet) {
if(ids[0]->iColour()!=PDT::Colour8) return false;
if(ids[1]->iColour()==PDT::Colour3&&ids[2]->iColour()==PDT::Colour3bar)
return true;
if(ids[1]->iColour()==PDT::Colour3bar&&ids[2]->iColour()==PDT::Colour3)
return true;
return false;
}
else if(colourStructure_==TripletOctetTriplet) {
if(ids[0]!=ids[2]) return false;
if((ids[0]->iColour()==PDT::Colour3||ids[0]->iColour()==PDT::Colour3bar) &&
ids[1]->iColour()==PDT::Colour8) return true;
return false;
}
else if(colourStructure_==SextetSextetOctet) {
if(ids[0]!=ids[1]) return false;
if((ids[0]->iColour()==PDT::Colour6 || ids[0]->iColour()==PDT::Colour6bar) &&
ids[2]->iColour()==PDT::Colour8) return true;
return false;
}
+ else if(colourStructure_==TripletTripletSinglet) {
+ if(ids[0]->iColour()!=ids[1]->iColour()) return false;
+ if((ids[0]->iColour()==PDT::Colour3||ids[0]->iColour()==PDT::Colour3bar) &&
+ ids[2]->iColour()==PDT::Colour0) return true;
+ return false;
+ }
+ else if(colourStructure_==OctetOctetSinglet) {
+ if(ids[0]!=ids[1]) return false;
+ if(ids[0]->iColour()==PDT::Colour8 && ids[2]->iColour()==PDT::Colour0) return true;
+ return false;
+ }
+ else if(colourStructure_==Epsilon) {
+ if(ids[0]->iColour()!=PDT::Colour3&&ids[0]->iColour()!=PDT::Colour3bar) return false;
+ if(ids[0]->iColour()!=-ids[1]->iColour()) return false;
+ if(ids[0]->iColour()!=-ids[2]->iColour()) return false;
+ return true;
+ }
+ else if(colourStructure_==OctetSinglet) {
+ if(ids[0]->iColour()==PDT::Colour8 && ids[1]->iColour()==PDT::Colour0) return true;
+ return false;
+ }
else if(colourStructure_==ChargedChargedNeutral) {
if(ids[0]!=ids[1]) return false;
if(ids[2]->iCharge()!=0) return false;
if(ids[0]->iCharge()==ids[1]->iCharge()) return true;
return false;
}
else if(colourStructure_==ChargedNeutralCharged) {
if(ids[0]!=ids[2]) return false;
if(ids[1]->iCharge()!=0) return false;
if(ids[0]->iCharge()==ids[2]->iCharge()) return true;
return false;
}
else if(colourStructure_==NeutralChargedCharged) {
if(ids[1]->id()!=-ids[2]->id()) return false;
if(ids[0]->iCharge()!=0) return false;
if(ids[1]->iCharge()==-ids[2]->iCharge()) return true;
return false;
}
else {
assert(false);
}
return false;
}
void SudakovFormFactor::addSplitting(const IdList & in) {
bool add=true;
for(unsigned int ix=0;ix<particles_.size();++ix) {
if(particles_[ix].size()==in.size()) {
bool match=true;
for(unsigned int iy=0;iy<in.size();++iy) {
if(particles_[ix][iy]!=in[iy]) {
match=false;
break;
}
}
if(match) {
add=false;
break;
}
}
}
if(add) particles_.push_back(in);
}
void SudakovFormFactor::removeSplitting(const IdList & in) {
for(vector<IdList>::iterator it=particles_.begin();
it!=particles_.end();++it) {
if(it->size()==in.size()) {
bool match=true;
for(unsigned int iy=0;iy<in.size();++iy) {
if((*it)[iy]!=in[iy]) {
match=false;
break;
}
}
if(match) {
vector<IdList>::iterator itemp=it;
--itemp;
particles_.erase(it);
it = itemp;
}
}
}
}
bool SudakovFormFactor::PDFVeto(const Energy2 t, const double x, const double z,
const tcPDPtr parton0, const tcPDPtr parton1,
Ptr<BeamParticleData>::transient_const_pointer beam) const {
double ratio=PDFVetoRatio(t,x,z,parton0,parton1,beam,1.);
return UseRandom::rnd() > ratio;
}
double SudakovFormFactor::PDFVetoRatio(const Energy2 t, const double x, const double z,
const tcPDPtr parton0, const tcPDPtr parton1,
Ptr<BeamParticleData>::transient_const_pointer beam,double factor) const {
assert(pdf_);
Energy2 theScale = t * sqr(ShowerHandler::currentHandler()->factorizationScaleFactor()*factor);
if (theScale < sqr(freeze_)) theScale = sqr(freeze_);
const double newpdf=pdf_->xfx(beam,parton0,theScale,x/z);
if(newpdf<=0.) return 0.;
const double oldpdf=pdf_->xfx(beam,parton1,theScale,x);
if(oldpdf<=0.) return 1.;
const double ratio = newpdf/oldpdf;
double maxpdf = pdfMax_;
switch (pdfFactor_) {
case 0: break;
case 1: maxpdf /= z; break;
case 2: maxpdf /= 1.-z; break;
case 3: maxpdf /= (z*(1.-z)); break;
case 4: maxpdf /= sqrt(z); break;
case 5: maxpdf *= sqrt(z); break;
default :
throw Exception() << "SudakovFormFactor::PDFVetoRatio invalid PDFfactor = "
<< pdfFactor_ << Exception::runerror;
}
if (ratio > maxpdf) {
generator()->log() << "PDFVeto warning: Ratio > " << name()
<< ":PDFmax (by a factor of "
<< ratio/maxpdf <<") for "
<< parton0->PDGName() << " to "
<< parton1->PDGName() << "\n";
}
return ratio/maxpdf ;
}
bool SudakovFormFactor::alphaSVeto(Energy2 pt2) const {
double ratio=alphaSVetoRatio(pt2,1.);
return UseRandom::rnd() > ratio;
}
double SudakovFormFactor::alphaSVetoRatio(Energy2 pt2, double factor) const {
if(ShowerHandler::currentHandlerIsSet())
factor *= ShowerHandler::currentHandler()->renormalizationScaleFactor();
return alpha_->showerRatio(pt2, factor);
}
diff --git a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h b/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/ZeroZeroOneEWSplitFn.h
@@ -1,256 +1,256 @@
// -*- C++ -*-
#ifndef Herwig_ZeroZeroOneEWSplitFn_H
#define Herwig_ZeroZeroOneEWSplitFn_H
//
// This is the declaration of the ZeroZeroOneEWSplitFn class.
//
#include "Sudakov1to2FormFactor.h"
#include "Herwig/Models/StandardModel/StandardModel.h"
#include "Herwig/Decay/TwoBodyDecayMatrixElement.h"
namespace Herwig {
using namespace ThePEG;
/**
* The ZeroZeroOneEWSplitFn class implements the splitting function for
* \f$\1\to q\1 0\f$ where the spin-1 particles are the W / Z massive
* electroweak gauge bosons and the spin-0 particle is the massive Higgs
* boson.
*
* @see \ref ZeroZeroOneEWSplitFnInterfaces "The interfaces"
* defined for ZeroZeroOneEWSplitFn.
*/
class ZeroZeroOneEWSplitFn: public Sudakov1to2FormFactor {
public:
/**
* Concrete implementation of the method to determine whether this splitting
* function can be used for a given set of particles.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual bool accept(const IdList & ids) const {
if(ids.size()!=3)
return false;
if(_couplingValueIm==0.&&_couplingValueRe==0.)
return false;
if(ids[0]->iCharge()!=ids[1]->iCharge()+ids[2]->iCharge())
return false;
if(ids[0]->iSpin()==PDT::Spin0 && ids[1]->iSpin()==PDT::Spin1 && ids[2]->iSpin()==PDT::Spin0)
return true;
else if(ids[0]->iSpin()==PDT::Spin0 && ids[1]->iSpin()==PDT::Spin0 && ids[2]->iSpin()==PDT::Spin1)
return true;
else
return false;
}
/**
* Methods to return the splitting function.
*/
//@{
/**
* The concrete implementation of the overestimate of the splitting function,
* \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual double overestimateP(const double z, const IdList & ids) const {
Complex ghhv(0.,0.);
getCouplings(ghhv,ids);
return norm(ghhv)*2*z/(1.-z);
}
/**
* The concrete implementation of the
* the ratio of the splitting function to the overestimate, i.e.
* \f$P(z,t)/P_{\rm over}(z)\f$.
* @param z The energy fraction.
* @param t The scale.
* @param ids The PDG codes for the particles in the splitting.
* @param mass Whether or not to include the mass dependent terms
* @param rho The spin density matrix
*/
virtual double ratioP(const double z, const Energy2 t, const IdList & ids,
- const bool mass, const RhoDMatrix & rho) const {
+ const bool mass, const RhoDMatrix & ) const {
// ratio in the massless limit
double val = 1.;
// the massive limit
if(mass){
// get the running mass
double m0t2 = sqr(getParticleData(ids[0]->id())->mass())/t;
double m1t2 = sqr(getParticleData(ids[1]->id())->mass())/t;
double m2t2 = sqr(getParticleData(ids[2]->id())->mass())/t;
val += m0t2-(1./z)*m1t2+((1.-z)/(4.*z))*m2t2;
}
return val;
}
/**
* The concrete implementation of the indefinite integral of the
* overestimated splitting function, \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double integOverP(const double z, const IdList & ids,
unsigned int PDFfactor=0) const {
assert(PDFfactor==0);
Complex ghhv(0.,0.);
getCouplings(ghhv,ids);
double pre = norm(ghhv)*2.;
return -pre*(z+log(1.-z));
}
/**
* The concrete implementation of the inverse of the indefinite integral.
* @param r Value of the splitting function to be inverted
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double invIntegOverP(const double r, const IdList & ids,
unsigned int PDFfactor=0) const {
assert(PDFfactor==0);
Complex ghhv(0.,0.);
getCouplings(ghhv,ids);
double pre = norm(ghhv)*2.;
return 1.-exp(-(1.+r/pre));
}
//@}
/**
* Method to calculate the azimuthal angle
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
- generatePhiForward(const double z, const Energy2 t, const IdList & ids,
- const RhoDMatrix &) {
+ generatePhiForward(const double , const Energy2 , const IdList & ,
+ const RhoDMatrix &) {
// no dependence on the spin density matrix, dependence on off-diagonal terms cancels
// and rest = splitting function for Tr(rho)=1 as required by defn
return vector<pair<int, Complex> >(1,make_pair(0,1.));
}
/**
* Method to calculate the azimuthal angle for backward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
- generatePhiBackward(const double z, const Energy2 t, const IdList & ids,
+ generatePhiBackward(const double , const Energy2 , const IdList & ,
const RhoDMatrix &) {
// no dependence on the spin density matrix, dependence on off-diagonal terms cancels
// and rest = splitting function for Tr(rho)=1 as required by defn
return vector<pair<int, Complex> >(1,make_pair(0,1.));
}
/**
* Calculate the matrix element for the splitting
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
*/
virtual DecayMEPtr matrixElement(const double z, const Energy2 t,
- const IdList & ids, const double phi, bool timeLike) {
+ const IdList & ids, const double phi, bool ) {
Complex ghhv(0.,0.);
getCouplings(ghhv,ids);
// calculate the kernal
DecayMEPtr kernal(new_ptr(TwoBodyDecayMatrixElement(PDT::Spin0,PDT::Spin0,PDT::Spin1)));
double m0t2 = sqr(getParticleData(ids[0]->id())->mass())/t;
double m1t2 = sqr(getParticleData(ids[1]->id())->mass())/t;
double m2t2 = sqr(getParticleData(ids[2]->id())->mass())/t;
Complex phase = exp(Complex(0.,1.)*phi);
Complex cphase = conj(phase);
double sqrtmass = sqrt(m0t2*z*(1.-z)-m1t2*(1.-z)-m2t2*z+z*(1.-z));
// assign kernel
(*kernal)(0,0,0) = -phase*ghhv*sqrtmass/(1.-z); // 111
(*kernal)(1,0,0) = -sqrt(m2t2)*(1.+z)/sqrt(2.*(1.-z)); // 211 -> 411
(*kernal)(2,0,0) = cphase*ghhv*sqrtmass/(1.-z); // 311
// return the answer
return kernal;
}
protected:
/**
* Get the couplings
*/
- void getCouplings(Complex & g, const IdList & ids) const {
+ void getCouplings(Complex & g, const IdList & ) const {
g = Complex(_couplingValueRe,_couplingValueIm);
}
public:
/** @name Functions used by the persistent I/O system. */
//@{
/**
* Function used to write out object persistently.
* @param os the persistent output stream written to.
*/
void persistentOutput(PersistentOStream & os) const;
/**
* Function used to read in object persistently.
* @param is the persistent input stream read from.
* @param version the version number of the object when written.
*/
void persistentInput(PersistentIStream & is, int version);
//@}
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const;
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const;
//@}
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
ZeroZeroOneEWSplitFn & operator=(const ZeroZeroOneEWSplitFn &) = delete;
private:
/**
* numerical value of the splitting coupling to be imported for BSM splittings
*/
double _couplingValueIm = 0.;
double _couplingValueRe = 0.;
};
}
#endif /* Herwig_ZeroZeroOneEWSplitFn_H */
diff --git a/Shower/QTilde/SplittingFunctions/ZeroZeroZeroEWSplitFn.h b/Shower/QTilde/SplittingFunctions/ZeroZeroZeroEWSplitFn.h
--- a/Shower/QTilde/SplittingFunctions/ZeroZeroZeroEWSplitFn.h
+++ b/Shower/QTilde/SplittingFunctions/ZeroZeroZeroEWSplitFn.h
@@ -1,231 +1,231 @@
// -*- C++ -*-
#ifndef Herwig_ZeroZeroZeroEWSplitFn_H
#define Herwig_ZeroZeroZeroEWSplitFn_H
//
// This is the declaration of the ZeroZeroZeroEWSplitFn class.
//
#include "Sudakov1to2FormFactor.h"
#include "Herwig/Models/StandardModel/StandardModel.h"
namespace Herwig {
using namespace ThePEG;
/**
* The ZeroZeroZeroEWSplitFn class implements the splitting function for
* \f$\frac12\to q\frac12 h\f$ where the spin-0 higgs particle is a massive scalar boson.
*
* @see \ref ZeroZeroZeroEWSplitFnInterfaces "The interfaces"
* defined for ZeroZeroZeroEWSplitFn.
*/
class ZeroZeroZeroEWSplitFn: public Sudakov1to2FormFactor {
public:
/**
* Concrete implementation of the method to determine whether this splitting
* function can be used for a given set of particles.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual bool accept(const IdList & ids) const;
/**
* Methods to return the splitting function.
*/
//@{
/**
* The concrete implementation of the overestimate of the splitting function,
* \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
*/
virtual double overestimateP(const double z, const IdList & ids) const {
Complex ghhh(0.,0.);
getCouplings(ghhh,ids);
return norm(ghhh)/(2.*z*(1.-z));
}
/**
* The concrete implementation of the
* the ratio of the splitting function to the overestimate, i.e.
* \f$P(z,t)/P_{\rm over}(z)\f$.
* @param z The energy fraction.
* @param t The scale.
* @param ids The PDG codes for the particles in the splitting.
* @param mass Whether or not to include the mass dependent terms
* @param rho The spin density matrix
*/
- virtual double ratioP(const double z, const Energy2 t, const IdList & ids,
- const bool mass, const RhoDMatrix & rho) const {
+ virtual double ratioP(const double z, const Energy2 t, const IdList & ,
+ const bool , const RhoDMatrix & ) const {
return z*(1.-z)/t*GeV2;
}
/**
* The concrete implementation of the indefinite integral of the
* overestimated splitting function, \f$P_{\rm over}\f$.
* @param z The energy fraction.
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double integOverP(const double z, const IdList & ids,
unsigned int PDFfactor=0) const;
/**
* The concrete implementation of the inverse of the indefinite integral.
* @param r Value of the splitting function to be inverted
* @param ids The PDG codes for the particles in the splitting.
* @param PDFfactor Which additional factor to include for the PDF
* 0 is no additional factor,
* 1 is \f$1/z\f$, 2 is \f$1/(1-z)\f$ and 3 is \f$1/z/(1-z)\f$
*/
virtual double invIntegOverP(const double r, const IdList & ids,
unsigned int PDFfactor=0) const;
//@}
/**
* Method to calculate the azimuthal angle
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiForward(const double, const Energy2, const IdList &,
const RhoDMatrix &) {
// scalar so no dependence
return {{ {0, 1.} }};
}
/**
* Method to calculate the azimuthal angle for backward evolution
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
* @return The weight
*/
virtual vector<pair<int,Complex> >
generatePhiBackward(const double, const Energy2, const IdList &,
const RhoDMatrix &) {
// scalar so no dependence
assert(false);
return {{ {0, 1.} }};
}
/**
* Calculate the matrix element for the splitting
* @param z The energy fraction
* @param t The scale \f$t=2p_j\cdot p_k\f$.
* @param ids The PDG codes for the particles in the splitting.
* @param The azimuthal angle, \f$\phi\f$.
*/
virtual DecayMEPtr matrixElement(const double z, const Energy2 t,
const IdList & ids, const double phi, bool timeLike);
protected:
/**
* Get the couplings
* @param g The couplings ( for the SM case, this is g_SM/(e*mH^2) )
* @param ids The PDG codes for the particles in the splitting.
*/
void getCouplings(Complex & g, const IdList & ids) const;
/**
* Get the couplings with running masses
* @param g The couplings ( for the SM case, this is g_SM/(e*mH^2) )
* @param ids The PDG codes for the particles in the splitting.
* @param t The scale \f$t=2p_j\cdot p_k\f$.
*/
void getCouplings(Complex & g, const IdList & ids, const Energy2 t) const;
public:
/** @name Functions used by the persistent I/O system. */
//@{
/**
* Function used to write out object persistently.
* @param os the persistent output stream written to.
*/
void persistentOutput(PersistentOStream & os) const;
/**
* Function used to read in object persistently.
* @param is the persistent input stream read from.
* @param version the version number of the object when written.
*/
void persistentInput(PersistentIStream & is, int version);
//@}
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const;
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const;
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
//@}
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
ZeroZeroZeroEWSplitFn & operator=(const ZeroZeroZeroEWSplitFn &) = delete;
private:
/**
* 1 / sin theta_w
*/
double gw_;
/**
* numerical value of the splitting coupling to be imported for BSM splittings
*/
double _couplingValueIm = 0.;
double _couplingValueRe = 0.;
/**
* Pointer to the SM object.
*/
tcHwSMPtr _theSM;
};
}
#endif /* Herwig_ZeroZeroZeroEWSplitFn_H */
diff --git a/Tests/Makefile.am b/Tests/Makefile.am
--- a/Tests/Makefile.am
+++ b/Tests/Makefile.am
@@ -1,416 +1,420 @@
AM_LDFLAGS += -module -avoid-version -rpath /dummy/path/not/used
EXTRA_DIST = Inputs python Rivet
EXTRA_LTLIBRARIES = LeptonTest.la GammaTest.la HadronTest.la DISTest.la
if WANT_LIBFASTJET
EXTRA_LTLIBRARIES += HadronJetTest.la LeptonJetTest.la
HadronJetTest_la_SOURCES = \
Hadron/VHTest.h Hadron/VHTest.cc\
Hadron/VTest.h Hadron/VTest.cc\
Hadron/HTest.h Hadron/HTest.cc
HadronJetTest_la_CPPFLAGS = $(AM_CPPFLAGS) $(FASTJETINCLUDE) \
-I$(FASTJETPATH)
HadronJetTest_la_LIBADD = $(FASTJETLIBS)
LeptonJetTest_la_SOURCES = \
Lepton/TopDecay.h Lepton/TopDecay.cc
LeptonJetTest_la_CPPFLAGS = $(AM_CPPFLAGS) $(FASTJETINCLUDE) \
-I$(FASTJETPATH)
LeptonJetTest_la_LIBADD = $(FASTJETLIBS)
endif
LeptonTest_la_SOURCES = \
Lepton/VVTest.h Lepton/VVTest.cc \
Lepton/VBFTest.h Lepton/VBFTest.cc \
Lepton/VHTest.h Lepton/VHTest.cc \
Lepton/FermionTest.h Lepton/FermionTest.cc
GammaTest_la_SOURCES = \
Gamma/GammaMETest.h Gamma/GammaMETest.cc \
Gamma/GammaPMETest.h Gamma/GammaPMETest.cc
DISTest_la_SOURCES = \
DIS/DISTest.h DIS/DISTest.cc
HadronTest_la_SOURCES = \
Hadron/HadronVVTest.h Hadron/HadronVVTest.cc\
Hadron/HadronVBFTest.h Hadron/HadronVBFTest.cc\
Hadron/WHTest.h Hadron/WHTest.cc\
Hadron/ZHTest.h Hadron/ZHTest.cc\
Hadron/VGammaTest.h Hadron/VGammaTest.cc\
Hadron/ZJetTest.h Hadron/ZJetTest.cc\
Hadron/WJetTest.h Hadron/WJetTest.cc\
Hadron/QQHTest.h Hadron/QQHTest.cc
REPO = $(top_builddir)/src/HerwigDefaults.rpo
HERWIG = $(top_builddir)/src/Herwig
HWREAD = $(HERWIG) read --repo $(REPO) -L $(builddir)/.libs -i $(top_builddir)/src
HWBUILD = $(HERWIG) build --repo $(REPO) -L $(builddir)/.libs -i $(top_builddir)/src
HWINTEGRATE = $(HERWIG) integrate
HWRUN = $(HERWIG) run -N $${NUMEVENTS:-10000}
tests : tests-LEP tests-DIS tests-LHC tests-Gamma
LEPDEPS = \
test-LEP-VV \
test-LEP-VH \
test-LEP-VBF \
test-LEP-BB \
test-LEP-Quarks \
test-LEP-Leptons
if WANT_LIBFASTJET
LEPDEPS += test-LEP-TopDecay
endif
tests-LEP : $(LEPDEPS)
tests-DIS : test-DIS-Charged test-DIS-Neutral
LHCDEPS = \
test-LHC-WW test-LHC-WZ test-LHC-ZZ \
test-LHC-ZGamma test-LHC-WGamma \
test-LHC-ZH test-LHC-WH \
test-LHC-ZJet test-LHC-WJet \
test-LHC-Z test-LHC-W \
test-LHC-ZZVBF test-LHC-VBF \
test-LHC-WWVBF \
test-LHC-bbH test-LHC-ttH \
test-LHC-GammaGamma test-LHC-GammaJet \
test-LHC-Higgs test-LHC-HiggsJet \
test-LHC-QCDFast test-LHC-QCD \
test-LHC-Top
if WANT_LIBFASTJET
LHCDEPS += \
test-LHC-Bottom \
test-LHC-WHJet test-LHC-ZHJet test-LHC-HJet \
test-LHC-ZShower test-LHC-WShower \
test-LHC-WHJet-Powheg test-LHC-ZHJet-Powheg test-LHC-HJet-Powheg \
test-LHC-ZShower-Powheg test-LHC-WShower-Powheg
endif
tests-LHC : $(LHCDEPS)
tests-Gamma : test-Gamma-FF test-Gamma-WW test-Gamma-P
LEPLIBS = LeptonTest.la
HADLIBS = HadronTest.la
if WANT_LIBFASTJET
LEPLIBS += LeptonJetTest.la
HADLIBS += HadronJetTest.la
endif
test-LEP-% : Inputs/LEP-%.in $(LEPLIBS)
$(HWREAD) $<
$(HWRUN) $(notdir $(subst .in,.run,$<))
test-Gamma-% : Inputs/Gamma-%.in GammaTest.la
$(HWREAD) $<
$(HWRUN) $(notdir $(subst .in,.run,$<))
test-DIS-% : Inputs/DIS-%.in DISTest.la
$(HWREAD) $<
$(HWRUN) $(notdir $(subst .in,.run,$<))
test-LHC-% : Inputs/LHC-%.in GammaTest.la $(HADLIBS)
$(HWREAD) $<
$(HWRUN) $(notdir $(subst .in,.run,$<))
tests-Rivet : Rivet-EE Rivet-DIS Rivet-Fixed \
Rivet-TVT-WZ Rivet-TVT-Photon Rivet-TVT-Jets \
Rivet-LHC-Jets Rivet-LHC-EW Rivet-LHC-Photon Rivet-LHC-Higgs
Rivet-%-UE-Cent.yoda : Rivet-%-UE-Cent.run Rivet-%-Cent.run
rm -rf $(subst .yoda,,$@)
mkdir $(subst .yoda,,$@)
mv $(subst .yoda,.run,$@) $(subst UE-,,$(subst .yoda,.run,$@)) $(subst .yoda,,$@)
cd $(subst .yoda,,$@); ../$(HWRUN) $(subst UE-,,$(subst .yoda,.run,$@)); mv $(subst UE-,,$@) ALICE_2015_PPCentrality.yoda
cd $(subst .yoda,,$@); export RIVET_ANALYSIS_PATH=`pwd`; ../$(HWRUN) $(subst .yoda,.run,$@)
mv $(subst .yoda,,$@)/$@ .
rm -rf $(subst .yoda,,$@)
Rivet-%.run : Rivet/%.in
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWBUILD) -c .cache/$(subst .run,,$@) $<
Rivet-Matchbox-%.yoda : Rivet-Matchbox-%.run
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWINTEGRATE) -c .cache/$(subst .run,,$<) $<
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWRUN) -c .cache/$(subst .run,,$<) $<
Rivet-%.yoda : Rivet-%.run
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWRUN) $<
Rivet/%.in :
python/make_input_files.py $(notdir $(subst .in,,$@))
Rivet-inputfiles: $(shell echo Rivet/EE{,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg,-Merging}-{7.7,9.4,12,13,17,27.6,27.7,29,30.2,30.3,30.5,30.7,30.8,30,31.2,31.3,31.6,34,34.8,41,41.5,42.1,42.6,43.5,43.6,45,50,52,53.3,55,55.3,56,57,58,59.5,60.8,60,61.4,65.4,66,75.7,76,82,85,10,12.8,21.5,22,22.5,25,26.8,34.5,35,36.2,44,48.0,91,93.0,130,130.1,133,136,161,161.3,172,172.3,177,182.8,183,188.6,189,192,194.4,196,197,200,200.2,202,205,206,206.2,207,91-nopi}.in) \
$(shell echo Rivet/EE-{183,189}-WW.in) \
$(shell echo Rivet/EE{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Powheg,-Matchbox-Powheg}-{14,14.8}.in) \
$(shell echo Rivet/EE{,-Dipole}-{10.5,11.96,12.8,13.96,16.86,21.84,26.8,28.48,35.44,48.0,97.0}-gg.in) \
$(shell echo Rivet/EE{,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg}-{2.2,2.6,3.0,3.2,4.17,4.3,4.41,5.0,5.2,4.6,4.8,5.8,6.2,6.5,6.6,7.0,7.4,3.63,4.03,4.5,8.8,9.27,9.46,9.51,10.52,10.52-sym,10.54,10.58,10.45,10.47,10.6}.in) \
$(shell echo Rivet/EE-{Upsilon,Upsilon2,Upsilon3,Upsilon4,Upsilon5,Upsilon4-asym,JPsi,Psi2S,Psi2S-All,Psi3770,Tau,Phi,Lambdac,Omega-Meson,Omega-Baryon,Eta,Xi0,Xic0,Xicp,Omegac0,Ds,Bc,Etac,Xim}.in) \
$(shell echo Rivet/DIS{,-NoME,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg,-Merging}-{225,251,300,318,318-CMS}-e+-{VeryLow,Low,Med,High}Q2.in) \
$(shell echo Rivet/DIS{,-NoME,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg,-Merging}-318-{e+,e-}-CC-{VeryLow,Low,Med,High}Q2.in) \
$(shell echo Rivet/DIS{,-NoME,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg,-Merging}-{296,300,318}-e--{VeryLow,Low,Med,High}Q2.in) \
$(shell echo Rivet/TVT{,-Powheg,-Matchbox,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox-Powheg,-Merging}-{Run-I-Z,Run-I-W,Run-I-WZ,Run-II-Z-e,Run-II-Z-{,LowMass-,HighMass-}mu,Run-II-W}.in) \
$(shell echo Rivet/TVT{,-Dipole}-Run-II-{DiPhoton-GammaGamma,DiPhoton-GammaJet,PromptPhoton}.in) \
$(shell echo Rivet/TVT-Powheg-Run-II-{DiPhoton-GammaGamma,DiPhoton-GammaJet}.in) \
$(shell echo Rivet/TVT{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-Run-{I,II}-{Jets-{1..6},DiJets-{1..4}}.in ) \
$(shell echo Rivet/TVT{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-{630-Jets-{1..3},300-Jets-1,900-Jets-1}.in ) \
$(shell echo Rivet/TVT{,-Dipole}-{Run-I,Run-II,300,630,900}-UE.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-7-DiJets-{1..7}-{A,B,C}.in ) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-13-DiJets-{{1..11}-A,{6..11}-B}.in ) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-{7,8,13}-Jets-{0..10}.in ) \
$(shell echo Rivet/LHC{,-Dipole}-{900,2360,2760,7,8,13}-UE.in ) \
$(shell echo Rivet/LHC{,-Dipole}-2760-Jets-{1..3}.in ) \
$(shell echo Rivet/LHC{,-Dipole}-{900,7,13}-UE-Long.in ) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-7-Charm-{0..5}.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-{5,13}-Charm-0.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-7-Bottom-{0..9}.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-13-Bottom-{0..6}.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-7-Top-{L,SL}.in) \
$(shell echo Rivet/LHC{,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Matchbox,-Matchbox-Powheg,-Merging}-{8,13}-Top-{All,L,SL}.in) \
$(shell echo Rivet/Star{,-Dipole}-{UE,Jets-{1..4}}.in ) \
$(shell echo Rivet/SppS{,-Dipole}-{53,63,200,500,546,900}-UE.in ) \
$(shell echo Rivet/LHC{,-Matchbox,-Matchbox-Powheg,-Powheg,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-{{,8-}W-{e,mu},13-W-mu,{,8-,13-}Z-{e,mu}-Mass{1..5},13-Z-nu,Z-mu-SOPHTY,WZ,WW-{emu,ll},13-WW-ll,13-ZZ-ll,ZZ-{ll,lv},{8,13}-WZ,8-ZZ-lv,8-WW-ll,Z-mu-Short}.in) \
$(shell echo Rivet/LHC{,-Dipole}-7-{W,Z}Gamma-{e,mu}.in) \
$(shell echo Rivet/LHC{,-Dipole}-8-ZGamma-{e,mu}.in) \
$(shell echo Rivet/LHC{,-Matchbox,-Matchbox-Powheg,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-{7-W-Jet-{1..3}-e,7-Z-Jet-{0..3}-e,7-Z-Jet-0-mu}.in) \
$(shell echo Rivet/LHC{-Matchbox,-Matchbox-Powheg,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-{Z-b,Z-bb,8-Z-b,8-Z-bb,13-Z-b,13-Z-bb,W-b,8-Z-jj}.in) \
$(shell echo Rivet/LHC{,-Dipole}-{7,8,13}-PromptPhoton-{1..5}.in) Rivet/LHC-GammaGamma-7.in \
$(shell echo Rivet/LHC{,-Powheg,-Dipole}-{7,8,13}-{DiPhoton-GammaGamma,DiPhoton-GammaJet}.in) \
$(shell echo Rivet/LHC{,-Powheg,-Matchbox,-Matchbox-Powheg,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-{ggH,VBF,WH,ZH}.in) \
$(shell echo Rivet/LHC{,-Powheg,-Matchbox,-Matchbox-Powheg,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-8-{{ggH,VBF,WH,ZH}{,-GammaGamma},ggH-WW}.in) \
$(shell echo Rivet/LHC{,-Matchbox,-Matchbox-Powheg,-Dipole,-Dipole-MCatNLO,-Dipole-Matchbox-Powheg,-Merging}-ggHJet.in) \
$(shell echo Rivet/ISR{,-Dipole}-{{30,44,53,62}-UE,{44,62}-Z-mu}.in Rivet/EHS{,-Dipole}-UE.in) \
$(shell echo Rivet/SPS{,-Dipole}-{17.4-UE,200-Z-mu}.in ) \
$(shell echo Rivet/Fermilab{,-Dipole}-{27.4,38.8}-Z-mu.in ) \
$(shell echo Rivet/EE-Gamma-Direct-mumu-{161,172,183,189,196,206}.in ) \
$(shell echo Rivet/EE-Gamma-Direct-tautau-{189,196,206}.in ) \
$(shell echo Rivet/EE-Gamma-{pi0,Eta,EtaPrime,EtaC,ChiC2,ChiC0_2P,ChiC2_2P}-10.58.in ) \
$(shell echo Rivet/EE-Gamma-{Eta-{1,29},EtaPrime-{34.3,91.2}}.in ) \
$(shell echo Rivet/EE-Gamma-{Direct,Single-Resolved,Double-Resolved}-Jets-{198,206}.in )
#$(shell echo Rivet/LHC{,-Dipole}-{7,13}{,-UE}-Cent.in )
Analysis/RivetHerwig.so: Analysis/*.cc
rivet-build Analysis/RivetHerwig.so Analysis/*.cc
Rivet-GammaGamma: Rivet-GammaGamma/done
touch $@
Rivet-GammaGamma/done: $(shell echo Rivet-GammaGamma-mumu-{3.5,4.5,5.5,6.5,7.5,9.0,12.5,17.5,30.0}.yoda )
rm -rf Rivet-GammaGamma
python/merge-GammaGamma GammaGamma
rivet-mkhtml -o Rivet-GammaGamma GammaGamma.yoda:Hw
touch $@
Rivet-EE-Gamma: Rivet-EE-Gamma/done
touch $@
Rivet-EE-Gamma/done: $(shell echo Rivet-EE-Gamma-Direct-mumu-{161,172,183,189,196,206}.yoda ) \
$(shell echo Rivet-EE-Gamma-Direct-tautau-{189,196,206}.yoda ) \
$(shell echo Rivet-EE-Gamma-{pi0,Eta,EtaPrime,EtaC,ChiC2,ChiC0_2P,ChiC2_2P}-10.58.yoda ) \
$(shell echo Rivet-EE-Gamma-{Eta-{1,29},EtaPrime-{34.3,91.2}}.yoda ) \
$(shell echo Rivet-EE-Gamma-{Direct,Single-Resolved,Double-Resolved}-Jets-{198,206}.yoda )
rm -rf Rivet-EE-Gamma
python/merge-EE-Gamma EE-Gamma
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; rivet-mkhtml -o Rivet-EE-Gamma EE-Gamma.yoda:Hw
touch $@
Rivet-EE : Rivet-EE/done
touch $@
Rivet-EE/done : $(shell echo Rivet{,-Powheg}-EE-{7.7,9.4,12,13,14,14.8,17,27.6,27.7,29,30.2,30.3,30.5,30.7,30.8,30,31.2,31.3,31.6,34,34.8,43.5,43.6,45,50,52,53.3,55,55.3,56,57,58,59.5,60.8,60,61.4,65.4,66,75.7,76,10,12.8,21.5,22,22.5,25,26.8,34.5,35,36.2,41,41.5,42.1,42.6,44,48.0,82,85,91,93.0,130,130.1,133,136,136.1,161,161.3,172,172.3,177,182.8,183,188.6,189,192,194.4,196,197,200,200.2,202,205,206,206.2,207,91-nopi}.yoda) \
$(shell echo Rivet-EE-{183,189}-WW.yoda) \
$(shell echo Rivet-EE-{10.5,11.96,12.8,13.96,16.86,21.84,26.8,28.48,35.44,48.0,97.0}-gg.yoda) \
$(shell echo Rivet-EE-{10.52,10.52-sym,10.6,2.2,2.6,3.0,3.2,4.6,4.8,5.8,6.2,6.5,6.6,7.0,7.4,3.63,4.03,4.17,4.3,4.41,5.0,5.2,4.5,8.8,9.27,9.46,9.51,10.54,10.58,10.45,10.47,Upsilon,Upsilon2,Upsilon3,Upsilon4,Upsilon5,Upsilon4-asym,Tau,Phi,Lambdac,Omega-Meson,Omega-Baryon,Eta,Xi0,Xic0,Xicp,Omegac0,Ds,Bc,Etac,Xim,JPsi,Psi2S,Psi2S-All,Psi3770}.yoda)
rm -rf Rivet-EE
python/merge-EE --with-gg --with-decay --with-WW EE
python/merge-EE Powheg-EE
rivet-mkhtml -o Rivet-EE EE.yoda:Hw Powheg-EE.yoda:Hw-Powheg
python/plot-EE Rivet-EE
touch $@
Onium-%.yoda:
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWBUILD) -c .cache/$(subst .yoda,,$@) Rivet/$(subst .yoda,.in,$@)
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWRUN) $(subst .yoda,.run,$@)
+Onium-Splitting: Analysis/RivetHerwig.so
+ OUTPUT=`python/OniumSplitting.py --generate-input-files`; $(MAKE) $$OUTPUT NUMEVENTS=$${NUMEVENTS:-10000};
+ export RIVET_ANALYSIS_PATH=`pwd`/Analysis; python/OniumSplitting.py --fast --analyse
+
Onium-Sigma: Analysis/RivetHerwig.so
OUTPUT=`python/OniumSigma.py --generate-input-files | grep -v CT14 | grep -v LHAPDF | grep -v Eur.Phys`; $(MAKE) $$OUTPUT NUMEVENTS=$${NUMEVENTS:-10000};
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; python/OniumSigma.py --fast --analyse
Rivet-LowEnergy-%.yoda:
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWBUILD) -c .cache/$(subst .yoda,,$@) Rivet/$(subst .yoda,.in,$@)
export RIVET_ANALYSIS_PATH=`pwd`/Analysis; $(HWRUN) $(subst .yoda,.run,$@)
Rivet-LowEnergy-EE-%:
args="--process "$(word 1,$(subst -, ,$(subst Rivet-LowEnergy-EE-,,$@))); if [ -n "$(strip $(word 2,$(subst -, ,$(subst Rivet-LowEnergy-EE-,,$@))))" ]; then args+=" --flavour "$(word 2,$(subst -, ,$(subst Rivet-LowEnergy-EE-,,$@))); fi; OUTPUT=`python/LowEnergy-EE.py $$args --non-perturbative --perturbative`; $(MAKE) $$OUTPUT NUMEVENTS=$${NUMEVENTS:-10000};
args="--process "$(word 1,$(subst -, ,$(subst Rivet-LowEnergy-EE-,,$@))); plots=`python/LowEnergy-EE.py $$args --plots`; python/mergeLowEnergy.py $(subst Rivet-LowEnergy-,,$@) $$plots; if [ -e LowEnergy-NonPerturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda ] && [ -e LowEnergy-Perturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda ]; then rivet-mkhtml -o Rivet-LowEnergy-EE-$(subst Rivet-LowEnergy-EE-,,$@) LowEnergy-NonPerturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda:"Non-Pert" LowEnergy-Perturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda:"Pert" $$plots; elif [ -e LowEnergy-NonPerturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda ]; then rivet-mkhtml -o Rivet-LowEnergy-EE-$(subst Rivet-LowEnergy-EE-,,$@) LowEnergy-NonPerturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda:"Non-Pert" $$plots; elif [ -e LowEnergy-Perturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda ]; then rivet-mkhtml -o Rivet-LowEnergy-EE-$(subst Rivet-LowEnergy-EE-,,$@) LowEnergy-Perturbative-EE-$(subst Rivet-LowEnergy-EE-,,$@).yoda:"Pert" $$plots; fi
Rivet-LowEnergy-Photon-%:
args="--process "$(word 1,$(subst -, ,$(subst Rivet-LowEnergy-Photon-,,$@))); if [ -n "$(strip $(word 2,$(subst -, ,$(subst Rivet-LowEnergy-Photon-,,$@))))" ]; then args+=" --flavour "$(word 2,$(subst -, ,$(subst Rivet-LowEnergy-Photon-,,$@))); fi; OUTPUT=`python/LowEnergy-Photon.py $$args --non-perturbative --perturbative --resonance`; $(MAKE) $$OUTPUT NUMEVENTS=$${NUMEVENTS:-10000};
args="--process "$(word 1,$(subst -, ,$(subst Rivet-LowEnergy-Photon-,,$@))); plots=`python/LowEnergy-Photon.py $$args --plots`; yodaArgs=`python/mergeLowEnergy.py $(subst Rivet-LowEnergy-Photon-,GammaGamma-,$@) $$plots`; rivet-mkhtml -o Rivet-LowEnergy-Photon-$(subst Rivet-LowEnergy-Photon-,,$@) $$yodaArgs $$plots;
Rivet-R:
OUTPUT=`python/R.py --perturbative --non-perturbative`; $(MAKE) $$OUTPUT NUMEVENTS=$${NUMEVENTS:-10000};
plots=`python/R.py --perturbative --non-perturbative --plots`; python/mergeLowEnergy.py R $$plots; rivet-mkhtml -o Rivet-R LowEnergy-Perturbative-R.yoda:"Pert" LowEnergy-NonPerturbative-R.yoda:"Non-Pert" $$plots
Rivet-DIS : Rivet-DIS/done
touch $@
Rivet-DIS/done: $(shell echo Rivet{-DIS,-NoME-DIS,-Powheg-DIS}-{225,251,300,318,318-CMS}-e+-{VeryLow,Low,Med,High}Q2.yoda) \
$(shell echo Rivet{-DIS,-NoME-DIS,-Powheg-DIS}-{296,300,318}-e--{VeryLow,Low,Med,High}Q2.yoda) \
$(shell echo Rivet{-DIS,-NoME-DIS,-Powheg-DIS}-318-{e+,e-}-CC-{VeryLow,Low,Med,High}Q2.yoda)
rm -rf Rivet-DIS
python/merge-DIS DIS
python/merge-DIS Powheg-DIS
python/merge-DIS NoME-DIS
rivet-mkhtml -o Rivet-DIS DIS.yoda:Hw Powheg-DIS.yoda:Hw-Powheg NoME-DIS.yoda:Hw-NoME
touch $@
Rivet-TVT-EW : Rivet-TVT-EW/done
touch $@
Rivet-TVT-EW/done: $(shell echo Rivet{,-Powheg}-TVT-{Run-I-Z,Run-I-W,Run-I-WZ,Run-II-Z-{e,{,LowMass-,HighMass-}mu},Run-II-W}.yoda)
rm -rf Rivet-TVT-EW
python/merge-TVT-EW TVT
python/merge-TVT-EW Powheg-TVT
rivet-mkhtml -o Rivet-TVT-EW TVT-EW.yoda:Hw Powheg-TVT-EW.yoda:Hw-Powheg
touch $@
Rivet-TVT-Photon : Rivet-TVT-Photon/done
touch $@
Rivet-TVT-Photon/done: $(shell echo Rivet{,-Powheg}-TVT-Run-II-{DiPhoton-GammaGamma,DiPhoton-GammaJet}.yoda Rivet-TVT-Run-II-PromptPhoton.yoda)
rm -rf Rivet-TVT-Photon
python/merge-TVT-Photon TVT
python/merge-TVT-Photon Powheg-TVT
rivet-mkhtml -o Rivet-TVT-Photon TVT-Photon.yoda:Hw Powheg-TVT-Photon.yoda:Hw-Powheg
touch $@
Rivet-TVT-Jets : Rivet-TVT-Jets/done
touch $@
Rivet-TVT-Jets/done: $(shell echo Rivet-TVT-Run-{I,II}-{Jets-{1..6},DiJets-{1..4}}.yoda ) \
$(shell echo Rivet-TVT-{630-Jets-{1..3},300-Jets-1,900-Jets-1}.yoda ) \
$(shell echo Rivet-TVT-{Run-I,Run-II,300,630,900}-UE.yoda)
rm -rf Rivet-TVT-Jets
python/merge-TVT-Jets TVT
rivet-mkhtml -o Rivet-TVT-Jets TVT-Jets.yoda:Hw
touch $@
Rivet-Fixed : Rivet-Fixed/done
touch $@
Rivet-Fixed/done : $(shell echo Rivet-SppS-{53,63,200,500,546,900}-UE.yoda ) \
$(shell echo Rivet-ISR-{{30,44,53,62}-UE,{44,62}-Z-mu}.yoda ) Rivet-EHS-UE.yoda \
$(shell echo Rivet-Star-{UE,Jets-{1..4}}.yoda ) \
$(shell echo Rivet-SPS-{17.4-UE,200-Z-mu}.yoda ) \
$(shell echo Rivet-Fermilab-{27.4,38.8}-Z-mu.yoda )
rm -rf Rivet-Fixed
python/merge-Fixed Fixed
rivet-mkhtml -o Rivet-Fixed Fixed.yoda:Hw
touch $@
Rivet-LHC-Jets : Rivet-LHC-Jets/done
touch $@
Rivet-LHC-Jets/done : \
$(shell echo Rivet-LHC-7-DiJets-{1..7}-{A,B,C}.yoda ) \
$(shell echo Rivet-LHC-13-DiJets-{{1..11}-A,{6..11}-B}.yoda ) \
$(shell echo Rivet-LHC-{7,8,13}-Jets-{0..10}.yoda ) \
$(shell echo Rivet-LHC-2760-Jets-{1..3}.yoda ) \
$(shell echo Rivet-LHC-{900,2360,2760,7,8,13}-UE.yoda ) \
$(shell echo Rivet-LHC-{900,7,13}-UE-Long.yoda ) \
$(shell echo Rivet-LHC-7-Charm-{0..5}.yoda ) \
$(shell echo Rivet-LHC-{5,13}-Charm-0.yoda ) \
$(shell echo Rivet-LHC-7-Bottom-{0..9}.yoda ) \
$(shell echo Rivet-LHC-13-Bottom-{0..6}.yoda ) \
$(shell echo Rivet-LHC-{7,8,13}-Top-{L,SL}.yoda ) \
$(shell echo Rivet-LHC-{8,13}-Top-All.yoda )
# $(shell echo Rivet-LHC-{7,13}-UE-Cent.yoda )
rm -rf Rivet-LHC-Jets
python/merge-LHC-Jets LHC
rivet-mkhtml -o Rivet-LHC-Jets LHC-Jets.yoda:Hw
touch $@
Rivet-LHC-EW : Rivet-LHC-EW/done
touch $@
Rivet-LHC-EW/done: \
$(shell echo Rivet{,-Powheg}-LHC-{{,8-}W-{e,mu},13-W-mu,{,8-,13-}Z-{e,mu}-Mass{1..5},13-Z-nu,Z-mu-SOPHTY,WZ,WW-{emu,ll},13-WW-ll,ZZ-{ll,lv},{8,13}-WZ,13-ZZ-ll,8-ZZ-lv,8-WW-ll,Z-mu-Short}.yoda) \
$(shell echo Rivet-LHC-{7-W-Jet-{1..3}-e,7-Z-Jet-{0..3}-e,7-Z-Jet-0-mu}.yoda) \
$(shell echo Rivet-LHC-7-{W,Z}Gamma-{e,mu}.yoda) \
$(shell echo Rivet-LHC-8-ZGamma-{e,mu}.yoda)
rm -rf Rivet-LHC-EW;
python/merge-LHC-EW LHC
python/merge-LHC-EW Powheg-LHC
rivet-mkhtml -o Rivet-LHC-EW LHC-EW.yoda:Hw Powheg-LHC-EW.yoda:Hw-Powheg \
Rivet-LHC-Z-mu-SOPHTY.yoda:Hw Rivet-Powheg-LHC-Z-mu-SOPHTY.yoda:Hw-Powheg
touch $@
Rivet-LHC-Photon : Rivet-LHC-Photon/done
touch $@
Rivet-LHC-Photon/done: \
$(shell echo Rivet-LHC-{7,8,13}-PromptPhoton-{1..5}.yoda) \
Rivet-LHC-GammaGamma-7.yoda \
$(shell echo Rivet{,-Powheg}-LHC-{7,8,13}-{DiPhoton-GammaGamma,DiPhoton-GammaJet}.yoda)
rm -rf Rivet-LHC-Photon
python/merge-LHC-Photon LHC
python/merge-LHC-Photon Powheg-LHC
rivet-mkhtml -o Rivet-LHC-Photon LHC-Photon.yoda:Hw Powheg-LHC-Photon.yoda:Hw-Powheg
touch $@
Rivet-LHC-Higgs : Rivet-LHC-Higgs/done
touch $@
Rivet-LHC-Higgs/done: \
$(shell echo Rivet{,-Powheg}-LHC-{ggH,VBF,WH,ZH}.yoda) \
$(shell echo Rivet{,-Powheg}-LHC-8-{{ggH,VBF,WH,ZH}{,-GammaGamma},ggH-WW}.yoda) \
Rivet-LHC-ggHJet.yoda
rivet-merge Rivet-Powheg-LHC-8-{ggH{-GammaGamma,-WW,},{VBF,ZH,WH}{,-GammaGamma}}.yoda -o Powheg-LHC-Higgs.yoda
rivet-merge Rivet-LHC-8-{ggH{-GammaGamma,-WW,},{VBF,ZH,WH}{,-GammaGamma}}.yoda -o LHC-Higgs.yoda
rm -rf Rivet-LHC-Higgs
rivet-mkhtml -o Rivet-LHC-Higgs Powheg-LHC-Higgs.yoda:Hw-Powheg LHC-Higgs.yoda:Hw\
Rivet-Powheg-LHC-ggH.yoda:gg-Powheg Rivet-LHC-ggH.yoda:gg Rivet-LHC-ggHJet.yoda:HJet \
Rivet-Powheg-LHC-VBF.yoda:VBF-Powheg Rivet-LHC-VBF.yoda:VBF Rivet-LHC-WH.yoda:WH Rivet-LHC-ZH.yoda:ZH \
Rivet-Powheg-LHC-WH.yoda:WH-Powheg Rivet-Powheg-LHC-ZH.yoda:ZH-Powheg
touch $@
clean-local:
rm -f *.out *.log *.tex *.top *.run *.dump *.mult *.Bmult *.yoda Rivet/*.in anatohepmc.txt hepmctoana.txt
rm -rf Rivet-*
rm -rf Onium-Splitting
rm -rf Analysis/*.so
distclean-local:
rm -rf .cache
diff --git a/Tests/python/OniumSplitting.py.in b/Tests/python/OniumSplitting.py.in
new file mode 100755
--- /dev/null
+++ b/Tests/python/OniumSplitting.py.in
@@ -0,0 +1,546 @@
+#! @PYTHON@
+from __future__ import print_function
+import yoda,os,math,subprocess,optparse
+from string import Template
+import numpy,matplotlib.pyplot as plt
+from scipy.integrate import dblquad as dblquad
+from scipy.integrate import quad as quad
+import datetime
+
+htmlTemplate=Template("""
+<html>
+<head>
+<title>Tests of Onium Splittings in the Parton Shower</title>
+<style>
+ html { font-family: sans-serif; }
+ img { border: 0; }
+ a { text-decoration: none; font-weight: bold; }
+ </style>
+ <script type="text/x-mathjax-config">
+ MathJax.Hub.Config({
+ tex2jax: {inlineMath: [["$$","$$"]]}
+ });
+ </script>
+ <script type="text/javascript" async
+ src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+ </script>
+ </head>
+<body>
+<section id="OniumTests">
+<h1>Tests of Onium splittings in the Parton Shower</h1>
+${plots}
+</section>
+
+<footer style="clear:both; margin-top:3em; padding-top:3em">
+${time}
+</footer>
+
+</body>
+</html>""")
+plotTemplate=Template("""
+<div class="plot" id="plot_${id}" style="float:left; font-size:smaller; font-weight:bold;">
+ <a href="#MC_Simple_Onium-${id}">&#9875;</a> ${id}:<br/>
+ <a name="MC_Simple_Onium-${id}"><a href="${id}.pdf">
+ <img src="${id}.png">
+ </a></a>
+</div>""")
+# various test functions
+m1=0.
+m2=0.
+M=0
+a1=0
+a2=0
+aS=0.
+R02=0.
+mix1=0.
+mix2=0.
+pTmin=1.
+# q -> q 1S0
+def D_q_q_1S0(z) :
+ return 8./81./math.pi*aS**2*R02*(1.-z)**2*z*(48. + 8.*z**2 - 8.*z**3 + 3.*z**4)/(m1**3*(2. - z)**6)
+
+def D_g_g_1S0(z) :
+ return aS**2/24./math.pi*R02/m1**3*(3.*z-2.*z**2+2.*(1.-z)*numpy.log(1.-z))
+
+zz=0.
+
+def upp(r) :
+ return 0.5*(1+r)
+
+def low(r) :
+ return 0.5*(r+zz**2)/zz
+
+def IPsi(y,r) :
+ z = zz
+ f0 = r**2*(1 + r)*(3 + 12*r + 13*r**2) - 16*r**2*(1 + r)*(1 + 3*r)*y \
+ - 2*r*(3 - 9*r - 21*r**2 + 7*r**3)* y**2 + 8*r*(4 + 3*r + 3*r**2)*y**3 \
+ - 4*r*(9 - 3*r - 4*r**2)*y**4 - 16*(1 + 3*r + 3*r**2)*y**5 + 8*(6 + 7*r)*y**6 - 32*y**7
+ f1 = -2*r*(1 + 5*r + 19*r**2 + 7*r**3)*y + 96*r**2*(1 + r)*y**2 \
+ + 8*(1 - 5*r - 22*r**2 - 2*r**3)*y**3 + 16*r*(7 + 3*r)*y**4 - 8*(5 + 7*r)*y**5 + 32*y**6
+ f2 = r*(1 + 5*r + 19*r**2 + 7*r**3) - 48*r**2*(1 + r)*y - 4*(1 - 5*r - 22*r**2 - 2*r**3)*y**2 \
+ - 8*r*(7 + 3*r)*y**3 + 4*(5 + 7*r)*y**4 - 16*y**5
+ g0 = (1 - r)*r**3*(3 + 24*r + 13*r**2) - 4*r**3*(7 - 3*r - 12*r**2)*y \
+ - 2*r**3*(17 + 22*r - 7*r**2)*y**2 + 4*r**2*(13 + 5*r - 6*r**2)*y**3 \
+ - 8*r*(1 + 2*r + 5*r**2 + 2*r**3)*y**4 - 8*r*(3 - 11*r - 6*r**2)*y**5 + 8*(1 - 2*r - 5*r**2)*y**6
+ g1 = -2*(1 - r)*r**2*(1 + r)*(1 + 7*r)*y + 8*(1 - 4*r)*r**2*(1 + 3*r)*y**2 \
+ + 4*r*(1 + 10*r + 57*r**2 + 4*r**3)* y**3 - 8*r*(1 + 29*r + 6*r**2)*y**4 - 8*(1 - 8*r - 5*r**2)*y**5
+ g2 = (1 - r)*r**2*(1 + r)*(1 + 7*r) - 4*(1 - 4*r)*r**2*(1 + 3*r)*y \
+ - 2*r*(1 + 10*r + 57*r**2 + 4*r**3)* y**2 + 4*r*(1 + 29*r + 6*r**2)*y**3 + 4*(1 - 8*r - 5*r**2)*y**4
+ c1 = f0+z*f1+z**2*f2
+ c2 = g0+z*g1+z**2*g2
+ return (c1 + ((1 + r - 2*y)*c2*numpy.log((-r + y + numpy.sqrt(-r + y**2))/(-r + y - numpy.sqrt(-r + y**2))))/(2.*(-r + y)*numpy.sqrt(-r + y**2))) \
+ /((1 - y)**2*(-r + y)**2*(-r + y**2)**2)
+
+def D_g_g_3S1(z) :
+ global zz
+ zz = z
+ return 3.*R02/2.*5./5184./numpy.pi**2/m1**3*aS**3*dblquad(IPsi,0.,z,low,upp)[0]
+
+def D_g_g_3P0(x) :
+ smin = pTmin**2/x/(1-x)+4.*m1**2/x
+ return -aS**2*R02/(6.*m1**3*numpy.pi)*(-9/smin + (16*m1**2*(-2 + x)*(-1 + x))/(-4*m1**2 + smin)**2
+ + (128*m1**4*(-1 + x)**2)/(3.*(4*m1**2 - smin)**3)
+ + (2*(11 - 10*x + x**2))/(4*m1**2 - smin) - (3*(-5 + 3*x)*numpy.log(smin))/(2.*m1**2)
+ + (3*(-5 + 3*x)*numpy.log(-4*m1**2 + smin))/(2.*m1**2))
+
+def D_g_g_3P1(x) :
+ smin = pTmin**2/x/(1-x)+4.*m1**2/x
+ return -aS**2*R02/(m1**3*numpy.pi)*((-1 + 2*(1 - x) - 2*(1 - x)**2)/(-4*m1**2 + smin) - (4*m1**2*(1 - x))/(-4*m1**2 + smin)**2 + (32*m1**4*(1 - x)**2)/(3.*(-4*m1**2 + smin)**3))
+
+def D_g_g_3P2(x) :
+ smin = pTmin**2/x/(1-x)+4.*m1**2/x
+ return -aS**2*R02/(3.*m1**3*numpy.pi)*(-6/smin + (-7 - 10*(1 - x) - 2*(1 - x)**2)/(-4*m1**2 + smin) + (4*m1**2*(1 + 4*(1 - x))*(1 - x))/(-4*m1**2 + smin)**2 -
+ (32*m1**4*(1 - x)**2)/(3.*(-4*m1**2 + smin)**3) + (3*(2 - x)*numpy.log(smin))/m1**2 - (3*(2 - x)*numpy.log(-4*m1**2 + smin))/m1**2)
+
+# q -> q 3S1
+def D_q_q_3S1(z) :
+ return 8./math.pi*aS**2*R02*(1.-z)**2*z*(16.-32.*z+72.*z**2-32.*z**3+5.*z**4)/(27.*m1**3*(2.-z)**6)
+# q -> q 3P0
+def D_q_q_3P0(z):
+ return 9./2./math.pi*R02*16.*aS**2*(1-z)**2*z*(192+384*z+528*z**2-1376*z**3 +1060*z**4-376*z**5+59*z**6)/(729.*m1**5*(2 - z)**8)
+# q -> q 3P1
+def D_q_q_3P1(z) :
+ return 9./2./math.pi*R02*64.*aS**2*(1 - z)**2*z*(96 - 288*z + 496*z**2 - 408*z**3 + 202*z**4 - 54*z**5 + 7*z**6)/(243.*m1**5*(2 - z)**8)
+# q -> q 3P2
+def D_q_q_3P2(z):
+ return 9./2./math.pi*R02*128*aS**2*(1 - z)**2*z*(48 - 192*z + 480*z**2 - 668*z**3 + 541*z**4 - 184*z**5 + 23*z**6)/(729.*m1**5*(2 - z)**8)
+# q -> q 1P1
+def D_q_q_1P1(z) :
+ return 9./2./math.pi*R02*16*aS**2*(1 - z)**2*z*(64 - 128*z + 176*z**2 - 160*z**3 + 140*z**4 - 56*z**5+9*z**6)/(81.*m1**5*(2-z)**8)
+# q -> q 1D2
+def D_q_q_1D2(x) :
+ return 8.*aS**2*R02/math.pi*(1 - x)**2*x*(3840-15360*x+30720*x**2-37120*x**3+35328*x**4-29344*x**5+18344*x**6-5848*x**7+775*x**8)/(81.*m1**7*(2 - x)**10)
+# q -> q 3D1
+def D_q_q_3D1(x) :
+ return 8*aS**2*R02/math.pi*(1 - x)**2*x*(17280 - 103680*x + 321120*x**2 - 551840*x**3 + 546744*x**4 - 314752*x**5 + 112402*x**6 - 24594*x**7 + 2915*x**8)/(405.*m1**7*(2 - x)**10)
+# q -> q 3D2
+def D_q_q_3D2(x) :
+ return 16*aS**2*R02/math.pi*(1 - x)**2*x*(2880 - 14400*x + 37360*x**2 - 58240*x**3 + 58604*x**4 - 38372*x**5 + 16517*x**6 - 4014*x**7 + 445*x**8)/(81.*m1**7*(2 - x)**10)
+# q -> q 3D3
+def D_q_q_3D3(x) :
+ return 8*aS**2*R02/math.pi*(1 - x)**2*x*(11520 - 69120*x + 231680*x**2 - 488960*x**3 + 675136*x**4 - 592288*x**5 + 309688*x**6 - 80736*x**7 + 8285*x**8)/(405.*m1**7*(2 - x)**10)
+# q -> q' 1S0
+def D_q_qp_1S0(z) :
+ W0 = 2.*(1.+z*a1)**2*(1.-z)
+ W1 = -2.*(2.*z**2*a2**2-z**2*a2 -4.*z*a2**2+4.*z*a2 -3.*z+4.*a2-2.)*(1.-z*a2)
+ W2 = -8.*(1.-z*a2)**2*a1*a2
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 2.*aS**2/27./M**3*R02/math.pi/a1**2/(1.-a2*z)**2* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.)
+# q -> q' 3S1
+def D_q_qp_3S1(z) :
+ W0 = 2.*((1.+z*a1)**2+2.*z**2)*(1.-z)
+ W1 = -2.*(2.*z**2*a2**2 -3.*z**2*a2 +4.*z*a2**2 + 4.*z*a2 -9.*z - 4.*a2+6.)*(1.-z*a2)
+ W2 = -24.*(1.-z*a2)**2*a1*a2
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 2.*aS**2/27./math.pi/M**3*R02/a1**2/(1.-a2*z)**2* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.)
+# q ->q' 3P0
+def D_q_qp_3P0(z) :
+ W0 = ( 4.*a2 - 3. - 8*z*a2**2 + 10*z*a2 - 3*z + 4*z**2*a2**3 - 5*z**2*a2**2 + z**2*a2 )**2*(1.-z)/96./a2**2
+ W1 = ((-1 + z*a2)**2*(18 + 27*z - 12*a2 + 18*z*a2 + 30*z**2*a2 - 40*a2**2 - 152*z*a2**2 - 206*z**2*a2**2 - 9*z**3*a2**2 + 32*a2**3 + 176*z*a2**3 + 324*z**2*a2**3 + 58*z**3*a2**3 - 64*z*a2**4 - 184*z**2*a2**4 - 80*z**3*a2**4 + 32*z**2*a2**5 + 32*z**3*a2**5))/(96.*a2**2)
+ W2 = (2*a2*(7.*a2-6.*z) -10.*a2-3. -2.*z*a2**2*(7.*a2-12.) -z**2*a2**2*(2.*a2-3.))*a1*(1.-z*a2)**3/(12.*a2)
+ W3 = 2.*a1**2*a2*(1.-z*a2)**4/3.
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 32.*aS**2/9./math.pi*R02/a1**4/(1.-a2*z)**4/M**5* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.+W3*deltaX**4/4.)
+# q ->q' 3P2
+def D_q_qp_3P2(z) :
+ W0 = (2 + 4*z + 9*z**2 + 10*z**3 + 5*z**4 - 8*z*a2 - 16*z**2*a2 - 28*z**3*a2 - 20*z**4*a2 + 12*z**2*a2**2 + 20*z**3*a2**2 + 24*z**4*a2**2 - 8*z**3*a2**3 - 8*z**4*a2**3 + 2*z**4*a2**4)*(1.-z)/24.
+ W1 = (-20 - 13*z + 8*z**2 + 30*z**3 + 16*a2 + 52*z*a2 - 30*z**2*a2 - 28*z**3*a2 - 32*z*a2**2 + 4*z**2*a2**2 - 7*z**3*a2**2 + 16*z**2*a2**3 + 4*z**3*a2**3)*(1.-z*a2)**2/24.
+ W2 = ( -26*a2 + 34 + 26.*z*a2**2 + 18*z*a2 - 45*z + 8*z**2*a2**2 - 15*z**2*a2 )*a1*(1.-z*a2)**3/12.
+ W3 = 10./3.*a1**2*a2*(1.-z*a2)**4
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 32.*aS**2/9./math.pi*R02/a1**4/(1.-a2*z)**4/M**5* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.+W3*deltaX**4/4.)
+# q to q' 1P1
+def D_q_qp_1P1(z) :
+ W0 = (1.-z)*(1 + z*(2 - 4*a2) + z**4*(2 + a1**2)* a2**2 + z**2*(3 - 2*a1*a2) + 2*z**3*a2* (-1 - 3*a2 + 2*a2**2))/32./a2**2
+ W1 = ((-1 + z*a2)**2* (-6 + 12*a2 - 8*a2**2 + z**3*a2**2* (13 - 38*a2 + 24*a2**2) + 2*z**2*a2* (5 + 17*a2 - 26*a2**2 + 4*a2**3) + z* (9 - 38*a2 + 16*a2**2 + 16*a2**3)))/(32.*a2**2)
+ W2 = (-1.+(6.-10.*z)*a2-(2.-4.*z+z**2)*a2**2+2.*z*(1.+z)*a2**3)*a1*(1.-z*a2)**3/4./a2
+ W3 = 2.*a1**2*a2*(1.-z*a2)**4
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 32.*aS**2/9.*R02/math.pi/a1**4/(1.-a2*z)**4/M**5* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.+W3*deltaX**4/4.)
+# q to q' 3P1
+def D_q_qp_3P1(z) :
+ W0 = -((-1 + z)*(1 + 2*z + 3*z**2 - 4*z*a2 - 10*z**2*a2 - 2*z**3*a2 + 8*z**2*a2**2 + 6*z**3*a2**2 + z**4*a2**2 - 4*z**3*a2**3 - 2*z**4*a2**3 + z**4*a2**4))/a2**2/16.
+ W1 = ((-1 + z*a2)**2* (-6 + 9*z + 4*a2 - 10*z*a2 + 10*z**2*a2 + 6*z*a2**2 - 22*z**2*a2**2 + z**3*a2**2 + 8*z**2*a2**3 - 2*z**3*a2**3 + 2*z**3*a2**4))/ (16.*a2**2)
+ W2 = -(a1*(-1 + z*a2)**3*(-2 + 6*a2 - 11*z*a2 - 2*a2**2 + 6*z*a2**2 + z**2*a2**2 + 2*z*a2**3))/a2/4.
+ W3 = 2.*a1**2*a2*(-1 + z*a2)**4
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ return 32.*aS**2/9.*R02/math.pi/a1**4/(1.-a2*z)**4/M**5* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.+W3*deltaX**4/4.)
+# q to q' P1
+def D_q_qp_P1(z) :
+ W0 = -0.25*((-1 + z)* (1 + z* (2 + 3*z + a2* (-3 + z* (-4 + a2 + (-1 + a2)**2* z)))))/ (a2**2* (-1 + a2*z)**3)
+ W1 = (6 - 9*z + a2* (-8 + 4*a2 + 24*z - 4*a2* (3 + 2*a2)*z + 2* (-5 + a2 + 2*a2**2* (2 + a2))* z**2 + a2* (11 + 4*(-4 + a2)* a2)*z**3))/(4.*a2**2* (-1 + a2*z)**2)
+ W2 = 2.*(-1 + a2)* (-1 + 3*a2 +(-2 + a2)*a2*z)/a2
+ deltaX = z*(1.-z)/(1.-a2*z)**2
+ mixed=16.*aS**2/9.*R02/math.pi/a1**4/M**5/math.sqrt(2.)* \
+ (W0*deltaX+W1*deltaX**2/2.+W2*deltaX**3/3.)
+ return mix1**2*D_q_qp_1P1(z)+mix2**2*D_q_qp_3P1(z)+mix1*mix2*mixed
+
+# q ->q' 3D1
+def D_q_qp_3D1(x) :
+ return (aS**2*R02/math.pi*(1 - x)**2*x*(60*(1 + 4*a1)**2 - 60*(1 + 4*a1)*(7 + 36*a1 - 28*a1**2)*x + 5*(261 + 2652*a1 + 6128*a1**2 - 12576*a1**3 + 7360*a1**4)*x**2 + 10*(-237 - 2589*a1 - 8754*a1**2 + 27528*a1**3 - 28808*a1**4 + 11360*a1**5)*x**3 + (2775 + 31350*a1 + 156435*a1**2 - 648372*a1**3 + 909816*a1**4 - 613056*a1**5 + 183552*a1**6)*x**4 - 4*(540 + 6585*a1 + 49910*a1**2 - 166879*a1**3 + 201928*a1**4 - 115084*a1**5 + 28400*a1**6)*a2*x**5 + (1095 + 13830*a1 + 142935*a1**2 - 389916*a1**3 + 377696*a1**4 - 164320*a1**5 + 36800*a1**6)*a2**2*x**6 - 2*(165 + 2100*a1 + 27645*a1**2 - 58086*a1**3 + 42360*a1**4 - 15720*a1**5 + 3360*a1**6)*a2**3*x**7 + 5*(9 + 114*a1 + 1817*a1**2 - 2524*a1**3 + 1676*a1**4 - 672*a1**5 + 192*a1**6)*a2**4*x**8))/(3240.*(1 - a2)**6*a2**2*M**7*(1 - a2*x)**10)
+# q ->q' 3D3
+def D_q_qp_3D3(x) :
+ return 2.*aS**2*R02/math.pi*(1 - x)**2*x*(90 + 90*(-7 + 2*a1)*x + 5*(399 - 174*a1 + 200*a1**2)*x**2 + 10*(-378 + 193*a1 - 437*a1**2 + 70*a1**3)*x**3 + (4725 - 2900*a1 + 8390*a1**2 - 1918*a1**3 + 2268*a1**4)*x**4 + 2*(-1995 + 1700*a1 - 4930*a1**2 + 1617*a1**3 - 2387*a1**4 + 350*a1**5)*x**5 + (2205 - 2830*a1 + 7940*a1**2 - 5194*a1**3 + 4914*a1**4 - 930*a1**5 + 1000*a1**6)*x**6 - 2*(360 - 325*a1 + 1680*a1**2 - 749*a1**3 + 1540*a1**4 + 295*a1**5 + 90*a1**6)*a2*x**7 + 5*(21 - 14*a1 + 133*a1**2 - 56*a1**3 + 189*a1**4 - 18*a1**5 + 18*a1**6)*a2**2*x**8)/(405.*a1**6*M**7*(1 - a2*x)**10)
+
+def D_q_qp_3D2(x) :
+ return aS**2*R02/math.pi*(-1 + x)**2*x*(180 + 180*(-7 + 4*a1)* x + 5* (777 - 852*a1 +464*a1**2 -64*a1**3 +128*a1**4)*x**2 - 10* (693 - 1087*a1 +1126*a1**2 -624*a1**3 +112*a1**4 +128*a1**5)*x**3 + (7875 -15650*a1 +23295*a1**2 -22564*a1**3 +9112*a1**4 +128*a1**5 +2304*a1**6)*x**4+ 4* (-1470 +2005*a1 -4740*a1**2 +4613*a1**3 -2296*a1**4 +488*a1**5 +320*a1**6)*a2* x**5 + (2835 - 2050*a1 +12035*a1**2 -8332*a1**3 +5952*a1**4 -960*a1**5 +640*a1**6)* a2**2*x**6 + 2* (-405 + 40*a1 -2565*a1**2 +602*a1**3 -1000*a1**4 +320*a1**5)* a2**3*x**7 + 5* (21 + 10*a1 +205*a1**2 +52*a1**3 +84*a1**4)*a2**4* x**8)/(648.*a1**6*a2**2*M**7*(-1 + a2*x)**10)
+
+def D_q_qp_1D2(x) :
+ return (aS**2*R02/math.pi*(-1 + x)**2*x*(60 - 60* (7 - 8*a1 +4*a1**2)*x + 5* (267 - 600*a1 +580*a1**2 -160*a1**3 +64*a1**4)*x**2 - 10* (255 - 825*a1 +1130*a1**2 -596*a1**3 +88*a1**4 +64*a1**5)*x**3 + (3225 -13050*a1 +22585*a1**2 -16872*a1**3 +5036*a1**4 -576*a1**5 +1152*a1**6)*x**4+ 4* (-690 + 2535*a1 -4200*a1**2 +2279*a1**3 -968*a1**4 +524*a1**5 +160*a1**6)*a2* x**5 + (1545 - 4890*a1 +8525*a1**2 -2176*a1**3 +3076*a1**4 -320*a1**5 +320*a1**6)* a2**2*x**6 - 2* (255 - 660*a1 +1475*a1**2 +174*a1**3 +740*a1**4 +120*a1**5)* a2**3*x**7 + 5* (15 - 30*a1 +107*a1**2 +56*a1**3 +80*a1**4)*a2**4* x**8))/(324.*a1**6*a2**2*M**7*(-1 + a2*x)**10)
+
+def D_q_qp_D2(x) :
+ return mix1**2*D_q_qp_1D2(x)+mix2**2*D_q_qp_3D2(x)+mix1*mix2*(aS**2*5.*R02/math.pi*(-1 + x)**2*x*(-12 + 12* (5 - 4*a1 +2*a1**2)*x - (129 - 198*a1 +156*a1**2 +64*a1**3)*x**2 + 4* (39 - 85*a1 +76*a1**2 -8*a1**3 +36*a1**4)*x**3 - 2* (57 - 156*a1 +133*a1**2 -130*a1**3 +198*a1**4 +48*a1**5)*x**4 - 4* (-12 + 27*a1 -4*a1**2 +51*a1**3 +2*a1**4 +14*a1**5)*a2* x**5 + (-9 + 16*a1 +11*a1**2 +62*a1**3 +4*a1**4)*a2**2* x**6))/(54.*math.sqrt(6.)*a1**6*a2**2*M**7*(-1 + a2*x)**8)
+
+def D_cc1(z) :
+ return 4.*aS**2*R02*(1.-z)**2*z*(16.-32.*z+72.*z**2-32.*z**3+5.*z**4)/(9.*m1**3*math.pi*(2.-z)**6)
+
+def D_bc0(z) :
+ return aS**2*a1*R02*(1 - z)**2*z*(6 - 18*(1 - 2*a1)*z + (21 - 74*a1 + 68*a1**2)*z**2 - 2*(1 - a1)*(6 - 19*a1 + 18*a1**2)*z**3 + 3*(1 - a1)**2*(1 - 2*a1 + 2*a1**2)*z**4)/(54.*m1**3*math.pi*(1 - (1 - a1)*z)**6)
+
+def D_bc1(z) :
+ return aS**2*a1*R02*(1 - z)**2*z*(2 - 2*(3 - 2*a1)*z + 3*(3 - 2*a1 + 4*a1**2)*z**2 - 2*(1 - a1)*(4 - a1 + 2*a1**2)*z**3 + (1 - a1)**2*(3 - 2*a1 + 2*a1**2)*z**4)/(18.*m1**3*math.pi*(1 - (1 - a1)*z)**6)
+
+# analytic line
+def fragmentation(funct,scale,step) :
+ x = []
+ y = []
+ xe=step
+ while xe<1. :
+ x.append(xe)
+ y.append(funct(x[-1])*scale)
+ xe+=step
+ return (x,y)
+
+# latex for plots
+latexName = {441 : "\\eta_c", 443 : "J/\\psi", 100441 : "\\eta_c(2S)", 100443 : "\psi(2S)",
+
+ 10443 : "h_c", 10441: "\\chi_{c0}", 20443: "\\chi_{c1}", 445: "\\chi_{c2}",
+
+ 30443 : "\\psi(3770)" , 20445 : "\\psi_2(1D)", 447 : "\\psi_3(1D)",
+
+ 551 : "\\eta_b", 553 : "\\Upsilon" , 100551 : "\\eta_b(2S)", 100553 : "\\Upsilon(2S)", 200551 : "\\eta_b(3S)", 200553 : "\\Upsilon(3S)", 300553 : "\\Upsilon(4S)",
+
+ 10553 : "h_b", 10551: "\\chi_{b0}", 20553: "\\chi_{b1}", 555: "\\chi_{b2}",
+
+ 110553 : "h_b(2P)", 110551: "\\chi_{b0}(2P)", 120553: "\\chi_{b1}(2P)", 100555: "\\chi_{b2}(2P)",
+ 210553 : "h_b(3P)", 210551: "\\chi_{b0}(3P)", 220553: "\\chi_{b1}(3P)", 200555: "\\chi_{b2}(3P)",
+
+ 10555 : "\\eta_{b2}", 30553 : "\\Upsilon_1(1D)", 20555 : "\\Upsilon_2(1D)", 557 : "\\Upsilon_3(1D)",
+
+ 541 : "B_c^+", 543 : "B_c^{*+}", 10541 : "B_{c0}^{*+}", 545 : "B_{c2}^{*+}",
+ 100541 : "B_c(2S)^+", 100543 : "B_c(2S)^{*+}", 10543 : "B_{c1}^+", 20543 : "B_{c1}^{\\prime+}",
+ 30543 : "B_c(1D)^{*+}", 547 : "B_{c3}(1D)^{*+}", 20545 : "B_{c2}(H)^{+}", 10545 : "B_{c2}(L)^+",
+ 4403 : "(cc)_1", 5503 : "(bb)_1", 5401 : "(bc)_0", 5403 : "(bc)_1" }
+
+
+herwigName = {441 : "eta_c" , 443 : "Jpsi" , 100441 : "eta_c(2S)" , 100443 : "psi(2S)",
+ 10443 : "h_c", 10441: "chi_c0", 20443: "chi_c1", 445: "chi_c2",
+ 30443 : "psi(3770)" , 20445 : "psi_2(1D)", 447 : "psi_3(1D)",
+
+ 551 : "eta_b" , 553 : "Upsilon" , 100551 : "eta_b(2S)" , 100553 : "Upsilon(2S)", 200551 : "eta_b(3S)", 200553 : "Upsilon(3S)", 300553 : "Upsilon(4S)",
+ 10553 : "h_b", 10551: "chi_b0", 20553: "chi_b1", 555: "chi_b2",
+ 110553 : "h_b(2P)", 110551: "chi_b0(2P)", 120553: "chi_b1(2P)", 100555: "chi_b2(2P)",
+ 210553 : "h_b(3P)", 210551: "chi_b0(3P)", 220553: "chi_b1(3P)", 200555: "chi_b2(3P)",
+ 10555 : "eta_b2", 30553 : "Upsilon_1(1D)", 20555 : "Upsilon_2(1D)", 557 : "Upsilon_3(1D)",
+
+ 541 : "B_c+", 543 : "B_c*+", 10541 : "B*_c0+", 545 : "B_c2+", 10543 : "B_c1+", 20543 : "B'_c1+",
+ 100541 : "B_c(2S)+", 100543 : "B_c(2S)*+",
+ 30543 : "B_c(1D)*+", 547 : "B_c3(1D)*+", 20545 : "B_c2(H)+", 10545 : "B_c2(L)+",
+
+ 4403 : "cc_1", 5503 : "bb_1", 5401 : "bc_0", 5403 : "bc_1" }
+
+
+# splitting tests
+testParameters={ "ctocEta_c" : [441 ,"ctoc11S0SplittingSudakov",4,"ccbar","1S",0.26,1.5,4.9,0.8**3,5e2 ,D_q_q_1S0,10**4],
+ "ctocJPsi" : [443 ,"ctoc13S1SplittingSudakov",4,"ccbar","1S",0.26,1.5,4.9,0.8**3,5e2 ,D_q_q_3S1,10**4],
+ "ctocEta_c2S" : [100441 ,"ctoc21S0SplittingSudakov",4,"ccbar","2S",0.26,1.5,4.9,0.6966,5e2 ,D_q_q_1S0,10**4],
+ "ctocPsi2S" : [100443 ,"ctoc23S1SplittingSudakov",4,"ccbar","2S",0.26,1.5,4.9,0.6966,5e2 ,D_q_q_3S1,10**4],
+
+ "gtogEta_c" : [441 ,"gtogcc11S0SplittingSudakov",21,"ccbar","1S",0.26,1.5,4.9,0.8**3,5e2 ,D_g_g_1S0,10**4],
+ "gtogJPsi" : [443 ,"gtogcc13S1SplittingSudakov",21,"ccbar","1S",0.26,1.5,4.9,0.8**3,5e4 ,D_g_g_3S1,10**6],
+ "gtogEta_c2S" : [100441 ,"gtogcc21S0SplittingSudakov",21,"ccbar","2S",0.26,1.5,4.9,0.6966,5e2 ,D_g_g_1S0,10**4],
+ "gtogPsi2S" : [100443 ,"gtogcc23S1SplittingSudakov",21,"ccbar","2S",0.26,1.5,4.9,0.6966,5e4 ,D_g_g_3S1,10**6],
+
+ "gtogChi_c0" : [10441 ,"gtogcc13P0SplittingSudakov",21,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_g_g_3P0,10**7],
+ "gtogChi_c1" : [20443 ,"gtogcc13P1SplittingSudakov",21,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_g_g_3P1,10**6],
+ "gtogChi_c2" : [ 445 ,"gtogcc13P2SplittingSudakov",21,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_g_g_3P2,10**6],
+
+ "ctocH_c" : [10443 ,"ctoc11P1SplittingSudakov",4,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_q_q_1P1,10**4],
+ "ctocChi_c0" : [10441 ,"ctoc13P0SplittingSudakov",4,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_q_q_3P0,10**4],
+ "ctocChi_c1" : [20443 ,"ctoc13P1SplittingSudakov",4,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_q_q_3P1,10**4],
+ "ctocChi_c2" : [ 445 ,"ctoc13P2SplittingSudakov",4,"ccbar","1P",0.26,1.5,4.9,0.1296,5e2 ,D_q_q_3P2,10**4],
+ "ctocPsi3770" : [30443 ,"ctoc13D1SplittingSudakov",4,"ccbar","1D",0.26,1.5,4.9,0.0329,5e3 ,D_q_q_3D1,10**5],
+ "ctocPsi_2" : [20445 ,"ctoc13D2SplittingSudakov",4,"ccbar","1D",0.26,1.5,4.9,0.0329,5e3 ,D_q_q_3D2,10**5],
+ "ctocPsi_3" : [ 447 ,"ctoc13D3SplittingSudakov",4,"ccbar","1D",0.26,1.5,4.9,0.0329,5e3 ,D_q_q_3D3,10**5],
+
+ "btobEta_b" : [551 ,"btob11S0SplittingSudakov",5,"bbbar","1S",0.19,1.5,4.9,1.8**3,5e3 ,D_q_q_1S0,10**5],
+ "btobUpsilon" : [553 ,"btob13S1SplittingSudakov",5,"bbbar","1S",0.19,1.5,4.9,1.8**3,5e3 ,D_q_q_3S1,10**5],
+ "btobEta_b2S" : [100551 ,"btob21S0SplittingSudakov",5,"bbbar","2S",0.19,1.5,4.9,2.8974,5e3 ,D_q_q_1S0,10**5],
+ "btobUpsilon2S" : [100553 ,"btob23S1SplittingSudakov",5,"bbbar","2S",0.19,1.5,4.9,2.8974,5e3 ,D_q_q_3S1,10**5],
+ "btobEta_b3S" : [200551 ,"btob31S0SplittingSudakov",5,"bbbar","3S",0.19,1.5,4.9,2.2496,5e3 ,D_q_q_1S0,10**5],
+ "btobUpsilon3S" : [200553 ,"btob33S1SplittingSudakov",5,"bbbar","3S",0.19,1.5,4.9,2.2496,5e3 ,D_q_q_3S1,10**5],
+ "btobUpsilon4S" : [300553 ,"btob43S1SplittingSudakov",5,"bbbar","4S",0.19,1.5,4.9,1.9645,5e3 ,D_q_q_3S1,10**5],
+
+ "gtogEta_b" : [551 ,"gtogbb11S0SplittingSudakov",21,"bbbar","1S",0.19,1.5,4.9,1.8**3,5e3 ,D_g_g_1S0,10**5],
+ "gtogUpsilon" : [553 ,"gtogbb13S1SplittingSudakov",21,"bbbar","1S",0.19,1.5,4.9,1.8**3,5e5 ,D_g_g_3S1,10**7],
+ "gtogEta_b2S" : [100551 ,"gtogbb21S0SplittingSudakov",21,"bbbar","2S",0.19,1.5,4.9,2.8974,5e3 ,D_g_g_1S0,10**5],
+ "gtogUpsilon2S" : [100553 ,"gtogbb23S1SplittingSudakov",21,"bbbar","2S",0.19,1.5,4.9,2.8974,5e5 ,D_g_g_3S1,10**7],
+ "gtogEta_b3S" : [200551 ,"gtogbb31S0SplittingSudakov",21,"bbbar","3S",0.19,1.5,4.9,2.2496,5e3 ,D_g_g_1S0,10**5],
+ "gtogUpsilon3S" : [200553 ,"gtogbb33S1SplittingSudakov",21,"bbbar","3S",0.19,1.5,4.9,2.2496,5e5 ,D_g_g_3S1,10**7],
+ "gtogUpsilon4S" : [300553 ,"gtogbb43S1SplittingSudakov",21,"bbbar","4S",0.19,1.5,4.9,1.9645,5e5 ,D_g_g_3S1,10**7],
+
+ "btobH_b" : [10553 ,"btob11P1SplittingSudakov",5,"bbbar","1P",0.19,1.5,4.9,1.6057,10000.,D_q_q_1P1,10**6],
+ "btobChi_b0" : [10551 ,"btob13P0SplittingSudakov",5,"bbbar","1P",0.19,1.5,4.9,1.6057,10000.,D_q_q_3P0,10**6],
+ "btobChi_b1" : [20553 ,"btob13P1SplittingSudakov",5,"bbbar","1P",0.19,1.5,4.9,1.6057,10000.,D_q_q_3P1,10**6],
+ "btobChi_b2" : [ 555 ,"btob13P2SplittingSudakov",5,"bbbar","1P",0.19,1.5,4.9,1.6057,10000.,D_q_q_3P2,10**6],
+
+ "btobH_b2P" : [110553 ,"btob21P1SplittingSudakov",5,"bbbar","2P",0.19,1.5,4.9,1.8240,5e4 ,D_q_q_1P1,10**6],
+ "btobChi_b02P" : [110551 ,"btob23P0SplittingSudakov",5,"bbbar","2P",0.19,1.5,4.9,1.8240,5e4 ,D_q_q_3P0,10**6],
+ "btobChi_b12P" : [120553 ,"btob23P1SplittingSudakov",5,"bbbar","2P",0.19,1.5,4.9,1.8240,5e4 ,D_q_q_3P1,10**6],
+ "btobChi_b22P" : [100555 ,"btob23P2SplittingSudakov",5,"bbbar","2P",0.19,1.5,4.9,1.8240,5e4 ,D_q_q_3P2,10**6],
+
+ "btobChi_b03P" : [210551 ,"btob33P0SplittingSudakov",5,"bbbar","3P",0.19,1.5,4.9,1.9804,5e4 ,D_q_q_3P0,10**6],
+ "btobChi_b13P" : [220553 ,"btob33P1SplittingSudakov",5,"bbbar","3P",0.19,1.5,4.9,1.9804,5e4 ,D_q_q_3P1,10**6],
+ "btobChi_b23P" : [200555 ,"btob33P2SplittingSudakov",5,"bbbar","3P",0.19,1.5,4.9,1.9804,5e4 ,D_q_q_3P2,10**6],
+
+ "btobEta_b2" : [10555 ,"btob11D2SplittingSudakov",5,"bbbar","1D",0.26,1.5,4.9,0.8394,5.e5 ,D_q_q_1D2,10**7],
+ "btobUpsilon_1" : [30553 ,"btob13D1SplittingSudakov",5,"bbbar","1D",0.26,1.5,4.9,0.8394,1.e6 ,D_q_q_3D1,10**7],
+ "btobUpsilon_2" : [20555 ,"btob13D2SplittingSudakov",5,"bbbar","1D",0.26,1.5,4.9,0.8394,1.e6 ,D_q_q_3D2,10**7],
+ "btobUpsilon_3" : [ 557 ,"btob13D3SplittingSudakov",5,"bbbar","1D",0.26,1.5,4.9,0.8394,1.e6 ,D_q_q_3D3,10**7],
+
+ "btocB_c" : [541 ,"btoc11S0SplittingSudakov",5,"bcbar","1S",0.26,1.5,4.9,1.9943,100.,D_q_qp_1S0,10**3],
+ "btocB_cStar" : [543 ,"btoc13S1SplittingSudakov",5,"bcbar","1S",0.26,1.5,4.9,1.9943,100.,D_q_qp_3S1,10**3],
+ "btocB_c2S" : [100541 ,"btoc21S0SplittingSudakov",5,"bcbar","2S",0.26,1.5,4.9,2.8974,100.,D_q_qp_1S0,10**3],
+ "btocB_cStar2S" : [100543 ,"btoc23S1SplittingSudakov",5,"bcbar","2S",0.26,1.5,4.9,2.8974,100.,D_q_qp_3S1,10**3],
+
+ "btocB_c0" : [10541 ,"btoc13P0SplittingSudakov",5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_3P0,10**4],
+ "btocB_c2" : [545 ,"btoc13P2SplittingSudakov",5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_3P2,10**4],
+ "btocB_c1P1" : [10543 ,"btoc1P1SplittingSudakov" ,5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_1P1,10**4,90.],
+ "btocB_c3P1" : [20543 ,"btoc1P1SplittingSudakov" ,5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_3P1,10**4,90.],
+ "btocB_c1P1mix" : [10543 ,"btoc1P1SplittingSudakov" ,5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_P1 ,10**4,25.],
+ "btocB_c3P1mix" : [20543 ,"btoc1P1SplittingSudakov" ,5,"bcbar","1P",0.26,1.5,4.9,0.3083,500.,D_q_qp_P1 ,10**4,25.],
+
+ "btocB_cStar1D" : [30543 ,"btoc13D1SplittingSudakov",5,"bcbar","1D",0.26,1.5,4.9,0.0986,5000.,D_q_qp_3D1,10**5],
+ "btocB_c3" : [547 ,"btoc13D3SplittingSudakov",5,"bcbar","1D",0.26,1.5,4.9,0.0986,1000.,D_q_qp_3D3,10**5],
+ "btocB_c1D2" : [10545 ,"btoc1D2SplittingSudakov" ,5,"bcbar","1D",0.26,1.5,4.9,0.0986,5000.,D_q_qp_1D2,10**5,90.],
+ "btocB_c3D2" : [20545 ,"btoc1D2SplittingSudakov" ,5,"bcbar","1D",0.26,1.5,4.9,0.0986,5000.,D_q_qp_3D2,10**5,90.],
+ "btocB_c1D2mix" : [10545 ,"btoc1D2SplittingSudakov" ,5,"bcbar","1D",0.26,1.5,4.9,0.0986,5000.,D_q_qp_D2 ,10**5,34.4],
+ "btocB_c3D2mix" : [20545 ,"btoc1D2SplittingSudakov" ,5,"bcbar","1D",0.26,1.5,4.9,0.0986,5000.,D_q_qp_D2 ,10**5,34.4],
+
+ "ctocbarcc1" : [4403 ,"QtoQcc1SplittingSudakov" ,4,"cc" ,"1S",0.26,1.5,4.9,0.07 ,1e3,D_cc1,1e5],
+ "btobbarbb1" : [5503 ,"QtoQbb1SplittingSudakov" ,5,"bb" ,"1S",0.26,1.5,4.9,0.633,1e3,D_cc1,1e5],
+ "btocbarbc0" : [5401 ,"QtoQbc0SplittingSudakov" ,5,"bc" ,"1S",0.26,1.5,4.9,0.25 ,5e2,D_bc0,1e5],
+ "btocbarbc1" : [5403 ,"QtoQbc1SplittingSudakov" ,5,"bc" ,"1S",0.26,1.5,4.9,0.25 ,5e2,D_bc1,1e5],
+}
+# options
+op = optparse.OptionParser(usage=__doc__)
+op.add_option("--generate-input-files", dest="infiles", default=False, action="store_true")
+op.add_option("--analyse", dest="analyse", default=False, action="store_true")
+op.add_option("--fast", dest="fast", default=False, action="store_true")
+opts, args = op.parse_args()
+# get template and write the file
+with open(os.path.join("Rivet/Templates/EE.in"), 'r') as f:
+ templateText = f.read()
+template = Template( templateText )
+# if we are generating the inputfiles
+if opts.infiles :
+ targets=""
+ # first find all the splittings
+ opts, args = op.parse_args()
+ splittings=[]
+ for fname in ["../src/defaults/Shower.in",
+ "../src/snippets/OniumShower.in"] :
+ infile=open(fname)
+ line=infile.readline()
+ while line :
+ if "SplittingGenerator:AddFinalSplitting" in line:
+ splittings.append(line.replace("Add","Delete"))
+ line=infile.readline()
+ infile.close()
+ # now loop over the examples
+ for (key,val) in testParameters.items() :
+ # mass of the state
+ if val[3]=="ccbar" or val[3]=="cc" :
+ mO=2.*val[6]
+ elif val[3]=="bbbar" or val[3]=="bb" :
+ mO=2.*val[7]
+ else :
+ mO=val[6]+val[7]
+ # process
+ if val[2] < 6 :
+ proc = """
+insert /Herwig/MatrixElements/SubProcess:MatrixElements 0 /Herwig/MatrixElements/MEee2gZ2qq
+set /Herwig/MatrixElements/MEee2gZ2qq:MinimumFlavour %s
+set /Herwig/MatrixElements/MEee2gZ2qq:MaximumFlavour %s
+""" % ( val[2],val[2])
+ elif val[2]==21 :
+ proc ="""
+create Herwig::MEee2Higgs2SM /Herwig/MatrixElements/MEee2Higgs2SM
+insert /Herwig/MatrixElements/SubProcess:MatrixElements 0 /Herwig/MatrixElements/MEee2Higgs2SM
+set /Herwig/MatrixElements/MEee2Higgs2SM:Allowed Gluon
+"""
+ # substs for the input file
+ parameters={"parameterFile" : """
+set /Herwig/Generators/EventGenerator:EventHandler:LuminosityFunction:Energy 10000.
+set /Herwig/Generators/EventGenerator:EventHandler:HadronizationHandler NULL
+set /Herwig/Generators/EventGenerator:EventHandler:DecayHandler NULL
+set /Herwig/Analysis/Basics:CheckQuark No
+set /Herwig/Particles/d:ConstituentMass 1e-10
+set /Herwig/Particles/u:ConstituentMass 1e-10
+set /Herwig/Particles/g:ConstituentMass 1e-9
+insert /Herwig/Analysis/RivetAnalysis:Analyses 0 MC_Simple_Onium""",
+ "process" : """
+%s
+set /Herwig/Particles/b:ConstituentMass %s
+set /Herwig/Particles/c:ConstituentMass %s
+set /Herwig/Particles/b:NominalMass %s
+set /Herwig/Particles/c:NominalMass %s
+set /Herwig/Particles/%s:NominalMass %s\n""" %(proc,val[7],val[6],val[7],val[6],herwigName[val[0]],mO),
+ "shower" : """
+read snippets/OniumShower.in
+set /Herwig/Shower/ShowerHandler:HardEmission 0
+do /Herwig/OniumParameters:SetWaveFunction %s %s %s
+set /Herwig/Shower/%s:FixedAlphaS %s
+set /Herwig/Shower/%s:EnhancementFactor %s
+cd /Herwig/Shower
+"""%(val[3],val[4],val[8],val[1],val[5],val[1],val[9])}
+ # mixing if needed
+ if len(val) == 13 :
+ parameters["shower"] += "do /Herwig/OniumParameters:SetSingletTripletMixing %s %s\n" % (val[4],val[12])
+ hName=herwigName[val[0]]
+ if val[3] == "bcbar" and val[2]==5 : hName=hName.replace("+","-")
+ # delete other splittings
+ for sp in splittings :
+ if not (val[1] in sp and hName in sp):
+ parameters["shower"] += sp
+ # write the input file
+ parameters["runname"]="Onium-%s"%key
+ with open(os.path.join("Rivet","Onium-%s.in"%key), 'w') as f:
+ f.write( template.substitute(parameters) )
+ targets += "Onium-%s.yoda " % key
+ print(targets)
+# if we are doing the analysis
+if opts.analyse :
+ if not os.path.isdir("Onium-Splitting"):
+ os.mkdir("Onium-Splitting")
+ plots=""
+ # loop over the tests
+ for (key,val) in testParameters.items() :
+ # mass of the quarks
+ if val[3]=="ccbar" or val[3]=="cc":
+ m1=val[6]
+ m2=val[6]
+ elif val[3]=="bbbar" or val[3]=="bb":
+ m1=val[7]
+ m2=val[7]
+ elif val[3]=="bcbar" or val[3]=="bc":
+ m1=val[6]
+ m2=val[7]
+ M = m1+m2
+ a1 = m1/M
+ a2 = 1-a1
+ # other parameters
+ aS = val[5]
+ R02 = val[8]
+ # mixing if needed
+ if len(val) == 13 :
+ mix1 = math.sin(val[12]/180.*math.pi)
+ mix2 = math.cos(val[12]/180.*math.pi)
+ itest = int((val[0]%100000)/10000);
+ if itest==2 :
+ (mix1,mix2) = (mix2,-mix1)
+ else :
+ mix1=0
+ mix2=0
+ if(val[2]==21) :
+ q1="g"
+ q2="g"
+ else :
+ if val[2] ==4 : q1 = "c"
+ elif val[2] ==5 : q1 = "b"
+ if val[3] != "bcbar" and val[3] !="bc" : q2 = q1
+ elif q1=="c" : q2 = "b"
+ else : q2 = "c"
+ lName=latexName[val[0]]
+ if q1=="b" and q2=="c" : lName=lName.replace("+","-")
+ if len(val[3])==2 :
+ title="Comparsion of fragmentation function for $%s\\to \\bar{%s} %s$" % (q1,q2,lName)
+ else :
+ title="Comparsion of fragmentation function for $%s\\to %s %s$" % (q1,q2,lName)
+ if len(val) == 13 :
+ title+=" ($\\theta=%.1f^0$)" % val[12]
+ plt.title(title)
+ aos = yoda.read("Onium-%s.yoda" % key)
+ histo = aos["/MC_Simple_Onium/h_%s" % val[0]]
+ x = []
+ dx = []
+ y1 = []
+ yan = []
+ dy1= []
+ chisq = 0.
+ ndof = 0
+ for bin in histo.bins() :
+ x .append(bin.xMid() )
+ dx .append(0.5*bin.xWidth())
+ y1 .append(bin.height() *val[11])
+ dy1.append(bin.heightErr()*val[11])
+ if(opts.fast) :
+ fval = val[11]*val[10](bin.xMid())
+ else :
+ fval = val[11]*quad(val[10],bin.xMin(),bin.xMax())[0]/bin.xWidth()
+ yan.append(fval)
+ if(dy1[-1]>0. and x[-1]>0.01 and x[-1]<0.99) :
+ chisq += ((fval-y1[-1])/dy1[-1])**2
+ ndof+=1.
+ if(ndof!=0) : chisq/=ndof
+ if(not opts.fast) :
+ (xan,yan) = fragmentation(val[10],val[11],step)
+ step=0.001
+ else :
+ xan=x
+ plt.plot(xan,yan,label="analytic ",color="black")
+ plt.errorbar(x,y1,yerr=dy1,xerr=dx,linestyle="none",fmt="none",
+ label="Hw Fixed $\\alpha_S$",color="red")
+ plt.xlabel("$z_{%s}$" % lName)
+ plt.ylabel("$D(z_{%s})\\times10^{%s}$" % (lName,int(math.log10(val[11]))))
+ if val[10]==D_g_g_3S1 :
+ loc = 1
+ else :
+ loc = 2
+ plt.legend(loc=loc,title="$\\chi^2/N=%.2f$"%chisq)
+ plt.xlim([0.,1.])
+ plt.savefig("Onium-Splitting/%s.pdf" %key)
+ plt.savefig("Onium-Splitting/%s.png" %key)
+ plt.clf()
+ plots+=plotTemplate.substitute({"id" : key})
+ with open(os.path.join("Onium-Splitting","index.html"), 'w') as f:
+ f.write( htmlTemplate.substitute( {"plots" : plots,
+ "time" :'<p>Generated at %s</p>' % datetime.datetime.now().strftime("%A, %d. %B %Y %I:%M%p") }) )
+
+# setup chi_c2(2P) 100445 chi_c2(2P) 3.929 0.029 0.24 0 0 0 5 0
diff --git a/configure.ac b/configure.ac
--- a/configure.ac
+++ b/configure.ac
@@ -1,273 +1,275 @@
dnl Process this file with autoconf to produce a configure script.
AC_PREREQ([2.63])
AC_INIT([Herwig],[devel],[herwig@projects.hepforge.org],[Herwig])
AC_CONFIG_SRCDIR([Utilities/HerwigStrategy.cc])
AC_CONFIG_AUX_DIR([Config])
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADERS([Config/config.h])
dnl AC_PRESERVE_HELP_ORDER
AC_CANONICAL_HOST
dnl === disable debug symbols by default =====
if test "x$CXXFLAGS" = "x"; then
CXXFLAGS="-O2 -DBOOST_UBLAS_NDEBUG -Wno-deprecated-declarations -Wno-deprecated-copy"
fi
if test "x$CFLAGS" = "x"; then
CFLAGS=-O2
fi
AC_LANG([C++])
AM_INIT_AUTOMAKE([1.11 subdir-objects gnu dist-bzip2 no-dist-gzip -Wall -Wno-portability])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
dnl Checks for C++ compiler. Handle C++11 flags.
AC_PROG_CXX
AX_CXX_COMPILE_STDCXX([11],[noext],[mandatory])
dnl check for POSIX
AC_CHECK_HEADER([unistd.h],[],
[AC_MSG_ERROR([Herwig needs "unistd.h". Non-POSIX systems are not supported.])])
AC_CHECK_HEADER([sys/stat.h],[],
[AC_MSG_ERROR([Herwig needs "sys/stat.h". Non-POSIX systems are not supported.])])
dnl Checks for programs.
AC_PROG_INSTALL
AC_PROG_MAKE_SET
AC_PROG_LN_S
dnl modified search order
AC_PROG_FC([gfortran g95 g77])
dnl xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 xlf f77 frt pgf77 cf77 fort77 fl32 af77])
AC_LANG_PUSH([Fortran])
AC_MSG_CHECKING([if the Fortran compiler ($FC) works])
AC_COMPILE_IFELSE(
AC_LANG_PROGRAM([],[ print *[,]"Hello"]),
[AC_MSG_RESULT([yes])],
[AC_MSG_RESULT([no])
AC_MSG_ERROR([A Fortran compiler is required to build Herwig.])
]
)
AC_LANG_POP([Fortran])
AC_FC_WRAPPERS
LT_PREREQ([2.2.6])
LT_INIT([disable-static dlopen pic-only])
dnl ####################################
dnl ####################################
dnl for Doc/fixinterfaces.pl
AC_PATH_PROG(PERL, perl)
dnl for Models/Feynrules
AM_PATH_PYTHON([2.6],, [:])
AM_CONDITIONAL([HAVE_PYTHON], [test "x$PYTHON" != "x:"])
HERWIG_CHECK_GSL
HERWIG_CHECK_THEPEG
BOOST_REQUIRE([1.41])
BOOST_FIND_HEADER([boost/numeric/ublas/io.hpp])
dnl Boost 1.64 is missing a required header to make these work
dnl we just assume they're there if io.hpp has been found OK above
dnl BOOST_FIND_HEADER([boost/numeric/ublas/matrix.hpp])
dnl BOOST_FIND_HEADER([boost/numeric/ublas/matrix_proxy.hpp])
dnl BOOST_FIND_HEADER([boost/numeric/ublas/matrix_sparse.hpp])
dnl BOOST_FIND_HEADER([boost/numeric/ublas/symmetric.hpp])
dnl BOOST_FIND_HEADER([boost/numeric/ublas/vector.hpp])
BOOST_FIND_HEADER([boost/operators.hpp])
BOOST_TEST()
HERWIG_CHECK_VBFNLO
HERWIG_CHECK_NJET
HERWIG_CHECK_GOSAM
HERWIG_CHECK_GOSAM_CONTRIB
HERWIG_CHECK_OPENLOOPS
HERWIG_CHECK_MADGRAPH
HERWIG_CHECK_EVTGEN
HERWIG_CHECK_PYTHIA
HERWIG_COMPILERFLAGS
HERWIG_LOOPTOOLS
FASTJET_CHECK_FASTJET
HERWIG_ENABLE_MODELS
SHARED_FLAG=-shared
AM_CONDITIONAL(NEED_APPLE_FIXES,
[test "xx${host/darwin/foundit}xx" != "xx${host}xx"])
if test "xx${host/darwin/foundit}xx" != "xx${host}xx"; then
APPLE_DSO_FLAGS=-Wl,-undefined,dynamic_lookup
SHARED_FLAG=-bundle
fi
AC_SUBST([APPLE_DSO_FLAGS])
AC_SUBST([SHARED_FLAG])
AC_SUBST([PYTHON])
AC_CONFIG_FILES([UnderlyingEvent/Makefile
Models/Makefile
Models/StandardModel/Makefile
Models/RSModel/Makefile
Models/General/Makefile
Models/Susy/Makefile
Models/Susy/NMSSM/Makefile
Models/Susy/RPV/Makefile
Models/UED/Makefile
Models/LH/Makefile
Models/DarkMatter/Makefile
Models/LHTP/Makefile
Models/Transplanckian/Makefile
Models/Leptoquarks/Makefile
Models/Zprime/Makefile
Models/TTbAsymm/Makefile
Models/Feynrules/Makefile
Models/Feynrules/python/Makefile-FR
Models/ADD/Makefile
Models/Sextet/Makefile
Decay/Makefile
Decay/FormFactors/Makefile
Decay/Tau/Makefile
Decay/Baryon/Makefile
Decay/VectorMeson/Makefile
Decay/Perturbative/Makefile
Decay/HeavyMeson/Makefile
Decay/ScalarMeson/Makefile
Decay/Dalitz/Makefile
Decay/TensorMeson/Makefile
Decay/WeakCurrents/Makefile
Decay/Partonic/Makefile
Decay/General/Makefile
Decay/Radiation/Makefile
Decay/EvtGen/Makefile
Doc/refman.conf
Doc/refman.h
PDT/Makefile
PDF/Makefile
MatrixElement/Makefile
MatrixElement/General/Makefile
MatrixElement/Lepton/Makefile
MatrixElement/Hadron/Makefile
MatrixElement/DIS/Makefile
MatrixElement/Powheg/Makefile
MatrixElement/Gamma/Makefile
MatrixElement/Reweighters/Makefile
MatrixElement/Onium/Makefile
MatrixElement/Matchbox/Makefile
MatrixElement/Matchbox/Base/Makefile
MatrixElement/Matchbox/Utility/Makefile
MatrixElement/Matchbox/Phasespace/Makefile
MatrixElement/Matchbox/Dipoles/Makefile
MatrixElement/Matchbox/InsertionOperators/Makefile
MatrixElement/Matchbox/Matching/Makefile
MatrixElement/Matchbox/Cuts/Makefile
MatrixElement/Matchbox/Scales/Makefile
MatrixElement/Matchbox/ColorFull/Makefile
MatrixElement/Matchbox/CVolver/Makefile
MatrixElement/Matchbox/Builtin/Makefile
MatrixElement/Matchbox/Builtin/Amplitudes/Makefile
MatrixElement/Matchbox/Tests/Makefile
MatrixElement/Matchbox/External/Makefile
MatrixElement/Matchbox/External/BLHAGeneric/Makefile
MatrixElement/Matchbox/External/VBFNLO/Makefile
MatrixElement/Matchbox/External/NJet/Makefile
MatrixElement/Matchbox/External/GoSam/Makefile
MatrixElement/Matchbox/External/OpenLoops/Makefile
MatrixElement/Matchbox/External/MadGraph/Makefile
MatrixElement/Matchbox/External/MadGraph/mg2herwig
MatrixElement/Matchbox/External/GoSam/gosam2herwig
MatrixElement/FxFx/Makefile
Sampling/Makefile
Sampling/CellGrids/Makefile
Shower/Makefile
Shower/QTilde/Makefile
Shower/QTilde/Matching/Makefile
+ Shower/QTilde/SplittingFunctions/Onium/Makefile
Shower/Dipole/Makefile
Shower/Dipole/Base/Makefile
Shower/Dipole/Kernels/Makefile
Shower/Dipole/Kinematics/Makefile
Shower/Dipole/Utility/Makefile
Shower/Dipole/AlphaS/Makefile
Shower/Dipole/SpinCorrelations/Makefile
Utilities/Makefile
Utilities/XML/Makefile
Utilities/Statistics/Makefile
Hadronization/Makefile
lib/Makefile
include/Makefile
src/Makefile
src/defaults/Makefile
src/snippets/Makefile
src/Matchbox/Makefile
src/herwig-config
Doc/Makefile
Doc/HerwigDefaults.in
Looptools/Makefile
Analysis/Makefile
API/Makefile
src/Makefile-UserModules
src/defaults/Analysis.in
src/defaults/MatchboxDefaults.in
src/defaults/Decays.in
src/defaults/decayers.in
src/defaults/setup.gosam.in
src/Matchbox/LO-DefaultShower.in
src/Matchbox/LO-DipoleShower.in
src/Matchbox/MCatLO-DefaultShower.in
src/Matchbox/MCatLO-DipoleShower.in
src/Matchbox/LO-NoShower.in
src/Matchbox/MCatNLO-DefaultShower.in
src/Matchbox/MCatNLO-DipoleShower.in
src/Matchbox/NLO-NoShower.in
src/Matchbox/Powheg-DefaultShower.in
src/Matchbox/Powheg-DipoleShower.in
src/Merging/Makefile
Shower/Dipole/Merging/Makefile
src/defaults/MatchboxMergingDefaults.in
Contrib/Makefile
Contrib/make_makefiles.sh
Tests/Makefile
Makefile])
AC_CONFIG_FILES([Tests/python/rivet_check ],[chmod +x Tests/python/rivet_check ])
AC_CONFIG_FILES([Tests/python/LowEnergy-EE.py ],[chmod +x Tests/python/LowEnergy-EE.py ])
AC_CONFIG_FILES([Tests/python/LowEnergy-Photon.py],[chmod +x Tests/python/LowEnergy-Photon.py])
AC_CONFIG_FILES([Tests/python/OniumSigma.py ],[chmod +x Tests/python/OniumSigma.py ])
+AC_CONFIG_FILES([Tests/python/OniumSplitting.py ],[chmod +x Tests/python/OniumSplitting.py ])
AC_CONFIG_FILES([Tests/python/make_input_files.py],[chmod +x Tests/python/make_input_files.py])
AC_CONFIG_FILES([Tests/python/merge-DIS ],[chmod +x Tests/python/merge-DIS ])
AC_CONFIG_FILES([Tests/python/merge-EE ],[chmod +x Tests/python/merge-EE ])
AC_CONFIG_FILES([Tests/python/merge-EE-Gamma ],[chmod +x Tests/python/merge-EE-Gamma ])
AC_CONFIG_FILES([Tests/python/merge-Fixed ],[chmod +x Tests/python/merge-Fixed ])
AC_CONFIG_FILES([Tests/python/merge-GammaGamma ],[chmod +x Tests/python/merge-GammaGamma ])
AC_CONFIG_FILES([Tests/python/merge-LHC-EW ],[chmod +x Tests/python/merge-LHC-EW ])
AC_CONFIG_FILES([Tests/python/merge-LHC-Jets ],[chmod +x Tests/python/merge-LHC-Jets ])
AC_CONFIG_FILES([Tests/python/merge-LHC-Photon ],[chmod +x Tests/python/merge-LHC-Photon ])
AC_CONFIG_FILES([Tests/python/mergeLowEnergy.py ],[chmod +x Tests/python/mergeLowEnergy.py ])
AC_CONFIG_FILES([Tests/python/merge-Star ],[chmod +x Tests/python/merge-Star ])
AC_CONFIG_FILES([Tests/python/merge-SppS ],[chmod +x Tests/python/merge-SppS ])
AC_CONFIG_FILES([Tests/python/merge-TVT-EW ],[chmod +x Tests/python/merge-TVT-EW ])
AC_CONFIG_FILES([Tests/python/merge-TVT-Jets ],[chmod +x Tests/python/merge-TVT-Jets ])
AC_CONFIG_FILES([Tests/python/merge-TVT-Photon ],[chmod +x Tests/python/merge-TVT-Photon ])
AC_CONFIG_FILES([Tests/python/plot-EE ],[chmod +x Tests/python/plot-EE ])
AC_CONFIG_FILES([Tests/python/R.py ],[chmod +x Tests/python/R.py ])
AC_CONFIG_FILES([Sampling/herwig-mergegrids ],[chmod +x Sampling/herwig-mergegrids ])
AC_CONFIG_LINKS([Doc/BSMlibs.in:Doc/BSMlibs.in])
AC_CONFIG_FILES([Doc/fixinterfaces.pl],[chmod +x Doc/fixinterfaces.pl])
AC_CONFIG_HEADERS([PDF/SaSPhotonPDF.cc])
HERWIG_OVERVIEW
AC_CONFIG_COMMANDS([summary],[cat config.herwig])
AC_OUTPUT
diff --git a/src/snippets/Makefile.am b/src/snippets/Makefile.am
--- a/src/snippets/Makefile.am
+++ b/src/snippets/Makefile.am
@@ -1,50 +1,51 @@
BUILT_SOURCES = done-all-links
snippetsdir = ${pkgdatadir}/snippets
INPUTFILES = \
CellGridSampler.in \
Diffraction.in \
DipoleMerging.in \
DipoleShowerFiveFlavours.in \
DipoleShowerFourFlavours.in \
EECollider.in \
EPCollider.in \
PECollider.in \
HepMCFixedOrder.in \
HepMC.in \
Matchbox.in \
MB-DipoleShower.in \
MB.in \
MonacoSampler.in \
Particles-SetLonglivedParticlesStable.in \
PDF-CT10.in \
PDF-NNPDF30NLO.in \
PPCollider.in \
RivetFixedOrder.in \
Rivet.in \
YFS.in \
CMWinQtiledShower.in \
Dipole_AutoTunes_gss.in \
Tune-DotProduct.in \
Tune-DotProduct-Veto.in \
Tune-pT.in \
Tune-Q2.in \
EvolutionScheme-DotProduct.in \
EvolutionScheme-DotProduct-Veto.in \
EvolutionScheme-pT.in \
EvolutionScheme-Q2.in \
FixedTarget.in \
FixedTarget-PP.in \
+OniumShower.in \
H7Hadrons.in
dist_snippets_DATA = $(INPUTFILES)
CLEANFILES = done-all-links
done-all-links: $(INPUTFILES)
@echo "Linking input files"
@for i in $(INPUTFILES); do \
if test -f $(srcdir)/$$i -a ! -e $$i; then \
$(LN_S) -f $(srcdir)/$$i; fi; done
@touch done-all-links

File Metadata

Mime Type
text/x-diff
Expires
Sat, May 3, 5:40 AM (4 h, 50 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4982791
Default Alt Text
(832 KB)

Event Timeline