ExtEnergyLoss Class Reference

Define physics process to calculate energy loss without fluctuations. More...

#include <ExtEnergyLoss.h>

Inheritance diagram for ExtEnergyLoss:

Public Member Functions
	ExtEnergyLoss (const G4String &processName="ExtEnergyLoss", G4ProcessType aType=fElectromagnetic)
	constructor
virtual	~ExtEnergyLoss ()
	destructor
G4bool	IsApplicable (const G4ParticleDefinition &)
	Reports if this process is applicable to the particle being swum.
G4double	GetContinuousStepLimit (const G4Track &, G4double, G4double, G4double &)
	Gets step limit for the particle being swum.
G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
	Apply energy loss process along the step.
G4double	GetStepLimit ()
	Gets the step limit for this process.
void	SetStepLimit (G4double)
	Sets the step limit for this process.

Private Attributes
EnergyLossForExtrapolator *	m_energyLossForExtrapolator
	Pointer to the geant4e-specific energy-loss and mult-scat class.
G4double	m_StepLimit
	Step limit for this process (fraction of KE that could be lost in one step)

Detailed Description

Define physics process to calculate energy loss without fluctuations.

Definition at line 32 of file ExtEnergyLoss.h.

Constructor & Destructor Documentation

ExtEnergyLoss()

ExtEnergyLoss	(	const G4String &	processName = "ExtEnergyLoss",
		G4ProcessType	aType = fElectromagnetic
	)

constructor

Definition at line 20 of file ExtEnergyLoss.cc.

  : G4VContinuousProcess(processName, type), m_energyLossForExtrapolator(NULL)
{
  B2DEBUG(200, "ExtEnergyLoss is created");
  if (m_energyLossForExtrapolator == NULL) {
    m_energyLossForExtrapolator = new EnergyLossForExtrapolator;
  }
  m_StepLimit = 1.0;  // fraction of kinetic energy that could be lost in one step
  if (false) {
    G4Track aTrack;
    G4Step aStep;
    double dummy;
    AlongStepDoIt(aTrack, aStep);
    GetContinuousStepLimit(aTrack, 0.0, 0.0, dummy);
  }
}

~ExtEnergyLoss()

~ExtEnergyLoss ( )

virtual

destructor

Definition at line 37 of file ExtEnergyLoss.cc.

{
  if (m_energyLossForExtrapolator != NULL) {
    delete m_energyLossForExtrapolator;
  }
}

Member Function Documentation

AlongStepDoIt()

G4VParticleChange * AlongStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

Apply energy loss process along the step.

Definition at line 44 of file ExtEnergyLoss.cc.

{
  aParticleChange.Initialize(aTrack);
 
  G4ErrorPropagatorData* g4edata =  G4ErrorPropagatorData::GetErrorPropagatorData();
 
  G4double kinEnergyStart = aTrack.GetKineticEnergy();
  G4double step_length = aStep.GetStepLength();
 
  const G4Material* aMaterial = aTrack.GetMaterial();
  const G4ParticleDefinition* aParticleDef = aTrack.GetDynamicParticle()->GetDefinition();
  G4double kinEnergyEnd = kinEnergyStart;
 
  if (g4edata->GetMode() == G4ErrorMode(G4ErrorMode_PropBackwards)) {
    kinEnergyEnd = m_energyLossForExtrapolator->EnergyBeforeStep(kinEnergyStart,
                   step_length,
                   aMaterial,
                   aParticleDef);
    G4double kinEnergyHalfStep = (kinEnergyStart + kinEnergyEnd) * 0.5;
 
    B2DEBUG(200, "ExtEnergyLoss::AlongStepDoIt() BWD  end " << kinEnergyEnd << " halfstep " << kinEnergyHalfStep);
 
    // rescale to energy lost at midpoint of step
    kinEnergyEnd = m_energyLossForExtrapolator->EnergyBeforeStep(kinEnergyHalfStep,
                   step_length,
                   aMaterial,
                   aParticleDef);
    kinEnergyEnd = kinEnergyStart - (kinEnergyHalfStep - kinEnergyEnd);
  } else if (g4edata->GetMode() == G4ErrorMode(G4ErrorMode_PropForwards)) {
 
    kinEnergyEnd = m_energyLossForExtrapolator->EnergyAfterStep(kinEnergyStart,
                                                                step_length,
                                                                aMaterial,
                                                                aParticleDef);
    G4double kinEnergyHalfStep = (kinEnergyStart + kinEnergyEnd) * 0.5;
    B2DEBUG(200, "ExtEnergyLoss::AlongStepDoIt() FWD  end " << kinEnergyEnd << " halfstep " << kinEnergyHalfStep);
 
    // rescale to energy lost at midpoint of step
    kinEnergyEnd = m_energyLossForExtrapolator->EnergyAfterStep(kinEnergyHalfStep,
                                                                step_length,
                                                                aMaterial,
                                                                aParticleDef);
    kinEnergyEnd = kinEnergyStart - (kinEnergyHalfStep - kinEnergyEnd);
  }
 
  G4double edepo = kinEnergyEnd - kinEnergyStart;
 
  B2DEBUG(300, "ExtEnergyLoss::AlongStepDoIt() Estart= " << kinEnergyStart << " Eend " << kinEnergyEnd
          << " Ediff " << -edepo << " step= " << step_length << " mate= " << aMaterial->GetName()
          << " particle= " << aParticleDef->GetParticleName());
 
  aParticleChange.ClearDebugFlag();
  aParticleChange.ProposeLocalEnergyDeposit(edepo);
  aParticleChange.SetNumberOfSecondaries(0);
 
  aParticleChange.ProposeEnergy(kinEnergyEnd);
 
  return &aParticleChange;
}

