Class List

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

[detail level 123]

►NHepMC | |

CPartonEndVertexException | Exception thrown when an undecayed parton is written into the record |

CPythia8ToHepMC | The Pythia8ToHepMC class |

CPythia8ToHepMCException | Base exception for all exceptions that Pythia8ToHepMC might throw |

►NHepMC3 | |

CPythia8ToHepMC3 | |

►NLHEH5 | |

CEvent | Event struct |

CEventHeader | Event header struct |

CEvents | Old event struct |

CEvents2 | New events struct |

CLHEFile | LHEFile class |

CParticle | Particle struct |

CProcInfo | Process info struct |

►NPythia8 | Header for classes to set beam momentum and interaction vertex spread |

►NLHAPDF5Interface | Map the f77 routines to C++ |

CLHAPDFInfo | Simple structure to hold LHAPDF set information |

CAlpgenHooks | |

CAlpgenPar | |

CAlphaEM | |

CAlphaStrong | |

CAlphaSUN | |

Camcnlo_unitarised_interface | |

CAmpCalculator | Calculator class for amplitudes, antennae, and Breit-Wigners |

CAmpWrapper | Class to contain an amplitude and two outgoing polarizations |

CAngantyr | The default HeavyIon model in Pythia |

CAntennaFunction | |

CAntennaFunctionIF | |

CAntennaFunctionIX | |

CAntennaSetFSR | The AntennaSetFSR class. Simple container of FF and RF antenna functions |

CAntennaSetISR | The AntennaSetISR class. Simple container of II and IF antenna functions |

CAntGGEmitFF | Class AntGQEmitFF, final-final antenna function |

CAntGGEmitFFsec | |

CAntGGEmitIF | Class AntGGEmitIF, initial-final antenna function |

CAntGGEmitIFsec | Class AntGGEmitIFsec, sector initial-final antenna function |

CAntGGEmitII | Class AntGGEmitII, initial-initial antenna function |

CAntGQEmitFF | Class AntGQEmitFF, final-final antenna function |

CAntGQEmitFFsec | |

CAntGQEmitIF | Class AntGQEmitIF, initial-final antenna function |

CAntGQEmitII | Class AntGQEmitII, initial-initial antenna function |

CAntGXConvIF | |

CAntGXConvII | |

CAntGXSplitFF | Class AntGXSplitFF, final-final antenna function |

CAntGXSplitFFsec | |

CAntQGEmitFF | Class AntQGEmitFF, final-final antenna function |

CAntQGEmitFFsec | |

CAntQGEmitIF | Class AntQGEmitIF, initial-final antenna function |

CAntQGEmitIFsec | |

CAntQGEmitRF | Class AntQGEmitRF, resonance-final antenna function |

CAntQGEmitRFsec | Class AntQGEmitRF, resonance-final antenna function |

CAntQQEmitFF | Class AntQQEmitFF, final-final antenna function |

CAntQQEmitFFsec | |

CAntQQEmitIF | Class AntQQEmitIF, initial-final antenna function |

CAntQQEmitII | Class AntQQEmitII, initial-initial antenna function |

CAntQQEmitRF | Class AntQQEmitRF, resonance-final antenna function |

CAntQXConvIF | |

CAntQXConvII | |

CAntWrapper | Class to contain an antenna function and two outgoing polarizations |

CAntXGSplitIF | |

CAntXGSplitIFsec | |

CAntXGSplitRF | Class AntXGSplitRF, resonance-final antenna function |

CAntXGSplitRFsec | Class AntXGSplitRF, resonance-final antenna function |

CBeamDipole | Purely internal to reconnectMPIs |

CBeamParticle | |

CBeamRemnants | |

CBeamSetup | |

CBeamShape | Base class to set beam momentum and interaction spot spread |

CBlackSubCollisionModel | |

CBoseEinstein | |

CBoseEinsteinHadron | Simple container for studied hadrons |

CBranchElementalISR | The BranchElementalISR class, container for 2 -> 3 trial branchings |

CBrancher | |

CBrancherEmitFF | Class BrancherEmitFF, branch elemental for 2->3 gluon emissions |

CBrancherEmitRF | |

CBrancherRF | BrancherRF base class for resonance-final antennae |

CBrancherSplitFF | Class BrancherSplitFF, branch elemental for 2->3 gluon splittings |

CBrancherSplitRF | |

CCellJet | |

CCJKL | |

CClustering | |

CClusterJet | |

CClusterModel | A model for nuclei clustered in smaller nuclei |

CColConfig | Describes the colour configuration of the whole event |

CColourDipole | |

CColourFlow | |

CColourJunction | |

CColourParticle | ColourParticle class |

CColourReconnection | Handles the colour reconnection |

CColourReconnectionBase | |

CColourStructure | Storage device for containing colour structure of hard process |

CColourTracing | ColourTracing class. It is used to trace colours within the event record |

CColSinglet | |

CColState | The ColState class |

CCombineMatchingInput | |

CCoupSM | |

CCoupSUSY | |

Ccreate_unordered_map | |

Ccreatemap | |

Ccreatevector | |

CCTEQ5L | |

CCTEQ6pdf | |

CDecayChannel | This class holds info on a single decay channel |

CDecayHandler | |

CDeuteronProduction | The DeuteronProduction class |

CDGLAP | A class containing DGLAP splitting functions for limit checking |

CDipoleSwingBase | |

CDire | |

CDire_fsr_ew_H2AA | |

