BLRunManager Class Reference

#include <BLRunManager.hh>

Inheritance diagram for BLRunManager:

BLCallback

List of all members.


Detailed Description

class BLRunManager -- enhanced version of G4RunManager.

There are three basic modes of BLRunManager: normal, collective, and enhanced.

Normal mode: This class inherents from G4RunManager, and can thus be used just like it, for standard control of the Geant4 simulation (via function BeamOn()).

Collective mode:

In collective mode a vector<G4TrackData*> is generated from the input file's beam commands, and then all tracks are stepped for one time step after which the BLCollectiveComputation::collectiveStep() is called; this is continued until all tracks are killed. Any secondaries generated can either be kept or discarded (see setCollectiveMode() below). The TrackID-s of primary tracks are preserved, and TrackIDs for secondary tracks are assigned sequentially from 1001, ignoring EventID.

Collective mode is selected by calling setCollectiveMode(), and then behaving externally just like normal mode (i.e. just call BeamOn()).

Enhanced mode: This class also implements functions that permit enhanced control of the simulation -- in particular there is a processOneTrack() function that simply processes a single track.

NOTE: the word "track" is ambiguous, and is commonly used as both a noun and a verb. Here it is a noun only (referring to a G4Track), and the verb is "process". Processing a track consists of stepping it through the simulation until it is killed or suspended, while holding all secondaries it generates. The secondaries are themselves tracks, and must be dealt with before another call to processOneTrack() (see below).

Enhanced run control: All of the usual G4beamline initialization must occur, so the following code is best put into a BLCallback function registered to replace the main loop -- that means it gets called after the post-Reference callbacks are called, and that after all replace-main-loop callbacks are called the program exits (thus avoiding the main loop).

BLRunManager *runmgr = BLRunManager::getObject(); runmgr->beginRun(int runid); --- loop over events --- runmgr->beginEvent(int evid); --- loop over tracks --- --- get a track runmgr->processOneTrack(track); --- handle secondaries (see below) runmgr->endEvent(); runmgr->endRun(); // write out NTuples, etc. (if appropriate)

There can be a loop over runs, if necessary.

Note that these enhanced run control routines do not create or handle trajectories, and ignore them if present. Hence no visualization of tracks is possible.

Note that secondaries are tracks, but they have not yet been assigned either a trackid or a parentid. Those should be assigned before the track is deferred, as all deferred tracks should have those id-s.

Handling secondaries -- do one of: runmgr->discardAllSecondaries(); or runmgr->processAllSecondariesAndDeferredTracks(); or runmgr->deferAllSecondaries(); // followed sometime later by: runmgr->processAllDeferredTracksAndTheirSecondaries(); or while((track=runmgr->popOneSecondary()) != 0) { // NOTE: you cannot call processOneTrack() here! // -- that would discard any remaining secondaries. if(--- condition ---) runmgr->deferOneTrack(track); else delete track; } // followed sometime later by: runmgr->processAllDeferredTracksAndTheirSecondaries();

Public Member Functions

 BLRunManager ()
 Constructor.
virtual ~BLRunManager ()
 Destructor.
virtual void BeamOn (int nEvents, const char *macroFile=0, G4int n_select=-1)
 BeamOn() will track beam events, in normal or collective mode. See setCollectiveMode() below.
virtual void callback (int type)
 callback() from BLCallback.
void beamOnCollective (int nEvents)
 beamOnCollective() processes an entire run in collective mode. In collective mode, a vector of BLTrackData is constructed, and all tracks in it are stepped one time step at a time. This is essentially an inversion of the usual loop over steps inside loops over tracks and events. All secondaries are immediately added to the end of trackVector, if keepSecondaries is true. The Tune and Reference particles are always tracked in normal mode.
void registerCollectiveComputation (BLCollectiveComputation *compute)
 registerCollectiveComputation() will register a computation to be called after every time step in collective mode. Multiple computations are called in the order they are registered. Must be called before beamOnCollective() or steps may be missed (usually called in the command() function of a BLCommand, so the order of commands in the input file is preserved).
std::vector< BLTrackData > & getTrackVector ()
 getTrackVector() returns the trackVector. Note: the track vector and its tracks can be modified inside the collective computation (takes effect immediately). As BLRunManager is a singleton, the trackVector never changes. No track is ever removed from the track vector, but they can have their status set to fStopAndKill which effectively does that.
int getCurrentTrackIndex ()
 getCurrentTrackIndex() returns the index in the track vector of the track currently being tracked. Returns -1 if not in collective mode, or if tracking is not in progress.
bool getCollectiveMode ()
 getCollectiveMode() returns true if in collective mode.
