EtaPiPiPiDecayerThe

`EtaPiPiPiDecayer`

class is designed for the simulation of the decay of the or to either or and the decay of the to or
PScalar4FermionsDecayerThe `PScalar4FermionsDecayer`

class is designed for the decay of the neutral pion to four leptons, in this case electrons
PScalarLeptonNeutrinoDecayerDesigned for the decay of pseudoscalar mesons to a lepton and a neutrino
PScalarPScalarVectorDecayerThe `PScalarPScalarVectorDecayer`

class is designed to perform the decay of a pseudoscalar meson to another pseudoscalar meson and a vector meson
PScalarVectorFermionsDecayerThe `PScalarVectorFermionsDecayer`

class is designed for the decay of a pseudoscalar meson to a spin-1 particle and a fermion-antifermion pair
PScalarVectorVectorDecayerThe `PScalarVectorVectorDecayer`

class is designed to perform the decay of a pseudoscalar meson to two spin-1 particles
ScalarMesonFactorizedDecayerThe `ScalarMesonFactorizedDecayer`

class is a class which combines a WeakDecayCurrent and a ScalarFormFactor in the naive factorization approximation to perform the non-leptonic weak decays of scalar mesons
ScalarMesonTensorScalarDecayerThe `ScalarMesonTensorScalarDecayer`

class is designed for the decay of a (pseudo)scalar meson to a tensor meson and another (pseudo)scalar meson
ScalarScalarScalarDecayerThe `ScalarScalarScalarDecayer`

class is designed for the decay of a scalar meson to two scalar mesons
ScalarVectorVectorDecayerDesigned to perform the decay of a scalar meson to two spin-1 particles
SemiLeptonicScalarDecayerThe `SemiLeptonicScalarDecayer`

class is designed for the semileptonic decay of a (pesudo)scalar meson to another meson and a lepton/neutino pair
TauDecayerPerforms the decay of the
TensorMeson2PScalarDecayerThe `TensorMeson2PScalarDecayer`

class is designed for the decay of a tensor meson to two pseudoscalars via matrix element which takes the form

where is the polarization tensor of the decaying tensor meson, $p_{1,2}$ are the momenta of the decay products and is the coupling

TensorMesonVectorPScalarDecayerThe`TensorMesonVectorPScalarDecayer`

class handles the decay of a tensor meson to a vector and a pseudoscalar
TensorMesonVectorVectorDecayerDesigned to simulate the decay of a tensor meson to two spin-1 particles
TwoBodyDecayMatrixElement
a1SimpleDecayerSimple model of the decay of the meson to three pions including meson intermediate states
a1ThreePionCLEODecayerThe `a1ThreePionCLEODecayer`

class is designed to implement the decay of the to three pions using the model of Phys.Rev.D61:012002,2000, (hep-ex/9902022) (CLEO) which was fitted to the one charged and two neutral pion channel for the charged decay in
a1ThreePionDecayerThe `a1ThreePionDecayer`

class is designed to implement the decay of the a_1 to three pions
OniumToOniumPiPiDecayerUses the matrix element of Brown and Cahn PRL35, 1 (1975) for the decay of onium resonaces to lighter states and pion pairs
PVectorMesonVectorPScalarDecayerThis class is designed for the decay of a pseudovector meson to a spin-1 particle, either a vector meson or a photon, and a pseudoscalar meson
VectorMeson2FermionDecayerThe `VectorMeson2FermionDecayer`

class is designed for the decay of a vector meson to a fermion-antifermion pair
VectorMeson2MesonDecayerThis class is the implementation for the decay of a vector meson to two scalar mesons, the classic example is , via a current which is the difference of the momenta of the mesons
VectorMeson3PionDecayerDesigned to perform the decay of an meson to three pions via rho mesons including the option of higher rho resonaces and a constant term
VectorMesonPScalarFermionsDecayerThe `VectorMesonPScalarFermionsDecayer`

class is designed to perform the decay of a vector meson to a pesudo scalar and a fermion-antifermion pair according to a current which is the vertex combined with the branching of the vector into a fermion-antifermion pair
VectorMesonPVectorPScalarDecayerThis class is designed for the decay of a vector meson to a pseudovector meson and a pseudoscalar meson
VectorMesonVectorPScalarDecayerThis class is designed for the decay of a vector meson to another spin-1 particle, either another vector meson or a photon, and a pseduoscalar meson
VectorMesonVectorScalarDecayerThis class is designed for the decay of a vector meson to a spin-1 particle, either a vector meson or a photon, and a scalar meson
VectorMesonVectorVectorDecayerThis class is designed for the decay of a vector meson to two spin one particles, either other vector mesons or photons
FivePionCurrentHere is the documentation of the FivePionCurrent class
FourPionNovosibirskCurrentThe `FourPionNovosibirskCurrent`

class implements the decay of the weak current to 4 pions using the hadronic currents of Comput
KaonThreeMesonCurrentImplements the model of M
KPiCurrentHere is the documentation of the KPiCurrent class
LeptonNeutrinoCurrentThis class implements the weak decay current for a lepton and a neutrino
ScalarMesonCurrentThe weak current for the production of one (pseudo)-scalar meson
ThreeMesonCurrentBaseThis is the base class for the three meson decays of the weak current
FormFactorsHelper class for form factors
ThreeMesonDefaultCurrentImplements the currents from Z.Phys.C58:445 (1992), this paper uses the form from Z.Phys.C48:445 (1990) for the width and is the default model in TAUOLA
ThreePionCLEOCurrentThe `ThreePionCLEOCurrent`

class implements the decay of the weak current to three pions using the currents from CLEO Phys
TwoMesonRhoKStarCurrentWeak current for the production of two mesons via the or resonances
TwoPionPhotonCurrentThis class implements the decay current for via an intermediate
VectorMesonCurrentThe weak current for the production of one (pseudo)-vector meson
WeakDecayCurrentThe `WeakDecayCurrent`

