G4LossTableManager Class Reference

#include <G4LossTableManager.hh>

Public Member Functions
	~G4LossTableManager ()
void	Clear ()
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p, G4bool theMaster)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEmProcess *p, G4bool theMaster)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VMultipleScattering *p, G4bool theMaster)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	LocalPhysicsTables (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	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
G4bool	IsMaster () 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 ()

Friends
class	G4ThreadLocalSingleton< G4LossTableManager >

Detailed Description

Definition at line 100 of file G4LossTableManager.hh.

Constructor & Destructor Documentation

G4LossTableManager::~G4LossTableManager

(

)

Definition at line 126 of file G4LossTableManager.cc.

References test::a, test::b, and Clear().

{
  //G4cout << "### G4LossTableManager::~G4LossTableManager()" << G4endl;
  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();
  size_t fmod = fmod_vector.size();
  for (size_t a=0; a<mod; ++a) {
    if( mod_vector[a] ) { 
      for (size_t b=0; b<fmod; ++b) {
    if((G4VEmModel*)(fmod_vector[b]) == mod_vector[a]) {
      fmod_vector[b] = 0;
    }
      }
      delete mod_vector[a]; 
    }
  }
  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

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation

(

)

Definition at line 1300 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4RadioactiveDecay::BuildPhysicsTable(), G4EmCalculator::ComputeShellIonisationCrossSectionPerAtom(), G4NuclearDecayChannel::DecayIt(), G4EmCalculator::GetShellIonisationCrossSectionPerAtom(), G4LivermorePolarizedPhotoElectricModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4LivermoreComptonModifiedModel::Initialise(), G4DNABornIonisationModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4KleinNishinaModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeComptonModel::Initialise(), G4MuElecInelasticModel::Initialise(), G4MicroElecInelasticModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4LowEPComptonModel::Initialise(), and G4VEmProcess::PreparePhysicsTable().

{
  return atomDeexcitation;
}

G4double G4LossTableManager::BremsstrahlungTh

(

)

const

Definition at line 1237 of file G4LossTableManager.cc.

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

{
  return bremsTh;
}

G4bool G4LossTableManager::BuildCSDARange

(

)

const

Definition at line 947 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4VEnergyLossProcess::PreparePhysicsTable().

{
  return buildCSDARange;
}

void G4LossTableManager::BuildPhysicsTable

(

const G4ParticleDefinition *

aParticle

)

Definition at line 504 of file G4LossTableManager.cc.

References G4EmConfigurator::Clear().

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

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

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

Definition at line 603 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::BaseParticle(), G4EmConfigurator::Clear(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4VEnergyLossProcess::IsIonisationProcess(), G4VEnergyLossProcess::Particle(), and G4VEnergyLossProcess::SetIonisation().

{
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildPhysicsTable() for "
           << aParticle->GetParticleName()
       << " and process " << p->GetProcessName() << G4endl;
  }
  // clear configurator
  if(-1 == run && startInitialisation) {
    emConfigurator->Clear();
    firstParticle = aParticle; 
  }
  if(startInitialisation) {
    ++run;
    if(1 < verbose) {
      G4cout << "===== G4LossTableManager::BuildPhysicsTable() for run "
         << run << " =====" << G4endl;
    }
    if(atomDeexcitation) {
      atomDeexcitation->InitialiseAtomicDeexcitation();
    }
    currentParticle = 0;
    all_tables_are_built= true;
  }

  // initialisation before any table is built
  if ( startInitialisation && aParticle == firstParticle ) {

    startInitialisation = false;
    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) {
        isActive[i] = true;
    /*
    const G4ProcessManager* pm = el->GetProcessManager();
        isActive[i] = false;
        if(pm) { isActive[i] = pm->GetProcessActivation(el); }
    */
        base_part_vector[i] = el->BaseParticle(); 
        tables_are_built[i] = false;
    all_tables_are_built= false;
        if(!isActive[i]) { 
      el->SetIonisation(false); 
      tables_are_built[i] = true;
    }
  
    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;
    isActive[i] = false;
      }
    }
  }

  // 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 << "### Build Table for " << p->GetProcessName()
               << " and " << curr_part->GetParticleName() << 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(0 == run && p->IsIonisationProcess()) { loss_map[aParticle] = p; }

  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildPhysicsTable end: "
           << "all_tables_are_built= " << all_tables_are_built
           << G4endl;
  }
  if(all_tables_are_built) { 
    if(1 < verbose) {
      G4cout << "%%%%% All dEdx and Range tables are built for master run= " 
         << run << " %%%%%" << G4endl;
    }
  }
}