void setCollectiveMode (bool flag=true, bool _keepSecondaries=true, G4double _deltaT=1.0 *ns)
 setCollectiveMode() arranges for calls to BeamOn() to call beamOnCollective() rather than the usual G4RunManager function. This is for BEAM only; TUNE and REFERENCE particles are always tracked normally via G4RunManager::BeamOn(). _keepSecondaries applies ONLY in collective mode (in normal mode secondaries are always kept, in enhanced mode that is up to the user).
G4double getNextStepTime ()
 getNextStepTime() will get the time for the next step in time NOTE: inside collectiveStep() this function returns the time of the CURRENT step, not the next one.
G4double getDeltaT ()
 getDeltaT() will get the time interval between time steps
void setDeltaT (G4double dt)
 setDeltaT() will set the time interval between time steps. All tracks will be stepped to the same value of global time. Initiall value is 1.0*ns. deltaT <= 0.0 is an error. Can be called at any time; if called within collectiveStep() it will affect the immediately following time step.
void rejectCollectiveStep ()
 rejectCollectiveStep() will cause the run manager to abandon tracking (if in progress) and to discard all of the current tracks, replacing the vector with a copy saved immediately after the previous call to collectiveStep() returned. Thus the current collective step will be repeated as if no tracking had been performed since the previous return from collectiveStep(). For this to make sense, setDeltaT() should have been called with a smaller value -- this is intended for a collective algorithm to dynamically adapt the value of deltaT. Note: the first step is to bring all beam tracks to a common value of global time, and rejecting this step is ignored.
void beginRun (int runid=0)
 beginRun() begins a run in enhanced run-control mode.
void endRun ()
 endRun() ends a run in enhanced run-control mode.
void beginEvent (int evid=0)
 beginEvent() begins an event in enhanced run-control mode.
void endEvent ()
 endEvent() ends an event in enhanced run-control mode.
bool getNextBeamEventAndTrack (G4Event **pevent, G4Track **ptrack)
 getNextBeamEventAndTrack() will get the next beam event and track. returns true if one is returned, false if none are left. Neithe event actions nor track actions are performed. Both *pevent and *ptrack must be deleted.
void processOneTrack (G4Track *track)
 processOneTrack() tracks a single track until it is suspended or killed. Note that before tracking begins it deletes any held secondaries, so if secondaries are not to be discarded they must be deferred or processed before the next call. You may want to call BLManager::setState(SPECIAL) to prevent this track from being entered into NTuples for virtualdetectors (etc.) encountered during processing. This function MUST NOT BE CALLED if any track is being processed via any means (e.g. the normal BeamOn() is executing).
void discardAllSecondaries ()
 discardAllSecondaries() will discard all secondaries.
int deferAllSecondaries (int secondaryid=10000, int parentid=-1)
 deferAllSecondaries() will defer all secondaries until deferred tracks are processed. Returns # tracks deferred.
void deferOneTrack (G4Track *track)
 deferOneTrack() will defer a single track until deferred tracks are processed.
int processAllSecondariesAndDeferredTracks (int secondaryid=10000, int parentid=-1)
 processAllSecondariesAndDeferredTracks() will defer all secondaries and then process all deferred tracks and their secondaries. returns # tracks processed.
int processAllDeferredTracksAndTheirSecondaries (int trackid=10000)
 processAllDeferredTracksAndTheirSecondaries() will process all deferred tracks, including processing their secondaries. Returns # tracks processed.
G4Track * popOneSecondary ()
 popOneSecondary() will return a pointer to one secondary, removing it from the list of secondaries; returns NULL if no more. Intended to be called in a loop immediately after a call to processOneTrack(). The returned pointer should eventually be deleted. Order is LIFO.
G4Track * popOneDeferredTrack ()
 popOneDeferredTrack() will return a pointer to one deferred track, removing it from the list of deferred tracks; returns NULL if no more. The returned pointer should eventually be deleted. Note that a loop calling this function can defer other tracks or secondaries, which simply extends the loop. Order is LIFO.
void RunInitialization ()
void DoEventLoop (G4int n_event, const char *macroFile, G4int n_select)
void RunTermination ()
G4EventManager * getEventManager ()
G4TrackingManager * getTrackingManager ()
G4StackManager * getStackManager ()
void setCurrentEvent (G4Event *ev)
G4bool getRunAborted ()

Static Public Member Functions

static BLRunManagergetObject ()
 returns the (singleton) BLRunManager. Note that G4RunManager::GetRunManager() returns a pointr to the base class, not this class.

Private Member Functions

void appendTrack (G4Track *track)

Private Attributes

