| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4StackManager class implementation <<
27 // 26 //
28 // Author: Makoto Asai, 1996 << 27 // $Id: G4StackManager.cc,v 1.10 2006/06/29 18:10:19 gunter Exp $
29 // Adding sub-event parallelism << 28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
30 // 23/Aug/2023 << 29 //
31 // ------------------------------------------- << 30 //
>> 31 // Last Modification : 09/Dec/96 M.Asai
>> 32 //
32 33
33 #include "G4StackManager.hh" 34 #include "G4StackManager.hh"
34 #include "G4StackingMessenger.hh" 35 #include "G4StackingMessenger.hh"
35 #include "G4VTrajectory.hh" 36 #include "G4VTrajectory.hh"
36 #include "G4Event.hh" << 37 #include "evmandefs.hh"
37 #include "G4ios.hh" 38 #include "G4ios.hh"
38 39
39 #include "G4ParticleDefinition.hh" <<
40 #include "G4VProcess.hh" <<
41 <<
42 // Needed for temporal service <<
43 // <<
44 #include "G4ParticleTable.hh" <<
45 #include "G4ProcessManager.hh" <<
46 #include "G4ProcessVector.hh" <<
47 <<
48 G4StackManager::G4StackManager() 40 G4StackManager::G4StackManager()
>> 41 :userStackingAction(0),verboseLevel(0),numberOfAdditionalWaitingStacks(0)
49 { 42 {
50 theMessenger = new G4StackingMessenger(this) 43 theMessenger = new G4StackingMessenger(this);
51 #ifdef G4_USESMARTSTACK << 44 urgentStack = new G4TrackStack;
52 urgentStack = new G4SmartTrackStack; << 45 waitingStack = new G4TrackStack;
53 // G4cout << "+++ G4StackManager uses G4Smar << 46 postponeStack = new G4TrackStack;
54 #else <<
55 urgentStack = new G4TrackStack(5000); <<
56 // G4cout << "+++ G4StackManager uses ordina <<
57 #endif <<
58 waitingStack = new G4TrackStack(1000); <<
59 postponeStack = new G4TrackStack(1000); <<
60 } 47 }
61 48
62 G4StackManager::~G4StackManager() 49 G4StackManager::~G4StackManager()
63 { 50 {
64 delete userStackingAction; << 51 if(userStackingAction) delete userStackingAction;
65 <<
66 #ifdef G4VERBOSE <<
67 if(verboseLevel>0) <<
68 { <<
69 G4cout << "+++++++++++++++++++++++++++++++ <<
70 G4cout << " Maximum number of tracks in th <<
71 G4cout << "+++++++++++++++++++++++++++++++ <<
72 } <<
73 #endif <<
74 delete urgentStack; 52 delete urgentStack;
75 delete waitingStack; 53 delete waitingStack;
76 delete postponeStack; 54 delete postponeStack;
77 delete theMessenger; 55 delete theMessenger;
78 if(numberOfAdditionalWaitingStacks>0) << 56 if(numberOfAdditionalWaitingStacks>0) {
79 { << 57 for(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
80 for(G4int i=0; i<numberOfAdditionalWaiting <<
81 { <<
82 delete additionalWaitingStacks[i]; 58 delete additionalWaitingStacks[i];
83 } 59 }
84 } 60 }
85 } 61 }
86 62
87 G4int G4StackManager:: << 63 const G4StackManager & G4StackManager::operator=
88 PushOneTrack(G4Track* newTrack, G4VTrajectory* << 64 (const G4StackManager &) { return *this; }
89 { << 65 G4int G4StackManager::operator==(const G4StackManager &)
90 const G4ParticleDefinition* pd = newTrack->G << 66 const{ return false; }
91 if(pd->GetParticleDefinitionID() < 0) << 67 G4int G4StackManager::operator!=(const G4StackManager &)
>> 68 const{ return true; }
>> 69
>> 70 G4int G4StackManager::PushOneTrack(G4Track *newTrack,G4VTrajectory *newTrajectory)
>> 71 {
>> 72 G4ClassificationOfNewTrack classification;
>> 73 if(userStackingAction)
>> 74 { classification = userStackingAction->ClassifyNewTrack( newTrack ); }
>> 75 else
>> 76 { classification = DefaultClassification( newTrack ); }
>> 77
>> 78 if(classification==fKill) // delete newTrack without stacking
92 { 79 {
93 G4ExceptionDescription ED; << 80 #ifdef G4VERBOSE
94 ED << "A track without proper process mana << 81 if( verboseLevel > 0 )
95 into the track stack.\n" << 82 {
96 << " Particle name : " << pd->GetPartic << 83 G4cout << " ---> G4Track " << newTrack << " (trackID "
97 if(newTrack->GetParentID()==0) << 84 << newTrack->GetTrackID() << ", parentID "
98 { << 85 << newTrack->GetParentID() << ") is not to be stored." << G4endl;
99 ED << "created by a primary particle gen <<
100 } <<
101 else <<
102 { <<
103 const G4VProcess* vp = newTrack->GetCrea <<
104 if(vp != nullptr) <<
105 { <<
106 ED << "created by " << vp->GetProcessN <<
107 } <<
108 else <<
109 { <<
110 ED << "creaded by unknown process."; <<
111 } <<
112 } 86 }
113 G4Exception("G4StackManager::PushOneTrack" << 87 #endif
114 FatalException,ED); <<
115 delete newTrack; 88 delete newTrack;
116 return GetNUrgentTrack(); << 89 delete newTrajectory;
117 } 90 }
118 << 91 else
119 DefineDefaultClassification( newTrack ); <<
120 G4ClassificationOfNewTrack classification = <<
121 if(userStackingAction!=nullptr) <<
122 { 92 {
123 classification = userStackingAction->Class << 93 G4StackedTrack * newStackedTrack = new G4StackedTrack( newTrack, newTrajectory );
124 if(classification != fDefaultClassificatio << 94 switch (classification)
125 { 95 {
126 if(fExceptionSeverity!=G4ExceptionSeveri << 96 case fUrgent:
127 { << 97 urgentStack->PushToStack( newStackedTrack );
128 G4ExceptionDescription ed; << 98 break;
129 ed << "UserStackingAction has changed << 99 case fWaiting:
130 << fDefaultClassification << " to " << 100 waitingStack->PushToStack( newStackedTrack );
131 G4Exception("G4StackManager::PushOneTr << 101 break;
132 fExceptionSeverity,ed); << 102 case fPostpone:
133 } << 103 postponeStack->PushToStack( newStackedTrack );
134 } << 104 break;
135 } << 105 default:
136 if(newTrack->GetTrackStatus() == fSuspendAnd << 106 G4int i = classification - 10;
137 // to avoid this track sent to Waiting stack << 107 if(i<1||i>numberOfAdditionalWaitingStacks) {
138 { newTrack->SetTrackStatus( fSuspend ); } << 108 G4Exception("G4StackManager : invalid classification");
139 << 109 } else {
140 #ifdef G4VERBOSE << 110 additionalWaitingStacks[i-1]->PushToStack( newStackedTrack );
141 if( verboseLevel > 1 ) << 111 }
142 { << 112 break;
143 G4cout << "### Storing a track (" <<
144 << newTrack->GetParticleDefinition( <<
145 << ",trackID=" << newTrack->GetTrac <<
146 << ",parentID=" << newTrack->GetPar <<
147 if(newTrack->GetParentID()==0) <<
148 { G4cout << "created by a primary particle <<
149 else <<
150 { <<
151 const G4VProcess* vp = newTrack->GetCrea <<
152 if(vp != nullptr) <<
153 { G4cout << "created by " << vp->GetProc <<
154 else <<
155 { G4cout << "creaded by unknown process <<
156 } 113 }
157 G4cout << "into stack #" << classification <<
158 } 114 }
159 #endif <<
160 G4StackedTrack newStackedTrack( newTrack, ne <<
161 SortOut(newStackedTrack,classification); <<
162 115
163 return GetNUrgentTrack(); 116 return GetNUrgentTrack();
164 } 117 }
165 118
166 G4Track* G4StackManager::PopNextTrack(G4VTraje << 119
>> 120 G4Track * G4StackManager::PopNextTrack(G4VTrajectory**newTrajectory)
167 { 121 {
168 #ifdef G4VERBOSE 122 #ifdef G4VERBOSE
169 if( verboseLevel > 1 ) << 123 if( verboseLevel > 0 )
170 { 124 {
171 G4cout << "### pop requested out of " 125 G4cout << "### pop requested out of "
172 << GetNUrgentTrack() << " stacked t << 126 << GetNUrgentTrack() << " stacked tracks." << G4endl;
173 } 127 }
174 #endif 128 #endif
175 129
176 while( GetNUrgentTrack() == 0 ) 130 while( GetNUrgentTrack() == 0 )
177 { 131 {
178 #ifdef G4VERBOSE 132 #ifdef G4VERBOSE
179 if( verboseLevel > 1 ) << 133 if( verboseLevel > 0 ) G4cout << "### " << GetNWaitingTrack()
180 { << 134 << " waiting tracks are re-classified to" << G4endl;
181 G4cout << "### " << GetNWaitingTrack() <<
182 << " waiting tracks are re-classi <<
183 } <<
184 #endif 135 #endif
185 waitingStack->TransferTo(urgentStack); 136 waitingStack->TransferTo(urgentStack);
186 if(numberOfAdditionalWaitingStacks>0) << 137 if(numberOfAdditionalWaitingStacks>0) {
187 { << 138 for(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
188 for(G4int i=0; i<numberOfAdditionalWaiti << 139 if(i==0) {
189 { <<
190 if(i==0) <<
191 { <<
192 additionalWaitingStacks[0]->Transfer 140 additionalWaitingStacks[0]->TransferTo(waitingStack);
193 } << 141 } else {
194 else <<
195 { <<
196 additionalWaitingStacks[i]->Transfer 142 additionalWaitingStacks[i]->TransferTo(additionalWaitingStacks[i-1]);
197 } 143 }
198 } 144 }
199 } 145 }
200 if(userStackingAction != nullptr) << 146 if(userStackingAction) userStackingAction->NewStage();
201 { <<
202 userStackingAction->NewStage(); <<
203 } <<
204 <<
205 #ifdef G4VERBOSE 147 #ifdef G4VERBOSE
206 if( verboseLevel > 1 ) << 148 if( verboseLevel > 0 ) G4cout << " " << GetNUrgentTrack()
207 G4cout << " " << GetNUrgentTrack() << 149 << " urgent tracks and " << GetNWaitingTrack()
208 << " urgent tracks and " << GetNW << 150 << " waiting tracks." << G4endl;
209 << " waiting tracks." << G4endl; <<
210 #endif 151 #endif
211 if( ( GetNUrgentTrack()==0 ) && ( GetNWait << 152 if( ( GetNUrgentTrack()==0 ) && ( GetNWaitingTrack()==0 ) ) return 0;
212 return nullptr; <<
213 } 153 }
214 154
215 G4StackedTrack selectedStackedTrack = urgent << 155 G4StackedTrack * selectedStackedTrack = urgentStack->PopFromStack();
216 G4Track * selectedTrack = selectedStackedTra << 156 G4Track * selectedTrack = selectedStackedTrack->GetTrack();
217 *newTrajectory = selectedStackedTrack.GetTra << 157 *newTrajectory = selectedStackedTrack->GetTrajectory();
218 158
219 #ifdef G4VERBOSE 159 #ifdef G4VERBOSE
220 if( verboseLevel > 2 ) << 160 if( verboseLevel > 1 )
221 { 161 {
222 G4cout << "Selected G4StackedTrack : " << << 162 G4cout << "Selected G4StackedTrack : " << selectedStackedTrack
223 << " with G4Track " << selectedStac << 163 << " with G4Track " << selectedStackedTrack->GetTrack()
224 << " (trackID " << selectedStackedT << 164 << " (trackID " << selectedStackedTrack->GetTrack()->GetTrackID()
225 << ", parentID " << selectedStacked << 165 << ", parentID " << selectedStackedTrack->GetTrack()->GetParentID()
226 << ")" << G4endl; << 166 << ")" << G4endl;
227 } 167 }
228 #endif 168 #endif
229 169
>> 170 delete selectedStackedTrack;
230 return selectedTrack; 171 return selectedTrack;
231 } 172 }
232 173
233 void G4StackManager::ReClassify() 174 void G4StackManager::ReClassify()
234 { 175 {
235 G4StackedTrack aStackedTrack; << 176 G4StackedTrack * aStackedTrack;
236 G4TrackStack tmpStack; 177 G4TrackStack tmpStack;
237 << 178
238 if( userStackingAction == nullptr ) return; << 179 if( !userStackingAction ) return;
239 if( GetNUrgentTrack() == 0 ) return; 180 if( GetNUrgentTrack() == 0 ) return;
240 << 181
241 urgentStack->TransferTo(&tmpStack); 182 urgentStack->TransferTo(&tmpStack);
242 while( tmpStack.GetNTrack() > 0 ) << 183 while( (aStackedTrack=tmpStack.PopFromStack()) != 0 )
243 { 184 {
244 aStackedTrack=tmpStack.PopFromStack(); << 185 G4ClassificationOfNewTrack classification =
245 DefineDefaultClassification( aStackedTrack << 186 userStackingAction->ClassifyNewTrack( aStackedTrack->GetTrack() );
246 G4ClassificationOfNewTrack classification << 187 switch (classification)
247 if(userStackingAction!=nullptr) <<
248 { 188 {
249 classification = userStackingAction->Cla << 189 case fKill:
250 if(classification != fDefaultClassificat << 190 delete aStackedTrack->GetTrack();
251 { << 191 delete aStackedTrack->GetTrajectory();
252 if(fExceptionSeverity!=G4ExceptionSeve << 192 delete aStackedTrack;
253 { << 193 break;
254 G4ExceptionDescription ed; << 194 case fUrgent:
255 ed << "UserStackingAction has change << 195 urgentStack->PushToStack( aStackedTrack );
256 << fDefaultClassification << " to << 196 break;
257 G4Exception("G4StackManager::PushOne << 197 case fWaiting:
258 fExceptionSeverity,ed); << 198 waitingStack->PushToStack( aStackedTrack );
>> 199 break;
>> 200 case fPostpone:
>> 201 postponeStack->PushToStack( aStackedTrack );
>> 202 break;
>> 203 default:
>> 204 G4int i = classification - 10;
>> 205 if(i<1||i>numberOfAdditionalWaitingStacks) {
>> 206 G4Exception("G4StackManager : invalid classification");
>> 207 } else {
>> 208 additionalWaitingStacks[i-1]->PushToStack( aStackedTrack );
259 } 209 }
260 } << 210 break;
261 } 211 }
262 if(aStackedTrack.GetTrack()->GetTrackStatu <<
263 // to avoid this track sent to Waiting sta <<
264 { aStackedTrack.GetTrack()->SetTrackStatus <<
265 <<
266 SortOut(aStackedTrack,classification); <<
267 } 212 }
268 } 213 }
269 214
270 G4int G4StackManager::PrepareNewEvent(G4Event* << 215 G4int G4StackManager::PrepareNewEvent()
271 { 216 {
272 if(userStackingAction != nullptr) << 217 if(userStackingAction) userStackingAction->PrepareNewEvent();
273 { << 218
274 userStackingAction->PrepareNewEvent(); <<
275 } <<
276 <<
277 // Set the urgentStack in a defined state. N <<
278 // affect reproducibility <<
279 // <<
280 urgentStack->clearAndDestroy(); <<
281 <<
282 G4int n_passedFromPrevious = 0; 219 G4int n_passedFromPrevious = 0;
283 << 220
284 if( GetNPostponedTrack() > 0 ) 221 if( GetNPostponedTrack() > 0 )
285 { 222 {
286 #ifdef G4VERBOSE 223 #ifdef G4VERBOSE
287 if( verboseLevel > 1 ) << 224 if( verboseLevel > 0 )
288 { 225 {
289 G4cout << GetNPostponedTrack() << 226 G4cout << GetNPostponedTrack()
290 << " postponed tracked are now sh << 227 << " postponed tracked are now shifted to the stack." << G4endl;
291 } 228 }
292 #endif 229 #endif
293 << 230
294 G4StackedTrack aStackedTrack; << 231 G4StackedTrack * aStackedTrack;
295 G4TrackStack tmpStack; << 232 G4TrackStack tmpStack;
296 << 233
297 postponeStack->TransferTo(&tmpStack); 234 postponeStack->TransferTo(&tmpStack);
298 << 235
299 while( tmpStack.GetNTrack() > 0 ) << 236 while( (aStackedTrack=tmpStack.PopFromStack()) != 0 )
300 { 237 {
301 aStackedTrack=tmpStack.PopFromStack(); << 238 G4Track* aTrack = aStackedTrack->GetTrack();
302 G4Track* aTrack = aStackedTrack.GetTrack << 239 aTrack->SetParentID(-1);
303 DefineDefaultClassification( aTrack ); << 240 G4ClassificationOfNewTrack classification;
304 G4ClassificationOfNewTrack classificatio << 241 if(userStackingAction)
305 if(userStackingAction!=nullptr) << 242 { classification = userStackingAction->ClassifyNewTrack( aTrack ); }
>> 243 else
>> 244 { classification = DefaultClassification( aTrack ); }
>> 245
>> 246 if(classification==fKill)
306 { 247 {
307 classification = userStackingAction->C << 248 delete aTrack;
308 if(classification != fDefaultClassific << 249 delete aStackedTrack->GetTrajectory();
309 { << 250 delete aStackedTrack;
310 if(fExceptionSeverity!=G4ExceptionSe <<
311 { <<
312 G4ExceptionDescription ed; <<
313 ed << "UserStackingAction has chan <<
314 << fDefaultClassification << " <<
315 G4Exception("G4StackManager::PushO <<
316 fExceptionSeverity,ed) <<
317 } <<
318 } <<
319 } 251 }
320 if(classification!=fKill) << 252 else
321 { 253 {
322 aTrack->SetParentID(-1); << 254 aTrack->SetTrackID(-(++n_passedFromPrevious));
323 aTrack->SetTrackID(-(++n_passedFromPre << 255 switch (classification)
>> 256 {
>> 257 case fUrgent:
>> 258 urgentStack->PushToStack( aStackedTrack );
>> 259 break;
>> 260 case fWaiting:
>> 261 waitingStack->PushToStack( aStackedTrack );
>> 262 break;
>> 263 case fPostpone:
>> 264 postponeStack->PushToStack( aStackedTrack );
>> 265 break;
>> 266 default:
>> 267 G4int i = classification - 10;
>> 268 if(i<1||i>numberOfAdditionalWaitingStacks) {
>> 269 G4Exception("G4StackManager : invalid classification");
>> 270 } else {
>> 271 additionalWaitingStacks[i-1]->PushToStack( aStackedTrack );
>> 272 }
>> 273 break;
>> 274 }
324 } 275 }
325 else if(aTrack->GetTrackStatus() == fSus <<
326 // to avoid this track sent to Waiting s <<
327 { aTrack->SetTrackStatus( fSuspend ); } <<
328 <<
329 SortOut(aStackedTrack,classification); <<
330 } 276 }
331 } 277 }
332 278
333 // Reset sub-event stacks for a new event <<
334 for(auto& ses : subEvtStackMap) <<
335 { ses.second->PrepareNewEvent(currentEvent); <<
336 <<
337 return n_passedFromPrevious; 279 return n_passedFromPrevious;
338 } 280 }
339 281
340 void G4StackManager::SortOut(G4StackedTrack& a <<
341 { <<
342 if(classification==fKill) // delete the wi <<
343 { <<
344 G4Track* newTrack = aStackedTrack.GetTrack <<
345 G4VTrajectory* newTrajectory = aStackedTra <<
346 #ifdef G4VERBOSE <<
347 if( verboseLevel > 1 ) <<
348 { <<
349 G4cout << " ---> G4Track " << newTrack <<
350 << newTrack->GetTrackID() << ", p <<
351 << newTrack->GetParentID() << ") <<
352 } <<
353 #endif <<
354 delete newTrack; <<
355 delete newTrajectory; <<
356 } <<
357 else <<
358 { <<
359 switch (classification) <<
360 { <<
361 case fUrgent: <<
362 urgentStack->PushToStack( aStackedTrac <<
363 break; <<
364 case fWaiting: <<
365 waitingStack->PushToStack( aStackedTra <<
366 break; <<
367 case fPostpone: <<
368 postponeStack->PushToStack( aStackedTr <<
369 break; <<
370 default: <<
371 if(classification < 100) <<
372 { <<
373 // pushing to additional waiting sta <<
374 G4int i = classification - 10; <<
375 if(i<1 || i>numberOfAdditionalWaitin <<
376 { <<
377 G4ExceptionDescription ED; <<
378 ED << "invalid classification " << <<
379 G4Exception("G4StackManager::SortO <<
380 FatalException,ED); <<
381 } <<
382 else <<
383 { <<
384 additionalWaitingStacks[i-1]->Push <<
385 } <<
386 } <<
387 else <<
388 { <<
389 // pushing to sub-event stack <<
390 G4int ty = classification - 100; <<
391 auto ses = subEvtStackMap.find(ty); <<
392 if(ses==subEvtStackMap.end()) <<
393 { <<
394 G4ExceptionDescription ED; <<
395 ED << "invalid classification " << <<
396 G4Exception("G4StackManager::SortO <<
397 FatalException,ED); <<
398 } <<
399 else <<
400 { <<
401 ses->second->PushToStack( aStacked <<
402 } <<
403 } <<
404 break; <<
405 } <<
406 } <<
407 } <<
408 <<
409 void G4StackManager::SetNumberOfAdditionalWait 282 void G4StackManager::SetNumberOfAdditionalWaitingStacks(G4int iAdd)
410 { 283 {
411 if(iAdd > numberOfAdditionalWaitingStacks) 284 if(iAdd > numberOfAdditionalWaitingStacks)
412 { 285 {
413 for(G4int i=numberOfAdditionalWaitingStack << 286 for(int i=numberOfAdditionalWaitingStacks;i<iAdd;i++)
414 { 287 {
415 auto* newStack = new G4TrackStack; << 288 G4TrackStack* newStack = new G4TrackStack;
416 additionalWaitingStacks.push_back(newSta 289 additionalWaitingStacks.push_back(newStack);
417 } 290 }
418 numberOfAdditionalWaitingStacks = iAdd; 291 numberOfAdditionalWaitingStacks = iAdd;
419 } 292 }
420 else if (iAdd < numberOfAdditionalWaitingSta 293 else if (iAdd < numberOfAdditionalWaitingStacks)
421 { 294 {
422 for(G4int i=numberOfAdditionalWaitingStack << 295 for(int i=numberOfAdditionalWaitingStacks;i>iAdd;i--)
423 { 296 {
424 delete additionalWaitingStacks[i]; 297 delete additionalWaitingStacks[i];
425 } 298 }
426 } 299 }
427 } 300 }
428 301
429 void G4StackManager:: << 302 void G4StackManager::TransferStackedTracks(G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
430 TransferStackedTracks(G4ClassificationOfNewTra <<
431 G4ClassificationOfNewTra <<
432 { 303 {
433 if(origin==destination) return; 304 if(origin==destination) return;
434 if(origin==fKill) return; << 305 G4TrackStack* originStack = 0;
435 G4TrackStack* originStack = nullptr; <<
436 switch(origin) 306 switch(origin)
437 { 307 {
438 case fUrgent: 308 case fUrgent:
439 originStack = nullptr; << 309 originStack = urgentStack;
440 break; 310 break;
441 case fWaiting: 311 case fWaiting:
442 originStack = waitingStack; 312 originStack = waitingStack;
443 break; 313 break;
444 case fPostpone: 314 case fPostpone:
445 originStack = postponeStack; 315 originStack = postponeStack;
446 break; 316 break;
>> 317 case fKill:
>> 318 break;
447 default: 319 default:
448 G4int i = origin - 10; << 320 int i = origin - 10;
449 if(i<=numberOfAdditionalWaitingStacks) << 321 if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
450 { <<
451 originStack = additionalWaitingStacks[ <<
452 } <<
453 else <<
454 { <<
455 G4ExceptionDescription ED; <<
456 ED << "Invalid origin stack ID " << or <<
457 G4Exception("G4StackManager::TransferS <<
458 FatalException, ED); <<
459 } <<
460 break; 322 break;
461 } 323 }
462 << 324 if(!originStack) return;
>> 325
463 if(destination==fKill) 326 if(destination==fKill)
464 { 327 {
465 if(originStack != nullptr) << 328 G4StackedTrack * aStackedTrack;
>> 329 while( (aStackedTrack=originStack->PopFromStack()) != 0 )
466 { 330 {
467 originStack->clearAndDestroy(); << 331 delete aStackedTrack->GetTrack();
>> 332 delete aStackedTrack->GetTrajectory();
>> 333 delete aStackedTrack;
468 } 334 }
469 else << 335 }
470 { <<
471 urgentStack->clearAndDestroy(); <<
472 } <<
473 } <<
474 else 336 else
475 { 337 {
476 G4TrackStack* targetStack = nullptr; << 338 G4TrackStack* targetStack = 0;
477 switch(destination) 339 switch(destination)
478 { 340 {
479 case fUrgent: 341 case fUrgent:
480 targetStack = nullptr; << 342 targetStack = urgentStack;
481 break; 343 break;
482 case fWaiting: 344 case fWaiting:
483 targetStack = waitingStack; 345 targetStack = waitingStack;
484 break; 346 break;
485 case fPostpone: 347 case fPostpone:
486 targetStack = postponeStack; 348 targetStack = postponeStack;
487 break; 349 break;
488 default: 350 default:
489 G4int i = destination - 10; << 351 int i = origin - 10;
490 if(i<=numberOfAdditionalWaitingStacks) << 352 if(i<=numberOfAdditionalWaitingStacks) targetStack = additionalWaitingStacks[i-1];
491 { <<
492 targetStack = additionalWaitingStack <<
493 } <<
494 else <<
495 { <<
496 G4ExceptionDescription ED; <<
497 ED << "Invalid origin stack ID " << <<
498 G4Exception("G4StackManager::Transfe <<
499 FatalException, ED); <<
500 } <<
501 break; 353 break;
502 } 354 }
503 if(originStack != nullptr) << 355 if(!targetStack) return;
504 { << 356 originStack->TransferTo(targetStack);
505 if(targetStack != nullptr) <<
506 { <<
507 originStack->TransferTo(targetStack); <<
508 } <<
509 else <<
510 { <<
511 originStack->TransferTo(urgentStack); <<
512 } <<
513 } <<
514 else <<
515 { <<
516 urgentStack->TransferTo(targetStack); <<
517 } <<
518 } 357 }
519 return; 358 return;
520 } 359 }
521 360
522 void G4StackManager:: << 361 void G4StackManager::TransferOneStackedTrack(G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
523 TransferOneStackedTrack(G4ClassificationOfNewT <<
524 G4ClassificationOfNewT <<
525 { 362 {
526 if(origin==destination) return; 363 if(origin==destination) return;
527 if(origin==fKill) return; << 364 G4TrackStack* originStack = 0;
528 G4TrackStack* originStack = nullptr; <<
529 switch(origin) 365 switch(origin)
530 { 366 {
531 case fUrgent: 367 case fUrgent:
532 originStack = nullptr; << 368 originStack = urgentStack;
533 break; 369 break;
534 case fWaiting: 370 case fWaiting:
535 originStack = waitingStack; 371 originStack = waitingStack;
536 break; 372 break;
537 case fPostpone: 373 case fPostpone:
538 originStack = postponeStack; 374 originStack = postponeStack;
539 break; 375 break;
>> 376 case fKill:
>> 377 break;
540 default: 378 default:
541 G4int i = origin - 10; << 379 int i = origin - 10;
542 if(i<=numberOfAdditionalWaitingStacks) << 380 if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
543 { <<
544 originStack = additionalWaitingStacks[ <<
545 } <<
546 else <<
547 { <<
548 G4ExceptionDescription ED; <<
549 ED << "Invalid origin stack ID " << or <<
550 G4Exception("G4StackManager::TransferS <<
551 FatalException, ED); <<
552 } <<
553 break; 381 break;
554 } 382 }
555 << 383 if(!originStack) return;
556 G4StackedTrack aStackedTrack; << 384
>> 385 G4StackedTrack * aStackedTrack;
557 if(destination==fKill) 386 if(destination==fKill)
558 { 387 {
559 if( originStack != nullptr && (originStack << 388 if( (aStackedTrack=originStack->PopFromStack()) != 0 )
560 { <<
561 aStackedTrack = originStack->PopFromStac <<
562 delete aStackedTrack.GetTrack(); <<
563 delete aStackedTrack.GetTrajectory(); <<
564 } <<
565 else if (urgentStack->GetNTrack() != 0u ) <<
566 { 389 {
567 aStackedTrack = urgentStack->PopFromStac << 390 delete aStackedTrack->GetTrack();
568 delete aStackedTrack.GetTrack(); << 391 delete aStackedTrack->GetTrajectory();
569 delete aStackedTrack.GetTrajectory(); << 392 delete aStackedTrack;
570 } 393 }
571 } << 394 }
572 else 395 else
573 { 396 {
574 G4TrackStack* targetStack = nullptr; << 397 G4TrackStack* targetStack = 0;
575 switch(destination) 398 switch(destination)
576 { 399 {
577 case fUrgent: 400 case fUrgent:
578 targetStack = nullptr; << 401 targetStack = urgentStack;
579 break; 402 break;
580 case fWaiting: 403 case fWaiting:
581 targetStack = waitingStack; 404 targetStack = waitingStack;
582 break; 405 break;
583 case fPostpone: 406 case fPostpone:
584 targetStack = postponeStack; 407 targetStack = postponeStack;
585 break; 408 break;
586 default: 409 default:
587 G4int i = destination - 10; << 410 int i = origin - 10;
588 if(i<=numberOfAdditionalWaitingStacks) << 411 if(i<=numberOfAdditionalWaitingStacks) targetStack = additionalWaitingStacks[i-1];
589 { <<
590 targetStack = additionalWaitingStack <<
591 } <<
592 else <<
593 { <<
594 G4ExceptionDescription ED; <<
595 ED << "Invalid destination stack ID <<
596 G4Exception("G4StackManager::Transfe <<
597 FatalException, ED); <<
598 } <<
599 break; 412 break;
600 } 413 }
601 if((originStack != nullptr) && (originStac << 414 if(!targetStack) return;
602 { << 415 if( (aStackedTrack=originStack->PopFromStack()) != 0 )
603 aStackedTrack = originStack->PopFromStac <<
604 if(targetStack != nullptr) { targetStack <<
605 else { urgentStack->PushToSta <<
606 } <<
607 else if(urgentStack->GetNTrack() != 0u) <<
608 { 416 {
609 aStackedTrack = urgentStack->PopFromStac << 417 targetStack->PushToStack(aStackedTrack);
610 if(targetStack != nullptr) { targetStack <<
611 else { urgentStack->PushToSta <<
612 } 418 }
613 } 419 }
614 return; 420 return;
615 } 421 }
616 422
617 void G4StackManager::clear() <<
618 { <<
619 ClearUrgentStack(); <<
620 ClearWaitingStack(); <<
621 for(G4int i=1; i<=numberOfAdditionalWaitingS <<
622 { <<
623 ClearWaitingStack(i); <<
624 } <<
625 } <<
626 <<
627 void G4StackManager::ClearUrgentStack() <<
628 { <<
629 urgentStack->clearAndDestroy(); <<
630 } <<
631 <<
632 void G4StackManager::ClearWaitingStack(G4int i <<
633 { <<
634 if(i==0) <<
635 { <<
636 waitingStack->clearAndDestroy(); <<
637 } <<
638 else <<
639 { <<
640 if(i<=numberOfAdditionalWaitingStacks) <<
641 { <<
642 additionalWaitingStacks[i-1]->clearAndDe <<
643 } <<
644 } <<
645 } <<
646 <<
647 void G4StackManager::ClearPostponeStack() <<
648 { <<
649 postponeStack->clearAndDestroy(); <<
650 } <<
651 <<
652 G4int G4StackManager::GetNTotalTrack() const <<
653 { <<
654 std::size_t n = urgentStack->GetNTrack() <<
655 + waitingStack->GetNTrack() <<
656 + postponeStack->GetNTrack(); <<
657 for(G4int i=1; i<=numberOfAdditionalWaitingS <<
658 { <<
659 n += additionalWaitingStacks[i-1]->GetNTra <<
660 } <<
661 return G4int(n); <<
662 } <<
663 <<
664 G4int G4StackManager::GetNUrgentTrack() const <<
665 { <<
666 return (G4int)urgentStack->GetNTrack(); <<
667 } <<
668 423
669 G4int G4StackManager::GetNWaitingTrack(int i) <<
670 { <<
671 if(i==0) <<
672 { <<
673 return (G4int)waitingStack->GetNTrack(); <<
674 } <<
675 <<
676 if(i<=numberOfAdditionalWaitingStacks) <<
677 { <<
678 return (G4int)additionalWaitingStacks[i-1] <<
679 } <<
680 <<
681 return 0; <<
682 } <<
683 424
684 G4int G4StackManager::GetNPostponedTrack() con <<
685 { <<
686 return (G4int)postponeStack->GetNTrack(); <<
687 } <<
688 <<
689 void G4StackManager::SetVerboseLevel( G4int co <<
690 { <<
691 verboseLevel = value; <<
692 for(auto& sets : subEvtStackMap) <<
693 { sets.second->SetVerboseLevel(value); } <<
694 } <<
695 <<
696 void G4StackManager::SetUserStackingAction(G4U <<
697 { <<
698 userStackingAction = value; <<
699 if(userStackingAction != nullptr) <<
700 { <<
701 userStackingAction->SetStackManager(this); <<
702 } <<
703 } <<
704 <<
705 void G4StackManager::DefineDefaultClassificati <<
706 { <<
707 fDefaultClassification = fUrgent; <<
708 fExceptionSeverity = G4ExceptionSeverity::Ig <<
709 <<
710 if(defClassPartDef.size()>0) <<
711 { <<
712 auto pdm = defClassPartDef.find(aTrack->Ge <<
713 if(pdm!=defClassPartDef.end()) <<
714 { <<
715 fDefaultClassification = pdm->second.fir <<
716 fExceptionSeverity = pdm->second.second; <<
717 } <<
718 } <<
719 else if(defClassTrackStatus.size()>0) <<
720 { <<
721 auto tsm = defClassTrackStatus.find(aTrack <<
722 if(tsm!=defClassTrackStatus.end()) <<
723 { <<
724 fDefaultClassification = tsm->second.fir <<
725 fExceptionSeverity = tsm->second.second; <<
726 } <<
727 } <<
728 else if( aTrack->GetTrackStatus() == fSuspen <<
729 { fDefaultClassification = fWaiting; } <<
730 else if( aTrack->GetTrackStatus() == fPostpo <<
731 { fDefaultClassification = fPostpone; } <<
732 } <<
733 <<
734 void G4StackManager::SetDefaultClassification( <<
735 G4ClassificationOfNewTrack val, G <<
736 { <<
737 auto tsm = defClassTrackStatus.find(ts); <<
738 if(tsm==defClassTrackStatus.end()) <<
739 { defClassTrackStatus[ts] = std::pair(val,es <<
740 else <<
741 { <<
742 if(tsm->second.first!=val) <<
743 { // alternating default classification <<
744 G4ExceptionDescription ed; <<
745 ed << "Default classification for track <<
746 << " is changed from " << tsm->second <<
747 << val << "."; <<
748 G4Exception("G4StackManager::SetDefaultC <<
749 "Event11051",JustWarning,ed) <<
750 tsm->second.first = val; <<
751 } <<
752 // Change severity if needed. <<
753 if(tsm->second.second>es) tsm->second.seco <<
754 } <<
755 } <<
756 <<
757 void G4StackManager::SetDefaultClassification( <<
758 G4ClassificationOfNewTrack val, G <<
759 { <<
760 auto pdm = defClassPartDef.find(pd); <<
761 if(pdm==defClassPartDef.end()) <<
762 { defClassPartDef[pd] = std::pair(val,es); } <<
763 else <<
764 { <<
765 if(pdm->second.first!=val) <<
766 { // alternating default classification <<
767 G4ExceptionDescription ed; <<
768 ed << "Default classification for partic <<
769 << " is changed from " << pdm->second <<
770 << val << "."; <<
771 G4Exception("G4StackManager::SetDefaultC <<
772 "Event11052", JustWarning,ed <<
773 pdm->second.first = val; <<
774 } <<
775 // Change severity if needed. <<
776 if(pdm->second.second>es) pdm->second.seco <<
777 } <<
778 } <<
779 <<
780 void G4StackManager::RegisterSubEventType(G4in <<
781 { <<
782 if(subEvtStackMap.find(ty)==subEvtStackMap.e <<
783 { <<
784 subEvtStackMap[ty] = new G4SubEventTrackSt <<
785 subEvtTypes.push_back(ty); <<
786 #ifdef G4VERBOSE <<
787 subEvtStackMap[ty]->SetVerboseLevel(verbos <<
788 if( verboseLevel > 0 ) <<
789 { <<
790 G4cout << " ---> New sub-event stack f <<
791 << ty << " is created. Classifica <<
792 << subEvtTypes.size() + 99 << "." <<
793 } <<
794 } <<
795 else <<
796 { <<
797 if( verboseLevel > 1 ) <<
798 { <<
799 G4cout << " ---> Sub-event stack for s <<
800 << ty << " already registered." < <<
801 } <<
802 #endif <<
803 } <<
804 } <<
805 <<
806 void G4StackManager::ReleaseSubEvent(G4int ty) <<
807 { <<
808 auto ses = subEvtStackMap.find(ty); <<
809 if(ses==subEvtStackMap.end()) <<
810 { <<
811 G4ExceptionDescription ED; <<
812 ED << "Un-registered sub-event type " << t <<
813 G4Exception("G4StackManager::PopSubEvent", <<
814 FatalException,ED); <<
815 return; // NOLINT: Required to silence Cov <<
816 } <<
817 <<
818 ses->second->ReleaseSubEvent(); <<
819 } <<
820 425
821 426
822 427