void G4LossTableManager::Clear

(

)

Definition at line 218 of file G4LossTableManager.cc.

Referenced by ~G4LossTableManager().

{
  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;
    }
}

void G4LossTableManager::DeRegister

(

G4VEnergyLossProcess *

p

)

Definition at line 272 of file G4LossTableManager.cc.

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

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

void G4LossTableManager::DeRegister

(

G4VMultipleScattering *

p

)

Definition at line 298 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; }
  }
}

void G4LossTableManager::DeRegister

(

G4VEmProcess *

p

)

Definition at line 325 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; }
  }
}

void G4LossTableManager::DeRegister

(

G4VEmModel *

p

)

Definition at line 347 of file G4LossTableManager.cc.

References n.

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

void G4LossTableManager::DeRegister

(

G4VEmFluctuationModel *

p

)

Definition at line 368 of file G4LossTableManager.cc.

References n.

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

G4ElectronIonPair * G4LossTableManager::ElectronIonPair

(

)

Definition at line 1293 of file G4LossTableManager.cc.

{
  return emElectronIonPair;
}

G4EmConfigurator * G4LossTableManager::EmConfigurator

(

)

Definition at line 1286 of file G4LossTableManager.cc.

{
  return emConfigurator;
}

G4EmCorrections * G4LossTableManager::EmCorrections

(

)

Definition at line 1272 of file G4LossTableManager.cc.

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

{
  return emCorrections;
}

G4EmSaturation * G4LossTableManager::EmSaturation

(

)

Definition at line 1279 of file G4LossTableManager.cc.

Referenced by OpNovicePhysicsList::ConstructOp(), WLSOpticalPhysics::ConstructProcess(), and G4OpticalPhysics::ConstructProcess().

{
  return emSaturation;
}

G4double G4LossTableManager::FactorForAngleLimit

(

)

const

Definition at line 1251 of file G4LossTableManager.cc.

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

{
  return factorForAngleLimit;
}

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

Definition at line 1367 of file G4LossTableManager.cc.

References DBL_MAX, G4VEnergyLossProcess::GetCSDARange(), GetEnergyLossProcess(), and test::x.

Referenced by G4EmCalculator::GetCSDARange().

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

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

Definition at line 1343 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::GetDEDX(), GetEnergyLossProcess(), and test::x.

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

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

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

Definition at line 1416 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::GetDEDXDispersion(), GetEnergyLossProcess(), G4DynamicParticle::GetParticleDefinition(), and test::x.

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

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

(

)

Definition at line 1179 of file G4LossTableManager.cc.

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

{
  return emp_vector;
}

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

Definition at line 1404 of file G4LossTableManager.cc.

References GetEnergyLossProcess(), G4VEnergyLossProcess::GetKineticEnergy(), and test::x.

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

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  G4double x = 0;
  if(currentLoss) { x = currentLoss->GetKineticEnergy(range, couple); }
  return x;
}

G4VEnergyLossProcess * G4LossTableManager::GetEnergyLossProcess

(

const G4ParticleDefinition *

aParticle

)

Definition at line 1322 of file G4LossTableManager.cc.

References G4ParticleDefinition::GetParticleType().

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

{
  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;
      if(aParticle->GetParticleType() == "nucleus") {
    if ((pos = loss_map.find(theGenericIon)) != loss_map.end()) {
      currentLoss = (*pos).second;
    }
      }
    }
  }
  return currentLoss;
}

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

(

)