G4TrackingManager * trackManager
G4StackManager * stackManager
std::vector< BLTrackDatatrackVector
std::vector
< BLCollectiveComputation * > 
computeVector
bool collectiveMode
bool keepSecondaries
G4double nextStepTime
G4double deltaT
G4int currentTrackIndex
bool rejected
int nextSecondaryTrackID

Static Private Attributes

static BLRunManagersingleton = 0


Constructor & Destructor Documentation

BLRunManager::BLRunManager (  ) 

Constructor.

References collectiveMode, currentTrackIndex, deltaT, keepSecondaries, nextSecondaryTrackID, nextStepTime, rejected, singleton, and stackManager.

Referenced by getObject().

00111                            : G4RunManager(), trackVector(), computeVector()
00112 {
00113         assert(singleton==0);
00114         singleton = this;
00115 
00116         stackManager = 0;
00117         collectiveMode = false;
00118         keepSecondaries = true;
00119         nextStepTime = 0.0;
00120         deltaT = 1.0*ns;
00121         currentTrackIndex = -1;
00122         rejected = false;
00123         nextSecondaryTrackID = -9999;
00124 }

BLRunManager::~BLRunManager (  )  [virtual]

Destructor.

References computeVector, and trackVector.

00127 {
00128         trackVector.clear();
00129         computeVector.clear();
00130 }


Member Function Documentation

void BLRunManager::appendTrack ( G4Track *  track  )  [private]

References nextSecondaryTrackID, and trackVector.

Referenced by beamOnCollective().

00324 {
00325         G4int evId = currentEvent->GetEventID();
00326         if(track->GetTrackID() <= 0) {
00327                 track->SetTrackID(nextSecondaryTrackID++);
00328         }
00329 
00330         G4Event *tmp = currentEvent;
00331         currentEvent = new G4Event(*currentEvent);
00332 
00333         trackVector.push_back(BLTrackData(currentEvent,track));
00334 
00335         currentEvent = tmp;
00336 }

BLRunManager * BLRunManager::getObject (  )  [static]

returns the (singleton) BLRunManager. Note that G4RunManager::GetRunManager() returns a pointr to the base class, not this class.

References BLRunManager(), and singleton.

Referenced by BLCMDtrackermode::callback(), BLCMDtrace::command(), BLCMDcollective::command(), BLCMDtracker::fitTrack(), BLManager::handleCallbacks(), BLCMDtracker::handlePreviousTracks(), BLCMDtracker::operator()(), BLCMDtracker::PostUserTrackingAction(), TraceNTuple::TraceNTuple(), and TStepLimiter::TStepLimiter().

00100 {
00101         if(!singleton) {
00102                 new BLRunManager();
00103                 // startup sequencing prevents registering callback, so it
00104                 // is hard-coded in BLManager::handleCallbacks(). This is due
00105                 // to the BLManager constructor calling this function.
00106         }
00107 
00108         return singleton; 
00109 }

void BLRunManager::BeamOn ( int  nEvents,
const char *  macroFile = 0,
G4int  n_select = -1 
) [virtual]

BeamOn() will track beam events, in normal or collective mode. See setCollectiveMode() below.

References BEAM, beamOnCollective(), collectiveMode, and BLManager::getObject().

Referenced by BLManager::trackBeam(), and BLManager::trackTuneAndReferenceParticles().

00132                                                                             {
00133         if(collectiveMode && BLManager::getObject()->getState() == BEAM)
00134                 beamOnCollective(nEvents);
00135         else
00136                 G4RunManager::BeamOn(nEvents,macroFile,n_select);
00137 }

void BLRunManager::callback ( int  type  )  [virtual]

callback() from BLCallback.

Reimplemented from BLCallback.

References collectiveMode.

Referenced by BLManager::handleCallbacks().

00140 {
00141         // Only perform actions between reference and Beam
00142         if(type != 1) return;
00143 
00144         // in collectiveMode, add a TStepLimiter to every particle
00145         if(collectiveMode) {
00146                 printf("BLRunManager: adding TStepLimiter processes to all particles\n");
00147                 G4ParticleTable::G4PTblDicIterator *theParticleIterator
00148                         = G4ParticleTable::GetParticleTable()->GetIterator();
00149                 theParticleIterator->reset();
00150                 while((*theParticleIterator)()) {
00151                         G4ParticleDefinition *pd = 
00152                                         theParticleIterator->value();
00153                         if(pd->IsShortLived()) continue;
00154                         G4ProcessManager *pmgr = pd->GetProcessManager();
00155                         if(!pmgr) continue;
00156                         TStepLimiter *tsl = new TStepLimiter();
00157                         pmgr->AddProcess(tsl,-1,-1,3);
00158                         pmgr->SetProcessOrdering(tsl,idxPostStep);
00159                         pmgr->SetProcessOrdering(tsl,idxAtRest);
00160                 }
00161         }
00162 }

