thepeg
is hosted by
Hepforge
,
IPPP Durham
ThePEG
2.3.0
Config
Pointers.h
Go to the documentation of this file.
1
// -*- C++ -*-
2
//
3
// Pointers.h is a part of ThePEG - Toolkit for HEP Event Generation
4
// Copyright (C) 1999-2019 Leif Lonnblad
5
//
6
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
7
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
8
//
9
#ifndef ThePEG_Pointers_H
10
#define ThePEG_Pointers_H
11
31
#include "
ThePEG/Config/ThePEG.h
"
32
33
namespace
ThePEG
{
34
36
#define ThePEG_DECLARE_TEMPLATE_POINTERS(full, abbrev) \
37
\
38
typedef typename ThePEG::Ptr<full>::pointer abbrev; \
39
\
40
typedef typename ThePEG::Ptr<full>::const_pointer c ## abbrev; \
41
\
42
typedef typename ThePEG::Ptr<full>::transient_pointer t ## abbrev; \
43
\
44
typedef typename ThePEG::Ptr<full>::transient_const_pointer tc ## abbrev
45
47
#define ThePEG_DECLARE_POINTERS(full, abbrev) \
48
\
49
typedef ThePEG::Ptr<full>::pointer abbrev; \
50
\
51
typedef ThePEG::Ptr<full>::const_pointer c ## abbrev; \
52
\
53
typedef ThePEG::Ptr<full>::transient_pointer t ## abbrev; \
54
\
55
typedef ThePEG::Ptr<full>::transient_const_pointer tc ## abbrev
56
58
#define ThePEG_DECLARE_CLASS_POINTERS(full, abbrev) \
59
class full; \
60
ThePEG_DECLARE_POINTERS(full, abbrev)
61
62
ThePEG_DECLARE_CLASS_POINTERS
(
InterfacedBase
,
IBPtr
);
63
ThePEG_DECLARE_CLASS_POINTERS
(
Interfaced
,
IPtr
);
64
ThePEG_DECLARE_CLASS_POINTERS
(
ParticleData
,
PDPtr
);
65
ThePEG_DECLARE_CLASS_POINTERS
(
MatcherBase
,
PMPtr
);
66
ThePEG_DECLARE_CLASS_POINTERS
(
DecayMode
,
DMPtr
);
67
ThePEG_DECLARE_CLASS_POINTERS
(
Particle
,
PPtr
);
68
ThePEG_DECLARE_CLASS_POINTERS
(
EventGenerator
,
EGPtr
);
69
ThePEG_DECLARE_CLASS_POINTERS
(
EventHandler
,
EHPtr
);
70
ThePEG_DECLARE_CLASS_POINTERS
(
StepHandler
,
StepHdlPtr
);
71
ThePEG_DECLARE_CLASS_POINTERS
(
Hint
,
HintPtr
);
72
ThePEG_DECLARE_CLASS_POINTERS
(
HadronizationHandler
,
HadrHdlPtr
);
73
ThePEG_DECLARE_CLASS_POINTERS
(
CascadeHandler
,
CascHdlPtr
);
74
ThePEG_DECLARE_CLASS_POINTERS
(
MultipleInteractionHandler
,
MIHdlPtr
);
75
ThePEG_DECLARE_CLASS_POINTERS
(
DecayHandler
,
DecayHdlPtr
);
76
ThePEG_DECLARE_CLASS_POINTERS
(PileupHandler,
PileHdlPtr
);
77
ThePEG_DECLARE_CLASS_POINTERS
(
LuminosityFunction
,
LumiFnPtr
);
78
ThePEG_DECLARE_CLASS_POINTERS
(
PartonExtractor
,
PExtrPtr
);
79
ThePEG_DECLARE_CLASS_POINTERS
(
RandomGenerator
,
RanGenPtr
);
80
ThePEG_DECLARE_CLASS_POINTERS
(
AnalysisHandler
,
AnaPtr
);
81
ThePEG_DECLARE_CLASS_POINTERS
(
EventManipulator
,
EvtManipPtr
);
82
ThePEG_DECLARE_CLASS_POINTERS
(
Decayer
,
DecayerPtr
);
83
ThePEG_DECLARE_CLASS_POINTERS
(
Event
,
EventPtr
);
84
ThePEG_DECLARE_CLASS_POINTERS
(
Collision
,
CollPtr
);
85
ThePEG_DECLARE_CLASS_POINTERS
(
Step
,
StepPtr
);
86
ThePEG_DECLARE_CLASS_POINTERS
(
SubProcess
,
SubProPtr
);
87
ThePEG_DECLARE_CLASS_POINTERS
(
Strategy
,
StrategyPtr
);
88
ThePEG_DECLARE_CLASS_POINTERS
(
XComb
,
XCombPtr
);
89
ThePEG_DECLARE_CLASS_POINTERS
(
RemnantHandler
,
RemHPtr
);
90
ThePEG_DECLARE_CLASS_POINTERS
(
PDFBase
,
PDFPtr
);
91
ThePEG_DECLARE_CLASS_POINTERS
(
StandardModelBase
,
SMPtr
);
92
ThePEG_DECLARE_CLASS_POINTERS
(
ColourBase
,
CBPtr
);
93
ThePEG_DECLARE_CLASS_POINTERS
(
SpinInfo
,
SpinPtr
);
94
ThePEG_DECLARE_CLASS_POINTERS
(
EventInfoBase
,
EIPtr
);
95
ThePEG_DECLARE_CLASS_POINTERS
(
ReweightBase
,
ReweightPtr
);
96
ThePEG_DECLARE_CLASS_POINTERS
(
ColourLine
,
ColinePtr
);
97
ThePEG_DECLARE_POINTERS
(
Base
,
BPtr
);
98
99
// ThePEG_DECLARE_CLASS_POINTERS(,);
100
101
}
102
103
// #include "Pointers.icc"
104
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
105
// #include "Pointers.tcc"
106
#endif
107
108
#endif
/* ThePEG_Pointers_H */
ThePEG_DECLARE_CLASS_POINTERS
#define ThePEG_DECLARE_CLASS_POINTERS(full, abbrev)
This macro helps us to declare pointers and stuff to standard classes.
Definition:
Pointers.h:58
ThePEG_DECLARE_POINTERS
#define ThePEG_DECLARE_POINTERS(full, abbrev)
This macro helps us to declare pointers and stuff to standard classes.
Definition:
Pointers.h:47
ThePEG.h
This is the main config header file for ThePEG.
ThePEG::AnalysisHandler
The AnalysisHandler is the base class of all analysis objects which may be handled by the FullEventGe...
Definition:
AnalysisHandler.h:41
ThePEG::CascadeHandler
The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade model...
Definition:
CascadeHandler.h:33
ThePEG::Collision
This is the decalaration of the Collision class.
Definition:
Collision.h:34
ThePEG::ColourBase
ColourBase is the base class to be used to supply a Particle with information about its colour state.
Definition:
ColourBase.h:32
ThePEG::ColourLine
The ColourLine class represents colour lines connecting Particles.
Definition:
ColourLine.h:36
ThePEG::DecayHandler
The DecayHandler is the base class of all handlers implementing the administration of decays of unsta...
Definition:
DecayHandler.h:31
ThePEG::DecayMode
The DecayMode class describes a decay channel of a particle.
Definition:
DecayMode.h:87
ThePEG::Decayer
Decayer is an abstract base class to specify objects modelling the decay of a particle.
Definition:
Decayer.h:29
ThePEG::EventGenerator
The EventGenerator class manages a whole event generator run.
Definition:
EventGenerator.h:68
ThePEG::EventHandler
The EventHandler is the base class used to implement event handlers in ThePEG.
Definition:
EventHandler.h:63
ThePEG::EventInfoBase
EventInfoBase is a base class for information objects.
Definition:
EventInfoBase.h:27
ThePEG::EventManipulator
An object of the EventManipulator class may be assigned to a FullEventGenerator object.
Definition:
EventManipulator.h:41
ThePEG::Event
The Event class contains all Particles produced in the generation of an event.
Definition:
Event.h:37
ThePEG::HadronizationHandler
The HadronizationHandler is the base class of all handlers implementing models for hadronization of c...
Definition:
HadronizationHandler.h:30
ThePEG::Hint
Hint is a base class to be used to pass information between StepHandler s, which cannot be convayed t...
Definition:
Hint.h:48
ThePEG::InterfacedBase
InterfacedBase is the base class of all Interfaced objects to be handled by the BaseRepository class.
Definition:
InterfacedBase.h:45
ThePEG::Interfaced
The Interfaced class is derived from the InterfacedBase class adding a couple of things particular to...
Definition:
Interfaced.h:38
ThePEG::LuminosityFunction
The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment.
Definition:
LuminosityFunction.h:39
ThePEG::MatcherBase
MatcherBase is an abstract base class to be used for objects representing groups of ParticleData obje...
Definition:
MatcherBase.h:29
ThePEG::MultipleInteractionHandler
The MultipleInteractionHandler is the base class of all handlers implementing models for multiple int...
Definition:
MultipleInteractionHandler.h:29
ThePEG::PDFBase
PDFBase is the base class for implementing parton density functions for particles with sub-structure.
Definition:
PDFBase.h:40
ThePEG::ParticleData
ParticleData inherits from InterfacedBase and represents the properties of a particle type.
Definition:
ParticleData.h:36
ThePEG::Particle
The Particle class is used to describe an instance of a particle.
Definition:
Particle.h:83
ThePEG::PartonExtractor
The PartonExtractor is a base class defining the interface to objects responsible for extracting part...
Definition:
PartonExtractor.h:44
ThePEG::Pointer::RCPtr
RCPtr is a reference counted (smart) pointer.
Definition:
RCPtr.h:60
ThePEG::RandomGenerator
RandomGenerator is an interface to the CLHEP::RandomEngine classes.
Definition:
RandomGenerator.h:37
ThePEG::RemnantHandler
RemnantHandler is an abstract base class for implementing classes used to generate remnants when part...
Definition:
RemnantHandler.h:31
ThePEG::ReweightBase
The ReweightBase class is the base class of all objects representing external biases to matrix elemen...
Definition:
ReweightBase.h:39
ThePEG::SpinInfo
The SpinInfo is the base class for the spin information for the spin correlation algorithm.
Definition:
SpinInfo.h:58
ThePEG::StandardModelBase
StandardModelBase is used to handle standard model parameters in an EventGenerator.
Definition:
StandardModelBase.h:38
ThePEG::StepHandler
StepHandler is the base class for implementing any model for a step in the event generation chain.
Definition:
StepHandler.h:41
ThePEG::Step
The Step class contains information of all particles present after certain step in the event generati...
Definition:
Step.h:34
ThePEG::Strategy
The Strategy class represents a general strategy to be assigned to an EventGenerator.
Definition:
Strategy.h:41
ThePEG::SubProcess
A SubProcess object represents a hard sub-process in a collision.
Definition:
SubProcess.h:33
ThePEG::XComb
The XComb class stores all information about the generation of a hard sub-proces for a given pair of ...
Definition:
XComb.h:43
ThePEG
This is the main namespace within which all identifiers in ThePEG are declared.
Definition:
FactoryBase.h:28
ThePEG::Base
Define the base class from which all (polymorphic) classes in ThePEG are derived.
Definition:
ThePEG.h:54
Generated on Thu Jun 20 2024 14:47:00 for ThePEG by
1.9.6