CDire_fsr_ew_H2GG | |

CDire_fsr_ew_H2WW | |

CDire_fsr_ew_Q2QZ | |

CDire_fsr_ew_Q2ZQ | |

CDire_fsr_ew_W2QQ1 | |

CDire_fsr_ew_W2QQ2 | |

CDire_fsr_ew_W2WA | |

CDire_fsr_ew_Z2QQ1 | |

CDire_fsr_ew_Z2QQ2 | |

CDire_fsr_qcd_G2GG1 | |

CDire_fsr_qcd_G2GG2 | |

CDire_fsr_qcd_G2GG_notPartial | |

CDire_fsr_qcd_G2GGG | |

CDire_fsr_qcd_G2Gqqbar | |

CDire_fsr_qcd_G2QQ1 | |

CDire_fsr_qcd_G2QQ2 | |

CDire_fsr_qcd_G2QQ_notPartial | |

CDire_fsr_qcd_Q2GQ | |

CDire_fsr_qcd_Q2QbarQQId | |

CDire_fsr_qcd_Q2QG | |

CDire_fsr_qcd_Q2QG_notPartial | |

CDire_fsr_qcd_Q2QGG | |

CDire_fsr_qcd_Q2Qqqbar | |

CDire_fsr_qcd_Q2qQqbarDist | |

CDire_fsr_qed_A2FF | |

CDire_fsr_qed_L2AL | |

CDire_fsr_qed_L2LA | |

CDire_fsr_qed_L2LA_notPartial | |

CDire_fsr_qed_Q2AQ | |

CDire_fsr_qed_Q2QA | |

CDire_fsr_qed_Q2QA_notPartial | |

CDire_fsr_u1new_A2FF | |

CDire_fsr_u1new_A2SS | |

CDire_fsr_u1new_L2AL | |

CDire_fsr_u1new_L2LA | |

CDire_fsr_u1new_Q2AQ | |

CDire_fsr_u1new_Q2QA | |

CDire_isr_ew_Q2QZ | |

CDire_isr_qcd_G2GG1 | |

CDire_isr_qcd_G2GG2 | |

CDire_isr_qcd_G2QQ | |

CDire_isr_qcd_Q2GQ | |

CDire_isr_qcd_Q2QbarQQId | |

CDire_isr_qcd_Q2QG | |

CDire_isr_qcd_Q2qQqbarDist | Class inheriting from SplittingQCD class |

CDire_isr_qed_A2LL | |

CDire_isr_qed_A2QQ | |

CDire_isr_qed_L2AL | |

CDire_isr_qed_L2LA | |

CDire_isr_qed_Q2AQ | |

CDire_isr_qed_Q2QA | |

CDire_isr_u1new_A2LL | |

CDire_isr_u1new_A2QQ | |

CDire_isr_u1new_L2AL | |

CDire_isr_u1new_L2LA | |

CDire_isr_u1new_Q2AQ | |

CDire_isr_u1new_Q2QA | |

CDireClustering | |

CDireColChains | Container for multiple color chains |

CDireCouplFunction | Helper class for setEffectiveScales |

CDireDebugInfo | |

CDireEventInfo | |

CDireFunction | |

CDireHardProcess | |

CDireHistory | |

CDireHooks | Hooks is base class for user access to program execution |

CDireInfo | |

CDireMerging | |

CDireMergingHooks | DireMergingHooks is base class for user input to the merging procedure |

CDirePSWeight | Container for a single weight with auxiliary information |

CDireRootFinder | |

CDireSingleColChain | Definition of color chains |

CDireSpace | Does spacelike showers |

CDireSpaceEnd | Data on radiating dipole ends, only used inside DireSpace |

CDireSplitInfo | |

CDireSplitKinematics | |

CDireSplitParticle | |

CDireSplitting | |

CDireSplittingEW | |

CDireSplittingLibrary | |

CDireSplittingQCD | |

CDireSplittingQED | |

CDireSplittingU1new | |

CDireTimes | Does timelike showers |

CDireTimesEnd | Data on radiating dipole ends; only used inside DireTimes class |

CDireWeightContainer | Container for all shower weights, including handling |

CDoubleStrikmanSubCollisionModel | |

CDummyForStreams | Dummy to avoid harmless compiler warning that Streams.o has no symbols |

CEPAexternal | Equivalent photon approximation for sampling with external photon flux |

CEPPS16 | Nuclear modifications from EPPS16 fit |

CEPS09 | Nuclear modifications from EPS09 fit |

CEvent | Holds all info on the generated event |

CEventInfo | Class for storing Events and Info objects |

CEvolutionWindow | Helper struct for passing trial-alphaS information |

►CEvtGenDecays | |

CSignal | Map of signal particle info |

CEvtGenRandom | A class to wrap the Pythia random number generator for use by EvtGen |

CEWAntenna | Base class for an electroweak antenna |

CEWAntennaFF | Final-final electroweak antenna |

CEWAntennaFFres | Final-final electroweak resonance antenna |

CEWAntennaII | Initial-initial electroweak antenna |

CEWBranching | Class that contains an electroweak branching |

CEWParticle | Simple class to save information about particles |

CEWParticleData | Locally saved particle data in glorified map |

CEWSystem | Class that performs electroweak showers in a single parton system |

CExc | |

CExternalMEs | Base class for external matrix-element interfaces |

CExternalMEsMadgraph | External matrix element class specifically for MadGraph |

CExternalNucleusModel | |