void BLRunManager::beamOnCollective ( int  nEvents  ) 

beamOnCollective() processes an entire run in collective mode. In collective mode, a vector of BLTrackData is constructed, and all tracks in it are stepped one time step at a time. This is essentially an inversion of the usual loop over steps inside loops over tracks and events. All secondaries are immediately added to the end of trackVector, if keepSecondaries is true. The Tune and Reference particles are always tracked in normal mode.

References appendTrack(), BEAM, BLManager::BeginOfEventAction(), computeVector, currentTrackIndex, deltaT, BLTrackData::event, BLManager::getNextSecondaryTrackID(), BLManager::getObject(), TStepLimiter::getPrevStatus(), BLManager::getPrimaryTrackID(), IDLE, keepSecondaries, nextSecondaryTrackID, nextStepTime, processOneTrack(), rejected, RunInitialization(), RunTermination(), BLManager::setEventID(), BLManager::setEventTimeLimit(), BLManager::setState(), stackManager, BLTrackData::track, trackManager, and trackVector.

Referenced by BeamOn().

00165 {
00166         BLManager *manager = BLManager::getObject();
00167         G4TransportationManager *transportManager =
00168                         G4TransportationManager::GetTransportationManager();
00169         G4StateManager* stateManager = G4StateManager::GetStateManager();
00170         numberOfEventToBeProcessed = nEvents;
00171 
00172         if(!ConfirmBeamOnCondition()) {
00173                 G4Exception("BLRunManager","Cannot run beam",FatalException,"");
00174         }
00175         printf("================== In Collective Mode ==================\n");
00176         ConstructScoringWorlds();
00177         RunInitialization();
00178         G4ApplicationState currentState = stateManager->GetCurrentState();
00179         if(currentState != G4State_GeomClosed) {
00180                 G4Exception("BLRunManager","Geometry not closed",FatalException,
00181                                                                         "");
00182         }
00183 
00184         manager->setState(BEAM);
00185         stateManager->SetNewState(G4State_EventProc);
00186         trackManager = 0; // unused in collective mode
00187         stackManager = eventManager->GetStackManager();
00188         runAborted = false;
00189 
00190         // the per-event time limit makes no sense in collective mode
00191         manager->setEventTimeLimit(-1); // infinite
00192 
00193         // event loop to create trackVector
00194         G4PrimaryTransformer *transformer = new G4PrimaryTransformer();
00195         G4Navigator* navigator = transportManager->GetNavigatorForTracking();
00196         nextStepTime = -DBL_MAX;
00197         int nev;
00198         for(nev=0; nev<nEvents; ++nev) {
00199                 currentEvent = GenerateEvent(nev);
00200                 if(!currentEvent || runAborted) break;
00201                 stackManager->PrepareNewEvent();
00202                 manager->BeginOfEventAction(currentEvent);
00203                 G4TrackVector *tv=transformer->GimmePrimaries(currentEvent,0);
00204                 int evId=currentEvent->GetEventID();
00205                 if(evId <= 0) {
00206                         evId = nev;
00207                         currentEvent->SetEventID(evId);
00208                 }
00209                 nextSecondaryTrackID = manager->getNextSecondaryTrackID();
00210                 for(unsigned j=0; j<tv->size(); ++j) {
00211                         G4Track *track = (*tv)[j];
00212                         assert(j==0); // cannot handle multiple primaries 
00213                         track->SetTrackID(manager->getPrimaryTrackID());
00214                         appendTrack(track);
00215                         G4double t = track->GetGlobalTime();
00216                         if(t > nextStepTime) nextStepTime = t;
00217                 }
00218                 if(tv->size() == 0) delete currentEvent;
00219                 tv->clear();
00220                 if(runAborted) break;
00221                 transportManager->SetNavigatorForTracking(navigator);
00222                 manager->setEventID(evId+1);
00223         }
00224 
00225         printf("=========== Collective: %d Events, %ld Tracks ==============\n",
00226                                 nev,(long)trackVector.size());
00227 
00228         for(unsigned i=0; i<computeVector.size(); ++i)
00229                 computeVector[i]->beginCollectiveTracking(trackVector);
00230 
00231         // Step loop
00232         runAborted = false;
00233         int nActive;
00234         bool first=true;
00235         G4double saveNextStepTime = nextStepTime;
00236         std::vector<G4Track*> saveVector;
00237         do {
00238                 if(runAborted) goto RunAborted;
00239                 nActive = 0;
00240                 rejected = false;
00241                 // note: secondaries can be appended to trackVector during loop
00242                 for(unsigned i=0; i<trackVector.size(); ++i) {
00243                         if(rejected && !first) break;
00244                         BLTrackData *td = &trackVector[i];
00245                         G4Track *track = td->track;
00246                         G4TrackStatus trackStatus = track->GetTrackStatus();
00247 //printf("Collective Track loop: ev=%d trk=%d status=%d fAlive=%d fSuspend=%d\n",td->event->GetEventID(),track->GetTrackID(),(int)trackStatus, fAlive,fSuspend);
00248                         if(trackStatus != fAlive && 
00249                                                 trackStatus != fStopButAlive)
00250                                 continue;
00251                         ++nActive;
00252                         currentEvent = td->event;
00253                         manager->setEventID(td->event->GetEventID());
00254                         currentTrackIndex = i;
00255                         for(unsigned j=0; j<computeVector.size(); ++j)
00256                                 computeVector[j]->beginTrack(trackVector,i);
00257                         if(runAborted) goto RunAborted;
00258                         processOneTrack(track);
00259                         currentTrackIndex = -1;
00260                         if(td->event->IsAborted())
00261                                 track->SetTrackStatus(fKillTrackAndSecondaries);
00262                         if(runAborted) goto RunAborted;
00263                         trackStatus = track->GetTrackStatus();
00264                         if(trackStatus == fSuspend)
00265                                 track->SetTrackStatus(TStepLimiter::getPrevStatus());
00266                         G4TrackVector *tv = trackManager->GimmeSecondaries();
00267                         if(keepSecondaries && trackStatus != fKillTrackAndSecondaries) {
00268                                 for(unsigned j=0; j<tv->size(); ++j)
00269                                         appendTrack((*tv)[j]);
00270                                 tv->clear();
00271                         } else {
00272                                 for(unsigned j=0; j<tv->size(); ++j)
00273                                         delete (*tv)[j];
00274                                 tv->clear();
00275                         }
00276                 }
00277                 if(runAborted) goto RunAborted;
00278                 // don't call collectiveStep() if rejected during tracking
00279                 if(!rejected || first) {
00280                         for(unsigned i=0; i<computeVector.size(); ++i)
00281                                 computeVector[i]->collectiveStep(trackVector);
00282                 }
00283                 if(rejected && !first) {
00284                         // discard current tracks, and restore saved ones
00285                         unsigned n=saveVector.size();
00286                         // first, discard any added secondaries
00287                         while(trackVector.size() > n) {
00288                                 delete trackVector.back().track;
00289                                 delete trackVector.back().event;
00290                                 trackVector.pop_back();
00291                         }
00292                         assert(trackVector.size() == saveVector.size());
00293                         for(unsigned i=0; i<n; ++i) {
00294                                 delete trackVector[i].track;
00295                                 trackVector[i].track = saveVector[i];
00296                         }
00297                         nextStepTime = saveNextStepTime;
00298                 } else {
00299                         // delete saved tracks, and save current ones
00300                         for(unsigned i=0; i<saveVector.size(); ++i)
00301                                 delete saveVector[i];
00302                         saveVector.clear();
00303                         for(unsigned i=0; i<trackVector.size(); ++i)
00304                                 saveVector.push_back(
00305                                         new G4Track(*trackVector[i].track));
00306                         saveNextStepTime = nextStepTime;
00307                         nextStepTime += deltaT;
00308                 }
00309                 first = false;
00310         } while(nActive > 0);
00311 
00312 //fprintf(stderr,"BeamOnCollective tracking complete. sleep(10)... ");
00313 //sleep(10);
00314 //fprintf(stderr,"\n");
00315 RunAborted:
00316         for(unsigned i=0; i<computeVector.size(); ++i)
00317                 computeVector[i]->endCollectiveTracking(trackVector);
00318 
00319         RunTermination();
00320         manager->setState(IDLE);
00321 }