Definition at line 1172 of file G4LossTableManager.cc.

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

{
  return loss_vector;
}

G4EnergyLossMessenger * G4LossTableManager::GetMessenger

(

)

Definition at line 927 of file G4LossTableManager.cc.

{
  return theMessenger;
}

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

(

)

Definition at line 1187 of file G4LossTableManager.cc.

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

{
  return msc_vector;
}

G4int G4LossTableManager::GetNumberOfBinsPerDecade

(

)

const

Definition at line 1093 of file G4LossTableManager.cc.

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

{
  return nbinsPerDecade;
}

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

Definition at line 1392 of file G4LossTableManager.cc.

References DBL_MAX, GetEnergyLossProcess(), G4VEnergyLossProcess::GetRange(), and test::x.

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

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

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

Definition at line 1379 of file G4LossTableManager.cc.

References DBL_MAX, GetEnergyLossProcess(), G4VEnergyLossProcess::GetRangeForLoss(), and test::x.

Referenced by G4EmCalculator::GetRangeFromRestricteDEDX().

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

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

Definition at line 1355 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::GetDEDXForSubsec(), GetEnergyLossProcess(), and test::x.

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

G4LossTableBuilder * G4LossTableManager::GetTableBuilder

(

)

Definition at line 1307 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMscModel::GetParticleChangeForMSC(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetLambdaTable().

{
  return tableBuilder;
}

G4LossTableManager * G4LossTableManager::Instance ( void  )

static

Definition at line 112 of file G4LossTableManager.cc.

References G4ThreadLocalSingleton< T >::Instance().

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4VMultipleScattering::BuildPhysicsTable(), G4RadioactiveDecay::BuildPhysicsTable(), G4LossTableBuilder::BuildTableForModel(), G4EmCalculator::ComputeElectronicDEDX(), OpNovicePhysicsList::ConstructOp(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), PhysListEmStandardNR::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4NuclearDecayChannel::DecayIt(), export_G4LossTableManager(), exrdmPhysicsList::exrdmPhysicsList(), F04PhysicsList::F04PhysicsList(), 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(), G4EmUserPhysics::G4EmUserPhysics(), G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel(), G4ionIonisation::G4ionIonisation(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4UrbanMscModel::G4UrbanMscModel(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMscModel::G4VMscModel(), G4VMultipleScattering::G4VMultipleScattering(), G4WentzelVIModel::G4WentzelVIModel(), G4WentzelVIRelModel::G4WentzelVIRelModel(), GammaKnifePhysicsList::GammaKnifePhysicsList(), G4EmCalculator::GetCSDARange(), G4EnergyLossTables::GetDEDX(), G4EnergyLossTables::GetPreciseDEDX(), G4EnergyLossTables::GetPreciseEnergyFromRange(), G4EnergyLossTables::GetPreciseRangeFromEnergy(), PhysicsList::GetRange(), G4EnergyLossTables::GetRange(), HadrontherapyPhysicsList::HadrontherapyPhysicsList(), G4LivermorePolarizedPhotoElectricModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4DNABornIonisationModel::Initialise(), G4LivermoreComptonModifiedModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4KleinNishinaModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeComptonModel::Initialise(), G4MuElecInelasticModel::Initialise(), G4MicroElecInelasticModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4BraggIonModel::Initialise(), G4WentzelOKandVIxSection::Initialise(), G4WentzelVIRelXSection::Initialise(), G4LowEPComptonModel::Initialise(), G4mplIonisation::InitialiseEnergyLossProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eBremsstrahlung::InitialiseEnergyLossProcess(), G4CoulombScattering::InitialiseProcess(), IORTPhysicsList::IORTPhysicsList(), ML2PhysicsList::ML2PhysicsList(), PhysicsList::PhysicsList(), PhysListEmStandardNR::PhysListEmStandardNR(), DMXMinEkineCuts::PostStepGetPhysicalInteractionLength(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), RunAction::PrintDedxTables(), G4eBremsstrahlung::PrintInfo(), WLSPhysicsList::WLSPhysicsList(), and XrayFluoPhysicsList::XrayFluoPhysicsList().

{
  /*
  if(!theInstance) {
    theInstance = new G4LossTableManager;
  }
  return theInstance;
  */
  static G4ThreadLocalSingleton<G4LossTableManager> instance;
  return instance.Instance();
}

G4bool G4LossTableManager::IsMaster

(

)

const

Definition at line 1223 of file G4LossTableManager.cc.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), and G4VEmProcess::~G4VEmProcess().

{
  return isMaster;
}

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

Definition at line 513 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::BaseParticle(), G4EmConfigurator::Clear(), G4VEnergyLossProcess::DEDXTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4VEnergyLossProcess::InverseRangeTable(), G4VEnergyLossProcess::IsIonisationProcess(), G4VEnergyLossProcess::Particle(), G4VEnergyLossProcess::RangeTableForLoss(), and SetVerbose().

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

{
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::SlavePhysicsTable() for "
       << aParticle->GetParticleName()
       << " and process " << p->GetProcessName()
       << G4endl;
  }

  if(-1 == run && startInitialisation) {
    emConfigurator->Clear();
    firstParticle = aParticle; 
  }

  if(startInitialisation) {
    ++run;
    SetVerbose(verbose);
    if(1 < verbose) {
      G4cout << "===== G4LossTableManager::SlavePhysicsTable() for run "
         << run << " =====" << G4endl;
    }
    if(atomDeexcitation) {
      atomDeexcitation->InitialiseAtomicDeexcitation();
    }
    currentParticle = 0;
    startInitialisation = false;
    for (G4int i=0; i<n_loss; ++i) {
      if(loss_vector[i]) {
    tables_are_built[i] = false;
      } else {
    tables_are_built[i] = true;
        part_vector[i] = 0;
      }
    }
  }

  all_tables_are_built= true;
  for (G4int i=0; i<n_loss; ++i) {
    if(p == loss_vector[i]) {
      tables_are_built[i] = true;
      isActive[i] = true;
      /*
      const G4ProcessManager* pm = p->GetProcessManager();
      isActive[i] = false;
      if(pm) { isActive[i] = pm->GetProcessActivation(p); }
      */
      part_vector[i] = p->Particle(); 
      base_part_vector[i] = p->BaseParticle(); 
      dedx_vector[i] = p->DEDXTable();
      range_vector[i] = p->RangeTableForLoss();
      inv_range_vector[i] = p->InverseRangeTable();
      if(0 == run && p->IsIonisationProcess()) {
    loss_map[part_vector[i]] = loss_vector[i];
      }

      if(1 < verbose) { 
    G4cout << i <<".   "<< p->GetProcessName(); 
    if(part_vector[i]) {
      G4cout << "  for "  << part_vector[i]->GetParticleName();
    }
    G4cout << "  active= " << isActive[i]
           << "  table= " << tables_are_built[i]
           << "  isIonisation= " << p->IsIonisationProcess()
           << G4endl;
      }
      break;
    } else if(!tables_are_built[i]) {
      all_tables_are_built = false;
    }
  }

  // Set run time parameters 
  SetParameters(aParticle, p);

  if(1 < verbose) {
    G4cout << "### G4LossTableManager::SlavePhysicsTable end"
       << G4endl;
  }
  if(all_tables_are_built) { 
    if(1 < verbose) {
      G4cout << "%%%%% All dEdx and Range tables for worker are ready for run "
         << run << " %%%%%" << G4endl;
    }
  }
}

G4bool G4LossTableManager::LPMFlag

(

)

const

Definition at line 1201 of file G4LossTableManager.cc.

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

{
  return flagLPM;
}

G4double G4LossTableManager::MaxKinEnergy

(

)

const

Definition at line 1265 of file G4LossTableManager.cc.

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

{
  return maxKinEnergy;
}

G4double G4LossTableManager::MinKinEnergy

(

)

const

Definition at line 1258 of file G4LossTableManager.cc.

Referenced by G4VMscModel::GetParticleChangeForMSC().

{
  return minKinEnergy;
}

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

Definition at line 405 of file G4LossTableManager.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4EmConfigurator::PrepareModels(), and G4LossTableBuilder::SetInitialisationFlag().

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

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << " run= " << run 
       << "   loss_vector " << loss_vector.size() << G4endl;
  }

  isMaster = theMaster;

  if(!startInitialisation) { 
    tableBuilder->SetInitialisationFlag(false); 
    if (1 < verbose) {
      G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
         << G4endl;
    } 
  }

  // start initialisation for the first run
  if( -1 == run ) {
    emConfigurator->PrepareModels(particle, p);

    // initialise particles for given process
    for (G4int j=0; j<n_loss; ++j) {
      if (p == loss_vector[j] && !part_vector[j]) { 
    part_vector[j] = particle;
    if(particle->GetParticleName() == "GenericIon") {
      theGenericIon = particle;
    }
      }
    }
  }
  startInitialisation = true;
}

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

