BLCMDspacechargelw Class Reference

Inheritance diagram for BLCMDspacechargelw:

List of all members.

---

Detailed Description

class BLCMDspacechargelw - Lienard-Wiechert space-charge computation This computation works within the Geant4 tracking framework, and does the computation in the various callbacks.

The algorithm tracks individual particles, and computes their field using macro-particles that are co-located with the tracked particles. So it computes E and B fields from the macro-particles and adds this in to the BLGlobalField, which Geant4 uses for tracking. The field from each macro-particle is computed via Lienard-Wiechert potentials. When necessary, the trajectories of other macro-particles are linearly extrapolated from their current positions (because of the retarded time, this is needed only needed for macro-particles that are close to the particle currently being tracked). To handle particle creation and destruction, each macro-particle has time limits, and does not contribute any field if its trajectory is evaluated outside those limits. The expensive N^2 computation is done in the beginTrack() callback, not in the much more frequently called addElementField().

For a given particle being tracked, this version first evaluates the other MacroParticles' field at its position at the start of the time step; it then linearly extrapolates the particle's trajectory to the next time step, and evaluates the other MacroParticles' field there; addElementField() then interpolates between those values linearly in global time. As the interpolation is linear, it gives a reasonable value even a short time outside the time step.

Public Member Functions
	BLCMDspacechargelw ()
G4String	commandName ()
int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
void	defineNamedArgs ()
void	setStochasticsOff (G4Track *track)
void	restoreStochastics (G4Track *track)
virtual void	beginCollectiveTracking (std::vector< BLTrackData > &v)
virtual void	beginTrack (std::vector< BLTrackData > &v, int _index)
virtual void	collectiveStep (std::vector< BLTrackData > &v)
virtual void	endCollectiveTracking (std::vector< BLTrackData > &v)
virtual void	UserSteppingAction (const G4Step *step)
virtual void	PreUserTrackingAction (const G4Track *track)
virtual void	PostUserTrackingAction (const G4Track *track)
virtual void	addFieldValue (const G4double point[4], G4double field[6]) const
Private Attributes
G4double	deltaT
G4double	radius
G4double	charge
G4int	trackTwice
G4int	verbose
G4int	K
G4int	ignoreFieldWhenTracking
bool	tracking
std::vector< MacroParticle >	mp
int	index
G4double	pos0 [4]
G4double	pos1 [4]
G4double	field0 [6]
G4double	field1 [6]
std::vector< Monitor >	mon
BLNTuple *	ntuple
BLManager *	manager
BLRunManager *	runManager
BLPhysics *	physics
int	nstep
std::vector< int >	restoreList
G4double	rangeCut
Classes
struct	Monitor

---

Constructor & Destructor Documentation

BLCMDspacechargelw::BLCMDspacechargelw

(

)

References BLCMDTYPE_PHYSICS, charge, deltaT, ignoreFieldWhenTracking, index, K, manager, nstep, ntuple, physics, radius, rangeCut, BLCommand::registerCommand(), runManager, BLCommand::setDescription(), BLCommand::setSynopsis(), tracking, trackTwice, and verbose.

                                       : BLCollectiveComputation(), BLManager::SteppingAction(),
                BLManager::TrackingAction(), BLElementField(), mp(), mon(),
                restoreList()
{
        registerCommand(BLCMDTYPE_PHYSICS);
        setSynopsis("Lienard-Wiechert space charge computation");
        setDescription("This is a space charge computation that uses "
                "macro-particles to simulate more particles than is feasible "
                "to track individually. Each macro-particle is tracked as a "
                "single particle, but its charge is multiplied by the "
                "macro-particle charge when computing the field. The radius "
                "of the macro-particle is used to avoid the singularity from "
                "a point charge; outside the radius the macro-particle is "
                "treated as a point charge; inside the radius the point-charge "
                "field is multiplied by (r/radius)^K (radius and K are "
                "parameters).\n\n"
                "The trajectory of every particle is kept, and when computing "
                "the field at a point, the intersection of the point's past "
                "lightcone with the trajectory is used to determine the field "
                "from the macro-particle; there is a loop over all particles "
                "except the one currently being tracked. This computation "
                "scales as N^2, where N is the number of macro-particles; that "
                "makes it computationally infeasible for more than a few "
                "hundred macro-particles. But for the particles used, it is "
                "correct to within the following approximations: a) using "
                "macro-particles, b) linearly interpolating between steps, "
                "c) omitting the radiation term in the L-W potential.\n\n"
                "The fields are computed using eq. 63.8-9 (p 162) of Landau "
                "and Lifshitz, _Classical_Theory_of_Fields_, ignoring the "
                "radiation term. The computed fields are used in the usual "
                "Geant4 tracking. Particle creation and destruction are "
                "handled properly.\n\n"
                "This algorithm is primarily intended to test other space "
                "charge algorithms.");

        // initialize class variables here
        deltaT = -1.0;
        radius = -1.0;
        charge = -1.0;
        trackTwice = 0;
        verbose = -1;
        K = 1;
        ignoreFieldWhenTracking = 0;
        tracking = false;
        index = -1;
        ntuple = 0;
        manager = 0;    // not available yet -- set in command(...)
        runManager = 0; // not available yet -- set in command(...)
        physics = 0;    // not available yet -- set in beginCollectiveTracking
        nstep = 0;
        rangeCut = 0.0;
}