void BLRunManager::registerCollectiveComputation ( BLCollectiveComputation compute  )  [inline]

registerCollectiveComputation() will register a computation to be called after every time step in collective mode. Multiple computations are called in the order they are registered. Must be called before beamOnCollective() or steps may be missed (usually called in the command() function of a BLCommand, so the order of commands in the input file is preserved).

References computeVector.

Referenced by BLCMDtrace::command(), and BLCMDcollective::command().

00178                 { computeVector.push_back(compute); }

std::vector<BLTrackData>& BLRunManager::getTrackVector (  )  [inline]

getTrackVector() returns the trackVector. Note: the track vector and its tracks can be modified inside the collective computation (takes effect immediately). As BLRunManager is a singleton, the trackVector never changes. No track is ever removed from the track vector, but they can have their status set to fStopAndKill which effectively does that.

References trackVector.

00186 { return trackVector; }

int BLRunManager::getCurrentTrackIndex (  )  [inline]

getCurrentTrackIndex() returns the index in the track vector of the track currently being tracked. Returns -1 if not in collective mode, or if tracking is not in progress.

References currentTrackIndex.

00191 { return currentTrackIndex; }

bool BLRunManager::getCollectiveMode (  )  [inline]

void BLRunManager::setCollectiveMode ( bool  flag = true,
bool  _keepSecondaries = true,
G4double  _deltaT = 1.0*ns 
) [inline]

