#include <G4LossTableManager.hh>

Public Member Functions
	~G4LossTableManager ()

void	Clear ()

void	PreparePhysicsTable (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	PreparePhysicsTable (const G4ParticleDefinition aParticle, G4VEmProcess p)

void	PreparePhysicsTable (const G4ParticleDefinition aParticle, G4VMultipleScattering p)

void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)

void	BuildPhysicsTable (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

G4double	GetDEDX (const G4ParticleDefinition aParticle, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetSubDEDX (const G4ParticleDefinition aParticle, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetRange (const G4ParticleDefinition aParticle, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetCSDARange (const G4ParticleDefinition aParticle, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetRangeFromRestricteDEDX (const G4ParticleDefinition aParticle, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetEnergy (const G4ParticleDefinition aParticle, G4double range, const G4MaterialCutsCouple couple)

G4double	GetDEDXDispersion (const G4MaterialCutsCouple couple, const G4DynamicParticle dp, G4double &length)

void	Register (G4VEnergyLossProcess *p)

void	DeRegister (G4VEnergyLossProcess *p)

void	Register (G4VMultipleScattering *p)

void	DeRegister (G4VMultipleScattering *p)

void	Register (G4VEmProcess *p)

void	DeRegister (G4VEmProcess *p)

void	Register (G4VEmModel *p)

void	DeRegister (G4VEmModel *p)

void	Register (G4VEmFluctuationModel *p)

void	DeRegister (G4VEmFluctuationModel *p)

void	RegisterIon (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	RegisterExtraParticle (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	SetLossFluctuations (G4bool val)

void	SetSubCutoff (G4bool val, const G4Region *r=0)

void	SetIntegral (G4bool val)

void	SetRandomStep (G4bool val)

void	SetMinSubRange (G4double val)

void	SetMinEnergy (G4double val)

void	SetMaxEnergy (G4double val)

void	SetMaxEnergyForCSDARange (G4double val)

void	SetMaxEnergyForMuons (G4double val)

void	SetDEDXBinning (G4int val)

void	SetDEDXBinningForCSDARange (G4int val)

void	SetLambdaBinning (G4int val)

G4int	GetNumberOfBinsPerDecade () const

void	SetStepFunction (G4double v1, G4double v2)

void	SetBuildCSDARange (G4bool val)

void	SetLPMFlag (G4bool val)

void	SetSplineFlag (G4bool val)

void	SetLinearLossLimit (G4double val)

void	SetBremsstrahlungTh (G4double val)

void	SetFactorForAngleLimit (G4double val)

void	SetVerbose (G4int val)

G4EnergyLossMessenger *	GetMessenger ()

G4bool	BuildCSDARange () const

G4bool	LPMFlag () const

G4bool	SplineFlag () const

G4double	BremsstrahlungTh () const

G4double	FactorForAngleLimit () const

G4double	MinKinEnergy () const

G4double	MaxKinEnergy () const

const std::vector< G4VEnergyLossProcess * > &	GetEnergyLossProcessVector ()

const std::vector< G4VEmProcess * > &	GetEmProcessVector ()

const std::vector< G4VMultipleScattering * > &	GetMultipleScatteringVector ()

G4VEnergyLossProcess *	GetEnergyLossProcess (const G4ParticleDefinition *)

G4EmCorrections *	EmCorrections ()

G4EmSaturation *	EmSaturation ()

G4EmConfigurator *	EmConfigurator ()

G4ElectronIonPair *	ElectronIonPair ()

G4VAtomDeexcitation *	AtomDeexcitation ()

G4LossTableBuilder *	GetTableBuilder ()

void	SetAtomDeexcitation (G4VAtomDeexcitation *)

Static Public Member Functions
static G4LossTableManager *	Instance ()

Detailed Description

Definition at line 99 of file G4LossTableManager.hh.

Constructor & Destructor Documentation

◆ ~G4LossTableManager()

G4LossTableManager::~G4LossTableManager ( )

Definition at line 118 of file G4LossTableManager.cc.

{
  for (G4int i=0; i<n_loss; ++i) {
    if( loss_vector[i] ) { delete loss_vector[i]; }
  }
  size_t msc = msc_vector.size();
  for (size_t j=0; j<msc; ++j) {
    if( msc_vector[j] ) { delete msc_vector[j]; }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if( emp_vector[k] ) { delete emp_vector[k]; }
  }
  size_t mod = mod_vector.size();
  for (size_t a=0; a<mod; ++a) {
    if( mod_vector[a] ) { delete mod_vector[a]; }
  }
  size_t fmod = fmod_vector.size();
  for (size_t b=0; b<fmod; ++b) {
    if( fmod_vector[b] ) { delete fmod_vector[b]; }
  }
  Clear();
  delete theMessenger;
  delete tableBuilder;
  delete emCorrections;
  delete emSaturation;
  delete emConfigurator;
  delete emElectronIonPair;
  delete atomDeexcitation;
}

Member Function Documentation

◆ AtomDeexcitation()

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation ( )

Definition at line 1106 of file G4LossTableManager.cc.

{
  return atomDeexcitation;
}

◆ BremsstrahlungTh()

G4double G4LossTableManager::BremsstrahlungTh ( ) const

Definition at line 1043 of file G4LossTableManager.cc.

{
  return bremsTh;
}

Referenced by G4eBremsstrahlung::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::PrintInfo().

◆ BuildCSDARange()

G4bool G4LossTableManager::BuildCSDARange ( ) const

Definition at line 762 of file G4LossTableManager.cc.

{
  return buildCSDARange;
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ BuildPhysicsTable() [1/2]

void G4LossTableManager::BuildPhysicsTable ( const G4ParticleDefinition * aParticle )

Definition at line 458 of file G4LossTableManager.cc.

{
  if(0 == run && startInitialisation) {
    emConfigurator->Clear();
  }
}

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), and G4VMultipleScattering::BuildPhysicsTable().

◆ BuildPhysicsTable() [2/2]

void G4LossTableManager::BuildPhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 467 of file G4LossTableManager.cc.

{
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
           << aParticle->GetParticleName()
       << " and process " << p->GetProcessName() << G4endl;
  }
  // clear configurator
  if(0 == run && startInitialisation) {
    emConfigurator->Clear();
    firstParticle = aParticle; 
  }
  if(startInitialisation && atomDeexcitation) {
    atomDeexcitation->InitialiseAtomicDeexcitation();
  }
  startInitialisation = false;
 
  // initialisation before any table is built
  if ( aParticle == firstParticle ) {
    all_tables_are_built = true;
 
    if(1 < verbose) {
      G4cout << "### G4LossTableManager start initilisation for first particle "
         << firstParticle->GetParticleName() 
         << G4endl;
    }
    for (G4int i=0; i<n_loss; ++i) {
      G4VEnergyLossProcess* el = loss_vector[i];
 
      if(el) {
    const G4ProcessManager* pm = el->GetProcessManager();
        isActive[i] = false;
        if(pm) { isActive[i] = pm->GetProcessActivation(el); }
        if(0 == run) { base_part_vector[i] = el->BaseParticle(); }
        tables_are_built[i] = false;
    all_tables_are_built= false;
        if(!isActive[i]) { el->SetIonisation(false); }
  
    if(1 < verbose) { 
      G4cout << i <<".   "<< el->GetProcessName();
          if(el->Particle()) {
        G4cout << "  for "  << el->Particle()->GetParticleName();
      }
      G4cout << "  active= " << isActive[i]
                 << "  table= " << tables_are_built[i]
         << "  isIonisation= " << el->IsIonisationProcess();
      if(base_part_vector[i]) { 
        G4cout << "  base particle " << base_part_vector[i]->GetParticleName();
      }
      G4cout << G4endl;
    }
      } else {
        tables_are_built[i] = true;
        part_vector[i] = 0;
      }
    }
    ++run;
    currentParticle = 0;
  }
 
  // Set run time parameters 
  SetParameters(aParticle, p);
 
  if (all_tables_are_built) { return; }
 
  // Build tables for given particle
  all_tables_are_built = true;
 
  for(G4int i=0; i<n_loss; ++i) {
    if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
      const G4ParticleDefinition* curr_part = part_vector[i];
      if(1 < verbose) {
        G4cout << "### BuildPhysicsTable for " << p->GetProcessName()
               << " and " << curr_part->GetParticleName()
               << " start BuildTable " << G4endl;
      }
      G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
      if(curr_proc) { CopyTables(curr_part, curr_proc); }
    }
    if ( !tables_are_built[i] ) { all_tables_are_built = false; }
  }
 
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildDEDXTable end: "
           << "all_tables_are_built= " << all_tables_are_built
           << G4endl;
    
    if(all_tables_are_built) {
      G4cout << "### All dEdx and Range tables are built #####" << G4endl;
    }
  }
}

◆ Clear()

void G4LossTableManager::Clear ( )

Definition at line 196 of file G4LossTableManager.cc.

{
  all_tables_are_built = false;
  currentLoss = 0;
  currentParticle = 0;
  if(n_loss)
    {
      dedx_vector.clear();
      range_vector.clear();
      inv_range_vector.clear();
      loss_map.clear();
      loss_vector.clear();
      part_vector.clear();
      base_part_vector.clear();
      tables_are_built.clear();
      isActive.clear();
      n_loss = 0;
    }
}

Referenced by ~G4LossTableManager().

◆ DeRegister() [1/5]

void G4LossTableManager::DeRegister ( G4VEmFluctuationModel * p )

Definition at line 345 of file G4LossTableManager.cc.

{
  size_t n = fmod_vector.size();
  for (size_t i=0; i<n; ++i) {
    if(fmod_vector[i] == p) { fmod_vector[i] = 0; }
  }
}

◆ DeRegister() [2/5]

void G4LossTableManager::DeRegister ( G4VEmModel * p )

Definition at line 324 of file G4LossTableManager.cc.

{
  size_t n = mod_vector.size();
  for (size_t i=0; i<n; ++i) {
    if(mod_vector[i] == p) { mod_vector[i] = 0; }
  }
}

◆ DeRegister() [3/5]

void G4LossTableManager::DeRegister ( G4VEmProcess * p )

Definition at line 302 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  size_t emp = emp_vector.size();
  for (size_t i=0; i<emp; ++i) {
    if(emp_vector[i] == p) { emp_vector[i] = 0; }
  }
}

◆ DeRegister() [4/5]

void G4LossTableManager::DeRegister ( G4VEnergyLossProcess * p )

Definition at line 249 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  for (G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i] == p) { loss_vector[i] = 0; }
  }
}

Referenced by G4VEmFluctuationModel::~G4VEmFluctuationModel(), G4VEmModel::~G4VEmModel(), and G4VMultipleScattering::~G4VMultipleScattering().

◆ DeRegister() [5/5]

void G4LossTableManager::DeRegister ( G4VMultipleScattering * p )

Definition at line 275 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  size_t msc = msc_vector.size();
  for (size_t i=0; i<msc; ++i) {
    if(msc_vector[i] == p) { msc_vector[i] = 0; }
  }
}