---

Member Function Documentation

G4String BLCMDspacechargelw::commandName

(

)

[inline, virtual]

Implements BLCommand.

{ return "spacechargelw"; }

int BLCMDspacechargelw::command	(	BLArgumentVector &	argv,
		BLArgumentMap &	namedArgs
	)			[virtual]

Implements BLCommand.

References BLGlobalField::addElementField(), charge, deltaT, BLParam::getInt(), BLGlobalField::getObject(), BLRunManager::getObject(), BLManager::getObject(), BLCommand::handleNamedArgs(), manager, Param, BLCommand::print(), BLCommand::printError(), radius, BLRunManager::registerCollectiveComputation(), BLManager::registerSteppingAction(), BLManager::registerTrackingAction(), runManager, BLRunManager::setCollectiveMode(), BLRunManager::setDeltaT(), MacroParticle::testUnits(), MacroParticle::verbose, and verbose.

{
        manager = BLManager::getObject();
        runManager = BLRunManager::getObject();

        handleNamedArgs(namedArgs);

        if(verbose < 0) verbose=Param.getInt("steppingVerbose");
        if(verbose < 0) verbose = 0;
        MacroParticle::verbose = verbose;

        if(radius <= 0.0 || charge <= 0.0 || deltaT <= 0.0)
                printError("spacechargelw: radius, charge, deltaT must all be > 0");

        if(K < 0 || K > 4)
                printError("spacechargelw: K must be one of {0,1,2,3,4}");

        runManager->registerCollectiveComputation(this);
        runManager->setCollectiveMode(true);
        runManager->setDeltaT(deltaT);

        manager->registerSteppingAction(this);
        manager->registerTrackingAction(this);

        BLGlobalField::getObject()->addElementField(this); // infinite bounding
                                                           // box 
        print("");

        MacroParticle::testUnits();

        return 0;
}

void BLCMDspacechargelw::defineNamedArgs

(

)

[virtual]

Reimplemented from BLCommand.

References BLCommand::argDouble(), BLCommand::argInt(), charge, deltaT, ignoreFieldWhenTracking, K, radius, trackTwice, and verbose.

{
        argDouble(deltaT,"deltaT","Time step (ns).",ns);
        argDouble(radius,"radius","Radius of macro-particles (mm).",mm);
        argDouble(charge,"charge","Charge of macro-particles (times particle charge).");
        argInt(trackTwice,"trackTwice","0=linear extrapolation, 1=track (0)");
        argInt(verbose,"verbose","Non-zero for verbose prints (0).");
        argInt(K,"K","Exponent for macro-particle density (1).");
        argInt(ignoreFieldWhenTracking,"ignoreFieldWhenTracking","For testing only (0).");
}       

void BLCMDspacechargelw::setStochasticsOff

(

G4Track *

track

)

References BLPhysics::getRangeCut(), BLPhysics::getStochasticsEnabled(), BLPhysics::isStochasticProcess(), physics, rangeCut, and restoreList.

Referenced by beginTrack().

{
        restoreList.clear();

        if(!physics->getStochasticsEnabled()) return;

        rangeCut = physics->getRangeCut();

        G4UImanager* UI = G4UImanager::GetUIpointer();
        // turn off delta rays (and other particle production) by
        // setting production cut very high in energy by setting
        // the required range very large.
        UI->ApplyCommand("/run/setCut 1 parsec");
        // Turn off enegry-loss straggling
        UI->ApplyCommand("/process/eLoss/fluct false");

        // run through list of processes, disabling stochastic ones
        G4ProcessManager *pm = track->GetDefinition()->GetProcessManager();
        G4ProcessVector *pv=pm->GetProcessList();
        for(int i=0; i<pv->size(); ++i) {
                if(physics->isStochasticProcess((*pv)[i])) {
                        if(pm->GetProcessActivation(i))
                                restoreList.push_back(i);
                        pm->SetProcessActivation(i,false);
                }
        }
}

