| [828] | 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: G4RunManager.hh,v 1.51 2007/11/13 19:25:13 asaim Exp $
|
|---|
| [1058] | 28 | // GEANT4 tag $Name: geant4-09-02-ref-02 $
|
|---|
| [828] | 29 | //
|
|---|
| 30 | //
|
|---|
| 31 |
|
|---|
| 32 | // class description:
|
|---|
| 33 | //
|
|---|
| 34 | // This is a class for run control in GEANT4
|
|---|
| 35 | //
|
|---|
| 36 | // User must provide his own classes derived from the following
|
|---|
| 37 | // three abstract classes and register them to the RunManager.
|
|---|
| 38 | // G4VUserDetectorConstruction - Detector Geometry, Materials
|
|---|
| 39 | // G4VUserPhysicsList - Particle types and Processes
|
|---|
| 40 | // G4VUserPrimaryGeneratorAction - Event Generator selection
|
|---|
| 41 | //
|
|---|
| 42 | // In addition to the above mandatory classes, user can easily
|
|---|
| 43 | // customize of the default functionality of GEANT4 simulation
|
|---|
| 44 | // by making his own classes derived from the following 5 user
|
|---|
| 45 | // action classes.
|
|---|
| 46 | // G4UserRunAction - Actions for each Run
|
|---|
| 47 | // G4UserEventAction - Actions for each Event
|
|---|
| 48 | // G4UserStackingAction - Tracks Stacking selection
|
|---|
| 49 | // G4UserTrackingAction - Actions for each Track
|
|---|
| 50 | // G4UserSteppingAction - Actions for each Step
|
|---|
| 51 | //
|
|---|
| 52 | // G4RunManager is the only manager class in Geant4 kernel which
|
|---|
| 53 | // the user MUST construct an object by him/herself in the main().
|
|---|
| 54 | // Also, G4RunManager is the only manager class in Geant4 kernel
|
|---|
| 55 | // which the user CAN derive it to costomize the behavior of the
|
|---|
| 56 | // run control. For this case, user should use protected methods
|
|---|
| 57 | // provided in this class for procedures he/she does not want to
|
|---|
| 58 | // change.
|
|---|
| 59 | //
|
|---|
| 60 | // G4RunManager or the derived class of it MUST be a singleton.
|
|---|
| 61 | // The user MUST NOT construct more than one object even if there
|
|---|
| 62 | // are two different concrete implementations.
|
|---|
| 63 | //
|
|---|
| 64 | // G4RunManager controls all of state changes. See G4ApplicationState.hh
|
|---|
| 65 | // in intercoms category for the meanings of each state.
|
|---|
| 66 | //
|
|---|
| 67 |
|
|---|
| 68 | #ifndef G4RunManager_h
|
|---|
| 69 | #define G4RunManager_h 1
|
|---|
| 70 |
|
|---|
| 71 | // userAction classes
|
|---|
| 72 | class G4VUserDetectorConstruction;
|
|---|
| 73 | class G4VUserPhysicsList;
|
|---|
| 74 | class G4UserRunAction;
|
|---|
| 75 | class G4VUserPrimaryGeneratorAction;
|
|---|
| 76 | class G4UserEventAction;
|
|---|
| 77 | class G4UserStackingAction;
|
|---|
| 78 | class G4UserTrackingAction;
|
|---|
| 79 | class G4UserSteppingAction;
|
|---|
| 80 |
|
|---|
| 81 | class G4VPhysicalVolume;
|
|---|
| 82 | class G4Region;
|
|---|
| 83 | class G4Timer;
|
|---|
| 84 | class G4RunMessenger;
|
|---|
| 85 | class G4DCtable;
|
|---|
| 86 | class G4Run;
|
|---|
| 87 | class G4PrimaryTransformer;
|
|---|
| 88 |
|
|---|
| 89 | #include "G4RunManagerKernel.hh"
|
|---|
| 90 | #include "G4Event.hh"
|
|---|
| 91 | #include "G4EventManager.hh"
|
|---|
| 92 | #include "globals.hh"
|
|---|
| 93 | #include <vector>
|
|---|
| 94 | #include <stdlib.h>
|
|---|
| 95 |
|
|---|
| 96 | class G4RunManager
|
|---|
| 97 | {
|
|---|
| 98 | public: // with description
|
|---|
| 99 | static G4RunManager* GetRunManager();
|
|---|
| 100 | // Static method which returns the singleton pointer of G4RunManager or
|
|---|
| 101 | // its derived class.
|
|---|
| 102 |
|
|---|
| 103 | private:
|
|---|
| 104 | static G4RunManager* fRunManager;
|
|---|
| 105 |
|
|---|
| 106 | public: // with description
|
|---|
| 107 | G4RunManager();
|
|---|
| 108 | virtual ~G4RunManager();
|
|---|
| 109 | // The constructor and the destructor. The user must construct this class
|
|---|
| 110 | // object at the beginning of his/her main() and must delete it at the
|
|---|
| 111 | // bottom of the main().
|
|---|
| 112 |
|
|---|
| 113 | public: // with description
|
|---|
| 114 | virtual void BeamOn(G4int n_event,const char* macroFile=0,G4int n_select=-1);
|
|---|
| 115 | // This method starts an event loof of "n_event" events. The condition of Geant4
|
|---|
| 116 | // is examined before starting the event loop. This method must be invoked at
|
|---|
| 117 | // Idle state. The state will be changed to GeomClosed during the event loop and
|
|---|
| 118 | // will go back to Idle when the loop is over or aborted.
|
|---|
| 119 | // In case a string "macroFile" which represents the name of a macro file is given,
|
|---|
| 120 | // this macro file will be executed AT THE END of each event processing. In case
|
|---|
| 121 | // "n_select" is greater than zero, at the ond of first "n_select" events the macro
|
|---|
| 122 | // file is executed.
|
|---|
| 123 | virtual void Initialize();
|
|---|
| 124 | // This method invokes all the necessary initialization procedures for an event
|
|---|
| 125 | // loop. This method must be invoked at the Geant4 state of PreInit or Idle. The
|
|---|
| 126 | // state will be changed to Init during the initialization procedures and then
|
|---|
| 127 | // changed to Idle.
|
|---|
| 128 | // This method invokes two protected methods, InitializeGeometry() and
|
|---|
| 129 | // InitializePhysics().
|
|---|
| 130 | // After some event loops, the user can invoke this method once again. It is
|
|---|
| 131 | // required if the user changes geometry, physics process, and/or cut off value.
|
|---|
| 132 | // If the user forget the second invokation, G4RunManager will invoke BeamOn()
|
|---|
| 133 | // method will invoke this method. (Note that this feature is not valid for the
|
|---|
| 134 | // first initialization.)
|
|---|
| 135 | virtual void DefineWorldVolume(G4VPhysicalVolume * worldVol,
|
|---|
| 136 | G4bool topologyIsChanged=true);
|
|---|
| 137 | // This method must be invoked if the geometry setup has been changed between
|
|---|
| 138 | // runs. The flag 'topologyIsChanged' will specify if the geometry topology is
|
|---|
| 139 | // different from the original one used in the previous run; if not, it must be
|
|---|
| 140 | // set to false, so that the original optimisation and navigation history is
|
|---|
| 141 | // preserved. This method is invoked also at initialisation.
|
|---|
| 142 | //////////////////////////////////////////////////////virtual void ResetNavigator() const;
|
|---|
| 143 | // Resets the state of the navigator for tracking; needed for geometry updates.
|
|---|
| 144 | // It forces the optimisation and navigation history to be reset.
|
|---|
| 145 | virtual void AbortRun(G4bool softAbort=false);
|
|---|
| 146 | // This method safely aborts the current event loop even if an event is in progress.
|
|---|
| 147 | // This method is available for Geant4 states of GeomClosed and EventProc. The state
|
|---|
| 148 | // will be changed to Idle, so that another event loop can be done.
|
|---|
| 149 | // If softAbort is true, the event loop is aborted after processing the current
|
|---|
| 150 | // event, while the current event is aborted if it is false.
|
|---|
| 151 | virtual void AbortEvent();
|
|---|
| 152 | // This method aborts the currently processing event, remaining events in the
|
|---|
| 153 | // current event loop will be processed. This method is available only for
|
|---|
| 154 | // EventProc state.
|
|---|
| 155 |
|
|---|
| 156 | protected: // with description
|
|---|
| 157 |
|
|---|
| 158 | virtual void InitializeGeometry();
|
|---|
| 159 | virtual void InitializePhysics();
|
|---|
| 160 | // These protected methods are invoked from Initialize() method for the
|
|---|
| 161 | // initializations of geometry and physics processes. The user's concrete
|
|---|
| 162 | // G4VUserDetectorConstruction class will be accessed from InitializeGeometry() and
|
|---|
| 163 | // G4VUserPhysicsList class will be accessed from InitializePhysics().
|
|---|
| 164 |
|
|---|
| 165 | virtual G4bool ConfirmBeamOnCondition();
|
|---|
| 166 | virtual void RunInitialization();
|
|---|
| 167 | virtual void DoEventLoop(G4int n_event,const char* macroFile=0,G4int n_select=-1);
|
|---|
| 168 | virtual void RunTermination();
|
|---|
| 169 | // These four protected methods are invoked from BeamOn() method. These four methods
|
|---|
| 170 | // are invoked in this order.
|
|---|
| 171 | // ConfirmBeamOnCondition() method checks if all the necessary initializations have
|
|---|
| 172 | // already done. If the condition is not satisfied, false is returned and the follwing
|
|---|
| 173 | // three methods will be skipped.
|
|---|
| 174 | // RunInitialization() method initializes a run. For example, a G4Run class object
|
|---|
| 175 | // is constructed in this method.
|
|---|
| 176 | // DoEventLoop() method control an event loop. Arguments are same as BeamOn() method.
|
|---|
| 177 | // Inide the event loop, two following protected methods are invoked at the begining
|
|---|
| 178 | // and the end of each event.
|
|---|
| 179 | // RunTermination() method terminates a run processing. For example, a G4Run class
|
|---|
| 180 | // object is deleted in this class. If the user uses ODBMS and wants to store the
|
|---|
| 181 | // G4Run class object, he/she must override this method.
|
|---|
| 182 |
|
|---|
| 183 | ///////////////////////////////////////////////////////////virtual void BuildPhysicsTables();
|
|---|
| 184 | // This method is invoked from RunInitialization() to create physics tables.
|
|---|
| 185 |
|
|---|
| 186 | virtual G4Event* GenerateEvent(G4int i_event);
|
|---|
| 187 | virtual void AnalyzeEvent(G4Event* anEvent);
|
|---|
| 188 | // These two protected methods are invoked from DoEventLoop() method at the begining
|
|---|
| 189 | // and the end of each event processing.
|
|---|
| 190 | // GenerateEvent() method constructs a G4Event class object and invoke the user's
|
|---|
| 191 | // G4VUserPrimaryGeneratorAction concrete class. If the user is using ODBMS and event
|
|---|
| 192 | // objects have been created and stored in the data base, he/she must override this
|
|---|
| 193 | // method.
|
|---|
| 194 | // AnalyzeEvent() stores an event to a data base if a concrete G4VPersistentManager
|
|---|
| 195 | // class is defined.
|
|---|
| 196 |
|
|---|
| 197 | public: // with description
|
|---|
| 198 | //////////////////////////////////////////////////////void UpdateRegion();
|
|---|
| 199 | // Update region list.
|
|---|
| 200 | // This method is mandatory before invoking following two dump methods.
|
|---|
| 201 | // At RunInitialization(), this method is automatically invoked, and thus
|
|---|
| 202 | // the user needs not invoke.
|
|---|
| 203 |
|
|---|
| 204 | void DumpRegion(G4String rname) const;
|
|---|
| 205 | // Dump information of a region.
|
|---|
| 206 |
|
|---|
| 207 | void DumpRegion(G4Region* region=0) const;
|
|---|
| 208 | // Dump information of a region.
|
|---|
| 209 | // If the pointer is NULL, all regions are shown.
|
|---|
| 210 |
|
|---|
| 211 | protected:
|
|---|
| 212 | void StackPreviousEvent(G4Event* anEvent);
|
|---|
| 213 |
|
|---|
| 214 | protected:
|
|---|
| 215 | G4RunManagerKernel * kernel;
|
|---|
| 216 | G4EventManager * eventManager;
|
|---|
| 217 |
|
|---|
| 218 | G4VUserDetectorConstruction * userDetector;
|
|---|
| 219 | G4VUserPhysicsList * physicsList;
|
|---|
| 220 | G4UserRunAction * userRunAction;
|
|---|
| 221 | G4VUserPrimaryGeneratorAction * userPrimaryGeneratorAction;
|
|---|
| 222 | G4UserEventAction * userEventAction;
|
|---|
| 223 | G4UserStackingAction * userStackingAction;
|
|---|
| 224 | G4UserTrackingAction * userTrackingAction;
|
|---|
| 225 | G4UserSteppingAction * userSteppingAction;
|
|---|
| 226 |
|
|---|
| 227 | private:
|
|---|
| 228 | G4RunMessenger* runMessenger;
|
|---|
| 229 |
|
|---|
| 230 | protected:
|
|---|
| 231 | G4bool geometryInitialized;
|
|---|
| 232 | G4bool physicsInitialized;
|
|---|
| 233 | G4bool runAborted;
|
|---|
| 234 | G4bool initializedAtLeastOnce;
|
|---|
| 235 | G4bool geometryToBeOptimized;
|
|---|
| 236 |
|
|---|
| 237 | G4int runIDCounter;
|
|---|
| 238 | G4int verboseLevel;
|
|---|
| 239 | G4Timer * timer;
|
|---|
| 240 | G4DCtable* DCtable;
|
|---|
| 241 |
|
|---|
| 242 | G4Run* currentRun;
|
|---|
| 243 | G4Event* currentEvent;
|
|---|
| 244 | std::vector<G4Event*>* previousEvents;
|
|---|
| 245 | G4int n_perviousEventsToBeStored;
|
|---|
| 246 | G4int numberOfEventToBeProcessed;
|
|---|
| 247 |
|
|---|
| 248 | G4bool storeRandomNumberStatus;
|
|---|
| 249 | G4int storeRandomNumberStatusToG4Event;
|
|---|
| 250 | G4String randomNumberStatusDir;
|
|---|
| 251 | G4String randomNumberStatusForThisRun;
|
|---|
| 252 | G4String randomNumberStatusForThisEvent;
|
|---|
| 253 |
|
|---|
| 254 | G4VPhysicalVolume* currentWorld;
|
|---|
| 255 |
|
|---|
| 256 | G4int nParallelWorlds;
|
|---|
| 257 |
|
|---|
| 258 |
|
|---|
| 259 | public:
|
|---|
| 260 | virtual void rndmSaveThisRun();
|
|---|
| 261 | virtual void rndmSaveThisEvent();
|
|---|
| 262 | virtual void RestoreRandomNumberStatus(G4String fileN);
|
|---|
| 263 |
|
|---|
| 264 | public: // with description
|
|---|
| 265 | inline void SetUserInitialization(G4VUserDetectorConstruction* userInit)
|
|---|
| 266 | { userDetector = userInit; }
|
|---|
| 267 | inline void SetUserInitialization(G4VUserPhysicsList* userInit)
|
|---|
| 268 | {
|
|---|
| 269 | physicsList = userInit;
|
|---|
| 270 | kernel->SetPhysics(userInit);
|
|---|
| 271 | }
|
|---|
| 272 | inline void SetUserAction(G4UserRunAction* userAction)
|
|---|
| 273 | { userRunAction = userAction; }
|
|---|
| 274 | inline void SetUserAction(G4VUserPrimaryGeneratorAction* userAction)
|
|---|
| 275 | { userPrimaryGeneratorAction = userAction; }
|
|---|
| 276 | inline void SetUserAction(G4UserEventAction* userAction)
|
|---|
| 277 | {
|
|---|
| 278 | eventManager->SetUserAction(userAction);
|
|---|
| 279 | userEventAction = userAction;
|
|---|
| 280 | }
|
|---|
| 281 | inline void SetUserAction(G4UserStackingAction* userAction)
|
|---|
| 282 | {
|
|---|
| 283 | eventManager->SetUserAction(userAction);
|
|---|
| 284 | userStackingAction = userAction;
|
|---|
| 285 | }
|
|---|
| 286 | inline void SetUserAction(G4UserTrackingAction* userAction)
|
|---|
| 287 | {
|
|---|
| 288 | eventManager->SetUserAction(userAction);
|
|---|
| 289 | userTrackingAction = userAction;
|
|---|
| 290 | }
|
|---|
| 291 | inline void SetUserAction(G4UserSteppingAction* userAction)
|
|---|
| 292 | {
|
|---|
| 293 | eventManager->SetUserAction(userAction);
|
|---|
| 294 | userSteppingAction = userAction;
|
|---|
| 295 | }
|
|---|
| 296 | // These methods store respective user initialization and action classes.
|
|---|
| 297 | inline const G4VUserDetectorConstruction* GetUserDetectorConstruction() const
|
|---|
| 298 | { return userDetector; }
|
|---|
| 299 | inline const G4VUserPhysicsList* GetUserPhysicsList() const
|
|---|
| 300 | { return physicsList; }
|
|---|
| 301 | inline const G4UserRunAction* GetUserRunAction() const
|
|---|
| 302 | { return userRunAction; }
|
|---|
| 303 | inline const G4VUserPrimaryGeneratorAction* GetUserPrimaryGeneratorAction() const
|
|---|
| 304 | { return userPrimaryGeneratorAction; }
|
|---|
| 305 | inline const G4UserEventAction* GetUserEventAction() const
|
|---|
| 306 | { return userEventAction; }
|
|---|
| 307 | inline const G4UserStackingAction* GetUserStackingAction() const
|
|---|
| 308 | { return userStackingAction; }
|
|---|
| 309 | inline const G4UserTrackingAction* GetUserTrackingAction() const
|
|---|
| 310 | { return userTrackingAction; }
|
|---|
| 311 | inline const G4UserSteppingAction* GetUserSteppingAction() const
|
|---|
| 312 | { return userSteppingAction; }
|
|---|
| 313 | // These methods returns respective user initialization and action classes.
|
|---|
| 314 |
|
|---|
| 315 | inline void SetNumberOfAdditionalWaitingStacks(G4int iAdd)
|
|---|
| 316 | { eventManager->SetNumberOfAdditionalWaitingStacks(iAdd); }
|
|---|
| 317 | // Set the number of additional (optional) waiting stacks.
|
|---|
| 318 | // This method must be invoked at PreInit, Init or Idle states.
|
|---|
| 319 | // Once the user set the number of additional waiting stacks,
|
|---|
| 320 | // he/she can use the corresponding ENUM in G4ClassificationOfNewTrack.
|
|---|
| 321 |
|
|---|
| 322 | inline G4String GetVersionString() const
|
|---|
| 323 | { return kernel->GetVersionString(); }
|
|---|
| 324 |
|
|---|
| 325 | inline void SetPrimaryTransformer(G4PrimaryTransformer* pt)
|
|---|
| 326 | { kernel->SetPrimaryTransformer(pt); }
|
|---|
| 327 |
|
|---|
| 328 | inline void StoreRandomNumberStatusToG4Event(G4int vl)
|
|---|
| 329 | // if vl = 1 : status before primary particle generation is stored
|
|---|
| 330 | // if vl = 2 : status before event processing (after primary particle generation) is stored
|
|---|
| 331 | // if vl = 3 : both are stored
|
|---|
| 332 | // if vl = 0 : none is stored (default)
|
|---|
| 333 | {
|
|---|
| 334 | storeRandomNumberStatusToG4Event = vl;
|
|---|
| 335 | eventManager->StoreRandomNumberStatusToG4Event(vl);
|
|---|
| 336 | }
|
|---|
| 337 | inline G4int GetFlagRandomNumberStatusToG4Event() const
|
|---|
| 338 | { return storeRandomNumberStatusToG4Event; }
|
|---|
| 339 |
|
|---|
| 340 | public:
|
|---|
| 341 | inline void SetRandomNumberStore(G4bool flag)
|
|---|
| 342 | { storeRandomNumberStatus = flag; }
|
|---|
| 343 | inline G4bool GetRandomNumberStore() const
|
|---|
| 344 | { return storeRandomNumberStatus; }
|
|---|
| 345 | inline void SetRandomNumberStoreDir(G4String dir)
|
|---|
| 346 | {
|
|---|
| 347 | G4String dirStr = dir;
|
|---|
| 348 | if( dirStr(dirStr.length()-1) != '/' ) dirStr += "/";
|
|---|
| 349 | randomNumberStatusDir = dirStr;
|
|---|
| 350 | G4String shellCmd = "mkdir -p ";
|
|---|
| 351 | shellCmd += dirStr;
|
|---|
| 352 | system(shellCmd);
|
|---|
| 353 | }
|
|---|
| 354 | inline G4String GetRandomNumberStoreDir() const
|
|---|
| 355 | { return randomNumberStatusDir; }
|
|---|
| 356 | inline const G4String& GetRandomNumberStatusForThisRun() const
|
|---|
| 357 | { return randomNumberStatusForThisRun; }
|
|---|
| 358 | inline const G4String& GetRandomNumberStatusForThisEvent() const
|
|---|
| 359 | {
|
|---|
| 360 | if(storeRandomNumberStatusToG4Event==0 || storeRandomNumberStatusToG4Event==2)
|
|---|
| 361 | { G4Exception("Random number status is not available for this event."); }
|
|---|
| 362 | return randomNumberStatusForThisEvent;
|
|---|
| 363 | }
|
|---|
| 364 |
|
|---|
| 365 | public: // with description
|
|---|
| 366 | inline void GeometryHasBeenModified()
|
|---|
| 367 | { kernel->GeometryHasBeenModified(); }
|
|---|
| 368 | // This method must be invoked (or equivalent UI command can be used)
|
|---|
| 369 | // in case the user changes his/her detector geometry after
|
|---|
| 370 | // Initialize() metho has been invoked. Then, at the begining of the next BeamOn(),
|
|---|
| 371 | // all necessary re-initialization will be done.
|
|---|
| 372 |
|
|---|
| 373 | inline void PhysicsHasBeenModified()
|
|---|
| 374 | { kernel->PhysicsHasBeenModified(); }
|
|---|
| 375 | // This method must be invoked (or equivalent UI command can be used)
|
|---|
| 376 | // in case the user changes his/her physics process(es), e.g. (in)activate
|
|---|
| 377 | // some processes. Once this method is invoked, regardless of cuts are
|
|---|
| 378 | // changed or not, BuildPhysicsTable() of PhysicsList is invoked for
|
|---|
| 379 | // refreshing all physics tables.
|
|---|
| 380 |
|
|---|
| 381 | inline void CutOffHasBeenModified()
|
|---|
| 382 | {
|
|---|
| 383 | G4cerr << "CutOffHasBeenModified becomes obsolete." << G4endl;
|
|---|
| 384 | G4cerr << "It is safe to remove invoking this method." << G4endl;
|
|---|
| 385 | }
|
|---|
| 386 |
|
|---|
| 387 | public:
|
|---|
| 388 | inline void SetVerboseLevel(G4int vl)
|
|---|
| 389 | { verboseLevel = vl;
|
|---|
| 390 | kernel->SetVerboseLevel(vl); }
|
|---|
| 391 | inline G4int GetVerboseLevel() const
|
|---|
| 392 | { return verboseLevel; }
|
|---|
| 393 |
|
|---|
| 394 | inline void SetGeometryToBeOptimized(G4bool vl)
|
|---|
| 395 | {
|
|---|
| 396 | if(geometryToBeOptimized != vl)
|
|---|
| 397 | {
|
|---|
| 398 | geometryToBeOptimized = vl;
|
|---|
| 399 | kernel->GeometryHasBeenModified();
|
|---|
| 400 | kernel->SetGeometryToBeOptimized(vl);
|
|---|
| 401 | }
|
|---|
| 402 | }
|
|---|
| 403 | inline G4bool GetGeometryToBeOptimized()
|
|---|
| 404 | { return geometryToBeOptimized; }
|
|---|
| 405 |
|
|---|
| 406 | public: // with description
|
|---|
| 407 | inline void SetNumberOfEventsToBeStored(G4int val)
|
|---|
| 408 | { n_perviousEventsToBeStored = val; }
|
|---|
| 409 | // Sets the number of events to be kept after processing. That is, "val" previous
|
|---|
| 410 | // events can be used with the most recent event for digitizing pileup. "val"+1
|
|---|
| 411 | // previous event is deleted.
|
|---|
| 412 | // This method must be invoked before starting the event loop.
|
|---|
| 413 | inline const G4Run* GetCurrentRun() const
|
|---|
| 414 | { return currentRun; }
|
|---|
| 415 | // Returns the pointer to the current run. This method is available for Geant4
|
|---|
| 416 | // states of GeomClosed and EventProc.
|
|---|
| 417 | inline const G4Event* GetCurrentEvent() const
|
|---|
| 418 | { return currentEvent; }
|
|---|
| 419 | // Returns the pointer to the current event. This method is available for EventProc
|
|---|
| 420 | // state.
|
|---|
| 421 | inline const G4Event* GetPreviousEvent(G4int i) const
|
|---|
| 422 | {
|
|---|
| 423 | if(i>=1 && i<=n_perviousEventsToBeStored)
|
|---|
| 424 | { return (*previousEvents)[i-1]; }
|
|---|
| 425 | return 0;
|
|---|
| 426 | }
|
|---|
| 427 | // Returns the pointer to the "i" previous event. This method is availavle for
|
|---|
| 428 | // EventProc state. In case the event loop has not yet to reach to the requested
|
|---|
| 429 | // event, null will be returned. To use this method, SetNumberOfEventsToBeStored()
|
|---|
| 430 | // method mentioned above must be invoked previously to the event loop.
|
|---|
| 431 | inline void SetRunIDCounter(G4int i)
|
|---|
| 432 | { runIDCounter = i; }
|
|---|
| 433 | // Set the run number counter. Initially, the counter is initialized to zero and
|
|---|
| 434 | // incremented by one for every BeamOn().
|
|---|
| 435 | inline G4int GetNumberOfParallelWorld() const
|
|---|
| 436 | { return nParallelWorlds; }
|
|---|
| 437 | public:
|
|---|
| 438 | inline void SetDCtable(G4DCtable* DCtbl)
|
|---|
| 439 | { DCtable = DCtbl; }
|
|---|
| 440 |
|
|---|
| 441 | public:
|
|---|
| 442 | void ConstructScoringWorlds();
|
|---|
| 443 | private:
|
|---|
| 444 | void UpdateScoring();
|
|---|
| 445 | };
|
|---|
| 446 |
|
|---|
| 447 | #endif
|
|---|
| 448 |
|
|---|