◆ ElectronIonPair()

G4ElectronIonPair * G4LossTableManager::ElectronIonPair ( )

Definition at line 1099 of file G4LossTableManager.cc.

{
  return emElectronIonPair;
}

◆ EmConfigurator()

G4EmConfigurator * G4LossTableManager::EmConfigurator ( )

Definition at line 1092 of file G4LossTableManager.cc.

{
  return emConfigurator;
}

◆ EmCorrections()

G4EmCorrections * G4LossTableManager::EmCorrections ( )

Definition at line 1078 of file G4LossTableManager.cc.

{
  return emCorrections;
}

Referenced by G4BetheBlochModel::G4BetheBlochModel(), G4BraggModel::G4BraggModel(), G4EmCalculator::G4EmCalculator(), G4ionIonisation::G4ionIonisation(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), and G4BraggIonModel::Initialise().

◆ EmSaturation()

G4EmSaturation * G4LossTableManager::EmSaturation ( )

Definition at line 1085 of file G4LossTableManager.cc.

{
  return emSaturation;
}

Referenced by G4OpticalPhysics::ConstructProcess().

◆ FactorForAngleLimit()

G4double G4LossTableManager::FactorForAngleLimit ( ) const

Definition at line 1057 of file G4LossTableManager.cc.

{
  return factorForAngleLimit;
}