void BLCMDspacechargelw::restoreStochastics

(

G4Track *

track

)

References BLPhysics::getStochasticsEnabled(), physics, rangeCut, and restoreList.

Referenced by beginTrack().

{
        if(!physics->getStochasticsEnabled()) return;

        G4UImanager* UI = G4UImanager::GetUIpointer();
        static char setCmd[64] = { 0 };
        if(setCmd[0] == '\0') sprintf(setCmd,"/run/setCut %g mm",rangeCut/mm);
        UI->ApplyCommand(setCmd);
        UI->ApplyCommand("/process/eLoss/fluct true");

        // run through list of disabled processes, restoring them
        G4ProcessManager *pm = track->GetDefinition()->GetProcessManager();
        for(unsigned int j=0; j<restoreList.size(); ++j) {
                pm->SetProcessActivation(restoreList[j],true);
        }
}

void BLCMDspacechargelw::beginCollectiveTracking

(

std::vector< BLTrackData > &

v

)

[virtual]

Reimplemented from BLCollectiveComputation.

References charge, BLNTuple::create(), deltaT, FIELDS, BLManager::getPhysics(), K, manager, mon, mp, nstep, ntuple, physics, radius, runManager, BLRunManager::setDeltaT(), verbose, and MacroParticle::verbose.

{
        physics = manager->getPhysics();

        // initialize mp[] and mon[]
        mp.clear();
        mon.clear();
        for(unsigned i=0; i<v.size(); ++i) {
                mp.push_back(MacroParticle(v[i].track,charge,radius,K));
                mon.push_back(Monitor());
        }

        runManager->setDeltaT(deltaT);

        nstep = 0;
        MacroParticle::verbose = verbose;

        ntuple = BLNTuple::create("","NTuples","CollectiveMonitor",FIELDS,"");
}

void BLCMDspacechargelw::beginTrack	(	std::vector< BLTrackData > &	v,
		int	_index
	)			[virtual]

Reimplemented from BLCollectiveComputation.

References BLNTuple::appendRow(), BEAM, BLAssert, charge, deltaT, E, field0, field1, BLManager::getState(), BLManager::getSteppingVerbose(), index, K, manager, mon, mp, nstep, ntuple, pos0, pos1, BLRunManager::processOneTrack(), radius, restoreStochastics(), runManager, BLManager::setState(), setStochasticsOff(), SPECIAL, trackTwice, UNSET, and verbose.

