source: trunk/source/event/src/G4StackManager.cc@ 1041

Last change on this file since 1041 was 964, checked in by garnier, 17 years ago

update event
File size: 12.0 KB
RevLine 
[816]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// $Id: G4StackManager.cc,v 1.10 2006/06/29 18:10:19 gunter Exp $
[964]28// GEANT4 tag $Name: geant4-09-02-ref-02 $
[816]29//
30//
31// Last Modification : 09/Dec/96 M.Asai
32//
33
34#include "G4StackManager.hh"
35#include "G4StackingMessenger.hh"
36#include "G4VTrajectory.hh"
37#include "evmandefs.hh"
38#include "G4ios.hh"
39
40G4StackManager::G4StackManager()
41:userStackingAction(0),verboseLevel(0),numberOfAdditionalWaitingStacks(0)
42{
43 theMessenger = new G4StackingMessenger(this);
44 urgentStack = new G4TrackStack;
45 waitingStack = new G4TrackStack;
46 postponeStack = new G4TrackStack;
47}
48
49G4StackManager::~G4StackManager()
50{
51 if(userStackingAction) delete userStackingAction;
52 delete urgentStack;
53 delete waitingStack;
54 delete postponeStack;
55 delete theMessenger;
56 if(numberOfAdditionalWaitingStacks>0) {
57 for(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
58 delete additionalWaitingStacks[i];
59 }
60 }
61}
62
63const G4StackManager & G4StackManager::operator=
64(const G4StackManager &) { return *this; }
65G4int G4StackManager::operator==(const G4StackManager &)
66const{ return false; }
67G4int G4StackManager::operator!=(const G4StackManager &)
68const{ return true; }
69
70G4int 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
79 {
80#ifdef G4VERBOSE
81 if( verboseLevel > 0 )
82 {
83 G4cout << " ---> G4Track " << newTrack << " (trackID "
84 << newTrack->GetTrackID() << ", parentID "
85 << newTrack->GetParentID() << ") is not to be stored." << G4endl;
86 }
87#endif
88 delete newTrack;
89 delete newTrajectory;
90 }
91 else
92 {
93 G4StackedTrack * newStackedTrack = new G4StackedTrack( newTrack, newTrajectory );
94 switch (classification)
95 {
96 case fUrgent:
97 urgentStack->PushToStack( newStackedTrack );
98 break;
99 case fWaiting:
100 waitingStack->PushToStack( newStackedTrack );
101 break;
102 case fPostpone:
103 postponeStack->PushToStack( newStackedTrack );
104 break;
105 default:
106 G4int i = classification - 10;
107 if(i<1||i>numberOfAdditionalWaitingStacks) {
108 G4Exception("G4StackManager : invalid classification");
109 } else {
110 additionalWaitingStacks[i-1]->PushToStack( newStackedTrack );
111 }
112 break;
113 }
114 }
115
116 return GetNUrgentTrack();
117}
118
119
120G4Track * G4StackManager::PopNextTrack(G4VTrajectory**newTrajectory)
121{
122#ifdef G4VERBOSE
123 if( verboseLevel > 0 )
124 {
125 G4cout << "### pop requested out of "
126 << GetNUrgentTrack() << " stacked tracks." << G4endl;
127 }
128#endif
129
130 while( GetNUrgentTrack() == 0 )
131 {
132#ifdef G4VERBOSE
133 if( verboseLevel > 0 ) G4cout << "### " << GetNWaitingTrack()
134 << " waiting tracks are re-classified to" << G4endl;
135#endif
136 waitingStack->TransferTo(urgentStack);
137 if(numberOfAdditionalWaitingStacks>0) {
138 for(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
139 if(i==0) {
140 additionalWaitingStacks[0]->TransferTo(waitingStack);
141 } else {
142 additionalWaitingStacks[i]->TransferTo(additionalWaitingStacks[i-1]);
143 }
144 }
145 }
146 if(userStackingAction) userStackingAction->NewStage();
147#ifdef G4VERBOSE
148 if( verboseLevel > 0 ) G4cout << " " << GetNUrgentTrack()
149 << " urgent tracks and " << GetNWaitingTrack()
150 << " waiting tracks." << G4endl;
151#endif
152 if( ( GetNUrgentTrack()==0 ) && ( GetNWaitingTrack()==0 ) ) return 0;
153 }
154
155 G4StackedTrack * selectedStackedTrack = urgentStack->PopFromStack();
156 G4Track * selectedTrack = selectedStackedTrack->GetTrack();
157 *newTrajectory = selectedStackedTrack->GetTrajectory();
158
159#ifdef G4VERBOSE
160 if( verboseLevel > 1 )
161 {
162 G4cout << "Selected G4StackedTrack : " << selectedStackedTrack
163 << " with G4Track " << selectedStackedTrack->GetTrack()
164 << " (trackID " << selectedStackedTrack->GetTrack()->GetTrackID()
165 << ", parentID " << selectedStackedTrack->GetTrack()->GetParentID()
166 << ")" << G4endl;
167 }
168#endif
169
170 delete selectedStackedTrack;
171 return selectedTrack;
172}
173
174void G4StackManager::ReClassify()
175{
176 G4StackedTrack * aStackedTrack;
177 G4TrackStack tmpStack;
178
179 if( !userStackingAction ) return;
180 if( GetNUrgentTrack() == 0 ) return;
181
182 urgentStack->TransferTo(&tmpStack);
183 while( (aStackedTrack=tmpStack.PopFromStack()) != 0 )
184 {
185 G4ClassificationOfNewTrack classification =
186 userStackingAction->ClassifyNewTrack( aStackedTrack->GetTrack() );
187 switch (classification)
188 {
189 case fKill:
190 delete aStackedTrack->GetTrack();
191 delete aStackedTrack->GetTrajectory();
192 delete aStackedTrack;
193 break;
194 case fUrgent:
195 urgentStack->PushToStack( aStackedTrack );
196 break;
197 case fWaiting:
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 );
209 }
210 break;
211 }
212 }
213}
214
215G4int G4StackManager::PrepareNewEvent()
216{
217 if(userStackingAction) userStackingAction->PrepareNewEvent();
218
219 G4int n_passedFromPrevious = 0;
220
221 if( GetNPostponedTrack() > 0 )
222 {
223#ifdef G4VERBOSE
224 if( verboseLevel > 0 )
225 {
226 G4cout << GetNPostponedTrack()
227 << " postponed tracked are now shifted to the stack." << G4endl;
228 }
229#endif
230
231 G4StackedTrack * aStackedTrack;
232 G4TrackStack tmpStack;
233
234 postponeStack->TransferTo(&tmpStack);
235
236 while( (aStackedTrack=tmpStack.PopFromStack()) != 0 )
237 {
238 G4Track* aTrack = aStackedTrack->GetTrack();
239 aTrack->SetParentID(-1);
240 G4ClassificationOfNewTrack classification;
241 if(userStackingAction)
242 { classification = userStackingAction->ClassifyNewTrack( aTrack ); }
243 else
244 { classification = DefaultClassification( aTrack ); }
245
246 if(classification==fKill)
247 {
248 delete aTrack;
249 delete aStackedTrack->GetTrajectory();
250 delete aStackedTrack;
251 }
252 else
253 {
254 aTrack->SetTrackID(-(++n_passedFromPrevious));
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 }
275 }
276 }
277 }
278
279 return n_passedFromPrevious;
280}
281
282void G4StackManager::SetNumberOfAdditionalWaitingStacks(G4int iAdd)
283{
284 if(iAdd > numberOfAdditionalWaitingStacks)
285 {
286 for(int i=numberOfAdditionalWaitingStacks;i<iAdd;i++)
287 {
288 G4TrackStack* newStack = new G4TrackStack;
289 additionalWaitingStacks.push_back(newStack);
290 }
291 numberOfAdditionalWaitingStacks = iAdd;
292 }
293 else if (iAdd < numberOfAdditionalWaitingStacks)
294 {
295 for(int i=numberOfAdditionalWaitingStacks;i>iAdd;i--)
296 {
297 delete additionalWaitingStacks[i];
298 }
299 }
300}
301
302void G4StackManager::TransferStackedTracks(G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
303{
304 if(origin==destination) return;
305 G4TrackStack* originStack = 0;
306 switch(origin)
307 {
308 case fUrgent:
309 originStack = urgentStack;
310 break;
311 case fWaiting:
312 originStack = waitingStack;
313 break;
314 case fPostpone:
315 originStack = postponeStack;
316 break;
317 case fKill:
318 break;
319 default:
320 int i = origin - 10;
321 if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
322 break;
323 }
324 if(!originStack) return;
325
326 if(destination==fKill)
327 {
328 G4StackedTrack * aStackedTrack;
329 while( (aStackedTrack=originStack->PopFromStack()) != 0 )
330 {
331 delete aStackedTrack->GetTrack();
332 delete aStackedTrack->GetTrajectory();
333 delete aStackedTrack;
334 }
335 }
336 else
337 {
338 G4TrackStack* targetStack = 0;
339 switch(destination)
340 {
341 case fUrgent:
342 targetStack = urgentStack;
343 break;
344 case fWaiting:
345 targetStack = waitingStack;
346 break;
347 case fPostpone:
348 targetStack = postponeStack;
349 break;
350 default:
351 int i = origin - 10;
352 if(i<=numberOfAdditionalWaitingStacks) targetStack = additionalWaitingStacks[i-1];
353 break;
354 }
355 if(!targetStack) return;
356 originStack->TransferTo(targetStack);
357 }
358 return;
359}
360
361void G4StackManager::TransferOneStackedTrack(G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
362{
363 if(origin==destination) return;
364 G4TrackStack* originStack = 0;
365 switch(origin)
366 {
367 case fUrgent:
368 originStack = urgentStack;
369 break;
370 case fWaiting:
371 originStack = waitingStack;
372 break;
373 case fPostpone:
374 originStack = postponeStack;
375 break;
376 case fKill:
377 break;
378 default:
379 int i = origin - 10;
380 if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
381 break;
382 }
383 if(!originStack) return;
384
385 G4StackedTrack * aStackedTrack;
386 if(destination==fKill)
387 {
388 if( (aStackedTrack=originStack->PopFromStack()) != 0 )
389 {
390 delete aStackedTrack->GetTrack();
391 delete aStackedTrack->GetTrajectory();
392 delete aStackedTrack;
393 }
394 }
395 else
396 {
397 G4TrackStack* targetStack = 0;
398 switch(destination)
399 {
400 case fUrgent:
401 targetStack = urgentStack;
402 break;
403 case fWaiting:
404 targetStack = waitingStack;
405 break;
406 case fPostpone:
407 targetStack = postponeStack;
408 break;
409 default:
410 int i = origin - 10;
411 if(i<=numberOfAdditionalWaitingStacks) targetStack = additionalWaitingStacks[i-1];
412 break;
413 }
414 if(!targetStack) return;
415 if( (aStackedTrack=originStack->PopFromStack()) != 0 )
416 {
417 targetStack->PushToStack(aStackedTrack);
418 }
419 }
420 return;
421}
422
423
424
425
426
Note: See TracBrowser for help on using the repository browser.