ReweightProcess Class Reference

List of all members.

---

Detailed Description

class ReweightProcess does the re-weighting.

Public Member Functions
	ReweightProcess (G4ProcessManager *_pmgr, G4VProcess *proc, double _ratio)
virtual void	StartTracking (G4Track *track)
virtual void	EndTracking ()
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)
Private Attributes
double	ratio
G4ProcessManager *	pmgr

---

Constructor & Destructor Documentation

ReweightProcess::ReweightProcess	(	G4ProcessManager *	_pmgr,
		G4VProcess *	proc,
		double	_ratio
	)

References pmgr, and ratio.

                                               : G4WrapperProcess(PREFIX)
{
        ratio = _ratio;
        pmgr = _pmgr;
        RegisterProcess(proc);
}

---

Member Function Documentation

virtual void ReweightProcess::StartTracking

(

G4Track *

track

)

[inline, virtual]

                                                   {
                currentInteractionLength = -1.0;
                G4VProcess::ResetNumberOfInteractionLengthLeft();
                pRegProcess->StartTracking(track);
        }

virtual void ReweightProcess::EndTracking

(

)

[inline, virtual]

                                   {
                G4VProcess::ClearNumberOfInteractionLengthLeft();
                currentInteractionLength = -1.0;
                pRegProcess->EndTracking();
        }

G4double ReweightProcess::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)			[virtual]

{
        // original process has no AlongStepGetPhysicalInteractionLength()
        // our AlongStepDoIt() always gets called.
        return DBL_MAX;
}

G4VParticleChange * ReweightProcess::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)			[virtual]

References BLAssert, and pmgr.

{
        G4VParticleChange *pc = &aParticleChange;
        pc->Initialize(track);

        // Re-weight the track because it survived the artificial interaction
        // length. Do it here, because all GPIL routines have been called,
        // but no PostStepDoIt() or AtRestDoIt() have been called. So all
        // processes have computed their currentInteractionLength, and this
        // re-weighting will apply to all discrete processes.
        // Note that only the first ReweightProcess in the list will do the
        // re-weight; others return with no change.
        G4double effectiveIL=0.0, realIL=0.0;
        int n=pmgr->GetProcessListLength();
        G4ProcessVector *pv=pmgr->GetProcessList();
        int nReWeight = 0;
        for(int i=0; i<n; ++i) {
                G4VProcess *p=(*pv)[i];
                G4double currentIL=p->GetCurrentInteractionLength();
                if(currentIL <= 0.0) continue;
                effectiveIL += 1.0/currentIL;
                ReweightProcess *rw = dynamic_cast<ReweightProcess*>(p);
                if(rw != 0) {
                    if(nReWeight++ != 0 && rw == this) return pc;
                    currentIL = rw->pRegProcess->GetCurrentInteractionLength();
                    BLAssert(currentIL > DBL_MIN);
                }
                realIL += 1.0/currentIL;
        }
        effectiveIL = 1.0/effectiveIL;
        realIL = 1.0/realIL;
        G4double stepLength = stepData.GetStepLength();
        G4double factor = exp(stepLength/effectiveIL - stepLength/realIL);
        pc->ProposeParentWeight(track.GetWeight()*factor);

        return pc;
}

G4double ReweightProcess::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)			[virtual]

References ratio.

{
        if(previousStepSize > 0.0) {
                SubtractNumberOfInteractionLengthLeft(previousStepSize);
                if(theNumberOfInteractionLengthLeft < 0.0) {
                        theNumberOfInteractionLengthLeft=perMillion;
                }
        }

        pRegProcess->PostStepGetPhysicalInteractionLength(track,
                                                previousStepSize, condition);
        currentInteractionLength = pRegProcess->GetCurrentInteractionLength();
        if(currentInteractionLength < 0.0)
                G4Exception("reweightprocess","Process cannot be re-weighted",
                        FatalException, pRegProcess->GetProcessName().c_str());
        currentInteractionLength /= ratio;

        G4double value = theNumberOfInteractionLengthLeft *
                                                currentInteractionLength;
        return value;
}

G4VParticleChange * ReweightProcess::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)			[virtual]

References ratio.

{
        G4VParticleChange *pc = pRegProcess->PostStepDoIt(track,stepData);

        // re-weight track
        pc->ProposeParentWeight(track.GetWeight()/ratio);
        // (Geant4 bug requires the following update to the weight, sometimes.)
        stepData.GetPostStepPoint()->SetWeight(track.GetWeight()/ratio);

        // re-weight secondaries
        int n=pc->GetNumberOfSecondaries();
        for(int i=0; i<n; ++i) {
                G4Track *t=pc->GetSecondary(i);
                t->SetWeight(t->GetWeight()/ratio);
        }

        ClearNumberOfInteractionLengthLeft();
        return pc;
}

G4double ReweightProcess::AtRestGetPhysicalInteractionLength	(	const G4Track &	track,
		G4ForceCondition *	condition
	)			[virtual]

References ratio.

{
        G4double value = pRegProcess->
                        AtRestGetPhysicalInteractionLength(track,condition);

        value /= ratio;

        return value;
}

G4VParticleChange * ReweightProcess::AtRestDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)			[virtual]

References ratio.

{
        G4VParticleChange *pc = pRegProcess->AtRestDoIt(track,stepData);

        // re-weight track 
        pc->ProposeParentWeight(track.GetWeight()/ratio);
        // (Geant4 bug requires the following update to the weight, sometimes.)
        stepData.GetPostStepPoint()->SetWeight(track.GetWeight()/ratio);

        // re-weight secondaries
        int n=pc->GetNumberOfSecondaries();
        for(int i=0; i<n; ++i) {
                G4Track *t=pc->GetSecondary(i);
                t->SetWeight(t->GetWeight()/ratio);
        }

        ClearNumberOfInteractionLengthLeft();
        return pc;
}

---

Member Data Documentation

double ReweightProcess::ratio [private]

Referenced by AtRestDoIt(), AtRestGetPhysicalInteractionLength(), PostStepDoIt(), PostStepGetPhysicalInteractionLength(), and ReweightProcess().

G4ProcessManager* ReweightProcess::pmgr [private]

Referenced by AlongStepDoIt(), and ReweightProcess().

---

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

• BLCMDreweightprocess.cc