{
        if(manager->getState() != BEAM) return;

        index = _index;
        BLAssert(index >= 0 && (unsigned)index<v.size());

        G4Track *track = v[index].track;
        if(verbose==1 || verbose == 2) 
                printf("spacechargelw::beginTrack(%d)\n",index);

        // if this is a new (secondary) particle, add it to mp[] and mon[]
        if((unsigned)index >= mp.size()) {
                BLAssert((unsigned)index == mp.size());
                mp.push_back(MacroParticle(track,charge,radius,K));
                mp[index].setTmin(track->GetGlobalTime());
                mon.push_back(Monitor());
                if(verbose >= 3)
                        printf("spacechargelw::beginTrack(%d) added to mp[]\n",index);
        }

        // compute field of all other MacroParticle-s at this track's position
        G4ThreeVector p=track->GetPosition();
        pos0[0] = p[0];
        pos0[1] = p[1];
        pos0[2] = p[2];
        pos0[3] = track->GetGlobalTime();
        field0[0]=field0[1]=field0[2]=field0[3]=field0[4]=field0[5]=0.0;
        for(unsigned i=0; i<mp.size(); ++i) {
                if(i == (unsigned)index) continue;
                mp[i].addField(pos0,field0);
        }
        if(verbose >= 3)
                printf("spacechargelw::beginTrack(%4d) pos0:%.3f,%.3f,%.3f,%.3f field0:%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
                        index,pos0[0],pos0[1],pos0[2],pos0[3],
                        field0[0]/tesla,field0[1]/tesla,field0[2]/tesla,
                        field0[3]/(megavolt/meter),field0[4]/(megavolt/meter),
                        field0[5]/(megavolt/meter));

        if(trackTwice) {
                // track with stochastics off, full external field, and
                // constant space charge field (at track's current position).
                int isave = index;
                pos1[0] = pos0[0]; pos1[1] = pos0[1]; pos1[2] = pos0[2];
                pos1[3] = pos0[3] + deltaT; // values for a constant field
                G4Track *temp = new G4Track(*track);
                manager->setState(SPECIAL);
                setStochasticsOff(temp);
                if(manager->getSteppingVerbose() != 0)
                        printf("spacechargelw: pre-tracking begun\n");
                runManager->processOneTrack(temp); // will be suspended
                if(manager->getSteppingVerbose() != 0)
                        printf("spacechargelw: pre-tracking ended\n");
                restoreStochastics(temp);
                manager->setState(BEAM);
                p = temp->GetPosition();
                pos1[0] = p[0];
                pos1[1] = p[1];
                pos1[2] = p[2];
                pos1[3] = temp->GetGlobalTime();
                delete temp;
                index = isave;
                // protect against immediate track death
                if(pos1[3]-pos0[3] < 1.0E-4*ns) pos1[3] += 1.0E-4*ns;
        } else {
                // Linearly extrapolate this track to the next time step.
                p = track->GetMomentumDirection();
                G4double speed = track->GetVelocity();
                pos1[0] = pos0[0] + p[0]*speed*deltaT;
                pos1[1] = pos0[1] + p[1]*speed*deltaT;
                pos1[2] = pos0[2] + p[2]*speed*deltaT;
                pos1[3] = pos0[3] + deltaT;
        }

        // compute field of all other MacroParticle-s at extrapolated position
        // (this can be at a global time beyond the known trajectory of some of 
        //  the other macro-particles; they are linearly extrapolated inside
        //  their addfield()).
        field1[0]=field1[1]=field1[2]=field1[3]=field1[4]=field1[5]=0.0;
        for(unsigned i=0; i<mp.size(); ++i) {
                if(i == (unsigned)index) continue;
                mp[i].addField(pos1,field1);
        }
        if(verbose >= 3)
                printf("                        pos1:%.3f,%.3f,%.3f,%.3f field1:%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
                        pos1[0],pos1[1],pos1[2],pos1[3],
                        field1[0]/tesla,field1[1]/tesla,field1[2]/tesla,
                        field1[3]/(megavolt/meter),field1[4]/(megavolt/meter),
                        field1[5]/(megavolt/meter));

        // monitor the differences
        // (mon[index] contains the previous extrapolated values)
        if(mon[index].pos[0] != UNSET && fabs(pos0[3]-mon[index].pos[3]) < 0.002*ns) {
                G4ThreeVector deltaPos, deltaB, deltaE;
                for(int i=0; i<3; ++i) {
                        deltaPos[i] = pos0[i] - mon[index].pos[i];
                        deltaB[i] = field0[i] - mon[index].field[i];
                        deltaE[i] = field0[i+3] - mon[index].field[i+3];
                }
                if(verbose >= 3)
                    printf("deltaPos=%.6f,%.6f,%.6f deltaB=%.6f,%.6f,%.6f "
                        "deltaE=%.5f,%.6f,%.6f\n",
                        deltaPos[0]/mm,deltaPos[1]/mm,deltaPos[2]/mm,
                        deltaB[0]/tesla,deltaB[1]/tesla,deltaB[2]/tesla,
                        deltaE[0]/(megavolt/meter),deltaE[1]/(megavolt/meter),
                        deltaE[2]/(megavolt/meter));
                double data[11];
                data[0] = pos0[0];      // x
                data[1] = pos0[1];      // y
                data[2] = pos0[2];      // z
                data[3] = pos0[3];      // t
                data[4] = nstep;        // nStep
                data[5] = mon[index].deltaT;    // deltaT
                data[6] = sqrt(field0[0]*field0[0]+field0[1]*field0[1]+
                                        field0[2]*field0[2]); // Btot
                data[7] = sqrt(field0[3]*field0[3]+field0[4]*field0[4]+
                                        field0[5]*field0[5]); // Etot
                data[8] = deltaPos.mag(); // deltaPos
                data[9] = deltaB.mag(); // deltaB
                data[10] = deltaE.mag();        // deltaE
                ntuple->appendRow(data,11);
        }
        // put the new extrapolated values into mon[]
        mon[index] = Monitor(pos1,field1,deltaT);

        // Now that we have done the expensive N^2 computation, BLCMDspacechargelw::addField
        // will interpolate between pos0[] and pos1[] to approximate the field
        // at the trajectory of this particle with the corresponding value on 
        // the linearly-extrapolated trajectory.
}

