00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef BLMANAGER_HH
00020 #define BLMANAGER_HH
00021
00022 #include <vector>
00023 #include <map>
00024 #include <set>
00025 #include "G4VUserDetectorConstruction.hh"
00026 #include "G4SteppingManager.hh"
00027 #include "G4Step.hh"
00028 #include "G4Track.hh"
00029 #include "G4Run.hh"
00030 #include "G4Event.hh"
00031 #include "G4VPhysicalVolume.hh"
00032 #include "G4VExceptionHandler.hh"
00033
00034 #include "BLCallback.hh"
00035 #include "BLRunManager.hh"
00036 #include "BLPhysics.hh"
00037 #include "BLZStep.hh"
00038 #include "BLUserCode.hh"
00039
00040 class BLBeam;
00041
00042
00043
00044
00045 enum BLManagerState { IDLE, VISUAL, TUNE, REFERENCE, BEAM, SPECIAL };
00046 enum VerboseFormat { TAG,NSTEP,GLOBAL,CL,CLX,KE,STEP,VOL,PROCESS,B,E,MAT,
00047 P, ID, PART, SEG, WT, NEWLINE, EXT };
00048 enum PRNGSeedMethod { EVENT_NUMBER, NO_SEED, TIME_US };
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 class BLManager : public G4VUserDetectorConstruction,
00066 G4VExceptionHandler {
00067 public:
00068 class RunAction {
00069 public: virtual void BeginOfRunAction(const G4Run *run) = 0;
00070 public: virtual void EndOfRunAction(const G4Run *run) = 0;
00071 };
00072 class EventAction {
00073 public: virtual void BeginOfEventAction(const G4Event* event) = 0;
00074 public: virtual void EndOfEventAction(const G4Event* event) = 0;
00075 };
00076 class TrackingAction {
00077 protected: G4TrackingManager *fpTrackingManager;
00078 public: void SetTrackingManagerPointer(G4TrackingManager *p)
00079 {fpTrackingManager=p;}
00080 public: virtual void PreUserTrackingAction(const G4Track *track) = 0;
00081 public: virtual void PostUserTrackingAction(const G4Track *track) = 0;
00082 };
00083 class SteppingAction {
00084 public: virtual void UserSteppingAction(const G4Step *step) = 0;
00085 };
00086 class ZSteppingAction {
00087 public: virtual void UserZSteppingAction(const G4Track *track) = 0;
00088 };
00089 class PrimaryGeneratorAction {
00090 public: virtual void GeneratePrimaries(G4Event *event) = 0;
00091 };
00092 class StackingAction {
00093
00094 public: virtual G4ClassificationOfNewTrack
00095 ClassifyNewTrack(const G4Track*) = 0;
00096 public: virtual void NewStage() { }
00097 public: virtual void PrepareNewEvent() { }
00098 };
00099 private:
00100 struct ZStep {
00101 G4double z;
00102 ZSteppingAction *action;
00103 ZStep(G4double _z, ZSteppingAction *a) { z=_z; action=a; }
00104 };
00105 static BLManager *blManager;
00106 static bool initialized;
00107 BLRunManager *runManager;
00108 BLManagerState state;
00109 G4int steppingVerbose;
00110 unsigned int beamIndex;
00111 G4int histoUpdate;
00112 time_t startRun;
00113 time_t startEvent;
00114 G4int eventTimeLimit;
00115 BLPhysics *physics;
00116 G4VPhysicalVolume *worldPhysicalVolume;
00117 G4int eventID;
00118 G4int trackID;
00119 G4int eventsAborted;
00120 G4int warnings;
00121 G4int prevEventID;
00122 G4int eventsProcessed;
00123 bool endRun;
00124 PRNGSeedMethod seedMethod;
00125 G4String eventCutFile;
00126 std::set<int> eventList;
00127 G4SteppingManager *fpSteppingManager;
00128 G4TrackingManager *fpTrackingManager;
00129 std::vector<BLBeam*> beamVector;
00130 std::vector<BLBeam*> referenceVector;
00131 std::vector<RunAction*> runActionVector;
00132 std::vector<RunAction*> beamRunActionVector;
00133 std::vector<EventAction*> eventActionVector;
00134 std::vector<EventAction*> beamEventActionVector;
00135 std::vector<TrackingAction*> trackingActionVector;
00136 std::vector<BLCallback*> preReferenceCallbackVector;
00137 std::vector<BLCallback*> postReferenceCallbackVector;
00138 std::vector<BLCallback*> postTrackingCallbackVector;
00139 std::vector<BLCallback*> replaceMainLoopCallbackVector;
00140 std::vector<BLCallback*> visualizationCallbackVector;
00141 std::vector<SteppingAction*> allStepVector;
00142 std::map<G4VPhysicalVolume*,SteppingAction*> allStepMap;
00143 std::map<G4VPhysicalVolume*,SteppingAction*> tpStepMap;
00144 std::map<G4VPhysicalVolume*,SteppingAction*> rpStepMap;
00145 std::vector<SteppingAction*> tpStepVector;
00146 std::vector<SteppingAction*> rpStepVector;
00147 std::map<G4VPhysicalVolume*,SteppingAction*> beamStepMap;
00148 std::vector<SteppingAction*> beamStepVector;
00149 std::vector<int> verboseFormat;
00150 G4double zTolerance;
00151 std::vector<ZStep> tuneZStep;
00152 std::vector<ZStep> referenceZStep;
00153 std::vector<ZStep> beamZStep;
00154 std::vector<ZStep> *currentZStep;
00155 unsigned indexZStep;
00156 G4double prevZ;
00157 G4int nStuck;
00158 std::vector<StackingAction*> stackingActionVector;
00159 int nextSecondaryTrackID;
00160 std::map<G4int,G4int> trackIDMap;
00161 int primaryTrackID;
00162 int primaryParentID;
00163 std::vector<BLUserCode*> userCodeVector;
00164
00165 BLManager();
00166 void insertZStep(std::vector<ZStep>& vector, G4double z, ZSteppingAction *action);
00167 void readEventCutFile();
00168 public:
00169
00170
00171
00172
00173 static BLManager *getObject();
00174
00175
00176
00177 void delayedConstruction();
00178
00179
00180 ~BLManager();
00181
00182
00183 BLManagerState getState() { return state; }
00184
00185
00186 void setState(BLManagerState _state) { state = _state; }
00187
00188
00189
00190 int getSteppingVerbose() { return steppingVerbose; }
00191
00192
00193
00194 void setSteppingVerbose(int v) { steppingVerbose = v; }
00195
00196
00197
00198 int getEventTimeLimit() { return eventTimeLimit; }
00199
00200
00201
00202 void setEventTimeLimit(int sec) { eventTimeLimit = sec; }
00203
00204
00205 G4int getEventID() const { return eventID; }
00206
00207
00208 void setEventID(int evId) { eventID=evId; prevEventID=evId-1; }
00209
00210
00211
00212 bool skipEvent(int EventID)
00213 { return eventList.size() > 0 && eventList.count(eventID) == 0; }
00214
00215
00216
00217 void incrEventsProcessed(int eventID);
00218
00219
00220
00221 void registerSteppingAction(SteppingAction *sa)
00222 { allStepVector.push_back(sa); }
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232 void registerSteppingAction(G4VPhysicalVolume *physicalVol,
00233 SteppingAction *sa)
00234 { if(physicalVol != 0) allStepMap[physicalVol] = sa;
00235 else allStepVector.push_back(sa); }
00236
00237
00238
00239
00240
00241
00242
00243
00244 void registerTuneParticleStep(G4VPhysicalVolume *physicalVol,
00245 SteppingAction *sa)
00246 { if(physicalVol != 0) tpStepMap[physicalVol] = sa;
00247 else tpStepVector.push_back(sa); }
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257 void registerReferenceParticleStep(G4VPhysicalVolume *physicalVol,
00258 SteppingAction *sa)
00259 { if(physicalVol != 0) rpStepMap[physicalVol] = sa;
00260 else rpStepVector.push_back(sa); }
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270 void registerBeamStep(G4VPhysicalVolume *physicalVol,
00271 SteppingAction *sa)
00272 { if(physicalVol != 0) beamStepMap[physicalVol] = sa;
00273 else beamStepVector.push_back(sa); }
00274
00275
00276
00277
00278
00279 void registerZStep(G4double z, ZSteppingAction *sa, G4int when=7);
00280
00281
00282
00283 void registerStackingAction(StackingAction *sa)
00284 { stackingActionVector.push_back(sa); }
00285
00286
00287
00288 void setSteppingFormat();
00289
00290
00291
00292 G4String getFormatHelp();
00293
00294
00295
00296 void appendVerboseFormat(G4String fmt);
00297
00298
00299
00300
00301 void steppingVerbosePrint(const G4Step *step, const G4Track *track, int
00302 header=0);
00303
00304
00305
00306 void setSteppingManager(G4SteppingManager *p) { fpSteppingManager = p; }
00307
00308
00309
00310 G4SteppingManager *getSteppingManager() { return fpSteppingManager; }
00311
00312
00313
00314 void setTrackingManager(G4TrackingManager *p) { fpTrackingManager = p; }
00315
00316
00317
00318
00319
00320
00321 void initialize();
00322
00323
00324 static bool isInitialized() { return initialized; }
00325
00326
00327
00328 void trackTuneAndReferenceParticles();
00329
00330
00331 void trackBeam();
00332
00333
00334 void displayVisual();
00335
00336
00337
00338
00339 void displayGeometry(G4VPhysicalVolume *phys=0, int level=0);
00340
00341
00342
00343
00344 void registerPhysics(BLPhysics *_physics)
00345 { physics = _physics;
00346 runManager->SetUserInitialization(physics->getPhysicsList());
00347 }
00348
00349
00350 BLPhysics *getPhysics() { return physics; }
00351
00352
00353
00354 void registerBeam(BLBeam *_beam) { beamVector.push_back(_beam); }
00355
00356
00357
00358
00359 void registerReference(BLBeam *_beam)
00360 { referenceVector.push_back(_beam); }
00361
00362
00363 int nReference() { return referenceVector.size(); }
00364
00365
00366
00367
00368 void registerRunAction(RunAction *a, G4bool beamOnly=true)
00369 { if(beamOnly)
00370 beamRunActionVector.push_back(a);
00371 else
00372 runActionVector.push_back(a);
00373 }
00374
00375
00376
00377
00378 void registerEventAction(EventAction *a, G4bool beamOnly=true)
00379 { if(beamOnly)
00380 beamEventActionVector.push_back(a);
00381 else
00382 eventActionVector.push_back(a);
00383 }
00384
00385
00386 void registerTrackingAction(TrackingAction *a)
00387 { trackingActionVector.push_back(a); }
00388
00389
00390 void registerUserCode(BLUserCode *instance)
00391 { userCodeVector.push_back(instance); }
00392
00393
00394
00395 std::vector<BLUserCode*> getUserCodeInstances(G4String type)
00396 { std::vector<BLUserCode*> ret;
00397 for(unsigned i=0; i<userCodeVector.size(); ++i) {
00398 if(type == userCodeVector[i]->getType())
00399 ret.push_back(userCodeVector[i]);
00400 }
00401 return ret;
00402 }
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416 void registerCallback(BLCallback *cb, int type) {
00417 if(type==0) preReferenceCallbackVector.push_back(cb);
00418 else if(type==1) postReferenceCallbackVector.push_back(cb);
00419 else if(type==2) postTrackingCallbackVector.push_back(cb);
00420 else if(type==3) replaceMainLoopCallbackVector.push_back(cb);
00421 else if(type==4) visualizationCallbackVector.push_back(cb);
00422 }
00423
00424
00425
00426
00427
00428
00429
00430 void handleCallbacks(int type);
00431
00432
00433
00434
00435 G4VPhysicalVolume *getWorldPhysicalVolume()
00436 { return worldPhysicalVolume; }
00437
00438
00439
00440 void setPRNGSeedMethod(PRNGSeedMethod method)
00441 { seedMethod = method; }
00442
00443
00444
00445 PRNGSeedMethod getPRNGSeedMethod() { return seedMethod; }
00446
00447
00448
00449
00450 void setEventCutFile(G4String &f) { eventCutFile = f; }
00451
00452
00453
00454
00455
00456
00457
00458
00459 void UserSteppingAction(const G4Step *step);
00460
00461
00462 G4VPhysicalVolume *Construct();
00463
00464
00465 void PreUserTrackingAction(const G4Track *track);
00466
00467
00468 void PostUserTrackingAction(const G4Track *track);
00469
00470
00471 void BeginOfRunAction(const G4Run *run);
00472
00473
00474 void EndOfRunAction(const G4Run *run);
00475
00476
00477 void BeginOfEventAction(const G4Event* event);
00478
00479
00480 void EndOfEventAction(const G4Event* event);
00481
00482
00483 void GeneratePrimaries(G4Event *event);
00484
00485
00486 G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track*);
00487
00488
00489 void NewStage();
00490
00491
00492 void PrepareNewEvent();
00493
00494
00495 void clearTrackIDMap() { trackIDMap.clear(); }
00496
00497
00498
00499
00500 void setNextSecondaryTrackID(int next) { nextSecondaryTrackID = next; }
00501 int getNextSecondaryTrackID() { return nextSecondaryTrackID; }
00502
00503
00504
00505
00506 int getExternalTrackID(const G4Track *track);
00507
00508
00509
00510
00511 int getExternalParentID(const G4Track *track);
00512
00513
00514
00515 void setExternalTrackID(G4Track *track, int trackID, int parentID);
00516
00517
00518 int getPrimaryTrackID() { return primaryTrackID; }
00519
00520
00521 int getPrimaryParentID() { return primaryParentID; }
00522
00523
00524 void setPrimaryTrackID(int t, int p)
00525 { primaryTrackID = t; primaryParentID = p; }
00526
00527
00528 G4bool Notify(const char* originOfException, const char* exceptionCode,
00529 G4ExceptionSeverity severity, const char* description);
00530 };
00531
00532 #endif // BLMANAGER_HH