BLRunManager Class Reference

#include <BLRunManager.hh>

Inheritance diagram for BLRunManager:

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.
void	DoEventLoop (G4int n_event, const char *macroFile, G4int n_select)
	DoEventLoop() is REPLACED, so abondonCurrentEvent() works.
void	abandonCurrentEvent ()
	abandonCurrentEvent() will abandon the current event by performing a longjmp into DoEventLoop(). Not guaranteed to work, but probably does, even if called from BLAlarm::signal(). NOTE: If the current event can be abandoned, this function never returns; if the event cannot be abandoned, it returns immediately.
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)
	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().
G4double	getStepTime ()
	getStepTime() will get the ste time. NOTE: inside collectiveStep() this function returns the time of the current step; outside collectiveStep() it returns the next step time (i.e. the time at which tracks should be suspended).
void	setStepTime (G4double t)
	setStepTime() will set the time for the next step in time. If called from within collectiveStep(), it may confuse other classes collectiveStep()-s. If called from beginCollectiveTracking() it sets the time of the first step.
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	RunTermination ()
G4EventManager *	getEventManager ()
G4TrackingManager *	getTrackingManager ()
G4StackManager *	getStackManager ()
void	setCurrentEvent (G4Event *ev)
G4bool	getRunAborted ()
Static Public Member Functions
static BLRunManager *	getObject ()
	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
jmp_buf	jmpBuf
bool	validJmpBuf
std::vector< BLTrackData >	trackVector
std::vector < BLCollectiveComputation * >	computeVector
bool	collectiveMode
bool	keepSecondaries
G4double	stepTime
G4double	deltaT
G4int	currentTrackIndex
bool	rejected
int	nextSecondaryTrackID
Static Private Attributes
static BLRunManager *	singleton = 0

---

Constructor & Destructor Documentation

BLRunManager::BLRunManager

(

)

Constructor.

References BLAssert, collectiveMode, currentTrackIndex, deltaT, keepSecondaries, nextSecondaryTrackID, rejected, singleton, stackManager, stepTime, trackManager, and validJmpBuf.

Referenced by getObject().

                           : G4RunManager(), trackVector(), computeVector()
{
        BLAssert(singleton==0);
        singleton = this;

        trackManager = 0;
        stackManager = 0;
        validJmpBuf = false;
        collectiveMode = false;
        keepSecondaries = true;
        stepTime = 0.0;
        deltaT = 1.0*ns;
        currentTrackIndex = -1;
        rejected = false;
        nextSecondaryTrackID = -9999;
}

BLRunManager::~BLRunManager

(

)

[virtual]

Destructor.

References computeVector, and trackVector.

{
        trackVector.clear();
        computeVector.clear();
}

---

Member Function Documentation

void BLRunManager::appendTrack

(

G4Track *

track

)

[private]

References nextSecondaryTrackID, and trackVector.

Referenced by beamOnCollective().

{
        G4int evId = currentEvent->GetEventID();
        if(track->GetTrackID() <= 0) {
                track->SetTrackID(nextSecondaryTrackID++);
        }

        G4Event *tmp = currentEvent;
        currentEvent = new G4Event(*currentEvent);

        trackVector.push_back(BLTrackData(currentEvent,track));

        currentEvent = tmp;
}

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 BLCMDntuple::BeginOfEventAction(), Bunch::Bunch(), BLCMDtrackermode::callback(), BLCMDtrace::command(), BLCMDspacechargelw::command(), BLCMDspacecharge::command(), BLCMDcollective::command(), BLCMDtracker::fitTrack(), BLManager::handleCallbacks(), BLCMDtracker::handlePreviousTracks(), BLCMDtracker::operator()(), BLCMDtracker::PostUserTrackingAction(), BLCMDtracker::PreUserTrackingAction(), BLAlarm::sighandler(), TraceNTuple::TraceNTuple(), and TStepLimiter::TStepLimiter().