Definition at line 446 of file G4LossTableManager.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4EmConfigurator::PrepareModels(), and G4LossTableBuilder::SetInitialisationFlag().

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }
  isMaster = theMaster;

  if(!startInitialisation) { 
    tableBuilder->SetInitialisationFlag(false); 
    if (1 < verbose) {
      G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
         << G4endl;
    } 
  }

  // start initialisation for the first run
  if( -1 == run ) {
    emConfigurator->PrepareModels(particle, p);
  }
  startInitialisation = true;
}

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

Definition at line 474 of file G4LossTableManager.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4EmConfigurator::PrepareModels(), and G4LossTableBuilder::SetInitialisationFlag().

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }

  isMaster = theMaster;

  if(!startInitialisation) { 
    tableBuilder->SetInitialisationFlag(false); 
    if (1 < verbose) {
      G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
         << G4endl;
    } 
  }

  // start initialisation for the first run
  if( -1 == run ) {
    emConfigurator->PrepareModels(particle, p);
  } 
  startInitialisation = true;
}

void G4LossTableManager::Register

(

G4VEnergyLossProcess *

p

)

Definition at line 240 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::ActivateSubCutoff(), G4cout, G4endl, G4VProcess::GetProcessName(), G4VEnergyLossProcess::SetIntegral(), G4VEnergyLossProcess::SetLossFluctuations(), G4VEnergyLossProcess::SetMaxKinEnergy(), G4VEnergyLossProcess::SetMinKinEnergy(), G4VEnergyLossProcess::SetRandomStep(), and G4VEnergyLossProcess::SetStepFunction().

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