class is the base class for the hadronic currents produced in weak decays
DipoleUsed by the dipole shower to represent a dipole of two coloured partons
DipoleChainUsed by the dipole shower to represent a chain of dipoles
DipoleChainOrderingDipoleChainOrdering performs ordering on complete colour singlet dipole chains
SubleadingSplittingInfoGeneralized dipole splitting info to deal with subleading-N splittings
DipoleEventRecordused internally by the dipole shower
getMomentum
DipoleEventReweightReweight full final states produced by the shower
DipoleEvolutionOrderingDipoleEvolutionOrdering defines a particular evolution algortihm for the dipole shower
DipoleSplittingGeneratorDipoleSplittingGenerator is used by the dipole shower to sample splittings from a given dipole splitting kernel
DipoleIndexDipoleIndex is used to index splitting generators for a particular dipole
DipoleSplittingInfoDipoleSplittingInfo contains all parameters to generate a full dipole splitting
DipoleSplittingReweightDipoleSplittingReweight is used by the dipole shower to reweight splittings from a given dipole splitting kernel
DipoleShowerHandlerManages the showering using the dipole shower algorithm
RedoShowerIndicate a problem in the shower
DipoleSplittingKernelDipoleSplittingKernel is the base class for all kernels used within the dipole shower
FFgx2ggxDipoleKernelFFgx2ggxDipoleKernel implements the g -> gg splitting off a final-final dipole
FFgx2qqxDipoleKernelFFgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-final dipole
FFMgx2ggxDipoleKernelFFMgx2ggxDipoleKernel implements the g -> gg splitting off a final-final dipole
FFMgx2qqxDipoleKernelFFMgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-final dipole
FFMqx2qgxDipoleKernelFFMqx2qgxDipoleKernel implements the q -> qg splitting off a final-final dipole
FFqx2qgxDipoleKernelFFqx2qgxDipoleKernel implements the q -> qg splitting off a final-final dipole
FIgx2ggxDipoleKernelFIgx2ggxDipoleKernel implements the g -> gg splitting off a final-initial dipole
FIgx2qqxDipoleKernelFIgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-initial dipole
FIMgx2qqxDipoleKernelFIMgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-initial dipole
FIMqx2qgxDipoleKernelFIMqx2qgxDipoleKernel implements the q -> qg splitting off a final-initial dipole
FIqx2qgxDipoleKernelFIqx2qgxDipoleKernel implements the q -> qg splitting off a final-initial dipole
IFgx2ggxDipoleKernelIFgx2ggxDipoleKernel implements the g -> gg splitting off an initial-final dipole
IFgx2qqxDipoleKernelIFgx2qqxDipoleKernel implements the g -> qq splitting off an initial-final dipole
IFMgx2ggxDipoleKernelIFMgx2ggxDipoleKernel implements the g -> gg splitting off an initial-final dipole
IFMgx2qqxDipoleKernelIFMgx2qqxDipoleKernel implements the g -> qq splitting off an initial-final dipole
IFMqx2gqxDipoleKernelIFMqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-final dipole
IFMqx2qgxDipoleKernelIFMqx2qgxDipoleKernel implements the q -> qg splitting off an initial-final dipole
IFqx2gqxDipoleKernelIFqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-final dipole
IFqx2qgxDipoleKernelIFqx2qgxDipoleKernel implements the q -> qg splitting off an initial-final dipole
IIgx2ggxDipoleKernelIIgx2ggxDipoleKernel implements the g -> gg splitting off an initial-initial dipole
IIgx2qqxDipoleKernelIIgx2qqxDipoleKernel implements the g -> qq splitting off an initial-initial dipole
IIqx2gqxDipoleKernelIIqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-initial dipole
IIqx2qgxDipoleKernelIIqx2qgxDipoleKernel implements the q -> qg splitting off an initial-initial dipole
DipoleSplittingKinematicsDipoleSplittingKinematics is the base class for dipole splittings as performed in the dipole shower
FFLightKinematicsFFLightKinematics implements massless splittings off a final-final dipole
FFMassiveKinematicsFFMassiveKinematics implements massive splittings off a final-final dipole
FILightKinematicsFILightKinematics implements massless splittings off a final-initial dipole
FIMassiveKinematicsFIMassiveKinematics implements massless splittings off a final-initial dipole
IFLightKinematicsIFLightKinematics implements massless splittings off an initial-final dipole
IFMassiveKinematicsIFMassiveKinematics implements massless splittings off an initial-final dipole
IILightKinematicsIILightKinematics implements massless splittings off an initial-initial dipole
ConstituentReshufflerImplements reshuffling of partons on their nominal mass shell to their constituent mass shells
ReshuffleEquationThe function object defining the equation to be solved
DipoleMCCheckDipoleMCCheck is used to perform checks for the dipole shower
DipolePartonSplitterThe DipolePartonSplitter is a helper class to fix up colour and mother-child relations in typical shower splittings
IntrinsicPtGeneratorIntrinsicPtGenerator generates intrinsic pt for massless incoming partons in a shower independent way
PDFRatioPDFRatio implements numerically stable PDF ratios
ClusterThis class describes a cluster object
ClusterDecayerThis class decays the "normal" clusters
ClusterFinderThis class forms clusters from the partons produced in the Shower
ClusterFissionerThis class handles clusters which are too heavy
ClusterHadronizationHandlerClass that controls the cluster hadronization algorithm
ColourReconnectorClass for changing colour reconnections of partons
HadronSelectorThis class selects the hadron flavours of a cluster decay
HadronInfoClass used to store all the hadron information for easy access
KupcoClass designed to make STL routines easy to use
Hw64SelectorSelects the hadrons produced in cluster decay using the FORTRAN HERWIG variant of the cluster model
HwppSelectorSelects the hadrons produced in cluster decay using the Herwig variant of the cluster model
LightClusterDecayerThis class performs the decay of light clusters into a single hadron
PartonSplitterThis class splits the gluons from the end of the shower
DISBaseBase class for the implementation of DIS type processes including corrections in both the old fashioned matrix element and POWHEG approaches
MEChargedCurrentDISMatrix elements for charged current DIS
MENeutralCurrentDISMatrix elements for neutral current DIS
DrellYanBaseClass provides a base class for the implemented of Drell-Yan type processes and provides the matrix element and POWHEG style hard corrections
MEGammaGamma2ffMatrix elements for
MEGammaGamma2WWMatrix elements for
MEGammaP2JetsImplements the matrix elements for pointlike gamma+hadron -> jets
GeneralfftoffHHere is the documentation of the GeneralfftoffH class
GeneralfftoVHHere is the documentation of the GeneralfftoVH class
GeneralHardMEThis defines the GeneralHardME class that is designed to serve as a base class for matrix elements of specific spin structures when those structures are created by a a general model, i.e
MEExceptionException class to indicate a problem has occurred with setting up to matrix element
GeneralQQHiggsImplements the matrix elements for and
MEff2ffThis is the implementation of the matrix element for a process
MEff2ssDesigned to implement the matrix element for a fermion-antifermion to scalar-scalar hard process
MEff2svDesigned to implement the matrix element for a fermion-antifermion to vector-scalar hard process
MEff2tvHere is the documentation of the MEff2tv class
MEff2vsDesigned to implement the matrix element for a fermion-antifermion to vector-scalar hard process
MEff2vvThis class implements the matrix element calculation for a generic process
MEfv2fsThis class is designed to implement the matrix element for fermion-vector to fermion scalar
MEfv2tfHere is the documentation of the MEfv2tf class
MEfv2vfThis class implements the matrix element for a fermion and a vector boson to a fermion and a vector boson
MEvv2ffThis class is designed to implement the matrix element for the process vector-vector to fermion-antifermion pair
MEvv2ssThis is the implementation of the matrix element for the process vector-vector to scalar-scalar
MEvv2tvHere is the documentation of the MEvv2tv class
MEvv2vsThis is the implementation of the matrix element for massless vector-boson pair to a vector and scalar boson
MEvv2vvThis is the implementation of the matrix element for massless vector-boson pair to vector-boson pair
MEMinBiasSimple colour singlet exchange matrix element to be used in the soft component of the multiple scattering model of the underlying event
MEPP2GammaGammaImplements the production of photon pairs in hadron hadron collisions
MEPP2GammaJetImplements the matrix element for photon+jet production in hadron-hadron collisions
MEPP2HiggsImplements the matrix element for the process pp->Higgs with different Higgs shape prescriptions (see details in hep-ph/9505211) and the NLL corrected Higgs width (see details in the FORTRAN HERWIG manual)
MEPP2HiggsJetImplements the matrix element for Higgs+jet production
MEPP2HiggsVBFMatrix elements for the production of the Higgs boson via the vector boson fusion mechanism in hadron collisions
tChannelPairStruct to contain the hadronic system
MEPP2QQImplements the production of a heavy quark-antiquark pair via QCD
MEPP2QQHiggsImplements the matrix elements for and
MEPP2SingleTopImplements the matrix element for the production of a single top quark
MEPP2VGammaImplements the
MEPP2VVImplements the production of , and in hadron-hadron collisions
MEPP2WHMatrix elements for the production of the boson in association with the Higgs in hadron collisions
MEPP2WJetImplements the matrix element for the production of a W boson and a jet including the decay of the W
MEPP2ZHImplements the matrix element for
MEPP2ZJetImplements the matrix element for the production of a Z boson + a jet including the decay of the Z including interference
MEQCD2to2Matrix elements for QCD scattering processes in hadron-hadron collisions
MEQCD2to2FastImplements the matrix elements for QCD scattering processes using hard coded formulae and as such can not include spin correlations
MEqq2gZ2ffImplements the products of Standard Model fermion antifermion pairs via the resonance including photon interference terms
MEqq2W2ffImplements the matrix element for including the decay of the to Standard Model fermions
HardVertex
HwMEBaseServes a number of purposes
MEee2gZ2llMatrix element for
MEee2gZ2qqImplements the matrix element for including spin correlations
MEee2HiggsVBFThe MEee2HiggsVBF class
MEee2VectorMesonDesigned to produce neutral vector mesons in collisions and is primarily intended to test the hadronic decay package
MEee2VVImplements the matrix elements for
MEee2ZHImplements the matrix element for
DipoleRepositoryRepository of known subtraction dipoles
ProcessProcess information with coupling order
MatchboxAmplitudeMatchboxAmplitude is the base class for amplitude implementations inside Matchbox
MatchboxHybridAmplitudeMatchboxHybridAmplitude unifies two amplitude objects to provide tree and one-loop matrix elements
MatchboxMEBaseMatchboxMEBase is the base class for matrix elements in the context of the matchbox NLO interface
AccuracyHistogramSimple histogram for accuracy checks
MatchboxOLPMEMatchboxOLPME implements OLP interfaces
MatchboxReweightBaseMatchboxReweightBase is the base class for reweighting MatchboxMEBase matrix elements as |M|^2 ( w_1 + ... + w_n )
SubtractedMESubtractedME represents a subtracted real emission matrix element
SubtractionHistogramSimple envelope histogram to keep track of subtraction
MatchboxAmplitudeggttbarMatchboxAmplitudeggttbar
MatchboxAmplitudeggttbargMatchboxAmplitudeggttbarg
MatchboxAmplitudehbbbarMatchboxAmplitudehbbbar
MatchboxAmplitudehbbbargMatchboxAmplitudehbbbarg
MatchboxAmplitudehggMatchboxAmplitudehgg
MatchboxAmplitudehgggMatchboxAmplitudehggg
MatchboxAmplitudehqqbargMatchboxAmplitudehqqbarg
MatchboxAmplitudellbarqqbarMatchboxAmplitudellbarqqbar
MatchboxAmplitudellbarqqbargMatchboxAmplitudellbarqqbarg
MatchboxAmplitudellbarqqbarggMatchboxAmplitudellbarqqbargg
MatchboxAmplitudellbarqqbarqqbarMatchboxAmplitudellbarqqbarqqbar
MatchboxAmplitudelnuqqbarMatchboxAmplitudelnuqqbar
MatchboxAmplitudelnuqqbargMatchboxAmplitudelnuqqbarg
MatchboxAmplitudelnuqqbarggMatchboxAmplitudelnuqqbargg
MatchboxAmplitudelnuqqbarqqbarMatchboxAmplitudelnuqqbarqqbar
MatchboxAmplitudeqqbarttbarMatchboxAmplitudeqqbarttbar
MatchboxAmplitudeqqbarttbargMatchboxAmplitudeqqbarttbarg
MatchboxCurrentsMatchboxCurrents
MatchboxZGammaAmplitudeHere is the documentation of the MatchboxZGammaAmplitude class
FrixionePhotonSeparationCutThis class implements a cut on legoplot and rapidity separation
IdentifiedParticleCutIdentifiedParticleCut implements cuts on single momenta
InvariantMassCutThis class implements a cut on the invariant mass
MatchboxDeltaRCutMatchboxDeltaRCut implements cuts related to the separation in the legoplot plane
MissingPtCutMissingPtCut implements a cut on the total missing transverse momentum of a set of outgoing particles, i.e. for now the total transverse momentum of all outgoing neutrinos in an event
PairPtCutThis class implements a cut on the transverse momentum of a pair of particles
PairRapidityCutThis class implements a cut on the rapidity of a pair of particles
FFggxDipoleFFggxDipole implements the D_{g,g;k} subtraction dipole
FFMggxDipoleFFMggxDipole implements the D_{g,g;k} subtraction dipole
FFMqgxDipoleFFMqgxDipole implements the D_{Q,g;k} subtraction dipole, as well as the D_{gluino,g;k} subtraction dipole
FFMqqxDipoleFFMqqxDipole implements the D_{q,qbar;k} subtraction dipole
FFMsqgxDipoleFFMsqgxDipole implements the D_{sq,g;k} subtraction dipole
FFqgxDipoleFFqgxDipole implements the D_{q,g;k} subtraction dipole
FFqqxDipoleFFqqxDipole implements the D_{q,qbar;k} subtraction dipole
FIggxDipoleFIggxDipole implements the D_{g,g}^a subtraction dipole
FIMqgxDipoleFIMqgxDipole implements the D_{Q,g}^a subtraction dipole, as well as the D_{gluino,g}^a subtraction dipole
FIMqqxDipoleFIMqqxDipole implements the D_{q,qbar}^a subtraction dipole
FIMsqgxDipoleFIMsqgxDipole implements the D_{sq,g}^a subtraction dipole
FIqgxDipoleFIqgxDipole implements the D_{q,g}^a subtraction dipole
FIqqxDipoleFIqqxDipole implements the D_{q,qbar}^a subtraction dipole
IFggxDipoleIFggxDipole implements the D^{g,g}_k subtraction dipole
IFgqxDipoleIFgqxDipole implements the D_k^{g,q} subtraction dipole
IFMggxDipoleIFMggxDipole implements the D^{g,g}_k subtraction dipole
IFMgqxDipoleIFMgqxDipole implements the D_k^{g,q} subtraction dipole
IFMqgxDipoleIFMqgxDipole implements the D^{q,g}_k subtraction dipole
IFMqqxDipoleIFMqqxDipole implements the D^{q,qbar}_k subtraction dipole
IFqgxDipoleIFqgxDipole implements the D^{q,g}_k subtraction dipole
IFqqxDipoleIFqqxDipole implements the D^{q,qbar}_k subtraction dipole
IIggxDipoleIIggxDipole implements the D^{g,g;b} subtraction dipole
IIgqxDipoleIIgqxDipole implements the D^{g,q,k} subtraction dipole
IIqgxDipoleIIqgxDipole implements the D^{q,g;b} subtraction dipole
IIqqxDipoleIIqqxDipole implements the D^{q,qbar;b} subtraction dipole
SubtractionDipoleSubtractionDipole represents a dipole subtraction term in the formalism of Catani and Seymour
MergeInfoA helpre struct to communicate diagram merging and remapping information
GenericOLPAmplitudeGenericOLPAmplitude implements OLP interfaces
gosamprocinfo
GoSamAmplitudeGoSamAmplitude implements an interface to GoSam
MadGraphAmplitudeMadGraphAmplitude implements an interface to MadGraph
NJetsAmplitudeNJetsAmplitude implements an interface to NJets
OpenLoopsProcInfoProcess information for OpenLoops
OpenLoopsAmplitudeOpenLoopsAmplitude implements an interface to OpenLoops
VBFNLOAmplitudeVBFNLOAmplitude implements an interface to VBFNLO
VBFNLOPhasespaceVBFNLOPhasespace is an interface to the internal phasespace generator of VBFNLO. It uses the information passed via the BLHA interface to obtain information on the required channels
ReshuffleEquationThe function object defining the equation to be solved
DipoleIOperatorDipoleIOperator implements the I() insertion operator
DipoleMIOperatorDipoleMIOperator implements the I() insertion operator for the massive case. DipoleMIOperator does only apply for expanded con- vention and also not for dimensional reduction
DipoleMPKOperatorDipoleMPKOperator implements the P+K insertion operator for the massive case. DipoleMPKOperator does not apply for dimen- sional reduction
DipolePKOperatorDipolePKOperator implements the P+K insertion operator
MatchboxInsertionOperatorMatchboxInsertionOperator is the base class for insertion operators
MatchboxFactoryMatchboxFactory automatically sets up a NLO QCD calculation carried out in dipole subtraction
SplittingChannelIdentify a splitting channel
DipoleMatchingDipoleMatching implements NLO matching with the dipole shower
HardScaleProfileHardScaleProfile is the base class for profile scales. A few standard choices are provided by this implementation
MEMatchingMEMatching implements NLO matching with matrix element correction (aka Powheg)
QTildeMatchingQTildeMatching implements NLO matching with the default shower
ShowerApproximationShowerApproximation describes the shower emission to be used in NLO matching
ShowerApproximationGeneratorShowerApproximationGenerator generates emissions according to a shower approximation entering a NLO matching
ShowerApproximationKernelShowerApproximationKernel generates emissions according to a shower approximation entering a NLO matching
MaxTryExceptionException to communicate sampler maxtry events
FFLightInvertedTildeKinematicsFFLightInvertedTildeKinematics inverts the final-final tilde kinematics
FFLightTildeKinematicsFFLightTildeKinematics implements the 'tilde' kinematics for a final-final subtraction dipole
FFMassiveInvertedTildeKinematicsFFMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
FFMassiveTildeKinematicsFFMassiveTildeKinematics implements the 'tilde' kinematics for a final-final subtraction dipole
FILightInvertedTildeKinematicsFILightInvertedTildeKinematics inverts the final-final tilde kinematics
FILightTildeKinematicsFILightTildeKinematics implements the 'tilde' kinematics for a final-initial subtraction dipole
FIMassiveInvertedTildeKinematicsFIMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
FIMassiveTildeKinematicsFIMassiveTildeKinematics implements the 'tilde' kinematics for a final-initial subtraction dipole
FlatInvertibleLabframePhasespaceFlatInvertibleLabframePhasespace implements flat, invertible phase space generation in the lab frame
FlatInvertiblePhasespaceFlatInvertiblePhasespace implements flat, invertible phase space generation
IFLightInvertedTildeKinematicsIFLightInvertedTildeKinematics inverts the final-final tilde kinematics
IFLightTildeKinematicsIFLightTildeKinematics implements the 'tilde' kinematics for a initial-final subtraction dipole
IFMassiveInvertedTildeKinematicsIFMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
IFMassiveTildeKinematicsIFMassiveTildeKinematics implements the 'tilde' kinematics for a initial-final subtraction dipole
IILightInvertedTildeKinematicsIILightInvertedTildeKinematics inverts the final-final tilde kinematics
IILightTildeKinematics
InvertedTildeKinematicsInvertedTildeKinematics is the base class for the inverted 'tilde' kinematics being used for subtraction terms in the formalism of Catani and Seymour
StreamingRndWrap around a vector of random numbers to behave as a stream of those
MatchboxPhasespaceMatchboxPhasespace defines an abstract interface to a phase space generator
MatchboxRamboMatchboxRambo implements RAMBO phase space generation
ReshuffleEquationThe function object defining the equation to be solved
MatchboxReferenceMatchboxReference implements reference sample phase space generation
PhasespaceCouplingsStore couplings for the phasespace generator
TildeKinematicsTildeKinematics is the base class for the 'tilde' kinematics being used for subtraction terms in the formalism of Catani and Seymour
TreePhasespaceTreePhasespace is a multichannel phasespace generator adapting to singularity structures as determined from the matrix elements diagrams
TreePhasespaceChannelsStore channels for the tree phasespace
MatchboxHtScaleMatchboxHtScale implements scale choices related to transverse momenta
MatchboxLeptonMassScaleMatchboxLeptonMassScale implements scale choices related to lepton pair invariant masses
MatchboxLeptonPtScaleMatchboxLeptonPtScale implements scale choices related to lepton pair transverse momenta
MatchboxParticlePtScaleMatchboxParticlePtScale implements scale choices related to transverse momenta
MatchboxPtScaleMatchboxPtScale implements scale choices related to transverse momenta
MatchboxScaleMatchboxScale implements scale choices related to an input formula
MatchboxSHatScaleMatchboxSHatScale implements lastSHat() as scale choice
MatchboxTopMassScaleMatchboxTopMassScale implements a scale choice related to the invariant mass of the top-antitop quark pair
MatchboxTopMinMTScaleMatchboxTopMinMTScale implements a scale choice related to the quadratic sum of transverse masses of a top and antitop quark
MatchboxTopMTScaleMatchboxTopMTScale implements a scale choice related to the average of the transverse masses of a top and antitop quark
MatchboxTopSumMTScaleMatchboxTopSumMTScale implements a scale choice related to the quadratic sum of transverse masses of a top and antitop quark
MatchboxTriVecScalesMatchboxTriVecScales implements scale choices related to transverse momenta and transverse energies in events with up to three vector bosons in the final state, plus additional jets, where the vector bosons are associated to lepton pairs of distinct families
HardProcessAnalysisHere is the documentation of the HardProcessAnalysis class
AllHistogramsOutgoing partons and x distributions
HistogramsDifferential information per outgoing parton
WeightAnalyzerHere is the documentation of the WeightAnalyzer class
ColourBasisColourBasis is an interface to a colour basis implementation
matchRepMatch colour representation
DiagramDrawerDiagramDrawer draws ASCII output from Tree2toNDiagram objects for diagnostic purposes
LastMatchboxXCombInfoProvide easy access to MatchboxXComb XComb extensions
MatchboxFactoryMatcherMatchboxFactoryMatcher matches particles according to MatchboxFatory particle groups
MatchboxScaleChoiceMatchboxScaleChoice is the base class for scale choices within Matchbox
MatchboxXCombMatchbox extensions to StandardXComb
MatchboxXCombDataMatchbox extensions to StandardXComb
ReshuffleEquationHelper struct to define the reshuffling equation
MatchboxXCombGroupMatchbox extensions to StandardXComb
ProcessDataProvide storage for process data
SimpleColourBasisSimpleColourBasis implements the colour algebra needed for electroweak boson and electroweak boson + jet production at NLO. It mainly serves as an example for the general ColourBasis interface
SimpleColourBasis2SimpleColourBasis2 implements the colour algebra needed for processes with four coloured legs at NLO. It mainly serves as an example for the general ColourBasis interface
SpinCorrelationTensorSpinCorrelationTensor represents a spin correlation tensor of the form
SU2HelperHelpers for book keeping in electroweak processes
Tree2toNGeneratorGenerate Tree2toNDiagrams for a given process
LineMatcherHelper for topology restrictions
VertexA node in internally used trees
MEfftoffHBase class for vector boson fusion type processes in Herwig
MEfftoVHBase class for processes
MEee2gZ2llPowhegHere is the documentation of the MEee2gZ2llPowheg class
MEee2gZ2qqPowhegHere is the documentation of the MEee2gZ2qqPowheg class
MEPP2HiggsPowhegImplements the matrix element for the process pp->Higgs with different Higgs shape prescriptions (see details in hep-ph/9505211) and the NLL corrected Higgs width (see details in the FORTRAN HERWIG manual)
MEPP2HiggsVBFPowhegHere is the documentation of the MEPP2HiggsVBFPowheg class
MEPP2VVPowhegHere is the documentation of the MEPP2VVPowheg class
MEPP2WHPowhegNext-to-leading order matrix elements for in assoication with a Higgs boson in the PoOWHEG scheme
MEPP2ZHPowhegImplements the matrix element for
MEqq2gZ2ffPowhegImplements the products of Standard Model fermion antifermion pairs via the resonance including photon interference terms
MEqq2W2ffPowhegImplements the matrix element for including the decay of the to Standard Model fermions
bornVVKinematicsUsed to store information on the the kinematics of the real emission processes needed for the evaluation of matrix elements in the real part of the NLO process
realVVKinematicsUsed to store information on the the kinematics of the real emission processes needed for the evaluation of matrix elements in the real part of the NLO process
ProductionMatrixElementThe storage of the helicity amplitude expression for the matrix element of a hard process
ReweightEWHere is the documentation of the ReweightEW class
ADDModelThis is the class to be used instead of the Standard Model class for the ADD model
ADDModelFFGGRVertexThis is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
ADDModelFFGRVertexThis is the implementation of the Randell-Sundrum model fermion-antifermion tensor vertex for helicity amplitude calculations
ADDModelFFWGRVertexThis is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
ADDModelGGGGRVertexImplementation of the triple vector graviton couling in the ADD model
ADDModelSSGRVertexThew implementation of the graviton coupling to the Higgs in the ADDModel
ADDModelVVGRVertexThis is the implementation of the vector-vector-graviton vertex for the ADD model
ADDModelWWWGRVertexImplementation of the triple vector graviton couling in the ADD model
GravitonMassGeneratorHere is the documentation of the GravitonMassGenerator class
BSMModelHere is the documentation of the BSMModel class
BSMWidthGeneratorThis class is designed to be able to calculate the running width for a BSM particle given the decay mode and partial width calculated from the decayer
BSMWidthExceptionAn exception class to report an error
DecayConstructorInterfaced class that stores a vector of NBodyDecayConstructor objects and calls the appropriate function to create the decayers and decaymodes
FourBodyDecayConstructorHere is the documentation of the FourBodyDecayConstructor class
GenericHGGVertexImplements the coupling of the Higgs boson to gluons in a generic model using the other vertices coupling the Higgs boson to coloured particles
InteractionStruct to store the stuff needed for the vertices
GenericHPPVertexImplements the coupling of the Higgs boson to gluons in a generic model using the other vertices coupling the Higgs boson to coloured particles
InteractionStruct to store the stuff needed for the vertices
HardProcessConstructorHere is the documentation of the HardProcessConstructor class
HiggsVBFProcessConstructorHere is the documentation of the HiggsVBFProcessConstructor class
HiggsVectorBosonProcessConstructorHere is the documentation of the HiggsVectorBosonProcessConstructor class
HPDiagramThe HPDiagram struct contains information about a 2->2 hard-process that has been automatically generated by HardProcessConstructor
ModelGeneratorThis class is designed to store the particles in some model and then call the appropriate function to setup the model
NBodyDecayConstructorBaseThis is the base class for NBodyDecayConstructors
NBodyDecayConstructorErrorAn Exception class that can be used by all inheriting classes to indicate a setup problem
ParticleOrderingA struct to order the particles in the same way as in the DecayMode's
VertexOrderingA struct to order the particles in the same way as in the DecayMode's
PrototypeVertexStorage of a potenital n-body decay
NBVertexA simple vertex for the N-body diagram
NBDiagramThe NBDiagram struct contains information about a decay that has been automatically generated
QQHiggsProcessConstructorHere is the documentation of the QQHiggsProcessConstructor class
ResonantProcessConstructorThis class is designed to construct the diagrams for resonant processes using a provdided set of particles as interemdiates
RPConstructorErrorException class indicating setup problem
TBDiagramThe TBDiagram struct contains information about a decay that has been automatically generated by ThreeBodyDecayConstructor
ThreeBodyDecayConstructorInherits from the dummy base class NBodyDecayConstructorBase and implements the necessary functions in order to create the 3 body decaymodes for a given set of vertices stored in a Model class
TwoBodyDecayStruct for the prototype of a two-body decay mode
TwoBodyDecayConstructorInherits from the dummy base class NBodyDecayConstructorBase and implements the necessary functions in order to create the 2 body decay modes for a given set of vertices stored in a Model class
TwoToTwoProcessConstructorThe TwoToTwoProcessConstructor is designed to construct the diagrams that are possible for a given set of incoming and outgoing particles
TwoToTwoProcessConstructorErrorException class indicating setup problem
VVSLoopVertexThe `VVSLoopVertex`