setCollectiveMode() arranges for calls to BeamOn() to call beamOnCollective() rather than the usual G4RunManager function. This is for BEAM only; TUNE and REFERENCE particles are always tracked normally via G4RunManager::BeamOn(). _keepSecondaries applies ONLY in collective mode (in normal mode secondaries are always kept, in enhanced mode that is up to the user).

References collectiveMode, keepSecondaries, and setDeltaT().

Referenced by BLCMDcollective::command(), and BLManager::trackTuneAndReferenceParticles().

00205                 { collectiveMode=flag;
00206                   keepSecondaries=_keepSecondaries;
00207                   setDeltaT(_deltaT);
00208                 }

G4double BLRunManager::getNextStepTime (  )  [inline]

getNextStepTime() will get the time for the next step in time NOTE: inside collectiveStep() this function returns the time of the CURRENT step, not the next one.

References nextStepTime.

Referenced by TStepLimiter::AtRestGetPhysicalInteractionLength(), BLCMDcollective::collectiveStep(), and TStepLimiter::PostStepGetPhysicalInteractionLength().

00213 { return nextStepTime; }

G4double BLRunManager::getDeltaT (  )  [inline]

getDeltaT() will get the time interval between time steps

References deltaT.

00220 { return deltaT; }

void BLRunManager::setDeltaT ( G4double  dt  )  [inline]

setDeltaT() will set the time interval between time steps. All tracks will be stepped to the same value of global time. Initiall value is 1.0*ns. deltaT <= 0.0 is an error. Can be called at any time; if called within collectiveStep() it will affect the immediately following time step.

References deltaT.

Referenced by BLCMDcollective::beginCollectiveTracking(), BLCMDcollective::command(), and setCollectiveMode().

00227 { assert(dt>0.0); deltaT = dt; }

void BLRunManager::rejectCollectiveStep (  )  [inline]

rejectCollectiveStep() will cause the run manager to abandon tracking (if in progress) and to discard all of the current tracks, replacing the vector with a copy saved immediately after the previous call to collectiveStep() returned. Thus the current collective step will be repeated as if no tracking had been performed since the previous return from collectiveStep(). For this to make sense, setDeltaT() should have been called with a smaller value -- this is intended for a collective algorithm to dynamically adapt the value of deltaT. Note: the first step is to bring all beam tracks to a common value of global time, and rejecting this step is ignored.

References rejected.

00241 { rejected = true; }

void BLRunManager::beginRun ( int  runid = 0  ) 

beginRun() begins a run in enhanced run-control mode.

References BEAM, BLManager::getObject(), RunInitialization(), and BLManager::setState().

Referenced by BLCMDtrackermode::callback(), and BLCMDtracker::handlePreviousTracks().

00339 {
00340         BLManager::getObject()->setState(BEAM);
00341         ConstructScoringWorlds();
00342         RunInitialization();
00343         SetRunIDCounter(runid);
00344         runAborted = false;
00345 }

void BLRunManager::endRun (  ) 

endRun() ends a run in enhanced run-control mode.

References BLManager::getObject(), IDLE, RunTermination(), and BLManager::setState().

Referenced by BLCMDtrackermode::callback(), and BLCMDtracker::handlePreviousTracks().

00348 {
00349         RunTermination();
00350         BLManager::getObject()->setState(IDLE);
00351 }

void BLRunManager::beginEvent ( int  evid = 0  ) 

beginEvent() begins an event in enhanced run-control mode.

References BLManager::BeginOfEventAction(), BLManager::getObject(), stackManager, and trackManager.

Referenced by BLCMDtrackermode::callback(), and BLCMDtracker::handlePreviousTracks().

00354 {
00355         if(currentEvent) delete currentEvent;
00356         currentEvent = new G4Event(evid);
00357         trackManager = eventManager->GetTrackingManager();
00358         stackManager = eventManager->GetStackManager();
00359         BLManager::getObject()->BeginOfEventAction(currentEvent);
00360 }

