BLCMDreweightprocess Class Reference

Inheritance diagram for BLCMDreweightprocess:

List of all members.

---

Detailed Description

class BLCMDreweightprocess will re-weight physics processes.

This command permits the user to artificially increase (or decrease) the cross-section of one or more physics processes applied to one or more particles. This can be used to reduce the variance of a simulation intended to measure a rare process. The track weights are adjusted accordingly.

For example, in a simulation with 1E6 beam particles, essentially none will get through an absorber that is 10 interaction lengths long. To determine how many make it through for a beam of 1E12 particles, the interaction cross-section must be reduced.

Public Member Functions
	BLCMDreweightprocess ()
	Constructor.
virtual G4String	commandName ()
	commandName() returns "reweightprocess".
virtual int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
	command() implements the reweightprocess command.
virtual void	defineNamedArgs ()
	defineNamedArgs() defines the named arguments for this command.
void	callback (int type)
	callback() from BLCallback.
Private Member Functions
bool	isMatchingParticle (G4ParticleDefinition *pd)
bool	isMatchingProcess (const G4VProcess *proc)
bool	wrapProcess (G4ProcessManager *pmgr, G4VProcess *proc)
Private Attributes
G4String	particle
G4String	process
G4double	ratio

---

Constructor & Destructor Documentation

BLCMDreweightprocess::BLCMDreweightprocess

(

)

Constructor.

References BLCMDTYPE_PHYSICS, particle, process, ratio, BLCommand::registerCommand(), BLCommand::setDescription(), and BLCommand::setSynopsis().

Referenced by command().

                                           : BLCommand(), BLCallback()
{
        registerCommand(BLCMDTYPE_PHYSICS);
        setSynopsis("modify the cross-section of a physics process.");
        setDescription("This command will modify the cross-section of a "
                "physics process, modifying the track weights so that "
                "weighted histograms give the same statistical result as if "
                "the command were not used. Used properly, this can greatly "
                "reduce the variance of the result.\n\n"
                "Care should be taken to ensure that all regions that should "
                "be sampled actually are sampled. For instance, if ratio>1 "
                "the interaction length will be reduced, and deep inside an "
                "absorber there may be no sampling because no simulated tracks "
                "ever get there, even though real tracks will. If ratio<1 then "
                "the upstream regions of absorbers will be under sampled; this "
                "is usually OK, as the desired result is to increase the "
                "sampling deep inside the absorber.\n\n"
                "For ratio>>1 this command can be used to examine rare "
                "processes. This can induce multiple rare interactions in an "
                "event when normally none would be expected; the weights will "
                "still correctly correspond to the real interaction, even "
                "though the event topologies don't.\n\n"
                "This command cannot reweight any continuous process (e.g. "
                "multiple scattering, ionization energy loss, etc.) -- it "
                "will issue a fatal exception if applied to such a process.\n\n"
                "This command should not be applied to other processes that "
                "re-weight tracks (e.g. the neutrino command). "
                "Indeed it probably won't give the correct weights if any "
                "such process applies to the particle (except for itself, it "
                "cannot determine the unmodified interaction length of such "
                "procsses, which is needed to compute the weight).\n\n"
                "The re-weighting applies to both PostStep and AtRest "
                "processes, but some AtRest processes do not work with this "
                "re-weighting; for instance, Decay works properly in PostStep "
                "for a moving particle, but not for a stopped one AtRest. "
                "This is related to the Geant4 limitation that exactly one "
                "process be active AtRest, and exactly one step be taken.\n\n"
                "Be sure to test your use of this commnd for a simple physical "
                "situation before believing its results."
        );

        particle = "";
        process = "";
        ratio = 1.0;
}

---

Member Function Documentation

bool BLCMDreweightprocess::isMatchingParticle

(

G4ParticleDefinition *

pd

)

[inline, private]

References BLCommand::matchList(), and particle.

Referenced by callback().

            { return particle.size()==0 || 
                                matchList(pd->GetParticleName(),particle); }

bool BLCMDreweightprocess::isMatchingProcess

(

const G4VProcess *

proc

)

[inline, private]

References BLCommand::matchList(), and process.

Referenced by callback().

            { return matchList(proc->GetProcessName(),process); }

bool BLCMDreweightprocess::wrapProcess	(	G4ProcessManager *	pmgr,
		G4VProcess *	proc
	)			[private]

References ratio.

Referenced by callback().