CFlag | Class for bool flags |

CFlavContainer | |

CFlavourRope | |

CFluctuatingSubCollisionModel | |

CFragmentationModifierBase | |

CFVec | Class for vector of bool flags |

CGammaKinematics | Class to sample the virtuality and transverse momentum of emitted photons |

CGammaMatrix | |

CGammaPoint | Gives photon parton distribution when unresolved |

CGaussianModel | A Gaussian distribution for light nuclei |

CGLISSANDOModel | |

CGRSpiL | |

CGRV94L | |

CGRVpiL | |

►CHadronLevel | |

CPriorityNode | |

CHadronWidths | |

CHardCoreModel | |

CHardDiffraction | |

CHardProcess | |

CHardProcessParticle | |

CHardProcessParticleList | List of hard particles |

►CHeavyIons | |

CInfoGrabber | |

CHelicityMatrixElement | The helicity matrix element class |

CHelicityParticle | |

CHelicitySampler | A helicity sampler using external matrix elements |

CHEPEUP | |

CHEPRUP | |

CHiddenValleyFragmentation | |

CHIInfo | |

CHist | |

CHistory | |

CHistoryNode | Class for a single step in the history of a process |

CHistPlot | |

CHIUserHooks | |

CHJSlowJet | |

CHMEGamma2TwoFermions | Helicity matrix element for the hard process of photon -> two fermions |

CHMEHiggs2TwoFermions | Helicity matrix element for the decay of a Higgs -> two fermions |

CHMETau2FivePions | Helicity matrix element for a tau decaying into five pions |

CHMETau2FourPions | Helicity matrix element for a tau decay into four pions |

CHMETau2Meson | Helicity matrix element for a tau decaying into a single scalar meson |

CHMETau2PhaseSpace | Helicity matrix element for a tau decay into flat phase space |

CHMETau2ThreeMesons | Helicity matrix element for a tau decay into three mesons (base class) |

CHMETau2ThreeMesonsGeneric | Helicity matrix element for a tau decay into generic three mesons |

CHMETau2ThreeMesonsWithKaons | Helicity matrix element for a tau decay into three mesons with kaons |

CHMETau2ThreePions | Helicity matrix element for a tau decay into three pions |

CHMETau2TwoLeptons | Helicity matrix element for a tau decaying into two leptons |

CHMETau2TwoMesonsViaVector | |

CHMETau2TwoMesonsViaVectorScalar | |

CHMETau2TwoPionsGamma | Helicity matrix element for a tau decay into two pions and a photon |

CHMETauDecay | Base class for all tau decay helicity matrix elements |

CHMETwoFermions2GammaZ2TwoFermions | |

CHMETwoFermions2W2TwoFermions | |

CHMETwoGammas2TwoFermions | |

CHMEW2TwoFermions | Helicity matrix element for the hard process of W/W' -> two fermions |

CHMEX2TwoFermions | Helicity matrix element for the hard process of X -> two fermions |

CHMEZ2TwoFermions | Helicity matrix element for the hard process of Z/Z' -> two fermions |

CHOShellModel | A Harmonic-Oscillator Shell model for light nuclei |

CHulthenModel | The Hulthen potential for deuterons |

CHungarianAlgorithm | |

CHVcols | Stores Hidden Valley colours for HV-coloured particles |

CHVStringFlav | Used to select HV-quark and HV-hadron flavours |

CHVStringPT | Used to select select HV transverse momenta |

CHVStringZ | Used to sample the HV fragmentation function f(z) |

CImpactParameterGenerator | |

CInBeam | InBeam is a simple helper class for partons and their flux in a beam |

CInfo | |

CInfoGluonMove | Purely internal to reconnectMove |

CInPair | InPair is a simple helper class for colliding parton pairs and their flux |

CIsospin | |

CJetMatching | |

CJetMatchingAlpgen | Declaration of main UserHooks class to perform Alpgen matching |

CJetMatchingAlpgenInputAlpgen | |

CJetMatchingMadgraph | Declaration of main UserHooks class to perform Madgraph matching |

CJetMatchingMadgraphInputAlpgen | |

CJunction | |

CJunctionSplitting | |

CLepton | Gives electron (or muon, or tau) parton distribution |

CLepton2gamma | |

CLeptonPoint | Gives electron (or other lepton) parton distribution when unresolved |

CLHAgenerator | Collect generator information for an event file |

CLHAGrid1 | |

CLHAinitrwgt | The LHAinitrwgt assigns a group-name to a set of LHAweightgroup objects |

CLHAParticle | A class for the particles stored in LHAup |

CLHAPDF5 | Plugin interface to the LHAPDF5 library |

CLHAPDF6 | Provide interface to the LHAPDF6 library of parton densities |

CLHAProcess | A class for the processes stored in LHAup |

CLHArwgt | The LHArwgt assigns a group-name to a set of LHAwgt objects |

CLHAscales | Collect different scales relevant for an event |

CLHAup | |

CLHAupAlpgen | |

CLHAupFortran | |

CLHAupFromPYTHIA8 | A derived class with information read from PYTHIA 8 itself, for output |

CLHAupH5 | |

CLHAupH5v2 | |

CLHAupHelaconia | A derived class from LHAup which generates events with HelacOnia |

CLHAupLHEF | A derived class with information read from a Les Houches Event File |

CLHAupMadgraph | A derived class from LHAup which generates events with MadGraph 5 |

CLHAupPowheg | |

CLHAweight | Collect the wgt information |