void BLCMDspacechargelw::collectiveStep

(

std::vector< BLTrackData > &

v

)

[virtual]

Implements BLCollectiveComputation.

References BEAM, BLManager::getState(), manager, and mp.

{
        if(manager->getState() != BEAM) return;

        // TODO: update radius here
        // TODO: update deltaT here

        // prune MacroParticle trajectories
        for(unsigned i=0; i<mp.size(); ++i)
                mp[i].pruneTrajectory();
}

void BLCMDspacechargelw::endCollectiveTracking

(

std::vector< BLTrackData > &

v

)

[virtual]

Reimplemented from BLCollectiveComputation.

{
}

void BLCMDspacechargelw::UserSteppingAction

(

const G4Step *

step

)

[virtual]

Implements BLManager::SteppingAction.

References BEAM, BLAssert, deltaT, BLManager::getState(), index, manager, mp, and verbose.

{
        if(manager->getState() != BEAM) return; // includes SPECIAL

        BLAssert(index>=0 && (unsigned)index<mp.size());

        // add trajectory point unless tiny increment in time
        if(step->GetTrack()->GetGlobalTime()-mp[index].getMostRecentTime() >=
                                                                deltaT/10.0) {
                mp[index].addPoint(step->GetTrack());
                if(verbose >= 3)
                        printf("spacechargelw::UserSteppingAction index=%d point added\n",index);
        } else {
                if(verbose >= 3)
                        printf("spacechargelw::UserSteppingAction index=%d NO POINT - dt too small\n",index);
        }
}

void BLCMDspacechargelw::PreUserTrackingAction

(

const G4Track *

track

)

[virtual]

Implements BLManager::TrackingAction.

References BEAM, BLAssert, BLManager::getState(), index, manager, mp, tracking, and verbose.

{
        if(manager->getState() != BEAM) return;

        if(verbose >= 3)
                printf("spacechargelw::PreUserTrackingAction index=%d\n",index);

        BLAssert(index>=0 && (unsigned)index<mp.size());

        tracking = true;
}

void BLCMDspacechargelw::PostUserTrackingAction

(

const G4Track *

track

)

[virtual]

Implements BLManager::TrackingAction.

References BEAM, BLAssert, deltaT, BLManager::getState(), index, manager, mp, tracking, and verbose.

{
        if(manager->getState() != BEAM) return;

        BLAssert(index>=0 && (unsigned)index<mp.size());

        tracking = false;

        // add this point to the trajectory (no call to UserSteppingAction
        // when track is suspended).
        if(track->GetGlobalTime()-mp[index].getMostRecentTime() > deltaT/100.0)
                mp[index].addPoint(track);

        // set Tmax for tracks that are killed
        G4TrackStatus trackStatus = track->GetTrackStatus();
        if(trackStatus != fAlive && trackStatus != fStopButAlive && trackStatus != fSuspend) {
                mp[index].setTmax(track->GetGlobalTime());
                if(verbose >= 3)
                        printf("spacechargelw::PostUserTrackingAction index=%d track killed\n",index);
        } else {
                if(verbose >= 3)
                        printf("spacechargelw::PostUserTrackingAction index=%d\n",index);
        }

        index = -1;
}

void BLCMDspacechargelw::addFieldValue	(	const G4double	point[4],
		G4double	field[6]
	)			const [virtual]

Implements BLElementField.

References BEAM, BLAssert, field0, field1, BLManager::getState(), ignoreFieldWhenTracking, index, manager, mp, pos0, pos1, tracking, and verbose.