{
  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); }
}

void G4LossTableManager::Register

(

G4VMultipleScattering *

p

)

Definition at line 282 of file G4LossTableManager.cc.

References G4cout, G4endl, G4VProcess::GetProcessName(), and n.

{
  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);
}

void G4LossTableManager::Register

(

G4VEmProcess *

p

)

Definition at line 309 of file G4LossTableManager.cc.

References G4cout, G4endl, G4VProcess::GetProcessName(), and n.

{
  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);
}

void G4LossTableManager::Register

(

G4VEmModel *

p

)

Definition at line 336 of file G4LossTableManager.cc.

References G4cout, G4endl, and G4VEmModel::GetName().

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

void G4LossTableManager::Register

(

G4VEmFluctuationModel *

p

)

Definition at line 357 of file G4LossTableManager.cc.

References G4cout, G4endl, and G4VEmFluctuationModel::GetName().

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

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

Definition at line 378 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::BaseParticle(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), and G4VProcess::GetProcessName().

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

{ 
  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;
}

void G4LossTableManager::SetAtomDeexcitation

(

G4VAtomDeexcitation *

p

)

Definition at line 1314 of file G4LossTableManager.cc.

Referenced by G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), PhysListEmStandardNR::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), and G4EmStandardPhysics_option2::ConstructProcess().

{
  atomDeexcitation = p;
}

void G4LossTableManager::SetBremsstrahlungTh

(

G4double

val

)

Definition at line 1230 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetBremsstrahlungTh().