CLHAweightgroup | The LHAweightgroup assigns a group-name to a set of LHAweight objects |

CLHAweights | The LHAweights struct represents the information in a weights tag |

CLHAwgt | Collect the wgt information |

CLHblock | ************************* SLHA AUX CLASSES *****************************/// |

CLHdecayChannel | *************************** DECAY TABLES ***************************/// |

CLHdecayTable | |

CLHEF3FromPythia8 | |

CLHgenericBlock | Derived class for generic blocks containing vectors of strings |

CLHmatrixBlock | |

CLHtensor3Block | |

CLinearInterpolator | |

CLogger | |

CLogInterpolator | |

CLogNormalSubCollisionModel | |

CLowEnergyProcess | |

CMadgraphPar | |

CMBReconUserHooks | Class for colour reconnection models of general validity |

CMECs | |

CMergeResScaleHook | |

CMerging | |

►CMergingHooks | MergingHooks is base class for user input to the merging procedure |

CIndividualWeights | Struct to save individual weights |

CMiniStringFragmentation | |

CMode | Class for integer modes |

CMSTWpdf | |

CMultiParticle | Storage device for multiparticle |

CMultipartonInteractions | |

CMVec | Class for vector of integers |

CNaiveSubCollisionModel | |

CNeutrinoPoint | |

CnPDF | A derived class for nuclear PDFs. Needs a pointer for (free) proton PDFs |

CNucleon | |

CNucleonExcitations | |

CNucleus | |

CNucleus2gamma | |

CNucleusModel | |

COniaSetup | |

COverheadInfo | |

COverlappingRopeDipole | |

CParm | Class for double parms (where parm is shorthand for parameter) |

CParticle | |

CParticleData | This class holds a map of all ParticleDataEntries |

CParticleDataEntry | This class holds info on a single particle species |

CParticleDecays | Routines to decay a particle |

CParticleLocator | |

CPartonLevel | |

CPartonSystem | |

CPartonSystems | Describes the whole set of subcollisions |

CPartonVertex | Sets parton-level vertex information |

►CPDF | Base class for parton distribution functions |

CPDFEnvelope | Error envelope from PDF uncertainty |

CPdfSets | Containers for PDF sets |

CPhaseSpace | |

CPhaseSpace2to1tauy | A derived class with 2 -> 1 kinematics set up in tau, y |

CPhaseSpace2to2diffractive | A derived class with 2 -> 2 kinematics set up for diffractive scattering |

CPhaseSpace2to2elastic | A derived class with 2 -> 2 kinematics set up for elastic scattering |

CPhaseSpace2to2nondiffractive | |

CPhaseSpace2to2tauyz | A derived class with 2 -> 2 kinematics set up in tau, y, z = cos(theta) |

CPhaseSpace2to3diffractive | |

CPhaseSpace2to3tauycyl | |

CPhaseSpace2to3yyycyl | |

CPhaseSpaceLHA | A derived class for Les Houches events |

CPhysicsBase | |

CPomFix | Gives generic Q2-independent Pomeron PDF |

CPomH1FitAB | |

CPomH1Jets | |

CPomHISASD | A proton masked as a Pomeron for use within the Heavy Ion machinery |

CPowhegHooks | Use userhooks to veto PYTHIA emissions above the POWHEG scale |

CProcessContainer | |

CProcessLevel | |

CProgressLog | |

CProton2gammaDZ | |

CProtonPoint | |

CPseudoChain | Convenient shorthand for storing ordered list of chains |

CPVec | Class for vector of doubles |

CPythia | Top-level routines to generate an event |

CPythia8Rivet | |

CPythia8ToHepMC | |

CPythiaCascade | Intended flow: |

CPythiaParallel | Class for doing Pythia runs in parallel |

CQEDconvSystem | Class for a QED conversion system |

CQEDemitElemental | Class for QED emissions |

CQEDemitSystem | Class for a QED emission system |

CQEDsplitElemental | Class for trial QED splittings |

CQEDsplitSystem | Class for a QED splitting system |

CQEDsystem | Base class for QED systems |

CRambo | Rambo flat phase-space generator |

CReader | |

CResJunctionInfo | |

CResolution | A simple class for containing evolution variable definitions |

CResolvedParton | |

CResonanceCha | Charged partner of DM (PDG id 57.) |

CResonanceChaD | Doubly Charged partner of DM (PDG id 59.) |

CResonanceChar | Handles the Chargino resonances |

CResonanceDecayFilterHook | |

CResonanceDecays | |

CResonanceDM2 | |

CResonanceExcited | Handles excited-fermion resonances |

CResonanceFour | Handles fourth-generation resonances |

CResonanceGeneric | |

CResonanceGluino | Handles the Gluino resonances |

CResonanceGmZ | Handles the gamma*/Z0 resonance |

CResonanceGraviton | Handles the excited Graviton resonance |

CResonanceH | |

CResonanceHchg | Handles the H+- resonance |

CResonanceHchgchgLeft | Handles the H++/H– (left) resonance |

CResonanceHchgchgRight | Handles the H++/H– (right) resonance |

CResonanceKKgluon | Handles the g^*/KK-gluon^* resonance |

CResonanceLeptoquark | Handles the LQ/LQbar resonance |

CResonanceNeut | Handles the Neutralino resonances |

CResonanceNuRight | Handles righthanded Majorana neutrinos |

CResonanceRhorizontal | Handles the R^0 resonance |