Referenced by G4WentzelOKandVIxSection::Initialise(), G4WentzelVIRelXSection::Initialise(), and G4CoulombScattering::InitialiseProcess().

◆ GetCSDARange()

G4double G4LossTableManager::GetCSDARange	(	const G4ParticleDefinition *	aParticle,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1171 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x = DBL_MAX;
  if(currentLoss) { x = currentLoss->GetCSDARange(kineticEnergy, couple); }
  return x;
}

Referenced by G4EmCalculator::GetCSDARange().

◆ GetDEDX()

G4double G4LossTableManager::GetDEDX	(	const G4ParticleDefinition *	aParticle,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1145 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x = 0.0;
  if(currentLoss) { x = currentLoss->GetDEDX(kineticEnergy, couple); }
  else            { x = G4EnergyLossTables::GetDEDX(currentParticle,
                            kineticEnergy,couple,false); }
  return x;
}

Referenced by G4EnergyLossTables::GetDEDX(), G4EmCalculator::GetDEDX(), G4EnergyLossTables::GetPreciseDEDX(), and G4EnergyLossTables::GetPreciseRangeFromEnergy().

◆ GetDEDXDispersion()

G4double G4LossTableManager::GetDEDXDispersion	(	const G4MaterialCutsCouple *	couple,
		const G4DynamicParticle *	dp,
		G4double &	length
	)

Definition at line 1226 of file G4LossTableManager.cc.

{
  const G4ParticleDefinition* aParticle = dp->GetParticleDefinition();
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x = 0.0;
  if(currentLoss) { currentLoss->GetDEDXDispersion(couple, dp, length); }
  return x;
}

◆ GetEmProcessVector()

const std::vector< G4VEmProcess * > & G4LossTableManager::GetEmProcessVector ( )

Definition at line 992 of file G4LossTableManager.cc.

{
  return emp_vector;
}