is designed to calculate the coefficents for the terms in the Passarino-Veltman tensor reduction scheme
WeakCurrentDecayConstructorHere is the documentation of the WeakCurrentDecayConstructor class
LeptoquarkModelHere is the documentation of the LeptoquarkModel class
LeptoquarkModelSLQFFVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
LeptoquarkModelSLQSLQGGVertexImplementation of the gluon gluon coupling to pairs of scalar leptoquarks in the LeptoquarkModel
LeptoquarkModelSLQSLQGVertexImplementation of the gluon coupling to pairs of scalar leptoquarks in the LeptoquarkModel
LHFFGVertexImplements the couplings of the quarks and additional heavy top to the gluon in the Little Higgs model
LHFFHVertexImplements the couplings of the fermions to the Higgs bosons of the Little Higgs model
LHFFPVertexImplements the couplings of the fermions, both of the Standard Model and the additional heavy top to the photon and bosons in the Little Higgs model
LHFFWVertexImplements the couplings of the fermions, both of the Standard Model and the additional heavy top, to the and bosons in the Little Higgs model
LHFFZVertexImplements the couplings of the fermion, both of the Standard Model and the additional heavy top to the and bosons in the Little Higgs model
LHModelMain class for the implementation of the Little Higgs model in Herwig
LHWHHVertexImplements the coupling of an electroweak gauge boson to a pair of Higgs bosons in the Little Higgs model
LHWWHHVertexImplements the coupling of a pair of electroweak gauge bosons and a pair of Higgs bosons in the Little Higgs model
LHWWHVertexImplements the couplings of two electroweak gauge bosons to a Higgs boson in the Little Higgs model including the additional heavy photon, Z and W bosons in the model and the triplet Higgs bosons
LHWWWVertexImplements the triple boson coupling in the Little Higgs model for the electroweak bosons of the Standard Model and the additional , and bosons
LHWWWWVertexImplements the quartic self-couplings of electroweak gauge bosons in the Little Higgs model
LHTPFFGVertexImplements the coupling of the gluon to the coloured fermions, the SM quarks, the extra top-like quark and the T-parity odd quarks of the Little Higgs model with T-parity
LHTPFFHVertexImplements the couplings of the fermions to the Higgs bosons of the Little Higgs model with T-parity
LHTPFFPVertexImplements the couplings of the photon and its heavy partner in the Little Higgs model with T-parity
LHTPFFWVertexImplements the coupling of the and bosons of the Little Higgs model with T-parity to fermions
LHTPFFZVertexImplements the couples of the boson and its heavy partner to the fermions in the Little Higgs model with T-parity
LHTPHHHVertexImplements the triple Higgs boson interactions in the Little Higgs model with T-parity
LHTPModelMain class for the implementation of the Little Higgs model with T-parity
LHTPWHHVertexImplements the coupling of an electroweak gauge boson to a pair of Higgs bosons in the Little Higgs model with T-parity
LHTPWWHVertexThe LittleHiggsWWHVertex class implements the couplings of two electroweak gauge bosons to a Higgs boson in the Little Higgs model with T-parity including the additional heavy photon, Z and W bosons in the model and the triplet Higgs bosons
LHTPWWWVertexThis is the coupling of vector bosons to each other in the Littlest Higgs model with T-parity
RSModelThis is the class to be used instead of the Standard Model class for the Randell Sundrum model
RSModelFFGGRVertexThis is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
RSModelFFGRVertexThis is the implementation of the Randell-Sundrum model fermion-antifermion tensor vertex for helicity amplitude calculations
RSModelFFWGRVertexThis is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
RSModelGGGGRVertexImplementation of the triple vector graviton couling in the RS model
RSModelSSGRVertexThew implementation of the graviton coupling to the Higgs in the RSModel
RSModelVVGRVertexThis is the implementation of the vector-vector-graviton vertex for the RS model
RSModelWWWGRVertexImplementation of the triple vector graviton couling in the RS model
SextetFFSVertexHere is the documentation of the SextetFFSVertex class
SextetFFVVertexHere is the documentation of the SextetFFVVertex class
SextetGGSSVertexHere is the documentation of the SextetGGSSVertex class
SextetGGVVVertexHere is the documentation of the SextetGGVVVertex class
SextetGSSVertexHere is the documentation of the SextetGSSVertex class
SextetGVVVertexHere is the documentation of the SextetGVVVertex class
SextetModelThis class is used instead of the StandardModel class for the
AlphaEMExact reimplementation of the electromagentic coupling in FORTRAN HERWIG and is mainly intended for testing
GenericSVVVertexThe `GenericSVVVertex`

