Page MenuHomeHEPForge
Files F10664195

No OneTemporary
Actions

View Options

diff --git a/Models/ADD/ADDModel.cc b/Models/ADD/ADDModel.cc
--- a/Models/ADD/ADDModel.cc
+++ b/Models/ADD/ADDModel.cc
@@ -1,120 +1,120 @@
// -*- C++ -*-
//
// ADDModel.cc is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the ADDModel class.
//
#include "ADDModel.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
using namespace Herwig;
using namespace ThePEG;
using namespace ThePEG::Helicity;
void ADDModel::doinit() {
addVertex(FFGRVertex_);
addVertex(VVGRVertex_);
addVertex(SSGRVertex_);
addVertex(FFGGRVertex_);
addVertex(FFWGRVertex_);
addVertex(GGGGRVertex_);
addVertex(WWWGRVertex_);
- StandardModel::doinit();
+ BSMModel::doinit();
}
void ADDModel::persistentOutput(PersistentOStream & os) const {
os << ounit(mPlanckBar_,GeV) << ounit(md_,GeV) << delta_
<< ounit(lambdaT_,GeV)
<< FFGRVertex_ << VVGRVertex_ << SSGRVertex_
<< FFGGRVertex_ << FFWGRVertex_
<< GGGGRVertex_ << WWWGRVertex_;
}
void ADDModel::persistentInput(PersistentIStream & is, int) {
is >> iunit(mPlanckBar_,GeV) >> iunit(md_,GeV) >> delta_
>> iunit(lambdaT_,GeV)
>> FFGRVertex_ >> VVGRVertex_ >> SSGRVertex_
>> FFGGRVertex_ >> FFWGRVertex_
>> GGGGRVertex_ >> WWWGRVertex_;
}
ClassDescription<ADDModel> ADDModel::initADDModel;
// Definition of the static class description member.
void ADDModel::Init() {
static Reference<ADDModel,ThePEG::Helicity::AbstractFFTVertex> interfaceVertexFFGR
("Vertex/FFGR",
"Reference to the fermion-fermion-graviton vertex",
&ADDModel::FFGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractVVTVertex> interfaceVertexVVGR
("Vertex/VVGR",
"Reference to the vector-vector-graviton vertex",
&ADDModel::VVGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractSSTVertex> interfaceVertexSSGR
("Vertex/SSGR",
"Reference to the scalar-scalar-graviton vertex",
&ADDModel::SSGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractFFVTVertex> interfaceVertexFFGGR
("Vertex/FFGGR",
"Reference to the fermion-antifermion-gluon graviton vertex",
&ADDModel::FFGGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractFFVTVertex> interfaceVertexFFWGR
("Vertex/FFWGR",
"Reference to the fermion-antifermion-weak vector boson graviton vertex",
&ADDModel::FFWGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractVVVTVertex> interfaceVertexGGGGR
("Vertex/GGGGR",
"Reference to the three gluon graviton vertex",
&ADDModel::GGGGRVertex_, false, false, true, false, false);
static Reference<ADDModel,ThePEG::Helicity::AbstractVVVTVertex> interfaceVertexWWWGR
("Vertex/WWWGR",
"Reference to the three weak vector boson graviton vertex",
&ADDModel::WWWGRVertex_, false, false, true, false, false);
static ClassDocumentation<ADDModel> documentation
("The ADDModel class replaces the Standard Model class for the"
" ADD model");
static Parameter<ADDModel,unsigned int> interfaceDelta
("Delta",
"Number of extra dimensions",
&ADDModel::delta_, 2, 2, 1000,
false, false, Interface::limited);
static Parameter<ADDModel,Energy> interfaceReducedPlanckMass
("Reduced4dPlanckMass",
"The reduced planck mass in 4 dimensions",
&ADDModel::mPlanckBar_, GeV, 2.4e18*GeV, 1e17*GeV, 1e20*GeV,
false, false, Interface::limited);
static Parameter<ADDModel,Energy> interfaceDdPlanckMass
("DdPlanckMass",
"The d dimension planck mass",
&ADDModel::md_, GeV, 1000.*GeV, 100.0*GeV, 1e6*GeV,
false, false, Interface::limited);
static Parameter<ADDModel,Energy> interfaceLambdaT
("LambdaT",
"The cut-off for virtual graviton processes",
&ADDModel::lambdaT_, GeV, 1000.*GeV, 100.*GeV, 100000.0*GeV,
false, false, Interface::limited);
}
diff --git a/Models/ADD/ADDModel.h b/Models/ADD/ADDModel.h
--- a/Models/ADD/ADDModel.h
+++ b/Models/ADD/ADDModel.h
@@ -1,267 +1,267 @@
// -*- C++ -*-
//
// ADDModel.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_ADDModel_H
#define HERWIG_ADDModel_H
// This is the declaration of the ADDModel class.
-#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "Herwig++/Models/General/BSMModel.h"
#include "ThePEG/Helicity/Vertex/AbstractFFTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVTVertex.h"
#include "ADDModel.fh"
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
/** \ingroup Models
*
* This is the class to be used instead of the Standard Model class for
* the Randell Sundrum model.
*
* @see \ref ADDModelInterfaces "The interfaces"
* defined for ADDModel.
* @see StandardModel
* @see StandardModelBase
*
*/
-class ADDModel: public StandardModel {
+class ADDModel: public BSMModel {
public:
/**
* The default constructor
*/
ADDModel() : delta_(2), mPlanckBar_(2.4e18*GeV),
md_(1000.*GeV), lambdaT_(1000.*GeV) {
useMe();
}
/**
* Number of extrac dimensions
*/
unsigned int delta() const {return delta_;}
/**
* The reduced Planck mass in 4d
*/
Energy MPlanckBar() const {return mPlanckBar_;}
/**
* The d-dimension Planck mass
*/
Energy MD() const {return md_;}
/**
* The cut-off for virtual gravition processes
*/
Energy LambdaT() const {return lambdaT_;}
/** @name Vertices */
//@{
/**
* Pointer to the object handling the \f$G\to f\bar{f}\f$ vertex.
*/
tAbstractFFTVertexPtr vertexFFGR() const {return FFGRVertex_;}
/**
* Pointer to the object handling the \f$G\to VV\f$ vertex.
*/
tAbstractVVTVertexPtr vertexVVGR() const {return VVGRVertex_;}
/**
* Pointer to the object handling the \f$G\to SS\f$ vertex.
*/
tAbstractSSTVertexPtr vertexSSGR() const {return SSGRVertex_;}
/**
* Pointer to the object handling the \f$G\to f\bar{f}g\f$ vertex.
*/
tAbstractFFVTVertexPtr vertexFFGGR() const {return FFGGRVertex_;}
/**
* Pointer to the object handling the \f$G\to f\bar{f}W^\pm/Z^0/\gamma\f$ vertex.
*/
tAbstractFFVTVertexPtr vertexFFWGR() const {return FFWGRVertex_;}
/**
* Pointer to the object handling the \f$G\to W^+W^-Z^0/\gamma\f$ vertex.
*/
tAbstractVVVTVertexPtr vertexWWWGR() const {return WWWGRVertex_;}
/**
* Pointer to the object handling the \f$G\to ggg\f$ vertex.
*/
tAbstractVVVTVertexPtr vertexGGGGR() const {return GGGGRVertex_;}
//@}
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 Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
//@}
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const {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:
/**
* Describe a concrete class with persistent data.
*/
static ClassDescription<ADDModel> initADDModel;
/**
* Private and non-existent assignment operator.
*/
ADDModel & operator=(const ADDModel &);
private:
/**
* Number of extrac dimensions
*/
unsigned int delta_;
/**
* The reduced Planck mass in 4d
*/
Energy mPlanckBar_;
/**
* The d-dimension Planck mass
*/
Energy md_;
/**
* Cut-off parameter for virtual gravitons
*/
Energy lambdaT_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}\f$ vertex.
*/
AbstractFFTVertexPtr FFGRVertex_;
/**
* Pointer to the object handling the \f$G\to VV\f$ vertex.
*/
AbstractVVTVertexPtr VVGRVertex_;
/**
* Pointer to the object handling the \f$G\to SS\f$ vertex.
*/
AbstractSSTVertexPtr SSGRVertex_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}g\f$ vertex.
*/
AbstractFFVTVertexPtr FFGGRVertex_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}W/Z^0\gamma\f$ vertex.
*/
AbstractFFVTVertexPtr FFWGRVertex_;
/**
* Pointer to the object handling the \f$G\to W^+W^-Z^0\gamma\f$ vertex.
*/
AbstractVVVTVertexPtr WWWGRVertex_;
/**
* Pointer to the object handling the \f$G\to ggg\f$ vertex.
*/
AbstractVVVTVertexPtr GGGGRVertex_;
};
}
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/**
* The following template specialization informs ThePEG about the
* base class of ADDModel.
*/
template <>
struct BaseClassTrait<Herwig::ADDModel,1> {
/** Typedef of the base class of ADDModel. */
- typedef Herwig::StandardModel NthBase;
+ typedef Herwig::BSMModel NthBase;
};
/**
* The following template specialization informs ThePEG about the
* name of this class and the shared object where it is defined.
*/
template <>
struct ClassTraits<Herwig::ADDModel>
: public ClassTraitsBase<Herwig::ADDModel> {
/** Return the class name.*/
static string className() { return "Herwig::ADDModel"; }
/**
* Return the name of the shared library to be loaded to get
* access to this class and every other class it uses
* (except the base class).
*/
static string library() { return "HwADDModel.so"; }
};
/** @endcond */
}
#endif /* HERWIG_ADDModel_H */
diff --git a/Models/General/BSMModel.cc b/Models/General/BSMModel.cc
new file mode 100644
--- /dev/null
+++ b/Models/General/BSMModel.cc
@@ -0,0 +1,341 @@
+// -*- C++ -*-
+//
+// This is the implementation of the non-inlined, non-templated member
+// functions of the BSMModel class.
+//
+
+#include "BSMModel.h"
+#include "ThePEG/Interface/ClassDocumentation.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/Repository/Repository.h"
+#include "ThePEG/Utilities/StringUtils.h"
+#include "ThePEG/Persistency/PersistentOStream.h"
+#include "ThePEG/Persistency/PersistentIStream.h"
+#include "ThePEG/PDT/MassGenerator.h"
+#include "ThePEG/PDT/WidthGenerator.h"
+#include "ThePEG/PDT/DecayMode.h"
+
+using namespace Herwig;
+
+BSMModel::BSMModel() : decayFile_(), topModesFromFile_(false),
+ tolerance_(1e-6)
+{}
+
+void BSMModel::persistentOutput(PersistentOStream & os) const {
+ os << decayFile_ << topModesFromFile_ << tolerance_ ;
+}
+
+void BSMModel::persistentInput(PersistentIStream & is, int) {
+ is >> decayFile_ >> topModesFromFile_ >> tolerance_ ;
+}
+
+// *** 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).
+DescribeAbstractClass<BSMModel,Herwig::StandardModel>
+ describeHerwigBSMModel("Herwig::BSMModel", "BSMModel.so");
+
+void BSMModel::Init() {
+
+ static ClassDocumentation<BSMModel> documentation
+ ("The BSMModel class provides a base class for BSM models including the"
+ " features to read decays in the SLHA format");
+
+ static Parameter<BSMModel,string> interfaceDecayFileName
+ ("DecayFileName",
+ "Name of the file from which to read decays in the SLHA format",
+ &BSMModel::decayFile_, "",
+ false, false);
+
+ static Switch<BSMModel,bool> interfaceTopModes
+ ("TopModes",
+ "Whether ro use the Herwig++ SM top decays or those from the SLHA file",
+ &BSMModel::topModesFromFile_, false, false, false);
+ static SwitchOption interfaceTopModesFile
+ (interfaceTopModes,
+ "File",
+ "Take the modes from the files",
+ true);
+ static SwitchOption interfaceTopModesHerwig
+ (interfaceTopModes,
+ "Herwig",
+ "Use the SM ones", false);
+
+ static Parameter<BSMModel,double> interfaceBRTolerance
+ ("BRTolerance",
+ "Tolerance for the sum of branching ratios to be difference from one.",
+ &BSMModel::tolerance_, 1e-6, 1e-8, 0.01,
+ false, false, Interface::limited);
+
+}
+
+void BSMModel::doinit() {
+ StandardModel::doinit();
+ // check if need to read decays
+ if(decayFile()=="") return;
+ // read decays
+ CFileLineReader cfile;
+ cfile.open(decayFile_);
+ if( !cfile ) throw SetupException()
+ << "BSMModel::doinit - An error occurred in opening the "
+ << "decay file \"" << decayFile_ << "\"."
+ << Exception::runerror;
+ //Before reading the spectrum/decay files the SM higgs
+ //decay modes, mass and width generators need to be turned off.
+ PDPtr h0 = getParticleData(ParticleID::h0);
+ h0->widthGenerator(WidthGeneratorPtr());
+ h0->massGenerator(MassGenPtr());
+ h0->width(ZERO);
+ DecaySet::const_iterator dit = h0->decayModes().begin();
+ DecaySet::const_iterator dend = h0->decayModes().end();
+ for( ; dit != dend; ++dit ) {
+ generator()->preinitInterface(*dit, "BranchingRatio", "set", "0.");
+ generator()->preinitInterface(*dit, "OnOff", "set", "Off");
+ }
+ // if taking the top modes from the file
+ // delete the SM stuff
+ if(topModesFromFile_) {
+ PDPtr top = getParticleData(ParticleID::t);
+ top->widthGenerator(WidthGeneratorPtr());
+ top->massGenerator(MassGenPtr());
+ DecaySet::const_iterator dit = top->decayModes().begin();
+ DecaySet::const_iterator dend = top->decayModes().end();
+ for( ; dit != dend; ++dit ) {
+ generator()->preinitInterface(*dit, "BranchingRatio", "set", "0.");
+ generator()->preinitInterface(*dit, "OnOff", "set", "Off");
+ }
+ }
+ // read first line and check if this is a Les Houches event file
+ cfile.readline();
+ bool lesHouches = cfile.find("<LesHouchesEvents");
+ bool reading = !lesHouches;
+ if(lesHouches) cfile.readline();
+ // function pointer for putting all characters to lower case.
+ int (*pf)(int) = tolower;
+ while (true) {
+ string line = cfile.getline();
+ // check for start of slha block in SLHA files
+ if(lesHouches && !reading) {
+ if(line.find("<slha")==0) reading = true;
+ if(!cfile.readline()) break;
+ continue;
+ }
+ // ignore comment lines
+ if(line[0] == '#') {
+ if(!cfile.readline()) break;
+ continue;
+ }
+ // make everything lower case
+ transform(line.begin(), line.end(), line.begin(), pf);
+ // start of a block
+ if(line.find("decay") == 0) {
+ readDecay(cfile, line);
+ }
+ else if( lesHouches && line.find("</slha") == 0 ) {
+ reading = false;
+ break;
+ }
+ if(!cfile.readline()) break;
+ }
+}
+
+void BSMModel::readDecay(CFileLineReader & cfile,
+ string decay) const{
+ // extract parent PDG code and width
+ long parent(0);
+ Energy width(ZERO);
+ istringstream iss(decay);
+ string dummy;
+ iss >> dummy >> parent >> iunit(width, GeV);
+ PDPtr inpart = getParticleData(parent);
+ if(!topModesFromFile_&&abs(parent)==ParticleID::t) {
+ cfile.readline();
+ return;
+ }
+ if(!inpart) throw SetupException()
+ << "BSMModel::readDecay() - "
+ << "A ParticleData object with the PDG code "
+ << parent << " does not exist. "
+ << Exception::runerror;
+ inpart->width(width);
+ if( width > ZERO ) inpart->cTau(hbarc/width);
+ inpart->widthCut(5.*width);
+ Energy inMass = inpart->mass();
+ string prefix("decaymode " + inpart->name() + "->");
+ double brsum(0.);
+ unsigned int nmode = 0;
+ while(cfile.readline()) {
+ string line = cfile.getline();
+ // skip comments
+ if(line[0] == '#') continue;
+ // reached the end
+ if( line[0] == 'B' || line[0] == 'b' ||
+ line[0] == 'D' || line[0] == 'd' ||
+ line[0] == '<' ) {
+ cfile.resetline();
+ break;
+ }
+ // read the mode
+ // get the branching ratio and no of decay products
+ istringstream is(line);
+ double brat(0.);
+ unsigned int nda(0),npr(0);
+ is >> brat >> nda;
+ vector<tcPDPtr> products,bosons;
+ Energy mout(ZERO),moutnoWZ(ZERO);
+ string tag = prefix;
+ while( true ) {
+ long t;
+ is >> t;
+ if( is.fail() ) break;
+ if( t == abs(parent) ) {
+ throw SetupException()
+ << "An error occurred while read a decay of the "
+ << inpart->PDGName() << ". One of its products has the same PDG code "
+ << "as the parent particle. Please check the SLHA file.\n"
+ << Exception::runerror;
+ }
+ tcPDPtr p = getParticleData(t);
+ if( !p ) {
+ throw SetupException()
+ << "BSMModel::readDecay() - An unknown PDG code has been encounterd "
+ << "while reading a decay mode. ID: " << t
+ << Exception::runerror;
+ }
+ ++npr;
+ tag += p->name() + ",";
+ Energy mass = p->mass();
+ mout += mass;
+ if(abs(p->id())==ParticleID::Wplus||p->id()==ParticleID::Z0) {
+ bosons.push_back(p);
+ }
+ else {
+ products.push_back(p);
+ moutnoWZ += mass;
+ }
+ }
+ if( npr != nda ) {
+ throw SetupException()
+ << "BSMModel::readDecay - While reading a decay of the "
+ << inpart->PDGName() << " from an SLHA file, an inconsistency "
+ << "between the number of decay products and the value in "
+ << "the 'NDA' column was found. Please check if the spectrum "
+ << "file is correct.\n"
+ << Exception::warning;
+ }
+ if( npr > 1 ) {
+ tag.replace(tag.size() - 1, 1, ";");
+ // normal option
+ if(mout<=inMass) {
+ inpart->stable(false);
+ brsum += brat;
+ createDecayMode(tag, brat);
+ }
+ // no possible off-shell gauge bosons throw it away
+ else if(bosons.empty() || bosons.size()>2 ||
+ moutnoWZ>=inMass) {
+ cerr << "BSMModel::readDecay() "
+ << "The decay " << tag << " cannot proceed for on-shell "
+ << "particles, skipping it.\n";
+ }
+ else {
+ Energy maxMass = inMass - moutnoWZ;
+ string newTag = prefix;
+ for(unsigned int ix=0;ix<products.size();++ix)
+ newTag += products[ix]->name() + ",";
+ if(bosons.size()==1) {
+ cerr << "BSMModel::readDecay() "
+ << "The decay " << tag << " cannot proceed for on-shell\n"
+ << "particles, replacing gauge boson with its decay products\n";
+ vector<pair<double,string> > modes =
+ createWZDecayModes(newTag,brat,bosons[0],maxMass);
+ for(unsigned int ix=0;ix<modes.size();++ix) {
+ modes[ix].second.replace(modes[ix].second.size() - 1, 1, ";");
+ createDecayMode(modes[ix].second,modes[ix].first);
+ brsum += modes[ix].first;
+ }
+ }
+ else if(bosons.size()==2) {
+ bool identical = bosons[0]->id()==bosons[1]->id();
+ if(maxMass>bosons[0]->mass()&&maxMass>bosons[1]->mass()) {
+ cerr << "BSMModel::readDecay() "
+ << "The decay " << tag << " cannot proceed for on-shell\n"
+ << "particles, replacing one of the gauge bosons"
+ << " with its decay products\n";
+ unsigned int imax = identical ? 1 : 2;
+ if(imax==2) brat *= 0.5;
+ for(unsigned int ix=0;ix<imax;++ix) {
+ string newTag2 = newTag+bosons[ix]->name()+',';
+ unsigned int iother = ix==0 ? 1 : 0;
+ vector<pair<double,string> > modes =
+ createWZDecayModes(newTag2,brat,bosons[iother],maxMass);
+ for(unsigned int ix=0;ix<modes.size();++ix) {
+ modes[ix].second.replace(modes[ix].second.size() - 1, 1, ";");
+ createDecayMode(modes[ix].second,modes[ix].first);
+ brsum += modes[ix].first;
+ }
+ }
+ }
+ else {
+ cerr << "BSMModel::readDecay() "
+ << "The decay " << tag << " cannot proceed for on-shell\n"
+ << "particles, and has too many off-shell gauge bosons,"
+ << " skipping it.\n";
+ }
+ }
+ else {
+ cerr << "BSMModel::readDecay() "
+ << "The decay " << tag << " cannot proceed for on-shell\n"
+ << "particles, and has too many outgoing gauge bosons skipping it.\n";
+ }
+ }
+ }
+ }
+ if( abs(brsum - 1.) > tolerance_ && nmode!=0 ) {
+ cerr << "Warning: The total branching ratio for " << inpart->PDGName()
+ << " from the spectrum file does not sum to 1. The branching fractions"
+ << " will be rescaled.\n";
+ cerr << setprecision(13) << abs(brsum - 1.) << "\n";
+ }
+}
+
+void BSMModel::createDecayMode(string tag, double brat) const {
+ ostringstream cmd;
+ cmd << tag << string(" ")
+ << setprecision(13) << brat << string(" 1 /Herwig/Decays/Mambo");
+ Repository::exec(cmd.str(), cerr);
+}
+
+
+vector<pair<double,string> >
+BSMModel::createWZDecayModes(string tag, double brat,
+ tcPDPtr boson, Energy maxMass) const {
+ vector<pair<double,string> > modes;
+ double sum(0.);
+ for(DecaySet::const_iterator dit=boson->decayModes().begin();
+ dit!=boson->decayModes().end();++dit) {
+ tcDMPtr mode = *dit;
+ if(!mode->on()) continue;
+ string extra;
+ Energy outMass(ZERO);
+ for(ParticleMSet::const_iterator pit=mode->products().begin();
+ pit!=mode->products().end();++pit) {
+ extra += (**pit).name() + ",";
+ outMass += (**pit).mass();
+ }
+ if(outMass<maxMass) {
+ sum += mode->brat();
+ modes.push_back(make_pair(mode->brat(),tag+extra));
+ }
+ }
+ for(unsigned int ix=0;ix<modes.size();++ix)
+ modes[ix].first *= brat/sum;
+ return modes;
+}
diff --git a/Models/General/BSMModel.h b/Models/General/BSMModel.h
new file mode 100644
--- /dev/null
+++ b/Models/General/BSMModel.h
@@ -0,0 +1,135 @@
+// -*- C++ -*-
+#ifndef Herwig_BSMModel_H
+#define Herwig_BSMModel_H
+//
+// This is the declaration of the BSMModel class.
+//
+
+#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "ThePEG/Utilities/CFileLineReader.h"
+
+namespace Herwig {
+
+using namespace ThePEG;
+
+/**
+ * Here is the documentation of the BSMModel class.
+ *
+ * @see \ref BSMModelInterfaces "The interfaces"
+ * defined for BSMModel.
+ */
+class BSMModel: public Herwig::StandardModel {
+
+public:
+
+ /**
+ * The default constructor.
+ */
+ BSMModel();
+
+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:
+
+ /**
+ * Get name of SLHA decay file
+ */
+ const string & decayFile() const {return decayFile_;}
+
+ /**
+ * Set name of SLHA decay file
+ */
+ void decayFile(string in) {decayFile_ = in;}
+
+ /**
+ * Read decaymodes from LHA file
+ * @param ifs input stream containg data
+ * @param decay string containing name of parent and value of total width
+ */
+ void readDecay(CFileLineReader & ifs, string decay) const;
+
+ /**
+ * Create a DecayMode object in the repository
+ * @param tag The tag identifying the decay mode including the prefix
+ * 'decaymode'
+ * @param brat Branching ratio of this mode
+ */
+ void createDecayMode(string tag, double brat) const;
+
+ /**
+ * Create a DecayMode object in the repository
+ * @param tag The tag identifying the decay mode including the prefix
+ * 'decaymode'
+ * @param brat Branching ratio of this mode
+ */
+ vector<pair<double,string> > createWZDecayModes(string tag, double brat,
+ tcPDPtr boson,
+ Energy maxMass) 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.
+ */
+ BSMModel & operator=(const BSMModel &);
+
+private:
+
+ /**
+ * Name of the decay file
+ */
+ string decayFile_;
+
+ /**
+ * Whether or not to replace the top decay modes with those from
+ * the SLHA files
+ */
+ bool topModesFromFile_;
+
+ /**
+ * Tolerance for branching ratios
+ */
+ double tolerance_;
+
+};
+
+}
+
+#endif /* Herwig_BSMModel_H */
diff --git a/Models/General/Makefile.am b/Models/General/Makefile.am
--- a/Models/General/Makefile.am
+++ b/Models/General/Makefile.am
@@ -1,25 +1,26 @@
noinst_LTLIBRARIES = libHwModelGenerator.la
libHwModelGenerator_la_SOURCES = \
ModelGenerator.h ModelGenerator.fh ModelGenerator.cc\
DecayConstructor.cc DecayConstructor.h DecayConstructor.fh \
NBodyDecayConstructorBase.cc NBodyDecayConstructorBase.h \
NBodyDecayConstructorBase.fh \
TwoBodyDecayConstructor.cc TwoBodyDecayConstructor.h \
TwoToTwoProcessConstructor.h TwoToTwoProcessConstructor.fh \
TwoToTwoProcessConstructor.cc \
HardProcessConstructor.h HardProcessConstructor.fh \
HardProcessConstructor.cc \
HiggsVectorBosonProcessConstructor.h \
HiggsVectorBosonProcessConstructor.cc \
HiggsVBFProcessConstructor.h \
HiggsVBFProcessConstructor.cc \
QQHiggsProcessConstructor.h \
QQHiggsProcessConstructor.cc \
HPDiagram.h \
ThreeBodyDecayConstructor.h ThreeBodyDecayConstructor.cc \
WeakCurrentDecayConstructor.h WeakCurrentDecayConstructor.cc \
ResonantProcessConstructor.cc ResonantProcessConstructor.h \
ResonantProcessConstructor.fh \
VVSLoopVertex.fh VVSLoopVertex.h VVSLoopVertex.cc \
BSMWidthGenerator.h BSMWidthGenerator.fh BSMWidthGenerator.cc \
-TBDiagram.h
+TBDiagram.h\
+BSMModel.h BSMModel.cc
diff --git a/Models/Leptoquarks/LeptoquarkModel.cc b/Models/Leptoquarks/LeptoquarkModel.cc
--- a/Models/Leptoquarks/LeptoquarkModel.cc
+++ b/Models/Leptoquarks/LeptoquarkModel.cc
@@ -1,213 +1,213 @@
// -*- C++ -*-
//
// This is the implementation of the non-inlined, non-templated member
// functions of the LeptoquarkModel class.
//
#include "LeptoquarkModel.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
using namespace Herwig;
using namespace ThePEG;
using namespace ThePEG::Helicity;
void LeptoquarkModel::doinit() {
addVertex(_theSLQSLQGVertex);
addVertex(_theSLQSLQGGVertex);
addVertex(_theSLQFFVertex);
- StandardModel::doinit();
+ BSMModel::doinit();
}
LeptoquarkModel::LeptoquarkModel() : _CouplFF(0.312), _leftcoup(1.0), _rightcoup(1.0), _rightcouptilde(1.0), _leftcoup1(1.0) , _leftcoup12(1.0), _rightcoup12(1.0), _leftcoup12t(1.0), _dleftcoup(1.0), _drightcoup(1.0), _drightcouptilde(1.0), _dleftcoup1(1.0) , _dleftcoup12(1.0), _drightcoup12(1.0), _dleftcoup12t(1.0), _derivscalef(500.0) {}
IBPtr LeptoquarkModel::clone() const {
return new_ptr(*this);
}
IBPtr LeptoquarkModel::fullclone() const {
return new_ptr(*this);
}
// If needed, insert default implementations of virtual function defined
// in the InterfacedBase class here (using ThePEG-interfaced-impl in Emacs).
void LeptoquarkModel::persistentOutput(PersistentOStream & os) const {
os << _theSLQSLQGGVertex
<< _theSLQSLQGVertex
<< _theSLQFFVertex
<< _CouplFF
<< _leftcoup
<< _rightcoup
<< _leftcoup1
<< _rightcouptilde
<< _leftcoup12
<< _rightcoup12
<< _leftcoup12t
<< _dleftcoup
<< _drightcoup
<< _dleftcoup1
<< _drightcouptilde
<< _dleftcoup12
<< _drightcoup12
<< _dleftcoup12t
<< _derivscalef;
}
void LeptoquarkModel::persistentInput(PersistentIStream & is, int) {
is >> _theSLQSLQGGVertex
>> _theSLQSLQGVertex
>> _theSLQFFVertex
>> _CouplFF
>> _leftcoup
>> _rightcoup
>> _leftcoup1
>> _rightcouptilde
>> _leftcoup12
>> _rightcoup12
>> _leftcoup12t
>> _dleftcoup
>> _drightcoup
>> _dleftcoup1
>> _drightcouptilde
>> _dleftcoup12
>> _drightcoup12
>> _dleftcoup12t
>> _derivscalef;
}
ClassDescription<LeptoquarkModel> LeptoquarkModel::initLeptoquarkModel;
// Definition of the static class description member.
void LeptoquarkModel::Init() {
static Reference<LeptoquarkModel,ThePEG::Helicity::AbstractVSSVertex> interfaceVertexSLQSLQG
("Vertex/SLQSLQG",
"Reference to the scalar leptoquark-scalar leptoquark-gluon vertex",
&LeptoquarkModel::_theSLQSLQGVertex, false, false, true, false, false);
static Reference<LeptoquarkModel,ThePEG::Helicity::AbstractVVSSVertex> interfaceVertexSLQSLQGG
("Vertex/SLQSLQGG",
"Reference to the scalar leptoquark-scalar leptoquark-gluon-gluon vertex",
&LeptoquarkModel::_theSLQSLQGGVertex, false, false, true, false, false);
static Reference<LeptoquarkModel,ThePEG::Helicity::AbstractFFSVertex> interfaceVertexSLQFF
("Vertex/SLQFF",
"Reference to the scalar leptoquark-scalar-quark-lepton",
&LeptoquarkModel::_theSLQFFVertex, false, false, true, false, false);
static Parameter<LeptoquarkModel, double> interfaceLQCoupling
("LQCoupling",
"The overall Leptoquark Coupling",
&LeptoquarkModel::_CouplFF, 0.312, 0., 10.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ_L
("g_S0_L",
"The leptoquark S0 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_leftcoup, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ_R
("g_S0_R",
"The leptoquark S0 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_rightcoup, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ_Rt
("g_S0t_R",
"The leptoquark ~S0 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_rightcouptilde, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ_L1
("g_S1_L",
"The leptoquark S1 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_leftcoup1, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ12_L
("g_S12_L",
"The leptoquark S1/2 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_leftcoup12, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ12_R
("g_S12_R",
"The leptoquark S1/2 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_rightcoup12, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegLQ12t_L
("g_S12t_L",
"The leptoquark ~S1/2 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_leftcoup12t, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ_L
("g_dS0_L",
"The leptoquark dS0 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_dleftcoup, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ_R
("g_dS0_R",
"The leptoquark dS0 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_drightcoup, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ_Rt
("g_dS0t_R",
"The leptoquark ~dS0 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_drightcouptilde, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ_L1
("g_dS1_L",
"The leptoquark dS1 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_dleftcoup1, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ12_L
("g_dS12_L",
"The leptoquark dS1/2 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_dleftcoup12, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ12_R
("g_dS12_R",
"The leptoquark dS1/2 coupling LQ-lepton_right-quark_left",
&LeptoquarkModel::_drightcoup12, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfacegdLQ12t_L
("g_dS12t_L",
"The leptoquark ~dS1/2 coupling LQ-lepton_left-quark_right",
&LeptoquarkModel::_dleftcoup12t, 1.0, 0., 1.0,
false, false, Interface::limited);
static Parameter<LeptoquarkModel, double> interfaceDerivativeScale
("derivscale",
"The suppression scale for the derivatively coupled leptoquarks",
&LeptoquarkModel::_derivscalef, 500.0, 0., 10000.0,
false, false, Interface::limited);
static ClassDocumentation<LeptoquarkModel> documentation
("There is no documentation for the LeptoquarkModel class");
}
diff --git a/Models/Leptoquarks/LeptoquarkModel.h b/Models/Leptoquarks/LeptoquarkModel.h
--- a/Models/Leptoquarks/LeptoquarkModel.h
+++ b/Models/Leptoquarks/LeptoquarkModel.h
@@ -1,356 +1,356 @@
// -*- C++ -*-
#ifndef HERWIG_LeptoquarkModel_H
#define HERWIG_LeptoquarkModel_H
//
// This is the declaration of the LeptoquarkModel class.
//
-#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "Herwig++/Models/General/BSMModel.h"
#include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSSVertex.h"
#include "LeptoquarkModel.fh"
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
/**
* Here is the documentation of the LeptoquarkModel class.
*
* @see \ref LeptoquarkModelInterfaces "The interfaces"
* defined for LeptoquarkModel.
*/
-class LeptoquarkModel: public StandardModel {
+class LeptoquarkModel: public BSMModel {
public:
/**
* The default constructor.
*/
LeptoquarkModel();
/** @name Vertices */
//@{
/**
* Pointer to the object handling S0S0barg vertex.
*/
tAbstractVSSVertexPtr vertexSLQSLQG() const {return _theSLQSLQGVertex;}
/**
* Pointer to the object handling the S0S0bargg vertex.
*/
tAbstractVVSSVertexPtr vertexSLQSLQGG() const {return _theSLQSLQGGVertex;}
/**
* Pointer to the object handling the S0ql vertex.
*/
tAbstractFFSVertexPtr vertexSLQFF() const {return _theSLQFFVertex;}
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();
/**
* Return the overall fermion coupling
*/
double cfermion() const {return _CouplFF;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (S0)
*/
double cleft() const {return _leftcoup;}
/**
* Return the coupling of the leptoquark to right-handed leptons + left-handed quarks (S0)
*/
double cright() const {return _rightcoup;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (S1 triplet)
*/
double cleft1() const {return _leftcoup1;}
/**
* Return the coupling of the leptoquark to right-handed leptons
* + left-handed quarks (~S0)
*/
double crighttilde() const {return _rightcouptilde;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (S1/2)
*/
double cleft12() const {return _leftcoup12;}
/**
* Return the coupling of the leptoquark to right-handed leptons + left-handed quarks (S1/2)
*/
double cright12() const {return _rightcoup12;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (S1/2)
*/
double cleft12tilde() const {return _leftcoup12t;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (S0)
*/
double dcleft() const {return _dleftcoup;}
/**
* Return the coupling of the leptoquark to right-handed leptons + left-handed quarks (dS0)
*/
double dcright() const {return _drightcoup;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (dS1 triplet)
*/
double dcleft1() const {return _dleftcoup1;}
/**
* Return the coupling of the leptoquark to right-handed leptons
* + left-handed quarks (~dS0)
*/
double dcrighttilde() const {return _drightcouptilde;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (dS1/2)
*/
double dcleft12() const {return _dleftcoup12;}
/**
* Return the coupling of the leptoquark to right-handed leptons + left-handed quarks (dS1/2)
*/
double dcright12() const {return _drightcoup12;}
/**
* Return the coupling of the leptoquark to left-handed leptons + right-handed quarks (dS1/2)
*/
double dcleft12tilde() const {return _dleftcoup12t;}
/**
* Suppression scale for derivatively coupled scalar leptoquarks
*/
double fscale() const {return _derivscalef;}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
//@}
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const;
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
virtual IBPtr fullclone() const;
//@}
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<LeptoquarkModel> initLeptoquarkModel;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
LeptoquarkModel & operator=(const LeptoquarkModel &);
/**
* Pointer to the object handling the G to SLQ SLQ vertex.
*/
AbstractVSSVertexPtr _theSLQSLQGVertex;
/**
* Pointer to the object handling the GG to SLQ SLQ vertex.
*/
AbstractVVSSVertexPtr _theSLQSLQGGVertex;
/**
* Pointer to the object handling the SLQ to FF vertex.
*/
AbstractFFSVertexPtr _theSLQFFVertex;
/**
* Overall coupling to fermions
*/
double _CouplFF;
/**
* Overall coupling to left-handed leptons (S0)
*/
double _leftcoup;
/**
* Overall coupling to right-handed leptons (S0)
*/
double _rightcoup;
/**
* Overall coupling to left-handed leptons (~S0)
*/
double _rightcouptilde;
/**
* Overall coupling to left-handed leptons (S1 triplet)
*/
double _leftcoup1;
/**
* Overall coupling to left-handed leptons (S1/2)
*/
double _leftcoup12;
/**
* Overall coupling to right-handed leptons (S1/2)
*/
double _rightcoup12;
/**
* Overall coupling to left-handed leptons (~S1/2)
*/
double _leftcoup12t;
/**
* Overall coupling to left-handed leptons (dS0)
*/
double _dleftcoup;
/**
* Overall coupling to right-handed leptons (dS0)
*/
double _drightcoup;
/**
* Overall coupling to left-handed leptons (~dS0)
*/
double _drightcouptilde;
/**
* Overall coupling to left-handed leptons (dS1 triplet)
*/
double _dleftcoup1;
/**
* Overall coupling to left-handed leptons (dS1/2)
*/
double _dleftcoup12;
/**
* Overall coupling to right-handed leptons (dS1/2)
*/
double _drightcoup12;
/**
* Overall coupling to left-handed leptons (~dS1/2)
*/
double _dleftcoup12t;
/**
* Suppression scale for derivatively coupled scalar leptoquarks, f
*/
double _derivscalef;
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of LeptoquarkModel. */
template <>
struct BaseClassTrait<Herwig::LeptoquarkModel,1> {
/** Typedef of the first base class of LeptoquarkModel. */
- typedef Herwig::StandardModel NthBase;
+ typedef Herwig::BSMModel NthBase;
};
/** This template specialization informs ThePEG about the name of
* the LeptoquarkModel class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::LeptoquarkModel>
: public ClassTraitsBase<Herwig::LeptoquarkModel> {
/** Return a platform-independent class name */
static string className() { return "Herwig::LeptoquarkModel"; }
/**
* The name of a file containing the dynamic library where the class
* LeptoquarkModel is implemented. It may also include several, space-separated,
* libraries if the class LeptoquarkModel depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwLeptoquarkModel.so"; }
};
/** @endcond */
}
#endif /* HERWIG_LeptoquarkModel_H */
diff --git a/Models/RSModel/RSModel.cc b/Models/RSModel/RSModel.cc
--- a/Models/RSModel/RSModel.cc
+++ b/Models/RSModel/RSModel.cc
@@ -1,110 +1,110 @@
// -*- C++ -*-
//
// RSModel.cc is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the RSModel class.
//
#include "RSModel.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
using namespace Herwig;
using namespace ThePEG;
using namespace ThePEG::Helicity;
void RSModel::doinit() {
addVertex(FFGRVertex_);
addVertex(VVGRVertex_);
addVertex(SSGRVertex_);
addVertex(FFGGRVertex_);
addVertex(FFWGRVertex_);
addVertex(GGGGRVertex_);
addVertex(WWWGRVertex_);
- StandardModel::doinit();
+ BSMModel::doinit();
}
void RSModel::persistentOutput(PersistentOStream & os) const {
os << ounit(Lambda_pi_,GeV)
<< FFGRVertex_ << VVGRVertex_ << SSGRVertex_
<< FFGGRVertex_ << FFWGRVertex_
<< GGGGRVertex_ << WWWGRVertex_;
}
void RSModel::persistentInput(PersistentIStream & is, int) {
is >> iunit(Lambda_pi_,GeV)
>> FFGRVertex_ >> VVGRVertex_ >> SSGRVertex_
>> FFGGRVertex_ >> FFWGRVertex_
>> GGGGRVertex_ >> WWWGRVertex_;
}
ClassDescription<RSModel> RSModel::initRSModel;
// Definition of the static class description member.
void RSModel::Init() {
static Reference<RSModel,ThePEG::Helicity::AbstractFFTVertex> interfaceVertexFFGR
("Vertex/FFGR",
"Reference to the fermion-fermion-graviton vertex",
&RSModel::FFGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractVVTVertex> interfaceVertexVVGR
("Vertex/VVGR",
"Reference to the vector-vector-graviton vertex",
&RSModel::VVGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractSSTVertex> interfaceVertexSSGR
("Vertex/SSGR",
"Reference to the scalar-scalar-graviton vertex",
&RSModel::SSGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractFFVTVertex> interfaceVertexFFGGR
("Vertex/FFGGR",
"Reference to the fermion-antifermion-gluon graviton vertex",
&RSModel::FFGGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractFFVTVertex> interfaceVertexFFWGR
("Vertex/FFWGR",
"Reference to the fermion-antifermion-weak vector boson graviton vertex",
&RSModel::FFWGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractVVVTVertex> interfaceVertexGGGGR
("Vertex/GGGGR",
"Reference to the three gluon graviton vertex",
&RSModel::GGGGRVertex_, false, false, true, false, false);
static Reference<RSModel,ThePEG::Helicity::AbstractVVVTVertex> interfaceVertexWWWGR
("Vertex/WWWGR",
"Reference to the three weak vector boson graviton vertex",
&RSModel::WWWGRVertex_, false, false, true, false, false);
static Parameter<RSModel,Energy> interfaceLambda_pi
("Lambda_pi",
"The coupling of the graviton to matter",
&RSModel::Lambda_pi_, GeV, 10000*GeV, ZERO, 1.0e12*GeV,
false, false, false);
static ClassDocumentation<RSModel> documentation
("The RSModel class replaces the Standard Model class for the"
" RS model",
"The Randall-Sundrum model was constructed from \\cite{Randall:1999ee}.",
"%\\cite{Randall:1999ee}\n"
"\\bibitem{Randall:1999ee}\n"
" L.~Randall and R.~Sundrum,\n"
" ``A large mass hierarchy from a small extra dimension,''\n"
" Phys.\\ Rev.\\ Lett.\\ {\\bf 83}, 3370 (1999)\n"
" [arXiv:hep-ph/9905221].\n"
" %%CITATION = PRLTA,83,3370;%%\n"
);
}
diff --git a/Models/RSModel/RSModel.h b/Models/RSModel/RSModel.h
--- a/Models/RSModel/RSModel.h
+++ b/Models/RSModel/RSModel.h
@@ -1,237 +1,237 @@
// -*- C++ -*-
//
// RSModel.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_RSModel_H
#define HERWIG_RSModel_H
// This is the declaration of the RSModel class.
-#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "Herwig++/Models/General/BSMModel.h"
#include "ThePEG/Helicity/Vertex/AbstractFFTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVTVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVTVertex.h"
#include "RSModel.fh"
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
/** \ingroup Models
*
* This is the class to be used instead of the Standard Model class for
* the Randell Sundrum model.
*
* @see \ref RSModelInterfaces "The interfaces"
* defined for RSModel.
* @see StandardModel
* @see StandardModelBase
*
*/
-class RSModel: public StandardModel {
+class RSModel: public BSMModel {
public:
/**
* The default constructor
*/
RSModel(): Lambda_pi_(10000*GeV) {
useMe();
}
/**
* Return the gravition coupling
*/
Energy lambda_pi() const {return Lambda_pi_;}
/** @name Vertices */
//@{
/**
* Pointer to the object handling the \f$G\to f\bar{f}\f$ vertex.
*/
tAbstractFFTVertexPtr vertexFFGR() const {return FFGRVertex_;}
/**
* Pointer to the object handling the \f$G\to VV\f$ vertex.
*/
tAbstractVVTVertexPtr vertexVVGR() const {return VVGRVertex_;}
/**
* Pointer to the object handling the \f$G\to SS\f$ vertex.
*/
tAbstractSSTVertexPtr vertexSSGR() const {return SSGRVertex_;}
/**
* Pointer to the object handling the \f$G\to f\bar{f}g\f$ vertex.
*/
tAbstractFFVTVertexPtr vertexFFGGR() const {return FFGGRVertex_;}
/**
* Pointer to the object handling the \f$G\to f\bar{f}W^\pm/Z^0/\gamma\f$ vertex.
*/
tAbstractFFVTVertexPtr vertexFFWGR() const {return FFWGRVertex_;}
/**
* Pointer to the object handling the \f$G\to W^+W^-Z^0/\gamma\f$ vertex.
*/
tAbstractVVVTVertexPtr vertexWWWGR() const {return WWWGRVertex_;}
/**
* Pointer to the object handling the \f$G\to ggg\f$ vertex.
*/
tAbstractVVVTVertexPtr vertexGGGGR() const {return GGGGRVertex_;}
//@}
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 Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
//@}
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
virtual IBPtr clone() const {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:
/**
* Describe a concrete class with persistent data.
*/
static ClassDescription<RSModel> initRSModel;
/**
* Private and non-existent assignment operator.
*/
RSModel & operator=(const RSModel &);
private:
/**
* Coupling of the graviton
*/
Energy Lambda_pi_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}\f$ vertex.
*/
AbstractFFTVertexPtr FFGRVertex_;
/**
* Pointer to the object handling the \f$G\to VV\f$ vertex.
*/
AbstractVVTVertexPtr VVGRVertex_;
/**
* Pointer to the object handling the \f$G\to SS\f$ vertex.
*/
AbstractSSTVertexPtr SSGRVertex_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}g\f$ vertex.
*/
AbstractFFVTVertexPtr FFGGRVertex_;
/**
* Pointer to the object handling the \f$G\to f\bar{f}W/Z^0\gamma\f$ vertex.
*/
AbstractFFVTVertexPtr FFWGRVertex_;
/**
* Pointer to the object handling the \f$G\to W^+W^-Z^0\gamma\f$ vertex.
*/
AbstractVVVTVertexPtr WWWGRVertex_;
/**
* Pointer to the object handling the \f$G\to ggg\f$ vertex.
*/
AbstractVVVTVertexPtr GGGGRVertex_;
};
}
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/**
* The following template specialization informs ThePEG about the
* base class of RSModel.
*/
template <>
struct BaseClassTrait<Herwig::RSModel,1> {
/** Typedef of the base class of RSModel. */
- typedef Herwig::StandardModel NthBase;
+ typedef Herwig::BSMModel NthBase;
};
/**
* The following template specialization informs ThePEG about the
* name of this class and the shared object where it is defined.
*/
template <>
struct ClassTraits<Herwig::RSModel>
: public ClassTraitsBase<Herwig::RSModel> {
/** Return the class name.*/
static string className() { return "Herwig::RSModel"; }
/**
* Return the name of the shared library to be loaded to get
* access to this class and every other class it uses
* (except the base class).
*/
static string library() { return "HwRSModel.so"; }
};
/** @endcond */
}
#endif /* HERWIG_RSModel_H */
diff --git a/Models/Susy/NMSSM/NMSSMGOGOHVertex.h b/Models/Susy/NMSSM/NMSSMGOGOHVertex.h
--- a/Models/Susy/NMSSM/NMSSMGOGOHVertex.h
+++ b/Models/Susy/NMSSM/NMSSMGOGOHVertex.h
@@ -1,219 +1,219 @@
// -*- C++ -*-
#ifndef HERWIG_NMSSMGOGOHVertex_H
#define HERWIG_NMSSMGOGOHVertex_H
//
// This is the declaration of the NMSSMGOGOHVertex class.
//
#include "ThePEG/Helicity/Vertex/Scalar/FFSVertex.h"
-#include "Herwig++/Models/StandardModel/StandardModel.h"
#include "Herwig++/Models/Susy/MixingMatrix.h"
namespace Herwig {
using namespace ThePEG;
+using namespace ThePEG::Helicity;
/**
* Here is the documentation of the NMSSMGOGOHVertex class.
*
* @see \ref NMSSMGOGOHVertexInterfaces "The interfaces"
* defined for NMSSMGOGOHVertex.
*/
class NMSSMGOGOHVertex: public FFSVertex {
public:
/**
* The default constructor.
*/
inline NMSSMGOGOHVertex();
/** @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();
/**
* Calculate the couplings. This method is virtual and must be implemented in
* classes inheriting from this.
* @param q2 The scale \f$q^2\f$ for the coupling at the vertex.
* @param part1 The ParticleData pointer for the first particle.
* @param part2 The ParticleData pointer for the second particle.
* @param part3 The ParticleData pointer for the third particle.
*/
virtual void setCoupling(Energy2 q2,tcPDPtr part1,tcPDPtr part2,
tcPDPtr part3);
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);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
*/
virtual void doinit();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<NMSSMGOGOHVertex> initNMSSMGOGOHVertex;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
NMSSMGOGOHVertex & operator=(const NMSSMGOGOHVertex &);
private:
/**
* The various mixing matrices and couplings
*/
//@{
/**
* The V chargino mixing matrix
*/
MixingMatrixPtr _mixV;
/**
* The U chargino mixing matrix
*/
MixingMatrixPtr _mixU;
/**
* The neutralino mixing matrix
*/
MixingMatrixPtr _mixN;
/**
* The CP-even neutral Higgs mixing matrix
*/
MixingMatrixPtr _mixS;
/**
* The CP-odd neutral Higgs mixing matrix
*/
MixingMatrixPtr _mixP;
/**
* The tri-linear \f$\lambda\f$ coupling
*/
double _lambda;
/**
* The tri-linear \f$\kappa\f$ coupling
*/
double _kappa;
/**
* \f$\sin\beta\f$
*/
double _sinb;
/**
* \f$\cos\beta\f$
*/
double _cosb;
/**
* \f$\sin\theta_W\f$
*/
double _sw;
/**
* \f$\cos\theta_W\f$
*/
double _cw;
/**
* The last \f$q^2\f$ the coupling was evaluated at.
*/
Energy2 _q2last;
/**
* The last value of the coupling
*/
double _couplast;
//@}
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of NMSSMGOGOHVertex. */
template <>
struct BaseClassTrait<Herwig::NMSSMGOGOHVertex,1> {
/** Typedef of the first base class of NMSSMGOGOHVertex. */
typedef ThePEG::Helicity::FFSVertex NthBase;
};
/** This template specialization informs ThePEG about the name of
* the NMSSMGOGOHVertex class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::NMSSMGOGOHVertex>
: public ClassTraitsBase<Herwig::NMSSMGOGOHVertex> {
/** Return a platform-independent class name */
static string className() { return "Herwig::NMSSMGOGOHVertex"; }
/**
* The name of a file containing the dynamic library where the class
* NMSSMGOGOHVertex is implemented. It may also include several, space-separated,
* libraries if the class NMSSMGOGOHVertex depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwSusy.so HwNMSSM.so"; }
};
/** @endcond */
}
#endif /* HERWIG_NMSSMGOGOHVertex_H */
diff --git a/Models/Susy/NMSSM/NMSSMHHHVertex.h b/Models/Susy/NMSSM/NMSSMHHHVertex.h
--- a/Models/Susy/NMSSM/NMSSMHHHVertex.h
+++ b/Models/Susy/NMSSM/NMSSMHHHVertex.h
@@ -1,318 +1,317 @@
// -*- C++ -*-
#ifndef HERWIG_NMSSMHHHVertex_H
#define HERWIG_NMSSMHHHVertex_H
//
// This is the declaration of the NMSSMHHHVertex class.
//
#include "ThePEG/Helicity/Vertex/Scalar/SSSVertex.h"
-#include "ThePEG/StandardModel/StandardModelBase.h"
#include "Herwig++/Models/StandardModel/StandardModel.h"
#include "Herwig++/Models/Susy/MixingMatrix.h"
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
/** \ingroup Helicity
* The NMSSMHHHVertex defines the triple
* Higgs coupling in the NMSSM.
*
* @see \ref NMSSMHHHVertexInterfaces "The interfaces"
* defined for NMSSMHHHVertex.
*/
class NMSSMHHHVertex: public SSSVertex {
public:
/**
* The default constructor.
*/
NMSSMHHHVertex();
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();
/**
* Calculate the couplings. This method is virtual and must be implemented in
* classes inheriting from this.
* @param q2 The scale \f$q^2\f$ for the coupling at the vertex.
* @param part1 The ParticleData pointer for the first particle.
* @param part2 The ParticleData pointer for the second particle.
* @param part3 The ParticleData pointer for the third particle.
*/
virtual void setCoupling(Energy2 q2,tcPDPtr part1,tcPDPtr part2,
tcPDPtr part3);
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);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
*/
virtual void doinit();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<NMSSMHHHVertex> initNMSSMHHHVertex;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
NMSSMHHHVertex & operator=(const NMSSMHHHVertex &);
private:
/**
* The mixing matrix combination \f$U^S_{ai}U^S_{bj}U^S_{ck}\f$
* @param a The row element of the first CP-even mixing matrix
* @param b The column element of the first CP-even mixing matrix
* @param c The row element of the second CP-even mixing matrix
* @param i The column element of the second CP-even mixing matrix
* @param j The row element of the third CP-even mixing matrix
* @param k The column element of the third CP-even mixing matrix
*/
Complex usMix(unsigned int a, unsigned int b, unsigned int c,
unsigned int i, unsigned int j, unsigned int k) const {
return (*_mixS)(a,i)*(*_mixS)(b,j)*(*_mixS)(c,k) +
(*_mixS)(a,i)*(*_mixS)(c,j)*(*_mixS)(b,k) +
(*_mixS)(b,i)*(*_mixS)(a,j)*(*_mixS)(c,k) +
(*_mixS)(b,i)*(*_mixS)(c,j)*(*_mixS)(a,k) +
(*_mixS)(c,i)*(*_mixS)(a,j)*(*_mixS)(b,k) +
(*_mixS)(c,i)*(*_mixS)(b,j)*(*_mixS)(a,k);
}
/**
* The mixing matrix combination \f$U^S_{ai}U^P_{bj}U^P_{ck}\f$
* @param a The row element of the first CP-even mixing matrix
* @param b The column element of the first CP-even mixing matrix
* @param c The row element of the second CP-even mixing matrix
* @param i The column element of the second CP-even mixing matrix
* @param j The row element of the third CP-even mixing matrix
* @param k The column element of the third CP-even mixing matrix
*/
Complex upMix(unsigned int a, unsigned int b, unsigned int c,
unsigned int i, unsigned int j, unsigned int k) const {
return (*_mixS)(a,i)*((*_mixP)(b,j)*(*_mixP)(c,k) +
(*_mixP)(c,j)*(*_mixP)(b,k));
}
private:
/**
* A pointer to the object containing the SM parameters
*/
tcHwSMPtr _theSM;
/**
* The \f$W\f$ mass
*/
Energy _mw;
/**
* The \f$Z\f$ mass
*/
Energy _mz;
/**
* The \f$b\f$ mass
*/
Energy _mb;
/**
* The \f$t\f$ mass
*/
Energy _mt;
/**
* \f$\sin^2\theta_W\f$
*/
double _sw2;
/**
* \f$\cos\theta_W\f$
*/
double _cw;
/**
* The CP-even Higgs mixing matrix
*/
MixingMatrixPtr _mixS;
/**
* The CP-odd Higgs mixing matrix
*/
MixingMatrixPtr _mixP;
/**
* The coefficient of the trilinear \f$SH_2 H_1\f$ term in the superpotential
*/
double _lambda;
/**
* The coefficient of the cubic singlet term in the superpotential
*/
double _kappa;
/**
* The product \f$\lambda \langle S\rangle \f$.
*/
Energy _lambdaVEV;
/**
* The soft trilinear \f$SH_2 H_1\f$ coupling
*/
Energy _theAl;
/**
* The soft cubic \f$S\f$ coupling
*/
Energy _theAk;
/**
* \f$\sin\beta\f$
*/
double _sb;
/**
* \f$\cos\beta\f$
*/
double _cb;
/**
* \f$\sin2\beta\f$
*/
double _s2b;
/**
* \f$\cos2\beta\f$
*/
double _c2b;
/**
* The value of the VEV of the higgs that couples to the down-type sector
* \f$ g*sqrt(2)M_W\cos\beta \f$
*/
Energy _vu;
/**
* The value of the VEV of the higgs that couples to the up-type sector
* i.e. \f$ g*sqrt(2)M_W\sin\beta \f$
*/
Energy _vd;
/**
* The value of the VEV of the singlet higgs
*/
Energy _s;
/**
* The scale at which this vertex was last evaluated
*/
Energy2 _q2last;
/**
* The value of the EW coupling when it was last evaluated
*/
double _glast;
/**
* left 3rd generation scalar quark mass
*/
Energy _MQ3;
/**
* right scalar top mass
*/
Energy _MU2;
/**
* Whether or onto to include the radiative terms
*/
bool _includeRadiative;
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of NMSSMHHHVertex. */
template <>
struct BaseClassTrait<Herwig::NMSSMHHHVertex,1> {
/** Typedef of the first base class of NMSSMHHHVertex. */
typedef Helicity::SSSVertex NthBase;
};
/** This template specialization informs ThePEG about the name of
* the NMSSMHHHVertex class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::NMSSMHHHVertex>
: public ClassTraitsBase<Herwig::NMSSMHHHVertex> {
/** Return a platform-independent class name */
static string className() { return "Herwig::NMSSMHHHVertex"; }
/**
* The name of a file containing the dynamic library where the class
* NMSSMHHHVertex is implemented. It may also include several, space-separated,
* libraries if the class NMSSMHHHVertex depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwSusy.so HwNMSSM.so"; }
};
/** @endcond */
}
#endif /* HERWIG_NMSSMHHHVertex_H */
diff --git a/Models/Susy/NMSSM/NMSSMWHHVertex.h b/Models/Susy/NMSSM/NMSSMWHHVertex.h
--- a/Models/Susy/NMSSM/NMSSMWHHVertex.h
+++ b/Models/Susy/NMSSM/NMSSMWHHVertex.h
@@ -1,189 +1,189 @@
// -*- C++ -*-
#ifndef HERWIG_NMSSMWHHVertex_H
#define HERWIG_NMSSMWHHVertex_H
//
// This is the declaration of the NMSSMWHHVertex class.
//
#include "ThePEG/Helicity/Vertex/Scalar/VSSVertex.h"
-#include "Herwig++/Models/StandardModel/StandardModel.h"
#include "Herwig++/Models/Susy/MixingMatrix.h"
namespace Herwig {
using namespace ThePEG;
+using namespace ThePEG::Helicity;
/**
* The NMSSMWHHVertex class implements the coupling of an electroweak"
* gauge boson with two Higgs bosons in the NMSSM.
*
* @see \ref NMSSMWHHVertexInterfaces "The interfaces"
* defined for NMSSMWHHVertex.
*/
class NMSSMWHHVertex: public VSSVertex {
public:
/**
* The default constructor.
*/
NMSSMWHHVertex();
/** @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();
/**
* Calculate the couplings. This method is virtual and must be implemented in
* classes inheriting from this.
* @param q2 The scale \f$q^2\f$ for the coupling at the vertex.
* @param part1 The ParticleData pointer for the first particle.
* @param part2 The ParticleData pointer for the second particle.
* @param part3 The ParticleData pointer for the third particle.
*/
virtual void setCoupling(Energy2 q2,tcPDPtr part1,tcPDPtr part2,tcPDPtr part3);
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);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
*/
virtual void doinit();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<NMSSMWHHVertex> initNMSSMWHHVertex;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
NMSSMWHHVertex & operator=(const NMSSMWHHVertex &);
private:
/**
* \f$\sin\beta\f$
*/
double _sinb;
/**
* \f$\cos\beta\f$
*/
double _cosb;
/**
* \f$\sin\theta_W\f$
*/
double _sw;
/**
* \f$\cos\theta_W\f$
*/
double _cw;
/**
* The last \f$q^2\f$ the coupling was evaluated at.
*/
Energy2 _q2last;
/**
* The last value of the coupling
*/
double _couplast;
/**
* Mixing matrix for the CP-even Higgs bosons
*/
MixingMatrixPtr _mixS;
/**
* Mixing matrix for the CP-odd Higgs bosons
*/
MixingMatrixPtr _mixP;
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of NMSSMWHHVertex. */
template <>
struct BaseClassTrait<Herwig::NMSSMWHHVertex,1> {
/** Typedef of the first base class of NMSSMWHHVertex. */
typedef ThePEG::Helicity::VSSVertex NthBase;
};
/** This template specialization informs ThePEG about the name of
* the NMSSMWHHVertex class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::NMSSMWHHVertex>
: public ClassTraitsBase<Herwig::NMSSMWHHVertex> {
/** Return a platform-independent class name */
static string className() { return "Herwig::NMSSMWHHVertex"; }
/**
* The name of a file containing the dynamic library where the class
* NMSSMWHHVertex is implemented. It may also include several, space-separated,
* libraries if the class NMSSMWHHVertex depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwSusy.so HwNMSSM.so"; }
};
/** @endcond */
}
#endif /* HERWIG_NMSSMWHHVertex_H */
diff --git a/Models/Susy/NMSSM/NMSSMWWHVertex.h b/Models/Susy/NMSSM/NMSSMWWHVertex.h
--- a/Models/Susy/NMSSM/NMSSMWWHVertex.h
+++ b/Models/Susy/NMSSM/NMSSMWWHVertex.h
@@ -1,193 +1,193 @@
// -*- C++ -*-
#ifndef HERWIG_NMSSMWWHVertex_H
#define HERWIG_NMSSMWWHVertex_H
//
// This is the declaration of the NMSSMWWHVertex class.
//
#include "ThePEG/Helicity/Vertex/Scalar/VVSVertex.h"
#include "Herwig++/Models/Susy/MixingMatrix.h"
-#include "Herwig++/Models/StandardModel/StandardModel.h"
namespace Herwig {
using namespace ThePEG;
+using namespace ThePEG::Helicity;
/** \ingroup Helicity
*
* The NMSSMWWHVertex class is the implementation of the coupling of two electroweak
* gauge bosons to the Higgs bosons of the NMSSM. It inherits from VVSVertex and
* implements the setCoupling member.
*
* @see \ref NMSSMWWHVertexInterfaces "The interfaces"
* @see VVSVertex
* @see SMWWHVertex
* defined for NMSSMWWHVertex.
*/
class NMSSMWWHVertex: public VVSVertex {
public:
/**
* The default constructor.
*/
NMSSMWWHVertex();
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();
/**
* Calculate the couplings.
* @param q2 The scale \f$q^2\f$ for the coupling at the vertex.
* @param part1 The ParticleData pointer for the first particle.
* @param part2 The ParticleData pointer for the second particle.
* @param part3 The ParticleData pointer for the third particle.
*/
virtual void setCoupling(Energy2 q2,tcPDPtr part1,tcPDPtr part2,tcPDPtr part3);
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);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
*/
virtual void doinit();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<NMSSMWWHVertex> initNMSSMWWHVertex;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
NMSSMWWHVertex & operator=(const NMSSMWWHVertex &);
private:
/**
* Storage of the couplings.
*/
//@{
/**
* The last value of the electroweak coupling calculated.
*/
Complex _couplast;
/**
* The scale \f$q^2\f$ at which the coupling was last evaluated.
*/
Energy2 _q2last;
/**
* The mass of the \f$W\f$ boson.
*/
Energy _mw;
/**
* The factor for the \f$Z\f$ vertex.
*/
double _zfact;
/**
* \f$\sin\beta\f$
*/
double _sinb;
/**
* \f$\cos\beta\f$
*/
double _cosb;
/**
* Mixing matrix for the CP-even Higgs bosons
*/
MixingMatrixPtr _mixS;
//@}
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of NMSSMWWHVertex. */
template <>
struct BaseClassTrait<Herwig::NMSSMWWHVertex,1> {
/** Typedef of the first base class of NMSSMWWHVertex. */
typedef ThePEG::Helicity::VVSVertex NthBase;
};
/** This template specialization informs ThePEG about the name of
* the NMSSMWWHVertex class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::NMSSMWWHVertex>
: public ClassTraitsBase<Herwig::NMSSMWWHVertex> {
/** Return a platform-independent class name */
static string className() { return "Herwig::NMSSMWWHVertex"; }
/**
* The name of a file containing the dynamic library where the class
* NMSSMWWHVertex is implemented. It may also include several, space-separated,
* libraries if the class NMSSMWWHVertex depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwSusy.so HwNMSSM.so"; }
};
/** @endcond */
}
#endif /* HERWIG_NMSSMWWHVertex_H */
diff --git a/Models/Susy/SusyBase.cc b/Models/Susy/SusyBase.cc
--- a/Models/Susy/SusyBase.cc
+++ b/Models/Susy/SusyBase.cc
@@ -1,905 +1,644 @@
// -*- C++ -*-
//
// SusyBase.cc is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the SusyBase class.
//
#include "SusyBase.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Repository/Repository.h"
#include "ThePEG/Utilities/StringUtils.h"
#include "ThePEG/Repository/CurrentGenerator.h"
#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/PDT/MassGenerator.h"
#include "ThePEG/PDT/WidthGenerator.h"
#include "ThePEG/PDT/DecayMode.h"
using namespace Herwig;
-SusyBase::SusyBase() : readFile_(false), topModesFromFile_(false),
- tolerance_(1e-6), MPlanck_(2.4e18*GeV),
+SusyBase::SusyBase() : readFile_(false), MPlanck_(2.4e18*GeV),
gravitino_(false),
tanBeta_(0), mu_(ZERO),
M1_(ZERO), M2_(ZERO), M3_(ZERO),
mH12_(ZERO),mH22_(ZERO),
meL_(ZERO),mmuL_(ZERO),mtauL_(ZERO),
meR_(ZERO),mmuR_(ZERO),mtauR_(ZERO),
mq1L_(ZERO),mq2L_(ZERO),mq3L_(ZERO),
mdR_(ZERO),muR_(ZERO),msR_(ZERO),
mcR_(ZERO),mbR_(ZERO),mtR_(ZERO),
gluinoPhase_(1.)
{}
IBPtr SusyBase::clone() const {
return new_ptr(*this);
}
IBPtr SusyBase::fullclone() const {
return new_ptr(*this);
}
void SusyBase::doinit() {
addVertex(WSFSFVertex_);
addVertex(NFSFVertex_);
addVertex(GFSFVertex_);
addVertex(HSFSFVertex_);
addVertex(CFSFVertex_);
addVertex(GSFSFVertex_);
addVertex(GGSQSQVertex_);
addVertex(GSGSGVertex_);
addVertex(NNZVertex_);
if(NNPVertex_) addVertex(NNPVertex_);
if(GNGVertex_) addVertex(GNGVertex_);
addVertex(CCZVertex_);
addVertex(CNWVertex_);
addVertex(GOGOHVertex_);
addVertex(WHHVertex_);
addVertex(NCTVertex_);
if(gravitino_) {
if(GVNHVertex_) addVertex(GVNHVertex_);
if(GVNVVertex_) addVertex(GVNVVertex_);
if(GVFSVertex_) addVertex(GVFSVertex_);
}
- StandardModel::doinit();
+ BSMModel::doinit();
}
void SusyBase::persistentOutput(PersistentOStream & os) const {
- os << readFile_ << topModesFromFile_ << gravitino_
+ os << readFile_ << gravitino_
<< NMix_ << UMix_ << VMix_ << WSFSFVertex_
<< NFSFVertex_ << GFSFVertex_ << HSFSFVertex_ << CFSFVertex_
<< GSFSFVertex_ << GGSQSQVertex_ << GSGSGVertex_
<< NNZVertex_ << NNPVertex_ << CCZVertex_ << CNWVertex_
<< GOGOHVertex_ << WHHVertex_ << GNGVertex_ << NCTVertex_
<< GVNHVertex_ << GVNVVertex_ << GVFSVertex_
<< tanBeta_ << ounit(mu_,GeV)
<< ounit(M1_,GeV) << ounit(M2_,GeV) << ounit(M3_,GeV)
<< ounit(mH12_,GeV2) << ounit(mH22_,GeV2)
<< ounit(meL_,GeV) << ounit(mmuL_,GeV) << ounit(mtauL_,GeV)
<< ounit(meR_,GeV) << ounit(mmuR_,GeV) << ounit(mtauR_,GeV)
<< ounit(mq1L_,GeV) << ounit(mq2L_,GeV) << ounit(mq3L_,GeV)
<< ounit(mdR_,GeV) << ounit(muR_,GeV) << ounit(msR_,GeV)
<< ounit(mcR_,GeV) << ounit(mbR_,GeV) << ounit(mtR_,GeV)
- << gluinoPhase_ << tolerance_ << ounit(MPlanck_,GeV);
+ << gluinoPhase_ << ounit(MPlanck_,GeV);
}
void SusyBase::persistentInput(PersistentIStream & is, int) {
- is >> readFile_ >> topModesFromFile_ >> gravitino_
+ is >> readFile_ >> gravitino_
>> NMix_ >> UMix_ >> VMix_ >> WSFSFVertex_
>> NFSFVertex_ >> GFSFVertex_ >> HSFSFVertex_ >> CFSFVertex_
>> GSFSFVertex_ >> GGSQSQVertex_ >> GSGSGVertex_
>> NNZVertex_ >> NNPVertex_ >> CCZVertex_ >> CNWVertex_
>> GOGOHVertex_ >> WHHVertex_ >> GNGVertex_ >> NCTVertex_
>> GVNHVertex_ >> GVNVVertex_ >> GVFSVertex_
>> tanBeta_ >> iunit(mu_,GeV)
>> iunit(M1_,GeV) >> iunit(M2_,GeV) >> iunit(M3_,GeV)
>> iunit(mH12_,GeV2) >> iunit(mH22_,GeV2)
>> iunit(meL_,GeV) >> iunit(mmuL_,GeV) >> iunit(mtauL_,GeV)
>> iunit(meR_,GeV) >> iunit(mmuR_,GeV) >> iunit(mtauR_,GeV)
>> iunit(mq1L_,GeV) >> iunit(mq2L_,GeV) >> iunit(mq3L_,GeV)
>> iunit(mdR_,GeV) >> iunit(muR_,GeV) >> iunit(msR_,GeV)
>> iunit(mcR_,GeV) >> iunit(mbR_,GeV) >> iunit(mtR_,GeV)
- >> gluinoPhase_ >> tolerance_ >> iunit(MPlanck_,GeV);
+ >> gluinoPhase_ >> iunit(MPlanck_,GeV);
}
ClassDescription<SusyBase> SusyBase::initSusyBase;
// Definition of the static class description member.
void SusyBase::Init() {
static ClassDocumentation<SusyBase> documentation
("This is the base class for any SUSY model.",
"SUSY spectrum files follow the Les Houches accord"
" \\cite{Skands:2003cj,Allanach:2008qq}.",
" %\\cite{Skands:2003cj}\n"
"\\bibitem{Skands:2003cj}\n"
" P.~Skands {\\it et al.},\n"
" ``SUSY Les Houches accord: Interfacing SUSY spectrum calculators, decay\n"
" %packages, and event generators,''\n"
" JHEP {\\bf 0407}, 036 (2004)\n"
" [arXiv:hep-ph/0311123].\n"
" %%CITATION = JHEPA,0407,036;%%\n"
"%\\cite{Allanach:2008qq}\n"
"\\bibitem{Allanach:2008qq}\n"
" B.~Allanach {\\it et al.},\n"
" %``SUSY Les Houches Accord 2,''\n"
" Comput.\\ Phys.\\ Commun.\\ {\\bf 180}, 8 (2009)\n"
" [arXiv:0801.0045 [hep-ph]].\n"
" %%CITATION = CPHCB,180,8;%%\n"
);
- static Switch<SusyBase,bool> interfaceTopModes
- ("TopModes",
- "Whether ro use the Herwig++ SM top decays or those from the SLHA file",
- &SusyBase::topModesFromFile_, false, false, false);
- static SwitchOption interfaceTopModesFile
- (interfaceTopModes,
- "File",
- "Take the modes from the files",
- true);
- static SwitchOption interfaceTopModesHerwig
- (interfaceTopModes,
- "Herwig",
- "Use the SM ones",
- false);
static Reference<SusyBase,Helicity::AbstractVSSVertex> interfaceVertexWSS
("Vertex/WSFSF",
"Reference to Susy W SF SF vertex",
&SusyBase::WSFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFSVertex> interfaceVertexNFSF
("Vertex/NFSF",
"Reference to the neutralino-fermion-sfermion vertex",
&SusyBase::NFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFSVertex> interfaceVertexGFSF
("Vertex/GFSF",
"Reference to the gluino-fermion-sfermion vertex",
&SusyBase::GFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractSSSVertex> interfaceVertexHSFSF
("Vertex/HSFSF",
"Reference to the Higgs-fermion-sfermion vertex",
&SusyBase::HSFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFSVertex> interfaceVertexCFSF
("Vertex/CFSF",
"Reference to the chargino-fermion-sfermion vertex",
&SusyBase::CFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractVSSVertex> interfaceVertexGSFSF
("Vertex/GSFSF",
"Reference to the gluon-sfermion-sfermion vertex",
&SusyBase::GSFSFVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractVVSSVertex> interfaceVertexGGSS
("Vertex/GGSQSQ",
"Reference to the gluon-gluon-squark-squark vertex",
&SusyBase::GGSQSQVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexGSGSG
("Vertex/GSGSG",
"Reference to the gluon-gluino-gluino vertex",
&SusyBase::GSGSGVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexNNZ
("Vertex/NNZ",
"Reference to Z-~chi_i0-~chi_i0 vertex",
&SusyBase::NNZVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexNNP
("Vertex/NNP",
"Reference to photon-~chi_i0-~chi_i0 vertex",
&SusyBase::NNPVertex_, false, false, true, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexGNG
("Vertex/GNG",
"Reference to gluon-~chi_i0-gluino vertex",
&SusyBase::GNGVertex_, false, false, true, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexCCZ
("Vertex/CCZ",
"Reference to ~chi_i+-~chi_i-Z vertex",
&SusyBase::CCZVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFVVertex> interfaceVertexCNW
("Vertex/CNW",
"Reference to ~chi_i+-chi_i0-W vertex",
&SusyBase::CNWVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractFFSVertex> interfaceVertexGOGOH
("Vertex/GOGOH",
"Reference to the gaugino-gaugino-higgs vertex",
&SusyBase::GOGOHVertex_, false, false, true, false);
static Reference<SusyBase,Helicity::AbstractVSSVertex> interfaceVertexWHH
("Vertex/SSWHH",
"Reference to Susy WHHVertex",
&SusyBase::WHHVertex_, false, false, true, false);
static Reference<SusyBase,AbstractFFSVertex> interfaceVertexNCT
("Vertex/NCT",
"Vertex for the flavour violating coupling of the top squark "
"to the neutralino and charm quark.",
&SusyBase::NCTVertex_, false, false, true, false, false);
static Reference<SusyBase,AbstractRFSVertex> interfaceVertexGVNH
("Vertex/GVNH",
"Vertex for the interfaction of the gravitino-neutralino"
" and Higgs bosons",
&SusyBase::GVNHVertex_, false, false, true, true, false);
static Reference<SusyBase,AbstractRFVVertex> interfaceVertexGVNV
("Vertex/GVNV",
"Vertex for the interfaction of the gravitino-neutralino"
" and vector bosons",
&SusyBase::GVNVVertex_, false, false, true, true, false);
static Reference<SusyBase,AbstractRFSVertex> interfaceVertexGVFS
("Vertex/GVFS",
"Vertex for the interfaction of the gravitino-fermion"
" and sfermion",
&SusyBase::GVFSVertex_, false, false, true, true, false);
- static Parameter<SusyBase,double> interfaceBRTolerance
- ("BRTolerance",
- "Tolerance for the sum of branching ratios to be difference from one.",
- &SusyBase::tolerance_, 1e-6, 1e-8, 0.01,
- false, false, Interface::limited);
-
static Parameter<SusyBase,Energy> interfaceMPlanck
("MPlanck",
"The Planck mass for GMSB models",
&SusyBase::MPlanck_, GeV, 2.4e18*GeV, 1.e16*GeV, 1.e20*GeV,
false, false, Interface::limited);
}
void SusyBase::readSetup(istream & is) {
string filename = dynamic_ptr_cast<istringstream*>(&is)->str();
if(readFile_)
throw SetupException()
<< "A second SLHA file " << filename << " has been opened."
<< "This is probably unintended and as it can cause crashes"
<< " and other unpredictable behaviour it is not allowed."
<< Exception::runerror;
CFileLineReader cfile;
cfile.open(filename);
if( !cfile ) throw SetupException()
<< "SusyBase::readSetup - An error occurred in opening the "
<< "spectrum file \"" << filename << "\". A SUSY model cannot be "
<< "run without this."
<< Exception::runerror;
useMe();
- //Before reading the spectrum/decay files the SM higgs
- //decay modes, mass and width generators need to be turned off.
- PDPtr h0 = getParticleData(ParticleID::h0);
- h0->widthGenerator(WidthGeneratorPtr());
- h0->massGenerator(MassGenPtr());
- h0->width(ZERO);
- DecaySet::const_iterator dit = h0->decayModes().begin();
- DecaySet::const_iterator dend = h0->decayModes().end();
- for( ; dit != dend; ++dit ) {
- const InterfaceBase * ifb =
- BaseRepository::FindInterface(*dit, "BranchingRatio");
- ifb->exec(**dit, "set", "0.0");
- ifb = BaseRepository::FindInterface(*dit, "OnOff");
- ifb->exec(**dit, "set", "Off");
- }
- // if taking the top modes from the file
- // delete the SM stuff
- if(topModesFromFile_) {
- PDPtr top = getParticleData(ParticleID::t);
- top->widthGenerator(WidthGeneratorPtr());
- top->massGenerator(MassGenPtr());
- DecaySet::const_iterator dit = top->decayModes().begin();
- DecaySet::const_iterator dend = top->decayModes().end();
- for( ; dit != dend; ++dit ) {
- const InterfaceBase * ifb =
- BaseRepository::FindInterface(*dit, "BranchingRatio");
- ifb->exec(**dit, "set", "0.0");
- ifb = BaseRepository::FindInterface(*dit, "OnOff");
- ifb->exec(**dit, "set", "Off");
- }
- }
// read first line and check if this is a Les Houches event file
cfile.readline();
bool lesHouches = cfile.find("<LesHouchesEvents");
bool reading = !lesHouches;
if(lesHouches) cfile.readline();
//function pointer for putting all characters to lower case.
int (*pf)(int) = tolower;
do {
string line = cfile.getline();
// check for start of slha block in SLHA files
if(lesHouches && !reading) {
if(line.find("<slha")==0) reading = true;
if(!cfile.readline()) break;
continue;
}
// ignore comment lines
if(line[0] == '#') {
if(!cfile.readline()) break;
continue;
}
// make everything lower case
transform(line.begin(), line.end(), line.begin(), pf);
// start of a block
if(line.find("block") == 0) {
string name = StringUtils::car(StringUtils::cdr(line), " #");
name = StringUtils::stripws(name);
// mixing matrix
if((name.find("mix") != string::npos &&
name.find("hmix") != 0)) {
unsigned int row(0),col(0);
MixingVector vals = readMatrix(cfile,row,col);
mixings_[name] = make_pair(make_pair(row,col),vals);
}
else if(name.find("au") == 0 || name.find("ad") == 0 ||
name.find("ae") == 0 ) {
string test = StringUtils::car(line, "#");
while (test.find("=")!= string::npos) {
test = StringUtils::cdr(test, "=");
}
istringstream is(test);
double scale;
is >> scale;
unsigned int row(0),col(0);
MixingVector vals = readMatrix(cfile,row,col);
if(scale>1e10) continue;
mixings_[name] = make_pair(make_pair(row,col),vals);
}
else if( name.find("info") == string::npos) {
readBlock(cfile,name,line);
}
else {
if(!cfile.readline()) break;
}
continue;
}
- // decays
- else if( line.find("decay") == 0 ) {
- readDecay(cfile, line);
- continue;
- }
else if( lesHouches && line.find("</slha") == 0 ) {
reading = false;
break;
}
if(!cfile.readline()) break;
}
while(true);
// extract the relevant parameters
extractParameters();
// create the mixing matrices we need
createMixingMatrices();
// set the masses, this has to be done after the
// mixing matrices have been created
resetRepositoryMasses();
// have now read the file
+ if(decayFile()=="") decayFile(filename);
readFile_=true;
}
void SusyBase::readBlock(CFileLineReader & cfile,string name,string linein) {
if(!cfile)
throw SetupException()
<< "SusyBase::readBlock() - The input stream is in a bad state"
<< Exception::runerror;
// storage or the parameters
string test = StringUtils::car(linein, "#");
ParamMap store;
bool set = true;
// special for the alpha block
if(name.find("alpha") == 0 ) {
double alpha;
cfile.readline();
string line = cfile.getline();
istringstream iss(line);
iss >> alpha;
store.insert(make_pair(1,alpha));
}
else {
// extract the scale from the block if present
if(test.find("=")!= string::npos) {
while(test.find("=")!=string::npos)
test= StringUtils::cdr(test,"=");
istringstream is(test);
double scale;
is >> scale;
// only store the lowest scale block
if(parameters_.find(name)!=parameters_.end()) {
set = scale < parameters_[name][-1];
}
else {
store.insert(make_pair(-1,scale));
}
}
while(cfile.readline()) {
string line = cfile.getline();
// skip comments
if(line[0] == '#') continue;
// reached the end
if( line[0] == 'B' || line[0] == 'b' ||
line[0] == 'D' || line[0] == 'd' ||
line[0] == '<' ) {
cfile.resetline();
break;
}
istringstream is(line);
long index;
double value;
is >> index >> value;
store.insert(make_pair(index, value));
}
}
if(set) parameters_[name]=store;
}
-void SusyBase::readDecay(CFileLineReader & cfile,
- string decay) const{
- map<string,ParamMap>::const_iterator fit=parameters_.find("mass");
- if(fit==parameters_.end())
- throw Exception() << "SusyBase::readDecay() "
- << "BLOCK MASS not found in input file"
- << "it must be before the decays so the kinematics can be checked"
- << Exception::runerror;
- ParamMap theMasses = fit->second;
- if(!cfile)
- throw SetupException()
- <<"SusyBase::readDecay - The input stream is in a bad state";
- // extract parent PDG code and width
- long parent(0);
- Energy width(ZERO);
- istringstream iss(decay);
- string dummy;
- iss >> dummy >> parent >> iunit(width, GeV);
- PDPtr inpart = getParticleData(parent);
- if(!topModesFromFile_&&abs(parent)==ParticleID::t) {
- cfile.readline();
- return;
- }
- if(!inpart) throw SetupException()
- << "SusyBase::readDecay() - "
- << "A ParticleData object with the PDG code "
- << parent << " does not exist. "
- << Exception::runerror;
- inpart->width(width);
- if( width > ZERO ) inpart->cTau(hbarc/width);
- inpart->widthCut(5.*width);
- ParamMap::iterator it = theMasses.find(abs(inpart->id()));
- Energy inMass = it!=theMasses.end() ? abs(it->second*GeV) : inpart->mass();
- string prefix("decaymode " + inpart->name() + "->");
- double brsum(0.);
- unsigned int nmode = 0;
- while(cfile.readline()) {
- string line = cfile.getline();
- // skip comments
- if(line[0] == '#') continue;
- // reached the end
- if( line[0] == 'B' || line[0] == 'b' ||
- line[0] == 'D' || line[0] == 'd' ||
- line[0] == '<' ) {
- cfile.resetline();
- break;
- }
- // read the mode
- // get the branching ratio and no of decay products
- istringstream is(line);
- double brat(0.);
- unsigned int nda(0),npr(0);
- is >> brat >> nda;
- vector<tcPDPtr> products,bosons;
- Energy mout(ZERO),moutnoWZ(ZERO);
- string tag = prefix;
- while( true ) {
- long t;
- is >> t;
- if( is.fail() ) break;
- if( t == abs(parent) ) {
- throw SetupException()
- << "An error occurred while read a decay of the "
- << inpart->PDGName() << ". One of its products has the same PDG code "
- << "as the parent particle. Please check the SLHA file.\n"
- << Exception::runerror;
- }
- tcPDPtr p = getParticleData(t);
- if( !p ) {
- throw SetupException()
- << "SusyBase::readDecay() - An unknown PDG code has been encounterd "
- << "while reading a decay mode. ID: " << t
- << Exception::runerror;
- }
- ++npr;
- tag += p->name() + ",";
- ParamMap::iterator it = theMasses.find(abs(p->id()));
- Energy mass = it!=theMasses.end() ? abs(it->second*GeV) : p->mass();
- mout += mass;
- if(abs(p->id())==ParticleID::Wplus||p->id()==ParticleID::Z0) {
- bosons.push_back(p);
- }
- else {
- products.push_back(p);
- moutnoWZ += mass;
- }
- }
- if( npr != nda ) {
- throw SetupException()
- << "SusyBase::readDecay - While reading a decay of the "
- << inpart->PDGName() << " from an SLHA file, an inconsistency "
- << "between the number of decay products and the value in "
- << "the 'NDA' column was found. Please check if the spectrum "
- << "file is correct.\n"
- << Exception::warning;
- }
- if( npr > 1 ) {
- tag.replace(tag.size() - 1, 1, ";");
- // normal option
- if(mout<=inMass) {
- inpart->stable(false);
- brsum += brat;
- createDecayMode(tag, brat);
- }
- // no possible off-shell gauge bosons throw it away
- else if(bosons.empty() || bosons.size()>2 ||
- moutnoWZ>=inMass) {
- cerr << "SusyBase::readDecay() "
- << "The decay " << tag << " cannot proceed for on-shell "
- << "particles, skipping it.\n";
- }
- else {
- Energy maxMass = inMass - moutnoWZ;
- string newTag = prefix;
- for(unsigned int ix=0;ix<products.size();++ix)
- newTag += products[ix]->name() + ",";
- if(bosons.size()==1) {
- cerr << "SusyBase::readDecay() "
- << "The decay " << tag << " cannot proceed for on-shell\n"
- << "particles, replacing gauge boson with its decay products\n";
- vector<pair<double,string> > modes =
- createWZDecayModes(newTag,brat,bosons[0],maxMass);
- for(unsigned int ix=0;ix<modes.size();++ix) {
- modes[ix].second.replace(modes[ix].second.size() - 1, 1, ";");
- createDecayMode(modes[ix].second,modes[ix].first);
- brsum += modes[ix].first;
- }
- }
- else if(bosons.size()==2) {
- bool identical = bosons[0]->id()==bosons[1]->id();
- if(maxMass>bosons[0]->mass()&&maxMass>bosons[1]->mass()) {
- cerr << "SusyBase::readDecay() "
- << "The decay " << tag << " cannot proceed for on-shell\n"
- << "particles, replacing one of the gauge bosons"
- << " with its decay products\n";
- unsigned int imax = identical ? 1 : 2;
- if(imax==2) brat *= 0.5;
- for(unsigned int ix=0;ix<imax;++ix) {
- string newTag2 = newTag+bosons[ix]->name()+',';
- unsigned int iother = ix==0 ? 1 : 0;
- vector<pair<double,string> > modes =
- createWZDecayModes(newTag2,brat,bosons[iother],maxMass);
- for(unsigned int ix=0;ix<modes.size();++ix) {
- modes[ix].second.replace(modes[ix].second.size() - 1, 1, ";");
- createDecayMode(modes[ix].second,modes[ix].first);
- brsum += modes[ix].first;
- }
- }
- }
- else {
- cerr << "SusyBase::readDecay() "
- << "The decay " << tag << " cannot proceed for on-shell\n"
- << "particles, and has too many off-shell gauge bosons,"
- << " skipping it.\n";
- }
- }
- else {
- cerr << "SusyBase::readDecay() "
- << "The decay " << tag << " cannot proceed for on-shell\n"
- << "particles, and has too many outgoing gauge bosons skipping it.\n";
- }
- }
- }
- }
- if( abs(brsum - 1.) > tolerance_ && nmode!=0 ) {
- cerr << "Warning: The total branching ratio for " << inpart->PDGName()
- << " from the spectrum file does not sum to 1. The branching fractions"
- << " will be rescaled.\n";
- cerr << setprecision(13) << abs(brsum - 1.) << "\n";
- }
-}
-
const MixingVector
SusyBase::readMatrix(CFileLineReader & cfile,
unsigned int & row, unsigned int & col) {
if(!cfile)
throw SetupException()
<< "SusyBase::readMatrix() - The input stream is in a bad state."
<< Exception::runerror;
unsigned int rowmax(0), colmax(0);
MixingVector values;
while(cfile.readline()) {
string line = cfile.getline();
// skip comments
if(line[0] == '#') continue;
// reached the end
if( line[0] == 'B' || line[0] == 'b' ||
line[0] == 'D' || line[0] == 'd' ||
line[0] == '<' ) {
cfile.resetline();
break;
}
istringstream is(line);
unsigned int index1, index2;
double real(0.), imag(0.);
is >> index1 >> index2 >> real >> imag;
values.push_back(MixingElement(index1,index2,Complex(real, imag)));
if(index1 > rowmax) rowmax = index1;
if(index2 > colmax) colmax = index2;
}
col=colmax;
row=rowmax;
return values;
}
-void SusyBase::createDecayMode(string tag, double brat) const {
- ostringstream cmd;
- cmd << tag << string(" ")
- << setprecision(13) << brat << string(" 1 /Herwig/Decays/Mambo");
- Repository::exec(cmd.str(), cerr);
-}
-
void SusyBase::createMixingMatrix(MixingMatrixPtr & matrix,
string name, const MixingVector & values,
MatrixSize size) {
matrix = new_ptr(MixingMatrix(size.first,size.second));
for(unsigned int ix=0; ix < values.size(); ++ix)
(*matrix)(values[ix].row-1,values[ix].col-1) = values[ix].value;
if(name == "nmix") {
vector<long> ids(4);
ids[0] = 1000022; ids[1] = 1000023;
ids[2] = 1000025; ids[3] = 1000035;
matrix->setIds(ids);
}
else if(name == "nmnmix") {
vector<long> ids(5);
ids[0] = 1000022; ids[1] = 1000023;
ids[2] = 1000025; ids[3] = 1000035;
ids[4] = 1000045;
matrix->setIds(ids);
}
else if(name == "umix") {
vector<long> ids(2);
ids[0] = 1000024; ids[1] = 1000037;
matrix->setIds(ids);
}
else if(name == "vmix") {
vector<long> ids(2);
ids[0] = 1000024; ids[1] = 1000037;
matrix->setIds(ids);
}
else if(name == "stopmix") {
vector<long> ids(2);
ids[0] = 1000006; ids[1] = 2000006;
matrix->setIds(ids);
}
else if(name == "sbotmix") {
vector<long> ids(2);
ids[0] = 1000005; ids[1] = 2000005;
matrix->setIds(ids);
}
else if(name == "staumix") {
vector<long> ids(2);
ids[0] = 1000015; ids[1] = 2000015;
matrix->setIds(ids);
}
else if(name == "nmhmix") {
vector<long> ids(3);
ids[0] = 25; ids[1] = 35; ids[2] = 45;
matrix->setIds(ids);
}
else if(name == "nmamix") {
vector<long> ids(2);
ids[0] = 36; ids[1] = 46;
matrix->setIds(ids);
}
else
throw SetupException() << "Cannot find correct title for mixing matrix "
<< name << Exception::runerror;
}
void SusyBase::resetRepositoryMasses() {
map<string,ParamMap>::const_iterator fit=parameters_.find("mass");
if(fit==parameters_.end())
throw Exception() << "BLOCK MASS not found in input file"
<< " can't set masses of SUSY particles"
<< Exception::runerror;
ParamMap theMasses = fit->second;
for(ParamMap::iterator it = theMasses.begin(); it != theMasses.end();
++it) {
long id = it->first;
double mass = it->second;
//a negative mass requires an adjustment to the
//associated mixing matrix by a factor of i
if(mass < 0.0) adjustMixingMatrix(id);
PDPtr part = getParticleData(id);
if(!part) throw SetupException()
<< "SusyBase::resetRepositoryMasses() - Particle with PDG code " << id
<< " not found." << Exception::warning;
//Find interface nominal mass interface
const InterfaceBase * ifb = BaseRepository::FindInterface(part, "NominalMass");
ostringstream os;
os << abs(it->second);
ifb->exec(*part, "set", os.str());
// switch on gravitino interactions?
gravitino_ |= id== ParticleID::SUSY_Gravitino;
}
theMasses.clear();
}
void SusyBase::adjustMixingMatrix(long id) {
//get correct mixing matrix
switch(id) {
case 1000021 :
gluinoPhase_ = Complex(0.,1.);
break;
case 1000022 :
case 1000023 :
case 1000025 :
case 1000035 :
case 1000045 :
if(NMix_)
NMix_->adjustPhase(id);
else
throw SetupException() << "SusyBase::adjustMixingMatrix - "
<< "The neutralino mixing matrix pointer "
<< "is null!" << Exception::runerror;
break;
case 1000024 :
case 1000037 :
if(UMix_)
UMix_->adjustPhase(id);
else
throw SetupException() << "SusyBase::adjustMixingMatrix - "
<< "The U-Type chargino mixing matrix pointer "
<< "is null!" << Exception::runerror;
if(VMix_)
VMix_->adjustPhase(id);
else
throw SetupException() << "SusyBase::adjustMixingMatrix - "
<< "The V-Type chargino mixing matrix pointer "
<< "is null!" << Exception::runerror;
break;
default :
throw SetupException()
<< "SusyBase::adjustMixingMatrix - Trying to adjust mixing matrix "
<< "phase for a particle that does not have a mixing matrix "
<< "associated with it. " << id << " must have a negative mass in "
<< "the spectrum file, this should only occur for particles that mix."
<< Exception::runerror;
}
}
void SusyBase::createMixingMatrices() {
map<string,pair<MatrixSize, MixingVector > >::const_iterator it;
for(it=mixings_.begin();it!=mixings_.end();++it) {
string name=it->first;
// create the gaugino mixing matrices
if(name == "nmix" || name == "nmnmix" ){
createMixingMatrix(NMix_,name,it->second.second,it->second.first);
}
else if (name == "umix" ) {
createMixingMatrix(UMix_,name,it->second.second,it->second.first);
}
else if (name == "vmix") {
createMixingMatrix(VMix_,name,it->second.second,it->second.first);
}
}
}
void SusyBase::extractParameters(bool checkmodel) {
map<string,ParamMap>::const_iterator pit;
ParamMap::const_iterator it;
// try and get tan beta from extpar first
pit=parameters_.find("extpar");
// extract tan beta
tanBeta_ = -1.;
if(pit!=parameters_.end()) {
it = pit->second.find(25);
if(it!=pit->second.end()) tanBeta_ = it->second;
}
// otherwise from minpar
if(tanBeta_<0.) {
pit=parameters_.find("minpar");
if(pit!=parameters_.end()) {
it = pit->second.find(3);
if(it!=pit->second.end()) tanBeta_ = it->second;
}
}
if(tanBeta_<0.)
throw Exception() << "Can't find tan beta in BLOCK MINPAR"
<< " or BLOCK EXTPAR " << Exception::runerror;
// extract parameters from hmix
pit=parameters_.find("hmix");
if(pit==parameters_.end()) {
cerr << "BLOCK HMIX not found setting mu to zero\n";
mu_=ZERO;
}
else {
it = pit->second.find(1);
if(it==pit->second.end()) {
cerr << "mu not found in BLOCK HMIX setting to zero\n";
}
else {
mu_=it->second*GeV;
}
}
pit = parameters_.find("msoft");
if( pit == parameters_.end() )
throw Exception() << "BLOCK MSOFT not found in "
<< "SusyBase::extractParameters()"
<< Exception::runerror;
M1_ = pit->second.find(1 )->second*GeV;
M2_ = pit->second.find(2 )->second*GeV;
M3_ = pit->second.find(3 )->second*GeV;
mH12_ = pit->second.find(21)->second*GeV2;
mH22_ = pit->second.find(22)->second*GeV2;
meL_ = pit->second.find(31)->second*GeV;
mmuL_ = pit->second.find(32)->second*GeV;
mtauL_ = pit->second.find(33)->second*GeV;
meR_ = pit->second.find(34)->second*GeV;
mmuR_ = pit->second.find(35)->second*GeV;
mtauR_ = pit->second.find(36)->second*GeV;
mq1L_ = pit->second.find(41)->second*GeV;
mq2L_ = pit->second.find(42)->second*GeV;
mq3L_ = pit->second.find(43)->second*GeV;
muR_ = pit->second.find(44)->second*GeV;
mcR_ = pit->second.find(45)->second*GeV;
mtR_ = pit->second.find(46)->second*GeV;
mdR_ = pit->second.find(47)->second*GeV;
msR_ = pit->second.find(48)->second*GeV;
mbR_ = pit->second.find(49)->second*GeV;
if(checkmodel) {
throw Exception() << "The SusyBase class should not be used as a "
<< "Model class, use one of the models which inherit"
<< " from it" << Exception::runerror;
}
}
-
-vector<pair<double,string> >
-SusyBase::createWZDecayModes(string tag, double brat,
- tcPDPtr boson, Energy maxMass) const {
- vector<pair<double,string> > modes;
- double sum(0.);
- for(DecaySet::const_iterator dit=boson->decayModes().begin();
- dit!=boson->decayModes().end();++dit) {
- tcDMPtr mode = *dit;
- if(!mode->on()) continue;
- string extra;
- Energy outMass(ZERO);
- for(ParticleMSet::const_iterator pit=mode->products().begin();
- pit!=mode->products().end();++pit) {
- extra += (**pit).name() + ",";
- outMass += (**pit).mass();
- }
- if(outMass<maxMass) {
- sum += mode->brat();
- modes.push_back(make_pair(mode->brat(),tag+extra));
- }
- }
- for(unsigned int ix=0;ix<modes.size();++ix)
- modes[ix].first *= brat/sum;
- return modes;
-}
diff --git a/Models/Susy/SusyBase.h b/Models/Susy/SusyBase.h
--- a/Models/Susy/SusyBase.h
+++ b/Models/Susy/SusyBase.h
@@ -1,724 +1,688 @@
// -*- C++ -*-
//
// SusyBase.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_SusyBase_H
#define HERWIG_SusyBase_H
//
// This is the declaration of the SusyBase class.
//
-#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "Herwig++/Models/General/BSMModel.h"
#include "MixingMatrix.h"
#include "ThePEG/Utilities/CFileLineReader.h"
#include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractRFSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractRFVVertex.h"
#include "SusyBase.fh"
namespace Herwig {
using namespace ThePEG;
/*@name Some convenient typedefs. */
//@{
/**
* Map to hold key, parameter pairs.
*/
typedef map<long, double> ParamMap;
//@}
/** \ingroup Models
* This class is designed to be a base class for SUSY models. There is
* an interface to set the name of the spectrum file to read in
* the necessary parameters for a SUSY model.
*
* @see \ref SusyBaseInterfaces "The interfaces"
* defined for SusyBase.
* @see StandardModel
*/
-class SusyBase: public StandardModel {
+class SusyBase: public BSMModel {
public:
/**
* The default constructor.
*/
SusyBase();
public:
/** @name Access functions. */
//@{
/**
* Value of \f$\tan\beta\f$.
*/
double tanBeta() const { return tanBeta_; }
/**
* Value of \f$\mu\f$ parameter.
*/
Energy muParameter() const { return mu_; }
/**
* The neutralino mixing matrix
*/
const MixingMatrixPtr & neutralinoMix() const {
return NMix_;
}
/**
* The U-type chargino mixing matrix
*/
const MixingMatrixPtr & charginoUMix() const {
return UMix_;
}
/**
* The V-type chargino mixing matrix
*/
const MixingMatrixPtr & charginoVMix() const {
return VMix_;
}
/**
* The phase for gluino vertices
*/
const Complex & gluinoPhase() const {return gluinoPhase_;}
//@}
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();
public:
/**
* Soft breaking parameters
*/
//@{
/**
* The bilinear breaking mass term for the bino
*/
const Energy & M1() const {return M1_;}
/**
* The bilinear breaking mass term for the wino
*/
const Energy & M2() const {return M2_;}
/**
* The bilinear breaking mass term for the gluinos
*/
const Energy & M3() const {return M3_;}
/**
* The soft breaking mass squared for \f$H_1\f$
*/
const Energy2 & Mh12() const {return mH12_;}
/**
* The soft breaking mass squared for \f$H_2\f$
*/
const Energy2 & Mh22() const {return mH22_;}
/**
* Soft breaking mass for the first generation lepton doublet
*/
const Energy & MeL() const {return meL_;}
/**
* Soft breaking mass for the second generation lepton doublet
*/
const Energy & MmuL() const {return mmuL_;}
/**
* Soft breaking mass for the third generation lepton doublet
*/
const Energy & MtauL() const {return mtauL_;}
/**
* Soft breaking mass for the first generation lepton singlet
*/
const Energy & MeR() const {return meR_;}
/**
* Soft breaking mass for the second generation lepton singlet
*/
const Energy & MmuR() const {return mmuR_;}
/**
* Soft breaking mass for the third generation lepton singlet
*/
const Energy & MtauR() const {return mtauR_;}
/**
* Soft breaking mass for the first generation quark doublet
*/
const Energy & Mq1L() const {return mq1L_;}
/**
* Soft breaking mass for the second generation quark doublet
*/
const Energy & Mq2L() const {return mq2L_;}
/**
* Soft breaking mass for the third generation quark doublet
*/
const Energy & Mq3L() const {return mq3L_;}
/**
* Soft breaking mass for the down singlet
*/
const Energy & MdR() const {return mdR_;}
/**
* Soft breaking mass for the up singlet
*/
const Energy & MuR() const {return muR_;}
/**
* Soft breaking mass for the strange singlet
*/
const Energy & MsR() const {return msR_;}
/**
* Soft breaking mass for the charm singlet
*/
const Energy & McR() const {return mcR_;}
/**
* Soft breaking mass for the bottom singlet
*/
const Energy & MbR() const {return mbR_;}
/**
* Soft breaking mass for the top singlet
*/
const Energy & MtR() const {return mtR_;}
//@}
/**
* Planck mass
*/
const Energy & MPlanck() const {return MPlanck_;}
protected:
/**
* Function to read information from a setup file.
* @param is istream object to read file.
*/
virtual void readSetup(istream & is);
private:
/**@name Functions to help file read-in. */
//@{
/**
* Read block from LHA file
* @param ifs input stream containg data
* @param name The name of the block
* @param line The line defining the block
*/
void readBlock(CFileLineReader & ifs,string name,string line);
/**
* Function to read mixing matrix from LHA file
* @param ifs input stream containg data
* @param row Number of rows
* @param col Number of columns
*/
const MixingVector readMatrix(CFileLineReader & ifs, unsigned int & row,
unsigned int & col);
- /**
- * Read decaymodes from LHA file
- * @param ifs input stream containg data
- * @param decay string containing name of parent and value of total width
- */
- void readDecay(CFileLineReader & ifs, string decay) const;
-
- /**
- * Create a DecayMode object in the repository
- * @param tag The tag identifying the decay mode including the prefix
- * 'decaymode'
- * @param brat Branching ratio of this mode
- */
- void createDecayMode(string tag, double brat) const;
-
- /**
- * Create a DecayMode object in the repository
- * @param tag The tag identifying the decay mode including the prefix
- * 'decaymode'
- * @param brat Branching ratio of this mode
- */
- vector<pair<double,string> > createWZDecayModes(string tag, double brat,
- tcPDPtr boson,
- Energy maxMass) const;
-
protected:
/**
* Create the mixing matrices for the model
*/
virtual void createMixingMatrices();
/**
* Extract the parameters from the input blocks
*/
virtual void extractParameters(bool checkmodel=true);
/**
* Create a object MixingMatrix in the repository
* @param matrix Pointer to the mixing matrix
* @param name Name of the mixing matrix, i.e. nmix, umix...
* @param values Value of each entry in the matrix
* @param size The size of the matrix
*/
void createMixingMatrix(MixingMatrixPtr & matrix, string name,
const MixingVector & values,
MatrixSize size);
/**
* Reset masses in the repository to values read from LHA file.
*/
void resetRepositoryMasses();
/**
* Adjust row of Mixing Matrix if a negative mass occurs in LHA file
* @param id The PDG code of the particle with a negative mass
*/
virtual void adjustMixingMatrix(long id);
//@}
/**
* Access to the mixings and parameters for the inheriting classes
*/
//@{
/**
* Parameter blocks
*/
const map<string,ParamMap> & parameters() const {
return parameters_;
}
/**
* Mixing blocks
*/
const map<string,pair<MatrixSize,MixingVector> > & mixings() const {
return mixings_;
}
//@}
/**
* Reset neutralino mixing matrix
*/
void neutralinoMix(MixingMatrixPtr nm) { NMix_ = nm; }
/**
* Reset the U-type chargino mixing matrix
*/
void charginoUMix(MixingMatrixPtr um) { UMix_ = um; }
/**
* Reset the V-type chargino mixing matrix
*/
void charginoVMix(MixingMatrixPtr vm) { VMix_ = vm; }
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 static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<SusyBase> initSusyBase;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
SusyBase & operator=(const SusyBase &);
private:
/**
* Whether or not the SLHA fiel has been read
*/
bool readFile_;
/**
- * Whether or not to replace the top decay modes with those from
- * the SLHA files
- */
- bool topModesFromFile_;
-
- /**
- * Tolerance for branching ratios
- */
- double tolerance_;
-
- /**
* Planck mass needed in GMSB models
*/
Energy MPlanck_;
/**
* Whether or not to include gravitino interactions
*/
bool gravitino_;
/*
* Storage of the parameters.
*/
//@{
/**
* Parameter blocks
*/
map<string,ParamMap> parameters_;
/**
* Mixing blocks
*/
map<string,pair<MatrixSize, MixingVector> > mixings_;
/**
* \f$\tan\beta\f$
*/
double tanBeta_;
/**
* \f$\mu\f$
*/
Energy mu_;
//@}
/**
* Soft breaking parameters
*/
//@{
/**
* The bilinear breaking mass term for the bino
*/
Energy M1_;
/**
* The bilinear breaking mass term for the wino
*/
Energy M2_;
/**
* The bilinear breaking mass term for the gluinos
*/
Energy M3_;
/**
* The soft breaking mass squared for \f$H_1\f$
*/
Energy2 mH12_;
/**
* The soft breaking mass squared for \f$H_2\f$
*/
Energy2 mH22_;
/**
* Soft breaking mass for the first generation lepton doublet
*/
Energy meL_;
/**
* Soft breaking mass for the second generation lepton doublet
*/
Energy mmuL_;
/**
* Soft breaking mass for the third generation lepton doublet
*/
Energy mtauL_;
/**
* Soft breaking mass for the first generation lepton singlet
*/
Energy meR_;
/**
* Soft breaking mass for the second generation lepton singlet
*/
Energy mmuR_;
/**
* Soft breaking mass for the third generation lepton singlet
*/
Energy mtauR_;
/**
* Soft breaking mass for the first generation quark doublet
*/
Energy mq1L_;
/**
* Soft breaking mass for the second generation quark doublet
*/
Energy mq2L_;
/**
* Soft breaking mass for the third generation quark doublet
*/
Energy mq3L_;
/**
* Soft breaking mass for the down singlet
*/
Energy mdR_;
/**
* Soft breaking mass for the up singlet
*/
Energy muR_;
/**
* Soft breaking mass for the strange singlet
*/
Energy msR_;
/**
* Soft breaking mass for the charm singlet
*/
Energy mcR_;
/**
* Soft breaking mass for the bottom singlet
*/
Energy mbR_;
/**
* Soft breaking mass for the top singlet
*/
Energy mtR_;
//@}
/**
* Phase for the gluino
*/
Complex gluinoPhase_;
/**
* Neutralino and Chargino mixing matrices
*/
//@{
/**
* Store pointers to the gaugino mixing matrices
*/
//@{
/**
* The neutralino mixing matrix
*/
MixingMatrixPtr NMix_;
/**
* The \f$U\f$ mixing matrix for the charginos
*/
MixingMatrixPtr UMix_;
/**
* The \f$V\f$ mixing matrix for the charginos
*/
MixingMatrixPtr VMix_;
//@}
/**@name Vertex pointers. */
//@{
/**
* Pointer to the gauge boson sfermion-sfermion vertex
*/
AbstractVSSVertexPtr WSFSFVertex_;
/**
* Pointer to the neutralino-fermion-sfermion vertex
*/
AbstractFFSVertexPtr NFSFVertex_;
/**
* Pointer to the gluino-fermion-sfermion coupling
*/
AbstractFFSVertexPtr GFSFVertex_;
/**
* Pointer to the Higgs-sfermion-sfermion vertex
*/
AbstractSSSVertexPtr HSFSFVertex_;
/**
* Pointer to the \f$\tilde{\chi}^+\f$-fermion-sfermion vertex
*/
AbstractFFSVertexPtr CFSFVertex_;
/**
* Pointer to the gluon-sfermion-sfermion vertex
*/
AbstractVSSVertexPtr GSFSFVertex_;
/**
* Pointer to the gluon-gluon-squark-squark vertex;
*/
AbstractVVSSVertexPtr GGSQSQVertex_;
/**
* Pointer to the gluon-gluino-gluino vertex
*/
AbstractFFVVertexPtr GSGSGVertex_;
/**
* Pointer to the gluino-neutralino-gluon vertex
*/
AbstractFFVVertexPtr GNGVertex_;
/**
* Pointer to the neutralino-neutralino-Z vertex
*/
AbstractFFVVertexPtr NNZVertex_;
/**
* Pointer to the neutralino-neutralino-photon vertex
*/
AbstractFFVVertexPtr NNPVertex_;
/**
* Pointer to the vertex chargino-chargino-Z vertex
*/
AbstractFFVVertexPtr CCZVertex_;
/**
* Pointer to the vertex chargino-neutralino-Z vertex
*/
AbstractFFVVertexPtr CNWVertex_;
/**
* Pointer to the vertex gaugino-gaugino-higgs vertex
*/
AbstractFFSVertexPtr GOGOHVertex_;
/**
* Pointer to the vertex for a gauge boson and higgs
*/
AbstractVSSVertexPtr WHHVertex_;
/**
* Pointer to the vertex for flavour changing stop decay
*/
AbstractFFSVertexPtr NCTVertex_;
/**
* Pointer to the vertex for gravitino-neutralino vector boson
*/
AbstractRFVVertexPtr GVNVVertex_;
/**
* Pointer to the vertex for gravitino-neutralino Higgs boson
*/
AbstractRFSVertexPtr GVNHVertex_;
/**
* Pointer to the vertex for gravitino-fermion sfermion
*/
AbstractRFSVertexPtr GVFSVertex_;
//@}
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of SusyBase. */
template <>
struct BaseClassTrait<Herwig::SusyBase,1> {
/** Typedef of the first base class of SusyBase. */
- typedef Herwig::StandardModel NthBase;
+ typedef Herwig::BSMModel NthBase;
};
/** This template specialization informs ThePEG about the name of
* the SusyBase class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::SusyBase>
: public ClassTraitsBase<Herwig::SusyBase> {
/** Return a platform-independent class name */
static string className() { return "Herwig::SusyBase"; }
/**
* The name of a file containing the dynamic library where the class
* SusyBase is implemented. It may also include several, space-separated,
* libraries if the class SusyBase depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwSusy.so"; }
};
/** @endcond */
}
#endif /* HERWIG_SusyBase_H */
diff --git a/Models/UED/UEDBase.cc b/Models/UED/UEDBase.cc
--- a/Models/UED/UEDBase.cc
+++ b/Models/UED/UEDBase.cc
@@ -1,425 +1,425 @@
// -*- C++ -*-
//
// UEDBase.cc is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the UEDBase class.
//
#include "UEDBase.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Repository/Repository.h"
#include "ThePEG/Repository/CurrentGenerator.h"
using namespace Herwig;
UEDBase::UEDBase() : theRadCorr(true), theInvRadius(500.*GeV),
theLambdaR(20.), theMbarH(), theSinThetaOne(0.),
theVeV(246.*GeV) {}
void UEDBase::doinit() {
- StandardModel::doinit();
+ BSMModel::doinit();
//level-1 masses and mixing angle
calculateKKMasses(1);
writeSpectrum();
//add the level-1 vertices.
addVertex(theF1F1Z0Vertex);
addVertex(theF1F1G0Vertex);
addVertex(theF1F0G1Vertex);
addVertex(theG1G1G0Vertex);
addVertex(theG0G0G1G1Vertex);
addVertex(theF1F1P0Vertex);
addVertex(theF1F1W0Vertex);
addVertex(theF1F0W1Vertex);
addVertex(theF1F0H1Vertex);
addVertex(theP0H1H1Vertex);
addVertex(theZ0H1H1Vertex);
addVertex(theW0A1H1Vertex);
addVertex(theZ0A1h1Vertex);
addVertex(theW0W1W1Vertex);
}
void UEDBase::persistentOutput(PersistentOStream & os) const {
os << theRadCorr << ounit(theInvRadius, GeV) << theLambdaR
<< theF1F1Z0Vertex << theF1F1G0Vertex << theF1F0G1Vertex
<< theG1G1G0Vertex << theG0G0G1G1Vertex << theF1F1P0Vertex
<< theF1F1W0Vertex << theF1F0W1Vertex << theF1F0H1Vertex
<< theP0H1H1Vertex << theZ0H1H1Vertex << theW0A1H1Vertex
<< theZ0A1h1Vertex << theW0W1W1Vertex << ounit(theVeV,GeV)
<< ounit(theMbarH, GeV) << theSinThetaOne;
}
void UEDBase::persistentInput(PersistentIStream & is, int) {
is >> theRadCorr >> iunit(theInvRadius, GeV) >> theLambdaR
>> theF1F1Z0Vertex >> theF1F1G0Vertex >> theF1F0G1Vertex
>> theG1G1G0Vertex >> theG0G0G1G1Vertex >> theF1F1P0Vertex
>> theF1F1W0Vertex >> theF1F0W1Vertex >> theF1F0H1Vertex
>> theP0H1H1Vertex >> theZ0H1H1Vertex >> theW0A1H1Vertex
>> theZ0A1h1Vertex >> theW0W1W1Vertex >> iunit(theVeV,GeV)
>> iunit(theMbarH, GeV) >> theSinThetaOne;
}
ClassDescription<UEDBase> UEDBase::initUEDBase;
// Definition of the static class description member.
void UEDBase::Init() {
static ClassDocumentation<UEDBase> documentation
("This class implements/stores the necessary information for the simulation"
" of a Universal Extra Dimensions model.",
"Universal extra dimensions model based on \\cite{Cheng:2002iz,Appelquist:2000nn}.",
"%\\cite{Cheng:2002iz}\n"
"\\bibitem{Cheng:2002iz}\n"
" H.~C.~Cheng, K.~T.~Matchev and M.~Schmaltz,\n"
" ``Radiative corrections to Kaluza-Klein masses,''\n"
" Phys.\\ Rev.\\ D {\\bf 66}, 036005 (2002)\n"
" [arXiv:hep-ph/0204342].\n"
" %%CITATION = PHRVA,D66,036005;%%\n"
"%\\cite{Appelquist:2000nn}\n"
"\\bibitem{Appelquist:2000nn}\n"
" T.~Appelquist, H.~C.~Cheng and B.~A.~Dobrescu,\n"
" ``Bounds on universal extra dimensions,''\n"
" Phys.\\ Rev.\\ D {\\bf 64}, 035002 (2001)\n"
" [arXiv:hep-ph/0012100].\n"
" %%CITATION = PHRVA,D64,035002;%%\n"
);
static Switch<UEDBase,bool> interfaceRadiativeCorrections
("RadiativeCorrections",
"Calculate the radiative corrections to the masses",
&UEDBase::theRadCorr, true, false, false);
static SwitchOption interfaceRadiativeCorrectionsYes
(interfaceRadiativeCorrections,
"Yes",
"Calculate the radiative corrections to the masses",
true);
static SwitchOption interfaceRadiativeCorrectionsNo
(interfaceRadiativeCorrections,
"No",
"Leave the masses of the KK particles as n/R",
false);
static Parameter<UEDBase,Energy> interfaceInverseRadius
("InverseRadius",
"The inverse radius of the compactified dimension ",
&UEDBase::theInvRadius, GeV, 500.*GeV, ZERO, ZERO,
true, false, Interface::nolimits);
static Parameter<UEDBase,double> interfaceLambdaR
("LambdaR",
"The product of the cut-off scale and the radius of compactification",
&UEDBase::theLambdaR, 20.0, 0.0, 0,
false, false, Interface::lowerlim);
static Parameter<UEDBase,Energy> interfaceBoundaryMass
("HiggsBoundaryMass",
"The boundary mass for the Higgs",
&UEDBase::theMbarH, GeV, ZERO, ZERO, ZERO,
false, false, Interface::lowerlim);
static Parameter<UEDBase,Energy> interfaceVeV
("HiggsVEV",
"The vacuum expectation value of the Higgs field",
&UEDBase::theVeV, GeV, 246.*GeV, ZERO, ZERO,
true, false, Interface::nolimits);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F1Z
("Vertex/F1F1Z",
"The F1F1Z UED Vertex",
&UEDBase::theF1F1Z0Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F1G0
("Vertex/F1F1G0",
"The F1F1G UED Vertex",
&UEDBase::theF1F1G0Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F0G1
("Vertex/F1F0G1",
"The F1F0G0 UED Vertex",
&UEDBase::theF1F0G1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVVVVertex> interfaceG1G1G0
("Vertex/G1G1G0",
"The G1G1G0 UED Vertex",
&UEDBase::theG1G1G0Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVVVVVertex> interfaceG0G0G1G1
("Vertex/G0G0G1G1",
"The G0G0G1G1 UED Vertex",
&UEDBase::theG0G0G1G1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F1P
("Vertex/F1F1P",
"The F1F1P UED Vertex",
&UEDBase::theF1F1P0Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F1W
("Vertex/F1F1W",
"The F1F1W UED Vertex",
&UEDBase::theF1F1W0Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFVVertex> interfaceF1F0W1
("Vertex/F1F0W1",
"The F1F0W1 UED Vertex",
&UEDBase::theF1F0W1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractFFSVertex> interfaceF1F0H1
("Vertex/F1F0H1",
"The F1F0H1 UED Vertex",
&UEDBase::theF1F0H1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVSSVertex> interfaceP0H1H1
("Vertex/P0H1H1",
"The P0H1H1 UED Vertex",
&UEDBase::theP0H1H1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVSSVertex> interfaceZ0H1H1
("Vertex/Z0H1H1",
"The Z0H1H1 UED Vertex",
&UEDBase::theZ0H1H1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVSSVertex> interfaceW0A1H1
("Vertex/W0A1H1",
"The W0A1H1 UED Vertex",
&UEDBase::theW0A1H1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVSSVertex> interfaceZ0A1h1
("Vertex/Z0A1h1",
"The W0A1H1 UED Vertex",
&UEDBase::theZ0A1h1Vertex, false, false, true, false, false);
static Reference<UEDBase,Helicity::AbstractVVVVertex> interfaceW0W1W1
("Vertex/W0W1W1",
"The W0W1W1 UED Vertex",
&UEDBase::theW0W1W1Vertex, false, false, true, false, false);
}
void UEDBase::calculateKKMasses(const unsigned int n) {
useMe();
if(n == 0)
throw InitException() << "UEDBase::resetKKMasses - "
<< "Trying to reset masses with KK number == 0!"
<< Exception::warning;
if(theRadCorr) {
fermionMasses(n);
bosonMasses(n);
}
else {
cerr <<
"Warning: Radiative corrections to particle masses have been "
"turned off.\n The masses will be set to (n/R + m_sm)^1/2 and "
"the spectrum will be\n highly degenerate so that no decays "
"will occur.\n This is only meant to be used for debugging "
"purposes.\n";
//set masses to tree level for each kk mode
long level1 = 5000000 + n*100000;
long level2 = 6000000 + n*100000;
Energy2 ndmass2 = sqr(n*theInvRadius);
for ( int i = 1; i < 38; ++i ) {
if(i == 7 || i == 17) i += 4;
if(i == 26) i += 10;
Energy kkmass = sqrt( ndmass2 + sqr(getParticleData(i)->mass()) );
resetMass(level1 + i, kkmass);
if( i < 7 || i == 11 || i == 13 || i == 15 )
resetMass(level2 + i, kkmass);
}
}
}
void UEDBase::bosonMasses(const unsigned int n) {
// Common constants
const Energy2 invRad2 = theInvRadius*theInvRadius;
const double g_em2 = 4.*Constants::pi*alphaEM(invRad2);
const double g_s2 = 4.*Constants::pi*alphaS(invRad2);
const double g_W2 = g_em2/sin2ThetaW();
//Should probably use a function to calculate zeta.
const double zeta3 = 1.20206;
const Energy2 nmass2 = sqr(n*theInvRadius);
const double pi2 = sqr(Constants::pi);
const double norm = 1./16./pi2;
const double nnlogLR = n*n*log(theLambdaR);
long level = 5000000 + n*100000;
//gluon
Energy2 deltaGB = g_s2*invRad2*norm*(23.*nnlogLR - 3.*zeta3/2./pi2 );
resetMass(level + 21, sqrt(nmass2 + deltaGB));
//W+/-
Energy2 deltaGW = g_W2*invRad2*norm*( 15.*nnlogLR - 5.*zeta3/2./pi2 );
Energy2 mw2 = sqr(getParticleData(24)->mass());
resetMass(level + 24, sqrt(mw2 + nmass2 + deltaGW));
//Z and gamma are a mixture of Bn and W3n
deltaGB = -g_em2*invRad2*norm*( 39.*zeta3/2./pi2 + nnlogLR/3. );
Energy2 mz2 = sqr(getParticleData(23)->mass());
Energy2 fp = 0.5*(mz2 + deltaGB + deltaGW + 2.*nmass2);
Energy2 sp = 0.5*sqrt( sqr(deltaGB - deltaGW - 2.*mw2 + mz2)
- 4.*mw2*(mw2 - mz2) );
resetMass(level + 22, sqrt(fp - sp));
resetMass(level + 23, sqrt(fp + sp));
//mixing angle will now depend on both Z* and gamma* mass
//Derived expression:
//
// cos^2_theta_N = ( (n/R)^2 + delta_GW + mw^2 - m_gam*^2)/(m_z*^2 - m_gam*^2)
//
double cn2 = (nmass2 + deltaGW + mw2 - fp + sp)/2./sp;
double sn = sqrt(1. - cn2);
theMixingAngles.insert(make_pair(n, sn));
if( n == 1 ) theSinThetaOne = sn;
//scalars
Energy2 mh2 = sqr(getParticleData(25)->mass());
double lambda_H = mh2/theVeV/theVeV;
deltaGB = nnlogLR*norm*invRad2*(3.*g_W2 + (3.*g_em2/2.) - 2.*lambda_H)
+ sqr(theMbarH);
//H0
Energy2 new_m2 = nmass2 + deltaGB;
resetMass(level + 25, sqrt( mh2 + new_m2 ));
//A0
resetMass(level + 36, sqrt( mz2 + new_m2 ));
//H+
resetMass(level + 37, sqrt( mw2 + new_m2 ));
}
void UEDBase::fermionMasses(const unsigned int n) {
const Energy2 invRad2 = theInvRadius*theInvRadius;
const double g_em2 = 4.*Constants::pi*alphaEM(invRad2);
const double g_s2 = 4.*Constants::pi*alphaS(invRad2);
const double g_W2 = g_em2/sin2ThetaW();
const Energy nmass = n*theInvRadius;
const Energy norm =
nmass*log(theLambdaR)/16./Constants::pi/Constants::pi;
const Energy topMass = getParticleData(6)->mass();
const double ht = sqrt(2)*topMass/theVeV;
//doublets
Energy deltaL = norm*(6.*g_s2 + (27.*g_W2/8.) + (g_em2/8.));
Energy deltaQ = deltaL;
Energy2 shift = sqr(nmass + deltaL);
long level = 5000000 + n*100000;
for(long i = 1; i < 17; ++i) {
if(i == 6) {
i += 5;
deltaL = norm*( (27.*g_W2/8.) + (9.*g_em2/8.) );
shift = sqr(nmass + deltaL);
}
Energy2 new_m2 = sqr(getParticleData(i)->mass()) + shift;
resetMass(level + i, sqrt(new_m2));
}
//singlet shifts
const Energy deltaU = norm*(6.*g_s2 + 2.*g_em2);
const Energy deltaD = norm*(6.*g_s2 + 0.5*g_em2);
const Energy2 shiftU = sqr(nmass + deltaU);
const Energy2 shiftD = sqr(nmass + deltaD);
//Top quarks seperately as they have different corrections
const Energy2 mt2 = sqr(topMass);
const Energy delta_Q3 = -3.*ht*ht*norm/2.;
const Energy deltaTD = deltaQ + delta_Q3;
const Energy deltaTS = deltaU + 2.*delta_Q3;
Energy second_term =
0.5*sqrt( sqr(2.*nmass + deltaTS + deltaTD) + 4.*mt2 );
//doublet
resetMass(level + 6, abs(0.5*(deltaTD - deltaTS) - second_term) );
//singlet
level += 1000000;
resetMass(level + 6, 0.5*(deltaTD - deltaTS) + second_term);
// others
//lepton
Energy delta = 9.*norm*g_em2/2.;
shift = sqr(nmass + delta);
for(long i = 1; i < 17; ) {
if(i == 6) i += 5;
Energy2 smMass2(sqr(getParticleData(i)->mass()));
if(i < 6) {
Energy2 new_m2;
if( i % 2 == 0)
new_m2 = smMass2 + shiftU;
else
new_m2 = smMass2 + shiftD;
resetMass(level + i, sqrt(new_m2));
++i;
}
else {
resetMass(level + i, sqrt(smMass2 + shift));
i += 2;
}
}
}
void UEDBase::resetMass(long id, Energy mass) {
theMasses.push_back(make_pair(id, mass));
tPDPtr particle = getParticleData(id);
if(!particle) {
throw InitException() << "UEDBase::resetMass - Trying to reset a mass for "
<< "a ParticleData object that does not exist. ID: "
<< id << Exception::warning;
return;
}
//find the correct interface
const InterfaceBase * ifc =
Repository::FindInterface(particle, "NominalMass");
if(!ifc)
throw InitException() << "UEDBase::resetMass - There was an error while "
<< "retrieving the NominalMass interface for "
<< particle->fullName()
<< Exception::abortnow;
//put value into a stream
ostringstream oss;
oss << ounit(mass, GeV);
if(!oss)
throw InitException() << "UEDBase::resetMass - There was an error while "
<< "reading the new mass into a stream for "
<< particle->fullName()
<< Exception::abortnow;
ifc->exec(*particle, "set", oss.str());
}
void UEDBase::writeSpectrum() {
sort(theMasses.begin(), theMasses.end(), lowerMass);
ostream & ofs = CurrentGenerator::current().misc();
ofs << "# MUED Model Particle Spectrum\n"
<< "# R^-1: " << theInvRadius/GeV << " GeV\n"
<< "# Lambda * R: " << theLambdaR << "\n"
<< "# Higgs Mass: " << getParticleData(25)->mass()/GeV << " GeV\n";
ofs << "#\n# ID\t\t\tMass(GeV)\n";
while (!theMasses.empty()) {
IDMassPair tmp = theMasses.back();
tcPDPtr data = getParticleData(tmp.first);
ofs << tmp.first << "\t\t\t" << tmp.second/GeV << "\t\t" << (data? data->PDGName() : "")
<< endl;
theMasses.pop_back();
}
ofs << "#\n";
}
double UEDBase::sinThetaN(const unsigned int n) const {
WAMap::const_iterator pos = theMixingAngles.find(n);
if(pos != theMixingAngles.end())
return pos->second;
else {
throw Exception() << "UEDBase::sinThetaN() - A mixing angle has "
<< "been requested for a level that does not "
<< "exist. Check that the radiative corrections "
<< "for the " << n << "th level have been "
<< "calculated." << Exception::warning;
return 0.0;
}
}
diff --git a/Models/UED/UEDBase.h b/Models/UED/UEDBase.h
--- a/Models/UED/UEDBase.h
+++ b/Models/UED/UEDBase.h
@@ -1,367 +1,367 @@
// -*- C++ -*-
//
// UEDBase.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_UEDBase_H
#define HERWIG_UEDBase_H
//
// This is the declaration of the UEDBase class.
//
-#include "Herwig++/Models/StandardModel/StandardModel.h"
+#include "Herwig++/Models/General/BSMModel.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractFFSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h"
#include "UEDBase.fh"
namespace Herwig {
using namespace ThePEG;
/**
* This class serves as a base class for all UED models. It stores the
* values of the inverse radius and the product \f$\Lambda R \f$ and has functions
* to calculate the radiative corrections to the nth level KK excitations.
*
* To use this class for n > 1 simply inherit off it, calculate the necessary masses
* using the provided functions for the new excitations and add the
* appropriate vertices.
*
* @see \ref UEDBaseInterfaces "The interfaces"
* defined for UEDBase.
*/
-class UEDBase: public StandardModel {
+class UEDBase: public BSMModel {
public:
/** Typedef for ID-Mass pair. */
typedef pair<long, Energy> IDMassPair;
/** Typedef for unsigned int/double map to store Weinburg angles.*/
typedef map<unsigned int, double> WAMap;
public:
/**
* The default constructor.
*/
UEDBase();
/** @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();
public:
/** @name Public Access Functions.*/
//@{
/**
* Return the compactification radius
*/
InvEnergy compactRadius() const {
return 1./theInvRadius;
}
/**
* Return the Weinburg mixing angle for any level.
*/
double sinThetaN(const unsigned int n) const;
/**
* Return the Weinburg mixing angle for \f$n = 1\f$
*/
double sinThetaOne() const {
return theSinThetaOne;
}
//@}
protected:
/**
* Add a new ID,mass pair to the mass storage
* @param elem The element to add in to storage
*/
void addMassElement(IDMassPair elem) {
theMasses.push_back(elem);
}
/**
* Add a new mixing angle to the storage
* @param n The level
* @param val The value
*/
void addMixingAngle(const unsigned int n,
const double val) {
theMixingAngles.insert(make_pair(n, val));
}
private:
/** @name Utility Functions for calculating masses. */
//@{
/**
* Calculate the radiative corrections to the masses of the KK excitations
* @param n The KK-level for which to calculate the masses.
*/
void calculateKKMasses(const unsigned int n);
/**
* Calculate the radiative corrections to the spin-0 and spin-1
* masses of the KK excitations
* @param n The KK-level for which to calculate the masses.
*/
void bosonMasses(const unsigned int n);
/**
* Calculate the radiative corrections to the spin-1/2
* masses of the KK excitations.
* @param n The KK-level for which to calculate the masses.
*/
void fermionMasses(const unsigned int n);
/**
* Reset the mass of the ParticleData object
*@param id The id of the particles mass to reset
*@param value The new mass
*/
void resetMass(long id, Energy value);
/**
* Calculate the Weinburg Mixing angle for the appropriate level.
* @param n The KK-level for which to calculate the mixing angle.
*/
double calculateMixingAngle(const unsigned int n);
//@}
/**
* Write out a spectrum file ordered in mass (name can be set by an interface).
*/
void writeSpectrum();
/**
* A predicate for sorting the list of masses.
*/
static bool lowerMass(const pair<long, Energy> & p1,
const pair<long, Energy> & p2) {
return p1.second < p2.second;
}
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);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
virtual void doinit();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<UEDBase> initUEDBase;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
UEDBase & operator=(const UEDBase &);
private:
/**
* Whether to calculate the radiative corrections to the KK masses
*/
bool theRadCorr;
/**
* Store the radius of the compactified dimension.
*/
Energy theInvRadius;
/**
* The value of \f$\Lambda R \f$.
*/
double theLambdaR;
/**
* The boundary mass term for the Higgs.
*/
Energy theMbarH;
/**
* The values of \f$\sin\theta_N\f$
*/
WAMap theMixingAngles;
/**
* Store \f$\sin\theta_1\f$ for faster access
*/
double theSinThetaOne;
/**
* Store the masses of the new particles
*/
vector<IDMassPair> theMasses;
/**
* The value of the vacuum expectation value of the higgs field.
*/
Energy theVeV;
/** @name The level 1 UED vertices. */
//@{
/**
* The \f$\bar{f}^{(1)}f^{(1)}Z^{(0)}\f$
*/
AbstractFFVVertexPtr theF1F1Z0Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(1)}g^{(0)}\f$
*/
AbstractFFVVertexPtr theF1F1G0Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(0)}g^{(1)}\f$
*/
AbstractFFVVertexPtr theF1F0G1Vertex;
/**
* The \f$g^{(1)}g^{(1)}g\f$ vertex
*/
AbstractVVVVertexPtr theG1G1G0Vertex;
/**
* The \f$g\,g\,g^{(1)},g^{(1)}\f$ vertex
*/
AbstractVVVVVertexPtr theG0G0G1G1Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(1)}\gamma\f$
*/
AbstractFFVVertexPtr theF1F1P0Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(1)}W\f$
*/
AbstractFFVVertexPtr theF1F1W0Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(0)}W^{(1)}\f$
*/
AbstractFFVVertexPtr theF1F0W1Vertex;
/**
* The \f$\bar{f}^{(1)}f^{(0)}H^{(1)}\f$
*/
AbstractFFSVertexPtr theF1F0H1Vertex;
/**
* The \f$ A^\mu_{(0)}H^+_{(1)}H-_{(1)}\f$
*/
AbstractVSSVertexPtr theP0H1H1Vertex;
/**
* The \f$ Z^\mu_{(0)}H^+_{(1)}H-_{(1)}\f$
*/
AbstractVSSVertexPtr theZ0H1H1Vertex;
/**
* The \f$ W^\pm_{\mu(0)}A_{(1)}H^\mp_{(1)}\f$
*/
AbstractVSSVertexPtr theW0A1H1Vertex;
/**
* The \f$ Z^\mu_{\mu(0)}A_{(1)}h_{(1)}\f$
*/
AbstractVSSVertexPtr theZ0A1h1Vertex;
/**
* The \f$W^{(1)}Z^{(1)}W_{(0)}\f$ vertex
*/
AbstractVVVVertexPtr theW0W1W1Vertex;
//@}
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of UEDBase. */
template <>
struct BaseClassTrait<Herwig::UEDBase,1> {
/** Typedef of the first base class of UEDBase. */
- typedef Herwig::StandardModel NthBase;
+ typedef Herwig::BSMModel NthBase;
};
/** This template specialization informs ThePEG about the name of
* the UEDBase class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::UEDBase>
: public ClassTraitsBase<Herwig::UEDBase> {
/** Return a platform-independent class name */
static string className() { return "Herwig::UEDBase"; }
/**
* The name of a file containing the dynamic library where the class
* UEDBase is implemented. It may also include several, space-separated,
* libraries if the class UEDBase depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
static string library() { return "HwUED.so"; }
};
/** @endcond */
}
#endif /* HERWIG_UEDBase_H */

File Metadata

Mime Type
text/x-diff
Expires
Thu, Apr 24, 6:32 AM (1 d, 12 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4887746
Default Alt Text
(150 KB)

Event Timeline