CResonanceS | The ResonanceS class. (S a.k.a. DMmed(s=0), PDG id 54.) |

CResonanceSl | Charged scalar partner of DM (PDG id 56.) |

CResonanceSlepton | Handles the Slepton/Sneutrino resonances |

CResonanceSquark | Handles the Squark resonances |

CResonanceTop | Handles the top/antitop resonance |

CResonanceW | Handles the W+- resonance |

CResonanceWidths | The ResonanceWidths is the base class. Also used for generic resonaces |

CResonanceWprime | Handles the W'+- resonance |

CResonanceWRight | Handles the W_R+- resonance |

CResonanceZp | The ResonanceZp class. (Zp a.k.a. DMmed(s=1), PDG id 55.) |

CResonanceZprime | Handles the gamma*/Z0 /Z'^0 resonance |

CResonanceZRight | Handles the Z_R^0 resonance |

CRHadrons | |

CRndm | |

CRndmEngine | |

CRndmState | |

CRopeDipole | |

CRopeDipoleEnd | |

CRopeFragPars | |

CRopewalk | |

CRopewalkShover | Interface to RopeWalk via an ShoverBase object |

CRotBstMatrix | |

CSetLHEDecayProductHook | |

CSettings | |

CSetupContainers | |

CShowerModel | |

CSigma0AB2AB | A derived class for elastic scattering A B -> A B |

CSigma0AB2AX | A derived class for single diffractive scattering A B -> A X |

CSigma0AB2AXB | A derived class for central diffractive scattering A B -> A X B |

CSigma0AB2XB | A derived class for single diffractive scattering A B -> X B |

CSigma0AB2XX | A derived class for double diffractive scattering A B -> X X |

CSigma0nonDiffractive | A derived class for minimum-bias (inelastic, nondiffractive) events |

CSigma0Process | |

CSigma1ffbar2gmZ | A derived class for f fbar -> gamma*/Z0 |

CSigma1ffbar2gmZZprime | A derived class for f fbar -> gamma*/Z0/Z'0 |

CSigma1ffbar2GravitonStar | A derived class for f fbar -> G^* (excited graviton state) |

CSigma1ffbar2H | A derived class for f fbar -> H0 (SM), H1, H2 or A3 (BSM) |

CSigma1ffbar2Hchg | A derived class for f fbar' -> H+- |

CSigma1ffbar2Rhorizontal | A derived class for f fbar' -> R^0 (horizontal gauge boson) |

CSigma1ffbar2W | A derived class for f fbar' -> W+- |

CSigma1ffbar2Wprime | A derived class for f fbar' -> W'+- |

CSigma1ffbar2WRight | A derived class for f fbar' -> W_R^+- (righthanded gauge boson) |

CSigma1ffbar2Zp2XX | A derived class for f fbar' -> Zprime -> X X. (Zprime a.k.a. DMmed(s=1).) |

CSigma1ffbar2ZRight | A derived class for f fbar -> Z_R^0 (righthanded gauge boson) |

CSigma1ffbar2Zv | |

CSigma1ffbarZprimeWprime | |

CSigma1gg2GravitonStar | A derived class for g g -> G^* (excited graviton state) |

CSigma1gg2H | A derived class for g g -> H0 (SM), H1, H2 or A3 (BSM) |

CSigma1gg2S2XX | |

CSigma1gmgm2H | A derived class for gamma gamma -> H0 (SM Higgs), H1, H2 or A3 (BSM Higgs) |

CSigma1lgm2lStar | A derived class for l gamma -> l^* (excited lepton state) |

CSigma1ll2Hchgchg | A derived class for l l -> H_L^++– or H_R^++– (doubly charged Higgs) |

CSigma1Process | |

CSigma1qg2qStar | A derived class for q g -> q^* (excited quark state) |

CSigma1ql2LeptoQuark | A derived class for q l -> LQ (leptoquark) |

CSigma1qq2antisquark | |

CSigma1qqbar2KKgluonStar | A derived class for q qbar -> g^*/KK-gluon^* (excited kk-gluon state) |

CSigma2ff2fftgmZ | A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange |

CSigma2ff2fftW | A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange |

CSigma2ffbar2A3H12 | A derived class for f fbar -> A0(H_3) h0(H_1) or A0(H_3) H0(H_2) |

CSigma2ffbar2ffbarsgm | |

CSigma2ffbar2ffbarsgmZ | A derived class for f fbar -> gamma*/Z0 -> f' fbar', summed over light f |

CSigma2ffbar2FFbarsgmZ | |

CSigma2ffbar2ffbarsW | A derived class for f_1 fbar_2 -> W+- -> f_3 fbar_4, summed over light f |

CSigma2ffbar2FfbarsW | |

CSigma2ffbar2fGfGbar | |

CSigma2ffbar2gammagamma | A derived class for f fbar -> gamma gamma |

CSigma2ffbar2gmZgm | A derived class for f fbar' -> gamma*/Z0 gamma |

CSigma2ffbar2gmZgmZ | A derived class for f fbar -> gamma*/Z0 gamma*/Z0 |

CSigma2ffbar2HchgchgHchgchg | A derived class for f fbar -> H_(L/R)^++ H_(L/R)^– (doubly charged Higgs) |

CSigma2ffbar2HchgH12 | A derived class for f fbar -> H+- h0(H_1) or H+- H0(H_2) |

CSigma2ffbar2HposHneg | A derived class for f fbar -> H+ H- |

CSigma2ffbar2HW | |

