| ThePEG::AbstractClassDescription< T > | A concreate implementation of ClassDescriptionBase describing an abstract class with persistent data |
| ThePEG::Helicity::AbstractFFSVertex | Base class for all fermion-fermion-scalar vertices in ThePEG |
| ThePEG::Helicity::AbstractFFTVertex | Base class for all fermion-fermion-tensor interactions in ThePEG |
| ThePEG::Helicity::AbstractFFVTVertex | Base class for all fermion-fermion-vector-tensor interactions in ThePEG |
| ThePEG::Helicity::AbstractFFVVertex | Base class for all fermion-fermion-vector vertices in ThePEG |
| ThePEG::AbstractNoPIOClassDescription< T > | A concreate implementation of ClassDescriptionBase describing an abstract class without persistent data |
| ThePEG::Helicity::AbstractSSSVertex | Base class for all scalar-scalar-scalar interactions in ThePEG |
| ThePEG::Helicity::AbstractSSTVertex | Base class for scalar-scalar-tensor interactions in ThePEG |
| ThePEG::Helicity::AbstractVSSVertex | Base class for vector-scalar-scalar interactions in ThePEG |
| ThePEG::Helicity::AbstractVVSSVertex | Base class for vector-vector-scalar-scalar interactions in ThePEG |
| ThePEG::Helicity::AbstractVVSVertex | Here is the documentation of the AbstractVVSVertex class |
| ThePEG::Helicity::AbstractVVTVertex | Here is the documentation of the AbstractVVTVertex class |
| ThePEG::Helicity::AbstractVVVTVertex | Base class for all vector-vector-vector-tensor interactions in ThePEG |
| ThePEG::Helicity::AbstractVVVVertex | Base class for all vector-vector-vector interactions in ThePEG |
| ThePEG::Helicity::AbstractVVVVVertex | Base class for vector-vector-vector-vector interactions in ThePEG |
| ACDCGenerator::ACDCFncTraits< FncPtr > | ACDCFncTraits defines the interface to functions to be sampled by ACDCGen |
| ACDCGenerator::ACDCGen< Rnd, FncPtr > | ACDCGen is a general class for sampling multi-dimensional functions |
| ACDCGenerator::ACDCGen< Rnd, FncPtr >::Level | A helper struct representing a level of compensation |
| ACDCGenerator::ACDCGen< Rnd, FncPtr >::Slicer | This is a help struct to perform the divide-and-conquer slicing of cells before starting the compensation procedure |
| ACDCGenerator::ACDCGenCell | ACDCGenCell is the class representing a generation cell in ACDCGen |
| ACDCGenerator::ACDCGenCellInfo | This is a class describing cells to the outside world to be used for debugging purposes |
| ACDCGenerator::ACDCRandomTraits< Rnd > | ACDCRandomTraits defines the interface to random number generator objects to be used by ACDCGen |
| ThePEG::ACDCSampler | This class inherits from SampleBase and implements the Auto Compensating Divide-and-Conquer phase space generator, ACDCGen |
| ACDCGenerator::ACDCTraitsType | ACDCTraitsType is an empty non-polymorphic base class for all traits classes in ACDCGenerator |
| ThePEG::AllSelector | Used to extract all particles from an event |
| ThePEG::AlphaEMBase | AlphaEMBase an abstract base class used by the StandardModelBase class to implement the electro-magnetic coupling |
| ThePEG::AlphaSBase | AlphaSBase is an abstract base class used by the StandardModelBase to implement the QCD coupling,  |
| ThePEG::Amplitude | Abstract base class for all the classes representing complex amplitudes associated with either a hard 2 N subprocess or a decay 1 N process |
| LWH::AnalysisFactory | The "master" factory from which other factories are obtained |
| ThePEG::AnalysisHandler | The AnalysisHandler is the base class of all analysis objects which may be handled by the FullEventGenerator |
| ThePEG::AnalysisHandler::NoHistFactory | Exception class used if no histogram factory was found |
| ThePEG::AndMatcher< T1, T2 > | The AndMatcher class represents the boolean and operation between its two template argument classes of base type MatcherBase |
| ThePEG::AnyMatcher | A Matcher class which matches any particle |
| LWH::Axis | An Axis represents a binned histogram axis |
| ThePEG::BaryonMatcher | A Matcher class which matches any baryon |
| ThePEG::Base | Define the base class from which all (polymorphic) classes in ThePEG are derived |
| ThePEG::BaseClassTrait< Derived, BaseN > | BaseClassTraits describes the base classes of the templated class |
| ThePEG::ThePEG::BaseClassTrait< PDFBase, 1 > | This template specialization informs ThePEG about the \ base classes of PDFBase |
| ThePEG::BaseRepository | BaseRepository is a purely static class which keeps a set of InterfacedBase objects indexed by their name |
| ThePEG::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 |
| ThePEG::ThePEG::BinaryOpTraits< double, Lorentz5Vector< U > > | Template for multiplication by scalar |
| ThePEG::ThePEG::BinaryOpTraits< Lorentz5Vector< T >, double > | Template for multiplication by scalar |
| ThePEG::ThePEG::BinaryOpTraits< Lorentz5Vector< T >, Lorentz5Vector< U > > | Template for multiplication of two Lorentz5Vectors |
| ThePEG::ThePEG::BinaryOpTraits< Lorentz5Vector< T >, LorentzVector< U > > | Template for multiplication for LorentzVector and Lorentz5Vector |
| ThePEG::ThePEG::BinaryOpTraits< Lorentz5Vector< T >, std::complex< U > > | Template for multiplication for complex and Lorentz5Vector |
| ThePEG::ThePEG::BinaryOpTraits< LorentzVector< T >, Lorentz5Vector< U > > | Template for multiplication for LorentzVector and Lorentz5Vector |
| ThePEG::ThePEG::BinaryOpTraits< LorentzVector< T >, U > | Template for multiplication by scalar |
| ThePEG::ThePEG::BinaryOpTraits< std::complex< T >, Lorentz5Vector< U > > | Template for multiplication by scalar |
| ThePEG::ThePEG::BinaryOpTraits< T, LorentzVector< U > > | Template for multiplication by scalar |
| ThePEG::BreitWignerMass | BreitWignerMass is derived from MassGenerator and is able to generate the mass for a particle given its nominal mass and its with |
| ThePEG::CascadeHandler | The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade models |
| ThePEG::CFileLineReader | CFileLineReader is a wrapper around a standard C FILE stream |
| ThePEG::ChargedMatcher | A Matcher class which matches any charged particle |
| ThePEG::ChargedSelector | Used to extract all charged particles from an event |
| ThePEG::CKMBase | CKMBase is an abstract base classused by the StandardModelBase to implement the Cabibbo-Kobayashi-Mascawa mixing matrix |
| ThePEG::ClassDescription< T > | A concreate implementation of ClassDescriptionBase describing a concrete class with persistent data |
| ThePEG::ClassDescriptionBase | ClassDescriptionBase is the base class for all class description classes |
| ThePEG::ClassDescriptionHelper< T, IBase, B > | A helper class for tracing the base classes of a class to be described |
| ThePEG::ClassDescriptionTBase< T > | An intermediate templated base class derived from ClassDescriptionBase |
| ThePEG::ClassDocumentation< T > | The ClassDocumentation class is used to communicate documetation about an Interfaced class to the Repository |
| ThePEG::ClassDocumentationBase | Used to communicate documetation about an Interfaced class to the Repository |
| ThePEG::ClassTraits< T > | The default concrete implementation of ClassTraitsBase |
| ThePEG::ThePEG::ClassTraits< PDFBase > | This template specialization informs ThePEG about the name of \ the PDFBase class and the shared object where it is defined |
| ThePEG::ClassTraitsBase< T > | The templated ClassTraitsBase class defines a set of default information about classes used by ThePEG |
| ThePEG::ClassTraitsType | ClassTraitsType is an empty, non-polymorphic, base class |
| ThePEG::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 |
| ThePEG::Collision | This is the decalaration of the Collision class |
| ThePEG::ColourBase | ColourBase is the base class to be used to supply a Particle with information about its colour state |
| ThePEG::ColourLine | Colour lines connecting Particles |
| ThePEG::ColourLines | Defines the colour flow in a SubProcess |
| ThePEG::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 |
| ThePEG::ColourSinglet | A ColourSinglet object represents a set of colour-connected partons in a total colour-singlet state |
| ThePEG::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 |
| ThePEG::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 |
| std::std::complex< ThePEG::Qty< 0, 0, 0, DL, DE, DQ > > | Template specialization for std::complex<Qty<0,0,0> > with conversions to complex<double> |
| ThePEG::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 |
| ThePEG::CompSelector< T, WeightType >::Level | Internal struct used for bookkeeping when compensating |
| ThePEG::ConstituentParticleData | ConstituentParticleData inherits from the ParticleData class and is used for quarks, diquarks and gluons to store information about their constituent mass |
| ThePEG::Pointer::ConstRCPtr< T > | ConstRCPtr is a reference counted (smart) const pointer |
| ThePEG::Current< T > | The Current class keeps a static stack of objects of the templated class, which can be used anywhere by any class |
| ThePEG::CurrentGenerator | This CurrentGenerator class keeps a static stack of EventGenerators which can be used anywhere by any class |
| ThePEG::CurrentGenerator::Redirect | Class used to temporarily redirect a given ostream to the misc() stream of the current EventGenerator |
| ThePEG::Cuts | Cuts is a class for implementing kinematical cuts in ThePEG |
| ThePEG::DalitzDecayer | The DalitzDecayer inherits from the Decayer class and performs Dalitz decays into  |
| LWH::DataPoint | An DataPoint represents a binned histogram axis |
| LWH::DataPointSet | An DataPointSet represents a binned histogram axis |
| LWH::DataPointSetFactory | Basic user-level interface for creating a factory of IDataPointSet |
| ThePEG::Debug | The Debug class defines a number of debug levels and a static public member giving the current debug level in a run |
| ThePEG::Decayer | Decayer is an abstract base class to specify objects modelling the decay of a particle |
| ThePEG::Decayer::DecayFailure | Exception class used if something goes wrong in DecayParticle() |
| ThePEG::DecayHandler | The DecayHandler is the base class of all handlers implementing the administration of decays of unstable particles |
| ThePEG::DecayMode | Describes a decay channel of a particle |
| ThePEG::Deleted< T > | The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase |
| ThePEG::DeletedBase | The DeletedBase and its templated Deleted sub-class defines an interface to a class derived from the InterfacedBase |
| ThePEG::DescriptionList | The DescriptionList keeps a static list of descriptions of classes included in the current run |
| ThePEG::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 |
| ThePEG::DiquarkMatcher | A Matcher class which matches any (anti-)diquark |
| ThePEG::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 |
| ThePEG::DIterator< BaseIterator > | DIterator is an iterator adaptor class |
| ThePEG::DummyDecayer | DummyDecayer inherits from Decayer and is a dummy decayer class to be used for symbolic decay channels |
| ThePEG::DummyType | Dummy type for ambiguous function signatures |
| ThePEG::DynamicLoader | DynamicLoader is the general interface to the dynamic loader functions of the underlying operating system |
| ThePEG::Event | All Particles produced in the generation of an event |
| ThePEG::EventConfig | A helper class to facilitate persistent input and output |
| ThePEG::EventGenerator | Manages a whole event generator run |
| ThePEG::EventHandler | The EventHandler is the base class used to implement event handlers in ThePEG |
| ThePEG::EventInfoBase | EventInfoBase is a base class for information objects |
| ThePEG::EventManipulator | An object of the EventManipulator class may be assigned to a FullEventGenerator object |
| ThePEG::Exception | Exception is the base class for all exceptions to be used in ThePEG |
| ThePEG::Math::Functions::ExpX | Class corresponding to functions of the form  |
| ThePEG::FactoryBase | Here is the documentation of the FactoryBase class |
| ThePEG::FactoryBase::DataFiller | DataFiller is a helper class to facilitate adding data to a DataPointSet |
| ThePEG::Helicity::FermionSpinInfo | Inherits from the SpinInfo class and implements the storage of the basis vectors for a spin-1/2 particle |
| ThePEG::Helicity::FFSVertex | Implementation of the interact of a scalar boson and a fermion-antifermion pair |
| ThePEG::Helicity::FFTVertex | Implementation of the fermion-fermion-tensor vertex |
| ThePEG::Helicity::FFVTVertex | Implementation of the fermion-fermion--vector-tensor vertex |
| ThePEG::Helicity::FFVVertex | Base class for all helicity amplitude vertices which use the renormalisable form for the fermion-fermion-vector vertex |
| ThePEG::FinalStateSelector | Used to extract all final state particles from an event |
| ThePEG::FixedCMSLuminosity | Describes an experiment with incoming particles colliding with precicely defined and opposite momenta |
| ThePEG::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 |
| ThePEG::FlavourGenerator | FlavourGenerator is an abstract base class to be used to implement models describing the quark content of hadrons |
| ThePEG::Math::Functions::FracPowX< N, D > | Class corresponding to functions of the form  with integer N and D |
| ThePEG::GaussianPtGenerator | GaussianPtGenerator inherits from the abstract PtGenerator class |
| ThePEG::Helicity::GeneralFFVVertex | Base class for all helicity amplitude vertices which use a general form of the fermion-fermion-vector vertex |
| ThePEG::Helicity::GeneralVVSVertex | Implements a general Vector-Vector-Scalar vertex allowing for decay modes that only enter at the one-loop level |
| ThePEG::GraphvizPlot | Generates an output of the tree structure of the event which can be viewed using dot |
| ThePEG::GRV94L | GRV94L inherits from PDFBase via the GRVBase class and implements the GRV94L parton densities for (anti) protons and neutrons |
| ThePEG::GRV94M | GRV94M iherits from PDFBase via the GRVBase class and implements the GRV94M parton densities for (anti) protons ad neutrons |
| ThePEG::GRVBase | GRVBase inherits from PDFBase and is used as a base class for all GRV parton densities |
| ThePEG::HadronizationHandler | The HadronizationHandler is the base class of all handlers implementing models for hadronization of coloured particles |
| ThePEG::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 |
| ThePEG::HandlerBaseT< T > | HandlerBaseT is a dummy abstract templated class used as base class to HandlerBase |
| ThePEG::HandlerGroup< HDLR > | HandlerGroup is a templated utility class to manage a group of StepHandlers |
| ThePEG::HandlerGroupBase | HandlerGroupBase is the base class for the templated HandlerGroup utility class to manage a group of StepHandlers |
| ThePEG::Helicity::HelicityVertex | Designed to store the helicity amplitude expression for the matrix element for use by the spin correlation algorithm |
| ThePEG::HEPEUP | Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name |
| ThePEG::HepMCConverter< HepMCEventT, Traits > | The HepMCConverter defines only one public static function which converts a ThePEG::Event object to a HepMC::GenEvent |
| ThePEG::HepMCConverter< HepMCEventT, Traits >::Vertex | Help class to represent a temporary vertex which can be converted to a GenVertex |
| ThePEG::HepMCFile | Outputs ThePEG events in HepMC format |
| ThePEG::HepMCTraits< HepMCEventT > | The HepMCTraits class is used to deal with different flavours of HepMC in the HepMCConverter class |
| ThePEG::ThePEG::HepMCTraits< HepMC::GenEvent > | Struct for HepMC conversion |
| ThePEG::HepMCTraitsBase< HepMCEventT, HepMCParticleT, HepMCVertexT, HepMCPolarizationT, HepMCPdfInfoT > | HepMCTraitsBase is a convenient base class for specializing the HepMCTraits class to deal with different flavours of HepMC in the HepMCConverter class |
| ThePEG::HEPRUP | Simple container corresponding to the Les Houches accord (hep-ph/0109068) common block with the same name |
| ThePEG::Hint | Hint is a base class to be used to pass information between StepHandler s, which cannot be convayed through the Event record |
| LWH::Histogram1D | User level interface to 1D Histogram |
| LWH::HistogramFactory | User level interface for factory classes of Histograms (binned, unbinned, and profile) |
| ThePEG::HoldFlag< T > | HoldFlag objects are used to temporarily change the value of an object, restoring the original value when the HoldFlag object is destructed |
| ThePEG::ThePEG::HoldFlag< bool > | Specialization of HoldFlag for boolean variables |
| ThePEG::IEnum< T > | The IEnum helper class is used to facilitate input of enums from persistent streams |
| ThePEG::InputDescription | InputDescription objects are used by the PersistentIStream class to keep track of all classes it has read from a stream |
| ThePEG::Int2Type< v > | Conversion between integers and types |
| ThePEG::InterfaceBase | Defines a generic interface to any class derived from the InterfacedBase class |
| ThePEG::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 |
| ThePEG::InterfacedBase | InterfacedBase is the base class of all Interfaced objects to be handled by the BaseRepository class |
| ThePEG::InterfacedBase::UpdateChecker | Functor class to be used to update a range of dependent object |
| ThePEG::InterfacedBase::UpdateMapChecker | Functor class to be used to update a range of dependent object in a map |
| ThePEG::IntermediateSelector | Used to extract only intermediate particles from an event |
| ThePEG::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>) |
| ThePEG::Math::Functions::InvX1mX | Class corresponding to functions of the form  |
| ThePEG::IteratorRange< Iterator > | A pair of iterators to be used in specialized algorithms instead of the standard first, last construction |
| ThePEG::IUnit< T, UT > | The IUnit class is used to facilitate input of unitful numbers from and to a persistent stream |
| ThePEG::IUnitErr< T, UT > | The IUnitErr class is used to facilitate input of unitful numbers with error estimates written out using the OUnitErr class |
| ThePEG::KTClus | This clas implements the cuts relevant for the  -measure in the longitudinally invariant kt-algorithm |
| ThePEG::KTRapidityCut | Simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle |
| ThePEG::LastXCombInfo< XC > | LastXCombInfo is a templated class giving easy access to the information in an XComb object |
| ThePEG::LeptonLeptonPDF | LeptonLeptonPDF inherits from PDFBase and encodes the distribution of leptons within leptons, ie |
| ThePEG::LeptonLeptonRemnant | LeptonLeptonRemnant inherits from the RemnantHandler and implements the generation of a single collinear photon remnant when a lepton is extracted from a lepton |
| ThePEG::LeptonMatcher | A Matcher class which matches any lepton |
| ThePEG::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 |
| ThePEG::LesHouchesFileReader | LesHouchesFileReader is an base class to be used for objects which reads event files from matrix element generators |
| ThePEG::LesHouchesReader | LesHouchesReader is an abstract base class to be used for objects which reads event files or streams from matrix element generators |
| ThePEG::Level< T > | Level is used to increment temporarily a given integer variable |
| ThePEG::LHAPDF | Inherits from PDFBase and implements an interface to the LHAPDF library of parton density function parameterizations |
| ThePEG::LightAntiQuarkMatcher | A Matcher class which matches any light anti-quark ( , or  ) |
| ThePEG::LightQuarkMatcher | A Matcher class which matches any light quark (d,u or s) |
| ThePEG::LoopGuard< ExceptionT, MessageT > | A LoopGuard object can be used to throw an exception if a loop is iterated too many times |
| ThePEG::Lorentz5Vector< Value > | The Lorentz5Vector inherits from the LorentzVector class |
| ThePEG::LorentzRotation | Combine a SpinOneLorentzRotation and a spin SpinHalfLorentzRotation to provide members which can perform the Lorentz transformation of any object |
| ThePEG::Helicity::LorentzRSSpinor< Value > | The LorentzRSSpinor class is designed to store a Rarita-Schwinger spinor for a spin-3/2 particle |
| ThePEG::Helicity::LorentzRSSpinorBar< Value > | The LorentzRSSpinorBar class implements the storage of a barred Lorentz Rarita-Schwinger Spinor for a spin-3/2 particle |
| ThePEG::Helicity::LorentzSpinor< Value > | The LorentzSpinor class is designed to store a spinor |
| ThePEG::Helicity::LorentzSpinorBar< Value > | The LorentzSpinorBar class implements the storage of a barred LorentzSpinor |
| ThePEG::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 |
| ThePEG::LorentzVector< Value > | A 4-component Lorentz vector |
| ThePEG::LuminosityFunction | The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment |
| ThePEG::LWHFactory | Here is the documentation of the LWHFactory class |
| ThePEG::MadGraphOneCut | Objects of the MadGraphOneCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts |
| ThePEG::MadGraphReader | MadGraphReader inherits from LesHouchesFileReader and is able to read event files produced by the MadGraph/MadEvent program |
| ThePEG::MadGraphReader::WeightedExcetion | Exception class used to inform about inability to work with some weighted event files |
| ThePEG::MadGraphTwoCut | Objects of the MadGraphTwoCut class can be created automatically by the MadGraphReader class when scanning event files for information about cuts |
| ThePEG::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 |
| LWH::ManagedObject | The creator of trees |
| ThePEG::MassGenerator | MassGenerator is an abstract base class used by the ParticleData class to generate a mass for a Particle instance |
| ThePEG::Matcher< T > | Matcher is a templated class inheriting from MatcherBase |
| ThePEG::MatcherBase | MatcherBase is an abstract base class to be used for objects representing groups of ParticleData objects |
| ThePEG::MatcherType | MatcherType is an empty non-polymorphic base class for all matcher classes to be used as template argument to Matcher |
| ThePEG::Math::MathType | MathType is an empty non-polymorphic base class for all mathematical function types |
| ThePEG::MaxCmp< T > | 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 |
| ThePEG::ME2to2Base | ME2to2Base can be used as a base class for any matrix element class implementing 2 2 processes |
| ThePEG::ME2to2QCD | Inherits from the ME2to2Base class and can be used as a sub class for all QCD 2 2 processes |
| LWH::Measurement | Basic user-level interface class for holding a single "measurement" with positive and negative errors (to allow for asymmetric errors) |
| ThePEG::MEBase | Base class of all objects representing hard matrix elements in ThePEG |
| ThePEG::MECuts | (currently not at all) used to make cuts on generated phase space points for the hard interaction |
| ThePEG::MEee2gZ2qq | Implements the  matrix element |
| ThePEG::MEGG2GG | MEGG2GG inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MEGG2QQ | MEGG2QQ inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MENCDIS | Implements the  matrix element |
| ThePEG::MEQG2QG | MEQG2QG inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MEQQ2GG | MEQQ2GG inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MEQQ2qq | MEQQ2qq inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MEQq2Qq | MEQq2Qq inherits from ME2to2QCD and implements the standard  mmatrix element |
| ThePEG::MEqq2qq | MEqq2qq inherits from the ME2to2QCD and implements the standard  matrix element |
| ThePEG::MEQQ2QQ | MEQQ2QQ inherits from ME2to2QCD and implements the standard  matrix element |
| ThePEG::MesonMatcher | A Matcher class which matches any meson |
| ThePEG::MultiColour | This class is used to store colour information of RemnantParticle objects and other particle classes with complicated colour structures |
| ThePEG::MultiCutBase | This class corresponds to a kinematical cut to be made on a set of outgoing particles from a hard sub-process |
| ThePEG::MultiEventGenerator | Derived from the EventGenerator class and is capable of making several runs with a pre-defined set of parameter and switch values |
| ThePEG::MultipleInteractionHandler | The MultipleInteractionHandler is the base class of all handlers implementing models for multiple interactions |
| ThePEG::Named | The Named class is a simple concrete base class to used by classes of objects with a name |
| ThePEG::NegativeMatcher | A Matcher class which matches any negatively charged particle |
| ThePEG::NeutralMatcher | A Matcher class which matches any uncharged particle |
| ThePEG::NoPDF | NoPDF inherits from PDFBase and represents particles without sub-structure |
| ThePEG::NoPIOClassDescription< T > | A concreate implementation of ClassDescriptionBase describing a concrete class without persistent data |
| ThePEG::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 |
| ThePEG::NotMatcher< T > | The NotMatcher class represents the boolean not operation for its template argument class of base type MatcherBase |
| ThePEG::O1AlphaS | O1AlphaS inherits from AlphaSBase and implements the leading order running QCD coupling |
| ThePEG::ObjectIndexer< IntT, ObjT > | This is a templated class which dynamically associates (reference counted) objects to indices |
| ThePEG::OEnum< T > | The OEnum helper class is used to facilitate output of enums to persistent streams |
| ThePEG::OmegaPhi3PiDecayer | Inherits from performs FlatDecayer and will reweight the flat phase space suitable to describe the decay of a  or an  into  |
| ThePEG::OneCutBase | This class corresponds to a kinematical cut to be made on a single outgoing parton from a hard sub-process |
| ThePEG::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 |
| ThePEG::OrMatcher< T1, T2 > | The OrMatcher class represents the boolean or operation between its two template argument classes of base type MatcherBase |
| ThePEG::OUnit< T, UT > | The OUnit< class is used to facilitate output of unitful numbers to a persistent stream |
| ThePEG::OUnitErr< T, UT > | OUnitErr is used to write out unitful numbers with an error estimate on a standard ostream |
| ThePEG::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 |
| ThePEG::ThePEG::Parameter< T, string > | This is a partial specialization of Parameter for the string case |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::ThePEG::ParameterTBase< string > | This is a specialization of ParameterTBase for the string case |
| ThePEG::Particle | Used to describe an instance of a particle |
| ThePEG::Particle::ParticleRep | This class is used internally in the Particle class to represent information besides momentum and type |
| ThePEG::ParticleData | ParticleData inherits from InterfacedBase and represents the properties of a particle type |
| ThePEG::ParticleSelector< T > | The templated ParticleSelector class may be used to implement derived classes from the SelectorBase class |
| ThePEG::ParticleTraits< PType > | ParticleTraits is a templated class defining a general interface to any particle class |
| ThePEG::PartonBin | Used by the PartonExtractor class to store information about the extraction of a parton from a particle |
| ThePEG::PartonBinInstance | PartonBinInstance is used to store information about the generation of a given parton extraction for a corresponding PartonBin object |
| ThePEG::PartonExtractor | The PartonExtractor is a base class defining the interface to objects responsible for extracting partons from particles |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::PDFBase | PDFBase is the base class for implementing parton density functions for particles with sub-structure |
| ThePEG::PDFCuts | Used to specify cuts on scale and momentum fractions for which a PDFBase object is expected to give parton densities |
| ThePEG::PDT | PDT is a helper class implementing enumerations for charge, colour and spin to be used by the ParticleData class |
| ThePEG::PersistentIStream | PersistentIStream is used to read persistent objects from a stream where they were previously written using PersistentOStream |
| ThePEG::PersistentOStream | PersistentOStream is used to write objects persistently to a stream from which they can be read in again with a PersistentIStream |
| ThePEG::PositiveMatcher | A Matcher class which matches any positively charged particle |
| ThePEG::Math::Functions::Pow1mX< N > | Class corresponding to functions of the form  with integer N |
| ThePEG::Math::Power< N, Inv > | Templated class for calculating integer powers |
| ThePEG::Math::ThePEG::Math::Power< 0, false > | Struct for powers |
| ThePEG::Math::ThePEG::Math::Power< 0, true > | Struct for powers |
| ThePEG::Math::ThePEG::Math::Power< N, false > | Struct for powers |
| ThePEG::Math::ThePEG::Math::Power< N, true > | Struct for powers |
| ThePEG::Math::Functions::PowX< N > | Class corresponding to functions of the form  with integer N |
| ThePEG::PrimaryCollisionSelector | Used to extract all particles from the primary Collision of an event |
| ThePEG::PseudoScalarMesonMatcher | A Matcher class which matches any pseudo scalar meson |
| ThePEG::PtGenerator | PtGenerator is the base for all classes implementing alternative models for transverse momentum generation |
| ThePEG::Pointer::Ptr< T > | Ptr is a templated class to provide typedefs for pointers types ThePEG should use for a given type |
| ThePEG::Pointer::PtrTraits< T > | The PtrTraits class is used everywhere in ThePEG to interface to the pointers which are handled |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< const T * > | Specialization of the PtrTraits class for standard bare const pointers |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< ConstRCPtr< T > > | Specialization of the PtrTraits class for ConstRCPtr |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< RCPtr< T > > | Specialization of the PtrTraits class for RCPtr |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< T * > | Specialization of the PtrTraits class for standard bare pointers |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< TransientConstRCPtr< T > > | Specialization of the PtrTraits class for TransientConstRCPtr |
| ThePEG::Pointer::ThePEG::Pointer::PtrTraits< TransientRCPtr< T > > | Specialization of the PtrTraits class for TransientRCPtr |
| ThePEG::Pointer::PtrTraitsType | PtrTraitsType is an empty non-polymorphic base class for all PtrTraits classes |
| ThePEG::Qty< L, E, Q, DL, DE, DQ > | This template class allows the compiler to check calculations with physical quantities for dimensional correctness |
| ThePEG::QTY< L, E, Q, DL, DE, DQ > | Helper class to define unitful quantities |
| ThePEG::ThePEG::Qty< 0, 0, 0, DL, DE, DQ > | Specialization of Qty for <0,0,0> with conversions to double |
| ThePEG::QtyHelper< M, II > | Helper classes to extend or shorten fractions |
| ThePEG::ThePEG::QtyHelper< 0, II > | Template to help with fractional powers of dimensions |
| ThePEG::QtyInt< II, DI, DI2 > | Template to help with fractional powers of dimensions |
| ThePEG::QuarkMatcher | A Matcher class which matches any (anti-)quark |
| ThePEG::QuarksToHadronsDecayer | Inherits from Decayer and is able to decay particles to  (2 or 4) quarks which then are decayed to hadrons according to phase space |
| ThePEG::RandomGenerator | RandomGenerator is an interface to the CLHEP::RandomEngine classes |
| ThePEG::Pointer::RCPtr< T > | RCPtr is a reference counted (smart) pointer |
| ThePEG::Pointer::RCPtrBase | RCPtrBase is the base class of RCPtr and ConstRCPtr which are reference counted (smart) pointers |
| ThePEG::Rebinder< T > | Rebinder is a class associating pairs of pointers to objects |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::Pointer::ReferenceCounted | ReferenceCounted must be the (virtual) base class of all classes which may be pointed to by the RCPtr smart pointer class |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::RemInfoBase | Empty base class |
| ThePEG::RemnantData | Not a normal ParticleData class |
| ThePEG::RemnantDecayer | Base class to be used for all decayers capable of decaying a RemnantParticle object produced by a SoftRemnantHandler object |
| ThePEG::RemnantDecayer::SubSystemFail | Exception used if getSubSystem fails |
| ThePEG::RemnantHandler | RemnantHandler is an abstract base class for implementing classes used to generate remnants when partons are extracted from particles |
| ThePEG::RemnantParticle | Here is the documentation of the RemnantParticle class |
| ThePEG::Repository | Repository inherits from the BaseRepository class |
| ThePEG::ReweightBase | Base class of all objects representing external biases to matrix elements |
| ThePEG::ReweightConstant | Simple ReweightBase sub-class which simply reweight an event with a constant |
| ThePEG::ReweightMinPT | Reweights matrix elements with the minimum of the transverse momenta of the outgoing partons to some power |
| ThePEG::Helicity::RhoDMatrix | Designed to implement the storage of the rho and D matrices which are required for the spin correlation algorithm |
| ThePEG::RivetAnalysis | Here is the documentation of the RivetAnalysis class |
| ThePEG::Helicity::RSFermionSpinInfo | Inherits from the SpinInfo class and implements the storage of the basis vector for a spin-3/2 particle |
| ThePEG::Helicity::RSSpinorBarWaveFunction | The RSSpinorBarWaveFunction class is designed to store the wavefunction of a spin- particle in a form suitable for use in helicity amplitude calculations of the matrix element using a similar philosophy to the FORTRAN HELAS code |
| ThePEG::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 |
| ThePEG::RunningCoupling | RunningCoupling an abstract base class unifying the treatment of running couplings in ThePEG |
| ThePEG::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 |
| ThePEG::Helicity::ScalarSpinInfo | Designed to be the implementation of the spin information for a scalar particle |
| ThePEG::Helicity::ScalarWaveFunction | |
| ThePEG::SelectIfBoth | Can be used to combine other selector objects |
| ThePEG::SelectIfEither | Can be used to combine other selector objects |
| ThePEG::SelectIfNot | The SelectIfNot classes can be used to negate the meaning of another SelectorBase object |
| ThePEG::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 |
| ThePEG::SelectorBase | Classes derived from the SelectorBase class are used to extract particles from an Event with Event::select() method |
| ThePEG::SimpleAlphaEM | SimpleAlphaEM inherits from AlphaEMBase and implements a simple running of the electromagnetic coupling as parameterized by H |
| ThePEG::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 |
| ThePEG::SimpleBaryonRemnantDecayer::BaryonContent | Simple struct to store info about baryon quark and di-quark constituents |
| ThePEG::SimpleBaryonRemnantDecayer::DecayFailed | Exception thrown if the decay of a remnant was impossible |
| ThePEG::SimpleBaryonRemnantDecayer::NoDISRespect | Warning Exception used when DIS kinematics was not respected |
| ThePEG::SimpleDISCut | SimpleDISCut inherits from TwoCutBase and omplements a simple  cut on the a scattered lepton, either neutral or charged current |
| ThePEG::SimpleFlavour | SimpleFlavour is a simple class to generate hadrons given the quark flavours |
| ThePEG::SimpleKTCut | This is a very simple concrete sub-class of OneCutbase simply requiring a minimum transverse momentum of any outgoing particle |
| ThePEG::SimplePhaseSpace | SimplePhaseSpace defines a set of static functions to be used for distributing momenta evenly in phase space |
| ThePEG::SimpleZGenerator | SimpleZGenerator is a very simple concrete subclass of ZGenerator |
| ThePEG::SoftRemnantHandler | SoftRemnantHandler inherits from the RemnantHandler and implements the generation of a single collinear RemnantParticle when anything is extracted from anything else |
| ThePEG::SpinBase | SpinBase is the base class for adding spin information to a Particle |
| ThePEG::SpinHalfLorentzRotation | Designed to offer the same features as the HepLorentzRotation class of CLHEP but for the spin- Lorentz transformation |
| ThePEG::Helicity::SpinInfo | The SpinInfo is the base class for the spin information for the spin correlation algorithm |
| ThePEG::SpinOneLorentzRotation | |
| ThePEG::Helicity::SpinorBarWaveFunction | |
| ThePEG::Helicity::SpinorWaveFunction | |
| ThePEG::Helicity::SSSSVertex | Implementation of the interaction of four scalars |
| ThePEG::Helicity::SSSVertex | Implementation of the interaction of three scalars |
| ThePEG::Helicity::SSTVertex | The VVTVertexclass is the implementation of the scalar-scalar-tensor vertex |
| ThePEG::StandardCKM | StandardCKM inherits from CKMBase and implements the standard parameterization of the CKM matrix in terms of three angles and a phase |
| ThePEG::StandardEventHandler | Main class for generating simple events without overlayed collisions |
| ThePEG::StandardModelBase | StandardModelBase is used to handle standard model parameters in an EventGenerator |
| ThePEG::StandardQCDPartonMatcher | A Matcher class which matches any standard QCD parton, ie |
| ThePEG::StandardRandom | StandardRandom inherits from the RandomGenerator class and is an interface to the CLHEP::JamesRandom engine class |
| ThePEG::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 |
| ThePEG::Step | Information of all particles present after certain step in the event generation |
| ThePEG::StepHandler | StepHandler is the base class for implementing any model for a step in the event generation chain |
| ThePEG::Stop | A standard exception class to be used to temporarily stop the generation of an event |
| ThePEG::Strategy | General strategy to be assigned to an EventGenerator |
| ThePEG::StringUtils | Few static utility functions for basic strings |
| ThePEG::SubProcess | A SubProcess object represents a hard  sub-process in a collision |
| ThePEG::SubProcessHandler | Used to handle a set of MEBase objects together with a PartonExtractor |
| ThePEG::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) |
| ThePEG::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) |
| ThePEG::SwitchOption | SwitchOption is used by the Switch class and its base class SwitchBase to define valid options in a switch |
| ThePEG::Tau2HadronsDecayer | Inherits FlatDecayer and can perform the decays of tau to neutrino + hadrons according to phase space, with an extra weight  |
| ThePEG::Helicity::TensorSpinInfo | Implementation of the spin information for tensor particles |
| ThePEG::Helicity::TensorWaveFunction | |
| ThePEG::ThePEGStrategy | Sub-class of the Strategy class, simply implementing the correct citation for ThePEG in the ClassDocumentation interface |
| ThePEG::ThreeVector< Value > | A 3-component vector |
| ThePEG::Throw< Ex > | Helper function to make it easier to throw exceptions |
| ThePEG::TmpTransform< Ptr > | This is a wrapper class to be used to temporarily make a Lorentz transform of an object |
| ThePEG::TraitsType | TraitsType is an empty, non-polymorphic, base class |
| ThePEG::Transformer | A helper class to be used in std:: algorithms to transform a range of particles |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::Transverse< Value > | Transverse represents the transverse components of a LorentzVector |
| LWH::Tree | Simple implementation of the AIDA::ITree interface |
| ThePEG::Tree2toNDiagram | Inherits from DiagramBase and represents a Feynman tree diagram |
| LWH::TreeFactory | The creator of trees |
| ThePEG::Triplet< T1, T2, T3 > | The Triplet class represents a general triplet of objects completely analogous to std::pair |
| ThePEG::TwoCutBase | This class corresponds to a kinematical cut to be made on a pair of particles in a hard sub-process |
| ThePEG::TypeInfo | TypeInfo is a simple wrapper around the ClassDescription system in ThePEG |
| ThePEG::TypeTraits< T > | Type traits for built-in types |
| ThePEG::UseRandom | This UseRandom class keeps a static stack of RandomGenerator objects which can be used anywhere by any class |
| ThePEG::Utilities | Concrete class with UtilityBase as base class |
| ThePEG::UtilityBase | UtilityBase is a base class implementing a number of static utility functions |
| ThePEG::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 |
| ThePEG::V2PPDecayer | Performs the decay of a vector meson into two pseudo-scalars according to a flat phase space |
| LWH::VariAxis | An VariAxis represents a binned histogram axis |
| ThePEG::VectorMesonMatcher | A Matcher class which matches any vector meson |
| ThePEG::Helicity::VectorSpinInfo | Implementation of the spin information for vector particles |
| ThePEG::Helicity::VectorWaveFunction | |
| ThePEG::Helicity::VertexBase | Base class for all helicity amplitude vertices |
| ThePEG::Veto | A standard exception class to be used for vetoing a whole event |
| ThePEG::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 |
| ThePEG::Helicity::VSSVertex | Implementation of the vector-scalar-scalar vertex |
| ThePEG::Helicity::VVSSVertex | Implementation of the coupling of two vectors and two scalars |
| ThePEG::Helicity::VVSVertex | Implementation of the vector-vector-scalar |
| ThePEG::Helicity::VVTVertex | Implementation of the vector-vector-tensor vertex |
| ThePEG::Helicity::VVVTVertex | The VVTVertex class is the implementation of the vector-vector-vector-tensor vertex |
| ThePEG::Helicity::VVVVertex | Base class for triple vector vertices using the perturbative form |
| ThePEG::Helicity::VVVVVertex | This is the implementation of the four vector vertex |
| ThePEG::Helicity::WaveFunctionBase | |
| ThePEG::WeakToHadronsDecayer | Inherits from QuarksToHadronsDecayer and can performs weak decays of taus and charmed and bottom hadrons |
| ThePEG::WeizsackerWilliamsPDF | Here is the documentation of the WeizsackerWilliamsPDF class |
| ThePEG::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 |
| ThePEG::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 |
| ThePEG::XSecCheck | Simple analysis class used for testing purposes |
| ThePEG::XSecCheck::UnexpectedXSec | The exception class used if the target cross section was not met |
| ThePEG::XSecStat | XSecStat is a concrete helper class used to collect statistics about the cross section for a specific process or group of processes |
| ThePEG::ZeroUnit | Helper class to construct zero unitful quantities |
| ThePEG::ZGenerator | ZGenerator is the base class for all classes implementing models to generate the momentum fraction,  , taken by hadrons produced in a hadronization scenario |