Referenced by G4EmProcessOptions::ActivateForcedInteraction(), G4EmProcessOptions::ActivateSecondaryBiasingForGamma(), G4EmProcessOptions::SetApplyCuts(), G4EmProcessOptions::SetPolarAngleLimit(), G4EmProcessOptions::SetProcessBiasingFactor(), and G4EmProcessOptions::SetVerbose().

◆ GetEnergy()

G4double G4LossTableManager::GetEnergy	(	const G4ParticleDefinition *	aParticle,
		G4double	range,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1212 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x;
  if(currentLoss) { x = currentLoss->GetKineticEnergy(range, couple); }
  else { x = G4EnergyLossTables::GetPreciseEnergyFromRange(currentParticle,range,
                               couple,false); }
  return x;
}

Referenced by G4EmCalculator::GetKinEnergy(), and G4EnergyLossTables::GetPreciseEnergyFromRange().

◆ GetEnergyLossProcess()

G4VEnergyLossProcess * G4LossTableManager::GetEnergyLossProcess ( const G4ParticleDefinition * aParticle )

Definition at line 1128 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) {
    currentParticle = aParticle;
    std::map<PD,G4VEnergyLossProcess*,std::less<PD> >::const_iterator pos;
    if ((pos = loss_map.find(aParticle)) != loss_map.end()) {
      currentLoss = (*pos).second;
    } else {
      currentLoss = 0;
      //ParticleHaveNoLoss(aParticle);
    }
  }
  return currentLoss;
}

Referenced by GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetRange(), GetRangeFromRestricteDEDX(), GetSubDEDX(), and G4VMultipleScattering::StartTracking().

◆ GetEnergyLossProcessVector()

const std::vector< G4VEnergyLossProcess * > & G4LossTableManager::GetEnergyLossProcessVector ( )

Definition at line 985 of file G4LossTableManager.cc.

{
  return loss_vector;
}

Referenced by G4EmProcessOptions::ActivateForcedInteraction(), G4EmProcessOptions::ActivateSecondaryBiasing(), G4EmCalculator::ComputeElectronicDEDX(), G4EmProcessOptions::SetLambdaFactor(), G4EmProcessOptions::SetProcessBiasingFactor(), and G4EmProcessOptions::SetVerbose().

◆ GetMessenger()

G4EnergyLossMessenger * G4LossTableManager::GetMessenger ( )

Definition at line 742 of file G4LossTableManager.cc.

{
  return theMessenger;
}

◆ GetMultipleScatteringVector()

const std::vector< G4VMultipleScattering * > & G4LossTableManager::GetMultipleScatteringVector ( )

Definition at line 1000 of file G4LossTableManager.cc.

{
  return msc_vector;
}

Referenced by G4EmProcessOptions::SetMscGeomFactor(), G4EmProcessOptions::SetMscLateralDisplacement(), G4EmProcessOptions::SetMscRangeFactor(), G4EmProcessOptions::SetMscStepLimitation(), G4EmProcessOptions::SetPolarAngleLimit(), G4EmProcessOptions::SetSkin(), and G4EmProcessOptions::SetVerbose().

◆ GetNumberOfBinsPerDecade()

G4int G4LossTableManager::GetNumberOfBinsPerDecade ( ) const

Definition at line 908 of file G4LossTableManager.cc.

{
  return nbinsPerDecade;
}

Referenced by G4LossTableBuilder::BuildTableForModel(), and G4VEmModel::InitialiseElementSelectors().

◆ GetRange()

G4double G4LossTableManager::GetRange	(	const G4ParticleDefinition *	aParticle,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1198 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x;
  if(currentLoss) { x = currentLoss->GetRange(kineticEnergy, couple); }
  else { x = G4EnergyLossTables::GetRange(currentParticle,kineticEnergy,
                      couple,false); }
  return x;
}

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4EnergyLossTables::GetRange(), G4EmCalculator::GetRange(), G4UserSpecialCuts::PostStepGetPhysicalInteractionLength(), and G4EmSaturation::VisibleEnergyDeposition().

◆ GetRangeFromRestricteDEDX()

G4double G4LossTableManager::GetRangeFromRestricteDEDX	(	const G4ParticleDefinition *	aParticle,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1184 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x;
  if(currentLoss) { x = currentLoss->GetRangeForLoss(kineticEnergy, couple); }
  else { x = G4EnergyLossTables::GetRange(currentParticle,kineticEnergy,
                      couple,false); }
  return x;
}

Referenced by G4EmCalculator::GetRangeFromRestricteDEDX().

◆ GetSubDEDX()

G4double G4LossTableManager::GetSubDEDX	(	const G4ParticleDefinition *	aParticle,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 1159 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x = 0.0;
  if(currentLoss) { x = currentLoss->GetDEDXForSubsec(kineticEnergy, couple); }
  return x;
}