CSigma2ffbar2HZ | |

CSigma2ffbar2LEDgammagamma | |

CSigma2ffbar2LEDllbar | |

CSigma2ffbar2LEDUnparticlegamma | |

CSigma2ffbar2LEDUnparticleZ | |

CSigma2ffbar2TEVffbar | |

CSigma2ffbar2Wgm | A derived class for f fbar' -> W+- gamma |

CSigma2ffbar2WW | A derived class for f fbar -> W+ W- |

CSigma2ffbar2ZpH | A derived class for f fbar' -> Zprime H, Zprime -> X X |

CSigma2ffbar2ZW | A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.) |

CSigma2ffbargmZggm | An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations |

CSigma2ffbargmZWgmZW | An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+ |

CSigma2ffbarWggm | An intermediate class for f fbar -> W+- g/gamma and permutations |

CSigma2fgm2gmZf | A derived class for f gamma -> gamma*/Z0 f |

CSigma2fgm2Wf | A derived class for f gamma -> W+- f' |

CSigma2gg2gammagamma | A derived class for g g -> gamma gamma |

CSigma2gg2gg | A derived class for g g -> g g |

CSigma2gg2ggamma | A derived class for g g -> g gamma |

CSigma2gg2gluinogluino | A derived class for g g -> gluino gluino |

CSigma2gg2GravitonStarg | A derived class for g g -> G^* g (excited graviton state) |

CSigma2gg2Hglt | |

CSigma2gg2LEDgammagamma | |

CSigma2gg2LEDgg | A derived class for g g -> (LED G*) -> g g |

CSigma2gg2LEDllbar | |

CSigma2gg2LEDqqbar | A derived class for g g -> (LED G*) -> q qbar |

CSigma2gg2LEDUnparticleg | |

CSigma2gg2LQLQbar | A derived class for g g -> LQ LQbar (leptoquark) |

CSigma2gg2qGqGbar | A derived class for g g -> qG qGbar (generic quark of spin 0, 1/2 or 1) |

CSigma2gg2qqbar | A derived class for g g -> q qbar (q = u, d, s, i.e. almost massless) |

CSigma2gg2QQbar | A derived class for g g -> Q Qbar (Q = c, b or t) |

CSigma2gg2QQbar3DJ1g | A derived class for g g -> QQbar[3DJ(1)] g (Q = c or b) |

CSigma2gg2QQbar3PJ1g | A derived class for g g -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2) |

CSigma2gg2QQbar3S11g | A derived class for g g -> QQbar[3S1(1)] g (Q = c or b) |

CSigma2gg2QQbar3S11gm | A derived class for g g -> QQbar[3S1(1)] gamma (Q = c or b) |

CSigma2gg2QQbar3S11QQbar3S11 | A derived class for g g -> QQbar[3S1(1)] QQbar[3S1(1)] (Q = c or b) |

CSigma2gg2QQbarX8g | A derived class for g g -> QQbar[X(8)] g (Q = c or b, X = 3S1, 1S0 or 3PJ) |

CSigma2gg2Sg2XXj | |

CSigma2gg2squarkantisquark | A derived class for g g -> ~q ~q* |

CSigma2ggm2qqbar | A derived class for g gamma -> q qbar (q = u, d, s, c, b) |

CSigma2gmgm2ffbar | A derived class for gamma gamma -> f fbar |

CSigma2lgm2Hchgchgl | A derived class for l- gamma -> H_(L/R)^– l+ (doubly charged Higgs) |

CSigma2Process | |

CSigma2QCffbar2llbar | |

CSigma2QCqq2qq | |

CSigma2QCqqbar2qqbar | |

CSigma2qg2charsquark | A derived class for q g -> chargino_i squark_j (incl cc) |

CSigma2qg2chi0squark | A derived class for q g -> neutralino_i squark_j (and cc) |

CSigma2qg2gmZq | A derived class for q g -> gamma*/Z0 q |

CSigma2qg2GravitonStarq | A derived class for q g -> G^* q (excited graviton state) |

CSigma2qg2Hchgq | A derived class for q g -> H+- q' |

CSigma2qg2Hq | |

CSigma2qg2Hqlt | |

CSigma2qg2LEDqg | |

CSigma2qg2LEDUnparticleq | |

CSigma2qg2LeptoQuarkl | A derived class for q g -> LQ l (leptoquark) |

CSigma2qg2qg | |

CSigma2qg2qgamma | |

CSigma2qg2QQbar3PJ1q | A derived class for q g -> QQbar[3PJ(1)] q (Q = c or b, J = 0, 1 or 2) |

CSigma2qg2QQbarX8q | A derived class for q g -> QQbar[X(8)] q (Q = c or b, X = 3S1, 1S0 or 3PJ) |

CSigma2qg2Sq2XXj | |

CSigma2qg2squarkgluino | A derived class for q g -> ~q ~g |

CSigma2qg2Wq | A derived class for q g -> W+- q' |

CSigma2qg2Zpq2XXj | |

CSigma2qgm2qg | |

CSigma2qgm2qgm | |

CSigma2qq2LEDqq | A derived class for q q(bar)' -> (LED G*) -> q q(bar)' |

CSigma2qq2qq | |

CSigma2qq2QqtW | |

CSigma2qq2qStarq | A derived class for q q' -> q^* q' (excited quark state) |

CSigma2qq2squarksquark | A derived class for q q' -> ~q_i ~q_j |