void BLRunManager::endEvent (  ) 

endEvent() ends an event in enhanced run-control mode.

References BLManager::EndOfEventAction(), BLManager::getObject(), stackManager, and trackManager.

Referenced by BLCMDtrackermode::callback(), and BLCMDtracker::handlePreviousTracks().

00363 {
00364         BLManager::getObject()->EndOfEventAction(currentEvent);
00365         if(currentEvent) delete currentEvent;
00366         currentEvent = 0;
00367         trackManager = 0;
00368         stackManager = 0;
00369 }

bool BLRunManager::getNextBeamEventAndTrack ( G4Event **  pevent,
G4Track **  ptrack 
)

getNextBeamEventAndTrack() will get the next beam event and track. returns true if one is returned, false if none are left. Neithe event actions nor track actions are performed. Both *pevent and *ptrack must be deleted.

References BEAM, BLManager::getObject(), BLManager::getPrimaryParentID(), BLManager::getPrimaryTrackID(), BLManager::setState(), and SPECIAL.

00372 {
00373         static bool more=true;
00374         static int nev=0;
00375         static BLManager *manager=0;
00376         static G4PrimaryTransformer *transformer=0;
00377         if(!manager) {
00378                 manager = BLManager::getObject();
00379                 transformer = new G4PrimaryTransformer();
00380         }
00381 
00382         if(!more) return false;
00383 
00384         manager->setState(BEAM);
00385         currentEvent = GenerateEvent(nev);
00386         if(!currentEvent || runAborted) {
00387                 more = false;
00388                 return false;
00389         }
00390         *pevent = currentEvent;
00391         G4TrackVector *tv=transformer->GimmePrimaries(currentEvent,0);
00392         int evId=currentEvent->GetEventID();
00393         if(evId <= 0) {
00394                 evId = nev;
00395                 currentEvent->SetEventID(evId);
00396         }
00397         for(unsigned j=0; j<tv->size(); ++j) {
00398                 G4Track *track = (*tv)[j];
00399                 assert(j==0); // cannot handle multiple primaries 
00400                 track->SetTrackID(manager->getPrimaryTrackID());
00401                 track->SetParentID(manager->getPrimaryParentID());
00402                 *ptrack = track;
00403         }
00404         tv->clear();
00405         if(runAborted) {
00406                 more = false;
00407                 return false;
00408         }
00409         ++nev;
00410         manager->setState(SPECIAL);
00411         return true;
00412 }

void BLRunManager::processOneTrack ( G4Track *  track  ) 

processOneTrack() tracks a single track until it is suspended or killed. Note that before tracking begins it deletes any held secondaries, so if secondaries are not to be discarded they must be deferred or processed before the next call. You may want to call BLManager::setState(SPECIAL) to prevent this track from being entered into NTuples for virtualdetectors (etc.) encountered during processing. This function MUST NOT BE CALLED if any track is being processed via any means (e.g. the normal BeamOn() is executing).

References stackManager, and trackManager.

Referenced by beamOnCollective(), BLCMDtracker::fitTrack(), BLCMDtracker::operator()(), and processAllDeferredTracksAndTheirSecondaries().

00415 {
00416         if(!trackManager || !stackManager) {
00417                 trackManager = eventManager->GetTrackingManager();
00418                 stackManager = eventManager->GetStackManager();
00419         }
00420         assert(track != 0);
00421         trackManager->ProcessOneTrack(track);
00422 }

void BLRunManager::discardAllSecondaries (  ) 

discardAllSecondaries() will discard all secondaries.

References trackManager.

00425 {
00426         G4TrackVector *secondaries = trackManager->GimmeSecondaries();
00427         for(unsigned j=0; j<secondaries->size(); ++j)
00428                 delete (*secondaries)[j];
00429         secondaries->clear();
00430 }

int BLRunManager::deferAllSecondaries ( int  secondaryid = 10000,
int  parentid = -1 
)

deferAllSecondaries() will defer all secondaries until deferred tracks are processed. Returns # tracks deferred.

References deferOneTrack(), and trackManager.

Referenced by processAllDeferredTracksAndTheirSecondaries(), and processAllSecondariesAndDeferredTracks().

00433 {
00434         int n=0;
00435         G4TrackVector *secondaries = trackManager->GimmeSecondaries();
00436         for(unsigned j=0; j<secondaries->size(); ++j) {
00437                 G4Track *track = (*secondaries)[j];
00438                 track->SetTrackID(secondaryid++);
00439                 track->SetParentID(parentid); 
00440                 deferOneTrack(track);
00441                 ++n;
00442         }
00443         secondaries->clear();
00444 
00445         return n;
00446 }

