thepeg
is hosted by
Hepforge
,
IPPP Durham
ThePEG
2.3.0
Handlers
EventHandler.h
1
// -*- C++ -*-
2
//
3
// EventHandler.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_EventHandler_H
10
#define ThePEG_EventHandler_H
11
// This is the declaration of the EventHandler class.
12
13
#include "ThePEG/Handlers/HandlerBase.h"
14
#include "ThePEG/Handlers/HandlerGroup.h"
15
#include "ThePEG/Handlers/StepHandler.h"
16
#include "ThePEG/EventRecord/Event.h"
17
#include "ThePEG/Handlers/LastXCombInfo.h"
18
#include "ThePEG/Handlers/SubProcessHandler.fh"
19
#include "ThePEG/Cuts/Cuts.fh"
20
#include "EventHandler.fh"
21
22
namespace
ThePEG
{
23
63
class
EventHandler
:
public
HandlerBase
,
public
LastXCombInfo
<> {
64
65
public
:
66
68
enum
ConsistencyLevel
{
69
clNoCheck
,
70
clCollision
,
71
clStep
,
72
clPrintCollision
,
73
clPrintStep
74
};
75
77
typedef
vector<HandlerGroupBase *>
GroupVector
;
78
79
public
:
80
86
EventHandler
(
bool
warnincomplete =
true
);
87
91
EventHandler
(
const
EventHandler
&);
92
96
virtual
~EventHandler
();
98
99
public
:
100
107
virtual
void
initialize
();
108
115
virtual
EventPtr
generateEvent
();
116
122
tEventPtr
generateEvent
(
tEventPtr
e);
123
129
tEventPtr
generateEvent
(
tStepPtr
s);
130
135
virtual
EventPtr
continueEvent
();
136
141
tCollPtr
continueCollision
();
142
146
void
clearEvent
();
147
151
virtual
void
select
(
tXCombPtr
newXComb);
152
157
virtual
bool
empty
()
const
;
158
163
virtual
void
statistics
(ostream &)
const
;
164
173
virtual
CrossSection
histogramScale
()
const
;
174
182
virtual
CrossSection
integratedXSec
()
const
;
183
191
virtual
CrossSection
integratedXSecErr
()
const
;
193
200
long
maxLoop
()
const
{
return
theMaxLoop
; }
201
206
const
cPDPair
&
incoming
()
const
{
return
theIncoming
; }
207
211
const
LuminosityFunction
&
lumiFn
()
const
{
return
*
theLumiFn
; }
212
216
tcLumiFnPtr
lumiFnPtr
()
const
{
return
theLumiFn
; }
217
221
tLumiFnPtr
lumiFnPtr
(){
return
theLumiFn
; }
222
226
tCutsPtr
cuts
()
const
{
return
theCuts
; }
227
232
tPExtrPtr
partonExtractor
()
const
{
return
thePartonExtractor
; }
233
238
tCascHdlPtr
cascadeHandler
()
const
;
239
244
tCascHdlPtr
CKKWHandler
()
const
{
return
cascadeHandler
(); }
245
249
tEventPtr
currentEvent
()
const
{
return
theCurrentEvent
; }
250
254
tCollPtr
currentCollision
()
const
{
return
theCurrentCollision
; }
255
259
tStepPtr
currentStep
()
const
{
return
theCurrentStep
; }
260
264
bool
weighted
()
const
{
return
weightedEvents
; }
265
271
int
statLevel
()
const
{
return
theStatLevel
; }
272
277
ConsistencyLevel
consistencyLevel
()
const
{
return
theConsistencyLevel
; }
278
284
double
consistencyEpsilon
()
const
{
return
theConsistencyEpsilon
; }
285
287
294
void
performStep
(
tStepHdlPtr
handler,
tHintPtr
hint);
295
300
void
addStep
(
Group::Level
,
Group::Handler
,
301
tStepHdlPtr
=
tStepHdlPtr
(),
tHintPtr
=
tHintPtr
());
302
308
tStepPtr
newStep
(
tcStepHdlPtr
sh) {
309
currentStep
(
currentCollision
()->
newStep
(sh));
310
return
currentStep
();
311
}
312
316
void
popStep
() {
317
currentCollision
()->popStep();
318
currentStep
(
currentCollision
()->finalStep());
319
}
320
324
virtual
void
initGroups
();
325
329
void
currentEvent
(
tEventPtr
e) {
theCurrentEvent
= e; }
330
334
void
currentCollision
(
tCollPtr
c) {
theCurrentCollision
= c; }
335
339
void
currentStep
(
tStepPtr
s) {
theCurrentStep
= s; }
340
344
tStepHdlPtr
currentStepHandler
()
const
{
return
theCurrentStepHandler
; }
345
349
void
currentStepHandler
(
tStepHdlPtr
sh) {
theCurrentStepHandler
= sh; }
350
354
void
throwCurrent
();
355
359
virtual
void
clean
();
360
366
virtual
void
checkConsistency
()
const
;
367
369
370
public
:
371
378
void
persistentOutput
(
PersistentOStream
& os)
const
;
379
385
void
persistentInput
(
PersistentIStream
& is,
int
version);
387
391
static
void
Init
();
392
393
protected
:
394
401
virtual
IBPtr
clone
()
const
;
402
407
virtual
IBPtr
fullclone
()
const
;
409
416
virtual
void
dofinish
() {
417
clean
();
418
HandlerBase::dofinish
();
419
}
420
430
virtual
void
rebind
(
const
TranslationMap
& trans);
431
437
virtual
IVector
getReferences
();
439
440
441
protected
:
442
446
LuminosityFunction
&
lumiFn
() {
return
*
theLumiFn
; }
447
451
void
setupGroups
();
452
456
GroupVector
&
groups
() {
return
theGroups
; }
457
461
const
GroupVector
&
groups
()
const
{
return
theGroups
; }
462
463
464
protected
:
465
469
void
lumiFn
(
LumiFnPtr
);
470
471
private
:
472
477
long
theMaxLoop
;
478
482
bool
weightedEvents
;
483
488
int
theStatLevel
;
489
494
ConsistencyLevel
theConsistencyLevel
;
495
501
double
theConsistencyEpsilon
;
502
506
LumiFnPtr
theLumiFn
;
507
512
CutsPtr
theCuts
;
513
518
PExtrPtr
thePartonExtractor
;
519
523
HandlerGroup<SubProcessHandler>
theSubprocessGroup
;
524
528
HandlerGroup<CascadeHandler>
theCascadeGroup
;
529
533
HandlerGroup<MultipleInteractionHandler>
theMultiGroup
;
534
538
HandlerGroup<HadronizationHandler>
theHadronizationGroup
;
539
543
HandlerGroup<DecayHandler>
theDecayGroup
;
544
548
GroupVector
theGroups
;
549
553
EventPtr
theCurrentEvent
;
554
558
CollPtr
theCurrentCollision
;
559
563
StepPtr
theCurrentStep
;
564
568
StepHdlPtr
theCurrentStepHandler
;
569
570
protected
:
571
575
HandlerGroup<SubProcessHandler>
optSubprocessGroup
;
576
580
HandlerGroup<CascadeHandler>
optCascadeGroup
;
581
585
HandlerGroup<MultipleInteractionHandler>
optMultiGroup
;
586
590
HandlerGroup<HadronizationHandler>
optHadronizationGroup
;
591
595
HandlerGroup<DecayHandler>
optDecayGroup
;
596
597
protected
:
598
602
GroupVector
optGroups
;
603
604
protected
:
605
609
bool
warnIncomplete
;
610
615
cPDPair
theIncoming
;
616
617
protected
:
618
624
class
EventHandlerStepError:
public
Exception
{};
625
630
class
EventHandlerHistError:
public
Exception
{};
631
636
class
EventHandlerIncompleteError:
public
Exception {};
637
640
struct
EventLoopException:
public
Exception {
642
EventLoopException(
const
EventHandler &);
643
};
644
649
struct
LumiFuncError:
public
Exception {};
650
654
struct
ConsistencyException:
public
Exception {};
655
658
private
:
659
660
ThePEG_DECLARE_PREPOST_GROUP(
SubProcessHandler
,Post);
661
ThePEG_DECLARE_GROUPINTERFACE(
CascadeHandler
,
CascHdlPtr
);
662
ThePEG_DECLARE_GROUPINTERFACE(
MultipleInteractionHandler
,
MIHdlPtr
);
663
ThePEG_DECLARE_GROUPINTERFACE(
HadronizationHandler
,
HadrHdlPtr
);
664
ThePEG_DECLARE_GROUPINTERFACE(
DecayHandler
,
DecayHdlPtr
);
665
666
ThePEG_DECLARE_CLASS_DESCRIPTION(
EventHandler
);
667
671
EventHandler
&
operator=
(
const
EventHandler
&) =
delete
;
672
673
};
674
676
ThePEG_DECLARE_CLASS_TRAITS(
EventHandler
,
HandlerBase
);
679
}
680
681
#endif
/* ThePEG_EventHandler_H */
ThePEG::CascadeHandler
The CascadeHandler is the base class of all handlers implementing perturbative partonic cascade model...
Definition:
CascadeHandler.h:33
ThePEG::DecayHandler
The DecayHandler is the base class of all handlers implementing the administration of decays of unsta...
Definition:
DecayHandler.h:31
ThePEG::EventHandler
The EventHandler is the base class used to implement event handlers in ThePEG.
Definition:
EventHandler.h:63
ThePEG::EventHandler::theConsistencyLevel
ConsistencyLevel theConsistencyLevel
Determines how often the event handler should check for charge and energy-momentum conservation.
Definition:
EventHandler.h:494
ThePEG::EventHandler::currentStep
tStepPtr currentStep() const
Get current step.
Definition:
EventHandler.h:259
ThePEG::EventHandler::throwCurrent
void throwCurrent()
Throw away the current event/collision.
ThePEG::EventHandler::empty
virtual bool empty() const
Returns true if there are no step handlers left to apply to the current event;.
ThePEG::EventHandler::integratedXSec
virtual CrossSection integratedXSec() const
The total integrated cross section of the processes generated in this run.
ThePEG::EventHandler::optDecayGroup
HandlerGroup< DecayHandler > optDecayGroup
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:595
ThePEG::EventHandler::theCurrentStepHandler
StepHdlPtr theCurrentStepHandler
The current StepHandler.
Definition:
EventHandler.h:568
ThePEG::EventHandler::continueEvent
virtual EventPtr continueEvent()
Continue generating an event if the generation has been stopped before finishing.
ThePEG::EventHandler::optGroups
GroupVector optGroups
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:602
ThePEG::EventHandler::theConsistencyEpsilon
double theConsistencyEpsilon
The maximum fraction of the total invariant mass of a collision that any of the components of the sum...
Definition:
EventHandler.h:501
ThePEG::EventHandler::~EventHandler
virtual ~EventHandler()
Destructor.
ThePEG::EventHandler::Init
static void Init()
Standard Init function used to initialize the interface.
ThePEG::EventHandler::theHadronizationGroup
HandlerGroup< HadronizationHandler > theHadronizationGroup
The HadronizationHandler group.
Definition:
EventHandler.h:538
ThePEG::EventHandler::addStep
void addStep(Group::Level, Group::Handler, tStepHdlPtr=tStepHdlPtr(), tHintPtr=tHintPtr())
In the curresnt list of step handlers to go through, add another step handler and/or hint.
ThePEG::EventHandler::clean
virtual void clean()
Throw away the last generated event before generating a new one.
ThePEG::EventHandler::lumiFn
void lumiFn(LumiFnPtr)
Set the luminosity function.
ThePEG::EventHandler::popStep
void popStep()
Remove the last step.
Definition:
EventHandler.h:316
ThePEG::EventHandler::fullclone
virtual IBPtr fullclone() const
Make a clone of this object, possibly modifying the cloned object to make it sane.
ThePEG::EventHandler::persistentInput
void persistentInput(PersistentIStream &is, int version)
Function used to read in object persistently.
ThePEG::EventHandler::cuts
tCutsPtr cuts() const
The kinematical cuts to used by subclasses which do not provide their own.
Definition:
EventHandler.h:226
ThePEG::EventHandler::statLevel
int statLevel() const
The level of statistics.
Definition:
EventHandler.h:271
ThePEG::EventHandler::initGroups
virtual void initGroups()
Initialize the groups of step handlers.
ThePEG::EventHandler::theIncoming
cPDPair theIncoming
The pair of incoming particle types.
Definition:
EventHandler.h:615
ThePEG::EventHandler::currentStep
void currentStep(tStepPtr s)
Set current step.
Definition:
EventHandler.h:339
ThePEG::EventHandler::CKKWHandler
tCascHdlPtr CKKWHandler() const
Return a pointer (possibly null) to the assigned main CascadeHandler to be used as CKKW-reweighter.
Definition:
EventHandler.h:244
ThePEG::EventHandler::rebind
virtual void rebind(const TranslationMap &trans)
Rebind pointer to other Interfaced objects.
ThePEG::EventHandler::dofinish
virtual void dofinish()
Finalize this object.
Definition:
EventHandler.h:416
ThePEG::EventHandler::optCascadeGroup
HandlerGroup< CascadeHandler > optCascadeGroup
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:580
ThePEG::EventHandler::theGroups
GroupVector theGroups
The step handler groups.
Definition:
EventHandler.h:548
ThePEG::EventHandler::lumiFn
LuminosityFunction & lumiFn()
Access to the luminosity function.
Definition:
EventHandler.h:446
ThePEG::EventHandler::weightedEvents
bool weightedEvents
True if this event handler should produce weightes events.
Definition:
EventHandler.h:482
ThePEG::EventHandler::continueCollision
tCollPtr continueCollision()
Continue the generation of a Collision.
ThePEG::EventHandler::generateEvent
virtual EventPtr generateEvent()
Generate an event.
ThePEG::EventHandler::theSubprocessGroup
HandlerGroup< SubProcessHandler > theSubprocessGroup
The SubProcessHandler group.
Definition:
EventHandler.h:523
ThePEG::EventHandler::theCurrentStep
StepPtr theCurrentStep
The current Step.
Definition:
EventHandler.h:563
ThePEG::EventHandler::checkConsistency
virtual void checkConsistency() const
Check that the charge and energy-momentum in the last step of the current collision is consistent wit...
ThePEG::EventHandler::currentEvent
void currentEvent(tEventPtr e)
Set current event.
Definition:
EventHandler.h:329
ThePEG::EventHandler::initialize
virtual void initialize()
Initialize this event handler and all related objects needed to generate events.
ThePEG::EventHandler::weighted
bool weighted() const
Return true if this event handler should produce weightes events.
Definition:
EventHandler.h:264
ThePEG::EventHandler::maxLoop
long maxLoop() const
Return the maximum number attemts allowed to select a sub-process for each event.
Definition:
EventHandler.h:200
ThePEG::EventHandler::currentStepHandler
void currentStepHandler(tStepHdlPtr sh)
Set current StepHandler.
Definition:
EventHandler.h:349
ThePEG::EventHandler::statistics
virtual void statistics(ostream &) const
Write out accumulated statistics about intergrated cross sections and stuff.
ThePEG::EventHandler::groups
const GroupVector & groups() const
Access the step handler groups.
Definition:
EventHandler.h:461
ThePEG::EventHandler::theMaxLoop
long theMaxLoop
The maximum number of attempts to select a sub-process allowed per event.
Definition:
EventHandler.h:477
ThePEG::EventHandler::histogramScale
virtual CrossSection histogramScale() const
Histogram scale.
ThePEG::EventHandler::integratedXSecErr
virtual CrossSection integratedXSecErr() const
The estimated error in the total integrated cross section of the processes generated in this run.
ThePEG::EventHandler::consistencyEpsilon
double consistencyEpsilon() const
The maximum fraction of the total invariant mass of a collision that any of the components of the sum...
Definition:
EventHandler.h:284
ThePEG::EventHandler::newStep
tStepPtr newStep(tcStepHdlPtr sh)
Create a new step and make it current.
Definition:
EventHandler.h:308
ThePEG::EventHandler::lumiFnPtr
tLumiFnPtr lumiFnPtr()
Access to the luminosity function.
Definition:
EventHandler.h:221
ThePEG::EventHandler::theCurrentCollision
CollPtr theCurrentCollision
The current Collision.
Definition:
EventHandler.h:558
ThePEG::EventHandler::lumiFn
const LuminosityFunction & lumiFn() const
Access the luminosity function.
Definition:
EventHandler.h:211
ThePEG::EventHandler::clearEvent
void clearEvent()
Clear all step handlers, making the handler ready for a new event.
ThePEG::EventHandler::warnIncomplete
bool warnIncomplete
Emit warning that this EventHandler is incomplete.
Definition:
EventHandler.h:609
ThePEG::EventHandler::clone
virtual IBPtr clone() const
Make a simple clone of this object.
ThePEG::EventHandler::currentCollision
void currentCollision(tCollPtr c)
Set current collision.
Definition:
EventHandler.h:334
ThePEG::EventHandler::theStatLevel
int theStatLevel
Controlls the amount of statistics written out after each run to the EventGenerators ....
Definition:
EventHandler.h:488
ThePEG::EventHandler::EventHandler
EventHandler(bool warnincomplete=true)
Default constructor.
ThePEG::EventHandler::currentCollision
tCollPtr currentCollision() const
Get current collision.
Definition:
EventHandler.h:254
ThePEG::EventHandler::theCuts
CutsPtr theCuts
The kinematical cuts to used by subclasses which do not provide their own.
Definition:
EventHandler.h:512
ThePEG::EventHandler::currentEvent
tEventPtr currentEvent() const
Gget current event.
Definition:
EventHandler.h:249
ThePEG::EventHandler::optHadronizationGroup
HandlerGroup< HadronizationHandler > optHadronizationGroup
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:590
ThePEG::EventHandler::select
virtual void select(tXCombPtr newXComb)
Change the XComb object.
ThePEG::EventHandler::currentStepHandler
tStepHdlPtr currentStepHandler() const
Get current StepHandler.
Definition:
EventHandler.h:344
ThePEG::EventHandler::lumiFnPtr
tcLumiFnPtr lumiFnPtr() const
Access the luminosity function.
Definition:
EventHandler.h:216
ThePEG::EventHandler::cascadeHandler
tCascHdlPtr cascadeHandler() const
Return a pointer (possibly null) to the assigned main CascadeHandler.
ThePEG::EventHandler::getReferences
virtual IVector getReferences()
Return a vector of all pointers to Interfaced objects used in this object.
ThePEG::EventHandler::consistencyLevel
ConsistencyLevel consistencyLevel() const
Determines how often the event handler should check for charge and energy-momentum conservation.
Definition:
EventHandler.h:277
ThePEG::EventHandler::theCascadeGroup
HandlerGroup< CascadeHandler > theCascadeGroup
The CascadeHandler group.
Definition:
EventHandler.h:528
ThePEG::EventHandler::performStep
void performStep(tStepHdlPtr handler, tHintPtr hint)
Perform a given step using a handler and a hint.
ThePEG::EventHandler::optSubprocessGroup
HandlerGroup< SubProcessHandler > optSubprocessGroup
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:575
ThePEG::EventHandler::thePartonExtractor
PExtrPtr thePartonExtractor
A PartonExtractor object to be used by sub classes which do not provide their own.
Definition:
EventHandler.h:518
ThePEG::EventHandler::persistentOutput
void persistentOutput(PersistentOStream &os) const
Function used to write out object persistently.
ThePEG::EventHandler::theLumiFn
LumiFnPtr theLumiFn
Pointer to a luminosity function tobe used by subclasses.
Definition:
EventHandler.h:506
ThePEG::EventHandler::partonExtractor
tPExtrPtr partonExtractor() const
A PartonExtractor object to be used by sub classes which do not provide their own.
Definition:
EventHandler.h:232
ThePEG::EventHandler::optMultiGroup
HandlerGroup< MultipleInteractionHandler > optMultiGroup
Utility object to facilitate default selection of step handlers.
Definition:
EventHandler.h:585
ThePEG::EventHandler::generateEvent
tEventPtr generateEvent(tEventPtr e)
Generate an Event, where the initial state is supplied from the outside.
ThePEG::EventHandler::groups
GroupVector & groups()
Access the step handler groups.
Definition:
EventHandler.h:456
ThePEG::EventHandler::generateEvent
tEventPtr generateEvent(tStepPtr s)
Generate an Event, where the initial state is supplied as a single step from the outside.
ThePEG::EventHandler::EventHandler
EventHandler(const EventHandler &)
Copy-constructor.
ThePEG::EventHandler::theDecayGroup
HandlerGroup< DecayHandler > theDecayGroup
The DecayHandler group.
Definition:
EventHandler.h:543
ThePEG::EventHandler::ConsistencyLevel
ConsistencyLevel
Enumerate the different levels of consistency checking.
Definition:
EventHandler.h:68
ThePEG::EventHandler::clStep
@ clStep
Check every Step.
Definition:
EventHandler.h:71
ThePEG::EventHandler::clCollision
@ clCollision
Check every Collision.
Definition:
EventHandler.h:70
ThePEG::EventHandler::clPrintStep
@ clPrintStep
Check every Step.
Definition:
EventHandler.h:73
ThePEG::EventHandler::clPrintCollision
@ clPrintCollision
Check every Collision.
Definition:
EventHandler.h:72
ThePEG::EventHandler::clNoCheck
@ clNoCheck
Do not perform consistency checks.
Definition:
EventHandler.h:69
ThePEG::EventHandler::setupGroups
void setupGroups()
Setup the step handler groups.
ThePEG::EventHandler::operator=
EventHandler & operator=(const EventHandler &)=delete
Private and non-existent assignment operator.
ThePEG::EventHandler::theMultiGroup
HandlerGroup< MultipleInteractionHandler > theMultiGroup
The MultipleInteractionHandler group.
Definition:
EventHandler.h:533
ThePEG::EventHandler::incoming
const cPDPair & incoming() const
The pair of incoming particle types.
Definition:
EventHandler.h:206
ThePEG::EventHandler::theCurrentEvent
EventPtr theCurrentEvent
The current Event.
Definition:
EventHandler.h:553
ThePEG::EventHandler::GroupVector
vector< HandlerGroupBase * > GroupVector
A vector of HandlerGroups.
Definition:
EventHandler.h:77
ThePEG::Exception
Exception is the base class for all exceptions to be used in ThePEG.
Definition:
Exception.h:44
ThePEG::HadronizationHandler
The HadronizationHandler is the base class of all handlers implementing models for hadronization of c...
Definition:
HadronizationHandler.h:30
ThePEG::HandlerBase
HandlerBase is an abstract base class derived from the Interfaced class via the HandlerBaseT class ad...
Definition:
HandlerBase.h:151
ThePEG::HandlerGroup
HandlerGroup is a templated utility class to manage a group of StepHandlers.
Definition:
HandlerGroup.h:321
ThePEG::InterfacedBase::dofinish
virtual void dofinish()
Finalize this object.
Definition:
InterfacedBase.h:208
ThePEG::LastXCombInfo
LastXCombInfo is a templated class giving easy access to the information in an XComb object.
Definition:
LastXCombInfo.h:32
ThePEG::LuminosityFunction
The LuminosityFunction describes the momentum distribution of the incoming beams in an experiment.
Definition:
LuminosityFunction.h:39
ThePEG::MultipleInteractionHandler
The MultipleInteractionHandler is the base class of all handlers implementing models for multiple int...
Definition:
MultipleInteractionHandler.h:29
ThePEG::PersistentIStream
PersistentIStream is used to read persistent objects from a stream where they were previously written...
Definition:
PersistentIStream.h:48
ThePEG::PersistentOStream
PersistentOStream is used to write objects persistently to a stream from which they can be read in ag...
Definition:
PersistentOStream.h:51
ThePEG::Pointer::RCPtr
RCPtr is a reference counted (smart) pointer.
Definition:
RCPtr.h:60
ThePEG::Pointer::TransientConstRCPtr
TransientConstRCPtr is a simple wrapper around a bare const pointer which can be assigned to and from...
Definition:
RCPtr.h:696
ThePEG::Pointer::TransientRCPtr
TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr a...
Definition:
RCPtr.h:519
ThePEG::Qty< std::ratio< L, DL >, std::ratio< E, DE >, std::ratio< Q, DQ > >
Definition:
PhysicalQty.h:77
ThePEG::Rebinder
Rebinder is a class associating pairs of pointers to objects.
Definition:
Rebinder.h:27
ThePEG::SubProcessHandler
The SubProcessHandler class is used to handle a set of MEBase objects together with a PartonExtractor...
Definition:
SubProcessHandler.h:49
ThePEG::Group::Handler
Handler
Enumeration for the type of HandlerGroups.
Definition:
HandlerGroup.h:433
ThePEG::Group::Level
Level
Enumeration for the type of step handler.
Definition:
HandlerGroup.h:442
ThePEG
This is the main namespace within which all identifiers in ThePEG are declared.
Definition:
FactoryBase.h:28
ThePEG::cPDPair
pair< cPDPtr, cPDPtr > cPDPair
A pair of pointers to const ParticleData objects.
Definition:
Containers.h:118
ThePEG::tHintPtr
ThePEG::Ptr< Hint >::transient_pointer tHintPtr
Alias for a transient pointer to Hint .
Definition:
Pointers.h:71
ThePEG::tStepHdlPtr
ThePEG::Ptr< StepHandler >::transient_pointer tStepHdlPtr
Alias for a transient pointer to StepHandler .
Definition:
Pointers.h:70
ThePEG::IVector
vector< IBPtr > IVector
A vector of pointers to InterfacedBase objects.
Definition:
Containers.h:67
Generated on Thu Jun 20 2024 14:47:00 for ThePEG by
1.9.6