◆ GetTableBuilder()

G4LossTableBuilder * G4LossTableManager::GetTableBuilder ( )

Definition at line 1113 of file G4LossTableManager.cc.

{
  return tableBuilder;
}

Referenced by G4VMscModel::GetParticleChangeForMSC(), G4VEmProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ Instance()

G4LossTableManager * G4LossTableManager::Instance ( )

static

Definition at line 107 of file G4LossTableManager.cc.

{
  if(0 == theInstance) {
    static G4LossTableManager manager;
    theInstance = &manager;
  }
  return theInstance;
}

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4RadioactiveDecay::BuildPhysicsTable(), G4LossTableBuilder::BuildTableForModel(), G4EmCalculator::ComputeElectronicDEDX(), G4EmDNAPhysics::ConstructProcess(), G4EmDNAPhysicsChemistry::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4NuclearDecayChannel::DecayIt(), G4BetheBlochModel::G4BetheBlochModel(), G4BraggModel::G4BraggModel(), G4EmCalculator::G4EmCalculator(), G4EmLivermorePhysics::G4EmLivermorePhysics(), G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(), G4EmLowEPPhysics::G4EmLowEPPhysics(), G4EmPenelopePhysics::G4EmPenelopePhysics(), G4EmProcessOptions::G4EmProcessOptions(), G4EmStandardPhysics::G4EmStandardPhysics(), G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(), G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(), G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(), G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(), G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel(), G4ionIonisation::G4ionIonisation(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4QAtomicPhysics::G4QAtomicPhysics(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4UrbanMscModel90::G4UrbanMscModel90(), G4UrbanMscModel92::G4UrbanMscModel92(), G4UrbanMscModel93::G4UrbanMscModel93(), G4UrbanMscModel95::G4UrbanMscModel95(), G4UrbanMscModel96::G4UrbanMscModel96(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMscModel::G4VMscModel(), G4VMultipleScattering::G4VMultipleScattering(), G4WentzelVIModel::G4WentzelVIModel(), G4WentzelVIRelModel::G4WentzelVIRelModel(), G4EnergyLossTables::GetDEDX(), G4EnergyLossTables::GetPreciseDEDX(), G4EnergyLossTables::GetPreciseEnergyFromRange(), G4EnergyLossTables::GetPreciseRangeFromEnergy(), G4EnergyLossTables::GetRange(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4LivermoreComptonModifiedModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4LivermorePolarizedPhotoElectricModel::Initialise(), G4LowEPComptonModel::Initialise(), G4MuElecInelasticModel::Initialise(), G4PenelopeComptonModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4BraggIonModel::Initialise(), G4KleinNishinaModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4DNABornIonisationModel::Initialise(), G4WentzelOKandVIxSection::Initialise(), G4WentzelVIRelXSection::Initialise(), G4VEmModel::InitialiseElementSelectors(), G4hhIonisation::InitialiseEnergyLossProcess(), G4mplIonisation::InitialiseEnergyLossProcess(), G4eBremsstrahlung::InitialiseEnergyLossProcess(), G4CoulombScattering::InitialiseProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4eBremsstrahlung::PrintInfo(), G4VEnergyLossProcess::PrintInfoDefinition(), G4VEmProcess::RetrievePhysicsTable(), G4VEmFluctuationModel::~G4VEmFluctuationModel(), G4VEmModel::~G4VEmModel(), G4VEmProcess::~G4VEmProcess(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ LPMFlag()

G4bool G4LossTableManager::LPMFlag ( ) const

Definition at line 1014 of file G4LossTableManager.cc.

{
  return flagLPM;
}

Referenced by G4eBremsstrahlung::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::PrintInfo().

◆ MaxKinEnergy()

G4double G4LossTableManager::MaxKinEnergy ( ) const

Definition at line 1071 of file G4LossTableManager.cc.

{
  return maxKinEnergy;
}

Referenced by G4VMscModel::GetParticleChangeForMSC(), and G4VMultipleScattering::PreparePhysicsTable().

◆ MinKinEnergy()

G4double G4LossTableManager::MinKinEnergy ( ) const

Definition at line 1064 of file G4LossTableManager.cc.

{
  return minKinEnergy;
}

Referenced by G4VMscModel::GetParticleChangeForMSC().

◆ PreparePhysicsTable() [1/3]

void G4LossTableManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VEmProcess *	p
	)

Definition at line 419 of file G4LossTableManager.cc.

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
 
  // start initialisation for the first run
  if( 0 == run ) {
    emConfigurator->PrepareModels(particle, p);
  }
  startInitialisation = true;
}

◆ PreparePhysicsTable() [2/3]

void G4LossTableManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 390 of file G4LossTableManager.cc.

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << " run= " << run 
       << "   loss_vector " << loss_vector.size() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
 
  // start initialisation for the first run
  startInitialisation = true;
 
  if( 0 == run ) {
    emConfigurator->PrepareModels(particle, p);
 
    // initialise particles for given process
    for (G4int j=0; j<n_loss; ++j) {
      if (p == loss_vector[j]) {
    if (!part_vector[j]) { part_vector[j] = particle; }
      }
    }
  }
}

Referenced by G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

◆ PreparePhysicsTable() [3/3]

void G4LossTableManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VMultipleScattering *	p
	)

Definition at line 439 of file G4LossTableManager.cc.

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
 
  // start initialisation for the first run
  if( 0 == run ) {
    emConfigurator->PrepareModels(particle, p);
  } 
}

