source: trunk/source/event/src/G4EventManager.cc@ 1111

Last change on this file since 1111 was 1058, checked in by garnier, 17 years ago

file release beta
File size: 12.3 KB
Line 
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: G4EventManager.cc,v 1.30 2007/03/08 23:56:12 asaim Exp $
28// GEANT4 tag $Name: geant4-09-02-ref-02 $
29//
30//
31//
32
33#include "G4EventManager.hh"
34#include "G4ios.hh"
35#include "G4EvManMessenger.hh"
36#include "G4Event.hh"
37#include "G4UserEventAction.hh"
38#include "G4UserStackingAction.hh"
39#include "G4SDManager.hh"
40#include "G4StateManager.hh"
41#include "G4ApplicationState.hh"
42#include "G4TransportationManager.hh"
43#include "G4Navigator.hh"
44#include "Randomize.hh"
45
46G4EventManager* G4EventManager::fpEventManager = 0;
47G4EventManager* G4EventManager::GetEventManager()
48{ return fpEventManager; }
49
50G4EventManager::G4EventManager()
51:currentEvent(0),trajectoryContainer(0),
52 verboseLevel(0),tracking(false),abortRequested(false),
53 storetRandomNumberStatusToG4Event(false)
54{
55 if(fpEventManager)
56 {
57 G4Exception("G4EventManager::G4EventManager() has already been made.");
58 }
59 else
60 {
61 trackManager = new G4TrackingManager;
62 transformer = new G4PrimaryTransformer;
63 trackContainer = new G4StackManager;
64 theMessenger = new G4EvManMessenger(this);
65 sdManager = G4SDManager::GetSDMpointerIfExist();
66 fpEventManager = this;
67 userEventAction = 0;
68 userStackingAction = 0;
69 userTrackingAction = 0;
70 userSteppingAction = 0;
71 }
72}
73
74// private -> never called
75G4EventManager::G4EventManager(const G4EventManager&) {;}
76G4EventManager& G4EventManager::operator=(const G4EventManager&)
77{ return *this; }
78
79G4EventManager::~G4EventManager()
80{
81 delete trackContainer;
82 delete transformer;
83 delete trackManager;
84 delete theMessenger;
85 if(userEventAction) delete userEventAction;
86 fpEventManager = 0;
87}
88
89/*
90const G4EventManager & G4EventManager::operator=(const G4EventManager &right)
91{ }
92G4int G4EventManager::operator==(const G4EventManager &right) const { }
93G4int G4EventManager::operator!=(const G4EventManager &right) const { }
94*/
95
96
97
98void G4EventManager::DoProcessing(G4Event* anEvent)
99{
100 printf("G4EventManager::DoProcessing vvvvvvvvvvvvvvvvvvvvvvv\n");
101 G4StateManager* stateManager = G4StateManager::GetStateManager();
102 G4ApplicationState currentState = stateManager->GetCurrentState();
103 if(currentState!=G4State_GeomClosed)
104 {
105 G4Exception("G4EventManager::ProcessOneEvent",
106 "IllegalApplicationState",
107 JustWarning,
108 "Geometry is not closed : cannot process an event.");
109 return;
110 }
111 currentEvent = anEvent;
112 stateManager->SetNewState(G4State_EventProc);
113 if(storetRandomNumberStatusToG4Event>1)
114 {
115 std::ostringstream oss;
116 CLHEP::HepRandom::saveFullState(oss);
117 randomNumberStatusToG4Event = oss.str();
118 currentEvent->SetRandomNumberStatusForProcessing(randomNumberStatusToG4Event);
119 }
120
121 // Reseting Navigator has been moved to G4Eventmanager, so that resetting
122 // is now done for every event.
123 G4ThreeVector center(0,0,0);
124 G4Navigator* navigator =
125 G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
126 navigator->LocateGlobalPointAndSetup(center,0,false);
127
128 G4Track * track;
129 G4TrackStatus istop;
130
131#ifdef G4VERBOSE
132 if ( verboseLevel > 0 )
133 {
134 G4cout << "=====================================" << G4endl;
135 G4cout << " G4EventManager::ProcessOneEvent() " << G4endl;
136 G4cout << "=====================================" << G4endl;
137 }
138#endif
139
140 trackContainer->PrepareNewEvent();
141
142#ifdef G4_STORE_TRAJECTORY
143 trajectoryContainer = 0;
144#endif
145
146 sdManager = G4SDManager::GetSDMpointerIfExist();
147 if(sdManager)
148 { currentEvent->SetHCofThisEvent(sdManager->PrepareNewEvent()); }
149
150 if(userEventAction) userEventAction->BeginOfEventAction(currentEvent);
151
152#ifdef G4VERBOSE
153 if ( verboseLevel > 1 )
154 {
155 G4cout << currentEvent->GetNumberOfPrimaryVertex()
156 << " vertices passed from G4Event." << G4endl;
157 }
158#endif
159
160 if(!abortRequested)
161 { StackTracks( transformer->GimmePrimaries( currentEvent, trackIDCounter ),true ); }
162
163#ifdef G4VERBOSE
164 if ( verboseLevel > 0 )
165 {
166 G4cout << trackContainer->GetNTotalTrack() << " primaries "
167 << "are passed from G4EventTransformer." << G4endl;
168 G4cout << "!!!!!!! Now start processing an event !!!!!!!" << G4endl;
169 }
170#endif
171
172 G4VTrajectory* previousTrajectory;
173 while( ( track = trackContainer->PopNextTrack(&previousTrajectory) ) != 0 )
174 {
175
176#ifdef G4VERBOSE
177 if ( verboseLevel > 1 )
178 {
179 G4cout << "Track " << track << " (trackID " << track->GetTrackID()
180 << ", parentID " << track->GetParentID()
181 << ") is passed to G4TrackingManager." << G4endl;
182 }
183#endif
184
185 tracking = true;
186 trackManager->ProcessOneTrack( track );
187 istop = track->GetTrackStatus();
188 tracking = false;
189
190#ifdef G4VERBOSE
191 if ( verboseLevel > 0 )
192 {
193 G4cout << "Track (trackID " << track->GetTrackID()
194 << ", parentID " << track->GetParentID()
195 << ") is processed with stopping code " << istop << G4endl;
196 }
197#endif
198
199 G4VTrajectory * aTrajectory = 0;
200#ifdef G4_STORE_TRAJECTORY
201 aTrajectory = trackManager->GimmeTrajectory();
202
203 if(previousTrajectory)
204 {
205 previousTrajectory->MergeTrajectory(aTrajectory);
206 delete aTrajectory;
207 aTrajectory = previousTrajectory;
208 }
209 if(aTrajectory&&(istop!=fStopButAlive)&&(istop!=fSuspend))
210 {
211 if(!trajectoryContainer)
212 { trajectoryContainer = new G4TrajectoryContainer;
213 currentEvent->SetTrajectoryContainer(trajectoryContainer); }
214 trajectoryContainer->insert(aTrajectory);
215 }
216#endif
217
218 G4TrackVector * secondaries = trackManager->GimmeSecondaries();
219 switch (istop)
220 {
221 case fStopButAlive:
222 case fSuspend:
223 trackContainer->PushOneTrack( track, aTrajectory );
224 StackTracks( secondaries );
225 break;
226
227 case fPostponeToNextEvent:
228 trackContainer->PushOneTrack( track );
229 StackTracks( secondaries );
230 break;
231
232 case fStopAndKill:
233 StackTracks( secondaries );
234 delete track;
235 break;
236
237 case fAlive:
238 G4cout << "Illeagal TrackStatus returned from G4TrackingManager!"
239 << G4endl;
240 case fKillTrackAndSecondaries:
241 //if( secondaries ) secondaries->clearAndDestroy();
242 if( secondaries )
243 {
244 for(size_t i=0;i<secondaries->size();i++)
245 { delete (*secondaries)[i]; }
246 secondaries->clear();
247 }
248 delete track;
249 break;
250 }
251 }
252
253#ifdef G4VERBOSE
254 if ( verboseLevel > 0 )
255 {
256 G4cout << "NULL returned from G4StackManager." << G4endl;
257 G4cout << "Terminate current event processing." << G4endl;
258 }
259#endif
260
261 if(sdManager)
262 { sdManager->TerminateCurrentEvent(currentEvent->GetHCofThisEvent()); }
263
264 if(userEventAction) userEventAction->EndOfEventAction(currentEvent);
265
266 stateManager->SetNewState(G4State_GeomClosed);
267 currentEvent = 0;
268 abortRequested = false;
269 printf("G4EventManager::DoProcessing ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
270}
271
272void G4EventManager::StackTracks(G4TrackVector *trackVector,G4bool IDhasAlreadySet)
273{
274 G4Track * newTrack;
275
276 if( trackVector )
277 {
278
279 size_t n_passedTrack = trackVector->size();
280 if( n_passedTrack == 0 ) return;
281 for( size_t i = 0; i < n_passedTrack; i++ )
282 {
283 newTrack = (*trackVector)[ i ];
284 trackIDCounter++;
285 if(!IDhasAlreadySet)
286 {
287 newTrack->SetTrackID( trackIDCounter );
288 if(newTrack->GetDynamicParticle()->GetPrimaryParticle())
289 {
290 G4PrimaryParticle* pp
291 = (G4PrimaryParticle*)(newTrack->GetDynamicParticle()->GetPrimaryParticle());
292 pp->SetTrackID(trackIDCounter);
293 }
294 }
295 trackContainer->PushOneTrack( newTrack );
296#ifdef G4VERBOSE
297 if ( verboseLevel > 1 )
298 {
299 G4cout << "A new track " << newTrack
300 << " (trackID " << newTrack->GetTrackID()
301 << ", parentID " << newTrack->GetParentID()
302 << ") is passed to G4StackManager." << G4endl;
303 }
304#endif
305 }
306 trackVector->clear();
307 }
308}
309
310void G4EventManager::SetUserAction(G4UserEventAction* userAction)
311{
312 userEventAction = userAction;
313 if(userEventAction) userEventAction->SetEventManager(this);
314}
315
316void G4EventManager::SetUserAction(G4UserStackingAction* userAction)
317{
318 userStackingAction = userAction;
319 trackContainer->SetUserStackingAction(userAction);
320}
321
322void G4EventManager::SetUserAction(G4UserTrackingAction* userAction)
323{
324 userTrackingAction = userAction;
325 trackManager->SetUserAction(userAction);
326}
327
328void G4EventManager::SetUserAction(G4UserSteppingAction* userAction)
329{
330 userSteppingAction = userAction;
331 trackManager->SetUserAction(userAction);
332}
333
334void G4EventManager::ProcessOneEvent(G4Event* anEvent)
335{
336 trackIDCounter = 0;
337 DoProcessing(anEvent);
338}
339
340#ifdef CLHEP_HepMC // Temporarly disabled
341#include "G4HepMCInterface.hh"
342void G4EventManager::ProcessOneEvent(const HepMC::GenEvent* hepmcevt,G4Event* anEvent)
343{
344 static G4String randStat;
345 trackIDCounter = 0;
346 G4bool tempEvent = false;
347 if(!anEvent)
348 {
349 anEvent = new G4Event();
350 tempEvent = true;
351 }
352 if(storetRandomNumberStatusToG4Event==1 || storetRandomNumberStatusToG4Event==3)
353 {
354 std::ostringstream oss;
355 CLHEP::HepRandom::saveFullState(oss);
356 anEvent->SetRandomNumberStatus(randStat=oss.str());
357 }
358 G4HepMCInterface::HepMC2G4(hepmcevt,anEvent);
359 DoProcessing(anEvent);
360 if(tempEvent)
361 { delete anEvent; }
362}
363#endif
364
365void G4EventManager::ProcessOneEvent(G4TrackVector* trackVector,G4Event* anEvent)
366{
367 static G4String randStat;
368 trackIDCounter = 0;
369 G4bool tempEvent = false;
370 if(!anEvent)
371 {
372 anEvent = new G4Event();
373 tempEvent = true;
374 }
375 if(storetRandomNumberStatusToG4Event==1 || storetRandomNumberStatusToG4Event==3)
376 {
377 std::ostringstream oss;
378 CLHEP::HepRandom::saveFullState(oss);
379 anEvent->SetRandomNumberStatus(randStat=oss.str());
380 }
381 StackTracks(trackVector,false);
382 DoProcessing(anEvent);
383 if(tempEvent)
384 { delete anEvent; }
385}
386
387void G4EventManager::SetUserInformation(G4VUserEventInformation* anInfo)
388{
389 G4StateManager* stateManager = G4StateManager::GetStateManager();
390 G4ApplicationState currentState = stateManager->GetCurrentState();
391 if(currentState!=G4State_EventProc || currentEvent==0)
392 {
393 G4Exception("G4EventManager::SetUserInformation",
394 "IllegalApplicationState",
395 JustWarning,
396 "G4VUserEventInformation cannot be set because of ansense of G4Event.");
397 return;
398 }
399
400 currentEvent->SetUserInformation(anInfo);
401}
402
403G4VUserEventInformation* G4EventManager::GetUserInformation()
404{
405 G4StateManager* stateManager = G4StateManager::GetStateManager();
406 G4ApplicationState currentState = stateManager->GetCurrentState();
407 if(currentState!=G4State_EventProc || currentEvent==0)
408 { return 0; }
409
410 return currentEvent->GetUserInformation();
411}
412
413void G4EventManager::KeepTheCurrentEvent()
414{ if(currentEvent) currentEvent->KeepTheEvent(); }
415
416
Note: See TracBrowser for help on using the repository browser.