CSigma2qqbar2charchar | A derived class for q qbar -> chargino+_i chargino-_j |

CSigma2qqbar2charchi0 | A derived class for q qbar -> neutralino_i chargino_j |

CSigma2qqbar2chargluino | A derived class for q qbar -> neutralino_i chargino_j |

CSigma2qqbar2chi0chi0 | A derived class for q qbar -> neutralino_i neutralino_j |

CSigma2qqbar2chi0gluino | A derived class for q qbar -> neutralino_i gluino |

CSigma2qqbar2DY | |

CSigma2qqbar2gg | A derived class for q qbar -> g g |

CSigma2qqbar2ggamma | A derived class for q qbar -> g gamma |

CSigma2qqbar2gluinogluino | A derived class for q qbar -> gluino gluino |

CSigma2qqbar2gmZg | A derived class for q qbar -> gamma*/Z0 g |

CSigma2qqbar2GravitonStarg | A derived class for q qbar -> G^* g (excited graviton state) |

CSigma2qqbar2Hglt | |

CSigma2qqbar2LEDgg | A derived class for q qbar -> (LED G*) -> g g |

CSigma2qqbar2LEDqqbarNew | A derived class for q qbar -> (LED G*) -> q' qbar' |

CSigma2qqbar2LEDUnparticleg | |

CSigma2qqbar2LQLQbar | A derived class for q qbar -> LQ LQbar (leptoquark) |

CSigma2qqbar2lStarlbar | A derived class for q qbar -> l^* lbar (excited lepton state) |

CSigma2qqbar2lStarlStarBar | |

CSigma2qqbar2qGqGbar | A derived class for q qbar -> qG qGbar (generic quark of spin 0, 1/2 or 1) |

CSigma2qqbar2QQbar | A derived class for q qbar -> Q Qbar (Q = c, b or t) |

CSigma2qqbar2QQbar3PJ1g | A derived class for q qbar -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2) |

CSigma2qqbar2QQbar3S11QQbar3S11 | A derived class for q qbar -> QQbar[3S1(1)] QQbar[3S1(1)] (Q = c or b) |

CSigma2qqbar2qqbarNew | A derived class for q qbar -> q' qbar' |

CSigma2qqbar2QQbarX8g | |

CSigma2qqbar2sleptonantislepton | A derived class for q qbar' -> ~q_i ~q*_j |

CSigma2qqbar2squarkantisquark | A derived class for q qbar' -> ~q_i ~q*_j |

CSigma2qqbar2Wg | A derived class for q qbar' -> W+- g |

CSigma2qqbar2Zpg2XXj | |

CSigma2SUSY | An intermediate class for SUSY 2 -> 2 with nontrivial decay angles |

CSigma3ff2HchgchgfftWW | A derived class for f_1 f_2 -> H_(L/R)^++– f_3 f_4 (W+- W+- fusion) |

CSigma3ff2HfftWW | |

CSigma3ff2HfftZZ | |

CSigma3gg2ggg | A derived class for g g -> g g g |

CSigma3gg2HQQbar | |

CSigma3gg2qqbarg | |

CSigma3Process | |

CSigma3qg2qgg | |

CSigma3qg2qqqbarDiff | |

CSigma3qg2qqqbarSame | |

CSigma3qq2qqgDiff | A derived class for q q' -> q q' g |

CSigma3qq2qqgSame | A derived class for q q -> q q g |

CSigma3qqbar2ggg | A derived class for q qbar -> g g g |

CSigma3qqbar2HQQbar | |

CSigma3qqbar2qqbargDiff | |

CSigma3qqbar2qqbargSame | |

CSigmaABMST | |

CSigmaCombined | |

CSigmaLHAProcess | |

CSigmaLowEnergy | Gets cross sections for hadron-hadron collisions at low energies |

CSigmaMBR | |

CSigmaMultiparton | |

CSigmaOniaSetup | A helper class used to setup the onia processes |

CSigmaProcess | SigmaProcess is the base class for cross section calculations |

CSigmaRPP | |

CSigmaSaSDL | |

CSigmaTotal | |

CSigmaTotAux | |

CSigmaTotOwn | |

CSimpleShowerModel | |

CSimpleSpaceShower | Does spacelike showers |

CSimpleTimeShower | Does timelike showers |

CSimpleWeakShowerMEs | |

CSingleCell | |

CSingleCellJet | |

CSingleClusterJet | |

CSingleSlowJet | |

CSLHAinterface | |

CSlowJet | |

CSlowJetHook | |

CSpaceDipoleEnd | Data on radiating dipole ends, only used inside SimpleSpaceShower |

CSpaceShower | Does spacelike showers |

CSphericity | |

CSplit2g2QQbar1S01g | |

CSplit2g2QQbar3PJ1g | |

CSplit2g2QQbar3S11gg | |

CSplit2g2QQbarX8 | Splitting class for g -> QQbar[X(8)] (Q = c or b) |

CSplit2Q2QQbar1P11Q | |

CSplit2Q2QQbar1S01Q | |

CSplit2Q2QQbar3PJ1Q | |

CSplit2Q2QQbar3PJ8Q | |

CSplit2Q2QQbar3S11Q | |

CSplit2QQbarXg82QQbarX8g | |

CSplit2QQbarXq82QQbarX8g | |

CSplitOnia | |

CSplitOniaSetup | |

CStauWidths | Class StauWidths |

CStringBreaks | |

CStringEnd | |

CStringFlav | Used to select quark and hadron flavours |