void BLRunManager::deferOneTrack ( G4Track *  track  ) 

deferOneTrack() will defer a single track until deferred tracks are processed.

References stackManager.

Referenced by deferAllSecondaries().

00449 {
00450         stackManager->PushOneTrack(track);
00451 }

int BLRunManager::processAllSecondariesAndDeferredTracks ( int  secondaryid = 10000,
int  parentid = -1 
) [inline]

processAllSecondariesAndDeferredTracks() will defer all secondaries and then process all deferred tracks and their secondaries. returns # tracks processed.

References deferAllSecondaries(), and processAllDeferredTracksAndTheirSecondaries().

00297                                                                          {
00298                 int first = secondaryid;
00299                 secondaryid += deferAllSecondaries(secondaryid,parentid);
00300                 secondaryid +=
00301                        processAllDeferredTracksAndTheirSecondaries(secondaryid);
00302                 return secondaryid-first;
00303         }

int BLRunManager::processAllDeferredTracksAndTheirSecondaries ( int  trackid = 10000  ) 

processAllDeferredTracksAndTheirSecondaries() will process all deferred tracks, including processing their secondaries. Returns # tracks processed.

References deferAllSecondaries(), processOneTrack(), and stackManager.

Referenced by processAllSecondariesAndDeferredTracks().

00454 {
00455         int first=secondaryid;
00456         for(;;) {
00457                 G4VTrajectory *trajectory=0;
00458                 G4Track *track = stackManager->PopNextTrack(&trajectory);
00459                 if(!track) break;
00460                 processOneTrack(track);
00461                 int parentid = track->GetTrackID();
00462                 delete track;
00463                 secondaryid += deferAllSecondaries(secondaryid,parentid);
00464         }
00465 
00466         return secondaryid-first;
00467 }

G4Track * BLRunManager::popOneSecondary (  ) 

popOneSecondary() will return a pointer to one secondary, removing it from the list of secondaries; returns NULL if no more. Intended to be called in a loop immediately after a call to processOneTrack(). The returned pointer should eventually be deleted. Order is LIFO.

References trackManager.

00470 {
00471         G4TrackVector *secondaries = trackManager->GimmeSecondaries();
00472         int i = secondaries->size();
00473         if(i == 0) return 0;
00474         G4Track *track = secondaries->back();
00475         secondaries->pop_back();
00476         return track;
00477 }

G4Track * BLRunManager::popOneDeferredTrack (  ) 

popOneDeferredTrack() will return a pointer to one deferred track, removing it from the list of deferred tracks; returns NULL if no more. The returned pointer should eventually be deleted. Note that a loop calling this function can defer other tracks or secondaries, which simply extends the loop. Order is LIFO.

References stackManager.

00480 {
00481         G4VTrajectory *trajectory=0;
00482         return stackManager->PopNextTrack(&trajectory);
00483 }

void BLRunManager::RunInitialization (  )  [inline]

Referenced by beamOnCollective(), and beginRun().

00326 { G4RunManager::RunInitialization(); }

void BLRunManager::DoEventLoop ( G4int  n_event,
const char *  macroFile,
G4int  n_select 
) [inline]

00327                                                                              {
00328                 G4RunManager::DoEventLoop(n_event,macroFile,n_select);
00329         }

void BLRunManager::RunTermination (  )  [inline]

Referenced by beamOnCollective(), and endRun().

00330 { G4RunManager::RunTermination(); }

G4EventManager* BLRunManager::getEventManager (  )  [inline]

Referenced by BLCMDtrackermode::callback().

00331 { return eventManager; }

G4TrackingManager* BLRunManager::getTrackingManager (  )  [inline]

References trackManager.

00332 { return trackManager; }

G4StackManager* BLRunManager::getStackManager (  )  [inline]

References stackManager.

00333 { return stackManager; }

void BLRunManager::setCurrentEvent ( G4Event *  ev  )  [inline]

Referenced by BLCMDtrace::collectiveStep().

00334 { currentEvent = ev; }

G4bool BLRunManager::getRunAborted (  )  [inline]

Referenced by BLCMDtrackermode::callback().

00335 { return runAborted; }


Member Data Documentation

BLRunManager * BLRunManager::singleton = 0 [static, private]

Referenced by BLRunManager(), and getObject().

G4TrackingManager* BLRunManager::trackManager [private]

G4StackManager* BLRunManager::stackManager [private]

std::vector<BLTrackData> BLRunManager::trackVector [private]

G4double BLRunManager::nextStepTime [private]

G4double BLRunManager::deltaT [private]

bool BLRunManager::rejected [private]


The documentation for this class was generated from the following files:
g4beamline