Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678]

CACDCGenerator::ACDCGen< Rnd, FncPtr >	ACDCGen is a general class for sampling multi-dimensional functions
CACDCGenerator::ACDCGen< UseRandom, tStdEHPtr >
CACDCGenerator::ACDCGenCell	ACDCGenCell is the class representing a generation cell in ACDCGen
CACDCGenerator::ACDCGenCellInfo	This is a class describing cells to the outside world to be used for debugging purposes
►CACDCGenerator::ACDCTraitsType	ACDCTraitsType is an empty non-polymorphic base class for all traits classes in ACDCGenerator
CACDCGenerator::ACDCFncTraits< FncPtr >	ACDCFncTraits defines the interface to functions to be sampled by ACDCGen
CACDCGenerator::ACDCRandomTraits< Rnd >	ACDCRandomTraits defines the interface to random number generator objects to be used by ACDCGen
CThePEG::AnyReference	AnyReference is inspired by boost::any to hold a reference to an object of arbitrary type
CThePEG::CutTypes::Azimuth	Identify an azimuth-type cut
CThePEG::SimpleBaryonRemnantDecayer::BaryonContent	Simple struct to store info about baryon quark and di-quark constituents
CThePEG::BaseClasses< BaseT1, BaseT2, BaseT3, BaseT4 >	Helper class for multiple base classes
CThePEG::BaseClassesTraits< T >	Traits class used by DescribeCLassT for transparent handling of one base class or a several base classes encoded by BaseClasses
CThePEG::BaseClassesTraits< 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
►CThePEG::BaseRepository	BaseRepository is a purely static class which keeps a set of InterfacedBase objects indexed by their name
CThePEG::Repository	Repository inherits from the BaseRepository class
CThePEG::BinaryOpTraits< T, U >	BinaryOpTraits should be specialized with typdefs called MulT and DivT which gives the type resulting when multiplying and dividing the template argument types respectively
CBinningCheck< Unit >
CThePEG::CFile	Here is the documentation of the CFile class
CThePEG::CFileLineReader	CFileLineReader is a wrapper around a standard C FILE stream
CThePEG::ClassDescriptionHelper< T, IBase, B >	A helper class for tracing the base classes of a class to be described
►CThePEG::ClassDocumentationBase	Used to communicate documetation about an Interfaced class to the Repository
CThePEG::ClassDocumentation< T >	The ClassDocumentation class is used to communicate documetation about an Interfaced class to the Repository
CThePEG::BlobMEBase::ColourConnection	Helper struct to represent colour connections
CThePEG::ColourSinglet	A ColourSinglet object represents a set of colour-connected partons in a total colour-singlet state
Cstd::complex< ThePEG::QtyDouble >	Template specialization for std::complex<Qty<0,0,0> > with conversions to complex<double>
CThePEG::CompSelector< T, WeightType >	The CompSelector class works like the Selector class in that it can be used to randomly select objects according to associated probabilities
CThePEG::CompSelector< int, CrossSection >
CThePEG::Current< T >	The Current class keeps a static stack of objects of the templated class, which can be used anywhere by any class
CThePEG::CurrentGenerator	This CurrentGenerator class keeps a static stack of EventGenerators which can be used anywhere by any class
CThePEG::FactoryBase::DataFiller	DataFiller is a helper class to facilitate adding data to a DataPointSet
CThePEG::Debug	The Debug class defines a number of debug levels and a static public member giving the current debug level in a run
CThePEG::DebugItem	Can be used to efficiently handle detailed debug options
CThePEG::DescribeClassAbstractHelper< T, abstract >	Helper class used by DescribeClassT for transparent handling of abstract and concrete classes
CThePEG::DescribeClassAbstractHelper< T, true >	Helper class used y DescribeClassT for transparent handling of abstract and concrete classes
CThePEG::DescribeClassPIOHelper< T, NoPIO >	Helper class used by DescribeClassT for transparent handling of classes with and without persistent I/O functions
CThePEG::DescribeClassPIOHelper< T, true >	Helper class used by DescribeClassT for transparent handling of classes with and without persistent I/O functions
CThePEG::DescriptionList	The DescriptionList keeps a static list of descriptions of classes included in the current run
CThePEG::Direction< I >	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
CThePEG::DummyType	Dummy type for ambiguous function signatures
CThePEG::DynamicLoader	DynamicLoader is the general interface to the dynamic loader functions of the underlying operating system
CThePEG::CutTypes::Energy	Identify an energy-type cut
CThePEG::EventConfig	A helper class to facilitate persistent input and output
►Cstd::exception	STL class
►CThePEG::Exception	Exception is the base class for all exceptions to be used in ThePEG
CThePEG::Decayer::DecayFailure	Exception class used if something goes wrong in DecayParticle()
CThePEG::MadGraphReader::WeightedException	Exception class used to inform about inability to work with some weighted event files
CThePEG::RemnantDecayer::SubSystemFail	Exception used if getSubSystem fails
CThePEG::SimpleBaryonRemnantDecayer::DecayFailed	Exception thrown if the decay of a remnant was impossible
CThePEG::SimpleBaryonRemnantDecayer::NoDISRespect	Warning Exception used when DIS kinematics was not respected
CThePEG::XSecCheck::UnexpectedXSec	The exception class used if the target cross section was not met
CFixGlobal1
►CThePEG::HandlerGroupBase	HandlerGroupBase is the base class for the templated HandlerGroup utility class to manage a group of StepHandlers
CThePEG::HandlerGroup< ThePEG::SubProcessHandler >
CThePEG::HandlerGroup< ThePEG::CascadeHandler >
CThePEG::HandlerGroup< ThePEG::MultipleInteractionHandler >
CThePEG::HandlerGroup< ThePEG::HadronizationHandler >
CThePEG::HandlerGroup< ThePEG::DecayHandler >
CThePEG::HandlerGroup< HDLR >	HandlerGroup is a templated utility class to manage a group of StepHandlers
CThePEG::HEPEUP	Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name
CThePEG::HepMCConverter< HepMCEventT, Traits >	The HepMCConverter defines only one public static function which converts a ThePEG::Event object to a HepMC::GenEvent
CThePEG::HepMCTraits< HepMCEventT >	The HepMCTraits class is used to deal with different flavours of HepMC in the HepMCConverter class
CThePEG::HepMCTraitsBase< HepMCEventT, HepMCParticleT, HepMCParticlePtrT, HepMCVertexT, HepMCVertexPtrT, HepMCPolarizationT, HepMCPdfInfoT >	HepMCTraitsBase is a convenient base class for specializing the HepMCTraits class to deal with different flavours of HepMC in the HepMCConverter class
►CThePEG::HepMCTraitsBase< HepMC::GenEvent, HepMC::GenParticle, HepMC::GenParticle *, HepMC::GenVertex, HepMC::GenVertex *, HepMC::Polarization, HepMC::PdfInfo >
CThePEG::HepMCTraits< HepMC::GenEvent >	Struct for HepMC conversion
CThePEG::HEPRUP	Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name
CThePEG::HoldFlag< T >	HoldFlag objects are used to temporarily change the value of an object, restoring the original value when the HoldFlag object is destructed
CThePEG::HoldFlag< bool >	Specialization of HoldFlag for boolean variables
►CIAnalysisFactory
CLWH::AnalysisFactory	The "master" factory from which other factories are obtained
►CIAxis
CLWH::Axis	An Axis represents a binned histogram axis
CLWH::VariAxis	An VariAxis represents a binned histogram axis
►CIDataPoint
CLWH::DataPoint	An DataPoint represents a binned histogram axis
►CIDataPointSet
CLWH::DataPointSet	An DataPointSet represents a binned histogram axis
►CIDataPointSetFactory
CLWH::DataPointSetFactory	Basic user-level interface for creating a factory of IDataPointSet
CThePEG::IEnum< T >	The IEnum helper class is used to facilitate input of enums from persistent streams
►CIHistogram1D
CLWH::Histogram1D	User level interface to 1D Histogram
►CIHistogram2D
CLWH::Histogram2D	User level interface to 1D Histogram
►CIHistogramFactory
CLWH::HistogramFactory	User level interface for factory classes of Histograms (binned, unbinned, and profile)
►CIManagedObject
►CLWH::ManagedObject	The creator of trees
CLWH::DataPointSet	An DataPointSet represents a binned histogram axis
CLWH::Histogram1D	User level interface to 1D Histogram
CLWH::Histogram2D	User level interface to 1D Histogram
►CIMeasurement
CLWH::Measurement	Basic user-level interface class for holding a single "measurement" with positive and negative errors (to allow for asymmetric errors)
►CInitException
CThePEG::AnalysisHandler::NoHistFactory	Exception class used if no histogram factory was found
CThePEG::Int2Type< v >	Conversion between integers and types
CThePEG::Interval< T, CMP >	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>)
CThePEG::Interval< double >
CThePEG::Interval< Energy2 >
CThePEG::is_qty< T >
►CITree
CLWH::Tree	Simple implementation of the AIDA::ITree interface
►CITreeFactory
CLWH::TreeFactory	The creator of trees
CThePEG::IUnit< T, UT >	The IUnit class is used to facilitate input of unitful numbers from and to a persistent stream
CThePEG::IUnitErr< T, UT >	The IUnitErr class is used to facilitate input of unitful numbers with error estimates written out using the OUnitErr class
►CThePEG::LastXCombInfo< XC >	LastXCombInfo is a templated class giving easy access to the information in an XComb object
CThePEG::CascadeHandler	The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade models
►CThePEG::EventHandler	The EventHandler is the base class used to implement event handlers in ThePEG
CThePEG::LesHouchesEventHandler	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
CThePEG::StandardEventHandler	Main class for generating simple events without overlayed collisions
►CThePEG::LesHouchesReader	LesHouchesReader is an abstract base class to be used for objects which reads event files or streams from matrix element generators
►CThePEG::LesHouchesFileReader	LesHouchesFileReader is an base class to be used for objects which reads event files from matrix element generators
CThePEG::MadGraphReader	MadGraphReader inherits from LesHouchesFileReader and is able to read event files produced by the MadGraph/MadEvent program
►CThePEG::LuminosityFunction	The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment
CThePEG::FixedCMSLuminosity	Describes an experiment with incoming particles colliding with precicely defined and opposite momenta
CThePEG::FixedTargetLuminosity	Here is the documentation of the FixedTargetLuminosity class
CThePEG::PartonExtractor	The PartonExtractor is a base class defining the interface to objects responsible for extracting partons from particles
►CThePEG::ReweightBase	Base class of all objects representing external biases to matrix elements
CThePEG::ReweightConstant	Simple ReweightBase sub-class which simply reweight an event with a constant
CThePEG::ReweightMinPT	Reweights matrix elements with the minimum of the transverse momenta of the outgoing partons to some power
►CThePEG::LastXCombInfo< StandardXComb >
►CThePEG::MEBase	Base class of all objects representing hard matrix elements in ThePEG
CThePEG::BlobMEBase	Here is the documentation of the BlobMEBase class
►CThePEG::ME2to2Base	ME2to2Base can be used as a base class for any matrix element class implementing 2 \(\rightarrow\) 2 processes
►CThePEG::ME2to2QCD	Inherits from the ME2to2Base class and can be used as a sub class for all QCD 2 \(\rightarrow\) 2 processes
CThePEG::MEGG2GG	MEGG2GG inherits from ME2to2QCD and implements the standard \(gg\rightarrow gg\) matrix element
CThePEG::MEGG2QQ	MEGG2QQ inherits from ME2to2QCD and implements the standard \(gg\rightarrow gq\bar{q}\) matrix element
CThePEG::MENCDIS	Implements the \(e^\pm q\rightarrow e^\pm q\) matrix element
CThePEG::MEQG2QG	MEQG2QG inherits from ME2to2QCD and implements the standard \(qg\rightarrow qg\) matrix element
CThePEG::MEQQ2GG	MEQQ2GG inherits from ME2to2QCD and implements the standard \(q\bar{q}\rightarrow gg\) matrix element
CThePEG::MEQQ2QQ	MEQQ2QQ inherits from ME2to2QCD and implements the standard \(q_iq_i\rightarrow q_iq_i\) matrix element
CThePEG::MEQQ2qq	MEQQ2qq inherits from ME2to2QCD and implements the standard \(q\bar{q}\rightarrow q'\bar{q'}\) matrix element
CThePEG::MEQq2Qq	MEQq2Qq inherits from ME2to2QCD and implements the standard \(q_iq_j\rightarrow q_iq_j\) mmatrix element
CThePEG::MEee2gZ2qq	Implements the \(e^+e^-\rightarrow\gamma/Z^0\rightarrow q\bar{q}\) matrix element
CThePEG::MEqq2qq	MEqq2qq inherits from the ME2to2QCD and implements the standard \(q_i\bar{q}_i\rightarrow q_i\bar{q}_i\) matrix element
CThePEG::MEGroup	'head' matrix element in association with a group of dependent matrix elements
CACDCGenerator::ACDCGen< Rnd, FncPtr >::Level	A helper struct representing a level of compensation
CThePEG::CompSelector< T, WeightType >::Level	Internal struct used for bookkeeping when compensating
CThePEG::Level< T >	Level is used to increment temporarily a given integer variable
CThePEG::LoopGuard< ExceptionT, MessageT >	A LoopGuard object can be used to throw an exception if a loop is iterated too many times
CThePEG::LoopGuard< ExceptionT, void >	A LoopGuard object can be used to throw an exception if a loop is iterated too many times
CThePEG::Helicity::LorentzRank3Tensor< Value >	The LorentzRank3Tensor class is designed to implement the storage of a complex tensor to be used to representation the wavefunction of a spin-2 particle
CThePEG::Helicity::LorentzRank3Tensor< double >
CThePEG::LorentzRotation	Combine a SpinOneLorentzRotation and a spin SpinHalfLorentzRotation to provide members which can perform the Lorentz transformation of any object
CThePEG::Helicity::LorentzRSSpinor< Value >	The LorentzRSSpinor class is designed to store a Rarita-Schwinger spinor for a spin-3/2 particle
CThePEG::Helicity::LorentzRSSpinor< double >
CThePEG::Helicity::LorentzRSSpinor< ThePEG::Qty< std::ratio< L, DL >, std::ratio< E, DE >, std::ratio< Q, DQ > > >
CThePEG::Helicity::LorentzRSSpinorBar< Value >	The LorentzRSSpinorBar class implements the storage of a barred Lorentz Rarita-Schwinger Spinor for a spin-3/2 particle
CThePEG::Helicity::LorentzRSSpinorBar< double >
CThePEG::Helicity::LorentzSpinor< Value >	The LorentzSpinor class is designed to store a spinor
CThePEG::Helicity::LorentzSpinor< double >
CThePEG::Helicity::LorentzSpinor< ThePEG::Qty< std::ratio< L, DL >, std::ratio< E, DE >, std::ratio< Q, DQ > > >
CThePEG::Helicity::LorentzSpinorBar< Value >	The LorentzSpinorBar class implements the storage of a barred LorentzSpinor
CThePEG::Helicity::LorentzSpinorBar< double >
CThePEG::Helicity::LorentzTensor< Value >	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
CThePEG::Helicity::LorentzTensor< double >
►CThePEG::LorentzVector< Value >	A 4-component Lorentz vector
CThePEG::Lorentz5Vector< Energy >
CThePEG::Lorentz5Vector< Length >
CThePEG::Lorentz5Vector< Value >	The Lorentz5Vector inherits from the LorentzVector class
CThePEG::LorentzVector< complex< double > >
CThePEG::LorentzVector< Energy >
CThePEG::LorentzVector< Length >
►CThePEG::MatcherType	MatcherType is an empty non-polymorphic base class for all matcher classes to be used as template argument to Matcher
CThePEG::AndMatcher< T1, T2 >	The AndMatcher class represents the boolean and operation between its two template argument classes of base type MatcherBase
CThePEG::AnyMatcher	A Matcher class which matches any particle
CThePEG::BaryonMatcher	A Matcher class which matches any baryon
CThePEG::ChargedMatcher	A Matcher class which matches any charged particle
CThePEG::DiquarkMatcher	A Matcher class which matches any (anti-)diquark
CThePEG::LeptonMatcher	A Matcher class which matches any lepton
CThePEG::LightAntiQuarkMatcher	A Matcher class which matches any light anti-quark ( \(\bar{\mbox{d}}\), \(\bar{\mbox{u}}\) or \(\bar{\mbox{s}}\))
CThePEG::LightQuarkMatcher	A Matcher class which matches any light quark (d,u or s)
CThePEG::MesonMatcher	A Matcher class which matches any meson
CThePEG::NegativeMatcher	A Matcher class which matches any negatively charged particle
CThePEG::NeutralMatcher	A Matcher class which matches any uncharged particle
CThePEG::NeutrinoMatcher	A Matcher class which matches any neutrino
CThePEG::NotMatcher< T >	The NotMatcher class represents the boolean not operation for its template argument class of base type MatcherBase
CThePEG::OrMatcher< T1, T2 >	The OrMatcher class represents the boolean or operation between its two template argument classes of base type MatcherBase
CThePEG::PositiveMatcher	A Matcher class which matches any positively charged particle
CThePEG::PseudoScalarMesonMatcher	A Matcher class which matches any pseudo scalar meson
CThePEG::QuarkMatcher	A Matcher class which matches any (anti-)quark
CThePEG::StandardQCDPartonMatcher	A Matcher class which matches any standard QCD parton, ie
CThePEG::VectorMesonMatcher	A Matcher class which matches any vector meson
►CThePEG::Math::MathType	MathType is an empty non-polymorphic base class for all mathematical function types
CThePEG::Math::Functions::ExpX	Class corresponding to functions of the form \(e^x\)
CThePEG::Math::Functions::FracPowX< N, D >	Class corresponding to functions of the form \(x^{N/D}\) with integer N and D
CThePEG::Math::Functions::InvX1mX	Class corresponding to functions of the form \(1/(x(1-x))\)
CThePEG::Math::Functions::Pow1mX< N >	Class corresponding to functions of the form \((1-x)^N\) with integer N
CThePEG::Math::Functions::PowX< N >	Class corresponding to functions of the form \(x^N\) with integer N
CThePEG::Math::Power< N, Inv >	Templated class for calculating integer powers
►CThePEG::MaxCmp< T, Indx, Cmp >	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
CThePEG::MinCmp< T, Indx >	Special calss for Minimum comparisons
CThePEG::MaxCmp< T, int, less< T > >
CThePEG::CutTypes::Momentum	Identify a momentum-type cut
►CThePEG::Named	The Named class is a simple concrete base class to used by classes of objects with a name
►CThePEG::ClassDescriptionBase	ClassDescriptionBase is the base class for all class description classes
CThePEG::ClassDescriptionTBase< ThePEG::ACDCSampler >
CThePEG::ClassDescriptionTBase< ThePEG::AlphaEMBase >
CThePEG::ClassDescriptionTBase< ThePEG::AlphaSBase >
CThePEG::ClassDescriptionTBase< ThePEG::Amplitude >
CThePEG::ClassDescriptionTBase< ThePEG::AnalysisHandler >
CThePEG::ClassDescriptionTBase< ThePEG::BeamParticleData >
CThePEG::ClassDescriptionTBase< ThePEG::BlobDiagram >
CThePEG::ClassDescriptionTBase< ThePEG::BlobMEBase >
CThePEG::ClassDescriptionTBase< ThePEG::BreitWignerMass >
CThePEG::ClassDescriptionTBase< ThePEG::CKMBase >
CThePEG::ClassDescriptionTBase< ThePEG::CascadeHandler >
CThePEG::ClassDescriptionTBase< ThePEG::ClusterCollapser >
CThePEG::ClassDescriptionTBase< ThePEG::Collision >
CThePEG::ClassDescriptionTBase< ThePEG::ColourBase >
CThePEG::ClassDescriptionTBase< ThePEG::ColourLine >
CThePEG::ClassDescriptionTBase< ThePEG::ColourPairDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::ConstituentParticleData >
CThePEG::ClassDescriptionTBase< ThePEG::Cuts >
CThePEG::ClassDescriptionTBase< ThePEG::DalitzDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::DecayHandler >
CThePEG::ClassDescriptionTBase< ThePEG::DecayMode >
CThePEG::ClassDescriptionTBase< ThePEG::Decayer >
CThePEG::ClassDescriptionTBase< ThePEG::DeltaMeasureCuts >
CThePEG::ClassDescriptionTBase< ThePEG::DiagramBase >
CThePEG::ClassDescriptionTBase< ThePEG::DummyDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::Event >
CThePEG::ClassDescriptionTBase< ThePEG::EventGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::EventHandler >
CThePEG::ClassDescriptionTBase< ThePEG::EventInfoBase >
CThePEG::ClassDescriptionTBase< ThePEG::EventManipulator >
CThePEG::ClassDescriptionTBase< ThePEG::FactoryBase >
CThePEG::ClassDescriptionTBase< ThePEG::FixedCMSLuminosity >
CThePEG::ClassDescriptionTBase< ThePEG::FlatDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::FlavourGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::FuzzyTheta >
CThePEG::ClassDescriptionTBase< ThePEG::GRV94L >
CThePEG::ClassDescriptionTBase< ThePEG::GRV94M >
CThePEG::ClassDescriptionTBase< ThePEG::GaussianPtGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::GraphvizPlot >
CThePEG::ClassDescriptionTBase< ThePEG::HIHepMCFile >
CThePEG::ClassDescriptionTBase< ThePEG::HadronizationHandler >
CThePEG::ClassDescriptionTBase< ThePEG::HandlerBase >
CThePEG::ClassDescriptionTBase< ThePEG::HelicityVertex >
CThePEG::ClassDescriptionTBase< ThePEG::HepMC3File >
CThePEG::ClassDescriptionTBase< ThePEG::HepMCFile >
CThePEG::ClassDescriptionTBase< ThePEG::Hint >
CThePEG::ClassDescriptionTBase< ThePEG::Interfaced >
CThePEG::ClassDescriptionTBase< ThePEG::InterfacedBase >
CThePEG::ClassDescriptionTBase< ThePEG::JetCuts >
CThePEG::ClassDescriptionTBase< ThePEG::KTClus >
CThePEG::ClassDescriptionTBase< ThePEG::KTRapidityCut >
CThePEG::ClassDescriptionTBase< ThePEG::LWHFactory >
CThePEG::ClassDescriptionTBase< ThePEG::LeptonLeptonPDF >
CThePEG::ClassDescriptionTBase< ThePEG::LesHouchesEventHandler >
CThePEG::ClassDescriptionTBase< ThePEG::LesHouchesFileReader >
CThePEG::ClassDescriptionTBase< ThePEG::LesHouchesReader >
CThePEG::ClassDescriptionTBase< ThePEG::LuminosityFunction >
CThePEG::ClassDescriptionTBase< ThePEG::ME2to2Base >
CThePEG::ClassDescriptionTBase< ThePEG::ME2to2QCD >
CThePEG::ClassDescriptionTBase< ThePEG::MEBase >
CThePEG::ClassDescriptionTBase< ThePEG::MECuts >
CThePEG::ClassDescriptionTBase< ThePEG::MEGG2GG >
CThePEG::ClassDescriptionTBase< ThePEG::MEGG2QQ >
CThePEG::ClassDescriptionTBase< ThePEG::MEGroup >
CThePEG::ClassDescriptionTBase< ThePEG::MENCDIS >
CThePEG::ClassDescriptionTBase< ThePEG::MEQG2QG >
CThePEG::ClassDescriptionTBase< ThePEG::MEQQ2GG >
CThePEG::ClassDescriptionTBase< ThePEG::MEQQ2QQ >
CThePEG::ClassDescriptionTBase< ThePEG::MEQQ2qq >
CThePEG::ClassDescriptionTBase< ThePEG::MEQq2Qq >
CThePEG::ClassDescriptionTBase< ThePEG::MEee2gZ2qq >
CThePEG::ClassDescriptionTBase< ThePEG::MEqq2qq >
CThePEG::ClassDescriptionTBase< ThePEG::MadGraphOneCut >
CThePEG::ClassDescriptionTBase< ThePEG::MadGraphReader >
CThePEG::ClassDescriptionTBase< ThePEG::MadGraphTwoCut >
CThePEG::ClassDescriptionTBase< ThePEG::Main >
CThePEG::ClassDescriptionTBase< ThePEG::MassGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::Matcher< T > >
CThePEG::ClassDescriptionTBase< ThePEG::MatcherBase >
CThePEG::ClassDescriptionTBase< ThePEG::MixedParticleData >
CThePEG::ClassDescriptionTBase< ThePEG::MultiColour >
CThePEG::ClassDescriptionTBase< ThePEG::MultiCutBase >
CThePEG::ClassDescriptionTBase< ThePEG::MultiEventGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::MultipleInteractionHandler >
CThePEG::ClassDescriptionTBase< ThePEG::NJetsCut >
CThePEG::ClassDescriptionTBase< ThePEG::NLORivetAnalysis >
CThePEG::ClassDescriptionTBase< ThePEG::NoPDF >
CThePEG::ClassDescriptionTBase< ThePEG::NoRemnants >
CThePEG::ClassDescriptionTBase< ThePEG::O1AlphaS >
CThePEG::ClassDescriptionTBase< ThePEG::OmegaPhi3PiDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::OneCutBase >
CThePEG::ClassDescriptionTBase< ThePEG::OneJetCut >
CThePEG::ClassDescriptionTBase< ThePEG::Onium3GDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::PDFBase >
CThePEG::ClassDescriptionTBase< ThePEG::Particle >
CThePEG::ClassDescriptionTBase< ThePEG::ParticleData >
CThePEG::ClassDescriptionTBase< ThePEG::PartonBin >
CThePEG::ClassDescriptionTBase< ThePEG::PartonBinInstance >
CThePEG::ClassDescriptionTBase< ThePEG::PartonExtractor >
CThePEG::ClassDescriptionTBase< ThePEG::PolarizedBeamParticleData >
CThePEG::ClassDescriptionTBase< ThePEG::ProgressLog >
CThePEG::ClassDescriptionTBase< ThePEG::PtGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::QuarksToHadronsDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::RandomGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::RemnantData >
CThePEG::ClassDescriptionTBase< ThePEG::RemnantDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::RemnantHandler >
CThePEG::ClassDescriptionTBase< ThePEG::RemnantParticle >
CThePEG::ClassDescriptionTBase< ThePEG::ReweightBase >
CThePEG::ClassDescriptionTBase< ThePEG::ReweightConstant >
CThePEG::ClassDescriptionTBase< ThePEG::ReweightMinPT >
CThePEG::ClassDescriptionTBase< ThePEG::RivetAnalysis >
CThePEG::ClassDescriptionTBase< ThePEG::RunningCoupling >
CThePEG::ClassDescriptionTBase< ThePEG::SamplerBase >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleAlphaEM >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleBaryonRemnantDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleDISCut >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleFlavour >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleKTCut >
CThePEG::ClassDescriptionTBase< ThePEG::SimpleZGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::SoftRemnantHandler >
CThePEG::ClassDescriptionTBase< ThePEG::SpinInfo >
CThePEG::ClassDescriptionTBase< ThePEG::StandardCKM >
CThePEG::ClassDescriptionTBase< ThePEG::StandardEventHandler >
CThePEG::ClassDescriptionTBase< ThePEG::StandardModelBase >
CThePEG::ClassDescriptionTBase< ThePEG::StandardRandom >
CThePEG::ClassDescriptionTBase< ThePEG::StandardXComb >
CThePEG::ClassDescriptionTBase< ThePEG::StdXCombGroup >
CThePEG::ClassDescriptionTBase< ThePEG::Step >
CThePEG::ClassDescriptionTBase< ThePEG::StepHandler >
CThePEG::ClassDescriptionTBase< ThePEG::Strategy >
CThePEG::ClassDescriptionTBase< ThePEG::SubProcess >
CThePEG::ClassDescriptionTBase< ThePEG::SubProcessGroup >
CThePEG::ClassDescriptionTBase< ThePEG::SubProcessHandler >
CThePEG::ClassDescriptionTBase< ThePEG::Tau2HadronsDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::TestLHAPDF >
CThePEG::ClassDescriptionTBase< ThePEG::ThePEGStrategy >
CThePEG::ClassDescriptionTBase< ThePEG::Tree2toNDiagram >
CThePEG::ClassDescriptionTBase< ThePEG::TwoCutBase >
CThePEG::ClassDescriptionTBase< ThePEG::UnResolvedRemnant >
CThePEG::ClassDescriptionTBase< ThePEG::V2LeptonsCut >
CThePEG::ClassDescriptionTBase< ThePEG::V2PPDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::WeakToHadronsDecayer >
CThePEG::ClassDescriptionTBase< ThePEG::WeizsackerWilliamsPDF >
CThePEG::ClassDescriptionTBase< ThePEG::WidthGenerator >
CThePEG::ClassDescriptionTBase< ThePEG::XComb >
CThePEG::ClassDescriptionTBase< ThePEG::XSecCheck >
CThePEG::ClassDescriptionTBase< ThePEG::ZGenerator >
CThePEG::DescribeClassT< T, int, true, false >
CThePEG::DescribeClassT< T, int, true, true >
CThePEG::DescribeClassT< T, int, false, false >
CThePEG::DescribeClassT< T, int, false, true >
►CThePEG::ClassDescriptionTBase< T >	An intermediate templated base class derived from ClassDescriptionBase
CThePEG::AbstractClassDescription< ThePEG::AlphaSBase >
CThePEG::AbstractClassDescription< ThePEG::DiagramBase >
CThePEG::AbstractClassDescription< ThePEG::FactoryBase >
CThePEG::AbstractClassDescription< ThePEG::Interfaced >
CThePEG::AbstractClassDescription< ThePEG::InterfacedBase >
CThePEG::AbstractClassDescription< ThePEG::LesHouchesReader >
CThePEG::AbstractClassDescription< ThePEG::ME2to2Base >
CThePEG::AbstractClassDescription< ThePEG::ME2to2QCD >
CThePEG::AbstractClassDescription< ThePEG::MEBase >
CThePEG::AbstractClassDescription< ThePEG::MEGroup >
CThePEG::AbstractClassDescription< ThePEG::MatcherBase >
CThePEG::AbstractClassDescription< ThePEG::PDFBase >
CThePEG::AbstractClassDescription< ThePEG::PtGenerator >
CThePEG::AbstractClassDescription< ThePEG::RemnantDecayer >
CThePEG::AbstractClassDescription< ThePEG::RemnantHandler >
CThePEG::AbstractClassDescription< ThePEG::ReweightBase >
CThePEG::AbstractClassDescription< ThePEG::RunningCoupling >
CThePEG::AbstractClassDescription< ThePEG::SamplerBase >
CThePEG::AbstractClassDescription< ThePEG::ZGenerator >
CThePEG::AbstractNoPIOClassDescription< ThePEG::AlphaEMBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::Amplitude >
CThePEG::AbstractNoPIOClassDescription< ThePEG::BlobMEBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::CKMBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::CascadeHandler >
CThePEG::AbstractNoPIOClassDescription< ThePEG::Decayer >
CThePEG::AbstractNoPIOClassDescription< ThePEG::EventManipulator >
CThePEG::AbstractNoPIOClassDescription< ThePEG::FlavourGenerator >
CThePEG::AbstractNoPIOClassDescription< ThePEG::HadronizationHandler >
CThePEG::AbstractNoPIOClassDescription< ThePEG::HandlerBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::HelicityVertex >
CThePEG::AbstractNoPIOClassDescription< ThePEG::Main >
CThePEG::AbstractNoPIOClassDescription< ThePEG::MassGenerator >
CThePEG::AbstractNoPIOClassDescription< ThePEG::MultiCutBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::MultipleInteractionHandler >
CThePEG::AbstractNoPIOClassDescription< ThePEG::OneCutBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::StepHandler >
CThePEG::AbstractNoPIOClassDescription< ThePEG::TwoCutBase >
CThePEG::AbstractNoPIOClassDescription< ThePEG::WidthGenerator >
CThePEG::ClassDescription< ThePEG::ACDCSampler >
CThePEG::ClassDescription< ThePEG::AnalysisHandler >
CThePEG::ClassDescription< ThePEG::BeamParticleData >
CThePEG::ClassDescription< ThePEG::BlobDiagram >
CThePEG::ClassDescription< ThePEG::ClusterCollapser >
CThePEG::ClassDescription< ThePEG::Collision >
CThePEG::ClassDescription< ThePEG::ColourBase >
CThePEG::ClassDescription< ThePEG::ColourLine >
CThePEG::ClassDescription< ThePEG::ColourPairDecayer >
CThePEG::ClassDescription< ThePEG::ConstituentParticleData >
CThePEG::ClassDescription< ThePEG::Cuts >
CThePEG::ClassDescription< ThePEG::DalitzDecayer >
CThePEG::ClassDescription< ThePEG::DecayHandler >
CThePEG::ClassDescription< ThePEG::DecayMode >
CThePEG::ClassDescription< ThePEG::DeltaMeasureCuts >
CThePEG::ClassDescription< ThePEG::Event >
CThePEG::ClassDescription< ThePEG::EventGenerator >
CThePEG::ClassDescription< ThePEG::EventHandler >
CThePEG::ClassDescription< ThePEG::FuzzyTheta >
CThePEG::ClassDescription< ThePEG::GaussianPtGenerator >
CThePEG::ClassDescription< ThePEG::GraphvizPlot >
CThePEG::ClassDescription< ThePEG::HIHepMCFile >
CThePEG::ClassDescription< ThePEG::HepMC3File >
CThePEG::ClassDescription< ThePEG::HepMCFile >
CThePEG::ClassDescription< ThePEG::Hint >
CThePEG::ClassDescription< ThePEG::JetCuts >
CThePEG::ClassDescription< ThePEG::KTClus >
CThePEG::ClassDescription< ThePEG::KTRapidityCut >
CThePEG::ClassDescription< ThePEG::LWHFactory >
CThePEG::ClassDescription< ThePEG::LesHouchesEventHandler >
CThePEG::ClassDescription< ThePEG::LesHouchesFileReader >
CThePEG::ClassDescription< ThePEG::LuminosityFunction >
CThePEG::ClassDescription< ThePEG::MECuts >
CThePEG::ClassDescription< ThePEG::MENCDIS >
CThePEG::ClassDescription< ThePEG::MEee2gZ2qq >
CThePEG::ClassDescription< ThePEG::MadGraphOneCut >
CThePEG::ClassDescription< ThePEG::MadGraphReader >
CThePEG::ClassDescription< ThePEG::MadGraphTwoCut >
CThePEG::ClassDescription< ThePEG::MixedParticleData >
CThePEG::ClassDescription< ThePEG::MultiColour >
CThePEG::ClassDescription< ThePEG::MultiEventGenerator >
CThePEG::ClassDescription< ThePEG::NJetsCut >
CThePEG::ClassDescription< ThePEG::NLORivetAnalysis >
CThePEG::ClassDescription< ThePEG::O1AlphaS >
CThePEG::ClassDescription< ThePEG::OmegaPhi3PiDecayer >
CThePEG::ClassDescription< ThePEG::OneJetCut >
CThePEG::ClassDescription< ThePEG::Onium3GDecayer >
CThePEG::ClassDescription< ThePEG::Particle >
CThePEG::ClassDescription< ThePEG::ParticleData >
CThePEG::ClassDescription< ThePEG::PartonBin >
CThePEG::ClassDescription< ThePEG::PartonBinInstance >
CThePEG::ClassDescription< ThePEG::PartonExtractor >
CThePEG::ClassDescription< ThePEG::PolarizedBeamParticleData >
CThePEG::ClassDescription< ThePEG::ProgressLog >
CThePEG::ClassDescription< ThePEG::QuarksToHadronsDecayer >
CThePEG::ClassDescription< ThePEG::RandomGenerator >
CThePEG::ClassDescription< ThePEG::RemnantData >
CThePEG::ClassDescription< ThePEG::RemnantParticle >
CThePEG::ClassDescription< ThePEG::ReweightConstant >
CThePEG::ClassDescription< ThePEG::ReweightMinPT >
CThePEG::ClassDescription< ThePEG::RivetAnalysis >
CThePEG::ClassDescription< ThePEG::SimpleBaryonRemnantDecayer >
CThePEG::ClassDescription< ThePEG::SimpleDISCut >
CThePEG::ClassDescription< ThePEG::SimpleFlavour >
CThePEG::ClassDescription< ThePEG::SimpleKTCut >
CThePEG::ClassDescription< ThePEG::SimpleZGenerator >
CThePEG::ClassDescription< ThePEG::SoftRemnantHandler >
CThePEG::ClassDescription< ThePEG::StandardCKM >
CThePEG::ClassDescription< ThePEG::StandardEventHandler >
CThePEG::ClassDescription< ThePEG::StandardModelBase >
CThePEG::ClassDescription< ThePEG::StandardRandom >
CThePEG::ClassDescription< ThePEG::StandardXComb >
CThePEG::ClassDescription< ThePEG::StdXCombGroup >
CThePEG::ClassDescription< ThePEG::Step >
CThePEG::ClassDescription< ThePEG::Strategy >
CThePEG::ClassDescription< ThePEG::SubProcess >
CThePEG::ClassDescription< ThePEG::SubProcessGroup >
CThePEG::ClassDescription< ThePEG::SubProcessHandler >
CThePEG::ClassDescription< ThePEG::Tau2HadronsDecayer >
CThePEG::ClassDescription< ThePEG::Tree2toNDiagram >
CThePEG::ClassDescription< ThePEG::UnResolvedRemnant >
CThePEG::ClassDescription< ThePEG::V2LeptonsCut >
CThePEG::ClassDescription< ThePEG::V2PPDecayer >
CThePEG::ClassDescription< ThePEG::WeakToHadronsDecayer >
CThePEG::ClassDescription< ThePEG::WeizsackerWilliamsPDF >
CThePEG::ClassDescription< ThePEG::XComb >
CThePEG::ClassDescription< ThePEG::XSecCheck >
CThePEG::NoPIOClassDescription< ThePEG::BreitWignerMass >
CThePEG::NoPIOClassDescription< ThePEG::DummyDecayer >
CThePEG::NoPIOClassDescription< ThePEG::EventInfoBase >
CThePEG::NoPIOClassDescription< ThePEG::FixedCMSLuminosity >
CThePEG::NoPIOClassDescription< ThePEG::FlatDecayer >
CThePEG::NoPIOClassDescription< ThePEG::GRV94L >
CThePEG::NoPIOClassDescription< ThePEG::GRV94M >
CThePEG::NoPIOClassDescription< ThePEG::LeptonLeptonPDF >
CThePEG::NoPIOClassDescription< ThePEG::MEGG2GG >
CThePEG::NoPIOClassDescription< ThePEG::MEGG2QQ >
CThePEG::NoPIOClassDescription< ThePEG::MEQG2QG >
CThePEG::NoPIOClassDescription< ThePEG::MEQQ2GG >
CThePEG::NoPIOClassDescription< ThePEG::MEQQ2QQ >
CThePEG::NoPIOClassDescription< ThePEG::MEQQ2qq >
CThePEG::NoPIOClassDescription< ThePEG::MEQq2Qq >
CThePEG::NoPIOClassDescription< ThePEG::MEqq2qq >
CThePEG::NoPIOClassDescription< ThePEG::Matcher< T > >
CThePEG::NoPIOClassDescription< ThePEG::NoPDF >
CThePEG::NoPIOClassDescription< ThePEG::NoRemnants >
CThePEG::NoPIOClassDescription< ThePEG::SimpleAlphaEM >
CThePEG::NoPIOClassDescription< ThePEG::SpinInfo >
CThePEG::NoPIOClassDescription< ThePEG::TestLHAPDF >
CThePEG::NoPIOClassDescription< ThePEG::ThePEGStrategy >
CThePEG::AbstractClassDescription< T >	A concreate implementation of ClassDescriptionBase describing an abstract class with persistent data
CThePEG::AbstractNoPIOClassDescription< T >	A concreate implementation of ClassDescriptionBase describing an abstract class without persistent data
CThePEG::ClassDescription< T >	A concreate implementation of ClassDescriptionBase describing a concrete class with persistent data
CThePEG::NoPIOClassDescription< T >	A concreate implementation of ClassDescriptionBase describing a concrete class without persistent data
►CThePEG::DescribeClassT< T, BaseT, Abstract, NoPIO >	DescribeClassT and its derived companion classes DescribeClass DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to the type information system in ThePEG
CThePEG::DescribeAbstractClass< T, BaseT >	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CThePEG::DescribeAbstractNoPIOClass< T, BaseT >	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CThePEG::DescribeClass< T, BaseT, Abstract, NoPIO >	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CThePEG::DescribeNoPIOClass< T, BaseT >	DescribeClass and its companion classes DescribeAbstractClass, DescribeNoPIOClass and DescribeAbstractNoPIOClass, is a simplified interface to type information system in ThePEG
CThePEG::Event	All Particles produced in the generation of an event
CThePEG::InputDescription	InputDescription objects are used by the PersistentIStream class to keep track of all classes it has read from a stream
►CThePEG::InterfaceBase	Defines a generic interface to any class derived from the InterfacedBase class
►CThePEG::CommandBase	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
CThePEG::Command< T >	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
►CThePEG::DeletedBase	The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase
CThePEG::Deleted< T >	The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase
►CThePEG::ParMapBase	The ParMap and its base classes ParMapTBase and ParMapBase defines an interface to a class derived from the InterfacedBase, through which maps (or any other container) of simple member variables can be manuipulated
►CThePEG::ParMapTBase< Type >	The ParMap and its base classes ParMapTBase and ParMapBase defines an interface to a class derived from the InterfacedBase, through which maps (or any other container) of simple member variables can be manuipulated
CThePEG::ParMap< T, Type >	The ParMap and its base classes ParMapTBase and ParMapBase defines an interface to a class derived from the InterfacedBase, through which maps (or any other container) of simple member variables can be manuipulated
►CThePEG::ParVectorBase	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
►CThePEG::ParVectorTBase< Type >	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
CThePEG::ParVector< T, Type >	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
►CThePEG::ParameterBase	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
►CThePEG::ParameterTBase< Type >	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
CThePEG::Parameter< T, Type >	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
►CThePEG::ParameterTBase< string >	This is a specialization of ParameterTBase for the string case
CThePEG::Parameter< T, string >	This is a partial specialization of Parameter for the string case
►CThePEG::RefInterfaceBase	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
►CThePEG::RefVectorBase	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
CThePEG::RefVector< T, R >	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
►CThePEG::ReferenceBase	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
CThePEG::Reference< T, R >	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
►CThePEG::SwitchBase	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)
CThePEG::Switch< T, Int >	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)
►CThePEG::InterfacedBase	InterfacedBase is the base class of all Interfaced objects to be handled by the BaseRepository class
►CThePEG::Interfaced	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
►CThePEG::HandlerBaseT< UseRandom >
►CThePEG::HandlerBase	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
CThePEG::Amplitude	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
►CThePEG::AnalysisHandler	The AnalysisHandler is the base class of all analysis objects which may be handled by the FullEventGenerator
CThePEG::GraphvizPlot	Generates an output of the tree structure of the event which can be viewed using dot
CThePEG::HIHepMCFile	Outputs ThePEG events in HepMC format with additional Heavy Ion information
CThePEG::HepMC3File	Outputs ThePEG events in HepMC format
CThePEG::HepMCFile	Outputs ThePEG events in HepMC format
CThePEG::NLOHepMC3File	Write hard sub processes or sub process groups to HepMC
CThePEG::NLOHepMCFile	Write hard sub processes or sub process groups to HepMC
CThePEG::NLORivetAnalysis	Here is the documentation of the NLORivetAnalysis class
CThePEG::ProgressLog	Will not perform an actual analysis
CThePEG::RivetAnalysis	Here is the documentation of the RivetAnalysis class
CThePEG::XSecCheck	Simple analysis class used for testing purposes
►CThePEG::Decayer	Decayer is an abstract base class to specify objects modelling the decay of a particle
CThePEG::DalitzDecayer	The DalitzDecayer inherits from the Decayer class and performs Dalitz decays into \(\gamma e^+ e^-\)
CThePEG::DummyDecayer	DummyDecayer inherits from Decayer and is a dummy decayer class to be used for symbolic decay channels
►CThePEG::FlatDecayer	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
CThePEG::ColourPairDecayer	ColourPairDecayer inherits from the FlatDecayer class and performs decays according to phase space into two or more particles, some of which may be coloured
CThePEG::OmegaPhi3PiDecayer	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\)
CThePEG::Onium3GDecayer	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
CThePEG::Tau2HadronsDecayer	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)\)
CThePEG::V2PPDecayer	Performs the decay of a vector meson into two pseudo-scalars according to a flat phase space
►CThePEG::QuarksToHadronsDecayer	Inherits from Decayer and is able to decay particles to \(n_q\) (2 or 4) quarks which then are decayed to hadrons according to phase space
CThePEG::WeakToHadronsDecayer	Inherits from QuarksToHadronsDecayer and can performs weak decays of taus and charmed and bottom hadrons
►CThePEG::RemnantDecayer	Base class to be used for all decayers capable of decaying a RemnantParticle object produced by a SoftRemnantHandler object
CThePEG::SimpleBaryonRemnantDecayer	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
CThePEG::EventHandler	The EventHandler is the base class used to implement event handlers in ThePEG
►CThePEG::FlavourGenerator	FlavourGenerator is an abstract base class to be used to implement models describing the quark content of hadrons
CThePEG::SimpleFlavour	SimpleFlavour is a simple class to generate hadrons given the quark flavours
CThePEG::JetPairRegion	JetPairRegion implements constraints on jets matching two jet regions
CThePEG::JetRegion	JetRegion implements the requirement of finding a jet inside a given range of transverse momenta, and (pseudo-)rapidity
CThePEG::LesHouchesReader	LesHouchesReader is an abstract base class to be used for objects which reads event files or streams from matrix element generators
CThePEG::LuminosityFunction	The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment
CThePEG::MEBase	Base class of all objects representing hard matrix elements in ThePEG
CThePEG::MultiJetRegion	MultiJetRegion implements pairwise constraints on jets matching several jet regions
►CThePEG::PDFBase	PDFBase is the base class for implementing parton density functions for particles with sub-structure
CThePEG::BudnevPDF	Implements the PDF for the radiation of a photon from the proton
►CThePEG::GRVBase	GRVBase inherits from PDFBase and is used as a base class for all GRV parton densities
CThePEG::GRV94L	GRV94L inherits from PDFBase via the GRVBase class and implements the GRV94L parton densities for (anti) protons and neutrons
CThePEG::GRV94M	GRV94M iherits from PDFBase via the GRVBase class and implements the GRV94M parton densities for (anti) protons ad neutrons
CThePEG::LHAPDF	Inherits from PDFBase and implements an interface to the LHAPDF library of parton density function parameterizations
CThePEG::LeptonLeptonPDF	LeptonLeptonPDF inherits from PDFBase and encodes the distribution of leptons within leptons, ie
CThePEG::NoPDF	NoPDF inherits from PDFBase and represents particles without sub-structure
CThePEG::NuclearPhotonPDF	Implements the PDF for the radiation of a photon from a heavy ion
CThePEG::WeizsackerWilliamsPDF	Here is the documentation of the WeizsackerWilliamsPDF class
CThePEG::PartonExtractor	The PartonExtractor is a base class defining the interface to objects responsible for extracting partons from particles
►CThePEG::PtGenerator	PtGenerator is the base for all classes implementing alternative models for transverse momentum generation
CThePEG::GaussianPtGenerator	GaussianPtGenerator inherits from the abstract PtGenerator class
►CThePEG::RemnantHandler	RemnantHandler is an abstract base class for implementing classes used to generate remnants when partons are extracted from particles
CThePEG::NoRemnants	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
CThePEG::SoftRemnantHandler	SoftRemnantHandler inherits from the RemnantHandler and implements the generation of a single collinear RemnantParticle when anything is extracted from anything else
CThePEG::UnResolvedRemnant	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
CThePEG::ReweightBase	Base class of all objects representing external biases to matrix elements
►CThePEG::StepHandler	StepHandler is the base class for implementing any model for a step in the event generation chain
CThePEG::CascadeHandler	The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade models
CThePEG::ClusterCollapser	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
CThePEG::DecayHandler	The DecayHandler is the base class of all handlers implementing the administration of decays of unstable particles
CThePEG::HadronizationHandler	The HadronizationHandler is the base class of all handlers implementing models for hadronization of coloured particles
CThePEG::MultipleInteractionHandler	The MultipleInteractionHandler is the base class of all handlers implementing models for multiple interactions
CThePEG::SubProcessHandler	Used to handle a set of MEBase objects together with a PartonExtractor
►CThePEG::ZGenerator	ZGenerator is the base class for all classes implementing models to generate the momentum fraction, \(z\), taken by hadrons produced in a hadronization scenario
CThePEG::SimpleZGenerator	SimpleZGenerator is a very simple concrete subclass of ZGenerator
►CThePEG::CKMBase	CKMBase is an abstract base classused by the StandardModelBase to implement the Cabibbo-Kobayashi-Mascawa mixing matrix
CThePEG::StandardCKM	StandardCKM inherits from CKMBase and implements the standard parameterization of the CKM matrix in terms of three angles and a phase
CThePEG::Cuts	Cuts is a class for implementing kinematical cuts in ThePEG
CThePEG::DecayMode	Describes a decay channel of a particle
►CThePEG::EventGenerator	Manages a whole event generator run
CThePEG::MultiEventGenerator	Derived from the EventGenerator class and is capable of making several runs with a pre-defined set of parameter and switch values
CThePEG::EventManipulator	An object of the EventManipulator class may be assigned to a FullEventGenerator object
►CThePEG::FactoryBase	Here is the documentation of the FactoryBase class
CThePEG::LWHFactory	Here is the documentation of the LWHFactory class
CThePEG::FuzzyTheta	FuzzyTheta implements fuzzy cut prescriptions
CThePEG::HandlerBaseT< T >	HandlerBaseT is a dummy abstract templated class used as base class to HandlerBase
►CThePEG::Helicity::VertexBase	Base class for all helicity amplitude vertices
CThePEG::Helicity::AbstractFFFFVertex	Base class for all 4-fermion vertices in ThePEG
CThePEG::Helicity::AbstractFFSSVertex	Here is the documentation of the AbstractFFSSVertex class
CThePEG::Helicity::AbstractFFSTVertex	Base class for all fermion-fermion-scalar-tensor interactions in ThePEG
►CThePEG::Helicity::AbstractFFSVertex	Base class for all fermion-fermion-scalar vertices in ThePEG
CThePEG::Helicity::FFSVertex	Implementation of the interact of a scalar boson and a fermion-antifermion pair
►CThePEG::Helicity::AbstractFFTVertex	Base class for all fermion-fermion-tensor interactions in ThePEG
CThePEG::Helicity::FFTVertex	Implementation of the fermion-fermion-tensor vertex
CThePEG::Helicity::AbstractFFVSVertex	Here is the documentation of the AbstractFFVSVertex class
►CThePEG::Helicity::AbstractFFVTVertex	Base class for all fermion-fermion-vector-tensor interactions in ThePEG
CThePEG::Helicity::FFVTVertex	Implementation of the fermion-fermion–vector-tensor vertex
CThePEG::Helicity::AbstractFFVVVertex	Base class for all fermion-fermion-vector-vector vertices in ThePEG
►CThePEG::Helicity::AbstractFFVVertex	Base class for all fermion-fermion-vector vertices in ThePEG
CThePEG::Helicity::FFVVertex	Base class for all helicity amplitude vertices which use the renormalisable form for the fermion-fermion-vector vertex
CThePEG::Helicity::GeneralFFVVertex	Base class for all helicity amplitude vertices which use a general form of the fermion-fermion-vector vertex
CThePEG::Helicity::AbstractRFSSVertex	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-scalar-scalar vertices in ThePEG
►CThePEG::Helicity::AbstractRFSVertex	Base class for all spin-3/2 fermion-fermion-scalar vertices in ThePEG
CThePEG::Helicity::RFSVertex	Implementation of the interact of a scalar boson and a spin-3/2 fermion-antifermion pair
CThePEG::Helicity::AbstractRFVSVertex	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-vector-scalar vertices in ThePEG
CThePEG::Helicity::AbstractRFVVVertex	The AbstractRFSVertex class provides a base class for all spin-3/2 fermion-fermion-vector-vector vertices in ThePEG
►CThePEG::Helicity::AbstractRFVVertex	Base class for all spin-3/2 fermion-fermion-vector vertices in ThePEG
CThePEG::Helicity::RFVVertex	Base class for all helicity amplitude vertices which use the renormalisable form for the spin-3/2 fermion-fermion-vector vertex
►CThePEG::Helicity::AbstractSSSSVertex	Base class for all scalar-scalar-scalar interactions in ThePEG
CThePEG::Helicity::SSSSVertex	Implementation of the interaction of four scalars
CThePEG::Helicity::AbstractSSSTVertex	Base class for all scalar-scalar-scalar-tensor interactions in ThePEG
►CThePEG::Helicity::AbstractSSSVertex	Base class for all scalar-scalar-scalar interactions in ThePEG
CThePEG::Helicity::SSSVertex	Implementation of the interaction of three scalars
►CThePEG::Helicity::AbstractSSTVertex	Base class for scalar-scalar-tensor interactions in ThePEG
CThePEG::Helicity::SSTVertex	The VVTVertexclass is the implementation of the scalar-scalar-tensor vertex
►CThePEG::Helicity::AbstractVSSVertex	Base class for vector-scalar-scalar interactions in ThePEG
►CThePEG::Helicity::GeneralVSSVertex	Here is the documentation of the GeneralVSSVertex class
CThePEG::Helicity::VSSVertex	Implementation of the vector-scalar-scalar vertex
►CThePEG::Helicity::AbstractVVSSVertex	Base class for vector-vector-scalar-scalar interactions in ThePEG
CThePEG::Helicity::VVSSVertex	Implementation of the coupling of two vectors and two scalars
CThePEG::Helicity::AbstractVVSTVertex	Base class for all vector-vector-scalar-tensor interactions in ThePEG
►CThePEG::Helicity::AbstractVVSVertex	Here is the documentation of the AbstractVVSVertex class
CThePEG::Helicity::GeneralVVSVertex	Implements a general Vector-Vector-Scalar vertex allowing for decay modes that only enter at the one-loop level
CThePEG::Helicity::VVSVertex	Implementation of the vector-vector-scalar
►CThePEG::Helicity::AbstractVVTVertex	Here is the documentation of the AbstractVVTVertex class
CThePEG::Helicity::VVTVertex	Implementation of the vector-vector-tensor vertex
►CThePEG::Helicity::AbstractVVVSVertex	Base class for all vector-vector-vector interactions in ThePEG
CThePEG::Helicity::VVVSVertex	Base class for triple vector scalar vertices
►CThePEG::Helicity::AbstractVVVTVertex	Base class for all vector-vector-vector-tensor interactions in ThePEG
CThePEG::Helicity::VVVTVertex	The VVTVertex class is the implementation of the vector-vector-vector-tensor vertex
►CThePEG::Helicity::AbstractVVVVVertex	Base class for vector-vector-vector-vector interactions in ThePEG
CThePEG::Helicity::VVVVVertex	This is the implementation of the four vector vertex
►CThePEG::Helicity::AbstractVVVVertex	Base class for all vector-vector-vector interactions in ThePEG
CThePEG::Helicity::VVVVertex	Base class for triple vector vertices using the perturbative form
►CThePEG::JetFinder	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
CThePEG::FastJetFinder	FastJetFinder implements the class of longitudinally invariant kt jet clustering algorithms
CThePEG::MECuts	(currently not at all) used to make cuts on generated phase space points for the hard interaction
►CThePEG::MassGenerator	MassGenerator is an abstract base class used by the ParticleData class to generate a mass for a Particle instance
CThePEG::BreitWignerMass	BreitWignerMass is derived from MassGenerator and is able to generate the mass for a particle given its nominal mass and its with
►CThePEG::MatcherBase	MatcherBase is an abstract base class to be used for objects representing groups of ParticleData objects
CThePEG::Matcher< T >	Matcher is a templated class inheriting from MatcherBase
►CThePEG::MultiCutBase	This class corresponds to a kinematical cut to be made on a set of outgoing particles from a hard sub-process
CThePEG::JetCuts	JetCuts combines various JetRegion and JetPairRegion objects into a cut object
CThePEG::NJetsCut	NJetsCut is a simple cut on jet multiplicity
CThePEG::OneJetCut	OneJetsCut is a simple one-jet inclusive cut, requiring at least one jet above a certain pt in a given rapidity interval
CThePEG::V2LeptonsCut	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
►CThePEG::NucleonFormFactor	The documentation of the NucleonFormFactor class provides a base class for the implementation of nucleon form factors, for use in the calculation of exclusive processes
CThePEG::DipoleFormFactor	Here is the documentation of the DipoleFormFactor class
CThePEG::HardSphereYukawaFormFactor	Implements a form factor model using a hard space + yukawaw interaction
►CThePEG::OneCutBase	This class corresponds to a kinematical cut to be made on a single outgoing parton from a hard sub-process
CThePEG::KTRapidityCut	Simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle
CThePEG::MadGraphOneCut	Objects of the MadGraphOneCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts
CThePEG::SimpleKTCut	This is a very simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle
►CThePEG::ParticleData	ParticleData inherits from InterfacedBase and represents the properties of a particle type
►CThePEG::BeamParticleData	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
CThePEG::PolarizedBeamParticleData	PolarizedBeamParticleData inherits from the BeamParticleData class and is used for polarized beam particles
CThePEG::ConstituentParticleData	ConstituentParticleData inherits from the ParticleData class and is used for quarks, diquarks and gluons to store information about their constituent mass
CThePEG::MixedParticleData	Designed to store the particle data for particles which undergo mixing with their anti-particle, e.g
CThePEG::RemnantData	Not a normal ParticleData class
►CThePEG::RandomGenerator	RandomGenerator is an interface to the CLHEP::RandomEngine classes
CThePEG::StandardRandom	StandardRandom inherits from the RandomGenerator class and is an interface to the CLHEP::JamesRandom engine class
►CThePEG::RunningCoupling	RunningCoupling an abstract base class unifying the treatment of running couplings in ThePEG
►CThePEG::AlphaEMBase	AlphaEMBase an abstract base class used by the StandardModelBase class to implement the electro-magnetic coupling
CThePEG::SimpleAlphaEM	SimpleAlphaEM inherits from AlphaEMBase and implements a simple running of the electromagnetic coupling as parameterized by H
►CThePEG::AlphaSBase	AlphaSBase is an abstract base class used by the StandardModelBase to implement the QCD coupling, \(\alpha_S\)
CThePEG::O1AlphaS	O1AlphaS inherits from AlphaSBase and implements the leading order running QCD coupling
►CThePEG::SamplerBase	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
CThePEG::ACDCSampler	This class inherits from SampleBase and implements the Auto Compensating Divide-and-Conquer phase space generator, ACDCGen
CThePEG::StandardModelBase	StandardModelBase is used to handle standard model parameters in an EventGenerator
►CThePEG::Strategy	General strategy to be assigned to an EventGenerator
CThePEG::ThePEGStrategy	Sub-class of the Strategy class, simply implementing the correct citation for ThePEG in the ClassDocumentation interface
►CThePEG::TwoCutBase	This class corresponds to a kinematical cut to be made on a pair of particles in a hard sub-process
CThePEG::DeltaMeasureCuts	This class implements a cuts on legoplot and rapidity separation
CThePEG::KTClus	This clas implements the cuts relevant for the \(\Delta R\)-measure in the longitudinally invariant kt-algorithm
CThePEG::MadGraphTwoCut	Objects of the MadGraphTwoCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts
CThePEG::SimpleDISCut	SimpleDISCut inherits from TwoCutBase and omplements a simple \(Q^2\) cut on the a scattered lepton, either neutral or charged current
CThePEG::WidthGenerator	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
CThePEG::SwitchOption	SwitchOption is used by the Switch class and its base class SwitchBase to define valid options in a switch
CThePEG::ObjectIndexer< IntT, ObjT, NoIndex >	This is a templated class which dynamically associates (reference counted) objects to integer indices
CThePEG::ObjectIndexer< long, ThePEG::ColourLine >
CThePEG::ObjectIndexer< long, ThePEG::Particle >
CThePEG::OEnum< T >	The OEnum helper class is used to facilitate output of enums to persistent streams
CThePEG::LesHouchesEventHandler::OptWeight	Collect statistics for this event handler's optional weights
CThePEG::OUnit< T, UT >	The OUnit< class is used to facilitate output of unitful numbers to a persistent stream
CThePEG::OUnitErr< T, UT >	OUnitErr is used to write out unitful numbers with an error estimate on a standard ostream
►Cstd::pair
CThePEG::IteratorRange< Iterator >	A pair of iterators to be used in specialized algorithms instead of the standard first, last construction
CThePEG::Particle::ParticleRep	This class is used internally in the Particle class to represent information besides momentum and type
CThePEG::PDF	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
CThePEG::PDFCuts	Used to specify cuts on scale and momentum fractions for which a PDFBase object is expected to give parton densities
CThePEG::PDT	PDT is a helper class implementing enumerations for charge, colour and spin to be used by the ParticleData class
CThePEG::PersistentIStream	PersistentIStream is used to read persistent objects from a stream where they were previously written using PersistentOStream
CThePEG::PersistentOStream	PersistentOStream is used to write objects persistently to a stream from which they can be read in again with a PersistentIStream
CThePEG::PID	PID is a helper class implementing the type of PDG particle ids
CThePEG::CutTypes::Polar	Identify an polar-angle-type cut
CThePEG::Math::Power< 0, false >	Struct for powers
CThePEG::Math::Power< 0, true >	Struct for powers
CThePEG::Math::Power< N, false >	Struct for powers
CThePEG::Math::Power< N, true >	Struct for powers
CThePEG::Pointer::Ptr< T >	Ptr is a templated class to provide typedefs for pointers types ThePEG should use for a given type
CThePEG::Pointer::Ptr< AlphaEMBase >
CThePEG::Pointer::Ptr< AlphaSBase >
CThePEG::Pointer::Ptr< CascadeHandler >
CThePEG::Pointer::Ptr< CKMBase >
CThePEG::Pointer::Ptr< Collision >
CThePEG::Pointer::Ptr< ColourBase >
CThePEG::Pointer::Ptr< ColourLine >
CThePEG::Pointer::Ptr< Decayer >
CThePEG::Pointer::Ptr< DecayMode >
CThePEG::Pointer::Ptr< Event >
CThePEG::Pointer::Ptr< EventGenerator >
CThePEG::Pointer::Ptr< EventHandler >
CThePEG::Pointer::Ptr< EventManipulator >
CThePEG::Pointer::Ptr< EventRecordBase >
CThePEG::Pointer::Ptr< FlavourGenerator >
CThePEG::Pointer::Ptr< HDLR >
CThePEG::Pointer::Ptr< LuminosityFunction >
CThePEG::Pointer::Ptr< MatcherBase >
CThePEG::Pointer::Ptr< Particle >
CThePEG::Pointer::Ptr< ParticleData >
CThePEG::Pointer::Ptr< ParticleDataClass >
CThePEG::Pointer::Ptr< PartonBinInstance >
CThePEG::Pointer::Ptr< PartonExtractor >
CThePEG::Pointer::Ptr< PDFBase >
CThePEG::Pointer::Ptr< PtGenerator >
CThePEG::Pointer::Ptr< RandomGenerator >
CThePEG::Pointer::Ptr< RemInfoBase >
CThePEG::Pointer::Ptr< RemnantHandler >
CThePEG::Pointer::Ptr< SpinInfo >
CThePEG::Pointer::Ptr< StandardModelBase >
CThePEG::Pointer::Ptr< StandardXComb >
CThePEG::Pointer::Ptr< Step >
CThePEG::Pointer::Ptr< StepHandler >
CThePEG::Pointer::Ptr< Strategy >
CThePEG::Pointer::Ptr< SubProcess >
CThePEG::Pointer::Ptr< ThePEG::Amplitude >
CThePEG::Pointer::Ptr< ThePEG::CascadeHandler >
CThePEG::Pointer::Ptr< ThePEG::DecayHandler >
CThePEG::Pointer::Ptr< ThePEG::FuzzyTheta >
CThePEG::Pointer::Ptr< ThePEG::HadronizationHandler >
CThePEG::Pointer::Ptr< ThePEG::JetFinder >
CThePEG::Pointer::Ptr< ThePEG::JetPairRegion >
CThePEG::Pointer::Ptr< ThePEG::JetRegion >
CThePEG::Pointer::Ptr< ThePEG::MatcherBase >
CThePEG::Pointer::Ptr< ThePEG::MultiJetRegion >
CThePEG::Pointer::Ptr< ThePEG::MultipleInteractionHandler >
CThePEG::Pointer::Ptr< ThePEG::SubProcessHandler >
CThePEG::Pointer::Ptr< XComb >
CThePEG::Pointer::Ptr< ZGenerator >
►CThePEG::Pointer::PtrTraitsType	PtrTraitsType is an empty non-polymorphic base class for all PtrTraits classes
CThePEG::Pointer::PtrTraits< T >	The PtrTraits class is used everywhere in ThePEG to interface to the pointers which are handled
CThePEG::Pointer::PtrTraits< ConstRCPtr< T > >	Specialization of the PtrTraits class for ConstRCPtr
CThePEG::Pointer::PtrTraits< RCPtr< T > >	Specialization of the PtrTraits class for RCPtr
CThePEG::Pointer::PtrTraits< T * >	Specialization of the PtrTraits class for standard bare pointers
CThePEG::Pointer::PtrTraits< TransientConstRCPtr< T > >	Specialization of the PtrTraits class for TransientConstRCPtr
CThePEG::Pointer::PtrTraits< TransientRCPtr< T > >	Specialization of the PtrTraits class for TransientRCPtr
CThePEG::Pointer::PtrTraits< const T * >	Specialization of the PtrTraits class for standard bare const pointers
CThePEG::Qty< L, E, T >	This template class allows the compiler to check calculations with physical quantities for dimensional correctness
CThePEG::Qty< 0, -2, 0 >
CThePEG::Qty< 0, 1, 0 >
CThePEG::Qty< 0, 2, 0 >
CThePEG::Qty< 1, 0, 0 >
CThePEG::Qty< std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 > >	Specialization of Qty for <0,0,0> with conversions to double
CThePEG::Qty< std::ratio< L, DL >, std::ratio< E, DE >, std::ratio< Q, DQ > >
CThePEG::qty_equal< T, U >
CThePEG::qty_equal< Qty< L1, E1, Q1 >, Qty< L2, E2, Q2 > >
CThePEG::CutTypes::Rapidity	Identify a rapidity-type cut
►CThePEG::Pointer::RCPtrBase	RCPtrBase is the base class of RCPtr and ConstRCPtr which are reference counted (smart) pointers
CThePEG::Pointer::ConstRCPtr< T >	ConstRCPtr is a reference counted (smart) const pointer
CThePEG::Pointer::RCPtr< T >	RCPtr is a reference counted (smart) pointer
CThePEG::Rebinder< T >	Rebinder is a class associating pairs of pointers to objects
CThePEG::CurrentGenerator::Redirect	Class used to temporarily redirect a given ostream to the misc() stream of the current EventGenerator
►CThePEG::Pointer::ReferenceCounted	ReferenceCounted must be the (virtual) base class of all classes which may be pointed to by the RCPtr smart pointer class
►CThePEG::Base	Define the base class from which all (polymorphic) classes in ThePEG are derived
CThePEG::Collision	This is the decalaration of the Collision class
CThePEG::ColourLine	Colour lines connecting Particles
CThePEG::ColourLines	Defines the colour flow in a SubProcess
►CThePEG::DiagramBase	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
CThePEG::BlobDiagram	Inherits from DiagramBase and represents a general Feynman diagram of which no further substructure is assumed
CThePEG::Tree2toNDiagram	Inherits from DiagramBase and represents a Feynman tree diagram
CThePEG::Event	All Particles produced in the generation of an event
►CThePEG::EventInfoBase	EventInfoBase is a base class for information objects
►CThePEG::ColourBase	ColourBase is the base class to be used to supply a Particle with information about its colour state
CThePEG::MultiColour	This class is used to store colour information of RemnantParticle objects and other particle classes with complicated colour structures
CThePEG::HelicityVertex	Designed to store the helicity amplitude expression for the matrix element for use by the spin correlation algorithm
►CThePEG::SpinInfo	The SpinInfo is the base class for the spin information for the spin correlation algorithm
CThePEG::Helicity::FermionSpinInfo	Inherits from the SpinInfo class and implements the storage of the basis vectors for a spin-1/2 particle
CThePEG::Helicity::RSFermionSpinInfo	Inherits from the SpinInfo class and implements the storage of the basis vector for a spin-3/2 particle
CThePEG::Helicity::Rank3TensorSpinInfo	Implementation of the spin information for tensor particles
CThePEG::Helicity::ScalarSpinInfo	Designed to be the implementation of the spin information for a scalar particle
CThePEG::Helicity::TensorSpinInfo	Implementation of the spin information for tensor particles
CThePEG::Helicity::VectorSpinInfo	Implementation of the spin information for vector particles
CThePEG::Hint	Hint is a base class to be used to pass information between StepHandler s, which cannot be convayed through the Event record
CThePEG::InterfacedBase	InterfacedBase is the base class of all Interfaced objects to be handled by the BaseRepository class
►CThePEG::Main	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
CThePEG::TestLHAPDF	Class derived from Main to do simple tests of the LHAPDF class
►CThePEG::Particle	Used to describe an instance of a particle
CThePEG::RemnantParticle	Here is the documentation of the RemnantParticle class
CThePEG::PartonBin	Used by the PartonExtractor class to store information about the extraction of a parton from a particle
CThePEG::PartonBinInstance	PartonBinInstance is used to store information about the generation of a given parton extraction for a corresponding PartonBin object
CThePEG::RemInfoBase	Empty base class
CThePEG::Step	Information of all particles present after certain step in the event generation
►CThePEG::SubProcess	A SubProcess object represents a hard \(2\rightarrow n\) sub-process in a collision
CThePEG::SubProcessGroup	A SubProcessGroup object represents a group of SubProcess objects in dependence of a head SubProcess object
►CThePEG::XComb	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
►CThePEG::StandardXComb	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
CThePEG::StdXCombGroup	'head' XComb object in association with a group of dependent XComb objects
►CThePEG::AnyReference::ReferenceHolderBase
CThePEG::AnyReference::ReferenceHolder< T >
CThePEG::RhoDMatrix	Designed to implement the storage of the rho and D matrices which are required for the spin correlation algorithm
CThePEG::Selector< T, WeightType >	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
CThePEG::Selector< int, CrossSection >
CThePEG::Selector< T, double >
CThePEG::Selector< tDMPtr >
CThePEG::Selector< tStdXCombPtr >
►CThePEG::SelectorBase	Classes derived from the SelectorBase class are used to extract particles from an Event with Event::select() method
CThePEG::AllSelector	Used to extract all particles from an event
CThePEG::ChargedSelector	Used to extract all charged particles from an event
CThePEG::FinalStateSelector	Used to extract all final state particles from an event
CThePEG::IntermediateSelector	Used to extract only intermediate particles from an event
CThePEG::ParticleSelector< T >	The templated ParticleSelector class may be used to implement derived classes from the SelectorBase class
CThePEG::PrimaryCollisionSelector	Used to extract all particles from the primary Collision of an event
CThePEG::SelectIfBoth	Can be used to combine other selector objects
CThePEG::SelectIfEither	Can be used to combine other selector objects
CThePEG::SelectIfNot	The SelectIfNot classes can be used to negate the meaning of another SelectorBase object
CACDCGenerator::ACDCGen< Rnd, FncPtr >::Slicer	This is a help struct to perform the divide-and-conquer slicing of cells before starting the compensation procedure
CThePEG::SpinHalfLorentzRotation	Designed to offer the same features as the HepLorentzRotation class of CLHEP but for the spin- \(\frac12\) Lorentz transformation
CThePEG::SpinOneLorentzRotation	..
CThePEG::Stop	A standard exception class to be used to temporarily stop the generation of an event
CThePEG::StringUtils	Few static utility functions for basic strings
CThePEG::ThreeVector< Value >	A 3-component vector
CThePEG::Throw< Ex >	Helper function to make it easier to throw exceptions
CThePEG::TmpTransform< Ptr >	This is a wrapper class to be used to temporarily make a Lorentz transform of an object
►CThePEG::TraitsType	TraitsType is an empty, non-polymorphic, base class
►CThePEG::ClassTraitsType	ClassTraitsType is an empty, non-polymorphic, base class
►CThePEG::ClassTraitsBase< PDFBase >
CThePEG::ClassTraits< PDFBase >	This template specialization informs ThePEG about the name of * the PDFBase class and the shared object where it is defined
►CThePEG::ClassTraitsBase< double >
CThePEG::ClassTraits< double >	ClassTraits specialization for double
CThePEG::BaseClassTrait< Derived, BaseN >	BaseClassTraits describes the base classes of the templated class
CThePEG::BaseClassTrait< PDFBase, 1 >	This template specialization informs ThePEG about the * base classes of PDFBase
►CThePEG::ClassTraitsBase< T >	The templated ClassTraitsBase class defines a set of default information about classes used by ThePEG
CThePEG::ClassTraits< T >	The default concrete implementation of ClassTraitsBase
CThePEG::ParticleTraits< PType >	ParticleTraits is a templated class defining a general interface to any particle class
CThePEG::Transformer	A helper class to be used in std:: algorithms to transform a range of particles
CThePEG::Pointer::TransientConstRCPtr< T >	TransientConstRCPtr is a simple wrapper around a bare const pointer which can be assigned to and from an RCPtr and ConstRCPtr without problem
CThePEG::Pointer::TransientRCPtr< T >	TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr and ConstRCPtr without problem
CThePEG::Triplet< T1, T2, T3 >	The Triplet class represents a general triplet of objects completely analogous to std::pair
CThePEG::TypeInfo	TypeInfo is a simple wrapper around the ClassDescription system in ThePEG
CThePEG::TypeTraits< T >	Type traits for built-in types
CThePEG::TypeTraits< PDT::Charge >	Type traits for built-in types
CThePEG::TypeTraits< PDT::Colour >	Type traits for built-in types
CThePEG::TypeTraits< PDT::Spin >	Type traits for built-in types
CThePEG::InterfacedBase::UpdateChecker	Functor class to be used to update a range of dependent object
CThePEG::InterfacedBase::UpdateMapChecker	Functor class to be used to update a range of dependent object in a map
CThePEG::UseRandom	This UseRandom class keeps a static stack of RandomGenerator objects which can be used anywhere by any class
►CThePEG::UtilityBase	UtilityBase is a base class implementing a number of static utility functions
CThePEG::Utilities	Concrete class with UtilityBase as base class
CThePEG::HepMCConverter< HepMCEventT, Traits >::Vertex	Help class to represent a temporary vertex which can be converted to a GenVertex
CThePEG::Veto	A standard exception class to be used for vetoing a whole event
CThePEG::VSelector< T, WeightType >	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
CThePEG::VSelector< long >
CThePEG::VSelector< pair< int, int > >
CThePEG::VSelector< pair< long, long > >
►CThePEG::Helicity::WaveFunctionBase
CThePEG::Helicity::RSSpinorBarWaveFunction	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
CThePEG::Helicity::RSSpinorWaveFunction	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
CThePEG::Helicity::Rank3TensorWaveFunction
CThePEG::Helicity::ScalarWaveFunction
CThePEG::Helicity::SpinorBarWaveFunction
CThePEG::Helicity::SpinorWaveFunction
CThePEG::Helicity::TensorWaveFunction
CThePEG::Helicity::VectorWaveFunction
CThePEG::XSecStat	XSecStat is a concrete helper class used to collect statistics about the cross section for a specific process or group of processes
CThePEG::ZeroUnit	Helper class to construct zero unitful quantities
►Cpair
CThePEG::Transverse< Energy >
CThePEG::Transverse< Value >	Transverse represents the transverse components of a LorentzVector