Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4EventManager.cc
Go to the documentation of this file.
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$
28//
29//
30//
31
32#include "G4EventManager.hh"
33#include "G4ios.hh"
34#include "G4EvManMessenger.hh"
35#include "G4Event.hh"
36#include "G4UserEventAction.hh"
38#include "G4SDManager.hh"
39#include "G4StateManager.hh"
40#include "G4ApplicationState.hh"
42#include "G4Navigator.hh"
43#include "Randomize.hh"
44
45G4EventManager* G4EventManager::fpEventManager = 0;
47{ return fpEventManager; }
48
50:currentEvent(0),trajectoryContainer(0),
51 verboseLevel(0),tracking(false),abortRequested(false),
52 storetRandomNumberStatusToG4Event(false)
53{
54 if(fpEventManager)
55 {
56 G4Exception("G4EventManager::G4EventManager","Event0001",FatalException,
57 "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);
66 fpEventManager = this;
67 userEventAction = 0;
68 userStackingAction = 0;
69 userTrackingAction = 0;
70 userSteppingAction = 0;
71 }
72}
73
74// private -> never called
76G4EventManager& G4EventManager::operator=(const G4EventManager&)
77{ return *this; }
78
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 abortRequested = false;
102 G4ApplicationState currentState = stateManager->GetCurrentState();
103 if(currentState!=G4State_GeomClosed)
104 {
105 G4Exception("G4EventManager::ProcessOneEvent",
106 "Event0002", JustWarning,
107 "IllegalApplicationState -- Geometry is not closed : cannot process an event.");
108 return;
109 }
110 currentEvent = anEvent;
111 stateManager->SetNewState(G4State_EventProc);
112 if(storetRandomNumberStatusToG4Event>1)
113 {
114 std::ostringstream oss;
116 randomNumberStatusToG4Event = oss.str();
117 currentEvent->SetRandomNumberStatusForProcessing(randomNumberStatusToG4Event);
118 }
119
120 // Reseting Navigator has been moved to G4Eventmanager, so that resetting
121 // is now done for every event.
122 G4ThreeVector center(0,0,0);
123 G4Navigator* navigator =
125 navigator->LocateGlobalPointAndSetup(center,0,false);
126
127 G4Track * track;
128 G4TrackStatus istop;
129
130#ifdef G4VERBOSE
131 if ( verboseLevel > 0 )
132 {
133 G4cout << "=====================================" << G4endl;
134 G4cout << " G4EventManager::ProcessOneEvent() " << G4endl;
135 G4cout << "=====================================" << G4endl;
136 }
137#endif
138
139 trackContainer->PrepareNewEvent();
140
141#ifdef G4_STORE_TRAJECTORY
142 trajectoryContainer = 0;
143#endif
144
146 if(sdManager)
147 { currentEvent->SetHCofThisEvent(sdManager->PrepareNewEvent()); }
148
149 if(userEventAction) userEventAction->BeginOfEventAction(currentEvent);
150
151#ifdef G4VERBOSE
152 if ( verboseLevel > 1 )
153 {
154 G4cout << currentEvent->GetNumberOfPrimaryVertex()
155 << " vertices passed from G4Event." << G4endl;
156 }
157#endif
158
159 if(!abortRequested)
160 { StackTracks( transformer->GimmePrimaries( currentEvent, trackIDCounter ),true ); }
161
162#ifdef G4VERBOSE
163 if ( verboseLevel > 0 )
164 {
165 G4cout << trackContainer->GetNTotalTrack() << " primaries "
166 << "are passed from G4EventTransformer." << G4endl;
167 G4cout << "!!!!!!! Now start processing an event !!!!!!!" << G4endl;
168 }
169#endif
170
171 G4VTrajectory* previousTrajectory;
172 while( ( track = trackContainer->PopNextTrack(&previousTrajectory) ) != 0 )
173 {
174
175#ifdef G4VERBOSE
176 if ( verboseLevel > 1 )
177 {
178 G4cout << "Track " << track << " (trackID " << track->GetTrackID()
179 << ", parentID " << track->GetParentID()
180 << ") is passed to G4TrackingManager." << G4endl;
181 }
182#endif
183
184 tracking = true;
185 trackManager->ProcessOneTrack( track );
186 istop = track->GetTrackStatus();
187 tracking = false;
188
189#ifdef G4VERBOSE
190 if ( verboseLevel > 0 )
191 {
192 G4cout << "Track (trackID " << track->GetTrackID()
193 << ", parentID " << track->GetParentID()
194 << ") is processed with stopping code " << istop << G4endl;
195 }
196#endif
197
198 G4VTrajectory * aTrajectory = 0;
199#ifdef G4_STORE_TRAJECTORY
200 aTrajectory = trackManager->GimmeTrajectory();
201
202 if(previousTrajectory)
203 {
204 previousTrajectory->MergeTrajectory(aTrajectory);
205 delete aTrajectory;
206 aTrajectory = previousTrajectory;
207 }
208 if(aTrajectory&&(istop!=fStopButAlive)&&(istop!=fSuspend))
209 {
210 if(!trajectoryContainer)
211 { trajectoryContainer = new G4TrajectoryContainer;
212 currentEvent->SetTrajectoryContainer(trajectoryContainer); }
213 trajectoryContainer->insert(aTrajectory);
214 }
215#endif
216
217 G4TrackVector * secondaries = trackManager->GimmeSecondaries();
218 switch (istop)
219 {
220 case fStopButAlive:
221 case fSuspend:
222 trackContainer->PushOneTrack( track, aTrajectory );
223 StackTracks( secondaries );
224 break;
225
227 trackContainer->PushOneTrack( track );
228 StackTracks( secondaries );
229 break;
230
231 case fStopAndKill:
232 StackTracks( secondaries );
233 delete track;
234 break;
235
236 case fAlive:
237 G4cout << "Illeagal TrackStatus returned from G4TrackingManager!"
238 << G4endl;
240 //if( secondaries ) secondaries->clearAndDestroy();
241 if( secondaries )
242 {
243 for(size_t i=0;i<secondaries->size();i++)
244 { delete (*secondaries)[i]; }
245 secondaries->clear();
246 }
247 delete track;
248 break;
249 }
250 }
251
252#ifdef G4VERBOSE
253 if ( verboseLevel > 0 )
254 {
255 G4cout << "NULL returned from G4StackManager." << G4endl;
256 G4cout << "Terminate current event processing." << G4endl;
257 }
258#endif
259
260 if(sdManager)
261 { sdManager->TerminateCurrentEvent(currentEvent->GetHCofThisEvent()); }
262
263 if(userEventAction) userEventAction->EndOfEventAction(currentEvent);
264
265 stateManager->SetNewState(G4State_GeomClosed);
266 currentEvent = 0;
267 abortRequested = false;
268}
269
270void G4EventManager::StackTracks(G4TrackVector *trackVector,G4bool IDhasAlreadySet)
271{
272 G4Track * newTrack;
273
274 if( trackVector )
275 {
276
277 size_t n_passedTrack = trackVector->size();
278 if( n_passedTrack == 0 ) return;
279 for( size_t i = 0; i < n_passedTrack; i++ )
280 {
281 newTrack = (*trackVector)[ i ];
282 trackIDCounter++;
283 if(!IDhasAlreadySet)
284 {
285 newTrack->SetTrackID( trackIDCounter );
286 if(newTrack->GetDynamicParticle()->GetPrimaryParticle())
287 {
290 pp->SetTrackID(trackIDCounter);
291 }
292 }
293 newTrack->SetOriginTouchableHandle(newTrack->GetTouchableHandle());
294 trackContainer->PushOneTrack( newTrack );
295#ifdef G4VERBOSE
296 if ( verboseLevel > 1 )
297 {
298 G4cout << "A new track " << newTrack
299 << " (trackID " << newTrack->GetTrackID()
300 << ", parentID " << newTrack->GetParentID()
301 << ") is passed to G4StackManager." << G4endl;
302 }
303#endif
304 }
305 trackVector->clear();
306 }
307}
308
310{
311 userEventAction = userAction;
312 if(userEventAction) userEventAction->SetEventManager(this);
313}
314
316{
317 userStackingAction = userAction;
318 trackContainer->SetUserStackingAction(userAction);
319}
320
322{
323 userTrackingAction = userAction;
324 trackManager->SetUserAction(userAction);
325}
326
328{
329 userSteppingAction = userAction;
330 trackManager->SetUserAction(userAction);
331}
332
334{
335 trackIDCounter = 0;
336 DoProcessing(anEvent);
337}
338
340{
341 static G4String randStat;
342 trackIDCounter = 0;
343 G4bool tempEvent = false;
344 if(!anEvent)
345 {
346 anEvent = new G4Event();
347 tempEvent = true;
348 }
349 if(storetRandomNumberStatusToG4Event==1 || storetRandomNumberStatusToG4Event==3)
350 {
351 std::ostringstream oss;
353 anEvent->SetRandomNumberStatus(randStat=oss.str());
354 }
355 StackTracks(trackVector,false);
356 DoProcessing(anEvent);
357 if(tempEvent)
358 { delete anEvent; }
359}
360
362{
364 G4ApplicationState currentState = stateManager->GetCurrentState();
365 if(currentState!=G4State_EventProc || currentEvent==0)
366 {
367 G4Exception("G4EventManager::SetUserInformation",
368 "Event0003", JustWarning,
369 "G4VUserEventInformation cannot be set because of ansense of G4Event.");
370 return;
371 }
372
373 currentEvent->SetUserInformation(anInfo);
374}
375
377{
379 G4ApplicationState currentState = stateManager->GetCurrentState();
380 if(currentState!=G4State_EventProc || currentEvent==0)
381 { return 0; }
382
383 return currentEvent->GetUserInformation();
384}
385
387{ if(currentEvent) currentEvent->KeepTheEvent(); }
388
390{
391 abortRequested = true;
392 trackContainer->clear();
393 if(tracking) trackManager->EventAborted();
394}
395
G4ApplicationState
@ G4State_EventProc
@ G4State_GeomClosed
@ JustWarning
@ FatalException
G4TrackStatus
@ fKillTrackAndSecondaries
@ fSuspend
@ fAlive
@ fStopAndKill
@ fStopButAlive
@ fPostponeToNextEvent
std::vector< G4Track * > G4TrackVector
bool G4bool
Definition: G4Types.hh:67
#define G4endl
Definition: G4ios.hh:52
G4DLLIMPORT std::ostream G4cout
static std::ostream & saveFullState(std::ostream &os)
Definition: Random.cc:185
G4PrimaryParticle * GetPrimaryParticle() const
void SetUserAction(G4UserEventAction *userAction)
void SetUserInformation(G4VUserEventInformation *anInfo)
void KeepTheCurrentEvent()
void AbortCurrentEvent()
static G4EventManager * GetEventManager()
void ProcessOneEvent(G4Event *anEvent)
G4VUserEventInformation * GetUserInformation()
G4int GetNumberOfPrimaryVertex() const
Definition: G4Event.hh:152
void SetRandomNumberStatus(G4String &st)
Definition: G4Event.hh:123
void KeepTheEvent(G4bool vl=true)
Definition: G4Event.hh:133
G4HCofThisEvent * GetHCofThisEvent() const
Definition: G4Event.hh:173
void SetRandomNumberStatusForProcessing(G4String &st)
Definition: G4Event.hh:128
void SetHCofThisEvent(G4HCofThisEvent *value)
Definition: G4Event.hh:115
void SetUserInformation(G4VUserEventInformation *anInfo)
Definition: G4Event.hh:186
G4VUserEventInformation * GetUserInformation() const
Definition: G4Event.hh:187
void SetTrajectoryContainer(G4TrajectoryContainer *value)
Definition: G4Event.hh:119
virtual G4VPhysicalVolume * LocateGlobalPointAndSetup(const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
Definition: G4Navigator.cc:116
G4TrackVector * GimmePrimaries(G4Event *anEvent, G4int trackIDCounter=0)
void TerminateCurrentEvent(G4HCofThisEvent *HCE)
Definition: G4SDManager.cc:114
G4HCofThisEvent * PrepareNewEvent()
Definition: G4SDManager.cc:107
static G4SDManager * GetSDMpointerIfExist()
Definition: G4SDManager.cc:49
G4int GetNTotalTrack() const
G4Track * PopNextTrack(G4VTrajectory **newTrajectory)
G4int PushOneTrack(G4Track *newTrack, G4VTrajectory *newTrajectory=0)
G4int PrepareNewEvent()
void SetUserStackingAction(G4UserStackingAction *value)
G4ApplicationState GetCurrentState() const
static G4StateManager * GetStateManager()
G4bool SetNewState(G4ApplicationState requestedState)
G4TrackStatus GetTrackStatus() const
G4int GetTrackID() const
void SetOriginTouchableHandle(const G4TouchableHandle &apValue)
const G4DynamicParticle * GetDynamicParticle() const
const G4TouchableHandle & GetTouchableHandle() const
void SetTrackID(const G4int aValue)
G4int GetParentID() const
void SetUserAction(G4UserTrackingAction *apAction)
G4TrackVector * GimmeSecondaries() const
void ProcessOneTrack(G4Track *apValueG4Track)
G4VTrajectory * GimmeTrajectory() const
G4bool insert(G4VTrajectory *p)
static G4TransportationManager * GetTransportationManager()
G4Navigator * GetNavigatorForTracking() const
void SetEventManager(G4EventManager *value)
virtual void BeginOfEventAction(const G4Event *anEvent)
virtual void EndOfEventAction(const G4Event *anEvent)
virtual void MergeTrajectory(G4VTrajectory *secondTrajectory)=0
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41