{
  bremsTh = val;
}

void G4LossTableManager::SetBuildCSDARange

(

G4bool

val

)

Definition at line 1145 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetBuildCSDARange().

{
  buildCSDARange = val;
}

void G4LossTableManager::SetDEDXBinning

(

G4int

val

)

Definition at line 1056 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetDEDXBinning().

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

void G4LossTableManager::SetDEDXBinningForCSDARange

(

G4int

val

)

Definition at line 1065 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetDEDXBinningForCSDARange().

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

void G4LossTableManager::SetFactorForAngleLimit

(

G4double

val

)

Definition at line 1244 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetFactorForAngleLimit().

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

void G4LossTableManager::SetIntegral

(

G4bool

val

)

Definition at line 974 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetIntegral().

{
  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); }
  }
}

void G4LossTableManager::SetLambdaBinning

(

G4int

val

)

Definition at line 1074 of file G4LossTableManager.cc.

References G4cout, G4endl, and n.

Referenced by G4EmProcessOptions::SetLambdaBinning().

{
  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); }
  }
}

void G4LossTableManager::SetLinearLossLimit

(

G4double

val

)

Definition at line 1136 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetLinearLossLimit().

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

void G4LossTableManager::SetLossFluctuations

(

G4bool

val

)

Definition at line 954 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetLossFluctuations().

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

void G4LossTableManager::SetLPMFlag

(

G4bool

val

)

Definition at line 1194 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetLPMFlag().

{
  flagLPM = val;
}

void G4LossTableManager::SetMaxEnergy

(

G4double

val

)

Definition at line 1024 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetMaxEnergy().

{
  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); }
  }
}

void G4LossTableManager::SetMaxEnergyForCSDARange

(

G4double

val

)

Definition at line 1039 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetMaxEnergyForCSDARange().

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

void G4LossTableManager::SetMaxEnergyForMuons

(

G4double

val

)

Definition at line 1048 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetMaxEnergyForMuons().

{
  maxEnergyForMuonsActive = true;
  maxKinEnergyForMuons = val;
}

void G4LossTableManager::SetMinEnergy

(

G4double

val

)

Definition at line 1009 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetMinEnergy().

{
  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); }
  }
}

void G4LossTableManager::SetMinSubRange

(

G4double

val

)

Definition at line 989 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetMinSubRange().

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

void G4LossTableManager::SetRandomStep

(

G4bool

val

)

Definition at line 999 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetRandomStep().

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

void G4LossTableManager::SetSplineFlag

(

G4bool

val

)

Definition at line 1208 of file G4LossTableManager.cc.

References G4LossTableBuilder::SetSplineFlag().

Referenced by G4EmProcessOptions::SetSplineFlag().

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

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

Definition at line 1124 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetStepFunction().

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

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

Definition at line 964 of file G4LossTableManager.cc.

Referenced by export_G4LossTableManager(), and G4EmProcessOptions::SetSubCutoff().

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

void G4LossTableManager::SetVerbose

(

G4int

val

)

Definition at line 1100 of file G4LossTableManager.cc.

References G4EmSaturation::SetVerbose(), G4EmConfigurator::SetVerbose(), G4ElectronIonPair::SetVerbose(), and G4VAtomDeexcitation::SetVerboseLevel().

Referenced by export_G4LossTableManager(), LocalPhysicsTables(), G4EmProcessOptions::SetVerbose(), and XrayFluoPhysicsList::XrayFluoPhysicsList().

{
  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); }
}

G4bool G4LossTableManager::SplineFlag

(

)

const

Definition at line 1216 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4VEmProcess::LambdaPhysicsVector(), G4VEnergyLossProcess::PrintInfoDefinition(), and G4VEmProcess::RetrievePhysicsTable().

{
  return splineFlag;
}

Friends And Related Function Documentation

friend class G4ThreadLocalSingleton< G4LossTableManager >

friend

Definition at line 103 of file G4LossTableManager.hh.

---

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

• G4LossTableManager.hh
• G4LossTableManager.cc