ECCE @ EIC Software
Reference for
ECCE @ EIC
simulation and reconstruction software on GitHub
Home page
Related Pages
Modules
Namespaces
Classes
Files
External Links
File List
File Members
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Groups
Pages
G4ITTrackHolder.hh
Go to the documentation of this file.
Or view
the newest version in sPHENIX GitHub for file G4ITTrackHolder.hh
1
//
2
// ********************************************************************
3
// * License and Disclaimer *
4
// * *
5
// * The Geant4 software is copyright of the Copyright Holders of *
6
// * the Geant4 Collaboration. It is provided under the terms and *
7
// * conditions of the Geant4 Software License, included in the file *
8
// * LICENSE and available at http://cern.ch/geant4/license . These *
9
// * include a list of copyright holders. *
10
// * *
11
// * Neither the authors of this software system, nor their employing *
12
// * institutes,nor the agencies providing financial support for this *
13
// * work make any representation or warranty, express or implied, *
14
// * regarding this software system or assume any liability for its *
15
// * use. Please see the license in the file LICENSE and URL above *
16
// * for the full disclaimer and the limitation of liability. *
17
// * *
18
// * This code implementation is the result of the scientific and *
19
// * technical work of the GEANT4 collaboration. *
20
// * By using, copying, modifying or distributing the software (or *
21
// * any work based on the software) you agree to acknowledge its *
22
// * use in resulting scientific publications, and indicate your *
23
// * acceptance of all terms of the Geant4 Software license. *
24
// ********************************************************************
25
//
26
/*
27
* G4ITTrackHolder.hh
28
*
29
* Created on: 17 sept. 2014
30
* Author: kara
31
*/
32
33
#ifndef G4ITTRACKHOLDER_HH
34
#define G4ITTRACKHOLDER_HH
35
36
#include "
G4TrackList.hh
"
37
#include "
G4VITTrackHolder.hh
"
38
#include <iostream>
39
40
class
PriorityList
:
public
G4TrackList::Watcher
41
{
42
public
:
43
enum
Type
44
{
45
MainList
= 0,
46
SecondariesList
= 1,
47
WaitingList
= 2,
48
Undefined
= -1
49
};
50
51
PriorityList
();
52
PriorityList
(
G4TrackManyList
& allMainList);
53
PriorityList
(
const
PriorityList
&
right
);
54
virtual
~PriorityList
();
55
56
virtual
void
NotifyDeletingList
(
G4TrackList
* __list);
57
58
void
NewMainList
(
G4TrackList
* __list,
G4TrackManyList
& allMainList);
59
60
G4TrackList
*
NewMainList
(
G4TrackManyList
& allMainList);
61
62
void
PushToMainList
(
G4Track
* __track,
G4TrackManyList
& allMainList);
63
64
void
TransferToMainList
(
G4TrackList
*& __list,
G4TrackManyList
& allMainList);
65
66
void
PushToListOfSecondaries
(
G4Track
* __track,
67
G4TrackManyList
& listOfAllSecondaries);
68
69
void
PushToWaitingList
(
G4Track
* __track);
70
71
void
TransferSecondariesToMainList
();
72
73
void
PushToMainList
(
G4Track
*
track
);
74
75
void
MergeWithMainList
(
G4TrackList
* trackList);
76
77
inline
G4TrackList
*
GetMainList
()
78
{
79
return
fpMainList
;
80
}
81
82
inline
G4TrackList
*
GetSecondariesList
()
83
{
84
return
&
fSecondaries
;
85
}
86
87
inline
void
SetWaitingList
(
G4TrackList
* __list)
88
{
89
fpWaitingList
= __list;
90
}
91
92
inline
G4TrackList
*
Get
(
Type
type)
93
{
94
switch
(type)
95
{
96
case
MainList
:
97
return
fpMainList
;
98
break
;
99
case
SecondariesList
:
100
return
&
fSecondaries
;
101
break
;
102
case
WaitingList
:
103
return
fpWaitingList
;
104
break
;
105
case
Undefined
:
106
return
0;
107
}
108
return
0;
109
}
110
111
int
GetNTracks
();
112
113
private
:
114
G4TrackList
*
fpMainList
;
115
G4TrackList
fSecondaries
;
116
// to merge with fpMainList
117
G4TrackList
*
fpWaitingList
;
118
// Waiting queue of currentList
119
};
120
121
class
G4ITTrackHolder
:
public
G4VITTrackHolder
122
{
123
/* UR:
124
* Push on time
125
* Push delayed
126
* Exception when going back
127
* Get all tracks
128
*/
129
130
static
G4ThreadLocal
G4ITTrackHolder
*
fgInstance
;
131
static
G4ITTrackHolder
*
fgMasterInstance
;
132
friend
class
G4Scheduler
;
133
friend
class
G4ITStepProcessor
;
134
friend
class
G4ITModelProcessor
;
135
136
public
:
137
//----- typedefs -----
138
typedef
int
Key
;
//TODO
139
typedef
std::map<Key, PriorityList*>
MapOfPriorityLists
;
140
typedef
std::map<double, std::map<Key, G4TrackList*> >
MapOfDelayedLists
;
141
142
//----- Access singletons + constructors/destructors-----
143
144
static
G4ITTrackHolder
*
Instance
();
145
static
G4ITTrackHolder
*
MasterInstance
();
146
147
G4ITTrackHolder
();
148
virtual
149
~G4ITTrackHolder
();
150
151
//----- Time of the next set of tracks -----
152
inline
double
GetNextTime
()
153
{
154
if
(
fDelayedList
.empty())
return
DBL_MAX
;
155
return
fDelayedList
.begin()->first;
156
}
157
158
//----- Add new tracks to the list -----
159
virtual
void
Push
(
G4Track
*);
160
static
void
PushToMaster
(
G4Track
*);
161
162
//----- Operations between lists -----
163
164
inline
void
PushToKill
(
G4Track
*
track
)
165
{
166
G4TrackList::Pop
(track);
167
fToBeKilledList
.
push_back
(track);
168
169
if
(track->
GetTrackStatus
() !=
fKillTrackAndSecondaries
){
170
track->
SetTrackStatus
(
fStopAndKill
);
171
}
172
}
173
174
bool
MergeNextTimeToMainList
(
double
&
time
);
175
void
MergeSecondariesWithMainList
();
176
void
MoveMainToWaitingList
();
177
178
// ----- To call at the end of the step -----
179
void
KillTracks
();
180
void
Clear
();
181
182
// ----- Add a watcher to a specific track list -----
183
// comment: to stop watching, just call StopWatching from your watcher class
184
bool
AddWatcher
(
int
,
185
G4TrackList::Watcher*,
186
PriorityList::Type
=
PriorityList::MainList
);
187
188
void
AddWatcherForMainList
(G4TrackList::Watcher*);
189
void
AddWatcherForKillList
(G4TrackList::Watcher*);
190
191
// ----- Access track lists -----
192
inline
MapOfPriorityLists
&
GetLists
()
193
{
return
fLists
;}
194
PriorityList
*
GetPriorityList
(
Key
);
195
G4TrackList
*
GetMainList
(
Key
);
196
inline
G4TrackManyList
*
GetMainList
()
197
{
198
return
&
fAllMainList
;
199
}
200
201
inline
G4TrackManyList
*
GetSecondariesList
()
202
{
203
return
&
fAllSecondariesList
;
204
}
205
206
inline
MapOfDelayedLists
&
GetDelayedLists
()
207
{
208
return
fDelayedList
;
209
}
210
211
virtual
size_t
GetNTracks
();
212
213
// ----- Check track lists are NOT empty -----
214
// comment: checking NOT empty faster than checking IS empty
215
inline
bool
MainListsNOTEmpty
()
216
{
217
return
CheckMapIsNOTEmpty
(
fLists
,
PriorityList::MainList
);
218
}
219
220
inline
bool
SecondaryListsNOTEmpty
()
221
{
222
return
CheckMapIsNOTEmpty
(
fLists
,
PriorityList::SecondariesList
);
223
}
224
225
bool
DelayListsNOTEmpty
();
226
227
bool
CheckMapIsNOTEmpty
(
MapOfPriorityLists
& mapOfLists,
228
PriorityList::Type
type);
229
230
inline
void
SetVerbose
(
int
verbose)
231
{
232
fVerbose
= verbose;
233
}
234
235
inline
G4TrackList
*
GetKillList
()
236
{
237
return
&
fToBeKilledList
;
238
}
239
240
protected
:
241
void
AddTrackID
(
G4Track
*
track
);
242
void
_PushTrack
(
G4Track
*
track
);
243
void
PushTo
(
G4Track
*,
PriorityList::Type
);
244
void
PushDelayed
(
G4Track
*
track
);
245
246
protected
:
247
std::map<Key, PriorityList*>
fLists
;
248
MapOfDelayedLists
fDelayedList
;
249
G4TrackList
fToBeKilledList
;
250
bool
fMainListHaveBeenSet
;
251
int
fVerbose
;
252
int
fNbTracks
;
253
254
double
fPostActivityGlobalTime
;
255
// double fPreActivityGlobalTime ;
256
257
G4TrackManyList
fAllMainList
;
258
G4TrackManyList
fAllSecondariesList
;
259
};
260
261
#endif
/* G4MIMOLECULARTRACKS_HH_ */
geant4
tree
geant4-10.6-release
source
processes
electromagnetic
dna
management
include
G4ITTrackHolder.hh
Built by
Jin Huang
. updated:
Wed Jun 29 2022 17:25:28
using
1.8.2 with
ECCE GitHub integration