class implements the setCoupling member for the Standard Model effective vertex Higgs-gluon-gluon
GenericVVVVertexThe `GenericVVVVertex`

class implements the setCoupling member for the Standard Model effective vertex EWVector-gluon-gluon
O2AlphaSImplementation of the two-loop in the same way as in FORTRAN HERWIG
RunningMassImplementation of the 1 or 2 loop QCD running mass
RunningMassBaseBase class for running mass calculations
SMFFGVertexThis is the implementation of the Standard Model quark-antiquark gluon vertex
SMFFHVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
SMFFPVertexThis is the implementation of the Standard Model fermion-antifermion photon vertex
SMFFWVertexThis is the implementation of the Standard model coupling of the W to the fermions
SMFFZVertexThis is the implementation of the Standard Model fermion-antifermion Z vertex
SMGGGGVertexImplementation of the Standard Model quartic gluon vertex
SMGGGVertexImplementation of the SM triple gluon vertex
SMHGGVertexThe `SMHGGVertex`

class implements the setCoupling member for the Standard Model effective vertex Higgs-gluon-gluon
SMHHHVertexHere is the documentation of the SMHHHVertex class
SMHPPVertexThe `SMHGGVertex`

class implements the setCoupling member for the Standard Model effective vertex Higgs-gamma-gamma
SMWWHHVertexHere is the documentation of the SMWWHHVertex class
SMWWHVertexThe SMWWHVertex is the implementation of the coupling of two electroweak gauge bosons to the Higgs in the Standard Model
SMWWWVertexThis is the implementation fo the vertex for the coupling of three standard Model electroweak bosons
SMWWWWVertexImplementation of the coupling of four electroweak gauge bosons in the SM
StandardCKMStandardCKM inherits from CKMBase and implements the standard parameterization of the CKM matrix in terms of three angles and a phase
StandardModelThis is the Herwig StandardModel class which inherits from ThePEG Standard Model class and implements additional Standard Model couplings, access to vertices for helicity amplitude calculations etc
MixingElementStruct for the elements of a mixing matrix
MixingMatrixThis class is desinged to store the mixing matrices needed for Susy studies
MixingMatrixErrorException class to indicate problem with mixing matrix
MSSMMain model class to replace the Standard Model when using the Minimal Supersymmetric Standard Model
NMSSMHere is the documentation of the NMSSM class
NMSSMFFHVertexImplements the interactions of the NMSSM Higgs bosons with the Standard Model fermions
NMSSMGGHVertexThis class implements the effective vertex for a higgs coupling to a pair of gluons in the NMSSM
NMSSMGOGOHVertexHere is the documentation of the NMSSMGOGOHVertex class
NMSSMHHHVertexThe NMSSMHHHVertex defines the triple Higgs coupling in the NMSSM
NMSSMHSFSFVertexThis class defines the coupling of Higgs bosons to the sfermions in the NMSSM
NMSSMPPHVertexThis class implements the effective vertex for a higgs coupling to a pair of photons in the NMSSM
NMSSMWHHVertexImplements the coupling of an electroweak" gauge boson with two Higgs bosons in the NMSSM
NMSSMWWHHVertexHere is the documentation of the NMSSMWWHHVertex class
NMSSMWWHVertexImplementation of the coupling of two electroweak gauge bosons to the Higgs bosons of the NMSSM
RPVHere is the documentation of the RPV class
RPVFFSVertexHere is the documentation of the RPVFFSVertex class
RPVFFWVertexHere is the documentation of the RPVFFWVertex class
RPVFFZVertexHere is the documentation of the RPVFFZVertex class
RPVLLEVertexHere is the documentation of the RPVLLEVertex class
RPVLQDVertexHere is the documentation of the RPVLQDVertex class
RPVSSSVertexHere is the documentation of the RPVSSSVertex class
RPVUDDVertexHere is the documentation of the RPVUDDVertex class
RPVWSSVertexHere is the documentation of the RPVWSSVertex class
RPVWWHVertexImplements the couplings of a pair of gauge bosons to scalars in the R-parity violating MSSM
SSCCZVertexThis class implements the coupling of a to a pair of charginos
SSCFSVertexThis is the implementation of the coupling of the charginos to fermion- sfermions
SSCNWVertexThis class is implements the coupling of a W boson to a chargino and a neutralino
SSFFHVertexThe is the coupling of higgs bosons in the MSSM to a pair of SM fermions
SSGFSVertexThis is the implementation of the coupling of a gluino to a squark- quark pair
SSGGSQSQVertexThis is the implementation of the 4 point gluon-gluon-squark-squark vertex
SSGNGVertexThis class implements the coupling of a gluon to a gluino and a neutralino via loop diagrams It inherits from GeneralFFVertex and implements the setCoupling method
SSGOGOHVertexThe is the coupling of higgs bosons in the MSSM to a pair of SM fermions
SSGSGSGVertexThis class implements the g- - vertex
SSGSSVertexThe SSGSSVertex implements the coupling of a gluon to 2 sfermions
SSGVFSVertexThis is the implementation of the coupling of the gravitino to fermion-sfermions
SSGVNHVertexImplements the coupling of the gravitino to a neutralino and Higgs boson
SSGVNVVertexImplements the coupling of the gravitino to a gaugino and the assoicated gauge boson
SSHGGVertexThis class implements the effective vertex coupling a higgs to a pair of gluons in the MSSM
SSHHHVertexThis is the higgs coupling with other higgs bosons in the MSSM
SSHPPVertexThis class implements the effective vertex coupling a higgs to a pair of photons in the MSSM
SSHSFSFVertexThis is the implementation of the coupling for a Higgs in the MSSM to a pair of sfermions
SSNCTVertexHere is the documentation of the SSNCTVertex class
SSNFSVertexThis is the implementation of the coupling of the neutralinos to fermion-sfermions
SSNNPVertexThis class implements the coupling of a photon to a pair of neutralinos via loop diagrams It inherits from GeneralFFVertex and implements the setCoupling method
SSNNZVertexThis class implements the coupling of a Z-boson to a pair of neutralinos
SSWGSSVertexThis is the implementation of the 4 point gluon-gluon-squark-squark vertex
SSWHHVertexThe coupling of a pair of higgs to the SM gauge bosons in the MSSM
SSWSSVertexThis is the implementation of the coupling of an SM gauge boson to a pair of sfermions
SSWWHHVertexHere is the documentation of the SSWWHHVertex class
SSWWHVertexThis class implements the coupling of a higgs in the MSSM to a pair of SM gauge bosons
SusyBaseThis class is designed to be a base class for SUSY models
METRP2to2Implements the matrix elements for Transplanckian scattering process
TTbAModelHere is the documentation of the TTbAModel class
TTbAModelAGQQVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
TTbAModelSU2XVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
TTbAModelWPTDVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
TTbAModelZPQQVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
UEDBaseThis class serves as a base class for all UED models
UEDF1F0G1VertexThis is the implementation of the vertex
UEDF1F0H1VertexThe implementation of the vertex
UEDF1F0W1VertexThis is the coupling, where is any level 1 EW gauge boson
UEDF1F1G0VertexThis is the implementation of the vertex
UEDF1F1P0VertexThis class implements the coupling of a pair of level-1 KK fermions to a standard Model photon
UEDF1F1W0VertexThis class implements the coupling of a pair of level-1 fermions to the SM $W$ boson
UEDF1F1Z0VertexThis is the implementation of the level-1 fermion-fermion Z-boson
UEDG0G0G1G1VertexThis is the implementation of the coupling of two Standard Model gluons to a pair of level 1 KK gluons
UEDG1G1G0VertexThis is the implementation of the Feynman rule for the coupling of Standard Model gluon to a pair of (level1) KK excited gluons
UEDP0H1H1VertexThe implementation of the vertex
UEDW0A1H1VertexThis is the coupling for the vertex
UEDW0W1W1VertexThe coupling for the and vertex
UEDZ0A1h1VertexThis class implements the coupling for the vertex
UEDZ0H1H1VertexThe implementation of the vertex
ZprimeModelHere is the documentation of the ZprimeModel class
ZprimeModelZPQQVertexThis is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
HwRemDecayerResponsible for the decay of the remnants
ExtraSoftScatterVetoStruct that is used to catch exceptions which are thrown due to energy conservation issues of additional soft scatters
HadronContentSimple struct to store info about baryon quark and di-quark constituents
IncomingPhotonEvolverPerforms the backward evolution of a photon in a partonic process to a quark or antiquark so that the event can be showered
MinBiasPDFDefines a modified pdf which uses an existing pdf object to add modifications like removing the valence part of it, which is needed in the backward evolution of secondary scatters
MPIPDFDefines a modified pdf which uses an existing pdf object to add modifications like removing the valence part of it, which is needed in the backward evolution of secondary scatters
MRSTImplementation of the MRST PDFs
PomeronFluxHere is the documentation of the PomeronFlux class
PomeronPDFImplementation of the PomeronPDF PDFs
ReggeonPDFImplementation of the ReggeonPDF PDFs
SatPDFDefines a modified pdf which uses an existing pdf object to add modifications like removing the valence part of it, which is needed in the backward evolution of secondary scatters
BaryonWidthGeneratorDesigned to automatically calculate the running width for a given particle using information from the decayModes and the Baryon1MesonDecayer to construct the running width
GenericMassGeneratorThe `GenericMassGenerator`

