Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►NACDCGenerator	The namespace in which all ACDCGen classes are defined
CACDCFncTraits	ACDCFncTraits defines the interface to functions to be sampled by ACDCGen
►CACDCGen	ACDCGen is a general class for sampling multi-dimensional functions
CLevel	A helper struct representing a level of compensation
CSlicer	This is a help struct to perform the divide-and-conquer slicing of cells before starting the compensation procedure
CACDCGenCell	ACDCGenCell is the class representing a generation cell in ACDCGen
CACDCGenCellInfo	This is a class describing cells to the outside world to be used for debugging purposes
CACDCRandomTraits	ACDCRandomTraits defines the interface to random number generator objects to be used by ACDCGen
CACDCTraitsType	ACDCTraitsType is an empty non-polymorphic base class for all traits classes in ACDCGenerator
►NLWH	The LWH namespace contains a Light-Weight Histogram package which implements the most rudimentary histogramming facilities according to the AIDA interface specifications
CAnalysisFactory	The "master" factory from which other factories are obtained
CAxis	An Axis represents a binned histogram axis
CDataPoint	An DataPoint represents a binned histogram axis
CDataPointSet	An DataPointSet represents a binned histogram axis
CDataPointSetFactory	Basic user-level interface for creating a factory of IDataPointSet
CHistogram1D	User level interface to 1D Histogram
CHistogram2D	User level interface to 1D Histogram
CHistogramFactory	User level interface for factory classes of Histograms (binned, unbinned, and profile)
CManagedObject	The creator of trees
CMeasurement	Basic user-level interface class for holding a single "measurement" with positive and negative errors (to allow for asymmetric errors)
CTree	Simple implementation of the AIDA::ITree interface
CTreeFactory	The creator of trees
CVariAxis	An VariAxis represents a binned histogram axis
►Nstd	STL namespace
Ccomplex< ThePEG::Qty< 0, 0, 0, DL, DE, DQ > >	Template specialization for std::complex<Qty<0,0,0> > with conversions to complex<double>
►NThePEG	This is the main namespace within which all identifiers in ThePEG are declared
►NHelicity	The Helicity namespace contains classes for spin representation classes in ThePEG
CAbstractFFSVertex	Base class for all fermion-fermion-scalar vertices in ThePEG
CAbstractFFTVertex	Base class for all fermion-fermion-tensor interactions in ThePEG
CAbstractFFVTVertex	Base class for all fermion-fermion-vector-tensor interactions in ThePEG
CAbstractFFVVertex	Base class for all fermion-fermion-vector vertices in ThePEG
CAbstractRFSVertex	Base class for all spin-3/2 fermion-fermion-scalar vertices in ThePEG
CAbstractRFVVertex	Base class for all spin-3/2 fermion-fermion-vector vertices in ThePEG
CAbstractSSSSVertex	Base class for all scalar-scalar-scalar interactions in ThePEG
CAbstractSSSVertex	Base class for all scalar-scalar-scalar interactions in ThePEG
CAbstractSSTVertex	Base class for scalar-scalar-tensor interactions in ThePEG
CAbstractVSSVertex	Base class for vector-scalar-scalar interactions in ThePEG
CAbstractVVSSVertex	Base class for vector-vector-scalar-scalar interactions in ThePEG
CAbstractVVSVertex	Here is the documentation of the AbstractVVSVertex class
CAbstractVVTVertex	Here is the documentation of the AbstractVVTVertex class
CAbstractVVVTVertex	Base class for all vector-vector-vector-tensor interactions in ThePEG
CAbstractVVVVertex	Base class for all vector-vector-vector interactions in ThePEG
CAbstractVVVVVertex	Base class for vector-vector-vector-vector interactions in ThePEG
CFermionSpinInfo	Inherits from the SpinInfo class and implements the storage of the basis vectors for a spin-1/2 particle
CFFSVertex	Implementation of the interact of a scalar boson and a fermion-antifermion pair
CFFTVertex	Implementation of the fermion-fermion-tensor vertex
CFFVTVertex	Implementation of the fermion-fermion–vector-tensor vertex
CFFVVertex	Base class for all helicity amplitude vertices which use the renormalisable form for the fermion-fermion-vector vertex
CGeneralFFVVertex	Base class for all helicity amplitude vertices which use a general form of the fermion-fermion-vector vertex
CGeneralVVSVertex	Implements a general Vector-Vector-Scalar vertex allowing for decay modes that only enter at the one-loop level
CLorentzRSSpinor	The LorentzRSSpinor class is designed to store a Rarita-Schwinger spinor for a spin-3/2 particle
CLorentzRSSpinorBar	The `LorentzRSSpinorBar` class implements the storage of a barred Lorentz Rarita-Schwinger Spinor for a spin-3/2 particle
CLorentzSpinor	The LorentzSpinor class is designed to store a spinor
CLorentzSpinorBar	The LorentzSpinorBar class implements the storage of a barred LorentzSpinor
CLorentzTensor	The LorentzTensor class is designed to implement the storage of a complex tensor to be used to representation the wavefunction of a spin-2 particle
CRFSVertex	Implementation of the interact of a scalar boson and a spin-3/2 fermion-antifermion pair
CRFVVertex	Base class for all helicity amplitude vertices which use the renormalisable form for the spin-3/2 fermion-fermion-vector vertex
CRSFermionSpinInfo	Inherits from the SpinInfo class and implements the storage of the basis vector for a spin-3/2 particle
CRSSpinorBarWaveFunction	The `RSSpinorBarWaveFunction` class is designed to store the wavefunction of a spin- $\frac32$ particle in a form suitable for use in helicity amplitude calculations of the matrix element using a similar philosophy to the FORTRAN HELAS code
CRSSpinorWaveFunction	Designed to store the wavefunction of a spin-3/2 particle in a form suitable for use in helicity amplitude calculations of the matrix element using a similar philosophy to the FORTRAN HELAS code
CScalarSpinInfo	Designed to be the implementation of the spin information for a scalar particle
CScalarWaveFunction
CSpinorBarWaveFunction
CSpinorWaveFunction
CSSSSVertex	Implementation of the interaction of four scalars
CSSSVertex	Implementation of the interaction of three scalars
CSSTVertex	The VVTVertexclass is the implementation of the scalar-scalar-tensor vertex
CTensorSpinInfo	Implementation of the spin information for tensor particles
CTensorWaveFunction
CVectorSpinInfo	Implementation of the spin information for vector particles
CVectorWaveFunction
CVertexBase	Base class for all helicity amplitude vertices
CVSSVertex	Implementation of the vector-scalar-scalar vertex
CVVSSVertex	Implementation of the coupling of two vectors and two scalars
CVVSVertex	Implementation of the vector-vector-scalar
CVVTVertex	Implementation of the vector-vector-tensor vertex
CVVVTVertex	The VVTVertex class is the implementation of the vector-vector-vector-tensor vertex
CVVVVertex	Base class for triple vector vertices using the perturbative form
CVVVVVertex	This is the implementation of the four vector vertex
CWaveFunctionBase
►NMath	The Math namespace includes the declaration of some useful mathematical functions
►NFunctions	This namespace introduces some useful function classes with known primitive and inverse primitive functions
CExpX	Class corresponding to functions of the form
CFracPowX	Class corresponding to functions of the form $x^{N/D}$ with integer N and D
CInvX1mX	Class corresponding to functions of the form
CPow1mX	Class corresponding to functions of the form with integer N
CPowX	Class corresponding to functions of the form with integer N
CMathType	MathType is an empty non-polymorphic base class for all mathematical function types
CPower	Templated class for calculating integer powers
CPower< 0, false >	Struct for powers
CPower< 0, true >	Struct for powers
CPower< N, false >	Struct for powers
CPower< N, true >	Struct for powers
►NPointer	The namespace for the reference counted pointer classes
CConstRCPtr	ConstRCPtr is a reference counted (smart) const pointer
CPtr	Ptr is a templated class to provide typedefs for pointers types ThePEG should use for a given type
CPtrTraits	The PtrTraits class is used everywhere in ThePEG to interface to the pointers which are handled
CPtrTraits< const T * >	Specialization of the PtrTraits class for standard bare const pointers
CPtrTraits< ConstRCPtr< T > >	Specialization of the PtrTraits class for ConstRCPtr
CPtrTraits< RCPtr< T > >	Specialization of the PtrTraits class for RCPtr
CPtrTraits< T * >	Specialization of the PtrTraits class for standard bare pointers
CPtrTraits< TransientConstRCPtr< T > >	Specialization of the PtrTraits class for TransientConstRCPtr
CPtrTraits< TransientRCPtr< T > >	Specialization of the PtrTraits class for TransientRCPtr
CPtrTraitsType	PtrTraitsType is an empty non-polymorphic base class for all PtrTraits classes
CRCPtr	RCPtr is a reference counted (smart) pointer
CRCPtrBase	RCPtrBase is the base class of RCPtr and ConstRCPtr which are reference counted (smart) pointers
CReferenceCounted	ReferenceCounted must be the (virtual) base class of all classes which may be pointed to by the RCPtr smart pointer class
CTransientConstRCPtr	TransientConstRCPtr is a simple wrapper around a bare const pointer which can be assigned to and from an RCPtr and ConstRCPtr without problem
CTransientRCPtr	TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr and ConstRCPtr without problem
CAbstractClassDescription	A concreate implementation of ClassDescriptionBase describing an abstract class with persistent data
CAbstractNoPIOClassDescription	A concreate implementation of ClassDescriptionBase describing an abstract class without persistent data
CACDCSampler	This class inherits from SampleBase and implements the Auto Compensating Divide-and-Conquer phase space generator, ACDCGen
CAllSelector	Used to extract all particles from an event
CAlphaEMBase	AlphaEMBase an abstract base class used by the StandardModelBase class to implement the electro-magnetic coupling
CAlphaSBase	AlphaSBase is an abstract base class used by the StandardModelBase to implement the QCD coupling, $\alpha_S$
CAmplitude	Abstract base class for all the classes representing complex amplitudes associated with either a hard 2 $\rightarrow$ N subprocess or a decay 1 $\rightarrow$ N process
►CAnalysisHandler	The AnalysisHandler is the base class of all analysis objects which may be handled by the FullEventGenerator
CNoHistFactory	Exception class used if no histogram factory was found
CAndMatcher	The AndMatcher class represents the boolean and operation between its two template argument classes of base type MatcherBase
CAnyMatcher	A Matcher class which matches any particle
►CAnyReference	AnyReference is inspired by boost::any to hold a reference to an object of arbitrary type
CReferenceHolder
CReferenceHolderBase
CBaryonMatcher	A Matcher class which matches any baryon
CBase	Define the base class from which all (polymorphic) classes in ThePEG are derived
CBaseClasses	Helper class for multiple base classes
CBaseClassesTraits	Traits class used by DescribeCLassT for transparent handling of one base class or a several base classes encoded by BaseClasses
CBaseClassesTraits< BaseClasses< BaseT1, BaseT2, BaseT3, BaseT4 > >	Traits class used by DescribeCLassT for transparent handling of one base class or a several base classes encoded by BaseClasses
CBaseClassTrait	BaseClassTraits describes the base classes of the templated class
CBaseClassTrait< PDFBase, 1 >	This template specialization informs ThePEG about the \ * base classes of PDFBase
CBaseRepository	BaseRepository is a purely static class which keeps a set of InterfacedBase objects indexed by their name
CBeamParticleData	BeamParticleData inherits from the ParticleData class and is used for particles which have information about their sub-structure implemented as a pointer to a PDFBase object
CBinaryOpTraits	BinaryOpTraits should be specialized with typdefs called MulT and DivT which gives the type resulting when multiplying and dividing the template argument types respectively
CBinaryOpTraits< double, Lorentz5Vector< U > >	Template for multiplication by scalar
CBinaryOpTraits< Lorentz5Vector< T >, double >	Template for multiplication by scalar
CBinaryOpTraits< Lorentz5Vector< T >, Lorentz5Vector< U > >	Template for multiplication of two Lorentz5Vectors
CBinaryOpTraits< Lorentz5Vector< T >, LorentzVector< U > >	Template for multiplication for LorentzVector and Lorentz5Vector
CBinaryOpTraits< Lorentz5Vector< T >, std::complex< U > >	Template for multiplication for complex and Lorentz5Vector
CBinaryOpTraits< LorentzVector< T >, Lorentz5Vector< U > >	Template for multiplication for LorentzVector and Lorentz5Vector
CBinaryOpTraits< LorentzVector< T >, U >	Template for multiplication by scalar
CBinaryOpTraits< std::complex< T >, Lorentz5Vector< U > >	Template for multiplication by scalar
CBinaryOpTraits< T, LorentzVector< U > >	Template for multiplication by scalar
CBreitWignerMass	BreitWignerMass is derived from MassGenerator and is able to generate the mass for a particle given its nominal mass and its with
CBudnevPDF	Here is the documentation of the BudnevPDF class
CCascadeHandler	The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade models
CCFile	Here is the documentation of the CFile class
CCFileLineReader	CFileLineReader is a wrapper around a standard C FILE stream
CChargedMatcher	A Matcher class which matches any charged particle
CChargedSelector	Used to extract all charged particles from an event
CCKMBase	CKMBase is an abstract base classused by the StandardModelBase to implement the Cabibbo-Kobayashi-Mascawa mixing matrix
CClassDescription	A concreate implementation of ClassDescriptionBase describing a concrete class with persistent data
CClassDescriptionBase	ClassDescriptionBase is the base class for all class description classes
CClassDescriptionHelper	A helper class for tracing the base classes of a class to be described
CClassDescriptionTBase	An intermediate templated base class derived from ClassDescriptionBase
CClassDocumentation	The `ClassDocumentation` class is used to communicate documetation about an Interfaced class to the Repository
CClassDocumentationBase	Used to communicate documetation about an Interfaced class to the Repository
CClassTraits	The default concrete implementation of ClassTraitsBase
CClassTraits< double >	ClassTraits specialization for double
CClassTraits< PDFBase >	This template specialization informs ThePEG about the name of \ * the PDFBase class and the shared object where it is defined
CClassTraitsBase	The templated ClassTraitsBase class defines a set of default information about classes used by ThePEG
CClassTraitsType	ClassTraitsType is an empty, non-polymorphic, base class
CClusterCollapser	ClusterCollapser is a general StepHandler which can be called anywhere in the event generation (typically as a pre-handler to the hadronization or a post-hadnler to the cascade) to find colour-less clusters of partons which are deemed to have to small invariant mass to be hadronized in the normal way
CCollision	This is the decalaration of the Collision class
CColourBase	ColourBase is the base class to be used to supply a Particle with information about its colour state
CColourLine	Colour lines connecting `Particle`s
CColourLines	Defines the colour flow in a SubProcess
CColourPairDecayer	ColourPairDecayer inherits from the FlatDecayer class and performs decays according to phase space into two or more particles, some of which may be coloured
CColourSinglet	A `ColourSinglet` object represents a set of colour-connected partons in a total colour-singlet state
CCommand	The CommandBase and its templated Command sub-class defines an interface to a class derived from the InterfacedBase, through which arbitratry command strings can be sent and received
CCommandBase	The CommandBase and its templated Command sub-class defines an interface to a class derived from the InterfacedBase, through which arbitratry command strings can be sent and received
►CCompSelector	The CompSelector class works like the Selector class in that it can be used to randomly select objects according to associated probabilities
CLevel	Internal struct used for bookkeeping when compensating
CConstituentParticleData	ConstituentParticleData inherits from the ParticleData class and is used for quarks, diquarks and gluons to store information about their constituent mass
CCurrent	The Current class keeps a static stack of objects of the templated class, which can be used anywhere by any class
►CCurrentGenerator	This CurrentGenerator class keeps a static stack of EventGenerators which can be used anywhere by any class
CRedirect	Class used to temporarily redirect a given ostream to the misc() stream of the current EventGenerator
CCuts	Cuts is a class for implementing kinematical cuts in ThePEG
CDalitzDecayer	The DalitzDecayer inherits from the Decayer class and performs Dalitz decays into $\gamma e^+ e^-$
CDebug	The `Debug` class defines a number of debug levels and a static public member giving the current debug level in a run
CDebugItem	Can be used to efficiently handle detailed debug options
►CDecayer	Decayer is an abstract base class to specify objects modelling the decay of a particle
CDecayFailure	Exception class used if something goes wrong in DecayParticle()
CDecayHandler	The DecayHandler is the base class of all handlers implementing the administration of decays of unstable particles
CDecayMode	Describes a decay channel of a particle
CDeleted	The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase
CDeletedBase	The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase
CDeltaMeasureCuts	This class implements a cuts on legoplot and rapidity separation
CDescribeAbstractClass	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CDescribeAbstractNoPIOClass	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CDescribeClass	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CDescribeClassAbstractHelper	Helper class used by DescribeClassT for transparent handling of abstract and concrete classes
CDescribeClassAbstractHelper< T, true >	Helper class used y DescribeClassT for transparent handling of abstract and concrete classes
CDescribeClassPIOHelper	Helper class used by DescribeClassT for transparent handling of classes with and without persistent I/O functions
CDescribeClassPIOHelper< T, true >	Helper class used by DescribeClassT for transparent handling of classes with and without persistent I/O functions
CDescribeClassT	DescribeClassT and its derived companion classes DescribeClass DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to the type information system in ThePEG
CDescribeNoPIOClass	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CDescriptionList	The `DescriptionList` keeps a static list of descriptions of classes included in the current run
CDiagramBase	DiagramBase is the base class of all classes which describes Feynman diagrams which can be generated by a matrix element class inheriting from MEBase, as reported by the MEBase::includedDiagrams() method
CDiquarkMatcher	A Matcher class which matches any (anti-)diquark
CDirection	A `Direction` object can be used to specify that some following operations should be assumed to be performed with the z-direction of the momenta reversed
CDIterator	DIterator is an iterator adaptor class
CDummyDecayer	DummyDecayer inherits from Decayer and is a dummy decayer class to be used for symbolic decay channels
CDummyType	Dummy type for ambiguous function signatures
CDynamicLoader	`DynamicLoader` is the general interface to the dynamic loader functions of the underlying operating system
CEvent	All Particles produced in the generation of an event
CEventConfig	A helper class to facilitate persistent input and output
CEventGenerator	Manages a whole event generator run
CEventHandler	The EventHandler is the base class used to implement event handlers in ThePEG
CEventInfoBase	EventInfoBase is a base class for information objects
CEventManipulator	An object of the EventManipulator class may be assigned to a FullEventGenerator object
CException	`Exception` is the base class for all exceptions to be used in ThePEG
►CFactoryBase	Here is the documentation of the FactoryBase class
CDataFiller	DataFiller is a helper class to facilitate adding data to a DataPointSet
CFinalStateSelector	Used to extract all final state particles from an event
CFixedCMSLuminosity	Describes an experiment with incoming particles colliding with precicely defined and opposite momenta
CFlatDecayer	Inrerits from the abstract Decayer class and implements the decay of a given Particle to a given set of children according to a flat phase space distribution
CFlavourGenerator	FlavourGenerator is an abstract base class to be used to implement models describing the quark content of hadrons
CGaussianPtGenerator	GaussianPtGenerator inherits from the abstract PtGenerator class
CGraphvizPlot	Generates an output of the tree structure of the event which can be viewed using dot
CGRV94L	GRV94L inherits from PDFBase via the GRVBase class and implements the GRV94L parton densities for (anti) protons and neutrons
CGRV94M	GRV94M iherits from PDFBase via the GRVBase class and implements the GRV94M parton densities for (anti) protons ad neutrons
CGRVBase	GRVBase inherits from PDFBase and is used as a base class for all GRV parton densities
CHadronizationHandler	The HadronizationHandler is the base class of all handlers implementing models for hadronization of coloured particles
CHandlerBase	HandlerBase is an abstract base class derived from the Interfaced class via the HandlerBaseT class adding some functionality such as easy acces to the RandomGenerator and the StandardModel object of the controlling EventGenerator object
CHandlerBaseT	HandlerBaseT is a dummy abstract templated class used as base class to HandlerBase
CHandlerGroup	HandlerGroup is a templated utility class to manage a group of `StepHandler`s
CHandlerGroupBase	HandlerGroupBase is the base class for the templated HandlerGroup utility class to manage a group of `StepHandler`s
CHelicityVertex	Designed to store the helicity amplitude expression for the matrix element for use by the spin correlation algorithm
CHEPEUP	Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name
►CHepMCConverter	The HepMCConverter defines only one public static function which converts a ThePEG::Event object to a `HepMC::GenEvent`
CVertex	Help class to represent a temporary vertex which can be converted to a GenVertex
CHepMCFile	Outputs ThePEG events in HepMC format
CHepMCTraits	The HepMCTraits class is used to deal with different flavours of HepMC in the HepMCConverter class
CHepMCTraits< HepMC::GenEvent >	Struct for HepMC conversion
CHepMCTraitsBase	HepMCTraitsBase is a convenient base class for specializing the HepMCTraits class to deal with different flavours of HepMC in the HepMCConverter class
CHEPRUP	Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name
CHint	Hint is a base class to be used to pass information between `StepHandler` s, which cannot be convayed through the Event record
CHoldFlag	`HoldFlag` objects are used to temporarily change the value of an object, restoring the original value when the `HoldFlag` object is destructed
CHoldFlag< bool >	Specialization of HoldFlag for boolean variables
CIEnum	The `IEnum` helper class is used to facilitate input of enums from persistent streams
CInputDescription	InputDescription objects are used by the PersistentIStream class to keep track of all classes it has read from a stream
CInt2Type	Conversion between integers and types
CInterfaceBase	Defines a generic interface to any class derived from the InterfacedBase class
CInterfaced	Derived from the InterfacedBase class adding a couple of things particular to ThePEG, in an attempt to keep the InterfacedBase class as generic as possible
►CInterfacedBase	InterfacedBase is the base class of all Interfaced objects to be handled by the BaseRepository class
CUpdateChecker	Functor class to be used to update a range of dependent object
CUpdateMapChecker	Functor class to be used to update a range of dependent object in a map
CIntermediateSelector	Used to extract only intermediate particles from an event
CInterval	An `Interval` object is used to represent an interval `[ lower(), upper() )` where the ordering is defined by the `bool operator()(const T &, const T &) const` member of the CMP class (by defaut less<T>)
CIteratorRange	A pair of iterators to be used in specialized algorithms instead of the standard first, last construction
CIUnit	The IUnit class is used to facilitate input of unitful numbers from and to a persistent stream
CIUnitErr	The IUnitErr class is used to facilitate input of unitful numbers with error estimates written out using the OUnitErr class
CJetFinder	JetFinder defines an interface to jet finders to be used when cuts should actually be defined on the level of reconstructed jets such as typically encountered in higher order corrections
CKTClus	This clas implements the cuts relevant for the $\Delta R$ -measure in the longitudinally invariant kt-algorithm
CKTRapidityCut	Simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle
CLastXCombInfo	LastXCombInfo is a templated class giving easy access to the information in an XComb object
CLeptonLeptonPDF	LeptonLeptonPDF inherits from PDFBase and encodes the distribution of leptons within leptons, ie
CLeptonMatcher	A Matcher class which matches any lepton
CLesHouchesEventHandler	The LesHouchesEventHandler 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
CLesHouchesFileReader	LesHouchesFileReader is an base class to be used for objects which reads event files from matrix element generators
CLesHouchesReader	LesHouchesReader is an abstract base class to be used for objects which reads event files or streams from matrix element generators
CLevel	Level is used to increment temporarily a given integer variable
CLHAPDF	Inherits from PDFBase and implements an interface to the LHAPDF library of parton density function parameterizations
CLightAntiQuarkMatcher	A Matcher class which matches any light anti-quark ( $\bar{\mbox{d}}$ , $\bar{\mbox{u}}$ or $\bar{\mbox{s}}$ )
CLightQuarkMatcher	A Matcher class which matches any light quark (d,u or s)
CLoopGuard	A LoopGuard object can be used to throw an exception if a loop is iterated too many times
CLoopGuard< ExceptionT, void >	A LoopGuard object can be used to throw an exception if a loop is iterated too many times
CLorentz5Vector	The Lorentz5Vector inherits from the `LorentzVector` class
CLorentzRotation	Combine a SpinOneLorentzRotation and a spin SpinHalfLorentzRotation to provide members which can perform the Lorentz transformation of any object
CLorentzVector	A 4-component Lorentz vector
CLuminosityFunction	The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment
CLWHFactory	Here is the documentation of the LWHFactory class
CMadGraphOneCut	Objects of the MadGraphOneCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts
►CMadGraphReader	MadGraphReader inherits from LesHouchesFileReader and is able to read event files produced by the MadGraph/MadEvent program
CWeightedException	Exception class used to inform about inability to work with some weighted event files
CMadGraphTwoCut	Objects of the MadGraphTwoCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts
CMain	This is a base class for classes implementing a main steering routine for running an EventGenerator, in case the standard 'go()' function in the EventGenerator is not enough
CMassGenerator	MassGenerator is an abstract base class used by the ParticleData class to generate a mass for a Particle instance
CMatcher	Matcher is a templated class inheriting from MatcherBase
CMatcherBase	MatcherBase is an abstract base class to be used for objects representing groups of ParticleData objects
CMatcherType	MatcherType is an empty non-polymorphic base class for all matcher classes to be used as template argument to Matcher
CMaxCmp	MaxCmp is a helper class to be used in a loop where one would like to keep track of the largest value so far of a certain expression
CME2to2Base	ME2to2Base can be used as a base class for any matrix element class implementing 2 $\rightarrow$ 2 processes
CME2to2QCD	Inherits from the ME2to2Base class and can be used as a sub class for all QCD 2 $\rightarrow$ 2 processes
CMEBase	Base class of all objects representing hard matrix elements in ThePEG
CMEee2gZ2qq	Implements the $e^+e^-\rightarrow\gamma/Z^0\rightarrow q\bar{q}$ matrix element
CMEGG2GG	MEGG2GG inherits from ME2to2QCD and implements the standard $gg\rightarrow gg$ matrix element
CMEGG2QQ	MEGG2QQ inherits from ME2to2QCD and implements the standard $gg\rightarrow gq\bar{q}$ matrix element
CMEGroup	'head' matrix element in association with a group of dependent matrix elements
CMENCDIS	Implements the $e^\pm q\rightarrow e^\pm q$ matrix element
CMEQG2QG	MEQG2QG inherits from ME2to2QCD and implements the standard $qg\rightarrow qg$ matrix element
CMEQQ2GG	MEQQ2GG inherits from ME2to2QCD and implements the standard $q\bar{q}\rightarrow gg$ matrix element
CMEqq2qq	MEqq2qq inherits from the ME2to2QCD and implements the standard $q_i\bar{q}_i\rightarrow q_i\bar{q}_i$ matrix element
CMEQQ2qq	MEQQ2qq inherits from ME2to2QCD and implements the standard $q\bar{q}\rightarrow q'\bar{q'}$ matrix element
CMEQQ2QQ	MEQQ2QQ inherits from ME2to2QCD and implements the standard $q_iq_i\rightarrow q_iq_i$ matrix element
CMEQq2Qq	MEQq2Qq inherits from ME2to2QCD and implements the standard $q_iq_j\rightarrow q_iq_j$ mmatrix element
CMesonMatcher	A Matcher class which matches any meson
CMinCmp	Special calss for Minimum comparisons
CMixedParticleData	Designed to store the particle data for particles which undergo mixing with their anti-particle, e.g
CMultiColour	This class is used to store colour information of RemnantParticle objects and other particle classes with complicated colour structures
CMultiCutBase	This class corresponds to a kinematical cut to be made on a set of outgoing particles from a hard sub-process
CMultiEventGenerator	Derived from the EventGenerator class and is capable of making several runs with a pre-defined set of parameter and switch values
CMultipleInteractionHandler	The MultipleInteractionHandler is the base class of all handlers implementing models for multiple interactions
CNamed	The `Named` class is a simple concrete base class to used by classes of objects with a name
CNegativeMatcher	A Matcher class which matches any negatively charged particle
CNeutralMatcher	A Matcher class which matches any uncharged particle
CNLOKTJetFinder	NLOKTJetFinder implements the class of longitudinally invariant kt jet clustering algorithms, as relevant for cuts on the real emission contribution to a NLO calculation
CNoPDF	NoPDF inherits from PDFBase and represents particles without sub-structure
CNoPIOClassDescription	A concreate implementation of ClassDescriptionBase describing a concrete class without persistent data
CNoRemnants	NoRemnants inherits from RemnantHandler but can only handle particles without sub-structure with the parton density given by a NoPDF object and will never give any remnants
CNotMatcher	The NotMatcher class represents the boolean not operation for its template argument class of base type MatcherBase
CO1AlphaS	O1AlphaS inherits from AlphaSBase and implements the leading order running QCD coupling
CObjectIndexer	This is a templated class which dynamically associates (reference counted) objects to integer indices
COEnum	The `OEnum` helper class is used to facilitate output of enums to persistent streams
COmegaPhi3PiDecayer	Inherits from performs FlatDecayer and will reweight the flat phase space suitable to describe the decay of a $\phi$ or an $\omega$ into $\pi^+\pi^-\pi^0$
COneCutBase	This class corresponds to a kinematical cut to be made on a single outgoing parton from a hard sub-process
COnium3GDecayer	Inherits from performs FlatDecayer and will reweight the flat phase space suitable to describe the decay of a spin-1 onium resonance into three gluons or two gluons and a photon
COrMatcher	The OrMatcher class represents the boolean or operation between its two template argument classes of base type MatcherBase
COUnit	The OUnit< class is used to facilitate output of unitful numbers to a persistent stream
COUnitErr	OUnitErr is used to write out unitful numbers with an error estimate on a standard ostream
CParameter	The Parameter and its base classes ParameterTBase and ParameterBase defines an interface to a class derived from the InterfacedBase, through which simple member variables can be manuipulated
CParameter< T, string >	This is a partial specialization of Parameter for the string case
CParameterBase	The Parameter and its base classes ParameterTBase and ParameterBase defines an interface to a class derived from the InterfacedBase, through which simple member variables can be manuipulated
CParameterTBase	The Parameter and its base classes ParameterTBase and ParameterBase defines an interface to a class derived from the InterfacedBase, through which simple member variables can be manuipulated
CParameterTBase< string >	This is a specialization of ParameterTBase for the string case
►CParticle	Used to describe an instance of a particle
CParticleRep	This class is used internally in the Particle class to represent information besides momentum and type
CParticleData	ParticleData inherits from InterfacedBase and represents the properties of a particle type
CParticleSelector	The templated `ParticleSelector` class may be used to implement derived classes from the `SelectorBase` class
CParticleTraits	ParticleTraits is a templated class defining a general interface to any particle class
CPartonBin	Used by the PartonExtractor class to store information about the extraction of a parton from a particle
CPartonBinInstance	PartonBinInstance is used to store information about the generation of a given parton extraction for a corresponding PartonBin object
CPartonExtractor	The PartonExtractor is a base class defining the interface to objects responsible for extracting partons from particles
CParVector	The ParVector and its base classes ParVectorTBase and ParVectorBase defines an interface to a class derived from the InterfacedBase, through which vectors (or any other container) of simple member variables can be manuipulated
CParVectorBase	The ParVector and its base classes ParVectorTBase and ParVectorBase defines an interface to a class derived from the InterfacedBase, through which vectors (or any other container) of simple member variables can be manuipulated
CParVectorTBase	The ParVector and its base classes ParVectorTBase and ParVectorBase defines an interface to a class derived from the InterfacedBase, through which vectors (or any other container) of simple member variables can be manuipulated
CPDF	PDF is a simple wrapper class with normal copy-semantics which holds a PDFBase object and a ParticleData object for which to determine parton densities
CPDFBase	PDFBase is the base class for implementing parton density functions for particles with sub-structure
CPDFCuts	Used to specify cuts on scale and momentum fractions for which a PDFBase object is expected to give parton densities
CPDT	PDT is a helper class implementing enumerations for charge, colour and spin to be used by the ParticleData class
CPersistentIStream	PersistentIStream is used to read persistent objects from a stream where they were previously written using PersistentOStream
CPersistentOStream	PersistentOStream is used to write objects persistently to a stream from which they can be read in again with a PersistentIStream
CPID	PID is a helper class implementing the type of PDG particle ids
CPolarizedBeamParticleData	PolarizedBeamParticleData inherits from the BeamParticleData class and is used for polarized beam particles
CPositiveMatcher	A Matcher class which matches any positively charged particle
CPrimaryCollisionSelector	Used to extract all particles from the primary Collision of an event
CProgressLog	Will not perform an actual analysis
CPseudoScalarMesonMatcher	A Matcher class which matches any pseudo scalar meson
CPtGenerator	PtGenerator is the base for all classes implementing alternative models for transverse momentum generation
CQTY	Helper class to define unitful quantities
CQty	This template class allows the compiler to check calculations with physical quantities for dimensional correctness
CQty< 0, 0, 0, DL, DE, DQ >	Specialization of Qty for <0,0,0> with conversions to double
CQtyHelper	Helper classes to extend or shorten fractions
CQtyHelper< 0, II >	Template to help with fractional powers of dimensions
CQtyInt	Template to help with fractional powers of dimensions
CQuarkMatcher	A Matcher class which matches any (anti-)quark
CQuarksToHadronsDecayer	Inherits from Decayer and is able to decay particles to (2 or 4) quarks which then are decayed to hadrons according to phase space
CRandomGenerator	RandomGenerator is an interface to the CLHEP::RandomEngine classes
CRebinder	Rebinder is a class associating pairs of pointers to objects
CReference	The Reference and its base class ReferenceBase defines an interface to a class derived from the InterfacedBase, through which pointers to other InterfacedBase objects may be manipulated
CReferenceBase	The Reference class and its base class ReferenceBase defines an interface to a class derived from the InterfacedBase, through which pointers to other InterfacedBase objects may be manipulated
CRefInterfaceBase	RefInterfaceBase is an abstract base class inheriting from InterfaceBase used for subclasses dealing with interfaces to do with references in one Interfaced object to another
CRefVector	The RefVector and its base class RefVectorBase defines an interface to a class derived from the InterfacedBase, through which vectors (or any other container) of pointers to other InterfacedBase objects may be manipulated
CRefVectorBase	The RefVector and its base class RefVectorBase defines an interface to a class derived from the InterfacedBase, through which vectors (or any other container) of pointers to other InterfacedBase objects may be manipulated
CRemInfoBase	Empty base class
CRemnantData	Not a normal ParticleData class
►CRemnantDecayer	Base class to be used for all decayers capable of decaying a RemnantParticle object produced by a SoftRemnantHandler object
CSubSystemFail	Exception used if getSubSystem fails
CRemnantHandler	RemnantHandler is an abstract base class for implementing classes used to generate remnants when partons are extracted from particles
CRemnantParticle	Here is the documentation of the RemnantParticle class
CRepository	Repository inherits from the BaseRepository class
CReweightBase	Base class of all objects representing external biases to matrix elements
CReweightConstant	Simple ReweightBase sub-class which simply reweight an event with a constant
CReweightMinPT	Reweights matrix elements with the minimum of the transverse momenta of the outgoing partons to some power
CRhoDMatrix	Designed to implement the storage of the rho and D matrices which are required for the spin correlation algorithm
CRivetAnalysis	Here is the documentation of the RivetAnalysis class
CRunningCoupling	RunningCoupling an abstract base class unifying the treatment of running couplings in ThePEG
CSamplerBase	This is the base class for all phase space sampler classes to be used by the EventHandler class to sample the phase space according to the cross sections for the processes in the EventHandler
CSelectIfBoth	Can be used to combine other selector objects
CSelectIfEither	Can be used to combine other selector objects
CSelectIfNot	The SelectIfNot classes can be used to negate the meaning of another SelectorBase object
CSelector	Selector is a templated class for storing objects associated with probabilities in a way such that, given a flat random number between 0 and 1, an object can be selected according to its relative probability
CSelectorBase	Classes derived from the `SelectorBase` class are used to extract particles from an Event with `Event::select()` method
CSimpleAlphaEM	SimpleAlphaEM inherits from AlphaEMBase and implements a simple running of the electromagnetic coupling as parameterized by H
►CSimpleBaryonRemnantDecayer	Inherits from the RemnantDecayer class and is able to decay RemnantParticles produced by the SoftRemnantHandler class for the cases when a single parton has been extracted from a baryon
CBaryonContent	Simple struct to store info about baryon quark and di-quark constituents
CDecayFailed	Exception thrown if the decay of a remnant was impossible
CNoDISRespect	Warning Exception used when DIS kinematics was not respected
CSimpleDISCut	SimpleDISCut inherits from TwoCutBase and omplements a simple cut on the a scattered lepton, either neutral or charged current
CSimpleFlavour	SimpleFlavour is a simple class to generate hadrons given the quark flavours
CSimpleKTCut	This is a very simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle
CSimplePhaseSpace	SimplePhaseSpace defines a set of static functions to be used for distributing momenta evenly in phase space
CSimpleZGenerator	SimpleZGenerator is a very simple concrete subclass of ZGenerator
CSoftRemnantHandler	SoftRemnantHandler inherits from the RemnantHandler and implements the generation of a single collinear RemnantParticle when anything is extracted from anything else
CSpinHalfLorentzRotation	Designed to offer the same features as the HepLorentzRotation class of CLHEP but for the spin- $\frac12$ Lorentz transformation
CSpinInfo	The SpinInfo is the base class for the spin information for the spin correlation algorithm
CSpinOneLorentzRotation	..
CStandardCKM	StandardCKM inherits from CKMBase and implements the standard parameterization of the CKM matrix in terms of three angles and a phase
CStandardEventHandler	Main class for generating simple events without overlayed collisions
CStandardModelBase	StandardModelBase is used to handle standard model parameters in an EventGenerator
CStandardQCDPartonMatcher	A Matcher class which matches any standard QCD parton, ie
CStandardRandom	StandardRandom inherits from the RandomGenerator class and is an interface to the CLHEP::JamesRandom engine class
CStandardXComb	Inherits from the more general XComb class which stores all information about the generation of a hard sub-proces for a given pair of incoming particles, a pair of extracted partons, etc
CStdDependentXComb	Inherits from the StandardXComb class and represents information on a hard subprocess in dependence of another hard subprocess referred to by the head XComb object
CStdXCombGroup	'head' XComb object in association with a group of dependent XComb objects
CStep	Information of all particles present after certain step in the event generation
CStepHandler	StepHandler is the base class for implementing any model for a step in the event generation chain
CStop	A standard exception class to be used to temporarily stop the generation of an event
CStrategy	General strategy to be assigned to an EventGenerator
CStringUtils	Few static utility functions for basic strings
CSubProcess	A SubProcess object represents a hard $2\rightarrow n$ sub-process in a collision
CSubProcessGroup	A SubProcessGroup object represents a group of SubProcess objects in dependence of a head SubProcess object
CSubProcessHandler	Used to handle a set of MEBase objects together with a PartonExtractor
CSwitch	The Switch class and its base class SwitchBase defines an interface to a class derived from the InterfacedBase, through which simple integer member variables can be manuipulated and set to a pre-defined set of values (options)
CSwitchBase	The Switch class and its base class SwitchBase defines an interface to a class derived from the InterfacedBase, through which simple integer member variables can be manuipulated and set to a pre-defined set of values (options)
CSwitchOption	SwitchOption is used by the Switch class and its base class SwitchBase to define valid options in a switch
CTau2HadronsDecayer	Inherits FlatDecayer and can perform the decays of tau to neutrino + hadrons according to phase space, with an extra weight $x_\nu(3-x_\nu)$
CTestLHAPDF	Class derived from Main to do simple tests of the LHAPDF class
CThePEGStrategy	Sub-class of the Strategy class, simply implementing the correct citation for ThePEG in the ClassDocumentation interface
CThreeVector	A 3-component vector
CThrow	Helper function to make it easier to throw exceptions
CTmpTransform	This is a wrapper class to be used to temporarily make a Lorentz transform of an object
CTraitsType	TraitsType is an empty, non-polymorphic, base class
CTransformer	A helper class to be used in `std::` algorithms to transform a range of particles
CTransverse	Transverse represents the transverse components of a LorentzVector
CTree2toNDiagram	Inherits from DiagramBase and represents a Feynman tree diagram
CTriplet	The Triplet class represents a general triplet of objects completely analogous to `std::pair`
CTwoCutBase	This class corresponds to a kinematical cut to be made on a pair of particles in a hard sub-process
CTypeInfo	TypeInfo is a simple wrapper around the ClassDescription system in ThePEG
CTypeTraits	Type traits for built-in types
CUnResolvedRemnant	UnResolvedRemnant inherits from the RemnantHandler and implements the generation of either the incoming particle as the remnant with the emission of a photon, pomeron or reggeon, or a photon remnant for the particle entering the hard process
CUseRandom	This UseRandom class keeps a static stack of RandomGenerator objects which can be used anywhere by any class
CUtilities	Concrete class with UtilityBase as base class
CUtilityBase	UtilityBase is a base class implementing a number of static utility functions
CV2LeptonsCut	This class inherits from MultiCutBase and describes cuts on the invariant mass of two final state leptons corresponding to the decay of a vector boson
CV2PPDecayer	Performs the decay of a vector meson into two pseudo-scalars according to a flat phase space
CVectorMesonMatcher	A Matcher class which matches any vector meson
CVeto	A standard exception class to be used for vetoing a whole event
CVSelector	VSelector is a templated class for storing objects associated with probabilities in a way such that, given a flat random number between 0 and 1, an object can be selected according to its relative probability
CWeakToHadronsDecayer	Inherits from QuarksToHadronsDecayer and can performs weak decays of taus and charmed and bottom hadrons
CWeizsackerWilliamsPDF	Here is the documentation of the WeizsackerWilliamsPDF class
CWidthGenerator	WidthGenerator is an abstract base class to be used to encapsulate models for giving the partial decay width of a ParticleData given the specified DecayModes
CXComb	Stores all information about the generation of a hard sub-proces for a given pair of incoming particles, a pair of extracted partons, total parton-parton energy squared and a PartonExtractor object
►CXSecCheck	Simple analysis class used for testing purposes
CUnexpectedXSec	The exception class used if the target cross section was not met
CXSecStat	XSecStat is a concrete helper class used to collect statistics about the cross section for a specific process or group of processes
CZeroUnit	Helper class to construct zero unitful quantities
CZGenerator	ZGenerator is the base class for all classes implementing models to generate the momentum fraction, , taken by hadrons produced in a hadronization scenario