Page MenuHomeHEPForge
Files F8724193

No OneTemporary
Actions

View Options

diff --git a/Shower/SplittingFunctions/HalfHalfOneSplitFn.cc b/Shower/SplittingFunctions/HalfHalfOneSplitFn.cc
--- a/Shower/SplittingFunctions/HalfHalfOneSplitFn.cc
+++ b/Shower/SplittingFunctions/HalfHalfOneSplitFn.cc
@@ -1,97 +1,95 @@
// -*- C++ -*-
//
// HalfHalfOneSplitFn.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 HalfHalfOneSplitFn class.
//
#include "HalfHalfOneSplitFn.h"
#include "ThePEG/PDT/ParticleData.h"
-#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/Interface/ClassDocumentation.h"
-#include "Herwig++/Shower/Base/ShowerParticle.h"
#include <cassert>
using namespace Herwig;
NoPIOClassDescription<HalfHalfOneSplitFn> HalfHalfOneSplitFn::initHalfHalfOneSplitFn;
// Definition of the static class description member.
void HalfHalfOneSplitFn::Init() {
static ClassDocumentation<HalfHalfOneSplitFn> documentation
("The HalfHalfOneSplitFn class implements the q -> qg splitting function");
}
double HalfHalfOneSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double val = (1. + sqr(z))/(1.-z);
if(mass) {
Energy m = getParticleData(ids[0])->mass();
val -= 2.*sqr(m)/t;
}
return colourFactor()*val;
}
double HalfHalfOneSplitFn::overestimateP(const double z, const IdList &) const {
return 2.*colourFactor()/(1.-z);
}
double HalfHalfOneSplitFn::ratioP(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double val = 1. + sqr(z);
if(mass) {
Energy m = getParticleData(ids[0])->mass();
val -= 2.*sqr(m)*(1.-z)/t;
}
return 0.5*val;
}
double HalfHalfOneSplitFn::integOverP(const double z, const IdList & ,
unsigned int PDFfactor) const {
switch (PDFfactor) {
case 0:
return -2.*colourFactor()*log(1.-z);
case 1:
return 2.*colourFactor()*log(z/(1.-z));
case 2:
return 2.*colourFactor()/(1.-z);
case 3:
default:
throw Exception() << "HalfHalfOneSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double HalfHalfOneSplitFn::invIntegOverP(const double r, const IdList & ,
unsigned int PDFfactor) const {
switch (PDFfactor) {
case 0:
return 1. - exp(- 0.5*r/colourFactor());
case 1:
return 1./(1.-exp(-0.5*r/colourFactor()));
case 2:
return 1.-2.*colourFactor()/r;
case 3:
default:
throw Exception() << "HalfHalfOneSplitFn::invIntegOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool HalfHalfOneSplitFn::accept(const IdList &ids) const {
// 3 particles and in and out fermion same
if(ids.size()!=3 || ids[0]!=ids[1]) return false;
tcPDPtr q=getParticleData(ids[0]);
tcPDPtr g=getParticleData(ids[2]);
if(q->iSpin()!=PDT::Spin1Half ||
g->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}
diff --git a/Shower/SplittingFunctions/HalfOneHalfSplitFn.cc b/Shower/SplittingFunctions/HalfOneHalfSplitFn.cc
--- a/Shower/SplittingFunctions/HalfOneHalfSplitFn.cc
+++ b/Shower/SplittingFunctions/HalfOneHalfSplitFn.cc
@@ -1,98 +1,96 @@
// -*- C++ -*-
//
// HalfOneHalfSplitFn.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 HalfOneHalfSplitFn class.
//
#include "HalfOneHalfSplitFn.h"
#include "ThePEG/PDT/ParticleData.h"
-#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/Interface/ClassDocumentation.h"
-#include "Herwig++/Shower/Base/ShowerParticle.h"
#include <cassert>
using namespace Herwig;
NoPIOClassDescription<HalfOneHalfSplitFn> HalfOneHalfSplitFn::initHalfOneHalfSplitFn;
// Definition of the static class description member.
void HalfOneHalfSplitFn::Init() {
static ClassDocumentation<HalfOneHalfSplitFn> documentation
("The HalfOneHalfSplitFn class implements the splitting function for q -> g q");
}
double HalfOneHalfSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double val=(2.*(1.-z)+sqr(z))/z;
if(mass) {
Energy m = getParticleData(ids[0])->mass();
val-=2.*sqr(m)/t;
}
return colourFactor()*val;
}
double HalfOneHalfSplitFn::overestimateP(const double z, const IdList &) const {
return 2.*colourFactor()/z;
}
double HalfOneHalfSplitFn::ratioP(const double z, const Energy2 t,
const IdList &ids,const bool mass) const {
double val=2.*(1.-z)+sqr(z);
if(mass) {
Energy m=getParticleData(ids[0])->mass();
val -=2.*sqr(m)*z/t;
}
return 0.5*val;
}
double HalfOneHalfSplitFn::integOverP(const double z, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return 2.*colourFactor()*log(z);
case 1:
return -2.*colourFactor()/z;
case 2:
return 2.*colourFactor()*log(z/(1.-z));
case 3:
default:
throw Exception() << "HalfOneHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double HalfOneHalfSplitFn::invIntegOverP(const double r, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return exp(0.5*r/colourFactor());
case 1:
return -2.*colourFactor()/r;
case 2:
return 1./(1.+exp(-0.5*r/colourFactor()));
case 3:
default:
throw Exception() << "HalfOneHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool HalfOneHalfSplitFn::accept(const IdList &ids) const {
// 3 particles and in and out fermion same
if(ids.size()!=3 || ids[0]!=ids[2]) return false;
tcPDPtr q=getParticleData(ids[0]);
tcPDPtr g=getParticleData(ids[1]);
if(q->iSpin()!=PDT::Spin1Half ||
g->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}
diff --git a/Shower/SplittingFunctions/OneHalfHalfSplitFn.cc b/Shower/SplittingFunctions/OneHalfHalfSplitFn.cc
--- a/Shower/SplittingFunctions/OneHalfHalfSplitFn.cc
+++ b/Shower/SplittingFunctions/OneHalfHalfSplitFn.cc
@@ -1,101 +1,99 @@
// -*- C++ -*-
//
// OneHalfHalfSplitFn.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 OneHalfHalfSplitFn class.
//
#include "OneHalfHalfSplitFn.h"
-#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Interface/ClassDocumentation.h"
-#include "Herwig++/Shower/Base/ShowerParticle.h"
#include <cassert>
using namespace Herwig;
NoPIOClassDescription<OneHalfHalfSplitFn> OneHalfHalfSplitFn::initOneHalfHalfSplitFn;
// Definition of the static class description member.
void OneHalfHalfSplitFn::Init() {
static ClassDocumentation<OneHalfHalfSplitFn> documentation
("The OneHalfHalfSplitFn class implements the splitting function for g->q qbar");
}
double OneHalfHalfSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double zz = z*(1.-z);
double val=1.-2.*zz;
if(mass) {
Energy m = getParticleData(ids[1])->mass();
val +=2.*sqr(m)/t;
}
return colourFactor()*val;
}
double OneHalfHalfSplitFn::overestimateP(const double, const IdList &) const {
return colourFactor();
}
double OneHalfHalfSplitFn::ratioP(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double zz = z*(1.-z);
double val = 1.-2.*zz;
if(mass) {
Energy m = getParticleData(ids[1])->mass();
val+= 2.*sqr(m)/t;
}
return val;
}
double OneHalfHalfSplitFn::integOverP(const double z, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return colourFactor()*z;
case 1:
return colourFactor()*log(z);
case 2:
return -colourFactor()*log(1.-z);
case 3:
return colourFactor()*log(z/(1.-z));
default:
throw Exception() << "OneHalfHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double OneHalfHalfSplitFn::invIntegOverP(const double r, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return r/colourFactor();
case 1:
return exp(r/colourFactor());
case 2:
return 1.-exp(-r/colourFactor());
case 3:
return 1./(1.+exp(-r/colourFactor()));
default:
throw Exception() << "OneHalfHalfSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool OneHalfHalfSplitFn::accept(const IdList &ids) const {
if(ids.size()!=3) return false;
if(ids[1]!=-ids[2]) return false;
tcPDPtr q=getParticleData(ids[1]);
if(q->iSpin()!=PDT::Spin1Half) return false;
tcPDPtr g=getParticleData(ids[0]);
if(g->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}
diff --git a/Shower/SplittingFunctions/OneOneOneSplitFn.cc b/Shower/SplittingFunctions/OneOneOneSplitFn.cc
--- a/Shower/SplittingFunctions/OneOneOneSplitFn.cc
+++ b/Shower/SplittingFunctions/OneOneOneSplitFn.cc
@@ -1,86 +1,85 @@
// -*- C++ -*-
//
// OneOneOneSplitFn.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 OneOneOneSplitFn class.
//
#include "OneOneOneSplitFn.h"
-#include "ThePEG/PDT/EnumParticles.h"
+#include "ThePEG/PDT/ParticleData.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Interface/ClassDocumentation.h"
-#include "Herwig++/Shower/Base/ShowerParticle.h"
#include <cassert>
using namespace Herwig;
NoPIOClassDescription<OneOneOneSplitFn> OneOneOneSplitFn::initOneOneOneSplitFn;
// Definition of the static class description member.
void OneOneOneSplitFn::Init() {
static ClassDocumentation<OneOneOneSplitFn> documentation
("The OneOneOneSplitFn class implements the g -> gg splitting function");
}
double OneOneOneSplitFn::P(const double z, const Energy2, const IdList &,
const bool)const {
// (this is historically important! the first physics - two years
// after the birth of the project - in the Herwig++ shower! Alberto
// & Stefan, 25/04/2002).
return colourFactor()*sqr(1.-z*(1.-z))/(z*(1.-z));
}
double OneOneOneSplitFn::overestimateP(const double z, const IdList &) const {
return colourFactor()*(1/z + 1/(1.-z));
}
double OneOneOneSplitFn::ratioP(const double z, const Energy2, const IdList &,
const bool) const {
return sqr(1.-z*(1.-z));
}
double OneOneOneSplitFn::invIntegOverP(const double r, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return 1./(1.+exp(-r/colourFactor()));
case 1:
case 2:
case 3:
default:
throw Exception() << "OneOneOneSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double OneOneOneSplitFn::integOverP(const double z, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return colourFactor()*log(z/(1.-z));
case 1:
case 2:
case 3:
default:
throw Exception() << "OneOneOneSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool OneOneOneSplitFn::accept(const IdList & ids) const {
if(ids.size()!=3) return false;
for(unsigned int ix=0;ix<ids.size();++ix) {
tcPDPtr part = getParticleData(ids[ix]);
if(part->iSpin()!=PDT::Spin1) return false;
}
return checkColours(ids);
}
diff --git a/Shower/SplittingFunctions/ZeroZeroOneSplitFn.cc b/Shower/SplittingFunctions/ZeroZeroOneSplitFn.cc
--- a/Shower/SplittingFunctions/ZeroZeroOneSplitFn.cc
+++ b/Shower/SplittingFunctions/ZeroZeroOneSplitFn.cc
@@ -1,96 +1,94 @@
// -*- C++ -*-
//
// PhitoPhiGSplitFn.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 ZeroZeroOneSplitFn class.
//
#include "ZeroZeroOneSplitFn.h"
#include "ThePEG/PDT/ParticleData.h"
-#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
-#include "Herwig++/Shower/Base/ShowerParticle.h"
#include <cassert>
using namespace Herwig;
NoPIOClassDescription<ZeroZeroOneSplitFn> ZeroZeroOneSplitFn::initZeroZeroOneSplitFn;
// Definition of the static class description member.
void ZeroZeroOneSplitFn::Init() {
static ClassDocumentation<ZeroZeroOneSplitFn> documentation
("The ZeroZeroOneSplitFn class implements the splitting function for the "
"radiation of a gluon by a scalar coloured particle");
}
double ZeroZeroOneSplitFn::P(const double z, const Energy2 t,
const IdList &ids, const bool mass) const {
double val = z/(1.-z);
if(mass) {
Energy m = getParticleData(ids[0])->mass();
val-= sqr(m)/t;
}
return 2.*colourFactor()*val;
}
double ZeroZeroOneSplitFn::overestimateP(const double z, const IdList &) const {
return 2.*colourFactor()/(1.-z);
}
double ZeroZeroOneSplitFn::ratioP(const double z, const Energy2 t,
const IdList &ids,const bool mass) const {
double val = z;
if(mass) {
Energy m = getParticleData(ids[0])->mass();
val-=sqr(m)*(1.-z)/t;
}
return val;
}
double ZeroZeroOneSplitFn::integOverP(const double z, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return -2.*colourFactor()*log(1.-z);
case 1:
case 2:
case 3:
default:
throw Exception() << "ZeroZeroOneSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
double ZeroZeroOneSplitFn::invIntegOverP(const double r, const IdList & ,
unsigned int PDFfactor) const {
switch(PDFfactor) {
case 0:
return 1. - exp(- 0.5*r/colourFactor());
case 1:
case 2:
case 3:
default:
throw Exception() << "ZeroZeroOneSplitFn::integOverP() invalid PDFfactor = "
<< PDFfactor << Exception::runerror;
}
}
bool ZeroZeroOneSplitFn::accept(const IdList &ids) const {
if(ids.size()!=3) return false;
if(ids[0]!=ids[1]) return false;
tcPDPtr q=getParticleData(ids[0]);
tcPDPtr g=getParticleData(ids[2]);
if(q->iSpin()!=PDT::Spin0 ||
g->iSpin()!=PDT::Spin1) return false;
return checkColours(ids);
}

File Metadata

Mime Type
text/x-diff
Expires
Mon, Jan 20, 10:42 PM (1 d, 17 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4242710
Default Alt Text
(15 KB)

Event Timeline