◆ Register() [1/5]

void G4LossTableManager::Register ( G4VEmFluctuationModel * p )

Definition at line 334 of file G4LossTableManager.cc.

{
  fmod_vector.push_back(p);
  if(verbose > 1) {
    G4cout << "G4LossTableManager::Register G4VEmFluctuationModel : " 
       << p->GetName() << G4endl;
  }
}

◆ Register() [2/5]

void G4LossTableManager::Register ( G4VEmModel * p )

Definition at line 313 of file G4LossTableManager.cc.

{
  mod_vector.push_back(p);
  if(verbose > 1) {
    G4cout << "G4LossTableManager::Register G4VEmModel : " 
       << p->GetName() << G4endl;
  }
}

◆ Register() [3/5]

void G4LossTableManager::Register ( G4VEmProcess * p )

Definition at line 286 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  G4int n = emp_vector.size();
  for (G4int i=0; i<n; ++i) {
    if(emp_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4LossTableManager::Register G4VEmProcess : " 
       << p->GetProcessName() << "  idx= " << emp_vector.size() << G4endl;
  }
  emp_vector.push_back(p);
}

◆ Register() [4/5]

void G4LossTableManager::Register ( G4VEnergyLossProcess * p )

Definition at line 218 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  for (G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4LossTableManager::Register G4VEnergyLossProcess : " 
       << p->GetProcessName() << "  idx= " << n_loss << G4endl;
  }
  ++n_loss;
  loss_vector.push_back(p);
  part_vector.push_back(0);
  base_part_vector.push_back(0);
  dedx_vector.push_back(0);
  range_vector.push_back(0);
  inv_range_vector.push_back(0);
  tables_are_built.push_back(false);
  isActive.push_back(true);
  all_tables_are_built = false;
  if(!lossFluctuationFlag) { p->SetLossFluctuations(false); }
  if(subCutoffFlag)        { p->ActivateSubCutoff(true); }
  if(rndmStepFlag)         { p->SetRandomStep(true); }
  if(stepFunctionActive)   { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
  if(integralActive)       { p->SetIntegral(integral); }
  if(minEnergyActive)      { p->SetMinKinEnergy(minKinEnergy); }
  if(maxEnergyActive)      { p->SetMaxKinEnergy(maxKinEnergy); }
}

Referenced by G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), and G4VMultipleScattering::G4VMultipleScattering().

◆ Register() [5/5]

void G4LossTableManager::Register ( G4VMultipleScattering * p )

Definition at line 259 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  G4int n = msc_vector.size();
  for (G4int i=0; i<n; ++i) {
    if(msc_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4LossTableManager::Register G4VMultipleScattering : " 
       << p->GetProcessName() << "  idx= " << msc_vector.size() << G4endl;
  }
  msc_vector.push_back(p);
}

◆ RegisterExtraParticle()

void G4LossTableManager::RegisterExtraParticle	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 363 of file G4LossTableManager.cc.

{ 
  if(!p || !part) { return; }
  for (G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4LossTableManager::RegisterExtraParticle "
       << part->GetParticleName() << "  G4VEnergyLossProcess : " 
       << p->GetProcessName() << "  idx= " << n_loss << G4endl;
  }
  ++n_loss;
  loss_vector.push_back(p);
  part_vector.push_back(part);
  base_part_vector.push_back(p->BaseParticle());
  dedx_vector.push_back(0);
  range_vector.push_back(0);
  inv_range_vector.push_back(0);
  tables_are_built.push_back(false);
  all_tables_are_built = false;
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ RegisterIon()

void G4LossTableManager::RegisterIon	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 355 of file G4LossTableManager.cc.

{
  loss_map[ion] = p;
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ SetAtomDeexcitation()

void G4LossTableManager::SetAtomDeexcitation ( G4VAtomDeexcitation * p )

Definition at line 1120 of file G4LossTableManager.cc.

{
  atomDeexcitation = p;
}

◆ SetBremsstrahlungTh()

void G4LossTableManager::SetBremsstrahlungTh ( G4double val )

Definition at line 1036 of file G4LossTableManager.cc.

{
  bremsTh = val;
}

Referenced by G4EmProcessOptions::SetBremsstrahlungTh().

◆ SetBuildCSDARange()

void G4LossTableManager::SetBuildCSDARange ( G4bool val )

Definition at line 960 of file G4LossTableManager.cc.

{
  buildCSDARange = val;
}

Referenced by G4EmProcessOptions::SetBuildCSDARange().

◆ SetDEDXBinning()

void G4LossTableManager::SetDEDXBinning ( G4int val )

Definition at line 871 of file G4LossTableManager.cc.

{
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetDEDXBinning(val); }
  }
}