class is a simple class for the generation of particle masses in Herwig
GenericWidthGeneratorDesigned to automatically calculate the running width for a given particle using information from the decayModes and the Decayers to construct the running width
OneOffShellCalculatorUse another `WidthCalculatorBase`

object to integrate over the mass of on of the external particles which can be off-shell for running width calculations
OneOffShellIntegrandClass for the integrand of a matrix element where one of the outgoing particles is off-shell.This class is used by the OneOffShellCalculator class to perform the integral
ScalarMassGeneratorThe `ScalarMassGenerator`

class is designed for the generation of the masses of the and mesons which have modes close to the on-shell mass of the particle
SMHiggsMassGeneratorImplements the generation of the Higgs boson mass according to the prescription of hep-ph/9505211
SMHiggsWidthGeneratorCalculates the width for the Standard Model Higgs boson
PhotonMatcherThis file declare a set of standard matcher classes in addition to those defined in ThePEG
TopMatcherA Matcher class which matches top quarks
HadronMatcherA Matcher class which matches any hadron
WBosonMatcherA Matcher class which matches W bosons
ZBosonMatcherA Matcher class which matches Z bosons
HiggsBosonMatcherA Matcher class which matches Higgs bosons
ChargedLeptonMatcherA Matcher class which matches any charged lepton
ThreeBodyAllOn1IntegralCalculatorThe ThreeBodyAllOn1IntegralCalculator class is designed to integrate a function which gives to give the partial width
ThreeBodyAllOnCalculatorThe ThreeBodyAllOnCalculator class is designed to integrate a three-body matrix element in which all the outgoing particles are on-shell to give the partial width
OuterThe class for the outer integrand of the integral of a three body decay matrix element
TwoBodyAllOnCalculatorThe `TwoBodyAllOnCalculator`

class is a wrapped around the the simple two body decay matrix elements in the `GenericWidthGenerator`

class and is designed to allow these matrix elements to be integrated if the external particles can be off-shell
TwoOffShellCalculatorUse `WidthCalculatorBase`

objects to integrate over the mass of two external particles which can be off-shell for running width calculations
TwoOffShellIntegrandClass for the integrand of a matrix element where two of the outgoing particles is off-shell
WidthCalculatorBaseBase class to be used by classes which calculate partial widths for the running width
BinSamplerBinSampler samples XCombs bins. This default implementation performs flat MC integration
NextIterationException to be thrown if cross section information should be updated
RandomNumberHistogramDefine the key for the collinear subtraction data
CellGridSamplerCellGridSampler samples XCombs bins using CellGrids
GeneralSamplerA GeneralSampler class
GeneralStatisticsGeneral Monte Carlo statistics
MonacoSamplerMonacoSampler samples XCombs bins using using Monaco
MultiIterationStatisticsMonte Carlo statistics for multiple iterations
RemapperRemapper adapts indivdual MC dimensions
SelectorEntry
BranchingThe branching struct is used to store information on the branching
InteractionVetoException class used to communicate failure of QED shower
HardBranchingDesigned to contain the information needed for an individual branching in the POWHEG approach
HardTreeDesigned to contain the information required to implement the POWHEG approach for Monte Carlo at next-to-leading order
KinematicsReconstructionVetoException class used to communicate failure of kinematics reconstruction
KinematicsReconstructorThis class is responsible for the kinematical reconstruction after each showering step, and also for the necessary Lorentz boosts in order to preserve energy-momentum conservation in the overall collision, and also the invariant mass and the rapidity of the hard subprocess system
ShowerKinematicsThis is the abstract base class from which all other shower kinematics classes derive
ShowerModelContainer for all the objects needed to implement a specific model of the shower evolution, as opposed to those which are independent of the evolution
ShowerParticleThis class represents a particle in the showering process
EvolutionPartnerStruct for all the info on an evolution partner
EvolutionScalesStruct to store the evolution scales
ShowerProgenitorA struct to store information on the perturbative particle which initiates a shower
ShowerTreeStores the basic information needed for each hard interaction, either a scattering process or decay, which needs to be showered
ShowerVertex
VetoShowerException class for vetoing a showering
ShowerVetoShowerVeto is a general interface for performing vetoes during showering
SudakovFormFactorThis is the definition of the Sudakov form factor class
ShowerAlphaThis class is the abstract class from which all types of running couplings used in the Showering derive from
ShowerAlphaQCDThis concrete class provides the definition of the pure virtual function value() and overestimateValue() for the strong coupling
ShowerAlphaQEDThis concrete class provides the definition of the pure virtual function value(scale) for
Decay_QTildeShowerKinematics1to2This (concrete) class provides the specific decay shower kinematics information
FS_QTildeShowerKinematics1to2This (concrete) class provides the specific Final State shower kinematics information
IS_QTildeShowerKinematics1to2This (concrete) class provides the specific Intial State shower kinematics information
QTildeFinderResponsible for finding the partners and setting the initial evolution scales for the shower evolution described in JHEP 0312:045,2003
QTildeModelInherits from the ShowerModel class and implements the checkConsistency member for the default Herwig Shower
JetKinStructA simple struct to store the information we need on the showering
ColourSingletStruct to store colour singlets
QTildeReconstructorThis class is responsible for the kinematical reconstruction after each showering step, and also for the necessary Lorentz boosts in order to preserve energy-momentum conservation in the overall collision, and also the invariant mass and the rapidity of the hard subprocess system
QTildeShowerKinematics1to2This abstract class describes the common features for initial and final state radiation kinematics for branchings and for the choice of as evolution variable
QTildeSudakovImplements the Sudakov form factor for evolution in using the veto algorithm
CKKWTreeHere is the documentation of the CKKWTree class
MatchingHandlerHere is the documentation of the MatchingHandler class
PotentialTreeStruct to store a potential CKKWTree
PowhegHandlerHere is the documentation of the PowhegHandler class
PowhegShowerHandler
ProtoBranchingClass to store a prototype branching
ProtoTreeClass for a prototype tree
ShowerHandlerThis class is the main driver of the shower: it is responsible for the proper handling of all other specific collaborating classes and for the storing of the produced particles in the event record
ExtraScatterVetoStruct that is used to catch exceptions which are thrown due to energy conservation issues of additional scatters
ShowerTriesVetoStruct that is used to catch exceptions which are thrown due to fact that the Shower has been invoked more than a defined threshold on a certain configuration
HalfHalfOneSplitFnThis class provides the concrete implementation of the exact leading-order splitting function for
HalfOneHalfSplitFnThis classs provides the concrete implementation of the exact leading-order splitting function for
OneHalfHalfSplitFnThis class provides the concrete implementation of the exact leading-order splitting function for
OneOneOneSplitFnThis class provides the concrete implementation of the exact leading-order splitting function for
SplittingFunctionThis is an abstract class which defines the common interface for all splitting functions, for both initial-state and final-state radiation
SplittingGeneratorThis class is responsible for creating, at the beginning of the Run, all the SplittingFunction objects and the corresponding SudakovFormFactor objects, and then of the generation of splittings (radiation emissions) during the event
ZeroZeroOneSplitFnThis class provides the concrete implementation of the exact leading-order splitting function for
UEBaseAbstract base class used to minimize the dependence between MPIHandler and all Shower classes
HerwigCLIHerwigCLI is the default implementation of the HerwigUI interface
HerwigUIHerwigUI is an interface to abstract the command line parameters
DISTestHere is the documentation of the DISTest class
GammaMETestHere is the documentation of the GammaMETest class
GammaPMETestHere is the documentation of the GammaPMETest class
HadronVBFTestHere is the documentation of the HadronVBFTest class
HadronVVTestHere is the documentation of the HadronVVTest class
HTestHere is the documentation of the HTest class
QQHTestHere is the documentation of the QQHTest class
VGammaTestHere is the documentation of the VGammaTest class
VHTestHere is the documentation of the VHTest class
VTestHere is the documentation of the VTest class
WHTestHere is the documentation of the WHTest class
WJetTestHere is the documentation of the WJetTest class
ZHTestHere is the documentation of the ZHTest class
ZJetTestHere is the documentation of the ZJetTest class
FermionTestHere is the documentation of the FermionTest class
TopDecayHere is the documentation of the TopDecay class
VBFTestHere is the documentation of the VBFTest class
VVTestHere is the documentation of the VVTest class
MPIHandlerThis class is responsible for generating additional semi hard partonic interactions
slopeAndTotalXSecA struct for the 2D root finding that is necessary to determine the soft cross section and the soft radius that is needed to describe the total cross section correctly
betaBisectionA struct for the root finding that is necessary to determine the slope of the soft pt spectrum to match the soft cross section
slopeBisectionA struct for the root finding that is necessary to determine the soft cross section and soft mu2 that are needed to describe the total cross section AND elastic slope correctly
TotalXSecBisectionA struct for the root finding that is necessary to determine the soft cross section that is needed to describe the total cross section correctly
slopeIntA struct for the integrand for the slope
EikonalizationA struct for the eikonalization of the inclusive cross section
MPISamplerThis class inherits from SampleBase and implements the Auto Compensating Divide-and-Conquer phase space generator, ACDCGen
MPIXSecReweighterMPIXSecReweighter sets up the proper minimum bias cross section
ProcessHandlerThis class is for handling the sampling of semi hard partonic interactions
StatDocumentation for the statistics struct
UA5HandlerThis is the class definition for the UA5Handler
GaussianIntegrator
GSLBisectionThis class is designed to find the root of a given function between 2 limits using bisection methods
GSLerrorStruct that is used to throw and catch GSL errors
IntervalErrorStruct that is used to throw and catch GSL errors
GSLHelperFrom, which can then be used by the GSL algorithms that need a pointer to a function and don't know about Units
GSLIntegratorThis class is designed to integrate a given function between 2 limits using the gsl QAGS integration subroutine
HerwigStrategySub-class of the Strategy class, simply implementing the correct citation for Herwig in the ClassDocumentation interface
HistogramSimple histogram for the Analysis handlers
BinOne bin of the histogram
Interpolator
RunDirectoriesHandle directories for external library and grid storage
WeakBHadronSelectorSelector to select weakly decaying B hadrons
StatisticSimple class designed to store a variable for statistical analysis
Generated on Thu Dec 3 2015 13:35:19 for Herwig by 1.8.6