{
        if(manager->getState() != BEAM) return;
        if(ignoreFieldWhenTracking != 0 && tracking) return;

        double fthis[6];
        fthis[0]=fthis[1]=fthis[2]=fthis[3]=fthis[4]=fthis[5]=0.0;

        if(index >= 0) {
                // interpolate field between pos0 and pos1 for this track
                BLAssert(pos1[3]-pos0[3] > 1.0e-8*ns);
                G4double f = (point[3]-pos0[3])/(pos1[3]-pos0[3]);
                fthis[0] = (1.0-f)*field0[0] + f*field1[0];
                fthis[1] = (1.0-f)*field0[1] + f*field1[1];
                fthis[2] = (1.0-f)*field0[2] + f*field1[2];
                fthis[3] = (1.0-f)*field0[3] + f*field1[3];
                fthis[4] = (1.0-f)*field0[4] + f*field1[4];
                fthis[5] = (1.0-f)*field0[5] + f*field1[5];
                if(verbose >= 3)
                        printf("spacechargelw::addFieldValue index=%d f=%.4f point=%.3f,%.3f,%.3f,%.3f\n",
                                index,f,point[0],point[1],point[2],point[3]);
        } else {
                // not during tracking, sum all macro-particles
                for(unsigned i=0; i<mp.size(); ++i) {
                    ((BLCMDspacechargelw*)this)->mp[i].addField(point,fthis);
                }
        }
        if(verbose >= 3)
                printf("spacechargelw::addFieldValue pos:%.3f,%.3f,%.3f,%.3f field:%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
                        point[0],point[1],point[2],point[3],
                        fthis[0]/tesla,fthis[1]/tesla,fthis[2]/tesla,
                        fthis[3]/(megavolt/meter),fthis[4]/(megavolt/meter),
                        fthis[5]/(megavolt/meter));

        field[0] += fthis[0];
        field[1] += fthis[1];
        field[2] += fthis[2];
        field[3] += fthis[3];
        field[4] += fthis[4];
        field[5] += fthis[5];
}

---

Member Data Documentation

G4double BLCMDspacechargelw::deltaT [private]

Referenced by beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), command(), defineNamedArgs(), PostUserTrackingAction(), and UserSteppingAction().

G4double BLCMDspacechargelw::radius [private]

Referenced by beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), command(), and defineNamedArgs().

G4double BLCMDspacechargelw::charge [private]

Referenced by beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), command(), and defineNamedArgs().

G4int BLCMDspacechargelw::trackTwice [private]

Referenced by beginTrack(), BLCMDspacechargelw(), and defineNamedArgs().

G4int BLCMDspacechargelw::verbose [private]

Referenced by addFieldValue(), beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), command(), defineNamedArgs(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

G4int BLCMDspacechargelw::K [private]

Referenced by beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), and defineNamedArgs().

G4int BLCMDspacechargelw::ignoreFieldWhenTracking [private]

Referenced by addFieldValue(), BLCMDspacechargelw(), and defineNamedArgs().

bool BLCMDspacechargelw::tracking [private]

Referenced by addFieldValue(), BLCMDspacechargelw(), PostUserTrackingAction(), and PreUserTrackingAction().

std::vector<MacroParticle> BLCMDspacechargelw::mp [private]

Referenced by addFieldValue(), beginCollectiveTracking(), beginTrack(), collectiveStep(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

int BLCMDspacechargelw::index [private]

Referenced by addFieldValue(), beginTrack(), BLCMDspacechargelw(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

G4double BLCMDspacechargelw::pos0[4] [private]

Referenced by addFieldValue(), and beginTrack().

G4double BLCMDspacechargelw::pos1[4] [private]

Referenced by addFieldValue(), and beginTrack().

G4double BLCMDspacechargelw::field0[6] [private]

Referenced by addFieldValue(), and beginTrack().

G4double BLCMDspacechargelw::field1[6] [private]

Referenced by addFieldValue(), and beginTrack().

std::vector<Monitor> BLCMDspacechargelw::mon [private]

Referenced by beginCollectiveTracking(), and beginTrack().

BLNTuple* BLCMDspacechargelw::ntuple [private]

Referenced by beginCollectiveTracking(), beginTrack(), and BLCMDspacechargelw().

BLManager* BLCMDspacechargelw::manager [private]

Referenced by addFieldValue(), beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), collectiveStep(), command(), PostUserTrackingAction(), PreUserTrackingAction(), and UserSteppingAction().

BLRunManager* BLCMDspacechargelw::runManager [private]

Referenced by beginCollectiveTracking(), beginTrack(), BLCMDspacechargelw(), and command().

BLPhysics* BLCMDspacechargelw::physics [private]

Referenced by beginCollectiveTracking(), BLCMDspacechargelw(), restoreStochastics(), and setStochasticsOff().

int BLCMDspacechargelw::nstep [private]

Referenced by beginCollectiveTracking(), beginTrack(), and BLCMDspacechargelw().

std::vector<int> BLCMDspacechargelw::restoreList [private]

Referenced by restoreStochastics(), and setStochasticsOff().

G4double BLCMDspacechargelw::rangeCut [private]

Referenced by BLCMDspacechargelw(), restoreStochastics(), and setStochasticsOff().

---

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

• BLCMDspacechargelw.cc