{
        if(!singleton) {
                new BLRunManager();
                // startup sequencing prevents registering callback, so it
                // is hard-coded in BLManager::handleCallbacks(). This is due
                // to the BLManager constructor calling this function.
        }

        return singleton; 
}

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().

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

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

DoEventLoop() is REPLACED, so abondonCurrentEvent() works.

References jmpBuf, and validJmpBuf.

{
        if(verboseLevel>0) { timer->Start(); }

        G4String msg;
        if(macroFile!=0) { 
                if(n_select<0) n_select = n_event;
                msg = "/control/execute ";
                msg += macroFile;
        } else {
                n_select = -1;
        }

        int local_n_select = n_select; // argument can be clobbered by longjmp

        // Event loop
        volatile G4int i_event = 0;
        if(setjmp(jmpBuf) != 0) ++i_event;
        validJmpBuf = true;
        while(i_event<n_event) {
                currentEvent = GenerateEvent(i_event);
                eventManager->ProcessOneEvent(currentEvent);
                AnalyzeEvent(currentEvent);
                UpdateScoring();
                if(i_event<local_n_select)
                        G4UImanager::GetUIpointer()->ApplyCommand(msg);
                StackPreviousEvent(currentEvent);
                currentEvent = 0;
                if(runAborted) break;
                ++i_event;
        }
        validJmpBuf = false;

        if(verboseLevel>0) {
                timer->Stop();
                G4cout << "Run terminated." << G4endl;
                G4cout << "Run Summary" << G4endl;
                if(runAborted) {
                        G4cout << "  Run Aborted after " << i_event + 1 <<
                                                " events processed." << G4endl;
                } else {
                        G4cout << "  Number of events processed : " << n_event
                                                                << G4endl; 
                }
                G4cout << "  "  << *timer << G4endl;
        }
}

void BLRunManager::abandonCurrentEvent

(

)

abandonCurrentEvent() will abandon the current event by performing a longjmp into DoEventLoop(). Not guaranteed to work, but probably does, even if called from BLAlarm::signal(). NOTE: If the current event can be abandoned, this function never returns; if the event cannot be abandoned, it returns immediately.

References jmpBuf, and validJmpBuf.

Referenced by BLAlarm::sighandler().

{
        if(validJmpBuf) {
                G4Exception("BLRunManager","Event Time Limit Alarm",
                                                        EventMustBeAborted,"");
                G4StateManager::GetStateManager()->
                                                SetNewState(G4State_GeomClosed);
                longjmp(jmpBuf,1);
        }
}

void BLRunManager::callback

(

int

type

)

[virtual]

callback() from BLCallback.

Reimplemented from BLCallback.

References collectiveMode, and stepTime.

Referenced by BLManager::handleCallbacks().

{
        // Only perform actions before Tune particle
        if(type != 0) return;

        // in collectiveMode, add a TStepLimiter to every particle
        if(collectiveMode) {
                printf("BLRunManager: adding TStepLimiter processes to all particles\n");
                G4ParticleTable::G4PTblDicIterator *theParticleIterator
                        = G4ParticleTable::GetParticleTable()->GetIterator();
                theParticleIterator->reset();
                while((*theParticleIterator)()) {
                        G4ParticleDefinition *pd = 
                                        theParticleIterator->value();
                        if(pd->IsShortLived()) continue;
                        G4ProcessManager *pmgr = pd->GetProcessManager();
                        if(!pmgr) continue;
                        TStepLimiter *tsl = new TStepLimiter();
                        pmgr->AddProcess(tsl,ordDefault,-1,ordDefault);
                }
                stepTime = DBL_MAX;
        }
}

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(), BLAssert, computeVector, currentTrackIndex, deltaT, BLTrackData::event, BLManager::getNextSecondaryTrackID(), BLManager::getObject(), TStepLimiter::getPrevStatus(), BLManager::getPrimaryTrackID(), IDLE, keepSecondaries, nextSecondaryTrackID, processOneTrack(), rejected, RunInitialization(), RunTermination(), BLManager::setEventID(), BLManager::setEventTimeLimit(), BLManager::setState(), stackManager, stepTime, BLTrackData::track, trackManager, and trackVector.