CStringFragmentation | |

CStringInteractions | |

CStringLength | StringLength class. It is used to calculate the lambda measure |

CStringPT | Used to select select transverse momenta |

CStringRegion | |

CStringRepulsionBase | |

CStringSystem | |

CStringVertex | |

CStringZ | Used to sample the fragmentation function f(z) |

CSubCollision | |

►CSubCollisionModel | |

CSigEst | Internal class to report cross section estimates |

CSubCollisionSet | The SubCollisionSet gives a set of subcollisions between two nuclei |

CSuppressSmallPT | |

►CSusyLesHouches | |

CEntry | Class for SLHA data entry |

CSUSYResonanceWidths | |

CTauDecays | |

CThrust | |

CTimeDipoleEnd | Data on radiating dipole ends; only used inside SimpleTimeShower class |

CTimeShower | Does timelike showers |

CTopReconUserHooks | Class for colour reconnection models specifically aimed at top decays |

CTrialGenerator | Base class for trial generators |

CTrialGeneratorFF | Trial generator for final-final branchings |

CTrialGeneratorIF | Trial generator for initial-final branchings |

CTrialGeneratorII | Trial generator for initial-initial branchings |

CTrialGeneratorISR | |

CTrialGeneratorRF | Trial generator for resonance-final branchings |

CTrialIFConvA | A conversion trial function for initial-final, g -> qqbar |

CTrialIFGCollA | A gluon collinear trial function for initial-final |

CTrialIFGCollK | K gluon collinear trial function for initial-final sector shower |

CTrialIFSoft | Soft-eikonal trial function for initial-final |

CTrialIFSplitA | A splitting trial function for initial-final, q -> gqbar |

CTrialIFSplitK | K splitting trial function for initial-final, g -> qqbar |

CTrialIIConvA | A conversion trial function for initial-initial, g -> qqbar |

CTrialIIConvB | B conversion trial function for initial-initial, g -> qqbar |

CTrialIIGCollA | A collinear trial function for initial-initial |

CTrialIIGCollB | B collinear trial function for initial-initial |

CTrialIISoft | |

CTrialIISplitA | A splitting trial function for initial-initial, q -> gqbar |

CTrialIISplitB | B splitting trial function for initial-initial, q -> gqbar |

CTrialReconnection | TrialReconnection class |

CTrialVFSoft | |

CUserHooks | UserHooks is base class for user access to program execution |

CUserHooksVector | UserHooksVector implements a vector of UserHooks and is itself a UserHooks |

CVec4 | |

CVincia | |

CVinciaClustering | Simple struct to store information about a 3 -> 2 clustering |

CVinciaColour | |

CVinciaCommon | |

CVinciaDiagnostics | Vincia diagnostics |

CVinciaEW | Top-level class for the electroweak shower module |

CVinciaEWVetoHook | Class to do the veto for overlapping QCD/EW shower phase space |

CVinciaFSR | |

CVinciaHardProcess | Container for the hard process used in Vincia merging |

CVinciaHistory | History class for the Vincia shower |

CVinciaISR | |

CVinciaMerging | Merging wrapper class for Vincia |

CVinciaMergingHooks | Class for Vincia to perform merging |

CVinciaModule | Base class for Vincia's QED and EW shower modules |

CVinciaQED | Class for performing QED showers |

CVinciaWeights | Class for storing Vincia weights |

CWave4 | |

CWeightContainer | |

CWeightsBase | |

CWeightsFragmentation | |

CWeightsLHEF | |

CWeightsMerging | |

CWeightsShower | Purely virtual base class for shower weights |

CWeightsSimpleShower | This shows a WeightsShower example implementation for SimpleShower |

CWidthFunction | |

CWoodsSaxonModel | A general Woods-Saxon distributed nucleus |

CWord | Class for string words |

CWriter | |

CWVec | Class for vector of strings |

CxfModPrepData | |

CXMLTag | |

CZetaGenerator | Base class for zeta trial generators |

CZetaGeneratorSet | |

CZGenFFEmitColI | The final-final ColI sector emission generator |

CZGenFFEmitColK | The final-final ColK sector emission generator |

CZGenFFEmitSoft | Final-final trial generators |

CZGenFFSplit | The final-final default sector splitting generator |

CZGenIFConv | The initial-final splitting generator |

CZGenIFEmitColA | The initial-final ColI sector generator |

CZGenIFEmitColK | The initial-final ColK sector generator |

CZGenIFEmitSoft | Intial-final trial generators |

CZGenIFSplitA | The initial-final initial antenna splitting generator |

CZGenIFSplitK | The initial-final final antenna splitting generator |

CZGenIIConv | The initial-initial splitting generator |

CZGenIIEmitCol | The initial-initial ColI sector generator |

CZGenIIEmitSoft | The initial-initial trial generators |

CZGenIISplit | The initial-initial initial splitting generator |

CZGenRFEmitColK | The resonance-final ColK sector generator |

CZGenRFEmitSoft | Resonance-final trial generators |

CZGenRFEmitSoftAlt | The resonance-final default sector alternate generator |

CZGenRFSplit | The resonance-final default sector splitting generator |

►Nstd | End namespace Pythia8 |

Chash< pair< T1, T2 > > | |

CMixMaxRndm | A derived class to generate random numbers using the MixMax algorithm |

CPy8Particle | Also gives PseudoJet & JetDefinition |

CSelectorWorkerPy8 |

Generated by 1.8.11