No OneTemporary
Actions

Size

41 KB

Subscribers

None

View Options

	diff --git a/Models/Sextet/SextetFFVVertex.cc b/Models/Sextet/SextetFFVVertex.cc
	--- a/Models/Sextet/SextetFFVVertex.cc
	+++ b/Models/Sextet/SextetFFVVertex.cc
	@@ -1,171 +1,168 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the SextetFFVVertex class.
	//

	#include "SextetFFVVertex.h"
	#include "SextetModel.h"
	#include "SextetParticles.h"
	#include "ThePEG/Interface/ClassDocumentation.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;

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

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

	void SextetFFVVertex::persistentOutput(PersistentOStream & os) const {
	os << g2_ << g2p_ ;
	}

	void SextetFFVVertex::persistentInput(PersistentIStream & is, int) {
	is >> g2_ >> g2p_ ;
	}


	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeClass<SextetFFVVertex,Helicity::FFVVertex>
	describeSextetFFVVertex("Herwig::SextetFFVVertex", "HwSextetModel.so");

	void SextetFFVVertex::Init() {

	static ClassDocumentation<SextetFFVVertex> documentation
	("The SextetFFVVertex class implements the coupling of two "
	"fermions to a scalar sextet particle.");

	}

	void SextetFFVVertex::doinit() {
	orderInGs (0);
	orderInGem(1);
	SextetModelPtr model =
	dynamic_ptr_cast<SextetModelPtr>(generator()->standardModel());
	if(!model) throw Exception() << "Must be using the SextetModel"
	<< " in SextetGSSVertex::doinit()"
	<< Exception::runerror;
	// extract the couplings
	g2_ = model->g2();
	g2p_= model->g2p();
	// add the enabled particles
	if(model->VectorDoubletY16Enabled()) {
	for(long ix=0;ix<3;++ix) {
	long iu = 2*ix + 2;
	long id = 2*ix + 1;
	if(g2_[ix]!=0.) {
	addToList( -id, -iu, ParticleID::VectorDQY16P);
	addToList( id, iu, ParticleID::VectorDQY16Pbar);
	addToList( -id, -id, ParticleID::VectorDQY16M);
	addToList( id, id, ParticleID::VectorDQY16Mbar);
	}
	}
	}
	if(model->VectorDoubletY56Enabled()) {
	for(long ix=0;ix<3;++ix) {
	long iu = 2*ix + 2;
	long id = 2*ix + 1;
	if(g2p_[ix]!=0.) {
	addToList( -iu, -iu, ParticleID::VectorDQY56P);
	addToList( iu, iu, ParticleID::VectorDQY56Pbar);
	addToList( -id, -iu, ParticleID::VectorDQY56M);
	addToList( id, iu, ParticleID::VectorDQY56Mbar);
	}
	}
	}
	Helicity::FFVVertex::doinit();
	}


	void SextetFFVVertex::setCoupling(Energy2, tcPDPtr part1,
	tcPDPtr part2,tcPDPtr part3) {
	long q1ID=(abs(part1->id())), q2ID=(abs(part2->id())),
	vDQID=(abs(part3->id()));
	//check scalar diquark
	assert( vDQID == ParticleID::VectorDQY16P \|\|
	vDQID == ParticleID::VectorDQY16M \|\|
	vDQID == ParticleID::VectorDQY56P \|\|
	vDQID == ParticleID::VectorDQY56M);
	//check quarks
	assert(!(q1ID>6) && !(q2ID>6));
	bool part1Up = (q1ID==2 \|\| q1ID==4 \|\| q1ID==6) ? true : false;
	bool part2Up = (q2ID==2 \|\| q2ID==4 \|\| q2ID==6) ? true : false;
	Complex cRight(1.,1.), cLeft(1.,1.), prefactor(1.,0.);

	if(vDQID==ParticleID::VectorDQY16P){
	//should be one up and down type
	assert((!part1Up && part2Up) \|\| (part1Up && !part2Up));
	long upType;
	if(part1Up)
	upType=q1ID;
	else
	upType=q2ID;
	if(upType==2)
	cRight=Complex(g2_[0]);
	else if(upType==4)
	cRight=Complex(g2_[1]);
	else
	cRight=Complex(g2_[2]);
	cLeft=Complex(0.);
	}
	if(vDQID==ParticleID::VectorDQY16M) {
	//should be both be down type
	assert(!part1Up && !part2Up);
	if(q1ID==1)
	cRight=Complex(g2_[0]);
	else if(q1ID==2)
	cRight=Complex(g2_[1]);
	else
	cRight=Complex(g2_[2]);
	cLeft=Complex(0.);
	}
	if(vDQID==ParticleID::VectorDQY56P) {
	//should both be up type
	assert(part1Up && part2Up);
	if(q1ID==2)
	cRight=Complex(g2p_[0]);
	else if(q1ID==4)
	cRight=Complex(g2p_[1]);
	else
	cRight=Complex(g2p_[2]);
	cLeft=Complex(0.);
	}
	if(vDQID==ParticleID::VectorDQY56M){
	//should be one up and down type
	assert((!part1Up && part2Up) \|\| (part1Up && !part2Up));
	long upType;
	if(part1Up)
	upType=q1ID;
	else
	upType=q2ID;
	if(upType==2)
	cRight=Complex(g2p_[0]);
	else if(upType==4)
	cRight=Complex(g2p_[1]);
	else
	cRight=Complex(g2p_[2]);
	cLeft=Complex(0.);
	}
	left(cLeft);
	right(cRight);
	norm(prefactor);
	}






	diff --git a/Models/Sextet/SextetGGSSVertex.cc b/Models/Sextet/SextetGGSSVertex.cc
	--- a/Models/Sextet/SextetGGSSVertex.cc
	+++ b/Models/Sextet/SextetGGSSVertex.cc
	@@ -1,81 +1,78 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the SextetGGSSVertex class.
	//

	#include "SextetGGSSVertex.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/EventRecord/Particle.h"
	#include "ThePEG/Repository/UseRandom.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "SextetModel.h"
	#include "SextetParticles.h"

	using namespace Herwig;

	SextetGGSSVertex::SextetGGSSVertex() : q2last_(), couplast_()
	{}

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

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

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeNoPIOClass<SextetGGSSVertex,VVSSVertex>
	describeSextetGGSSVertex("Herwig::SextetGGSSVertex", "HwSextetModel.so");

	void SextetGGSSVertex::Init() {

	static ClassDocumentation<SextetGGSSVertex> documentation
	("The SextetGGSSVertex class implements the coupling of two gluons to two"
	" scalar sextets");

	}

	void SextetGGSSVertex::setCoupling(Energy2 q2, tcPDPtr, tcPDPtr, tcPDPtr,
	tcPDPtr) {
	if(q2 != q2last_ \|\| couplast_ == 0.) {
	couplast_ = sqr(strongCoupling(q2));
	q2last_ = q2;
	}
	norm(couplast_);
	}

	void SextetGGSSVertex::doinit() {
	orderInGs(2);
	orderInGem(0);
	SextetModelPtr model =
	dynamic_ptr_cast<SextetModelPtr>(generator()->standardModel());
	if(!model) throw Exception() << "Must be using the SextetModel"
	<< " in SextetGSSVertex::doinit()"
	<< Exception::runerror;
	// add the enabled particles
	if(model->ScalarSingletY43Enabled())
	addToList(21,21,ParticleID::ScalarDQSingletY43,
	ParticleID::ScalarDQSingletY43bar);
	if(model->ScalarSingletY13Enabled())
	addToList(21,21,ParticleID::ScalarDQSingletY13,
	ParticleID::ScalarDQSingletY13bar);
	if(model->ScalarSingletY23Enabled())
	addToList(21,21,ParticleID::ScalarDQSingletY23,
	ParticleID::ScalarDQSingletY23bar);
	if(model->ScalarTripletY13Enabled()) {
	addToList(21,21,ParticleID::ScalarDQTripletP,
	ParticleID::ScalarDQTripletPbar);
	addToList(21,21,ParticleID::ScalarDQTriplet0,
	ParticleID::ScalarDQTriplet0bar);
	addToList(21,21,ParticleID::ScalarDQTripletM,
	ParticleID::ScalarDQTripletMbar);
	}
	VVSSVertex::doinit();
	}
	diff --git a/Models/Sextet/SextetGGVVVertex.cc b/Models/Sextet/SextetGGVVVertex.cc
	--- a/Models/Sextet/SextetGGVVVertex.cc
	+++ b/Models/Sextet/SextetGGVVVertex.cc
	@@ -1,75 +1,72 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the SextetGGVVVertex class.
	//

	#include "SextetGGVVVertex.h"
	#include "SextetModel.h"
	#include "SextetParticles.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/EventRecord/Particle.h"
	#include "ThePEG/Repository/UseRandom.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/Utilities/DescribeClass.h"

	using namespace Herwig;

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

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

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeNoPIOClass<SextetGGVVVertex,Helicity::VVVVVertex>
	describeSextetGGVVVertex("Herwig::SextetGGVVVertex", "HwSextetModel.so");

	void SextetGGVVVertex::Init() {

	static ClassDocumentation<SextetGGVVVertex> documentation
	("The SextetGGVVVertex class implements the coupling of two gluons to two vector"
	" sextet particles.");

	}

	void SextetGGVVVertex::doinit() {
	orderInGs(2);
	orderInGem(0);
	SextetModelPtr model =
	dynamic_ptr_cast<SextetModelPtr>(generator()->standardModel());
	if(!model) throw Exception() << "Must be using the SextetModel"
	<< " in SextetGGVVVertex::doinit()"
	<< Exception::runerror;
	if(model->VectorDoubletY16Enabled()) {
	addToList(21,21,ParticleID::VectorDQY16P,
	ParticleID::VectorDQY16Pbar);
	addToList(21,21,ParticleID::VectorDQY16M,
	ParticleID::VectorDQY16Mbar);

	}
	if(model->VectorDoubletY56Enabled()) {
	addToList(21,21,ParticleID::VectorDQY56P,
	ParticleID::VectorDQY56Pbar);
	addToList(21,21,ParticleID::VectorDQY56M,
	ParticleID::VectorDQY56Mbar);
	}
	VVVVVertex::doinit();
	}

	void SextetGGVVVertex::setCoupling(Energy2 q2, tcPDPtr , tcPDPtr ,
	tcPDPtr , tcPDPtr ) {
	if(q2 != q2Last_ \|\| coupLast_ == 0. ) {
	q2Last_ = q2;
	coupLast_ = sqr(strongCoupling(q2));
	}
	norm(coupLast_);
	setType(1);
	setOrder(0,1,2,3);
	}
	diff --git a/Models/Sextet/SextetModel.cc b/Models/Sextet/SextetModel.cc
	--- a/Models/Sextet/SextetModel.cc
	+++ b/Models/Sextet/SextetModel.cc
	@@ -1,237 +1,234 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the SextetModel class.
	//

	#include "SextetModel.h"
	#include "ThePEG/Utilities/StringUtils.h"
	#include "ThePEG/Interface/Reference.h"
	#include "ThePEG/Interface/Command.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/ParVector.h"
	#include "ThePEG/Interface/ClassDocumentation.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/Throw.h"

	using namespace Herwig;

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

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

	void SextetModel::persistentOutput(PersistentOStream & os) const {
	os << VVVVertex_ << VVVVVertex_ << VSSVertex_ << VVSSVertex_
	<< FFVVertex_ << FFSVertex_
	<< g1L_ << g1R_ << g1pR_ << g1ppR_ << g2_ << g2p_ << g3L_
	<< enableScalarSingletY43_ << enableScalarSingletY13_
	<< enableScalarSingletY23_ << enableScalarTripletY13_
	<< enableVectorDoubletY16_ << enableVectorDoubletY56_;
	}

	void SextetModel::persistentInput(PersistentIStream & is, int) {
	is >> VVVVertex_ >> VVVVVertex_ >> VSSVertex_ >> VVSSVertex_
	>> FFVVertex_ >> FFSVertex_
	>> g1L_ >> g1R_ >> g1pR_ >> g1ppR_ >> g2_ >> g2p_ >> g3L_
	>> enableScalarSingletY43_ >> enableScalarSingletY13_
	>> enableScalarSingletY23_ >> enableScalarTripletY13_
	>> enableVectorDoubletY16_ >> enableVectorDoubletY56_;
	}


	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeClass<SextetModel,StandardModel>
	describeSextetModel("Herwig::SextetModel", "HwSextetModel.so");

	void SextetModel::Init() {

	static ClassDocumentation<SextetModel> documentation
	("The SextetModel class provides the Model class for models with new scalars"
	" or vectors in the sextet representation of SU(3)");

	static Reference<SextetModel,ThePEG::Helicity::AbstractVVVVertex>
	interfaceVertexVDQVDQG
	("Vertex/VDQVDQG",
	"The coupling of the gluon to two vector diquarks",
	&SextetModel::VVVVertex_, false, false, true, false, false);

	static Reference<SextetModel,ThePEG::Helicity::AbstractVVVVVertex>
	interfaceVertexVDQVDQGG
	("Vertex/VDQVDQGG",
	"The coupling of two gluons to two vector diquarks",
	&SextetModel::VVVVVertex_, false, false, true, false, false);

	static Reference<SextetModel,ThePEG::Helicity::AbstractVSSVertex>
	interfaceVertexSDQSDQG
	("Vertex/SDQSDQG",
	"The coupling of the gluon to two scalar diquarks",
	&SextetModel::VSSVertex_, false, false, true, false, false);

	static Reference<SextetModel,ThePEG::Helicity::AbstractVVSSVertex>
	interfaceVertexSDQSDQGG
	("Vertex/SDQSDQGG",
	"The coupling of two gluons to two scalar diquarks",
	&SextetModel::VVSSVertex_, false, false, true, false, false);

	static Reference<SextetModel,ThePEG::Helicity::AbstractFFSVertex>
	interfaceVertexFFSDQ
	("Vertex/FFSDQ",
	"The coupling of two quarks to the scalar diquark",
	&SextetModel::FFSVertex_, false, false, true, false, false);

	static Reference<SextetModel,ThePEG::Helicity::AbstractFFVVertex>
	interfaceVertexFFVDQ
	("Vertex/FFVDQ",
	"The coupling of two quarks to the vector diquark",
	&SextetModel::FFVVertex_, false, false, true, false, false);

	static ParVector<SextetModel,double> interfaceg1L
	("g1L",
	"The \\f$SU(2)\\f$ quark-doublet coupling to \\f$\\Phi_{6,1,1/3}\\f$.",
	&SextetModel::g1L_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg1R
	("g1R",
	"The \\f$SU(2)\\f$ singlet coupling to \\f$\\Phi_{6,1,1/3}\\f$.",
	&SextetModel::g1R_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg1RPrime
	("g1RPrime",
	"The \\f$SU(2)\\f$ singlet coupling to \\f$\\Phi_{6,1,1/3}\\f$.",
	&SextetModel::g1pR_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg1RDoublePrime
	("g1RDoublePrime",
	"The \\f$SU(2)\\f$ singlet coupling to \\f$\\Phi_{6,1,1/3}\\f$.",
	&SextetModel::g1ppR_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg2
	("g2",
	"The coupling to \\f$V^\\mu_{6,2,-1/6}\\f$.",
	&SextetModel::g2_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg2Prime
	("g2Prime",
	"The coupling to \\f$V^\\mu_{6,2,5/6}\\f$.",
	&SextetModel::g2p_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static ParVector<SextetModel,double> interfaceg3L
	("g3L",
	"Coupling to \\f$\\Phi_{6,3,1/3}\\f$.",
	&SextetModel::g3L_, 3, 0.0, 0, 0,
	false, false, Interface::nolimits);

	static Command<SextetModel> interfaceEnableParticles
	("EnableParticles",
	"Enable specfic diquarks",
	&SextetModel::doEnable, false);

	}

	void SextetModel::doinit() {
	StandardModel::doinit();
	if ( !(enableScalarSingletY43_ \|\| enableScalarSingletY13_
	\|\| enableScalarSingletY23_ \|\| enableScalarTripletY13_
	\|\| enableVectorDoubletY16_ \|\| enableVectorDoubletY56_ )) {
	Throw<Exception>() << "You have not enabled any Sextet diquarks. Use e.g.\n"
	<< " do Model:EnableParticles Scalar Triplet Y=1/3\n"
	<< "to specify the spin, weak isospin and weak hypercharge."
	<< Exception::runerror;
	}
	addVertex(VVVVertex_);
	addVertex(VVVVVertex_);
	addVertex(VSSVertex_);
	addVertex(VVSSVertex_);
	addVertex(FFVVertex_);
	addVertex(FFSVertex_);
	}

	string SextetModel::doEnable(string args) {
	int spin=-1;
	int weak=-1;
	int Y[2]={-1000000,-1000000};
	string orig=args;
	while ( !args.empty() ) {
	string arg = StringUtils::car(args);
	args = StringUtils::cdr(args);
	if ( arg == "Scalar" ) spin=1;
	else if ( arg == "Vector" ) spin=3;
	else if ( arg == "Singlet" ) weak=1;
	else if ( arg == "Doublet" ) weak=2;
	else if ( arg == "Triplet" ) weak=3;
	else {
	if(arg.find("Y=")==string::npos) continue;
	arg = StringUtils::cdr(arg,"=");
	vector<string> split = StringUtils::split(arg,"/");
	if(split.size()!=2) continue;
	istringstream is1(split[0]);
	is1 >> Y[0];
	istringstream is2(split[1]);
	is2 >> Y[1];
	}
	}
	// check we read a value for all three quantum numbers
	if ( spin <0 \|\| weak<0 \|\| 0 \|\| Y[0]== -1000000) {
	return string("SextetModel:EnableParticles couldn't termine spin, weak") +
	string(" isospin or hypercharge for ") + orig + ".";
	}
	// check the values of Y
	if(!(Y[1]==3\|\|Y[1]==6)) {
	return string("SextetModel:EnableParticles invalid weak") +
	string(" hypercharge for ") + orig + ".";
	}
	// the various allowed combinations
	bool found = false;
	if(spin == 1 ) {
	found = true;
	if ( weak == 1 && Y[0] == 4 && Y[1] == 3) {
	enableScalarSingletY43_ = true;
	}
	else if( weak == 1 && Y[0] == 1 && Y[1] == 3) {
	enableScalarSingletY13_ = true;
	}
	else if( weak == 1 && Y[0] == -2 && Y[1] == 3) {
	enableScalarSingletY23_ = true;
	}
	else if( weak == 3 && Y[0] == 1 && Y[1] == 3) {
	enableScalarTripletY13_ = true;
	}
	else
	found = false;
	}
	else if(spin == 3 && weak == 2) {
	found = true;
	if ( Y[0] == -1 && Y[1] == 6) {
	enableVectorDoubletY16_ = true;
	}
	else if( Y[0] == 5 && Y[1] == 6) {
	enableVectorDoubletY56_ = true;
	}
	else
	found = false;
	}
	if(!found)
	return string("SextetModel:EnableParticles invalid combination") +
	string(" of spin, weak isospin or hypercharge for ") + orig + ".";
	else
	return "";
	}
	diff --git a/Models/StandardModel/GenericSVVVertex.cc b/Models/StandardModel/GenericSVVVertex.cc
	--- a/Models/StandardModel/GenericSVVVertex.cc
	+++ b/Models/StandardModel/GenericSVVVertex.cc
	@@ -1,102 +1,100 @@
	// -- C++ --
	//
	// GenericSVVVertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 GenericSVVVertex class.
	//

	#include "GenericSVVVertex.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/Command.h"

	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"

	using namespace Herwig;
	using namespace ThePEG;

	GenericSVVVertex::GenericSVVVertex()
	- :pids(ZERO),oas(0),oaew(0){
	- orderInGs(0);
	- orderInGem(0);
	-}
	+ :pids(ZERO),oas(0),oaew(0)
	+{}

	void GenericSVVVertex::doinit() {
	//PDG codes for particles at vertices
	addToList(pids[0],pids[1],pids[2]);
	orderInGs(oas);
	orderInGem(oaew);
	GeneralVVSVertex::doinit();
	}



	string GenericSVVVertex::dopids(string in) {
	vector<string> process = StringUtils::split(in);
	if ( process.size() != 3 )
	throw InitException() << "accepts only three particles.";

	for ( vector<string>::iterator p = process.begin();
	p != process.end(); ++p ) {
	int tmp;
	istringstream(*p) >> tmp;
	pids.push_back(tmp);
	}
	return "";
	}





	void GenericSVVVertex::persistentOutput(PersistentOStream & os) const {
	os << pids<<oas<<oaew;
	}

	void GenericSVVVertex::persistentInput(PersistentIStream & is, int) {
	is >> pids>>oas>>oaew;
	}

	// The following static variable is needed for the type
	// description system in ThePEG.
	DescribeClass<GenericSVVVertex,Helicity::GeneralVVSVertex>
	describeHerwigGenericSVVVertex("Herwig::GenericSVVVertex", "Herwig.so");

	void GenericSVVVertex::Init() {

	static ClassDocumentation<GenericSVVVertex> documentation
	("This class implements the s->v,v vertex");

	static Command<GenericSVVVertex> interfacepids
	("pids",
	"Set the pids.",
	&GenericSVVVertex::dopids, false);

	static Parameter<GenericSVVVertex, int> interfaceOrderoas
	("OrderInAlphaS",
	"The order in alpha_S",
	&GenericSVVVertex::oas, 2, 0, 0,
	false, false, Interface::lowerlim);

	static Parameter<GenericSVVVertex, int> interfaceOrderoaew
	("OrderInAlphaEW",
	"The order in alpha_EW",
	&GenericSVVVertex::oaew, 2, 0, 0,
	false, false, Interface::lowerlim);
	}

	void GenericSVVVertex::setCoupling(Energy2, tcPDPtr part2, tcPDPtr part3, tcPDPtr part1) {
	assert(part1 && part2 && part3);
	assert(part1->id() == pids[0] &&
	part2->id() == pids[1] && part3->id() == pids[2] );
	}

	diff --git a/Models/StandardModel/GenericVVVVertex.cc b/Models/StandardModel/GenericVVVVertex.cc
	--- a/Models/StandardModel/GenericVVVVertex.cc
	+++ b/Models/StandardModel/GenericVVVVertex.cc
	@@ -1,102 +1,100 @@
	// -- C++ --
	//
	// GenericVVVVertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 GenericVVVVertex class.
	//

	#include "GenericVVVVertex.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/Command.h"

	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"

	using namespace Herwig;
	using namespace ThePEG;

	GenericVVVVertex::GenericVVVVertex()
	- :pids(ZERO),oas(0),oaew(0){
	- orderInGs(0);
	- orderInGem(0);
	-}
	+ :pids(ZERO),oas(0),oaew(0)
	+{}

	void GenericVVVVertex::doinit() {
	//PDG codes for particles at vertices
	addToList(pids[0],pids[1],pids[2]);
	orderInGs(oas);
	orderInGem(oaew);
	VVVVertex::doinit();
	}



	string GenericVVVVertex::dopids(string in) {
	vector<string> process = StringUtils::split(in);
	if ( process.size() != 3 )
	throw InitException() << "accepts only three particles.";

	for ( vector<string>::iterator p = process.begin();
	p != process.end(); ++p ) {
	int tmp;
	istringstream(*p) >> tmp;
	pids.push_back(tmp);
	}
	return "";
	}





	void GenericVVVVertex::persistentOutput(PersistentOStream & os) const {
	os << pids<<oas<<oaew;
	}

	void GenericVVVVertex::persistentInput(PersistentIStream & is, int) {
	is >> pids>>oas>>oaew;
	}

	// The following static variable is needed for the type
	// description system in ThePEG.
	DescribeClass<GenericVVVVertex,Helicity::VVVVertex>
	describeHerwigGenericVVVVertex("Herwig::GenericVVVVertex", "Herwig.so");

	void GenericVVVVertex::Init() {

	static ClassDocumentation<GenericVVVVertex> documentation
	("This class implements the v->v,v vertex");

	static Command<GenericVVVVertex> interfacepids
	("pids",
	"Set the pids.",
	&GenericVVVVertex::dopids, false);

	static Parameter<GenericVVVVertex, int> interfaceOrderoas
	("OrderInAlphaS",
	"The order in alpha_S",
	&GenericVVVVertex::oas, 2, 0, 0,
	false, false, Interface::lowerlim);

	static Parameter<GenericVVVVertex, int> interfaceOrderoaew
	("OrderInAlphaEW",
	"The order in alpha_EW",
	&GenericVVVVertex::oaew, 2, 0, 0,
	false, false, Interface::lowerlim);
	}

	void GenericVVVVertex::setCoupling(Energy2, tcPDPtr part2, tcPDPtr part3, tcPDPtr part1) {
	assert(part1 && part2 && part3);
	assert(part1->id() == pids[0] &&
	part2->id() == pids[1] && part3->id() == pids[2] );
	}

	diff --git a/Models/Susy/MixingMatrix.cc b/Models/Susy/MixingMatrix.cc
	--- a/Models/Susy/MixingMatrix.cc
	+++ b/Models/Susy/MixingMatrix.cc
	@@ -1,62 +1,59 @@
	// -- C++ --
	//
	// MixingMatrix.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 MixingMatrix class.
	//

	#include "MixingMatrix.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"

	using namespace Herwig;

	void MixingMatrix::persistentOutput(PersistentOStream & os) const {
	os << mixingMatrix_ << ids_ << size_;
	}

	void MixingMatrix::persistentInput(PersistentIStream & is, int) {
	is >> mixingMatrix_ >> ids_ >> size_;
	}

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeClass<MixingMatrix,Interfaced>
	describeMixingMatrix("Herwig::MixingMatrix", "HwSusy.so");

	void MixingMatrix::Init() {

	static ClassDocumentation<MixingMatrix> documentation
	("The MixingMatrix class implements the storage of the SUSY mixing "
	"matrices.");

	}

	void MixingMatrix::adjustPhase(long id) {
	unsigned int irow(0);
	while(irow < size().first && ids_[irow] != id)
	++irow;
	for(unsigned int c = 0; c < size_.second; ++c)
	mixingMatrix_[irow][c] *= Complex(0., 1.);
	}

	ostream & Herwig::operator<<(ostream & os,const MixingMatrix & mix) {
	for(unsigned int ix=0;ix<mix.size().first;++ix) {
	for(unsigned int iy=0;iy<mix.size().second;++iy) {
	os << mix(ix,iy) << "\t";
	}
	os << "\n";
	}
	return os;
	}
	diff --git a/Models/Susy/SSCNWVertex.cc b/Models/Susy/SSCNWVertex.cc
	--- a/Models/Susy/SSCNWVertex.cc
	+++ b/Models/Susy/SSCNWVertex.cc
	@@ -1,134 +1,131 @@
	// -- C++ --
	//
	// SSCNWVertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 SSCNWVertex class.
	//

	#include "SSCNWVertex.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "ThePEG/PDT/EnumParticles.h"

	using namespace ThePEG::Helicity;
	using namespace Herwig;

	SSCNWVertex::SSCNWVertex() : _sw(0.), _couplast(0.), _q2last(ZERO),
	_id1last(0), _id2last(0), _leftlast(0.),
	_rightlast(0.) {
	orderInGs(0);
	orderInGem(1);
	}

	void SSCNWVertex::doinit() {
	long neu[] = { 1000022, 1000023, 1000025, 1000035, 1000045 };
	long cha[] = { 1000024, 1000037 };
	// sign == -1 outgoing W-, sign == +1 outgoing W+
	for(int sign = -1; sign < 2; sign += 2)
	for(unsigned int ine = 0; ine < 5; ++ine)
	for(unsigned int ic = 0; ic < 2; ++ic)
	addToList(-signcha[ic], neu[ine], sign24);
	FFVVertex::doinit();
	tSusyBasePtr theSS = dynamic_ptr_cast<SusyBasePtr>(generator()->standardModel());
	if(!theSS)
	throw InitException() << "SSCNWVertex::doinit() - The model pointer is null!"
	<< Exception::abortnow;
	_sw = sqrt(sin2ThetaW());

	_theN = theSS->neutralinoMix();
	_theU = theSS->charginoUMix();
	_theV = theSS->charginoVMix();

	if(!_theN \|\| !_theU \|\| ! _theV)
	throw InitException() << "SSCNWVertex::doinit() - "
	<< "A mixing matrix pointer is null."
	<< " N: " << _theN << " U: " << _theU << " V: "
	<< _theV << Exception::abortnow;
	}

	void SSCNWVertex::persistentOutput(PersistentOStream & os) const {
	os << _sw << _theN << _theU << _theV;
	}

	void SSCNWVertex::persistentInput(PersistentIStream & is, int) {
	is >> _sw >> _theN >> _theU >> _theV;
	}

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeClass<SSCNWVertex,Helicity::FFVVertex>
	describeSSCNWVertex("Herwig::SSCNWVertex", "HwSusy.so");

	void SSCNWVertex::Init() {

	static ClassDocumentation<SSCNWVertex> documentation
	("This class implements the coupling of a W boson to a "
	"neutralino and a chargino");

	}

	void SSCNWVertex::setCoupling(Energy2 q2, tcPDPtr part1, tcPDPtr part2,
	#ifndef NDEBUG
	tcPDPtr part3) {
	#else
	tcPDPtr) {
	#endif
	assert(abs(part3->id()) == ParticleID::Wplus);
	long neu, cha;
	if(part1->charged()) {
	cha = part1->id();
	neu = part2->id();
	}
	else {
	cha = part2->id();
	neu = part1->id();
	}
	assert((abs(cha) == 1000024 \|\| abs(cha) == 1000037) &&
	(neu == 1000022 \|\| neu == 1000023 \|\|
	neu == 1000025 \|\| neu == 1000035 \|\|
	neu == 1000045) );
	if(q2 != _q2last\|\|_couplast==0.) {
	_q2last = q2;
	_couplast = weakCoupling(q2);
	}
	norm(_couplast);
	if(cha != _id1last \|\| neu != _id2last) {
	_id1last = cha;
	_id2last = neu;
	unsigned int eigc = abs(cha) == 1000037 ? 1 : 0;
	unsigned int eign(0);
	if (neu == 1000023) eign = 1;
	else if(neu == 1000025) eign = 2;
	else if(neu == 1000035) eign = 3;
	else if(neu == 1000045) eign = 4;
	_leftlast = (_theN)(eign, 1)conj((*_theV)(eigc, 0)) -
	( (_theN)(eign, 3)conj((*_theV)(eigc, 1))/sqrt(2));
	_rightlast = conj((_theN)(eign, 1))(*_theU)(eigc, 0) +
	( conj((_theN)(eign, 2))(*_theU)(eigc, 1)/sqrt(2));
	}
	Complex ltemp = _leftlast;
	Complex rtemp = _rightlast;
	// conjugate if +ve chargino
	if(cha>0) {
	ltemp = conj(ltemp);
	rtemp = conj(rtemp);
	}
	if((part1->id()==cha&&cha>0)\|\|(part2->id()==cha&&cha<0)) {
	Complex temp = ltemp;
	ltemp = -rtemp;
	rtemp = -temp;
	}
	left (ltemp);
	right(rtemp);
	}
	diff --git a/Models/Susy/SSNNZVertex.cc b/Models/Susy/SSNNZVertex.cc
	--- a/Models/Susy/SSNNZVertex.cc
	+++ b/Models/Susy/SSNNZVertex.cc
	@@ -1,128 +1,125 @@
	// -- C++ --
	//
	// SSNNZVertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 SSNNZVertex class.
	//

	#include "SSNNZVertex.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "MixingMatrix.h"
	#include "ThePEG/PDT/EnumParticles.h"

	using namespace ThePEG::Helicity;
	using namespace Herwig;

	SSNNZVertex::SSNNZVertex() : _sw(0.), _cw(0.), _id1last(0),
	_id2last(0), _q2last(), _couplast(0.),
	_leftlast(0.), _rightlast(0.) {
	orderInGem(1);
	orderInGs(0);
	}

	void SSNNZVertex::doinit() {
	long neu[] = { 1000022, 1000023, 1000025, 1000035, 1000045 };
	for(unsigned int i = 0; i < 5; ++i)
	for(unsigned int j = 0; j < 5; ++j)
	addToList(neu[i], neu[j], 23);
	FFVVertex::doinit();
	tSusyBasePtr theSS = dynamic_ptr_cast<SusyBasePtr>(generator()->standardModel());
	if(!theSS)
	throw InitException() << "SSNNZVertex::doinit() - "
	<< "The model pointer is null."
	<< Exception::abortnow;

	_theN = theSS->neutralinoMix();
	if(!_theN)
	throw InitException() << "SSNNZVertex::doinit - The neutralino "
	<< "mixing matrix pointer is null."
	<< Exception::abortnow;
	_sw = sqrt(sin2ThetaW());
	_cw = sqrt(1 - _sw*_sw);
	}

	void SSNNZVertex::persistentOutput(PersistentOStream & os) const {
	os << _sw << _cw << _theN;
	}

	void SSNNZVertex::persistentInput(PersistentIStream & is, int) {
	is >> _sw >> _cw >> _theN;
	_id1last = 0;
	_id2last = 0;
	_q2last = ZERO;
	_couplast = 0.;
	_leftlast = 0.;
	_rightlast = 0.;
	}

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeClass<SSNNZVertex,Helicity::FFVVertex>
	describeSSNNZVertex("Herwig::SSNNZVertex", "HwSusy.so");

	void SSNNZVertex::Init() {

	static ClassDocumentation<SSNNZVertex> documentation
	("The coupling of a Z-boson to a pair of neutralinos");

	}

	void SSNNZVertex::setCoupling(Energy2 q2,tcPDPtr part1,
	#ifndef NDEBUG
	tcPDPtr part2,tcPDPtr part3) {
	#else
	tcPDPtr part2,tcPDPtr) {
	#endif
	assert(part3->id() == ParticleID::Z0);
	long ic1 = part2->id();
	long ic2 = part1->id();
	assert(ic1 == ParticleID::SUSY_chi_10 \|\| ic1 == ParticleID::SUSY_chi_20 \|\|
	ic1 == ParticleID::SUSY_chi_30 \|\| ic1 == ParticleID::SUSY_chi_40 \|\|
	ic1 == 1000045);
	assert(ic2 == ParticleID::SUSY_chi_10 \|\| ic2 == ParticleID::SUSY_chi_20 \|\|
	ic2 == ParticleID::SUSY_chi_30 \|\| ic2 == ParticleID::SUSY_chi_40 \|\|
	ic2 == 1000045);
	if(q2 != _q2last \|\| _couplast==0.) {
	_q2last = q2;
	_couplast = weakCoupling(q2)/_cw;
	}
	if(ic1 != _id1last \|\| ic2 != _id2last) {
	_id1last = ic1;
	_id2last = ic2;
	unsigned int neu1(ic1 - 1000022), neu2(ic2 - 1000022);
	if(neu1 > 1) {
	if(ic1 == 1000025)
	neu1 = 2;
	else if(ic1 == 1000035)
	neu1 = 3;
	else
	neu1 = 4;
	}
	if(neu2 > 1) {
	if(ic2 == 1000025)
	neu2 = 2;
	else if(ic2 == 1000035)
	neu2 = 3;
	else
	neu2 = 4;
	}
	_leftlast = 0.5( (_theN)(neu1, 3)conj((_theN)(neu2, 3)) -
	(_theN)(neu1, 2)conj((*_theN)(neu2, 2)) );
	_rightlast = -conj(_leftlast);
	}
	norm(_couplast);
	left(_leftlast);
	right(_rightlast);
	}
	diff --git a/Models/UED/UEDG0G0G1G1Vertex.cc b/Models/UED/UEDG0G0G1G1Vertex.cc
	--- a/Models/UED/UEDG0G0G1G1Vertex.cc
	+++ b/Models/UED/UEDG0G0G1G1Vertex.cc
	@@ -1,68 +1,65 @@
	// -- C++ --
	//
	// UEDG0G0G1G1Vertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 UEDG0G0G1G1Vertex class.
	//

	#include "UEDG0G0G1G1Vertex.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/PDT/EnumParticles.h"
	#include "UEDBase.h"

	using namespace Herwig;

	UEDG0G0G1G1Vertex::UEDG0G0G1G1Vertex() :
	theq2Last(ZERO), theCoupLast(0.) {
	orderInGs(2);
	orderInGem(0);
	}

	void UEDG0G0G1G1Vertex::doinit() {
	long kk1g = 5100021, smgl = 21;
	addToList(smgl, smgl, kk1g, kk1g);
	VVVVVertex::doinit();
	}

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeNoPIOClass<UEDG0G0G1G1Vertex,Helicity::VVVVVertex>
	describeUEDG0G0G1G1Vertex("Herwig::UEDG0G0G1G1Vertex", "HwUED.so");

	void UEDG0G0G1G1Vertex::Init() {

	static ClassDocumentation<UEDG0G0G1G1Vertex> documentation
	("This class implements the coupling of a pair of SM gluons to"
	"a pair of UED level-1 KK gluons.");

	}

	void UEDG0G0G1G1Vertex::setCoupling(Energy2 q2, tcPDPtr part1, tcPDPtr part2,
	tcPDPtr part3, tcPDPtr part4) {
	int ismg(0), ikkg(0);
	vector<tcPDPtr> particles(4);
	particles[0] = part1; particles[1] = part2;
	particles[2] = part3; particles[3] = part4;
	for(vector<long>::size_type i = 0; i < 4; ++i) {
	if(particles[i]->id() == ParticleID::g) ++ismg;
	if(particles[i]->id() == 5100021) ++ikkg;
	}
	assert(ismg == 2 && ikkg == 2);
	if(q2 != theq2Last \|\| theCoupLast == 0. ) {
	theq2Last = q2;
	theCoupLast = sqr(strongCoupling(q2));
	}
	norm(theCoupLast);
	setType(1);
	setOrder(0,1,2,3);
	}
	diff --git a/Models/UED/UEDG1G1G0Vertex.cc b/Models/UED/UEDG1G1G0Vertex.cc
	--- a/Models/UED/UEDG1G1G0Vertex.cc
	+++ b/Models/UED/UEDG1G1G0Vertex.cc
	@@ -1,68 +1,65 @@
	// -- C++ --
	//
	// UEDG1G1G0Vertex.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
	// Copyright (C) 2002-2017 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 UEDG1G1G0Vertex class.
	//

	#include "UEDG1G1G0Vertex.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "ThePEG/PDT/EnumParticles.h"

	using namespace ThePEG::Helicity;
	using namespace Herwig;

	UEDG1G1G0Vertex::UEDG1G1G0Vertex()
	: theq2Last(ZERO), theCoupLast(0.) {
	orderInGs(1);
	orderInGem(0);
	}

	void UEDG1G1G0Vertex::doinit() {
	long kkg1 = 5100021;
	addToList(kkg1, kkg1, 21);
	VVVVertex::doinit();
	}

	-// * Attention * The following static variable is needed for the type
	-// description system in ThePEG. Please check that the template arguments
	-// are correct (the class and its base class), and that the constructor
	-// arguments are correct (the class name and the name of the dynamically
	-// loadable library where the class implementation can be found).
	+// The following static variable is needed for the type
	+// description system in ThePEG.
	DescribeNoPIOClass<UEDG1G1G0Vertex,Helicity::VVVVertex>
	describeUEDG1G1G0Vertex("Herwig::UEDG1G1G0Vertex", "HwUED.so");

	void UEDG1G1G0Vertex::Init() {

	static ClassDocumentation<UEDG1G1G0Vertex> documentation
	("The UEDG1G1G0Vertex class implements the coupling of the "
	"gluon to two KK excitations of the gluon in the UED model.");

	}

	void UEDG1G1G0Vertex::setCoupling(Energy2 q2, tcPDPtr part1, tcPDPtr part2,
	tcPDPtr part3) {
	long id1(part1->id()), id2(part2->id()), id3(part3->id());
	if( (id1 == ParticleID::g && id2 == 5100021 && id3 == 5100021) \|\|
	(id2 == ParticleID::g && id1 == 5100021 && id3 == 5100021) \|\|
	(id3 == ParticleID::g && id1 == 5100021 && id2 == 5100021) ) {
	if(q2 != theq2Last \|\| theCoupLast == 0.) {
	theq2Last = q2;
	theCoupLast = strongCoupling(q2);
	}
	norm(theCoupLast);
	}
	else throw HelicityLogicalError()
	<< "UEDG1G1G0Vertex::setCoupling - "
	<< "There is an unknown particle in this vertex "
	<< id1 << " " << id2 << " " << id3 << Exception::runerror;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Dec 21, 6:09 PM (7 h, 10 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4023742
Default Alt Text: (41 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions