Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 123]

NACDCGenerator [external]
►NHerwig	-*- C++ -*-
NAPI	A very high-level API for interacting with Herwig's different run modes
NCheckId	This is a namespace which provides some useful methods for checking the PDG id of particles
NHiggsLoopFunctions	This is a namespace which provides the loop functions from NPB297 (1988) 221-243 which are used to calculate Higgs production with an additional jet and the real correction to \(h^0\to gg\)
NHistogramOptions	Options for histogram output
NKinematics	This is a namespace which provides some useful methods for kinematics computation, as the two body decays
NMath	The Math namespace includes the declaration of some useful mathematical functions
NProcessType	Enumerate the type of calculation required
►NRandomHelpers	Phase space generation utilities
CBreitWigner	The density 1/((x-z)^2 + abs(w z))
CContainer	A density container
CExpression	A density expression
CFlat	A constant density
CGenerator	Define the generator concept
CGenerator< BreitWigner >	Generate x with density 1/((x-z)^2 + abs(w z))
CGenerator< Container< Density > >	Container class for a general density
CGenerator< Expression >	Container base class for a general density
CGenerator< Flat >	Generate x flat
CGenerator< Inverse >	Generate x with density 1/|x-z|
CGenerator< Piecewise< Density, ToBeDefined > >	Generate a piecewise defined density
CGenerator< Piecewise< Density1, Density2 > >	Generate a piecewise defined density
CGenerator< Piecewise< ToBeDefined, ToBeDefined > >	Generate a piecewise defined density
CGenerator< Power >	Generate x with density |(x-z)|^p
CGenerator< Remap< Density > >	Generate a density remapped to a new interval
CGenerator< Rescale< Density > >	Generate a rescaled density
CGenerator< Sum< Density1, Density2 > >	Generate the sum of two densities
CGenerator< Zero >	Generate nothing
CInverse	A density 1/|x-z|
Cmatcher	Indicate that the argument density should be matched to the previous one in a piecewise definition
Con	Indicate remapping of a density
CPiecewise	A piecewise defined density
CPower	The density |(x-z)|^p
CRemap	Remap a density to a new interval
CRescale	Rescale a density
CSum	Add two densities
CToBeDefined	Placeholder when constructing piecewise defined densities
CZero	A zero density
NRunMode	Definition of the possible run modes of Herwig
Ca1SimpleDecayer	Simple model of the decay of the \(a_1\) meson to three pions including \(\rho\) meson intermediate states
Ca1ThreePionCLEODecayer	The a1ThreePionCLEODecayer class is designed to implement the decay of the \(a_1\) 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 \(a_1\) decay in \(\tau \to a_1 -> \pi\pi\pi\)
Ca1ThreePionDecayer	The a1ThreePionDecayer class is designed to implement the decay of the a_1 to three pions
CADDModel	This is the class to be used instead of the Standard Model class for the ADD model
CADDModelFFGGRVertex	This is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
CADDModelFFGRVertex	This is the implementation of the Randell-Sundrum model fermion-antifermion tensor vertex for helicity amplitude calculations
CADDModelFFWGRVertex	This is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
CADDModelGGGGRVertex	Implementation of the triple vector graviton couling in the ADD model
CADDModelSSGRVertex	Thew implementation of the graviton coupling to the Higgs in the ADDModel
CADDModelVVGRVertex	This is the implementation of the vector-vector-graviton vertex for the ADD model
CADDModelWWWGRVertex	Implementation of the triple vector graviton couling in the ADD model
CAlpGenHandlerOL	Here is the documentation of the AlpGenHandlerOL class
CAlphaEM	Exact reimplementation of the electromagentic coupling in FORTRAN HERWIG and is mainly intended for testing
CAnalyticOmnesFunction	Here is the documentation of the AnalyticOmnesFunction class
CBallZwickyScalarFormFactor	This class is the implementation of the form-factors of PRD71 014015 (2005) for the form-factor for the decay of a B-meson to a light pseudoscalar meson
CBallZwickyVectorFormFactor	Implements the form-factors of hep-ph/0412079 for the B meson to light vector mesons
CBaryon1MesonDecayerBase	The Baryon1MesonDecayerBase class is the base class for the decay of a baryon to another baryon and a pseudoscalar or vector meson
CBaryonFactorizedDecayer	Designed to combine the form factor for a weak baryon transition and a weak decay current to produce a decayer
CBaryonFormFactor	Base class for the implementation of the form-factors for the weak decay of a baryon
CBaryonSimpleFormFactor	Simple model for the form-factors for the semi-leptonic decay of the light (i.e
CBaryonThreeQuarkModelFormFactor	Implements the form factors for the semi-leptonic decay of baryons containing a heavy quark from the relativistic three-quark model calculation of PRD56, 348
CBaryonWidthGenerator	Designed to automatically calculate the running width for a given particle using information from the decayModes and the Baryon1MesonDecayer to construct the running width
CBasicConsistency	Simple analysis which performs a basic analysis of the event checking that energy, momentum and charge are conserved and no quarks or clusters are final-state particles
CbetaBisection	A struct for the root finding that is necessary to determine the slope of the soft pt spectrum to match the soft cross section
►CBinSampler	BinSampler samples XCombs bins. This default implementation performs flat MC integration
CNextIteration	Exception to be thrown if cross section information should be updated
CRandomNumberHistogram	Define the key for the collinear subtraction data
CBlobME	BlobME serves as a base class for special processes such as instanton or sphaleron induced ones
CbornVVKinematics	Used 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
CBottomMatcher	A Matcher class which matches bottom quarks
CBranching	The branching struct is used to store information on the branching
CBranchingElement	Typedef to pair the SudakovFormFactor and the particles in a branching
CBranchingInfo	Struct for the multiplcity data
CBranchingRatioReweighter	Designed to reweight events where some decay modes of a particle, or many particles, have been switched off in order to improve the statistics
CBSMModel	Here is the documentation of the BSMModel class
CBSMWidthException	An exception class to report an error
CBSMWidthGenerator	This 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
CBtoSGammaDecayer	Here is the documentation of the BtoSGammaDecayer class
CBtoSGammaFlatEnergy	Model of the hadronic mass is \(B\to s\gamma\) decays which produces a flat photon energy spectrum and as such is only intended for testing purposes
CBtoSGammaHadronicMass	Base class for the implementation of models of the hadronic mass spectrum in \(B\to s\gamma\) decays
CBtoSGammaKagan	Implements the model of hep-ph/9805303 for the hadronic mass spectrum in \(b\to s \gamma\) decays
CCellGridSampler	CellGridSampler samples XCombs bins using CellGrids
CChargedLeptonMatcher	A Matcher class which matches any charged lepton
CChengHeavyBaryonFormFactor	Implements the form-factors from PRD53, 1457 and PRD56, 2799 for the semi-leptonic decay of bottom and charm hadrons
CCKKWTree	Here is the documentation of the CKKWTree class
CCluster	This class describes a cluster object
CClusterDecayer	This class decays the "normal" clusters
CClusterFinder	This class forms clusters from the partons produced in the Shower
CClusterFissioner	This class handles clusters which are too heavy
CClusterHadronizationHandler	Class that controls the cluster hadronization algorithm
CCMWHalfHalfOneSplitFn	This class provides the concrete implementation of the CMW enhanced expressions for the splitting function for \(\frac12\to q\frac12 1\)
CCMWOneOneOneSplitFn	This class provides the concrete implementation of the CMW enhanced expressions for the splitting function for \(1\to 11\)
►CColourBasis	ColourBasis is an interface to a colour basis implementation
CmatchRep	Match colour representation
CColourMatrixElementCorrection	ColourMatrixElementCorrection is implementing colour matrix element corrections through the weighted Sudakov algorithm
CColourReconnector	Class for changing colour reconnections of partons
CColourSinglet	Struct to store colour singlets
►CConstituentReshuffler	Implements reshuffling of partons on their nominal mass shell to their constituent mass shells
CDecayReshuffleEquation	The function object defining the equation to be solved in the case of separate recoilers TODO - refine the whole implementation of separate partons and recoilers
CCrossSectionAnalysis	Here is the documentation of the CrossSectionAnalysis class
CCzyzNucleonFormFactor	Implements the model of Phys.Rev
CDalitzBase	Base class for the implementation of three-body Dalitz decays
CDalitzGS	Implements the Gounaris-Sakurai form of the propagator
CDalitzKMatrix	Allows the use of \(K\)-matrices in Dalitz decays
CDalitzLASS	Implements the LASS parametrization of the \(K\pi\) s-wave
CDalitzResonance	Container class for information on resonances in multi-body dalitz decays
CDalitzSigma	Implements the model of Zou and Bugg for the sigma resonance
CDecay_QTildeShowerKinematics1to2	This (concrete) class provides the specific decay shower kinematics information
CDecayConstructor	Interfaced class that stores a vector of NBodyDecayConstructor objects and calls the appropriate function to create the decayers and decaymodes
►CDecayIntegrator	Main class for Decayers implementing multi-channel phase space integration
CDecayIntegratorError	Exception for this class and those inheriting from it
CDecayMatrixElement	Here is the documentation of the DecayMatrixElement class
CDecayRadiationGenerator	Base class for classes generating QED radiation in particle decays in Herwig
CDecayVertex
CDensityOperator	Here is the documentation of the DensityOperator class
CDiagramDrawer	DiagramDrawer draws ASCII output from Tree2toNDiagram objects for diagnostic purposes
CDipole	Used by the dipole shower to represent a dipole of two coloured partons
CDipoleChain	Used by the dipole shower to represent a chain of dipoles
CDipoleChainOrdering	DipoleChainOrdering performs ordering on complete colour singlet dipole chains
►CDipoleEventRecord	used internally by the dipole shower
CgetMomentum
CDipoleEventReweight	Reweight full final states produced by the shower
CDipoleEvolutionOrdering	DipoleEvolutionOrdering defines a particular evolution algortihm for the dipole shower
CDipoleIndex	DipoleIndex is used to index splitting generators for a particular dipole
CDipoleIOperator	DipoleIOperator implements the I(\epsilon) insertion operator
CDipoleMatching	DipoleMatching implements NLO matching with the dipole shower
CDipoleMCCheck	DipoleMCCheck is used to perform checks for the dipole shower
CDipoleMIOperator	DipoleMIOperator implements the I(\epsilon) insertion operator for the massive case. DipoleMIOperator does only apply for expanded con- vention and also not for dimensional reduction
CDipoleMPKOperator	DipoleMPKOperator implements the P+K insertion operator for the massive case. DipoleMPKOperator does not apply for dimen- sional reduction
CDipolePartonSplitter	The DipolePartonSplitter is a helper class to fix up colour and mother-child relations in typical shower splittings
CDipolePKOperator	DipolePKOperator implements the P+K insertion operator
CDipoleRepository	Repository of known subtraction dipoles
►CDipoleShowerHandler	Manages the showering using the dipole shower algorithm
CRedoShower	Indicate a problem in the shower
CDipoleShowerParticle
CDipoleShowerVertex	This class represents the vertex for a given splitting in the dipole shower
CDipoleSplittingGenerator	DipoleSplittingGenerator is used by the dipole shower to sample splittings from a given dipole splitting kernel
CDipoleSplittingInfo	DipoleSplittingInfo contains all parameters to generate a full dipole splitting
CDipoleSplittingKernel	DipoleSplittingKernel is the base class for all kernels used within the dipole shower
CDipoleSplittingKinematics	DipoleSplittingKinematics is the base class for dipole splittings as performed in the dipole shower
CDipoleSplittingReweight	DipoleSplittingReweight is used by the dipole shower to reweight splittings from a given dipole splitting kernel
CDipoleVertexRecord	Here is the documentation of the DipoleVertexRecord class
CDISBase	Base class for the implementation of DIS type processes including corrections in both the old fashioned matrix element and POWHEG approaches
CDISTest	Here is the documentation of the DISTest class
CDMDMMediatorVertex	Implements the coupling of the dark matter to the mediator
CDMMediatorQuarksVertex	Implements the couplings of the quarks to the mediator
CDMModel	Designed to implement a simple dark matter mode with fermionic dark matter and a vector mediator, as described in arXiv:1911.11147
CDrellYanBase	Class provides a base class for the implemented of Drell-Yan type processes and provides the matrix element and POWHEG style hard corrections
CDrellYanPT	This AnalysisHandler books histograms of the weak boson's pt in Drell-Yan processes
CEikonalization	A struct for the eikonalization of the inclusive cross section
CEtaOmegaCurrent	Implements the current for $\eta\omega$ using the results of Phys.Rev
CEtaPhiCurrent	Implements the current for $\eta\phi$ using the results of Phys.Atom.Nucl
CEtaPhotonCurrent	Implements the decay current for \(\eta \gamma\) via intermediate \(\rho,\omega,\phi,\omega^\prime\)
CEtaPiGammaGammaDecayer	The EtaPiGammaGammaDecayer class implements a VMD model matrix element for \(\eta,\eta'\to \pi^0 \gamma \gamma\) taken from hep-ph/0112150
CEtaPiPiCurrent	Implements the weak current for two pions and the \(\eta\) meson
CEtaPiPiDefaultCurrent	Implements the current from Z.Phys.C58:445 (1992), for \( \pi^- \pi^0 \eta \)
CEtaPiPiFermionsDecayer	The EtaPiPiFermionsDecayer class implements the decay of the \(\eta\) or \(\eta'\) to \(\pi^+\pi^-\gamma\) using either a VMD type model or a model using either the theoretical or experimental form of the Omnes function taken from hep-ph/0112150
CEtaPiPiGammaDecayer	The EtaPiPiGammaDecayer class implements the decay of the \(\eta\) or \(\eta'\) to \(\pi^+\pi^-\gamma\) using either a VMD type model or a model using either the theoretical or experimental form of the Omnes function taken from hep-ph/0112150
CEtaPiPiPiDecayer	The EtaPiPiPiDecayer class is designed for the simulation of the decay of the \(\eta\) or \(\eta'\) to either \(\pi^+\pi^-\pi^0\) or \(\pi^0\pi^0\pi^0\) and the decay of the \(\eta'\) to \(\pi^+\pi^-\eta\) or \(\pi^0\pi^0\eta\)
CEtaPrimePiPiCurrent	Implements the weak current for two pions and the \(\eta^\prime\) meson
CEvtGenDecayer	Designed to allow the EvtGen decay package to be used as a Decayer in the Herwig structure
CEvtGenInterface	Main class for the use of the EvtGen decay package with Herwig
CEvtGenRandom	The EvtGenRamdom class is a wrapper around the RandomGenerator class of ThePEG so that when running Herwig with EvtGen the same random number generator is used for both
CExperimentalOmnesFunction	Here is the documentation of the ExperimentalOmnesFunction class
Cf1FourPiDecayer	Here is the documentation of the f1FourPiDecayer class
Cf1RhoPiPiDecayer	Here is the documentation of the f1RhoPiPiDecayer class
CFermionTest	Here is the documentation of the FermionTest class
CFFDipole	Generates radiation from a final-final dipole for the generation of photons in decay by the SOPTHY algorithm
CFFggxDipole	FFggxDipole implements the D_{g,g;k} subtraction dipole
CFFgx2ggxDipoleKernel	FFgx2ggxDipoleKernel implements the g -> gg splitting off a final-final dipole
CFFgx2qqxDipoleKernel	FFgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-final dipole
CFFLightInvertedTildeKinematics	FFLightInvertedTildeKinematics inverts the final-final tilde kinematics
CFFLightKinematics	FFLightKinematics implements massless splittings off a final-final dipole
CFFLightTildeKinematics	FFLightTildeKinematics implements the 'tilde' kinematics for a final-final subtraction dipole
CFFMassiveInvertedTildeKinematics	FFMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
CFFMassiveKinematics	FFMassiveKinematics implements massive splittings off a final-final dipole
CFFMassiveTildeKinematics	FFMassiveTildeKinematics implements the 'tilde' kinematics for a final-final subtraction dipole
CFFMggxDipole	FFMggxDipole implements the D_{g,g;k} subtraction dipole
CFFMgx2ggxDipoleKernel	FFMgx2ggxDipoleKernel implements the g -> gg splitting off a final-final dipole
CFFMgx2qqxDipoleKernel	FFMgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-final dipole
CFFMqgxDipole	FFMqgxDipole implements the D_{Q,g;k} subtraction dipole, as well as the D_{gluino,g;k} subtraction dipole
CFFMqqxDipole	FFMqqxDipole implements the D_{q,qbar;k} subtraction dipole
CFFMqx2qgxDipoleKernel	FFMqx2qgxDipoleKernel implements the q -> qg splitting off a final-final dipole
CFFMsqgxDipole	FFMsqgxDipole implements the D_{sq,g;k} subtraction dipole
CFFqgxDipole	FFqgxDipole implements the D_{q,g;k} subtraction dipole
CFFqqxDipole	FFqqxDipole implements the D_{q,qbar;k} subtraction dipole
CFFqx2qgxDipoleKernel	FFqx2qgxDipoleKernel implements the q -> qg splitting off a final-final dipole
CFFSDecayer	Implements the decay of a fermion to a fermion and a vector in a general model
CFFVCurrentDecayer	Here is the documentation of the FFVCurrentDecayer class
CFFVDecayer	Implements the decay of a fermion to a fermion and a vector in a general model
CFIggxDipole	FIggxDipole implements the D_{g,g}^a subtraction dipole
CFIgx2ggxDipoleKernel	FIgx2ggxDipoleKernel implements the g -> gg splitting off a final-initial dipole
CFIgx2qqxDipoleKernel	FIgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-initial dipole
CFILightInvertedTildeKinematics	FILightInvertedTildeKinematics inverts the final-final tilde kinematics
CFILightKinematics	FILightKinematics implements massless splittings off a final-initial dipole
CFILightTildeKinematics	FILightTildeKinematics implements the 'tilde' kinematics for a final-initial subtraction dipole
CFIMassiveDecayKinematics	FIMassiveDecayKinematics implements massive splittings off a final-initial decay dipole
CFIMassiveInvertedTildeKinematics	FIMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
CFIMassiveKinematics	FIMassiveKinematics implements massless splittings off a final-initial dipole
CFIMassiveTildeKinematics	FIMassiveTildeKinematics implements the 'tilde' kinematics for a final-initial subtraction dipole
CFIMDecaygx2ggxDipoleKernel	FIMDecaygx2ggxDipoleKernel implements the g -> gg splitting off a final-initial decay dipole and includes the contribution from the splitting of the intial / decay particle
CFIMDecaygx2qqxDipoleKernel	FIMDecaygx2qqxDipoleKernel implements the g -> qq splitting off a final-initial decay dipole
CFIMDecayqx2qgxDipoleKernel	FIMDecayqx2qgxDipoleKernel implements the q -> qg splitting off a final-initial decay dipole and includes the contribution from the splitting of the intial / decay particle
CFIMgx2qqxDipoleKernel	FIMgx2qqxDipoleKernel implements the g -> qqbar splitting off a final-initial dipole
CFIMqgxDipole	FIMqgxDipole implements the D_{Q,g}^a subtraction dipole, as well as the D_{gluino,g}^a subtraction dipole
CFIMqqxDipole	FIMqqxDipole implements the D_{q,qbar}^a subtraction dipole
CFIMqx2qgxDipoleKernel	FIMqx2qgxDipoleKernel implements the q -> qg splitting off a final-initial dipole
CFIMsqgxDipole	FIMsqgxDipole implements the D_{sq,g}^a subtraction dipole
CFIqgxDipole	FIqgxDipole implements the D_{q,g}^a subtraction dipole
CFIqqxDipole	FIqqxDipole implements the D_{q,qbar}^a subtraction dipole
CFIqx2qgxDipoleKernel	FIqx2qgxDipoleKernel implements the q -> qg splitting off a final-initial dipole
CFivePionCurrent	Here is the documentation of the FivePionCurrent class
CFlatInvertibleLabframePhasespace	FlatInvertibleLabframePhasespace implements flat, invertible phase space generation in the lab frame
CFlatInvertiblePhasespace	FlatInvertiblePhasespace implements flat, invertible phase space generation
CFlatteResonance	Implements the Flatte line-shape for resonances in Dalitz decays
CFlavourInfo
CFourBodyDecayConstructor	Here is the documentation of the FourBodyDecayConstructor class
CFourPionCzyzCurrent	The FourMesonCzyzCurrent class implements the currents from Phys.Rev
CFourPionNovosibirskCurrent	The FourPionNovosibirskCurrent class implements the decay of the weak current to 4 pions using the hadronic currents of Comput
CFrixionePhotonSeparationCut	This class implements a cut on legoplot and rapidity separation
CFRSDecayer	Implements the decay of a fermion to a spin-3/2 fermion and a vector in a general model
CFRVDecayer	Implements the decay of a fermion to a spin-3/2 fermion and a vector in a general model
CFS_QTildeShowerKinematics1to2	This (concrete) class provides the specific Final State shower kinematics information
CFtoFFFDecayer	General matrix elements for the decay of a (anti)fermion to three (anti)fermions
CFtoFVVDecayer	General matrix elements for the decay of a fermion to a fermion and two vector bosons
CFullShowerVeto	Here is the documentation of the FullShowerVeto class
CFxFxHandler	Here is the documentation of the FxFxHandler class
CGammaGammaAnalysis	GammaGammaAnalysis is for the analysis of events with a pair of hard photons produced
CGammaJetAnalysis	GammaJetAnalysis selects the photon with the hightest pt in the final state and books a number of histograms from its four momentum
CGammaMETest	Here is the documentation of the GammaMETest class
CGammaPMETest	Here is the documentation of the GammaPMETest class
CGaussianIntegrator
CGeneralCurrentDecayer	Here is the documentation of the GeneralCurrentDecayer class
CGeneralDecayMatrixElement
CGeneralfftoffH	Here is the documentation of the GeneralfftoffH class
CGeneralfftoVH	Here is the documentation of the GeneralfftoVH class
CGeneralFourBodyDecayer	Here is the documentation of the GeneralFourBodyDecayer class
CGeneralHardME	This 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
CGeneralQQHiggs	Implements the matrix elements for \(gg\to Q \bar Q h^0\) and \(q\bar q\to Q \bar Q h^0\)
CGeneralSampler	A GeneralSampler class
CGeneralStatistics	General Monte Carlo statistics
CGeneralThreeBodyDecayer	Here is the documentation of the GeneralThreeBodyDecayer class
CGeneralTwoBodyDecayer	Designed to be the base class for 2 body decays for some general model
►CGenericHGGVertex	Implements the coupling of the Higgs boson to gluons in a generic model using the other vertices coupling the Higgs boson to coloured particles
CInteraction	Struct to store the stuff needed for the vertices
►CGenericHPPVertex	Implements the coupling of the Higgs boson to gluons in a generic model using the other vertices coupling the Higgs boson to coloured particles
CInteraction	Struct to store the stuff needed for the vertices
CGenericMassGenerator	The GenericMassGenerator class is a simple class for the generation of particle masses in Herwig
CGenericOLPAmplitude	GenericOLPAmplitude implements OLP interfaces
CGenericSVVVertex	The GenericSVVVertex class implements the setCoupling member for the Standard Model effective vertex Higgs-gluon-gluon
CGenericVVVVertex	The GenericVVVVertex class implements the setCoupling member for the Standard Model effective vertex EWVector-gluon-gluon
CGenericWidthGenerator	Designed to automatically calculate the running width for a given particle using information from the decayModes and the Decayers to construct the running width
CGluonMassGenerator	Dynamic gluon mass generator; the default returns a constant mass
CGoSamAmplitude	GoSamAmplitude implements an interface to GoSam
Cgosamprocinfo
CGravitonMassGenerator	Here is the documentation of the GravitonMassGenerator class
►CGSLBisection	This class is designed to find the root of a given function between 2 limits using bisection methods
CGSLerror	Struct that is used to throw and catch GSL errors
CIntervalError	Struct that is used to throw and catch GSL errors
CGSLHelper	From, which can then be used by the GSL algorithms that need a pointer to a function and don't know about Units
CGSLIntegrator	This class is designed to integrate a given function between 2 limits using the gsl QAGS integration subroutine
CHadronInfo	Class used to store all the hadron information for easy access
CHadronMatcher	A Matcher class which matches any hadron
CHadronSelector	This class selects the hadron flavours of a cluster decay
CHadronVBFTest	Here is the documentation of the HadronVBFTest class
CHadronVVTest	Here is the documentation of the HadronVVTest class
CHalfHalfOneEWSplitFn	Implements the splitting function for \(\frac12\to q\frac12 1\) where the spin-1 particle is a massive electroweak gauge boson
CHalfHalfOneSplitFn	This class provides the concrete implementation of the exact leading-order splitting function for \(\frac12\to q\frac12 1\)
CHalfHalfZeroEWSplitFn	Implements the splitting function for \(\frac12\to q\frac12 h\) where the spin-0 higgs particle is a massive scalar boson
CHalfOneHalfSplitFn	This classs provides the concrete implementation of the exact leading-order splitting function for \(\frac12\to 1\frac12\)
CHardBranching	Designed to contain the information needed for an individual branching in the POWHEG approach
►CHardProcessAnalysis	Here is the documentation of the HardProcessAnalysis class
CAllHistograms	Outgoing partons and x distributions
CHistograms	Differential information per outgoing parton
CHardProcessConstructor	Here is the documentation of the HardProcessConstructor class
CHardScaleProfile	HardScaleProfile is the base class for profile scales. A few standard choices are provided by this implementation
CHardTree	Designed to contain the information required to implement the POWHEG approach for Monte Carlo at next-to-leading order
CHardVertex
CHeavyDecayer	This class is designed for the partonic decay of a bottom or charm mesons and baryons and is intended to be the same as that in HERWIG6.4
CHeavyMesonWidthGenerator	Calculates the running width for heavy mesons
CHerwigCLI	HerwigCLI is the default implementation of the HerwigUI interface
CHerwigStrategy	Sub-class of the Strategy class, simply implementing the correct citation for Herwig in the ClassDocumentation interface
CHerwigUI	HerwigUI is an interface to abstract the command line parameters
CHiggsBosonMatcher	A Matcher class which matches Higgs bosons
CHiggsJetAnalysis	HiggsJetAnalysis assumes that there is one Higgs in the final state and books some observables computed from its four momentum
CHiggsPair	Implements the matrix elements for HiggsPairian \(2\to2\) scattering process
CHiggsVBFProcessConstructor	Here is the documentation of the HiggsVBFProcessConstructor class
CHiggsVectorBosonProcessConstructor	Here is the documentation of the HiggsVectorBosonProcessConstructor class
►CHistogram	Simple histogram for the Analysis handlers
CBin	One bin of the histogram
CHistoryStep
CHJetsAnalysis	Here is the documentation of the HJetsAnalysis class
CHPDiagram	The HPDiagram struct contains information about a 2->2 hard-process that has been automatically generated by HardProcessConstructor
CHQETFormFactor	Implements the form factors for the decay of B mesons into D and \(D^*\) mesons using form factors based on Heavy Quark Effective theory of the parameterisation of hep-ph/9712417 away from the heavy quark limit
CHQETRadiativeDecayer	Implements the electromagnetic decays of excited heavy, i.e
CHQETStrongDecayer	Implements the strong decays of excited heavy, i.e
CHTest	Here is the documentation of the HTest class
CHw64Decayer	Hw64Decayer is a class that defines all the general routines used in HERWIG++ to imitate the HERWIG 6.4 decays
CHw64Selector	Selects the hadrons produced in cluster decay using the FORTRAN HERWIG variant of the cluster model
CHw7Selector	Selects the hadrons produced in cluster decay using the Herwig variant of the cluster model
CHwDecayerBase	Base class for Decayers in Herwig
CHwDecayHandler	The HwDecayHandler is the Herwig decay handler which administers the decays of unstable particles in Herwig
CHwMEBase	Serves a number of purposes
CHwppSelector	Selects the hadrons produced in cluster decay using the Herwig variant of the cluster model
►CHwRemDecayer	Responsible for the decay of the remnants
CExtraSoftScatterVeto	Struct that is used to catch exceptions which are thrown due to energy conservation issues of additional soft scatters
CHadronContent	Simple struct to store info about baryon quark and di-quark constituents
CIdentifiedParticleCut	IdentifiedParticleCut implements cuts on single momenta
CIFDipole	Generates radiation from a final-final dipole for the generation of photons in decay by the SOPTHY algorithm
CIFggxDipole	IFggxDipole implements the D^{g,g}_k subtraction dipole
CIFgqxDipole	IFgqxDipole implements the D_k^{g,q} subtraction dipole
CIFgx2ggxDipoleKernel	IFgx2ggxDipoleKernel implements the g -> gg splitting off an initial-final dipole
CIFgx2qqxDipoleKernel	IFgx2qqxDipoleKernel implements the g -> qq splitting off an initial-final dipole
CIFLightInvertedTildeKinematics	IFLightInvertedTildeKinematics inverts the final-final tilde kinematics
CIFLightKinematics	IFLightKinematics implements massless splittings off an initial-final dipole
CIFLightTildeKinematics	IFLightTildeKinematics implements the 'tilde' kinematics for a initial-final subtraction dipole
CIFMassiveDecayKinematics	IFMassiveDecayKinematics implements massive splittings off an initial-final decay dipole
CIFMassiveInvertedTildeKinematics	IFMassiveInvertedTildeKinematics inverts the final-final tilde kinematics
CIFMassiveKinematics	IFMassiveKinematics implements massless splittings off an initial-final dipole
CIFMassiveTildeKinematics	IFMassiveTildeKinematics implements the 'tilde' kinematics for a initial-final subtraction dipole
CIFMggxDipole	IFMggxDipole implements the D^{g,g}_k subtraction dipole
CIFMgqxDipole	IFMgqxDipole implements the D_k^{g,q} subtraction dipole
CIFMgx2ggxDipoleKernel	IFMgx2ggxDipoleKernel implements the g -> gg splitting off an initial-final dipole
CIFMgx2qqxDipoleKernel	IFMgx2qqxDipoleKernel implements the g -> qq splitting off an initial-final dipole
CIFMqgxDipole	IFMqgxDipole implements the D^{q,g}_k subtraction dipole
CIFMqqxDipole	IFMqqxDipole implements the D^{q,qbar}_k subtraction dipole
CIFMqx2gqxDipoleKernel	IFMqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-final dipole
CIFMqx2qgxDipoleKernel	IFMqx2qgxDipoleKernel implements the q -> qg splitting off an initial-final dipole
CIFqgxDipole	IFqgxDipole implements the D^{q,g}_k subtraction dipole
CIFqqxDipole	IFqqxDipole implements the D^{q,qbar}_k subtraction dipole
CIFqx2gqxDipoleKernel	IFqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-final dipole
CIFqx2qgxDipoleKernel	IFqx2qgxDipoleKernel implements the q -> qg splitting off an initial-final dipole
CIIggxDipole	IIggxDipole implements the D^{g,g;b} subtraction dipole
CIIgqxDipole	IIgqxDipole implements the D^{g,q,k} subtraction dipole
CIIgx2ggxDipoleKernel	IIgx2ggxDipoleKernel implements the g -> gg splitting off an initial-initial dipole
CIIgx2qqxDipoleKernel	IIgx2qqxDipoleKernel implements the g -> qq splitting off an initial-initial dipole
CIILightInvertedTildeKinematics	IILightInvertedTildeKinematics inverts the final-final tilde kinematics
CIILightKinematics	IILightKinematics implements massless splittings off an initial-initial dipole
CIILightTildeKinematics
CIIqgxDipole	IIqgxDipole implements the D^{q,g;b} subtraction dipole
CIIqqxDipole	IIqqxDipole implements the D^{q,qbar;b} subtraction dipole
CIIqx2gqxDipoleKernel	IIqx2gqxDipoleKernel implements the q -> gqbar splitting off an initial-initial dipole
CIIqx2qgxDipoleKernel	IIqx2qgxDipoleKernel implements the q -> qg splitting off an initial-initial dipole
CIncomingPhotonEvolver	Performs the backward evolution of a photon in a partonic process to a quark or antiquark so that the event can be showered
CInterpolator
CIntrinsicPtGenerator	IntrinsicPtGenerator generates intrinsic pt for massless incoming partons in a shower independent way
CInvariantMassCut	This class implements a cut on the invariant mass
CInvertedTildeKinematics	InvertedTildeKinematics is the base class for the inverted 'tilde' kinematics being used for subtraction terms in the formalism of Catani and Seymour
CIS_QTildeShowerKinematics1to2	This (concrete) class provides the specific Intial State shower kinematics information
CISGW2FormFactor	Implementation of the ISGW2 model of Phys
CISGWFormFactor	Implementation of the ISGW model of Phys
CJetKinStruct	A simple struct to store the information we need on the showering
►CJetsPlusAnalysis	Here is the documentation of the JetsPlusAnalysis class
CObjectProperties	Collection of object histograms; ranges are adjusted to the maximum, so range constraints and rebinning can be applied later
CPairProperties	Collection of pair histograms; ranges are adjusted to the maximum, so range constraints and rebinning can be applied later
CKaganIntegrand	A struct for the integrand which can access the dimensional value member of the BtoSGammaKagan class
CKinematicsReconstructionVeto	Exception class used to communicate failure of kinematics reconstruction
CKinematicsReconstructor	This 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
CKiselevBcFormFactor	Implements the form factors from hep-ph/0211021 for the decays of \(B_c\) mesons
CKKPiCurrent	Here is the documentation of the KKPiCurrent class
CKMatrix	Base class for the implementation of K-matrix parameterizations in Herwig
CKornerKramerCharmDecayer	The KornerKramerCharmDecayer class implements the model of Z.Phys.C55,659 (1992) for the non-leptonic decay of charm baryons
CKornerKurodaFormFactor	Implements the simple model of PRD 16, 2165, 1997 for the form factors of the baryon octet/
CKPiCurrent	Here is the documentation of the KPiCurrent class
CKPiIHalfFOCUSKMatrix	Implements the K-matrix fit of the FOCUS collaboration (Phys.Lett
CKPiIThreeHalfFOCUSKMatrix	Implements the K-matrix fit of the FOCUS collaboration (Phys.Lett
CKPiKStarCurrent	Weak current for the production of two mesons via the \(\rho\) or \(K^*\) resonances
CKrknloEventReweight
CKupco	Class designed to make STL routines easy to use
CLambdabExcitedLambdacSumRuleFormFactor	The LambdabExcitedLambdacSumRuleFormFactor class implements the form-factors of hep-ph/0012114 for the decay of the \(Lambda_b^0\) to excited \(\Lambda^+_c\) states
CLastMatchboxXCombInfo	Provide easy access to MatchboxXComb XComb extensions
CLEPBMultiplicity	The LEPBBMultiplicity class is designed to compare the production rates of \(B^+\), \(B^0\), \(B^0_s\) and B-baryons in B events at LEP
CLEPEventShapes	Performs the analysis of global event shapes and compares with LEP data
CLEPMultiplicityCount	Designed to count particle multiplicities and compare them to LEP data
CLeptonNeutrinoCurrent	This class implements the weak decay current for a lepton and a neutrino
►CLeptonsJetsAnalysis	Here is the documentation of the LeptonsJetsAnalysis class
CObjectProperties	Collection of object histograms; ranges are adjusted to the maximum, so range constraints and rebinning can be applied later
CPairProperties	Collection of pair histograms; ranges are adjusted to the maximum, so range constraints and rebinning can be applied later
CTripleProperties	Collection of triple histograms; ranges are adjusted to the maximum, so range constraints and rebinning can be applied later
CLeptoquarkModel	Here is the documentation of the LeptoquarkModel class
CLeptoquarkModelSLQFFVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CLeptoquarkModelSLQSLQGGVertex	Implementation of the gluon gluon coupling to pairs of scalar leptoquarks in the LeptoquarkModel
CLeptoquarkModelSLQSLQGVertex	Implementation of the gluon coupling to pairs of scalar leptoquarks in the LeptoquarkModel
CLHFFGVertex	Implements the couplings of the quarks and additional heavy top to the gluon in the Little Higgs model
CLHFFHVertex	Implements the couplings of the fermions to the Higgs bosons of the Little Higgs model
CLHFFPVertex	Implements the couplings of the fermions, both of the Standard Model and the additional heavy top to the photon and \(A_H\) bosons in the Little Higgs model
CLHFFWVertex	Implements the couplings of the fermions, both of the Standard Model and the additional heavy top, to the \(W^\pm\) and \(W_H^\pm\) bosons in the Little Higgs model
CLHFFZVertex	Implements the couplings of the fermion, both of the Standard Model and the additional heavy top to the \(Z^0\) and \(Z_H\) bosons in the Little Higgs model
CLHModel	Main class for the implementation of the Little Higgs model in Herwig
CLHTPFFGVertex	Implements 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
CLHTPFFHVertex	Implements the couplings of the fermions to the Higgs bosons of the Little Higgs model with T-parity
CLHTPFFPVertex	Implements the couplings of the photon and its heavy partner \(A_H\) in the Little Higgs model with T-parity
CLHTPFFWVertex	Implements the coupling of the \(W^\pm\) and \(W^\pm_H\) bosons of the Little Higgs model with T-parity to fermions
CLHTPFFZVertex	Implements the couples of the \(Z^0\) boson and its heavy partner to the fermions in the Little Higgs model with T-parity
CLHTPHHHVertex	Implements the triple Higgs boson interactions in the Little Higgs model with T-parity
CLHTPModel	Main class for the implementation of the Little Higgs model with T-parity
CLHTPWHHVertex	Implements the coupling of an electroweak gauge boson to a pair of Higgs bosons in the Little Higgs model with T-parity
CLHTPWWHVertex	The 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
CLHTPWWWVertex	This is the coupling of vector bosons to each other in the Littlest Higgs model with T-parity
CLHWHHVertex	Implements the coupling of an electroweak gauge boson to a pair of Higgs bosons in the Little Higgs model
CLHWWHHVertex	Implements the coupling of a pair of electroweak gauge bosons and a pair of Higgs bosons in the Little Higgs model
CLHWWHVertex	Implements 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
CLHWWWVertex	Implements the triple boson coupling in the Little Higgs model for the electroweak bosons of the Standard Model and the additional \(A_H\), \(Z_H\) and \(W_H^\pm\) bosons
CLHWWWWVertex	Implements the quartic self-couplings of electroweak gauge bosons in the Little Higgs model
CLightBaryonQuarkModelFormFactor	The LightBaryonQuarkModelFormFactor class implements the quark model calculation of hep-ph/9409272 for the form-factors for the decay of baryons containing the light quarks
CLightClusterDecayer	This class performs the decay of light clusters into a single hadron
CLightParticleMatcher	A Matcher class which matches any light (<1GeV) particles other than the photon
CLPairAnalysis	Designed to analyse lepton pairs
CMadGraphAmplitude	MadGraphAmplitude implements an interface to MadGraph
CMamboDecayer	Inherits from the Decayer class in ThePEG and implements the algorithm of R.Kleiss and W.J.Stirling NPB 385 (1992) 413-432 for massive multi-particle phase-space decays
CMassCutOff	Here is the documentation of the MassCutOff class
CMatchboxAmplitude	MatchboxAmplitude is the base class for amplitude implementations inside Matchbox
CMatchboxAmplitudeggttbar	MatchboxAmplitudeggttbar
CMatchboxAmplitudeggttbarg	MatchboxAmplitudeggttbarg
CMatchboxAmplitudehbbbar	MatchboxAmplitudehbbbar
CMatchboxAmplitudehbbbarg	MatchboxAmplitudehbbbarg
CMatchboxAmplitudehgg	MatchboxAmplitudehgg
CMatchboxAmplitudehggg	MatchboxAmplitudehggg
CMatchboxAmplitudehqqbarg	MatchboxAmplitudehqqbarg
CMatchboxAmplitudellbarqqbar	MatchboxAmplitudellbarqqbar
CMatchboxAmplitudellbarqqbarg	MatchboxAmplitudellbarqqbarg
CMatchboxAmplitudellbarqqbargg	MatchboxAmplitudellbarqqbargg
CMatchboxAmplitudellbarqqbarqqbar	MatchboxAmplitudellbarqqbarqqbar
CMatchboxAmplitudelnuqqbar	MatchboxAmplitudelnuqqbar
CMatchboxAmplitudelnuqqbarg	MatchboxAmplitudelnuqqbarg
CMatchboxAmplitudelnuqqbargg	MatchboxAmplitudelnuqqbargg
CMatchboxAmplitudelnuqqbarqqbar	MatchboxAmplitudelnuqqbarqqbar
CMatchboxAmplitudeqqbarttbar	MatchboxAmplitudeqqbarttbar
CMatchboxAmplitudeqqbarttbarg	MatchboxAmplitudeqqbarttbarg
CMatchboxCurrents	MatchboxCurrents
CMatchboxDeltaRCut	MatchboxDeltaRCut implements cuts related to the separation in the legoplot plane
►CMatchboxFactory	MatchboxFactory automatically sets up a NLO QCD calculation carried out in dipole subtraction
CSplittingChannel	Identify a splitting channel
CMatchboxFactoryMatcher	MatchboxFactoryMatcher matches particles according to MatchboxFatory particle groups
CMatchboxHtScale	MatchboxHtScale implements scale choices related to transverse momenta
CMatchboxHybridAmplitude	MatchboxHybridAmplitude unifies two amplitude objects to provide tree and one-loop matrix elements
CMatchboxInsertionOperator	MatchboxInsertionOperator is the base class for insertion operators
CMatchboxLeptonMassScale	MatchboxLeptonMassScale implements scale choices related to lepton pair invariant masses
CMatchboxLeptonPtScale	MatchboxLeptonPtScale implements scale choices related to lepton pair transverse momenta
►CMatchboxMEBase	MatchboxMEBase is the base class for matrix elements in the context of the matchbox NLO interface
CAccuracyHistogram	Simple histogram for accuracy checks
CMatchboxOLPME	MatchboxOLPME implements OLP interfaces
CMatchboxParticlePtScale	MatchboxParticlePtScale implements scale choices related to transverse momenta
CMatchboxPhasespace	MatchboxPhasespace defines an abstract interface to a phase space generator
CMatchboxPtScale	MatchboxPtScale implements scale choices related to transverse momenta
►CMatchboxRambo	MatchboxRambo implements RAMBO phase space generation
CReshuffleEquation	The function object defining the equation to be solved
CMatchboxReference	MatchboxReference implements reference sample phase space generation
CMatchboxReweightBase	MatchboxReweightBase is the base class for reweighting MatchboxMEBase matrix elements as |M|^2 ( w_1 + ... + w_n )
CMatchboxScaleChoice	MatchboxScaleChoice is the base class for scale choices within Matchbox
CMatchboxSHatScale	MatchboxSHatScale implements lastSHat() as scale choice
CMatchboxTopIndividualMTScale	MatchboxTopIndividualMTScale implements the scale as the transverse masses of the top quark in a top-pair process
CMatchboxTopLinearSumMTScale	MatchboxTopLinearSumMTScale implements the scale as the linear sum of the transverse masses of the top and antitop quarks in a top pair process
CMatchboxTopMassScale	MatchboxTopMassScale implements a scale choice related to the invariant mass of the top-antitop quark pair
CMatchboxTopMinMTScale	MatchboxTopMinMTScale implements a scale choice related to the quadratic sum of transverse masses of a top and antitop quark
CMatchboxTopMTScale	MatchboxTopMTScale implements a scale choice related to the average of the transverse masses of a top and antitop quark
CMatchboxTopSumMTScale	MatchboxTopSumMTScale implements a scale choice related to the quadratic sum of transverse masses of a top and antitop quark
CMatchboxTriVecScales	MatchboxTriVecScales 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
CMatchboxXComb	Matchbox extensions to StandardXComb
►CMatchboxXCombData	Matchbox extensions to StandardXComb
CReshuffleEquation	Helper struct to define the reshuffling equation
CMatchboxXCombGroup	Matchbox extensions to StandardXComb
CMatchboxZGammaAmplitude	Here is the documentation of the MatchboxZGammaAmplitude class
CMatchingHandler	Here is the documentation of the MatchingHandler class
CMEChargedCurrentDIS	Matrix elements for charged current DIS
CMEDiffraction	Simple colour singlet exchange matrix element to be used in the soft component of the multiple scattering model of the underlying event
CMEDM2Mesons	Implements dark matter annhilation via a vector current to mesons at low energies
CMEee2ff	Matrix element for \(e^+e^-\to\ell^+\ell^-\)
CMEee2gZ2ll	Matrix element for \(e^+e^-\to\ell^+\ell^-\)
CMEee2gZ2llPowheg	Here is the documentation of the MEee2gZ2llPowheg class
CMEee2gZ2qq	Implements the matrix element for \(e^+e^-\to Z/\gamma \to q\bar{q}\) including spin correlations
CMEee2gZ2qqPowheg	Here is the documentation of the MEee2gZ2qqPowheg class
CMEee2Higgs2SM	Implements the production of an \(s\)-channel Higgs in \(e^+e^-\) collisions in order to allow easy tests of Higgs decays
CMEee2HiggsVBF	The MEee2HiggsVBF class
CMEee2Mesons	Implements \(e^+e^-\) annhilation to mesons at low energy using hadronic currents
CMEee2VectorMeson	Designed to produce neutral vector mesons in \(e^+e^-\) collisions and is primarily intended to test the hadronic decay package
CMEee2VV	Implements the matrix elements for \(e^+e^-\to W^+W^-/|^0Z^0\)
CMEee2ZH	Implements the matrix element for \(e^+e^-\to Z^0h^0\)
CMEException	Exception class to indicate a problem has occurred with setting up to matrix element
CMEff2ff	This is the implementation of the \( 2\to 2\) matrix element for a \( \Psi \Psi \to \Psi \Psi\) process
CMEff2rf	This is the implementation of the \( 2\to 2\) matrix element for a fermion-fermion to fermion RS fermion process
CMEff2ss	Designed to implement the matrix element for a fermion-antifermion to scalar-scalar hard process
CMEff2ts	Implements the general matrix element for fermion fermion -> tensor scalar
CMEff2tv	The documentation of the MEff2tv class implements the general matrix element for vector vectro to tensor vector
CMEff2vs	Designed to implement the matrix element for a fermion-antifermion to vector-scalar hard process
CMEff2vv	This class implements the matrix element calculation for a generic \(\Psi \Psi \rightarrow V^{\mu} V^{\nu}\) process
CMEfftoffH	Base class for vector boson fusion type processes in Herwig
CMEfftoVH	Base class for \(f\bar{f}\to VH\) processes
CMEfv2fs	This class is designed to implement the matrix element for fermion-vector to fermion scalar
CMEfv2rs	This class is designed to implement the matrix element for fermion-vector to RS fermion scalar
CMEfv2rv	This class implements the matrix element for a fermion and a vector boson to a vector boson and a RS fermion
CMEfv2tf	Here is the documentation of the MEfv2tf class
CMEfv2vf	This class implements the matrix element for a fermion and a vector boson to a fermion and a vector boson
CMEGammaGamma2ff	Matrix elements for \(\gamma\gamma\to f \bar{f}\)
CMEGammaGamma2WW	Matrix elements for \(\gamma\gamma\to f \bar{f}\)
CMEGammaP2Jets	Implements the matrix elements for pointlike gamma+hadron -> jets
CMEHiggsPair	Implements the matrix elements for HiggsPairian \(2\to2\) scattering process
CMEHiggsPairJet	Implements the matrix elements for HiggsPairian \(2\to2\) scattering process
CMEHiggsPairOL	Implements the matrix elements for HiggsPairian \(2\to2\) scattering process
CMelikhovFormFactor	Implements the model of Phys
CMelikhovStechFormFactor	Implementation of the form factors from Phys
CMEMatching	MEMatching implements NLO matching with matrix element correction (aka Powheg)
CMEMinBias	Simple colour singlet exchange matrix element to be used in the soft component of the multiple scattering model of the underlying event
CMEMultiChannel	Here is the documentation of the MEMultiChannel class
CMENeutralCurrentDIS	Matrix elements for neutral current DIS
CMEPP2GammaGamma	Implements the production of photon pairs in hadron hadron collisions
CMEPP2GammaGammaPowheg	Here is the documentation of the MEPP2GammaGammaPowheg class
CMEPP2GammaJet	Implements the matrix element for photon+jet production in hadron-hadron collisions
CMEPP2Higgs	Implements 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)
CMEPP2HiggsJet	Implements the matrix element for Higgs+jet production
CMEPP2HiggsPowheg	Implements 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)
►CMEPP2HiggsVBF	Matrix elements for the production of the Higgs boson via the vector boson fusion mechanism in hadron collisions
CtChannelPair	Struct to contain the hadronic system
CMEPP2HiggsVBFPowheg	Here is the documentation of the MEPP2HiggsVBFPowheg class
CMEPP2QQ	Implements the production of a heavy quark-antiquark pair via QCD
CMEPP2QQHiggs	Implements the matrix elements for \(gg\to Q \bar Q h^0\) and \(q\bar q\to Q \bar Q h^0\)
CMEPP2SingleTop	Implements the matrix element for the production of a single top quark
CMEPP2VGamma	Implements the
CMEPP2VV	Implements the production of \(W^+W^-\), \(W^\pm Z^0\) and \(Z^0Z^o\) in hadron-hadron collisions
CMEPP2VVPowheg	Here is the documentation of the MEPP2VVPowheg class
CMEPP2WH	Matrix elements for the production of the \(W^\pm\) boson in association with the Higgs in hadron collisions
CMEPP2WHPowheg	Next-to-leading order matrix elements for \(W^\pm\) in assoication with a Higgs boson in the PoOWHEG scheme
CMEPP2WJet	Implements the matrix element for the production of a W boson and a jet including the decay of the W
CMEPP2ZH	Implements the matrix element for \(q\bar{q}\to Z^0h^0\)
CMEPP2ZHPowheg	Implements the matrix element for \(q\bar{q}\to Z^0h^0\)
CMEPP2ZJet	Implements the matrix element for the production of a Z boson + a jet including the decay of the Z including \(Z/\gamma\) interference
CMEQCD2to2	Matrix elements for \(2\to2\) QCD scattering processes in hadron-hadron collisions
CMEQCD2to2Fast	Implements the matrix elements for QCD \(2\to2\) scattering processes using hard coded formulae and as such can not include spin correlations
CMEqq2gZ2ff	Implements the products of Standard Model fermion antifermion pairs via the \(Z^0\) resonance including photon interference terms
CMEqq2gZ2ffPowheg	Implements the products of Standard Model fermion antifermion pairs via the \(Z^0\) resonance including photon interference terms
CMEqq2W2ff	Implements the matrix element for \(q\bar{q'}\to W^\pm\) including the decay of the \(W^\pm\) to Standard Model fermions
CMEqq2W2ffPowheg	Implements the matrix element for \(q\bar{q'}\to W^\pm\) including the decay of the \(W^\pm\) to Standard Model fermions
CMerger	This class is responsible for the handling of the merging process after the setup stage, performed by the merging factory. The class is inherited from the MergerBase class that is visible (and the interface) to the shower and matrix elements
CMergerBase	MergerBase is the base class MergingHelpers
CMergingFactory	MergingFactory automatically sets up a NLO QCD merging
CMergingReweight	Reweights subprocesses
CMETRP2to2	Implements the matrix elements for Transplanckian \(2\to2\) scattering process
CMEvv2ff	This class is designed to implement the matrix element for the \(2 \rightarrow 2\) process vector-vector to fermion-antifermion pair
CMEvv2rf	This class is designed to implement the matrix element for the \(2 \rightarrow 2\) process vector-vector to fermion- RS fermion
CMEvv2ss	This is the implementation of the matrix element for the process vector-vector to scalar-scalar
CMEvv2tv	Here is the documentation of the MEvv2tv class
CMEvv2vs	This is the implementation of the matrix element for \(2\to 2\) massless vector-boson pair to a vector and scalar boson
CMEvv2vv	This is the implementation of the matrix element for \(2\to 2\) massless vector-boson pair to vector-boson pair
CMinBiasPDF	Defines 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
CMIPWA	Allows the use on experimental extractions from Model Independent Partial Wave Analyses
CMissingPtCut	MissingPtCut 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
CMixingElement	Struct for the elements of a mixing matrix
►CMixingMatrix	This class is desinged to store the mixing matrices needed for Susy studies
CMixingMatrixError	Exception class to indicate problem with mixing matrix
CModelGenerator	This class is designed to store the particles in some model and then call the appropriate function to setup the model
CMonacoSampler	MonacoSampler samples XCombs bins using using Monaco
CMPIHandler	This class is responsible for generating additional semi hard partonic interactions
CMPIPDF	Defines 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
CMPISampler	This class inherits from SampleBase and implements the Auto Compensating Divide-and-Conquer phase space generator, ACDCGen
CMPIXSecReweighter	MPIXSecReweighter sets up the proper minimum bias cross section
CMSSM	Main model class to replace the Standard Model when using the Minimal Supersymmetric Standard Model
CMultiIterationStatistics	Monte Carlo statistics for multiple iterations
CMultiPartonExtractor	Inherits from the PartonExtractor of ThePEG but allows more control over the PDFs used in the case that there are multiple stages of parton extraction
CMultiplicityInfo	Struct for the multiplcity data
CMultiWeight	Designed to perform some simple analysis of gauge boson, W and Z, distributions in hadron-hadron collisions
CNBDiagram	The NBDiagram struct contains information about a \(1\to n\) decay that has been automatically generated
►CNBodyDecayConstructorBase	This is the base class for NBodyDecayConstructors
CMassOrdering
CNBodyDecayConstructorError	An Exception class that can be used by all inheriting classes to indicate a setup problem
CNBVertex	A simple vertex for the N-body diagram
CNJetsAmplitude	NJetsAmplitude implements an interface to NJets
CNMSSM	Here is the documentation of the NMSSM class
CNMSSMFFHVertex	Implements the interactions of the NMSSM Higgs bosons with the Standard Model fermions
CNMSSMGGHVertex	This class implements the effective vertex for a higgs coupling to a pair of gluons in the NMSSM
CNMSSMGOGOHVertex	Here is the documentation of the NMSSMGOGOHVertex class
CNMSSMHHHVertex	The NMSSMHHHVertex defines the triple Higgs coupling in the NMSSM
CNMSSMHSFSFVertex	This class defines the coupling of Higgs bosons to the sfermions in the NMSSM
CNMSSMPPHVertex	This class implements the effective vertex for a higgs coupling to a pair of photons in the NMSSM
CNMSSMWHHVertex	Implements the coupling of an electroweak" gauge boson with two Higgs bosons in the NMSSM
CNMSSMWWHHVertex	Here is the documentation of the NMSSMWWHHVertex class
CNMSSMWWHVertex	Implementation of the coupling of two electroweak gauge bosons to the Higgs bosons of the NMSSM
CNode	Part of the shower history in the merging procedure
CNonBShowerVeto	Vetos parton showers where no b (anti)quarks are produced
CNonLeptonicHyperonDecayer	This is a general class for the non-leptonic decay of hyperons
CNonLeptonicOmegaDecayer	The NonLeptonicOmegaDecayer class is designed for the non-leptonic weak decay of the Omega to a baryon from the lightest \(SU(3)\) octet and a pseudoscalar meson
CO2AlphaS	Implementation of the two-loop \(\alpha_S\) in the same way as in FORTRAN HERWIG
COmegaPionSNDCurrent	Implements the decay current for \(\pi^\pm\pi^0 \gamma\) via an intermediate \(\omega\)
COmegaPiPiCurrent	Here is the documentation of the OmegaPiPiCurrent class
COmegaXiStarPionDecayer	Implements the results of hep-ph/0405162 for the weak decay of the \(\Omega\) to the \(\Xi^*\) and a pion
COmnesFunction	Base class for the implementation of the Omnes function
COneHalfHalfSplitFn	This class provides the concrete implementation of the exact leading-order splitting function for \(1\to \frac12\frac12\)
COneKaonTwoPionCurrent	Implements the model of M
COneKaonTwoPionDefaultCurrent	Implements the currents from Z.Phys.C58:445 (1992), this paper uses the form from Z.Phys.C48:445 (1990) for the \(a_1\) width and is the default model in TAUOLA
COneOffShellCalculator	Use another WidthCalculatorBase object to integrate over the mass of on of the external particles which can be off-shell for running width calculations
COneOffShellIntegrand	Class 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
COneOneOneEWSplitFn	Implements the splitting function for \(\1\to q\1 1\) where the spin-1 particles are massive electroweak gauge bosons
COneOneOneMassiveSplitFn	This class provides the concrete implementation of the exact leading-order splitting function for \(1\to 11\) where the emitting particle is massi e
COneOneOneQEDSplitFn	Implements the splitting function for \(\1\to q\1 1\) where the spin-1 particles are massive electroweak gauge bosons
COneOneOneSplitFn	This class provides the concrete implementation of the exact leading-order splitting function for \(1\to 11\)
COneOneZeroEWSplitFn	Implements the splitting function for \(\1\to q\1 0\) where the spin-1 particles are the W / Z massive electroweak gauge bosons and the spin-0 particle is the massive Higgs boson
COniumToOniumPiPiDecayer	Uses the matrix element of Brown and Cahn PRL35, 1 (1975) for the decay of onium resonaces to lighter states and pion pairs
COpenLoopsAmplitude	OpenLoopsAmplitude implements an interface to OpenLoops
COpenLoopsProcInfo	Process information for OpenLoops
CPairPtCut	This class implements a cut on the transverse momentum of a pair of particles
CPairRapidityCut	This class implements a cut on the rapidity of a pair of particles
CParallelRunAnalysis	This analysis prints out information necessary for the combination of multiple Herwig runs during the run step
CParticleOrdering	A struct to order the particles in the same way as in the DecayModes
CPartnerFinder	This class is responsible of two related tasks:
CPartonicDecayerBase	Here is the documentation of the PartonicDecayerBase class
CPartonSplitter	This class splits the gluons from the end of the shower
CPDFRatio	PDFRatio implements numerically stable PDF ratios
►CPerturbativeDecayer	Base class for perturbative decays in Herwig and implements the functuality for the POWHEG corrections
CDipoleType	Type of dipole
CPerturbativeProcess	Simple struct for hard processes and decays
►CPhaseSpaceChannel	This class is designed to store the information needed for a given phase-space channel for use by the multi-channel phase space decayer and perform the generation of the phase space for that channel
CPhaseSpaceResonance	Struct for the intermediates in the phase-space channel
CPhasespaceCouplings	Store couplings for the phase space generator
CPhaseSpaceError	Exception for this class and those inheriting from it
CPhaseSpaceMode	The PhaseSpaceMode class is designed to store a group of phase-space channels for use by the DecayIntegrator class to generate the phase-space for a given decay mode
CPhiPiCurrent	Implements a current for \(\phi\pi\) using a current based on the model of Phys.Rev
CPhotonMatcher	This file declare a set of standard matcher classes in addition to those defined in ThePEG
CPionPhotonCurrent	Implements the decay current for \(\pi^{\pm,0} \gamma\) via intermediate \(\rho,\omega,\phi,\omega^\prime\)
CPiPiAnisovichKMatrix	Implements the K-matrix for $\pi\pi$ scattering from Eur.Phys.J.A 16 (2003) 229-258
CPiPiI2	Implementation of the \(I=2\) s-eave for \(\pi\pi\)
CPomeronFlux	Here is the documentation of the PomeronFlux class
CPomeronPDF	Implementation of the PomeronPDF PDFs
CPotentialTree	Struct to store a potential CKKWTree
CPowhegHandler	Here is the documentation of the PowhegHandler class
CPowhegShowerHandler
CProcess	Process information with coupling order
CProcessData	Provide storage for process data
CProcessHandler	This class is for handling the sampling of semi hard partonic interactions
CProductionMatrixElement	The storage of the helicity amplitude expression for the matrix element of a hard process
Cprogress_display
CProtoBranching	Class to store a prototype branching
CProtoTree	Class for a prototype tree
CPrototypeVertex	Storage of a potenital n-body decay
CPScalar4FermionsDecayer	The PScalar4FermionsDecayer class is designed for the decay of the neutral pion to four leptons, in this case electrons
CPScalarLeptonNeutrinoDecayer	Designed for the decay of pseudoscalar mesons to a lepton and a neutrino
CPScalarPScalarVectorDecayer	The PScalarPScalarVectorDecayer class is designed to perform the decay of a pseudoscalar meson to another pseudoscalar meson and a vector meson
CPScalarVectorFermionsDecayer	The PScalarVectorFermionsDecayer class is designed for the decay of a pseudoscalar meson to a spin-1 particle and a fermion-antifermion pair
CPScalarVectorVectorDecayer	The PScalarVectorVectorDecayer class is designed to perform the decay of a pseudoscalar meson to two spin-1 particles
CPseudoScalar2FermionsDecayer	Designed for the decay of a pseudoscalar meson to two fermions, in reality this is always the decay of the \(\eta_c\) to a baryon antibaryon pair
CPseudoTensorMesonTensorVectorDecayer	The PseudoTensorMesonTensorVectorDecayer class handles the decay of a tensor meson to tensor and a scalar meson
CPseudoTensorMesonVectorVectorDecayer	The PseudoTensorMesonVectorVectorDecayer class handles the decay of a pseudotensor meson to two vector mesons
CPTCutOff	Here is the documentation of the PTCutOff class
CQEDRadiationHandler	Designed so that the approach for the generation of QED radiation in decays can be used to generate QED radiation from the decay products of \(s\)-channel resonances produced in the hard process where the decay products of the resonance have been generated as part of the hard process
CQQHiggsProcessConstructor	Here is the documentation of the QQHiggsProcessConstructor class
CQQHTest	Here is the documentation of the QQHTest class
CQTildeMatching	QTildeMatching implements NLO matching with the default shower
CQTildeShowerHandler	The QTildeShowerHandler class
CQuarkoniumDecayer	Designed for the partonic decay of bottom and charmonium resonances
CRadiativeDoublyHeavyBaryonDecayer	Designed for the radiative decay of a baryon containing a heavy quark to another baryon containing a heavy quark
CRadiativeHeavyBaryonDecayer	Designed for the radiative decay of a baryon containing a heavy quark to another baryon containing a heavy quark
CRadiativeHyperonDecayer	Matrix elements for the decay of hyperons in which a photon is produced using the model of Phys
CRealEmissionProcess	Simple struct for hard processes and decays
CrealVVKinematics	Used 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
CReggeonPDF	Implementation of the ReggeonPDF PDFs
►CRemapper	Remapper adapts indivdual MC dimensions
CSelectorEntry
►CReshuffler	Implements reshuffling of partons on their nominal mass shell to their constituent mass shells
CReshuffleEquation	The function object defining the equation to be solved
CResonantProcessConstructor	This class is designed to construct the diagrams for resonant processes using a provdided set of particles as interemdiates
CReweightEW	Here is the documentation of the ReweightEW class
CRPConstructorError	Exception class indicating setup problem
CRPV	Here is the documentation of the RPV class
CRPVFFSVertex	Here is the documentation of the RPVFFSVertex class
CRPVFFWVertex	Here is the documentation of the RPVFFWVertex class
CRPVFFZVertex	Here is the documentation of the RPVFFZVertex class
CRPVLLEVertex	Here is the documentation of the RPVLLEVertex class
CRPVLQDVertex	Here is the documentation of the RPVLQDVertex class
CRPVSSSVertex	Here is the documentation of the RPVSSSVertex class
CRPVUDDVertex	Here is the documentation of the RPVUDDVertex class
CRPVWSSVertex	Here is the documentation of the RPVWSSVertex class
CRPVWWHVertex	Implements the couplings of a pair of gauge bosons to scalars in the R-parity violating MSSM
CRSModel	This is the class to be used instead of the Standard Model class for the Randell Sundrum model
CRSModelFFGGRVertex	This is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
CRSModelFFGRVertex	This is the implementation of the Randell-Sundrum model fermion-antifermion tensor vertex for helicity amplitude calculations
CRSModelFFWGRVertex	This is the implementation of the fermion-antifermion-vector-graviton vertex for the Randell-Sundrum model
CRSModelGGGGRVertex	Implementation of the triple vector graviton couling in the RS model
CRSModelSSGRVertex	Thew implementation of the graviton coupling to the Higgs in the RSModel
CRSModelVVGRVertex	This is the implementation of the vector-vector-graviton vertex for the RS model
CRSModelWWWGRVertex	Implementation of the triple vector graviton couling in the RS model
CRunDirectories	Handle directories for external library and grid storage
CRunningMass	Implementation of the 1 or 2 loop QCD running mass
CRunningMassBase	Base class for running mass calculations
CSaSPhotonPDF	Interface to the
CSatPDF	Defines 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
CScalar2FermionsDecayer	Designed for the decay of ascalar meson to two fermions, in reality this is always the decay of the \(\chi_{c0}\) to a baryon antibaryon pair
CScalarAmplitude	Base class for scalar amplitudes
CScalarFormFactor	Base class for the form factors for the weak decay of scalar to scalar, vector and tensor mesons
CScalarMassGenerator	The ScalarMassGenerator class is designed for the generation of the masses of the \(a_0\) and \(f_0\) mesons which have \(K\bar{K}\) modes close to the on-shell mass of the particle
CScalarMesonCurrent	The weak current for the production of one (pseudo)-scalar meson
CScalarMesonFactorizedDecayer	The ScalarMesonFactorizedDecayer class is a class which combines a WeakCurrent and a ScalarFormFactor in the naive factorization approximation to perform the non-leptonic weak decays of scalar mesons
CScalarMesonTensorScalarDecayer	The ScalarMesonTensorScalarDecayer class is designed for the decay of a (pseudo)scalar meson to a tensor meson and another (pseudo)scalar meson
CScalarScalarScalarDecayer	The ScalarScalarScalarDecayer class is designed for the decay of a scalar meson to two scalar mesons
CScalarTo3ScalarDalitz	Base class for the implementation of weak three-body decays of bottom and charm mesons
CScalarVectorVectorDecayer	Designed to perform the decay of a scalar meson to two spin-1 particles
CSemiLeptonicBaryonDecayer	The SemiLeptonicBaryonDecayer class is designed for the semi-leptonic decay of the baryons
CSemiLeptonicScalarDecayer	The SemiLeptonicScalarDecayer class is designed for the semileptonic decay of a (pesudo)scalar meson to another meson and a lepton/neutino pair
CSextetFFSVertex	Here is the documentation of the SextetFFSVertex class
CSextetFFVVertex	Here is the documentation of the SextetFFVVertex class
CSextetGGSSVertex	Here is the documentation of the SextetGGSSVertex class
CSextetGGVVVertex	Here is the documentation of the SextetGGVVVertex class
CSextetGSSVertex	Here is the documentation of the SextetGSSVertex class
CSextetGVVVertex	Here is the documentation of the SextetGVVVertex class
CSextetModel	This class is used instead of the StandardModel class for the
CSextetPSSVertex	Here is the documentation of the SextetPSSVertex class
CSextetPVVVertex	Here is the documentation of the SextetPVVVertex class
CSFFDecayer	Implements the decay of a scalar to 2 fermions in a general model
CShowerAlpha	This class is the abstract class from which all types of running couplings used in the Showering derive from
CShowerAlphaQCD	This concrete class provides the definition of the pure virtual function value() and overestimateValue() for the strong coupling
CShowerAlphaQED	This concrete class provides the definition of the pure virtual function value(scale) for \(\alpha_{\rm QED}\)
CShowerApproximation	ShowerApproximation describes the shower emission to be used in NLO matching
CShowerApproximationGenerator	ShowerApproximationGenerator generates emissions according to a shower approximation entering a NLO matching
►CShowerApproximationKernel	ShowerApproximationKernel generates emissions according to a shower approximation entering a NLO matching
CMaxTryException	Exception to communicate sampler maxtry events
CShowerBasis	Stores the basis vectors used by the shower
CShowerEventRecord	Here is the documentation of the ShowerEventRecord class
►CShowerHandler	This 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
CExtraScatterVeto	Struct that is used to catch exceptions which are thrown due to energy conservation issues of additional scatters
CParticleOrdering	A struct to order the particles in the same way as in the DecayMode's
CShowerTriesVeto	Struct 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
CShowerKinematics	This is the abstract base class from which all other shower kinematics classes derive
►CShowerParticle	This class represents a particle in the showering process
CEvolutionPartner	Struct for all the info on an evolution partner
CEvolutionScales	Struct to store the evolution scales
CShowerProgenitor	A struct to store information on the perturbative particle which initiates a shower
CShowerTree	Stores the basic information needed for each hard interaction, either a scattering process or decay, which needs to be showered
CShowerVariation	A struct identifying a shower variation
CShowerVertex
CShowerVeto	ShowerVeto is a general interface for performing vetoes during showering
CSimpleColourBasis	SimpleColourBasis 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
CSimpleColourBasis2	SimpleColourBasis2 implements the colour algebra needed for processes with four coloured legs at NLO. It mainly serves as an example for the general ColourBasis interface
CSimpleLHCAnalysis	Designed to perform some simple analysis of gauge boson, W and Z, distributions in hadron-hadron collisions
CSingletonFormFactor	Implements the form-factors from PRD43, 2939 for the decay of spin-1/2 baryons containing bottom and charm quarks
CslopeAndTotalXSec	A 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
CslopeBisection	A 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
CslopeInt	A struct for the integrand for the slope
CSMFFGVertex	This is the implementation of the Standard Model quark-antiquark gluon vertex
CSMFFHVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CSMFFPVertex	This is the implementation of the Standard Model fermion-antifermion photon vertex
CSMFFWVertex	This is the implementation of the Standard model coupling of the W to the fermions
CSMFFZVertex	This is the implementation of the Standard Model fermion-antifermion Z vertex
CSMGGGGVertex	Implementation of the Standard Model quartic gluon vertex
CSMGGGVertex	Implementation of the SM triple gluon vertex
CSMHGGVertex	The SMHGGVertex class implements the setCoupling member for the Standard Model effective vertex Higgs-gluon-gluon
CSMHHHVertex	Here is the documentation of the SMHHHVertex class
CSMHiggsFermionsDecayer	Designed to decay the Standard Model Higgs to the Standard Model fermions
CSMHiggsGGHiggsPPDecayer	The SMHiggsGGHiggsPPDecayer class performs the of a Standard Model Higgs boson to: a pair of photons or a pair of gluons, or a \(Z^0\) boson and a photon
CSMHiggsMassGenerator	Implements the generation of the Higgs boson mass according to the prescription of hep-ph/9505211
CSMHiggsWidthGenerator	Calculates the width for the Standard Model Higgs boson
CSMHiggsWWDecayer	Performs the decay of the Standard Model Higgs boson to \(W^+W^-\) and \(Z^0Z^0\) including the decays of the gauge bosons
CSMHPPVertex	The SMHGGVertex class implements the setCoupling member for the Standard Model effective vertex Higgs-gamma-gamma
CSMHZPVertex	Here is the documentation of the SMHZPVertex class
CSMTopDecayer	The SMTopDecayer performs decays of the top quark into the bottom quark and qqbar pairs or to the bottom quark and lepton neutrino pairs via W boson exchange
CSMWDecayer	The SMWDecayer is designed to perform the decay of the W boson to the Standard Model fermions, including the first order electroweak corrections
CSMWWHHVertex	Here is the documentation of the SMWWHHVertex class
CSMWWHVertex	The SMWWHVertex is the implementation of the coupling of two electroweak gauge bosons to the Higgs in the Standard Model
CSMWWWVertex	This is the implementation fo the vertex for the coupling of three standard Model electroweak bosons
CSMWWWWVertex	Implementation of the coupling of four electroweak gauge bosons in the SM
CSMZDecayer	The SMZDecayer is designed to perform the decay of the Z boson to the Standard Model fermions
CSOPHTY	Here is the documentation of the SOPHTY class
CSpin3Meson2PScalarDecayer	The Spin3Meson2PScalarDecayer class is designed for the decay of a rank 3 tensor meson to two pseudoscalars via matrix element which takes the form
CSpin3MesonTensorPScalarDecayer	The Spin3MesonTensorPScalarDecayer class is designed for the decay of a rank 3 tensor meson to a tensor and a scalar via matrix element which takes the form
CSpin3MesonTensorVectorDecayer	The Spin3MesonTensorVectorDecayer class is designed for the decay of a rank 3 tensor meson to a tensor and a vector via matrix element which takes the form
CSpin3MesonVectorPScalarDecayer	The Spin3MesonVectorPScalarDecayer class is designed for the decay of a rank 3 tensor meson to a vector and a scalar via matrix element which takes the form
CSpin3MesonVectorScalarDecayer	The Spin3MesonVectorScalarDecayer class is designed for the decay of a rank 3 tensor meson to a vector and a scalar via matrix element which takes the form
CSpinCorrelationTensor	SpinCorrelationTensor represents a spin correlation tensor of the form
CSpinHadronizer	Designed to be used as a post-hadronization handler to give a simple model of spin transfer between the perturbative and non-perturbative stages
CSplittingFunction	This is an abstract class which defines the common interface for all \(1\to2\) splitting functions, for both initial-state and final-state radiation
CSplittingGenerator	This 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
CSRFDecayer	Implements the decay of a scalar to spin-3/2 and spin-1/2 fermion in a general model
CSSCCZVertex	This class implements the coupling of a \(\gamma/Z^0\) to a pair of charginos
CSSCFSVertex	This is the implementation of the coupling of the charginos to fermion- sfermions
CSSCNWVertex	This class is implements the coupling of a W boson to a chargino and a neutralino
CSSFFHVertex	The is the coupling of higgs bosons in the MSSM to a pair of SM fermions
CSSGFSVertex	This is the implementation of the coupling of a gluino to a squark- quark pair
CSSGGSQSQVertex	This is the implementation of the 4 point gluon-gluon-squark-squark vertex
CSSGNGVertex	This 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
CSSGOGOHVertex	The is the coupling of higgs bosons in the MSSM to a pair of SM fermions
CSSGSGSGVertex	This class implements the g- \(\tilde{g}\)- \(\tilde{g}\) vertex
CSSGSSVertex	The SSGSSVertex implements the coupling of a gluon to 2 sfermions
CSSGVFSVertex	This is the implementation of the coupling of the gravitino to fermion-sfermions
CSSGVNHVertex	Implements the coupling of the gravitino to a neutralino and Higgs boson
CSSGVNVVertex	Implements the coupling of the gravitino to a gaugino and the assoicated gauge boson
CSSHGGVertex	This class implements the effective vertex coupling a higgs to a pair of gluons in the MSSM
CSSHHHVertex	This is the higgs coupling with other higgs bosons in the MSSM
CSSHPPVertex	This class implements the effective vertex coupling a higgs to a pair of photons in the MSSM
CSSHSFSFVertex	This is the implementation of the coupling for a Higgs in the MSSM to a pair of sfermions
CSSNCTVertex	Here is the documentation of the SSNCTVertex class
CSSNFSVertex	This is the implementation of the coupling of the neutralinos to fermion-sfermions
CSSNNPVertex	This class implements the coupling of a photon to a pair of neutralinos via loop diagrams It inherits from GeneralFFVertex and implements the setCoupling method
CSSNNZVertex	This class implements the coupling of a Z-boson to a pair of neutralinos
CSSSDecayer	The SSDecayer class implements the decay of a scalar to 2 scalars in a general model
CSSVDecayer	Implements the decay of a scalar to a vector and a scalar in a general model
CSSWGSSVertex	This is the implementation of the 4 point gluon-gluon-squark-squark vertex
CSSWHHVertex	The coupling of a pair of higgs to the SM gauge bosons in the MSSM
CSSWSSVertex	This is the implementation of the coupling of an SM gauge boson to a pair of sfermions
CSSWWHHVertex	Here is the documentation of the SSWWHHVertex class
CSSWWHVertex	This class implements the coupling of a higgs in the MSSM to a pair of SM gauge bosons
CSSWWSSVertex	Here is the documentation of the SSWWSSVertex class
CStandardCKM	StandardCKM inherits from CKMBase and implements the standard parameterization of the CKM matrix in terms of three angles and a phase
CStandardModel	This 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
CStat	Documentation for the statistics struct
CStatistic	Simple class designed to store a variable for statistical analysis
CStoFFFFDecayer	Here is the documentation of the StoFFFFDecayer class
CStoFFVDecayer	Here is the documentation of the StoFFVDecayer class
CStoSFFDecayer	General matrix element for scalar decays into another scalar and a fermion-antifermion pair
CStreamingRnd	Wrap around a vector of random numbers to behave as a stream of those
CStrongHeavyBaryonDecayer	The StrongHeavyBaryonDecayer class implements the strong decays of charm baryons using the results of hep-ph/9904421
CSU2Helper	Helpers for book keeping in electroweak processes
CSU3BaryonDecupletOctetPhotonDecayer	The SU3BaryonDecupletOctetPhotonDecayer class is designed for the decay of a deculpet baryon to an octet baryon and a photon using the SU(3) conserving term in the chiral lagrangian
CSU3BaryonDecupletOctetScalarDecayer	The SU3BaryonDecupletOctetScalarDecayer class is designed for the decay of a \(SU(3)\) deculpet baryon to an octet baryon and a pseudoscalar meson from the lightest multiplet
CSU3BaryonOctetDecupletScalarDecayer	The SU3BaryonOctetDecupletScalarDecayer class is designed for the decay of an SU(3) octet baryon to a deculpet baryon and a pseudoscalar meson from the lightest multiplet
CSU3BaryonOctetOctetPhotonDecayer	The SU3BaryonOctetOctetPhotonDecayer class performs the decay of a baryon octet to a different baryon octet and a photon
CSU3BaryonOctetOctetScalarDecayer	The SU3BaryonOctetOctetScalarDecayer class is a simple decayer for the strong decay of the excited baryon \(SU(3)\) octets to lower lying baryon octets and a pseudoscalar meson from the lightest multiplet, i.e
CSU3BaryonSingletOctetPhotonDecayer	The SU3BaryonSingletOctetPhotonDecayer class performs the radiative decay of an \(SU(3)\) singlet baryon to an \(SU(3)\) octet baryon
CSU3BaryonSingletOctetScalarDecayer	The SU3BaryonSingletOctetScalarDecayer class is a simple decayer for the strong decay of the excited baryon \(SU(3)\) singlets to a lighter baryon octet and a pseudoscalar meson from the lightest multiplet, i.e
CSubleadingSplittingInfo	Generalized dipole splitting info to deal with subleading-N splittings
►CSubtractedME	SubtractedME represents a subtracted real emission matrix element
CSubtractionHistogram	Simple envelope histogram to keep track of subtraction
►CSubtractionDipole	SubtractionDipole represents a dipole subtraction term in the formalism of Catani and Seymour
CMergeInfo	A helpre struct to communicate diagram merging and remapping information
CSudakovCutOff	Base class for cut-offs in the Sudakov
CSudakovFormFactor	This is the definition of the Sudakov form factor class
CSusyBase	This class is designed to be a base class for SUSY models
CSVVDecayer	This SVVDecayer class implements the decay of a scalar to 2 vector bosons using either the tree level VVSVertex or the loop vertex
CTauDecayer	Performs the decay of the \(\tau\)
CTBDiagram	The TBDiagram struct contains information about a \(1\to3\) decay that has been automatically generated by ThreeBodyDecayConstructor
CTensorMeson2PScalarDecayer	The TensorMeson2PScalarDecayer class is designed for the decay of a tensor meson to two pseudoscalars via matrix element which takes the form
CTensorMesonSpin3VectorDecayer	The TensorMesonSpin3VectorDecayer class is designed for the decay of a tensor meson to a rank 3 tensor and a vector via matrix element which takes the form
CTensorMesonTensorPScalarDecayer	The TensorMesonTensorPScalarDecayer class handles the decay of a tensor meson to tensor and a scalar meson
CTensorMesonTensorScalarDecayer	The TensorMesonTensorScalarDecayer class handles the decay of a tensor meson to tensor and a scalar meson
CTensorMesonVectorPScalarDecayer	The TensorMesonVectorPScalarDecayer class handles the decay of a tensor meson to a vector and a pseudoscalar
CTensorMesonVectorScalarDecayer	The TensorMesonVectorScalarDecayer class handles the decay of a tensor meson to vector and a scalar meson
CTensorMesonVectorVectorDecayer	Designed to simulate the decay of a tensor meson to two spin-1 particles
CTFFDecayer	Implements the decay of a tensor to 2 fermions in a general model
CThreeBodyAllOn1IntegralCalculator	The ThreeBodyAllOn1IntegralCalculator class is designed to integrate a function which gives \(d\Gamma/dm^2_{ij}\) to give the partial width
►CThreeBodyAllOnCalculator	The 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
COuter	The class for the outer integrand of the integral of a three body decay matrix element
CThreeBodyDecayConstructor	Inherits 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
►CThreeMesonCurrentBase	This is the base class for the three meson decays of the weak current
CFormFactors	Helper class for form factors
CThreePionCLEOCurrent	The ThreePionCLEOCurrent class implements the decay of the weak current to three pions using the currents from CLEO Phys
CThreePionCzyzCurrent	The ThreeMesonCzyzCurrent class implements the currents from Eur.Phys.J
CThreePionDefaultCurrent	Implements the currents from Z.Phys.C58:445 (1992), this paper uses the form from Z.Phys.C48:445 (1990) for the \(a_1\) width and is the default model in TAUOLA
CTildeKinematics	TildeKinematics is the base class for the 'tilde' kinematics being used for subtraction terms in the formalism of Catani and Seymour
CTopDecay	Here is the documentation of the TopDecay class
CTopMatcher	A Matcher class which matches top quarks
CTotalXSecBisection	A struct for the root finding that is necessary to determine the soft cross section that is needed to describe the total cross section correctly
►CTree2toNGenerator	Generate Tree2toNDiagrams for a given process
CLineMatcher	Helper for topology restrictions
CVertex	A node in internally used trees
CTreePhasespace	TreePhasespace is a multi-channel phase space generator adapting to singularity structures as determined from the matrix elements diagrams
CTreePhasespaceChannels	Store channels for the tree phasespace
CTSSDecayer	Implements the decay of a tensor to 2 scalars in a general model
CTTbAModel	Here is the documentation of the TTbAModel class
CTTbAModelAGQQVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CTTbAModelSU2XVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CTTbAModelWPTDVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CTTbAModelZPQQVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
CTTbarAnalysis	Tries to find a top antitop pair in the final state and books a number of histograms
CTTJetsAnalysis	Here is the documentation of the TTJetsAnalysis class
CTVVDecayer	Implements the decay of a tensor to 2 vector bosons in a general model
CTwoBodyAllOnCalculator	The 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
CTwoBodyDecay	Struct for the prototype of a two-body decay mode
CTwoBodyDecayConstructor	Inherits 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
CTwoBodyDecayMatrixElement
CTwoKaonCzyzCurrent	Implements the current of PRD 81 094014 for the production of two kaons
CTwoKaonOnePionCurrent	Implements the model of M
CTwoKaonOnePionDefaultCurrent	Implements the currents from Z.Phys.C58:445 (1992), this paper uses the form from Z.Phys.C48:445 (1990) for the \(a_1\) width and is the default model in TAUOLA
CTwoOffShellCalculator	Use WidthCalculatorBase objects to integrate over the mass of two external particles which can be off-shell for running width calculations
CTwoOffShellIntegrand	Class for the integrand of a matrix element where two of the outgoing particles is off-shell
CTwoPionCzyzCurrent	Implements the current of PRD 81 094014 for two pions
CTwoPionPhotonCurrent	This class implements the decay current for \(\pi^\pm\pi^0 \gamma\) via an intermediate \(\omega\)
CTwoPionPhotonSNDCurrent	Implements the decay current for \(\pi^\pm\pi^0 \gamma\) via an intermediate \(\omega\)
CTwoPionRhoCurrent	Weak current for the production of two mesons via the \(\rho\) resonances
CTwoToTwoProcessConstructor	The TwoToTwoProcessConstructor is designed to construct the diagrams that are possible for a given set of incoming and outgoing particles
CTwoToTwoProcessConstructorError	Exception class indicating setup problem
CUEBase	Abstract base class used to minimize the dependence between MPIHandler and all Shower classes
CUEDBase	This class serves as a base class for all UED models
CUEDF1F0G1Vertex	This is the implementation of the \(\bar{f}^{1}f^{0}g^{(1)}\) vertex
CUEDF1F0H1Vertex	The implementation of the \( f_{(1)}f_{(0)}H_{(1)}^\pm\) vertex
CUEDF1F0W1Vertex	This is the \( \bar{f}^{(1)} f^{(0)} W^{(1)}\) coupling, where \(W^{(1)}\) is any level 1 EW gauge boson
CUEDF1F1G0Vertex	This is the implementation of the \(\bar{f}^{1}f^{(1)}g\) vertex
CUEDF1F1P0Vertex	This class implements the coupling of a pair of level-1 KK fermions to a standard Model photon
CUEDF1F1W0Vertex	This class implements the coupling of a pair of level-1 fermions to the SM $W$ boson
CUEDF1F1Z0Vertex	This is the implementation of the level-1 fermion-fermion Z-boson
CUEDG0G0G1G1Vertex	This is the implementation of the coupling of two Standard Model gluons to a pair of level 1 KK gluons
CUEDG1G1G0Vertex	This is the implementation of the Feynman rule for the coupling of Standard Model gluon to a pair of (level1) KK excited gluons
CUEDP0H1H1Vertex	The implementation of the \(A^\mu_{(0)}H_{(1)}^+H_{(1)}^-\) vertex
CUEDW0A1H1Vertex	This is the coupling for the vertex \( W_{\mu(0)}^\pm A_{(1)}^0 H^\mp_{(1)}\)
CUEDW0W1W1Vertex	The coupling for the \( W\,W^{(1)}Z^{(1)}\) and \( W\,W^{(1)}\gamma^{(1)}\) vertex
CUEDZ0A1h1Vertex	This class implements the coupling for the \(A_{(1)}h_{(1)}Z^\mu_{{0}}\) vertex
CUEDZ0H1H1Vertex	The implementation of the \(Z^\mu_{(0)}H_{(1)}^+H_{(1)}^-\) vertex
CVariableMassCutOff	Here is the documentation of the VariableMassCutOff class
CVBFNLOAmplitude	VBFNLOAmplitude implements an interface to VBFNLO
►CVBFNLOPhasespace	VBFNLOPhasespace 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
CReshuffleEquation	The function object defining the equation to be solved
CVBFTest	Here is the documentation of the VBFTest class
CVectorCurrentDecayConstructor	Constructs the decay of low mass vector bosons via the weak currents
CVectorCurrentDecayer	Here is the documentation of the VectorCurrentDecayer class
CVectorMeson2FermionDecayer	The VectorMeson2FermionDecayer class is designed for the decay of a vector meson to a fermion-antifermion pair
CVectorMeson2MesonDecayer	This class is the implementation for the decay of a vector meson to two scalar mesons, the classic example is \(\rho -> \pi\pi\), via a current which is the difference of the momenta of the mesons
CVectorMeson2SpinHalfBaryonsDecayer	The VectorMeson2SpinHalfBaryonsDecayer class is designed for the decay of a vector meson to a baryon-antibaryon pair
CVectorMeson2SpinThreeHalfBaryonsDecayer	The VectorMeson2SpinThreeHalfBaryonsDecayer class is designed for the decay of a vector meson to a baryon-antibaryon pair
CVectorMesonCurrent	The weak current for the production of one (pseudo)-vector meson
CVectorMesonPScalarFermionsDecayer	The 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 \(V\to VP\) vertex combined with the branching of the vector into a fermion-antifermion pair
CVectorMesonTensorVectorDecayer	Designed to simulate the decay of a vector meson to a tensor meson and a spin-1 particle
CVectorMesonVectorPScalarDecayer	This 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
CVectorMesonVectorScalarDecayer	This 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
CVectorMesonVectorVectorDecayer	This class is designed for the decay of a vector meson to two spin one particles, either other vector mesons or photons
CVectorTo3PseudoScalarDalitz	Base class for the decay of vector mesons to 3 pseudoscalar mesons
CVertexOrdering	A struct to order the particles in the same way as in the DecayMode's
CVetoShower	Exception class for vetoing a showering
CVFFDecayer	Implements the decay of a vector to 2 fermions in a general model
CVGammaTest	Here is the documentation of the VGammaTest class
CVHTest	Here is the documentation of the VHTest class
CVSSDecayer	Implements the decay of a vector to 2 scalars in a general model
CVTest	Here is the documentation of the VTest class
CVtoFFVDecayer	Here is the documentation of the VtoFFVDecayer class
CVVSDecayer	Implements the decay of a vector to a vector and a scalar in a general model
CVVSLoopVertex	The VVSLoopVertex is designed to calculate the coefficents for the terms in the Passarino-Veltman tensor reduction scheme
CVVTest	Here is the documentation of the VVTest class
CVVVDecayer	Implements the decay of a vector to 2 vectors in a general model
CWBosonMatcher	A Matcher class which matches W bosons
CWeakBaryonCurrent	Wrapper around the BaryonFormFactor so that they can be used as a current
CWeakBHadronSelector	Selector to select weakly decaying B hadrons
CWeakCurrent	The WeakCurrent class is the base class for the hadronic currents produced in weak decays
CWeakCurrentDecayConstructor	Here is the documentation of the WeakCurrentDecayConstructor class
CWeakPartonicDecayer	Designed to replace the HeavyDecayer class which implements the partonic decays of hadrons containing a heavy quark in the same way as in FORTRAN Herwig
CWeightAnalyzer	Here is the documentation of the WeightAnalyzer class
CWHTest	Here is the documentation of the WHTest class
CWidthCalculatorBase	Base class to be used by classes which calculate partial widths for the running width
CWJetTest	Here is the documentation of the WJetTest class
CWSBFormFactor	Implementation of the form factor model of Z.Phys
CYFSFormFactors	Pure static class which implements the various YFS form factors we need for the decays
CZBosonMatcher	A Matcher class which matches Z bosons
CZeroZeroOneSplitFn	This class provides the concrete implementation of the exact leading-order splitting function for \(\phi\to \phi g\)
CZHTest	Here is the documentation of the ZHTest class
CZJetsAnalysis	Here is the documentation of the ZJetsAnalysis class
CZJetTest	Here is the documentation of the ZJetTest class
CZprimeModel	Here is the documentation of the ZprimeModel class
CZprimeModelZPQQVertex	This is the implementation of the vertex coupling the Standard Model Higgs to the Standard Model fermions for helicity amplitude calculations
NLWH [external]
Nstd	STL namespace
►NThePEG [external]
NConstants [external]
NCutTypes [external]
NFactoryBase [external]
NGroup [external]
NHelicity [external]
NInterface [external]
NMath [external]
NParticleID	The ParticleID namespace defines the ParticleCodes enumeration
NPointer [external]
NSimpleBaryonRemnantDecayer [external]
NSimplePhaseSpace [external]
NUnitRemoval [external]
NUnits [external]
NXSecCheck [external]
CFxFxEventHandler	The FxFxEventHandler inherits from the general EventHandler class and administers the reading of events generated by external matrix element generator programs according to the Les Houches accord
CFxFxFileReader	FxFxFileReader is an base class to be used for objects which reads event files from matrix element generators
CFxFxReader	FxFxReader is an abstract base class to be used for objects which reads event files or streams from matrix element generators