GetContinuousStepLimit()

G4double GetContinuousStepLimit	(	const G4Track &	aTrack,
		G4double	,
		G4double	currentMinimumStep,
		G4double &
	)

Gets step limit for the particle being swum.

Definition at line 104 of file ExtEnergyLoss.cc.

{
  G4double step = DBL_MAX;
  if (m_StepLimit < 1.0) {
    G4double kinEnergyStart = aTrack.GetKineticEnergy();
    G4double kinEnergyLoss = kinEnergyStart;
    const G4Material* aMaterial = aTrack.GetMaterial();
    const G4ParticleDefinition* aParticleDef = aTrack.GetDynamicParticle()->GetDefinition();
    G4ErrorPropagatorData* g4edata =  G4ErrorPropagatorData::GetErrorPropagatorData();
    if (g4edata->GetMode() == G4ErrorMode(G4ErrorMode_PropBackwards)) {
      kinEnergyLoss = - kinEnergyStart +
                      m_energyLossForExtrapolator->EnergyBeforeStep(kinEnergyStart, currentMinimumStep, aMaterial, aParticleDef);
    } else if (g4edata->GetMode() == G4ErrorMode(G4ErrorMode_PropForwards)) {
      kinEnergyLoss = kinEnergyStart -
                      m_energyLossForExtrapolator->EnergyAfterStep(kinEnergyStart, currentMinimumStep, aMaterial, aParticleDef);
    }
    B2DEBUG(300, "ExtEnergyLoss::GetContinuousStepLimit() currentMinimumStep " << currentMinimumStep
            << "  kinEnergyLoss " << kinEnergyLoss << " kinEnergyStart " << kinEnergyStart);
    if (kinEnergyLoss / kinEnergyStart > m_StepLimit) {
      step = m_StepLimit / (kinEnergyLoss / kinEnergyStart)  * currentMinimumStep;
      B2DEBUG(300, "ExtEnergyLoss::GetContinuousStepLimit() limiting Step " << step
              << " energy loss fraction " << kinEnergyLoss / kinEnergyStart << " > " << m_StepLimit);
    }
  }
 
  return step;
 
}

GetStepLimit()

G4double GetStepLimit ( )

inline

Gets the step limit for this process.

Definition at line 74 of file ExtEnergyLoss.h.

    {
      return m_StepLimit;
    }

IsApplicable()

G4bool IsApplicable ( const G4ParticleDefinition &  aParticle )

inline

Reports if this process is applicable to the particle being swum.

Definition at line 67 of file ExtEnergyLoss.h.

    {
      // This process applies to all geant4e-specific charged particles.
      // (Verified that it is only called for these - but let's check anyway.)
      return ((aParticle.GetPDGCharge() != 0) && (aParticle.GetParticleName().compare(0, 4, "g4e_") == 0));
    }

SetStepLimit()

void SetStepLimit ( G4double  val )

inline

Sets the step limit for this process.

Definition at line 79 of file ExtEnergyLoss.h.

    {
      m_StepLimit = val;
    }

Member Data Documentation

m_energyLossForExtrapolator

EnergyLossForExtrapolator* m_energyLossForExtrapolator

private

Pointer to the geant4e-specific energy-loss and mult-scat class.

Definition at line 60 of file ExtEnergyLoss.h.

m_StepLimit

G4double m_StepLimit

private

Step limit for this process (fraction of KE that could be lost in one step)

Definition at line 63 of file ExtEnergyLoss.h.

---

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

• simulation/kernel/include/ExtEnergyLoss.h
• simulation/kernel/src/ExtEnergyLoss.cc