thepeg is hosted by Hepforge, IPPP Durham
ThePEG 2.3.0
SubProcessGroup.h
1// -*- C++ -*-
2//
3// SubProcessGroup.h is a part of ThePEG - Toolkit for HEP Event Generation
4// Copyright (C) 1999-2019 Leif Lonnblad
5// Copyright (C) 2009-2019 Simon Platzer
6//
7// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
8// Please respect the MCnet academic guidelines, see GUIDELINES for details.
9//
10#ifndef ThePEG_SubProcessGroup_H
11#define ThePEG_SubProcessGroup_H
12// This is the declaration of the SubProcessGroup class.
13
14#include "ThePEG/EventRecord/SubProcess.h"
15
16namespace ThePEG {
17
26
27public:
28
35 SubProcessGroup(const PPair & newIncoming,
36 tCollPtr newCollision = tCollPtr(),
37 tcEventBasePtr newHandler = tcEventBasePtr());
38
43
47 virtual SubProPtr clone() const;
48
49protected:
50
58 virtual void rebind(const EventTranslationMap & trans);
59
60public:
61
66 virtual void transform(const LorentzRotation &);
67
71 const SubProcessVector& dependent() const { return theDependent; }
72
77
81 void add(tSubProPtr sub) { dependent().push_back(sub); }
82
83public:
84
89
94
98 static void Init();
99
100private:
101
106
107public:
108
112 virtual void printMe(ostream&) const;
113
114private:
115
120
126
131 friend struct ClassTraits<SubProcessGroup>;
132
137
138};
139
140
145template <>
148 typedef EventRecordBase NthBase;
149};
150
153template <>
154struct ClassTraits<SubProcessGroup>: public ClassTraitsBase<SubProcessGroup> {
156 static string className() { return "ThePEG::SubProcessGroup"; }
158 static TPtr create() { return TPtr::Create(SubProcessGroup()); }
159};
160
163}
164
165#endif /* ThePEG_SubProcessGroup_H */
A concreate implementation of ClassDescriptionBase describing a concrete class with persistent data.
The LorentzRotation class combine a SpinOneLorentzRotation and a spin SpinHalfLorentzRotation to prov...
PersistentIStream is used to read persistent objects from a stream where they were previously written...
PersistentOStream is used to write objects persistently to a stream from which they can be read in ag...
RCPtr is a reference counted (smart) pointer.
Definition: RCPtr.h:60
static RCPtr Create()
Allocate and construct an object of class T and return a RCPtr to it.
Definition: RCPtr.h:120
TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr a...
Definition: RCPtr.h:519
Rebinder is a class associating pairs of pointers to objects.
Definition: Rebinder.h:27
A SubProcessGroup object represents a group of SubProcess objects in dependence of a head SubProcess ...
virtual void rebind(const EventTranslationMap &trans)
Rebind to cloned objects.
SubProcessGroup()
Private default constructor must only be used by the PersistentIStream class via the ClassTraits<SubP...
SubProcessVector theDependent
The dependent subprocesses.
virtual ~SubProcessGroup()
Destructor.
static ClassDescription< SubProcessGroup > initSubProcessGroup
Describe concrete class with persistent data.
static void Init()
Standard Init function.
void persistentOutput(PersistentOStream &) const
Standard function for writing to a persistent stream.
virtual SubProPtr clone() const
Return a clone of this sub process group.
void persistentInput(PersistentIStream &, int)
Standard function for reading from a persistent stream.
SubProcessGroup(const PPair &newIncoming, tCollPtr newCollision=tCollPtr(), tcEventBasePtr newHandler=tcEventBasePtr())
Standard constructor.
void add(tSubProPtr sub)
Add a dependent SubProcess.
SubProcessVector & dependent()
Access the dependent SubProcess objects.
virtual void printMe(ostream &) const
Put to ostream.
const SubProcessVector & dependent() const
Return the dependent SubProcess objects.
SubProcessGroup & operator=(const SubProcessGroup &)=delete
Assignment is forbidden.
virtual void transform(const LorentzRotation &)
Perform a LorentzTransformation of all particles in the sub process.
A SubProcess object represents a hard sub-process in a collision.
Definition: SubProcess.h:33
This is the main namespace within which all identifiers in ThePEG are declared.
Definition: FactoryBase.h:28
pair< PPtr, PPtr > PPair
A pair of pointers to Particle objects.
Definition: Containers.h:127
Ptr< EventRecordBase >::transient_const_pointer tcEventBasePtr
Alias for a transient pointer to const EventRecordBase.
Definition: EventConfig.h:49
vector< SubProPtr > SubProcessVector
A vector of pointers to SubProcess.
Definition: EventConfig.h:84
ThePEG::Ptr< Collision >::transient_pointer tCollPtr
Alias for a transient pointer to Collision .
Definition: Pointers.h:84
BaseClassTraits describes the base classes of the templated class.
Definition: ClassTraits.h:156
int NthBase
The type of the BaseN'th base class (int means there are no further base classes).
Definition: ClassTraits.h:161
Define the base class from which all (polymorphic) classes in ThePEG are derived.
Definition: ThePEG.h:54
static string className()
Return the name of class T.
Definition: ClassTraits.h:66
static TPtr create()
Create a T object and return a smart pointer to it.
Definition: ClassTraits.h:60
ThePEG::Ptr< T >::pointer TPtr
Alias for a reference counted pointer to T .
Definition: ClassTraits.h:54
ClassTraitsType is an empty, non-polymorphic, base class.
Definition: ClassTraits.h:30
The default concrete implementation of ClassTraitsBase.
Definition: ClassTraits.h:134