Referenced by G4EmProcessOptions::SetDEDXBinning().

◆ SetDEDXBinningForCSDARange()

void G4LossTableManager::SetDEDXBinningForCSDARange ( G4int val )

Definition at line 880 of file G4LossTableManager.cc.

{
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetDEDXBinningForCSDARange(val); }
  }
}

Referenced by G4EmProcessOptions::SetDEDXBinningForCSDARange().

◆ SetFactorForAngleLimit()

void G4LossTableManager::SetFactorForAngleLimit ( G4double val )

Definition at line 1050 of file G4LossTableManager.cc.

{
  if(val > 0.0) { factorForAngleLimit = val; }
}

Referenced by G4EmProcessOptions::SetFactorForAngleLimit().

◆ SetIntegral()

void G4LossTableManager::SetIntegral ( G4bool val )

Definition at line 789 of file G4LossTableManager.cc.

{
  integral = val;
  integralActive = true;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetIntegral(val); }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetIntegral(val); }
  }
}

Referenced by G4EmProcessOptions::SetIntegral().

◆ SetLambdaBinning()

void G4LossTableManager::SetLambdaBinning ( G4int val )

Definition at line 889 of file G4LossTableManager.cc.

{
  G4int n = val/G4int(std::log10(maxKinEnergy/minKinEnergy) + 0.5);
  if(n < 5) {
    G4cout << "G4LossTableManager::SetLambdaBinning WARNING "
       << "too small number of bins " << val << "  ignored" 
       << G4endl;
    return;
  } 
  nbinsLambda = val;
  nbinsPerDecade = n;
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetLambdaBinning(val); }
  }
}

Referenced by G4EmProcessOptions::SetLambdaBinning().

◆ SetLinearLossLimit()

void G4LossTableManager::SetLinearLossLimit ( G4double val )

Definition at line 951 of file G4LossTableManager.cc.

{
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetLinearLossLimit(val); }
  }
}

Referenced by G4EmProcessOptions::SetLinearLossLimit().

◆ SetLossFluctuations()

void G4LossTableManager::SetLossFluctuations ( G4bool val )

Definition at line 769 of file G4LossTableManager.cc.

{
  lossFluctuationFlag = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetLossFluctuations(val); }
  }
}

Referenced by G4EmProcessOptions::SetLossFluctuations().

◆ SetLPMFlag()

void G4LossTableManager::SetLPMFlag ( G4bool val )

Definition at line 1007 of file G4LossTableManager.cc.

{
  flagLPM = val;
}

Referenced by G4EmProcessOptions::SetLPMFlag().

◆ SetMaxEnergy()

void G4LossTableManager::SetMaxEnergy ( G4double val )

Definition at line 839 of file G4LossTableManager.cc.

{
  maxEnergyActive = true;
  maxKinEnergy = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergy(val); }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetMaxKinEnergy(val); }
  }
}

Referenced by G4EmProcessOptions::SetMaxEnergy().

◆ SetMaxEnergyForCSDARange()

void G4LossTableManager::SetMaxEnergyForCSDARange ( G4double val )

Definition at line 854 of file G4LossTableManager.cc.

{
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergyForCSDARange(val); }
  }
}

Referenced by G4EmProcessOptions::SetMaxEnergyForCSDARange().

◆ SetMaxEnergyForMuons()

void G4LossTableManager::SetMaxEnergyForMuons ( G4double val )

Definition at line 863 of file G4LossTableManager.cc.

{
  maxEnergyForMuonsActive = true;
  maxKinEnergyForMuons = val;
}

Referenced by G4EmProcessOptions::SetMaxEnergyForMuons().

◆ SetMinEnergy()

void G4LossTableManager::SetMinEnergy ( G4double val )

Definition at line 824 of file G4LossTableManager.cc.

{
  minEnergyActive = true;
  minKinEnergy = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetMinKinEnergy(val); }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetMinKinEnergy(val); }
  }
}

Referenced by G4EmProcessOptions::SetMinEnergy().

◆ SetMinSubRange()

void G4LossTableManager::SetMinSubRange ( G4double val )

Definition at line 804 of file G4LossTableManager.cc.

{
  minSubRange = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetMinSubRange(val); }
  }
}

