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 31 of file ExtEnergyLoss.h.

Constructor & Destructor Documentation

◆ ExtEnergyLoss()

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

explicit

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
}

◆ ~ExtEnergyLoss()

~ExtEnergyLoss ( )

virtual

destructor

Definition at line 30 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 37 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 97 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 73 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 66 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 78 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 59 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 62 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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExtEnergyLoss()

◆ ~ExtEnergyLoss()

Member Function Documentation

◆ AlongStepDoIt()

◆ GetContinuousStepLimit()

◆ GetStepLimit()

◆ IsApplicable()

◆ SetStepLimit()

Member Data Documentation

◆ m_energyLossForExtrapolator

◆ m_StepLimit