Geant4  10.01
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: G4EventManager.cc 71031 2013-06-10 09:11:38Z gcosmo $
28 //
29 //
30 //
31 
32 #include "G4EventManager.hh"
33 #include "G4ios.hh"
34 #include "G4EvManMessenger.hh"
35 #include "G4Event.hh"
36 #include "G4UserEventAction.hh"
37 #include "G4UserStackingAction.hh"
38 #include "G4SDManager.hh"
39 #include "G4StateManager.hh"
40 #include "G4ApplicationState.hh"
42 #include "G4Navigator.hh"
43 #include "Randomize.hh"
44 
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  {
64  theMessenger = new G4EvManMessenger(this);
67  fpEventManager = this;
68  userEventAction = 0;
72  }
73 }
74 
75 // private -> never called
78 { return *this; }
79 
81 {
82  delete trackContainer;
83  delete transformer;
84  delete trackManager;
85  delete theMessenger;
87  fpEventManager = 0;
88 }
89 
90 /*
91 const G4EventManager & G4EventManager::operator=(const G4EventManager &right)
92 { }
93 G4int G4EventManager::operator==(const G4EventManager &right) const { }
94 G4int G4EventManager::operator!=(const G4EventManager &right) const { }
95 */
96 
97 
98 
100 {
101  abortRequested = false;
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;
113  {
114  std::ostringstream oss;
115  CLHEP::HepRandom::saveFullState(oss);
116  randomNumberStatusToG4Event = oss.str();
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 
140 
141 #ifdef G4_STORE_TRAJECTORY
143 #endif
144 
146  if(sdManager)
148 
150 
151 #ifdef G4VERBOSE
152  if ( verboseLevel > 1 )
153  {
155  << " vertices passed from G4Event." << G4endl;
156  }
157 #endif
158 
159  if(!abortRequested)
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  {
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)
262 
264 
266  currentEvent = 0;
267  abortRequested = false;
268 }
269 
270 void 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  {
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;
313 }
314 
316 {
317  userStackingAction = 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 G4ThreadLocal G4String *randStat = 0;
342  if (!randStat) randStat = new G4String;
343  trackIDCounter = 0;
344  G4bool tempEvent = false;
345  if(!anEvent)
346  {
347  anEvent = new G4Event();
348  tempEvent = true;
349  }
351  {
352  std::ostringstream oss;
353  CLHEP::HepRandom::saveFullState(oss);
354  anEvent->SetRandomNumberStatus(*randStat=oss.str());
355  }
356  StackTracks(trackVector,false);
357  DoProcessing(anEvent);
358  if(tempEvent)
359  { delete anEvent; }
360 }
361 
363 {
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 
374 }
375 
377 {
379  if(currentState!=G4State_EventProc || currentEvent==0)
380  { return 0; }
381 
383 }
384 
387 
389 {
390  abortRequested = true;
393 }
394 
G4int GetParentID() const
G4VTrajectory * GimmeTrajectory() const
G4UserEventAction * userEventAction
G4VUserEventInformation * GetUserInformation() const
Definition: G4Event.hh:199
void ProcessOneTrack(G4Track *apValueG4Track)
G4TrackVector * GimmePrimaries(G4Event *anEvent, G4int trackIDCounter=0)
void SetOriginTouchableHandle(const G4TouchableHandle &apValue)
CLHEP::Hep3Vector G4ThreeVector
G4Event * currentEvent
const G4DynamicParticle * GetDynamicParticle() const
virtual void EndOfEventAction(const G4Event *anEvent)
G4int GetNumberOfPrimaryVertex() const
Definition: G4Event.hh:164
G4UserTrackingAction * userTrackingAction
G4TrackingManager * trackManager
G4int GetNTotalTrack() const
G4TrackStatus GetTrackStatus() const
G4SDManager * sdManager
G4Navigator * GetNavigatorForTracking() const
void SetRandomNumberStatusForProcessing(G4String &st)
Definition: G4Event.hh:130
void SetHCofThisEvent(G4HCofThisEvent *value)
Definition: G4Event.hh:117
virtual void BeginOfEventAction(const G4Event *anEvent)
G4Track * PopNextTrack(G4VTrajectory **newTrajectory)
G4int storetRandomNumberStatusToG4Event
#define G4ThreadLocal
Definition: tls.hh:84
G4StackManager * trackContainer
void TerminateCurrentEvent(G4HCofThisEvent *HCE)
Definition: G4SDManager.cc:112
virtual void MergeTrajectory(G4VTrajectory *secondTrajectory)=0
static G4StateManager * GetStateManager()
void SetUserInformation(G4VUserEventInformation *anInfo)
Definition: G4Event.hh:198
void SetUserStackingAction(G4UserStackingAction *value)
G4GLOB_DLL std::ostream G4cout
G4bool SetNewState(G4ApplicationState requestedState)
G4TrackVector * GimmeSecondaries() const
G4EvManMessenger * theMessenger
void SetUserInformation(G4VUserEventInformation *anInfo)
bool G4bool
Definition: G4Types.hh:79
void SetEventManager(G4EventManager *value)
G4TrajectoryContainer * trajectoryContainer
void SetTrackID(G4int id)
G4String randomNumberStatusToG4Event
G4int PushOneTrack(G4Track *newTrack, G4VTrajectory *newTrajectory=0)
G4int PrepareNewEvent()
G4EventManager & operator=(const G4EventManager &right)
G4int GetTrackID() const
G4ApplicationState GetCurrentState() const
G4PrimaryParticle * GetPrimaryParticle() const
const G4TouchableHandle & GetTouchableHandle() const
static G4ThreadLocal G4EventManager * fpEventManager
void SetUserAction(G4UserTrackingAction *apAction)
G4bool insert(G4VTrajectory *p)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
void SetRandomNumberStatus(G4String &st)
Definition: G4Event.hh:125
G4PrimaryTransformer * transformer
static G4TransportationManager * GetTransportationManager()
G4HCofThisEvent * PrepareNewEvent()
Definition: G4SDManager.cc:105
G4UserStackingAction * userStackingAction
void StackTracks(G4TrackVector *trackVector, G4bool IDhasAlreadySet=false)
std::vector< G4Track * > G4TrackVector
G4StateManager * stateManager
void SetUserAction(G4UserEventAction *userAction)
G4UserSteppingAction * userSteppingAction
static G4EventManager * GetEventManager()
virtual G4VPhysicalVolume * LocateGlobalPointAndSetup(const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
Definition: G4Navigator.cc:122
void AbortCurrentEvent()
#define G4endl
Definition: G4ios.hh:61
void ProcessOneEvent(G4Event *anEvent)
G4HCofThisEvent * GetHCofThisEvent() const
Definition: G4Event.hh:185
void SetTrajectoryContainer(G4TrajectoryContainer *value)
Definition: G4Event.hh:121
void KeepTheEvent(G4bool vl=true)
Definition: G4Event.hh:135
G4TrackStatus
void DoProcessing(G4Event *anEvent)
void KeepTheCurrentEvent()
G4ApplicationState
void SetTrackID(const G4int aValue)
static G4SDManager * GetSDMpointerIfExist()
Definition: G4SDManager.cc:49
G4VUserEventInformation * GetUserInformation()