Referenced by G4EmProcessOptions::SetMinSubRange().

◆ SetRandomStep()

void G4LossTableManager::SetRandomStep ( G4bool val )

Definition at line 814 of file G4LossTableManager.cc.

{
  rndmStepFlag = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetRandomStep(val); }
  }
}

Referenced by G4EmProcessOptions::SetRandomStep().

◆ SetSplineFlag()

void G4LossTableManager::SetSplineFlag ( G4bool val )

Definition at line 1021 of file G4LossTableManager.cc.

{
  splineFlag = val;
  tableBuilder->SetSplineFlag(splineFlag);
}

Referenced by G4EmProcessOptions::SetSplineFlag().

◆ SetStepFunction()

void G4LossTableManager::SetStepFunction	(	G4double	v1,
		G4double	v2
	)

Definition at line 939 of file G4LossTableManager.cc.

{
  stepFunctionActive = true;
  maxRangeVariation = v1;
  maxFinalStep = v2;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
  }
}

Referenced by G4EmProcessOptions::SetStepFunction().

◆ SetSubCutoff()

void G4LossTableManager::SetSubCutoff	(	G4bool	val,
		const G4Region *	r = `0`
	)

Definition at line 779 of file G4LossTableManager.cc.

{
  subCutoffFlag = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->ActivateSubCutoff(val, r); }
  }
}

Referenced by G4EmProcessOptions::SetSubCutoff().

◆ SetVerbose()

void G4LossTableManager::SetVerbose ( G4int val )

Definition at line 915 of file G4LossTableManager.cc.

{
  verbose = val;
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetVerboseLevel(val); }
  }
  size_t msc = msc_vector.size();
  for (size_t j=0; j<msc; ++j) {
    if(msc_vector[j]) { msc_vector[j]->SetVerboseLevel(val); }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetVerboseLevel(val); }
  }
  emConfigurator->SetVerbose(val);
  //tableBuilder->SetVerbose(val);
  //emCorrections->SetVerbose(val);
  emSaturation->SetVerbose(val);
  emElectronIonPair->SetVerbose(val);
  if(atomDeexcitation) { atomDeexcitation->SetVerboseLevel(val); }
}

Referenced by G4EmProcessOptions::SetVerbose().

◆ SplineFlag()

G4bool G4LossTableManager::SplineFlag ( ) const

Definition at line 1029 of file G4LossTableManager.cc.

{
  return splineFlag;
}

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~G4LossTableManager()

Member Function Documentation

◆ AtomDeexcitation()

◆ BremsstrahlungTh()

◆ BuildCSDARange()

◆ BuildPhysicsTable() [1/2]

◆ BuildPhysicsTable() [2/2]

◆ Clear()

◆ DeRegister() [1/5]

◆ DeRegister() [2/5]

◆ DeRegister() [3/5]

◆ DeRegister() [4/5]

◆ DeRegister() [5/5]

◆ ElectronIonPair()

◆ EmConfigurator()

◆ EmCorrections()

◆ EmSaturation()

◆ FactorForAngleLimit()

◆ GetCSDARange()

◆ GetDEDX()

◆ GetDEDXDispersion()

◆ GetEmProcessVector()

◆ GetEnergy()

◆ GetEnergyLossProcess()

◆ GetEnergyLossProcessVector()

◆ GetMessenger()

◆ GetMultipleScatteringVector()

◆ GetNumberOfBinsPerDecade()

◆ GetRange()

◆ GetRangeFromRestricteDEDX()

◆ GetSubDEDX()

◆ GetTableBuilder()

◆ Instance()

◆ LPMFlag()

◆ MaxKinEnergy()

◆ MinKinEnergy()

◆ PreparePhysicsTable() [1/3]

◆ PreparePhysicsTable() [2/3]

◆ PreparePhysicsTable() [3/3]

◆ Register() [1/5]

◆ Register() [2/5]

◆ Register() [3/5]

◆ Register() [4/5]

◆ Register() [5/5]

◆ RegisterExtraParticle()

◆ RegisterIon()

◆ SetAtomDeexcitation()

◆ SetBremsstrahlungTh()

◆ SetBuildCSDARange()

◆ SetDEDXBinning()

◆ SetDEDXBinningForCSDARange()

◆ SetFactorForAngleLimit()

◆ SetIntegral()

◆ SetLambdaBinning()

◆ SetLinearLossLimit()

◆ SetLossFluctuations()

◆ SetLPMFlag()

◆ SetMaxEnergy()

◆ SetMaxEnergyForCSDARange()

◆ SetMaxEnergyForMuons()

◆ SetMinEnergy()

◆ SetMinSubRange()

◆ SetRandomStep()

◆ SetSplineFlag()

◆ SetStepFunction()

◆ SetSubCutoff()

◆ SetVerbose()

◆ SplineFlag()