BLManager.hh

Go to the documentation of this file.
00001 //      BLManager.hh
00002 /*
00003 This source file is part of G4beamline, http://g4beamline.muonsinc.com
00004 Copyright (C) 2003,2004,2005,2006 by Tom Roberts, all rights reserved.
00005 
00006 This program is free software; you can redistribute it and/or
00007 modify it under the terms of the GNU General Public License
00008 as published by the Free Software Foundation; either version 2
00009 of the License, or (at your option) any later version.
00010 
00011 This program is distributed in the hope that it will be useful,
00012 but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 GNU General Public License for more details.
00015 
00016 http://www.gnu.org/copyleft/gpl.html
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 // State SPECIAL is used for pre-tracking in collective mode -- all
00044 // entries into NTuples should be omitted in SPECIAL mode.
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 /**     BLManager is the overall manager for g4beamline, managing all aspects
00051  *      of the run.
00052  *
00053  *      Note it is uses all the G4 user action classes, implemented as classes
00054  *      under BLManager.
00055  *
00056  *      TrackID-s: It is non-trivial to preserve TrackID-s from input files,
00057  *      because Geant4 considers TrackID to be an internal variable, and it
00058  *      assigns them in a non-customizable manner. So BLManager keeps a
00059  *      trackIDMap[] that converts from internal (Geant4) to external (User)
00060  *      TrackID-s. It also uses BLTrackInfo to associate the external IDs
00061  *      with the track -- the external trackID is determined either in BLBeam
00062  *      (when the track is created), or in BLManager::PreUserTrackingAction
00063  *      for secondaries.
00064  **/
00065 class BLManager : public G4VUserDetectorConstruction, 
00066                         G4VExceptionHandler {
00067 public: // user Action classes
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         // returns only fUrgent or fKill.
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         G4ParticleDefinition *trackParticleDef;
00120         G4int fatalExceptions;
00121         G4int eventsAborted;
00122         G4int tracksAborted;
00123         G4int warnings;
00124         G4int prevEventID;
00125         G4int eventsProcessed;
00126         bool endRun;
00127         PRNGSeedMethod seedMethod;
00128         std::set<int> keepEventList;
00129         std::set<int> skipEventList;
00130         G4SteppingManager *fpSteppingManager;
00131         G4TrackingManager *fpTrackingManager;
00132         std::vector<BLBeam*> beamVector;
00133         std::vector<BLBeam*> referenceVector;
00134         std::vector<RunAction*> runActionVector;
00135         std::vector<RunAction*> beamRunActionVector;
00136         std::vector<EventAction*> eventActionVector;
00137         std::vector<EventAction*> beamEventActionVector;
00138         std::vector<TrackingAction*> trackingActionVector;
00139         std::vector<BLCallback*> preReferenceCallbackVector;
00140         std::vector<BLCallback*> postReferenceCallbackVector;
00141         std::vector<BLCallback*> postTrackingCallbackVector;
00142         std::vector<BLCallback*> replaceMainLoopCallbackVector;
00143         std::vector<BLCallback*> visualizationCallbackVector;
00144         std::vector<SteppingAction*> allStepVector;
00145         std::map<G4VPhysicalVolume*,SteppingAction*> allStepMap;
00146         std::map<G4VPhysicalVolume*,SteppingAction*> tpStepMap;
00147         std::map<G4VPhysicalVolume*,SteppingAction*> rpStepMap;
00148         std::vector<SteppingAction*> tpStepVector;
00149         std::vector<SteppingAction*> rpStepVector;
00150         std::map<G4VPhysicalVolume*,SteppingAction*> beamStepMap;
00151         std::vector<SteppingAction*> beamStepVector;
00152         std::vector<int> verboseFormat;
00153         G4double zTolerance;
00154         std::vector<ZStep> tuneZStep;
00155         std::vector<ZStep> referenceZStep;
00156         std::vector<ZStep> beamZStep;
00157         std::vector<ZStep> *currentZStep;
00158         unsigned indexZStep;
00159         G4double prevZ;
00160         G4int nStuck;
00161         std::vector<StackingAction*> stackingActionVector;
00162         int nextSecondaryTrackID;
00163         std::map<G4int,G4int> trackIDMap;
00164         int primaryTrackID;
00165         int primaryParentID;
00166         std::vector<BLUserCode*> userCodeVector;
00167         std::map<G4String,int> exceptionCount;
00168         /// private constructor -- immediate construction only.
00169         BLManager();
00170         void insertZStep(std::vector<ZStep>& vector, G4double z, ZSteppingAction *action);
00171 public:
00172         /// getObject() will return a pointer to the single BLManager object,
00173         /// creating it if necessary. Does only the immediate constructor, not
00174         /// delayedConstruction(). that means it is Ok to register capabilities,
00175         /// but not much else.
00176         static BLManager *getObject();
00177 
00178         /// delayedConstruction() performs things which must wait until all
00179         /// static initializers have executed (e.g. in Geant4 routines).
00180         void delayedConstruction();
00181 
00182         /// Destructor.
00183         ~BLManager();
00184 
00185         /// getState() returns the current state.
00186         BLManagerState getState() { return state; }
00187 
00188         /// setState sets the state
00189         void setState(BLManagerState _state) { state = _state; }
00190 
00191         /// getSteppingVerbose() returns steppingVerbose. NOTE: use this
00192         /// during tracking instead of Param.getInt("steppingVerbose");
00193         int getSteppingVerbose() { return steppingVerbose; }
00194 
00195         /// setSteppingVerbose() updates steppingVerbose. -- NOTE: many
00196         /// other classes relay on the Parameter, not the valud in this class.
00197         void setSteppingVerbose(int v) { steppingVerbose = v; }
00198 
00199         /// getEventTimeLimit() returns the CPU time limit for events (seconds).
00200         /// -1 mean infinite.
00201         int getEventTimeLimit() { return eventTimeLimit; }
00202 
00203         /// setEventTimeLimit() sets the CPU time limit for events (seconds).
00204         /// -1 mean infinite.
00205         void setEventTimeLimit(int sec) { eventTimeLimit = sec; }
00206 
00207         /// getEventID() gets the current eventID;
00208         G4int getEventID() const { return eventID; }
00209 
00210         /// setEventID() sets the current eventID;
00211         void setEventID(int evId) { eventID=evId; prevEventID=evId-1; }
00212 
00213         /// skipEvent() determines if this EventID should be skipped. It
00214         /// checks keepEventList and skipEventList.
00215         bool skipEvent(int EventID) {
00216           if(skipEventList.count(EventID) > 0) return true;
00217           return keepEventList.size() > 0 && keepEventList.count(EventID) == 0;
00218         }
00219 
00220         /// setKeepEvent() puts EventID into the keepEventList.
00221         /// (if keepEventList is empty, all events are kept.)
00222         void setKeepEvent(int EventID) { keepEventList.insert(EventID); }
00223 
00224         /// setSkipEvent() puts EventID into the skipEventList.
00225         void setSkipEvent(int EventID) { skipEventList.insert(EventID); }
00226 
00227         /// incrEventsProcessed() will increment eventsProcessed.
00228         /// For special uses only (e.g.MPI).
00229         void incrEventsProcessed(int eventID);
00230 
00231         /// registerSteppingAction() registers a SteppingAction to
00232         /// be called for each step (regardless of state).
00233         void registerSteppingAction(SteppingAction *sa)
00234                 { allStepVector.push_back(sa); }
00235 
00236         /// registerSteppingAction() registers a SteppingAction to
00237         /// be called for each step (regardless of state), for every step
00238         /// involving the physicalVol.
00239         /// The callback will be called if physicalVol is either
00240         /// the pre- or post-step physical volume (once if both).
00241         /// If physicalVol==0 it is called every reference particle step.
00242         /// LIMITATION: only one callback can be registered for a given 
00243         /// physicalVol (except 0).
00244         void registerSteppingAction(G4VPhysicalVolume *physicalVol,
00245                                                 SteppingAction *sa)
00246                 { if(physicalVol != 0) allStepMap[physicalVol] = sa;
00247                   else allStepVector.push_back(sa); }
00248 
00249         /// registerTuneParticleStep() registers a SteppingAction to
00250         /// be called for every tune particle step involving the physicalVol.
00251         /// The callback will be called if physicalVol is either
00252         /// the pre- or post-step physical volume (once if both).
00253         /// If physicalVol==0 it is called every tune particle step.
00254         /// LIMITATION: only one callback can be registered for a given 
00255         /// physicalVol (except 0).
00256         void registerTuneParticleStep(G4VPhysicalVolume *physicalVol,
00257                                         SteppingAction *sa)
00258                 { if(physicalVol != 0) tpStepMap[physicalVol] = sa; 
00259                   else tpStepVector.push_back(sa); }
00260 
00261         /// registerReferenceParticleStep() registers a SteppingAction to
00262         /// be called for every reference particle step involving the
00263         /// physicalVol.
00264         /// The callback will be called if physicalVol is either
00265         /// the pre- or post-step physical volume (once if both).
00266         /// If physicalVol==0 it is called every reference particle step.
00267         /// LIMITATION: only one callback can be registered for a given 
00268         /// physicalVol (except 0).
00269         void registerReferenceParticleStep(G4VPhysicalVolume *physicalVol,
00270                                         SteppingAction *sa)
00271                 { if(physicalVol != 0) rpStepMap[physicalVol] = sa; 
00272                   else rpStepVector.push_back(sa); }
00273 
00274         /// registerBeamStep() registers a SteppingAction to
00275         /// be called for every beam step involving the physicalVol.
00276         /// (beam particles are everything except reference and tune.)
00277         /// The callback will be called if physicalVol is either
00278         /// the pre- or post-step physical volume (once if both). 
00279         /// if physicalVol==0 it is called every beam step.
00280         /// LIMITATION: only one callback can be registered for a given 
00281         /// physicalVol (except 0).
00282         void registerBeamStep(G4VPhysicalVolume *physicalVol,
00283                                         SteppingAction *sa)
00284                 { if(physicalVol != 0) beamStepMap[physicalVol] = sa; 
00285                   else beamStepVector.push_back(sa); }
00286 
00287         /// registerZStep() will force a step to occur near the given z
00288         /// position, and will call the ZSteppingAction for it, interpolating
00289         /// to the desired z value (Centerline coords).
00290         /// when is a bitwise OR of 1=tune, 2=reference, 4=beam.
00291         void registerZStep(G4double z, ZSteppingAction *sa, G4int when=7);
00292 
00293         /// registerStackingAction() registers a StackingAction to be called
00294         /// by the Geant4 stacking manager.
00295         void registerStackingAction(StackingAction *sa)
00296                 { stackingActionVector.push_back(sa); }
00297 
00298         /// setSteppingFormat() sets the verbose printing format according
00299         /// to parameter "steppingFormat".
00300         void setSteppingFormat();
00301 
00302         /// getFormatHelp() returns a string with help text about valid format 
00303         /// items.
00304         G4String getFormatHelp();
00305 
00306         /// appendVerboseFormat() appends fmt to the format for printing when
00307         /// param steppingVerbose is nonzero
00308         void appendVerboseFormat(G4String fmt);
00309 
00310         /// steppingVerbosePrint() will print this step according to the current
00311         /// verboseFormat.
00312         /// Prints header if header != 0).
00313         void steppingVerbosePrint(const G4Step *step, const G4Track *track, int
00314                                                                 header=0);
00315 
00316         /// setSteppingManager() sets the pointer to the current
00317         /// G4SteppingManager.
00318         void setSteppingManager(G4SteppingManager *p) { fpSteppingManager = p; }
00319 
00320         /// getSteppingManager() returns a pointer to the current
00321         /// G4SteppingManager.
00322         G4SteppingManager *getSteppingManager() { return fpSteppingManager; }
00323 
00324         /// setTrackingManager() sets the pointer to the current
00325         /// G4TrackingManager.
00326         void setTrackingManager(G4TrackingManager *p) { fpTrackingManager = p; }
00327 
00328         /// initialize() will initialize the BLManager object, and the 
00329         /// geant4 kernel, thus constructing the geometry in the
00330         /// world group. Note that registerPhysics() must be called
00331         /// before initialize() (normally done by a "physics" command
00332         /// in the input file).
00333         void initialize();
00334 
00335         /// isInitialized() returns true if the BLManager has been initialized.
00336         static bool isInitialized() { return initialized; }
00337 
00338         /// trackTuneAndReferenceParticles() will generate and track the tune
00339         /// particle and then the reference particle.
00340         void trackTuneAndReferenceParticles();
00341 
00342         /// trackBeam() will generate the defined beam and track each event.
00343         void trackBeam();
00344 
00345         /// displayVisual() will display the detector visually.
00346         void displayVisual();
00347 
00348         /// displayGeometry() will display the geant4 geometry.
00349         /// This is a hierarchical ASCII listing of all volumes.
00350         /// if phys==0 then use the worldPhysicalVolume.
00351         void displayGeometry(G4VPhysicalVolume *phys=0, int level=0);
00352 
00353         /// registerPhysics() registers the BLPhysics object.
00354         /// It also sets the physics list to the BLRunManager, so following
00355         /// commands can find particle by name.
00356         void registerPhysics(BLPhysics *_physics)
00357                 { physics = _physics;
00358                   runManager->SetUserInitialization(physics->getPhysicsList());
00359                 }
00360         
00361         /// getPhysics returns the registered BLPhysics object.
00362         BLPhysics *getPhysics() { return physics; }
00363 
00364         /// registerBeam() registers a BLBeam object for beam generation.
00365         /// Multiple BLBeam objects can be registered, used in order.
00366         void registerBeam(BLBeam *_beam) { beamVector.push_back(_beam); }
00367 
00368         /// registerReference() registers a BLBeam object for reference 
00369         /// particle generation.
00370         /// Multiple BLBeam objects can be registered, used in order.
00371         void registerReference(BLBeam *_beam)
00372                 { referenceVector.push_back(_beam); }
00373 
00374         /// nReference() returns the number of reference particles registered.
00375         int nReference() { return referenceVector.size(); }
00376 
00377         /// registerRunAction() registers a UserRunAction.
00378         /// If beamOnly is true (the default), the callback is made only
00379         /// if state==BEAM.
00380         void registerRunAction(RunAction *a, G4bool beamOnly=true)
00381                 { if(beamOnly)
00382                         beamRunActionVector.push_back(a);
00383                   else
00384                         runActionVector.push_back(a);
00385                 }
00386 
00387         /// registerEventAction() registers a UserEventAction.
00388         /// If beamOnly is true (the default), the callback is made only
00389         /// if state==BEAM.
00390         void registerEventAction(EventAction *a, G4bool beamOnly=true)
00391                 { if(beamOnly)
00392                         beamEventActionVector.push_back(a);
00393                   else
00394                         eventActionVector.push_back(a);
00395                 }
00396 
00397         /// registerTrackingAction() registers a UserTackingAction.
00398         /// By default puts new entry at the back end of the vector;
00399         /// if front is true, puts new entry at the front.
00400         void registerTrackingAction(TrackingAction *a, bool front=false)
00401             { if(front)
00402                 trackingActionVector.insert(trackingActionVector.begin(),a); 
00403               else
00404                 trackingActionVector.push_back(a); 
00405             }
00406 
00407         /// registerUserCode() registers a BLUserCode instance.
00408         void registerUserCode(BLUserCode *instance)
00409                 { userCodeVector.push_back(instance); }
00410 
00411         /// getUserCodeInstances() returns a vector of all registered
00412         /// instances of BLUserCode with the specified type.
00413         std::vector<BLUserCode*> getUserCodeInstances(G4String type)
00414                 { std::vector<BLUserCode*> ret;
00415                   for(unsigned i=0; i<userCodeVector.size(); ++i) {
00416                         if(type == userCodeVector[i]->getType())
00417                                 ret.push_back(userCodeVector[i]);
00418                   }
00419                   return ret;
00420                 }
00421 
00422 
00423         /// registerCallback() registers a BLCallback.
00424         /// type=0 for pre-Tune particle,
00425         /// type=1 for post-Reference (pre-beam tracking),
00426         /// type=2 for post-beam tracking.
00427         /// type=3 for replacing the main program loop.
00428         /// type=4 for visualization.
00429         /// NOTE: if there are type=3 callbacks, when the last one returns
00430         /// the closes up by summarizing NTuples and callng handleCallbacks(2),
00431         /// and then the program exits. This prevents the main program loop from
00432         /// executing. type=3 callbacks are called just after the type=1
00433         /// callbacks (i.e. after the post-Reference callbacks).
00434         void registerCallback(BLCallback *cb, int type) {
00435                 if(type==0) preReferenceCallbackVector.push_back(cb);
00436                 else if(type==1) postReferenceCallbackVector.push_back(cb);
00437                 else if(type==2) postTrackingCallbackVector.push_back(cb);
00438                 else if(type==3) replaceMainLoopCallbackVector.push_back(cb);
00439                 else if(type==4) visualizationCallbackVector.push_back(cb);
00440         }
00441 
00442         /// handleCallbacks() calls all applicable registered callbacks.
00443         /// type=0 for pre-reference particle,
00444         /// type=1 for post-center (pre-beam tracking),
00445         /// type=2 for post-beam tracking (just before program exit).
00446         /// type=3 for replacing the main program loop.
00447         /// type=4 for visualization.
00448         void handleCallbacks(int type);
00449 
00450         /// getWorldPhysicalVolume() returns a pointer to the world PV.
00451         /// Note that it must already have been consructed, so this function
00452         /// returns NULL before construct() is called (by main).
00453         G4VPhysicalVolume *getWorldPhysicalVolume()
00454                 { return worldPhysicalVolume; }
00455 
00456         /// setPRNGSeedMethod() will set the method used to seed the
00457         /// pseudo random number generator at the start of each event.
00458         void setPRNGSeedMethod(PRNGSeedMethod method)
00459                 { seedMethod = method; }
00460 
00461         /// getPRNGSeedMethod() will return the method used to seed the
00462         /// pseudo random number generator at the start of each event.
00463         PRNGSeedMethod getPRNGSeedMethod() { return seedMethod; }
00464 
00465         // virtual functions from the geant4 base classes. All of them
00466         // call the registered actions, as appropriate for state and
00467         // the current physical volume (if applicable). Due to the design
00468         // of the Geant4 callback classes, these are mediated by classes of
00469         // the form BLManager_name.
00470 
00471         /// UserSteppingAction() from G4UserSteppingAction.
00472         void UserSteppingAction(const G4Step *step);
00473 
00474         /// Construct() from G4VUserDetectorConstruction.
00475         G4VPhysicalVolume *Construct();
00476 
00477         /// PreUserTrackingAction() from G4UserTrackingAction.
00478         void PreUserTrackingAction(const G4Track *track);
00479 
00480         /// PostUserTrackingAction() from G4UserTrackingAction.
00481         void PostUserTrackingAction(const G4Track *track);
00482 
00483         /// BeginOfRunAction() from G4UserRunAction.
00484         void BeginOfRunAction(const G4Run *run);
00485 
00486         /// EndOfRunAction() from G4UserRunAction.
00487         void EndOfRunAction(const G4Run *run);
00488 
00489         /// BeginOfEventAction() from G4UserEventAction.
00490         void BeginOfEventAction(const G4Event* event);
00491 
00492         /// EndOfEventAction() from G4UserEventAction.
00493         void EndOfEventAction(const G4Event* event);
00494 
00495         /// GeneratePrimaries() from G4VUserPrimaryGeneratorAction.
00496         void GeneratePrimaries(G4Event *event);
00497 
00498         /// ClassifyNewTrack() from G4UserStackingAction.
00499         G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track*);
00500 
00501         /// NewStage() from G4userStackingAction.
00502         void NewStage();
00503 
00504         /// PrepareNewEvent() from G4StackingAction.
00505         void PrepareNewEvent();
00506 
00507         /// clearTrackIDMap() clears the TrackID map.
00508         void clearTrackIDMap() { trackIDMap.clear(); }
00509 
00510         /// setNextSecondaryTrackID() sets the external TrackID for the
00511         /// next secondary track. Automatically incremented for subsequent
00512         /// secondaries.
00513         void setNextSecondaryTrackID(int next) { nextSecondaryTrackID = next; }
00514         int getNextSecondaryTrackID() { return nextSecondaryTrackID; }
00515 
00516         /// getExternalTrackID() returns the external TrackID for the given
00517         /// track.
00518         /// In collective mode, internal and external trackID-s are the same.
00519         int getExternalTrackID(const G4Track *track);
00520 
00521         /// getExternalParentID() returns the external ParentID for the given
00522         /// track.
00523         /// In collective mode, internal and external trackID-s are the same.
00524         int getExternalParentID(const G4Track *track);
00525 
00526         /// setExternalTrackID() will set the external trackID and parentID.
00527         /// if trackID<0 uses nextSecondarTrackID++.
00528         void setExternalTrackID(G4Track *track, int trackID, int parentID);
00529 
00530         /// getPrimaryTrackID() returns the primaryTrackID set by the beam command
00531         int getPrimaryTrackID() { return primaryTrackID; }
00532 
00533         /// getPrimaryParentID() returns the primaryParentID set by the beam command
00534         int getPrimaryParentID() { return primaryParentID; }
00535 
00536         /// setPrimaryTrackID() sets track and parent IDs for a primary track.
00537         void setPrimaryTrackID(int t, int p)
00538                 { primaryTrackID = t; primaryParentID = p; }
00539 
00540         /// Notify() from G4VExceptionHandler.
00541         G4bool Notify(const char* originOfException, const char* exceptionCode,
00542                         G4ExceptionSeverity severity, const char* description);
00543 
00544         /// exceptionSummary() prints a summary of all exceptions
00545         void exceptionSummary();
00546 
00547         /// GSL error handler
00548         static void gsl_error_handler(const char *reason, const char *file,
00549                                                 int lineno, int gsl_errno);
00550 };
00551 
00552 #endif // BLMANAGER_HH
g4beamline