Referenced by BeamOn().

{
        BLManager *manager = BLManager::getObject();
        G4TransportationManager *transportManager =
                        G4TransportationManager::GetTransportationManager();
        G4StateManager* stateManager = G4StateManager::GetStateManager();
        numberOfEventToBeProcessed = nEvents;

        if(!ConfirmBeamOnCondition()) {
                G4Exception("BLRunManager","Cannot run beam",FatalException,"");
        }
        printf("================== In Collective Mode ==================\n");
        ConstructScoringWorlds();
        RunInitialization();
        G4ApplicationState currentState = stateManager->GetCurrentState();
        if(currentState != G4State_GeomClosed) {
                G4Exception("BLRunManager","Geometry not closed",FatalException,
                                                                        "");
        }

        manager->setState(BEAM);
        stateManager->SetNewState(G4State_EventProc);
        trackManager = 0; // unused in collective mode
        stackManager = eventManager->GetStackManager();
        runAborted = false;

        // the per-event time limit makes no sense in collective mode
        manager->setEventTimeLimit(-1); // infinite

        // event loop to create trackVector
        G4PrimaryTransformer *transformer = new G4PrimaryTransformer();
        G4Navigator* navigator = transportManager->GetNavigatorForTracking();
        stepTime = -DBL_MAX;
        int nev;
        for(nev=0; nev<nEvents; ++nev) {
                currentEvent = GenerateEvent(nev);
                if(!currentEvent || runAborted) break;
                stackManager->PrepareNewEvent();
                manager->BeginOfEventAction(currentEvent);
                G4TrackVector *tv=transformer->GimmePrimaries(currentEvent,0);
                int evId=currentEvent->GetEventID();
                if(evId <= 0) {
                        evId = nev;
                        currentEvent->SetEventID(evId);
                }
                nextSecondaryTrackID = manager->getNextSecondaryTrackID();
                for(unsigned j=0; j<tv->size(); ++j) {
                        G4Track *track = (*tv)[j];
                        BLAssert(j==0); // cannot handle multiple primaries 
                        track->SetTrackID(manager->getPrimaryTrackID());
                        appendTrack(track);
                        G4double t = track->GetGlobalTime();
                        if(t > stepTime) stepTime = t;
                }
                if(tv->size() == 0) delete currentEvent;
                tv->clear();
                if(runAborted) break;
                transportManager->SetNavigatorForTracking(navigator);
                manager->setEventID(evId+1);
        }

        printf("=========== Collective: %d Events, %ld Tracks ==============\n",
                                nev,(long)trackVector.size());

        for(unsigned i=0; i<computeVector.size(); ++i)
                computeVector[i]->beginCollectiveTracking(trackVector);

        // Step loop
        runAborted = false;
        int nActive;
        bool first=true;
        G4double saveStepTime = stepTime;
        std::vector<G4Track*> saveVector;
        do {
                if(runAborted) goto RunAborted;
                nActive = 0;
                rejected = false;
                // note: secondaries can be appended to trackVector during loop
                for(unsigned i=0; i<trackVector.size(); ++i) {
                        if(rejected && !first) break;
                        BLTrackData *td = &trackVector[i];
                        G4Track *track = td->track;
                        G4TrackStatus trackStatus = track->GetTrackStatus();
//printf("Collective Track loop: ev=%d trk=%d status=%d fAlive=%d fSuspend=%d\n",td->event->GetEventID(),track->GetTrackID(),(int)trackStatus, fAlive,fSuspend);
                        if(trackStatus != fAlive && 
                                                trackStatus != fStopButAlive)
                                continue;
                        ++nActive;
                        currentEvent = td->event;
                        manager->setEventID(td->event->GetEventID());
                        currentTrackIndex = i;
                        for(unsigned j=0; j<computeVector.size(); ++j)
                                computeVector[j]->beginTrack(trackVector,i);
                        if(runAborted) goto RunAborted;
                        processOneTrack(track);
                        currentTrackIndex = -1;
                        if(td->event->IsAborted())
                                track->SetTrackStatus(fKillTrackAndSecondaries);
                        if(runAborted) goto RunAborted;
                        trackStatus = track->GetTrackStatus();
                        if(trackStatus == fSuspend)
                                track->SetTrackStatus(TStepLimiter::getPrevStatus());
                        G4TrackVector *tv = trackManager->GimmeSecondaries();
                        if(keepSecondaries && trackStatus != fKillTrackAndSecondaries) {
                                for(unsigned j=0; j<tv->size(); ++j)
                                        appendTrack((*tv)[j]);
                                tv->clear();
                        } else {
                                for(unsigned j=0; j<tv->size(); ++j)
                                        delete (*tv)[j];
                                tv->clear();
                        }
                }
                if(runAborted) goto RunAborted;
                // don't call collectiveStep() if rejected during tracking
                if(!rejected || first) {
                        for(unsigned i=0; i<computeVector.size(); ++i)
                                computeVector[i]->collectiveStep(trackVector);
                }
                if(rejected && !first) {
                        // discard current tracks, and restore saved ones
                        unsigned n=saveVector.size();
                        // first, discard any added secondaries
                        while(trackVector.size() > n) {
                                delete trackVector.back().track;
                                delete trackVector.back().event;
                                trackVector.pop_back();
                        }
                        BLAssert(trackVector.size() == saveVector.size());
                        for(unsigned i=0; i<n; ++i) {
                                delete trackVector[i].track;
                                trackVector[i].track = saveVector[i];
                        }
                        stepTime = saveStepTime;
                } else {
                        // delete saved tracks, and save current ones
                        for(unsigned i=0; i<saveVector.size(); ++i)
                                delete saveVector[i];
                        saveVector.clear();
                        for(unsigned i=0; i<trackVector.size(); ++i)
                                saveVector.push_back(
                                        new G4Track(*trackVector[i].track));
                        saveStepTime = stepTime;
                        stepTime += deltaT;
                }
                first = false;
        } while(nActive > 0);

RunAborted:
        for(unsigned i=0; i<computeVector.size(); ++i)
                computeVector[i]->endCollectiveTracking(trackVector);

        RunTermination();
        manager->setState(IDLE);
}

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(), BLCMDspacechargelw::command(), BLCMDspacecharge::command(), and BLCMDcollective::command().

                { 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.

{ 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.

{ return currentTrackIndex; }

bool BLRunManager::getCollectiveMode

(

)

[inline]

getCollectiveMode() returns true if in collective mode.

References collectiveMode.

Referenced by BLManager::BeginOfEventAction(), BLManager::getExternalParentID(), BLManager::getExternalTrackID(), BLManager::incrEventsProcessed(), BLManager::PostUserTrackingAction(), BLCMDtrace::PostUserTrackingAction(), BLManager::PreUserTrackingAction(), BLCMDtrace::PreUserTrackingAction(), BLManager::trackTuneAndReferenceParticles(), and BLCMDtrace::UserSteppingAction().

{ return collectiveMode; }

void BLRunManager::setCollectiveMode

(

bool

flag = true

)

[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().

References collectiveMode.

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

{ collectiveMode=flag; }

G4double BLRunManager::getStepTime

(

)

[inline]

getStepTime() will get the ste time. NOTE: inside collectiveStep() this function returns the time of the current step; outside collectiveStep() it returns the next step time (i.e. the time at which tracks should be suspended).

References stepTime.

Referenced by Bunch::addFieldValue(), TStepLimiter::AtRestGetPhysicalInteractionLength(), BLCMDcollective::collectiveStep(), Bunch::computeField(), Bunch::init(), TStepLimiter::PostStepGetPhysicalInteractionLength(), and Bunch::resizeGrid().

{ return stepTime; }

void BLRunManager::setStepTime

(

G4double

t

)

[inline]

setStepTime() will set the time for the next step in time. If called from within collectiveStep(), it may confuse other classes collectiveStep()-s. If called from beginCollectiveTracking() it sets the time of the first step.

References stepTime.

{ stepTime = t; }

G4double BLRunManager::getDeltaT

(

)

[inline]

getDeltaT() will get the time interval between time steps

References deltaT.

Referenced by Bunch::addFieldValue(), Bunch::computeField(), and Bunch::resizeGrid().

{ 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 BLAssert, and deltaT.

Referenced by BLCMDspacechargelw::beginCollectiveTracking(), BLCMDspacecharge::beginCollectiveTracking(), BLCMDspacechargelw::command(), BLCMDspacecharge::command(), and BLCMDcollective::command().

                                    { BLAssert(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.

{ 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().

{
        BLManager::getObject()->setState(BEAM);
        ConstructScoringWorlds();
        RunInitialization();
        SetRunIDCounter(runid);
        runAborted = false;
}

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().

{
        RunTermination();
        BLManager::getObject()->setState(IDLE);
}

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().

{
        if(currentEvent) delete currentEvent;
        currentEvent = new G4Event(evid);
        trackManager = eventManager->GetTrackingManager();
        stackManager = eventManager->GetStackManager();
        BLManager::getObject()->BeginOfEventAction(currentEvent);
}

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().

{
        BLManager::getObject()->EndOfEventAction(currentEvent);
        if(currentEvent) delete currentEvent;
        currentEvent = 0;
        trackManager = 0;
        stackManager = 0;
}

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, BLAssert, BLManager::getObject(), BLManager::getPrimaryParentID(), BLManager::getPrimaryTrackID(), BLManager::setState(), and SPECIAL.

{
        static bool more=true;
        static int nev=0;
        static BLManager *manager=0;
        static G4PrimaryTransformer *transformer=0;
        if(!manager) {
                manager = BLManager::getObject();
                transformer = new G4PrimaryTransformer();
        }

        if(!more) return false;

        manager->setState(BEAM);
        currentEvent = GenerateEvent(nev);
        if(!currentEvent || runAborted) {
                more = false;
                return false;
        }
        *pevent = currentEvent;
        G4TrackVector *tv=transformer->GimmePrimaries(currentEvent,0);
        int evId=currentEvent->GetEventID();
        if(evId <= 0) {
                evId = nev;
                currentEvent->SetEventID(evId);
        }
        for(unsigned j=0; j<tv->size(); ++j) {
                G4Track *track = (*tv)[j];
                BLAssert(j==0); // cannot handle multiple primaries 
                track->SetTrackID(manager->getPrimaryTrackID());
                track->SetParentID(manager->getPrimaryParentID());
                *ptrack = track;
        }
        tv->clear();
        if(runAborted) {
                more = false;
                return false;
        }
        ++nev;
        manager->setState(SPECIAL);
        return true;
}

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 BLAssert, stackManager, and trackManager.

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

{
        if(!trackManager || !stackManager) {
                trackManager = eventManager->GetTrackingManager();
                stackManager = eventManager->GetStackManager();
        }
        BLAssert(track != 0);
        trackManager->ProcessOneTrack(track);
}

void BLRunManager::discardAllSecondaries

(

)

discardAllSecondaries() will discard all secondaries.

References trackManager.

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

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().

{
        int n=0;
        G4TrackVector *secondaries = trackManager->GimmeSecondaries();
        for(unsigned j=0; j<secondaries->size(); ++j) {
                G4Track *track = (*secondaries)[j];
                track->SetTrackID(secondaryid++);
                track->SetParentID(parentid); 
                deferOneTrack(track);
                ++n;
        }
        secondaries->clear();

        return n;
}

void BLRunManager::deferOneTrack

(

G4Track *

track

)

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

References stackManager.

Referenced by deferAllSecondaries().

{
        stackManager->PushOneTrack(track);
}

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().

                                                                         {
                int first = secondaryid;
                secondaryid += deferAllSecondaries(secondaryid,parentid);
                secondaryid +=
                       processAllDeferredTracksAndTheirSecondaries(secondaryid);
                return secondaryid-first;
        }

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().

{
        int first=secondaryid;
        for(;;) {
                G4VTrajectory *trajectory=0;
                G4Track *track = stackManager->PopNextTrack(&trajectory);
                if(!track) break;
                processOneTrack(track);
                int parentid = track->GetTrackID();
                delete track;
                secondaryid += deferAllSecondaries(secondaryid,parentid);
        }

        return secondaryid-first;
}

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.

{
        G4TrackVector *secondaries = trackManager->GimmeSecondaries();
        int i = secondaries->size();
        if(i == 0) return 0;
        G4Track *track = secondaries->back();
        secondaries->pop_back();
        return track;
}

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.

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

void BLRunManager::RunInitialization

(

)

[inline]

Referenced by beamOnCollective(), and beginRun().

{ G4RunManager::RunInitialization(); }

void BLRunManager::RunTermination

(

)

[inline]

Referenced by beamOnCollective(), and endRun().

{ G4RunManager::RunTermination(); }

G4EventManager* BLRunManager::getEventManager

(

)

[inline]

Referenced by BLCMDtrackermode::callback().

{ return eventManager; }

G4TrackingManager* BLRunManager::getTrackingManager

(

)

[inline]

References trackManager.

{ return trackManager; }

G4StackManager* BLRunManager::getStackManager

(

)

[inline]

References stackManager.

{ return stackManager; }

void BLRunManager::setCurrentEvent

(

G4Event *

ev

)

[inline]

Referenced by BLCMDtrace::collectiveStep().

{ currentEvent = ev; }

G4bool BLRunManager::getRunAborted

(

)

[inline]

Referenced by BLCMDtrackermode::callback().

{ return runAborted; }

---

Member Data Documentation

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

Referenced by BLRunManager(), and getObject().

G4TrackingManager* BLRunManager::trackManager [private]

Referenced by beamOnCollective(), beginEvent(), BLRunManager(), deferAllSecondaries(), discardAllSecondaries(), endEvent(), getTrackingManager(), popOneSecondary(), and processOneTrack().

G4StackManager* BLRunManager::stackManager [private]

Referenced by beamOnCollective(), beginEvent(), BLRunManager(), deferOneTrack(), endEvent(), getStackManager(), popOneDeferredTrack(), processAllDeferredTracksAndTheirSecondaries(), and processOneTrack().

jmp_buf BLRunManager::jmpBuf [private]

Referenced by abandonCurrentEvent(), and DoEventLoop().

bool BLRunManager::validJmpBuf [private]

Referenced by abandonCurrentEvent(), BLRunManager(), and DoEventLoop().

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

Referenced by appendTrack(), beamOnCollective(), getTrackVector(), and ~BLRunManager().

std::vector<BLCollectiveComputation *> BLRunManager::computeVector [private]

Referenced by beamOnCollective(), registerCollectiveComputation(), and ~BLRunManager().

bool BLRunManager::collectiveMode [private]

Referenced by BeamOn(), BLRunManager(), callback(), getCollectiveMode(), and setCollectiveMode().

bool BLRunManager::keepSecondaries [private]

Referenced by beamOnCollective(), and BLRunManager().

G4double BLRunManager::stepTime [private]

Referenced by beamOnCollective(), BLRunManager(), callback(), getStepTime(), and setStepTime().

G4double BLRunManager::deltaT [private]

Referenced by beamOnCollective(), BLRunManager(), getDeltaT(), and setDeltaT().

G4int BLRunManager::currentTrackIndex [private]

Referenced by beamOnCollective(), BLRunManager(), and getCurrentTrackIndex().

bool BLRunManager::rejected [private]

Referenced by beamOnCollective(), BLRunManager(), and rejectCollectiveStep().

int BLRunManager::nextSecondaryTrackID [private]

Referenced by appendTrack(), beamOnCollective(), and BLRunManager().

---

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

• BLRunManager.hh
• BLRunManager.cc