{
        // cannot re-weight any continuous processes (don't know how to do it)
        if(pmgr->GetAlongStepIndex(proc) >= 0) return false;

        ReweightProcess *rp = new ReweightProcess(pmgr,proc,ratio);

        // fix the positions of all processes
        for(int i=idxAtRest; i<=idxPostStep; ++i) {
                G4ProcessVector *pv = pmgr->GetProcessVector(
                                        (G4ProcessVectorDoItIndex)i,typeDoIt);
                for(int k=1; k<pv->size(); ++k) { // 0 is Transportation
                        pmgr->SetProcessOrdering((*pv)[k],
                                        (G4ProcessVectorDoItIndex)i,k);
                }
        }

        int orderAtRest = pmgr->GetProcessOrdering(proc,idxAtRest);
        int orderAlongStep = ordLast;
        int orderPostStep = pmgr->GetProcessOrdering(proc,idxPostStep);

        pmgr->RemoveProcess(proc);

        pmgr->AddProcess(rp,orderAtRest,orderAlongStep,orderPostStep);

        return true;
}

virtual G4String BLCMDreweightprocess::commandName

(

)

[inline, virtual]

commandName() returns "reweightprocess".

Implements BLCommand.

{ return "reweightprocess"; }

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

command() implements the reweightprocess command.

Implements BLCommand.

References BLCMDreweightprocess(), BLManager::getObject(), BLCommand::handleNamedArgs(), BLCommand::print(), and BLManager::registerCallback().

{
        BLCMDreweightprocess *p = 
                        new BLCMDreweightprocess(defaultBLCMDreweightprocess);

        int retval = p->handleNamedArgs(namedArgs);

        // too early to modify processes here
        BLManager::getObject()->registerCallback(p,0);

        p->print("");

        return retval;
}

void BLCMDreweightprocess::defineNamedArgs

(

)

[virtual]

defineNamedArgs() defines the named arguments for this command.

Reimplemented from BLCommand.

References BLCommand::argDouble(), BLCommand::argString(), particle, process, and ratio.

{
        argString(particle,"particle","Comma-separated list of particle "
                                                "patterns ('' => all).");
        argString(process,"process","Comma-separated list of process patterns.");
        argDouble(ratio,"ratio","Ratio of artificial to real cross-section.");
}

void BLCMDreweightprocess::callback

(

int

type

)

[virtual]

callback() from BLCallback.

Reimplemented from BLCallback.

References BLAssert, BLManager::getObject(), isMatchingParticle(), isMatchingProcess(), BLManager::showAllExceptions(), and wrapProcess().

{
        BLManager *blmanager = BLManager::getObject();
        if(type == 0) {
                // wrap matching processes for matching particles
                G4ParticleTable::G4PTblDicIterator *theParticleIterator =
                        G4ParticleTable::GetParticleTable()->GetIterator();
                theParticleIterator->reset();
                while((*theParticleIterator)()) {
                        G4ParticleDefinition *pd = theParticleIterator->value();
                        if(!isMatchingParticle(pd)) continue;
                        G4ProcessManager *pmgr = pd->GetProcessManager();
                        BLAssert(pmgr != 0);
                        int n=pmgr->GetProcessListLength();
                        G4ProcessVector *pv=pmgr->GetProcessList();
                        for(int i=0; i<n; ++i) {
                            G4VProcess *p=(*pv)[i];
                            if(!isMatchingProcess(p)) continue;
                            char tmp[256];
                            sprintf(tmp,"process=%s particle=%s",
                                                p->GetProcessName().c_str(),
                                                pd->GetParticleName().c_str());
                            if(wrapProcess(pmgr,p))  {
                                bool flag=blmanager->showAllExceptions(true);
                                G4Exception("reweightprocess",
                                                "Process re-weighted",
                                                JustWarning, tmp);
                                blmanager->showAllExceptions(flag);
                            } else {
                                G4Exception("reweightprocess",
                                                "Process cannot be re-weighted",
                                                FatalException, tmp);
                            }
                        }
                }
        }
}

---

Member Data Documentation

G4String BLCMDreweightprocess::particle [private]

Referenced by BLCMDreweightprocess(), defineNamedArgs(), and isMatchingParticle().

G4String BLCMDreweightprocess::process [private]

Referenced by BLCMDreweightprocess(), defineNamedArgs(), and isMatchingProcess().

G4double BLCMDreweightprocess::ratio [private]

Referenced by BLCMDreweightprocess(), defineNamedArgs(), and wrapProcess().

---

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

• BLCMDreweightprocess.cc