#include <G4LossTableManager.hh>

Public Member Functions
G4VAtomDeexcitation *	AtomDeexcitation ()

void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)

void	BuildPhysicsTable (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	DeRegister (G4VEmFluctuationModel *p)

void	DeRegister (G4VEmModel *p)

void	DeRegister (G4VEmProcess *p)

void	DeRegister (G4VEnergyLossProcess *p)

void	DeRegister (G4VMultipleScattering *p)

void	DeRegister (G4VProcess *p)

void	DumpHtml ()

G4ElectronIonPair *	ElectronIonPair ()

G4EmConfigurator *	EmConfigurator ()

G4EmCorrections *	EmCorrections ()

G4EmSaturation *	EmSaturation ()

	G4LossTableManager (G4LossTableManager &)=delete

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

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

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

G4VEmProcess *	GetElectronGeneralProcess ()

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

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

G4VEnergyLossProcess *	GetEnergyLossProcess (const G4ParticleDefinition *)

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

G4VEmProcess *	GetGammaGeneralProcess ()

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

G4VEmProcess *	GetPositronGeneralProcess ()

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

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

G4LossTableBuilder *	GetTableBuilder ()

G4bool	IsMaster () const

void	LocalPhysicsTables (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

G4NIELCalculator *	NIELCalculator ()

G4LossTableManager &	operator= (const G4LossTableManager &right)=delete

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

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

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

void	Register (G4VEmFluctuationModel *p)

void	Register (G4VEmModel *p)

void	Register (G4VEmProcess *p)

void	Register (G4VEnergyLossProcess *p)

void	Register (G4VMultipleScattering *p)

void	Register (G4VProcess *p)

void	RegisterExtraParticle (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	ResetParameters ()

void	SetAtomDeexcitation (G4VAtomDeexcitation *)

void	SetElectronGeneralProcess (G4VEmProcess *)

void	SetGammaGeneralProcess (G4VEmProcess *)

void	SetNIELCalculator (G4NIELCalculator *)

void	SetPositronGeneralProcess (G4VEmProcess *)

void	SetSubCutProducer (G4VSubCutProducer *)

void	SetVerbose (G4int val)

G4VSubCutProducer *	SubCutProducer ()

	~G4LossTableManager ()

Static Public Member Functions
static G4LossTableManager *	Instance ()

Private Types
typedef const G4ParticleDefinition *	PD

Private Member Functions
G4VEnergyLossProcess *	BuildTables (const G4ParticleDefinition *aParticle)

void	Clear ()

void	CopyDEDXTables ()

void	CopyTables (const G4ParticleDefinition aParticle, G4VEnergyLossProcess )

	G4LossTableManager ()

void	ParticleHaveNoLoss (const G4ParticleDefinition *aParticle)

void	PrintEWarning (G4String, G4double)

Private Attributes
G4bool	all_tables_are_built

G4VAtomDeexcitation *	atomDeexcitation

std::vector< PD >	base_part_vector

G4VEnergyLossProcess *	currentLoss

PD	currentParticle

std::vector< G4PhysicsTable * >	dedx_vector

G4VEmProcess *	eGeneral

G4EmConfigurator *	emConfigurator

G4EmCorrections *	emCorrections

G4ElectronIonPair *	emElectronIonPair

std::vector< G4VEmProcess * >	emp_vector

PD	firstParticle

std::vector< G4VEmFluctuationModel * >	fmod_vector

G4VEmProcess *	gGeneral

std::vector< G4PhysicsTable * >	inv_range_vector

std::vector< G4bool >	isActive

G4bool	isMaster

std::map< PD, G4VEnergyLossProcess *, std::less< PD > >	loss_map

std::vector< G4VEnergyLossProcess * >	loss_vector

std::vector< G4VEmModel * >	mod_vector

std::vector< G4VMultipleScattering * >	msc_vector

G4int	n_loss

G4NIELCalculator *	nielCalculator

std::vector< G4VProcess * >	p_vector

std::vector< PD >	part_vector

G4VEmProcess *	pGeneral

std::vector< G4PhysicsTable * >	range_vector

G4int	run

G4bool	startInitialisation

G4VSubCutProducer *	subcutProducer

G4LossTableBuilder *	tableBuilder

std::vector< G4bool >	tables_are_built

PD	theElectron

PD	theGenericIon

G4EmParameters *	theParameters

G4int	verbose

Static Private Attributes
static G4ThreadLocal G4LossTableManager *	instance = nullptr

Friends
class	G4ThreadLocalSingleton< G4LossTableManager >

Detailed Description

Definition at line 77 of file G4LossTableManager.hh.

Member Typedef Documentation

◆ PD

typedef const G4ParticleDefinition* G4LossTableManager::PD

private

Definition at line 256 of file G4LossTableManager.hh.

Constructor & Destructor Documentation

◆ ~G4LossTableManager()

G4LossTableManager::~G4LossTableManager ( )

Definition at line 98 of file G4LossTableManager.cc.

{
  for (G4int i=0; i<n_loss; ++i) {
    delete loss_vector[i]; 
  }
  size_t msc = msc_vector.size();
  for (size_t j=0; j<msc; ++j) {
    delete msc_vector[j];
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    delete emp_vector[k];
  }
  emp = p_vector.size();
  for (size_t k=0; k<emp; ++k) {
    delete p_vector[k];
  }
  size_t mod = mod_vector.size();
  size_t fmod = fmod_vector.size();
  //G4cout << "   Nmod" << mod << "  Nfluc= " << fmod << G4endl;
  for (size_t a=0; a<mod; ++a) {
    //G4cout << "Delete model #" << a << "  " <<  mod_vector[a] << G4endl;
    if( nullptr != mod_vector[a] ) { 
      for (size_t b=0; b<fmod; ++b) {
        if((G4VEmModel*)(fmod_vector[b]) == mod_vector[a]) {
          fmod_vector[b] = nullptr;
        }
      }
      delete mod_vector[a]; 
      mod_vector[a] = nullptr;
    }
  }
  for (size_t b=0; b<fmod; ++b) {
    delete fmod_vector[b];
  }
  Clear();
  delete tableBuilder;
  delete emCorrections;
  delete emConfigurator;
  delete emElectronIonPair;
  delete nielCalculator;
  delete atomDeexcitation;
  delete subcutProducer;
}

References atomDeexcitation, Clear(), emConfigurator, emCorrections, emElectronIonPair, emp_vector, fmod_vector, loss_vector, mod_vector, msc_vector, n_loss, nielCalculator, p_vector, subcutProducer, and tableBuilder.

◆ G4LossTableManager() [1/2]

G4LossTableManager::G4LossTableManager ( G4LossTableManager & )

delete

◆ G4LossTableManager() [2/2]

G4LossTableManager::G4LossTableManager ( )

private

Definition at line 145 of file G4LossTableManager.cc.

{
  theParameters = G4EmParameters::Instance();
  n_loss = 0;
  run = -1;
  startInitialisation = false;
  all_tables_are_built = false;
  currentLoss = nullptr;
  currentParticle = nullptr;
  firstParticle = nullptr;
  isMaster = true;
  verbose = theParameters->Verbose();
  theElectron  = G4Electron::Electron();
  theGenericIon= nullptr;
  if(G4Threading::IsWorkerThread()) { 
    verbose = theParameters->WorkerVerbose();
    isMaster = false;
  }  
  tableBuilder = new G4LossTableBuilder(isMaster);
  emCorrections= new G4EmCorrections(verbose);
  emConfigurator = nullptr;
  emElectronIonPair = nullptr;
  atomDeexcitation = nullptr;
  subcutProducer = nullptr;
  nielCalculator = nullptr; 
  gGeneral = nullptr;
  eGeneral = pGeneral = nullptr;
}

References all_tables_are_built, atomDeexcitation, currentLoss, currentParticle, eGeneral, G4Electron::Electron(), emConfigurator, emCorrections, emElectronIonPair, firstParticle, gGeneral, G4EmParameters::Instance(), isMaster, G4Threading::IsWorkerThread(), n_loss, nielCalculator, pGeneral, startInitialisation, subcutProducer, tableBuilder, theElectron, theGenericIon, theParameters, G4EmParameters::Verbose(), verbose, and G4EmParameters::WorkerVerbose().

Member Function Documentation

◆ AtomDeexcitation()

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation ( )

inline

Definition at line 389 of file G4LossTableManager.hh.

{
  return atomDeexcitation;
}

References atomDeexcitation.

◆ BuildPhysicsTable() [1/2]

void G4LossTableManager::BuildPhysicsTable ( const G4ParticleDefinition * aParticle )

Definition at line 538 of file G4LossTableManager.cc.

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

References G4EmConfigurator::Clear(), emConfigurator, and startInitialisation.

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

◆ BuildPhysicsTable() [2/2]

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

Definition at line 627 of file G4LossTableManager.cc.

{
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildPhysicsTable() for "
           << aParticle->GetParticleName()
           << " and process " << p->GetProcessName() << G4endl;
  }
  // clear configurator
  if(-1 == run && startInitialisation) {
    if(emConfigurator) { emConfigurator->Clear(); }
    firstParticle = aParticle; 
  }
  if(startInitialisation) {
    ++run;
    if(1 < verbose) {
      G4cout << "===== G4LossTableManager::BuildPhysicsTable() for run "
             << run << " ===== " << atomDeexcitation << G4endl;
    }
    currentParticle = nullptr;
    all_tables_are_built= true;
  }
 
  // initialisation before any table is built
  if ( startInitialisation && aParticle == firstParticle ) {
 
    startInitialisation = false;
    if(1 < verbose) {
      G4cout << "### G4LossTableManager start initialisation for first particle "
             << firstParticle->GetParticleName() 
             << G4endl;
    }
 
    if(nielCalculator) { nielCalculator->Initialise(); } 
 
    for (G4int i=0; i<n_loss; ++i) {
      G4VEnergyLossProcess* el = loss_vector[i];
 
      if(el) {
        isActive[i] = true;
        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] = nullptr;
        isActive[i] = false;
      }
    }
  }
 
  if (all_tables_are_built) { 
    theParameters->SetIsPrintedFlag(true);
    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() 
               << "  " << tables_are_built[i] << "  " << base_part_vector[i] 
               << G4endl;
      }
      G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
      if(curr_proc) { 
        CopyTables(curr_part, curr_proc); 
        if(p == curr_proc && 0 == run && p->IsIonisationProcess()) { 
          loss_map[aParticle] = p; 
          //G4cout << "G4LossTableManager::BuildPhysicsTable: " 
          //     << aParticle->GetParticleName()
          //         << " added to map " << p <<  G4endl;
        }
      }
    }
    if ( !tables_are_built[i] ) { all_tables_are_built = false; }
  }
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::BuildPhysicsTable end: "
           << "all_tables_are_built= " << all_tables_are_built << " "
           << aParticle->GetParticleName() << " proc: " << p << G4endl;
  }
  if(all_tables_are_built) { 
    if(1 < verbose) {
      G4cout << "%%%%% All dEdx and Range tables are built for master run= " 
             << run << " %%%%%" << G4endl;
    }
  }
}

References all_tables_are_built, atomDeexcitation, base_part_vector, G4VEnergyLossProcess::BaseParticle(), BuildTables(), G4EmConfigurator::Clear(), CopyTables(), currentParticle, emConfigurator, firstParticle, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4NIELCalculator::Initialise(), isActive, G4VEnergyLossProcess::IsIonisationProcess(), loss_map, loss_vector, n_loss, nielCalculator, part_vector, G4VEnergyLossProcess::Particle(), run, G4VEnergyLossProcess::SetIonisation(), G4EmParameters::SetIsPrintedFlag(), startInitialisation, tables_are_built, theParameters, and verbose.

◆ BuildTables()

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

private

Definition at line 784 of file G4LossTableManager.cc.

{
  if(1 < verbose) {
    G4cout << "G4LossTableManager::BuildTables() for "
           << aParticle->GetParticleName() << G4endl;
  }
 
  std::vector<G4PhysicsTable*> t_list;  
  std::vector<G4VEnergyLossProcess*> loss_list;
  std::vector<G4bool> build_flags;
  G4VEnergyLossProcess* em = nullptr;
  G4VEnergyLossProcess* p = nullptr;
  G4int iem = 0;
  G4PhysicsTable* dedx = nullptr;
  G4int i;
 
  G4ProcessVector* pvec = 
    aParticle->GetProcessManager()->GetProcessList();
  G4int nvec = pvec->size();
 
  for (i=0; i<n_loss; ++i) {
    p = loss_vector[i];
    if (p) {
      G4bool yes = (aParticle == part_vector[i]);
 
      // possible case of process sharing between particle/anti-particle
      if(!yes) {
        G4VProcess* ptr = static_cast<G4VProcess*>(p);
        for(G4int j=0; j<nvec; ++j) {
          //G4cout << "j= " << j << " " << (*pvec)[j] << " " << ptr << G4endl;
          if(ptr == (*pvec)[j]) {
            yes = true;
            break;
          }
        }
      }      
      // process belong to this particle
      if(yes && isActive[i]) {
        if (p->IsIonisationProcess() || !em) {
          em = p;
          iem= i;
        }
        // tables may be shared between particle/anti-particle
        G4bool val = false;
        if (!tables_are_built[i]) {
          val = true;
          dedx = p->BuildDEDXTable(fRestricted);
          //G4cout << "Build DEDX table for " << p->GetProcessName()
          // << " idx= " << i << dedx << " " << dedx->length() << G4endl;
          p->SetDEDXTable(dedx,fRestricted);
          tables_are_built[i] = true;
        } else {
          dedx = p->DEDXTable();
        }
        t_list.push_back(dedx);
        loss_list.push_back(p);
        build_flags.push_back(val);
      }
    }
  }
 
  G4int n_dedx = t_list.size();
  if (0 == n_dedx || !em) {
    G4cout << "G4LossTableManager WARNING: no DEDX processes for " 
           << aParticle->GetParticleName() << G4endl;
    return 0;
  }
  G4int nSubRegions = em->NumberOfSubCutoffRegions();
 
  if (1 < verbose) {
    G4cout << "G4LossTableManager::BuildTables() start to build range tables"
           << " and the sum of " << n_dedx << " processes"
           << " iem= " << iem << " em= " << em->GetProcessName()
           << " buildCSDARange= " << theParameters->BuildCSDARange()
           << " nSubRegions= " << nSubRegions;
    if(subcutProducer) { 
      G4cout << " SubCutProducer " << subcutProducer->GetName(); 
    }
    G4cout << G4endl;
  }
  // do not build tables if producer class is defined
  if(subcutProducer) { nSubRegions = 0; }
 
  dedx = em->DEDXTable(); 
  em->SetIonisation(true);
  em->SetDEDXTable(dedx, fIsIonisation);
 
  if (1 < n_dedx) {
    dedx = 0;
    dedx = G4PhysicsTableHelper::PreparePhysicsTable(dedx);
    tableBuilder->BuildDEDXTable(dedx, t_list);
    em->SetDEDXTable(dedx, fRestricted);
  }
 
  /*
  if(2==run && "e-" == aParticle->GetParticleName()) {
    G4cout << "G4LossTableManager::BuildTables for e- " << dedx << G4endl;
    G4cout << (*dedx) << G4endl;
    G4cout << "%%%%% Instance ID= " << (*dedx)[0]->GetInstanceID() << G4endl;
    G4cout << "%%%%% LastValue= " << (*dedx)[0]->GetLastValue() << G4endl;
    G4cout << "%%%%% 1.2 " << (*(dedx))[0]->Value(1.2) << G4endl;
  }
  */
  dedx_vector[iem] = dedx;
 
  G4PhysicsTable* range = em->RangeTableForLoss();
  if(!range) range  = G4PhysicsTableHelper::PreparePhysicsTable(range);
  range_vector[iem] = range;
 
  G4PhysicsTable* invrange = em->InverseRangeTable();
  if(!invrange) invrange = G4PhysicsTableHelper::PreparePhysicsTable(invrange);
  inv_range_vector[iem]  = invrange;
 
  tableBuilder->BuildRangeTable(dedx, range);
  tableBuilder->BuildInverseRangeTable(range, invrange);
 
  //  if(1<verbose) G4cout << *dedx << G4endl;
 
  em->SetRangeTableForLoss(range);
  em->SetInverseRangeTable(invrange);
 
  //  if(1<verbose) G4cout << *range << G4endl;
 
  std::vector<G4PhysicsTable*> listSub;
  std::vector<G4PhysicsTable*> listCSDA;
 
  for (i=0; i<n_dedx; ++i) {
    p = loss_list[i];
    if(p != em) { p->SetIonisation(false); }
    if(build_flags[i]) {
      p->SetLambdaTable(p->BuildLambdaTable(fRestricted));
    }
    if(theParameters->BuildCSDARange()) { 
      dedx = p->BuildDEDXTable(fTotal);
      p->SetDEDXTable(dedx,fTotal);
      listCSDA.push_back(dedx); 
    }     
  }
 
  if(theParameters->BuildCSDARange()) {
    G4PhysicsTable* dedxCSDA = em->DEDXunRestrictedTable();
    if (1 < n_dedx) {
      dedxCSDA = nullptr;
      dedxCSDA = G4PhysicsTableHelper::PreparePhysicsTable(dedxCSDA);
      tableBuilder->BuildDEDXTable(dedxCSDA, listCSDA);
      em->SetDEDXTable(dedxCSDA,fTotal);
    }
    G4PhysicsTable* rCSDA = em->CSDARangeTable();
    if(!rCSDA) { rCSDA = G4PhysicsTableHelper::PreparePhysicsTable(rCSDA); }
    tableBuilder->BuildRangeTable(dedxCSDA, rCSDA);
    em->SetCSDARangeTable(rCSDA);
  }
 
  if (1 < verbose) {
    G4cout << "G4LossTableManager::BuildTables: Tables are built for "
           << aParticle->GetParticleName()
           << "; ionisation process: " << em->GetProcessName()
           << "  " << em
           << G4endl;
  }
  return em;
}

Referenced by BuildPhysicsTable().

◆ Clear()

void G4LossTableManager::Clear ( )

private

Definition at line 176 of file G4LossTableManager.cc.

{
  all_tables_are_built = false;
  currentLoss = nullptr;
  currentParticle = nullptr;
  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;
  }
}

References all_tables_are_built, base_part_vector, currentLoss, currentParticle, dedx_vector, inv_range_vector, isActive, loss_map, loss_vector, n_loss, part_vector, range_vector, and tables_are_built.

Referenced by ~G4LossTableManager().

◆ CopyDEDXTables()

void G4LossTableManager::CopyDEDXTables ( )

private

◆ CopyTables()

void G4LossTableManager::CopyTables	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	base_proc
	)

private

Definition at line 743 of file G4LossTableManager.cc.

{
  for (G4int j=0; j<n_loss; ++j) {
 
    G4VEnergyLossProcess* proc = loss_vector[j];
 
    if (!tables_are_built[j] && part == base_part_vector[j]) {
      tables_are_built[j] = true;
      proc->SetDEDXTable(base_proc->IonisationTable(),fRestricted);
      proc->SetDEDXTable(base_proc->DEDXunRestrictedTable(),fTotal);
      proc->SetCSDARangeTable(base_proc->CSDARangeTable());
      proc->SetRangeTableForLoss(base_proc->RangeTableForLoss());
      proc->SetInverseRangeTable(base_proc->InverseRangeTable());
      proc->SetLambdaTable(base_proc->LambdaTable());
      proc->SetIonisation(base_proc->IsIonisationProcess());
      if(proc->IsIonisationProcess()) { 
        range_vector[j] = base_proc->RangeTableForLoss();
        inv_range_vector[j] = base_proc->InverseRangeTable();
        loss_map[part_vector[j]] = proc; 
        //G4cout << "G4LossTableManager::CopyTable " 
        //       << part_vector[j]->GetParticleName()
        //       << " added to map " << proc << G4endl;
      }
      if (1 < verbose) {
         G4cout << "For " << proc->GetProcessName()
                << " for " << part_vector[j]->GetParticleName()
                << " base_part= " << part->GetParticleName()
                << " tables are assigned"
                << G4endl;
      }
    }
 
    if (theElectron == part && theElectron == proc->SecondaryParticle() ) {
      proc->SetSecondaryRangeTable(base_proc->RangeTableForLoss());
    }
  }
}

Referenced by BuildPhysicsTable().

◆ DeRegister() [1/6]

void G4LossTableManager::DeRegister ( G4VEmFluctuationModel * p )

Definition at line 380 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] = nullptr; }
  }
}

References fmod_vector, and CLHEP::detail::n.

◆ DeRegister() [2/6]

void G4LossTableManager::DeRegister ( G4VEmModel * p )

Definition at line 355 of file G4LossTableManager.cc.

{
  //G4cout << "G4LossTableManager::DeRegister G4VEmModel : " << p << G4endl;
  size_t n = mod_vector.size();
  for (size_t i=0; i<n; ++i) {
    if(mod_vector[i] == p) { 
      mod_vector[i] = nullptr; 
      break;
    }
  }
}

References mod_vector, and CLHEP::detail::n.

◆ DeRegister() [3/6]

void G4LossTableManager::DeRegister ( G4VEmProcess * p )

Definition at line 300 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] = nullptr; 
      break;
    }
  }
}

References emp_vector.

◆ DeRegister() [4/6]

void G4LossTableManager::DeRegister ( G4VEnergyLossProcess * p )

Definition at line 241 of file G4LossTableManager.cc.

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

References loss_vector, and n_loss.

Referenced by G4AnnihiToMuPair::~G4AnnihiToMuPair(), G4GammaConversionToMuons::~G4GammaConversionToMuons(), G4SynchrotronRadiation::~G4SynchrotronRadiation(), G4VEmFluctuationModel::~G4VEmFluctuationModel(), G4VEmModel::~G4VEmModel(), G4VEmProcess::~G4VEmProcess(), G4VEnergyLossProcess::~G4VEnergyLossProcess(), G4VMultipleScattering::~G4VMultipleScattering(), and G4VTransitionRadiation::~G4VTransitionRadiation().

◆ DeRegister() [5/6]

void G4LossTableManager::DeRegister ( G4VMultipleScattering * p )

Definition at line 270 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] = nullptr;
      break;
    }
  }
}

References msc_vector.

◆ DeRegister() [6/6]

void G4LossTableManager::DeRegister ( G4VProcess * p )

Definition at line 330 of file G4LossTableManager.cc.

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

References p_vector.

◆ DumpHtml()

void G4LossTableManager::DumpHtml ( )

Definition at line 1076 of file G4LossTableManager.cc.

{
  // Automatic generation of html documentation page for physics lists
  // List processes and models for the most important
  // particles in descending order of importance
  // NB. for model names with length > 18 characters the .rst file needs
  //  to be edited by hand. Or modify G4EmModelManager::DumpModelList
 
  char* dirName = std::getenv("G4PhysListDocDir");
  char* physList = std::getenv("G4PhysListName");
  if (dirName && physList) {
    G4String physListName = G4String(physList);
    G4String pathName = G4String(dirName) + "/" + physListName + ".rst";
 
    std::ofstream outFile;
    outFile.open(pathName);
   
    outFile << physListName << G4endl;
    outFile << std::string(physListName.length(), '=') << G4endl;
 
    std::vector<G4ParticleDefinition*> particles {
        G4Gamma::Gamma(),
        G4Electron::Electron(),
        G4Positron::Positron(),
        G4Proton::ProtonDefinition(),
        G4MuonPlus::MuonPlusDefinition(),
        G4MuonMinus::MuonMinusDefinition(),
      };
   
    std::vector<G4VEmProcess*> emproc_vector = GetEmProcessVector();
    std::vector<G4VEnergyLossProcess*> enloss_vector = 
      GetEnergyLossProcessVector();
    std::vector<G4VMultipleScattering*> mscat_vector =
      GetMultipleScatteringVector();
    
    for (auto theParticle : particles) {
      outFile << G4endl << "**" << theParticle->GetParticleName()
              << "**" << G4endl << G4endl << " .. code-block:: none" << G4endl;
 
      G4ProcessManager* pm = theParticle->GetProcessManager();
      G4ProcessVector*  pv = pm->GetProcessList();
      G4int plen = pm->GetProcessListLength();
 
      for (auto emproc : emproc_vector) {
        for (G4int i = 0; i < plen; ++i) {
          G4VProcess* proc = (*pv)[i];
          if (proc == emproc) {
            outFile << G4endl;
            proc->ProcessDescription(outFile);
            break;
          }
        }
      }
 
      for (auto mscproc : mscat_vector) {
        for (G4int i = 0; i < plen; ++i) {
          G4VProcess* proc = (*pv)[i];
          if (proc == mscproc) {
            outFile << G4endl;
            proc->ProcessDescription(outFile);
            break;
          }
        }
      }
 
      for (auto enlossproc : enloss_vector) {
        for (G4int i = 0; i < plen; ++i) {
          G4VProcess* proc = (*pv)[i];
          if (proc == enlossproc) {
            outFile << G4endl;
            proc->ProcessDescription(outFile);
            break;
          }
        }
      }
    }
    outFile.close();
  }
}

References G4Electron::Electron(), G4endl, G4Gamma::Gamma(), GetEmProcessVector(), GetEnergyLossProcessVector(), GetMultipleScatteringVector(), G4ProcessManager::GetProcessList(), G4ProcessManager::GetProcessListLength(), G4MuonMinus::MuonMinusDefinition(), G4MuonPlus::MuonPlusDefinition(), G4Positron::Positron(), G4VProcess::ProcessDescription(), and G4Proton::ProtonDefinition().

◆ ElectronIonPair()

G4ElectronIonPair * G4LossTableManager::ElectronIonPair ( )

Definition at line 1009 of file G4LossTableManager.cc.

{
  if(!emElectronIonPair) { 
    emElectronIonPair = new G4ElectronIonPair(verbose);
  }
  return emElectronIonPair;
}

References emElectronIonPair, and verbose.

◆ EmConfigurator()

G4EmConfigurator * G4LossTableManager::EmConfigurator ( )

Definition at line 999 of file G4LossTableManager.cc.

{
  if(!emConfigurator) {
    emConfigurator = new G4EmConfigurator(verbose); 
  }
  return emConfigurator;
}

References emConfigurator, and verbose.

◆ EmCorrections()

G4EmCorrections * G4LossTableManager::EmCorrections ( )

inline

Definition at line 382 of file G4LossTableManager.hh.

{
  return emCorrections;
}

References emCorrections.

Referenced by G4AtimaEnergyLossModel::G4AtimaEnergyLossModel(), G4BetheBlochModel::G4BetheBlochModel(), G4BraggModel::G4BraggModel(), G4EmCalculator::G4EmCalculator(), G4ionIonisation::G4ionIonisation(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4LindhardSorensenIonModel::G4LindhardSorensenIonModel(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4BraggIonModel::Initialise(), and G4ContinuousGainOfEnergy::SetDynamicMassCharge().

◆ EmSaturation()

G4EmSaturation * G4LossTableManager::EmSaturation ( )

Definition at line 992 of file G4LossTableManager.cc.

{
  return theParameters->GetEmSaturation();
}

References G4EmParameters::GetEmSaturation(), and theParameters.

Referenced by G4OpticalPhysics::ConstructProcess().

◆ GetCSDARange()

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

inline

Definition at line 318 of file G4LossTableManager.hh.

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

References currentLoss, currentParticle, DBL_MAX, G4VEnergyLossProcess::GetCSDARange(), and GetEnergyLossProcess().

Referenced by G4EmCalculator::GetCSDARange().

◆ GetDEDX()

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

inline

Definition at line 307 of file G4LossTableManager.hh.

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

References currentLoss, currentParticle, G4VEnergyLossProcess::GetDEDX(), and GetEnergyLossProcess().

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

◆ GetDEDXDispersion()

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

inline

Definition at line 363 of file G4LossTableManager.hh.

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

References currentLoss, currentParticle, G4VEnergyLossProcess::GetDEDXDispersion(), GetEnergyLossProcess(), and G4DynamicParticle::GetParticleDefinition().

◆ GetElectronGeneralProcess()

G4VEmProcess * G4LossTableManager::GetElectronGeneralProcess ( )

inline

Definition at line 431 of file G4LossTableManager.hh.

{
  return eGeneral;
} 

References eGeneral.

Referenced by G4EmExtraPhysics::ConstructGammaElectroNuclear().

◆ GetEmProcessVector()

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

Definition at line 977 of file G4LossTableManager.cc.

{
  return emp_vector;
}

References emp_vector.

Referenced by DumpHtml(), and G4EmCalculator::FindDiscreteProcess().

◆ GetEnergy()

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

inline

Definition at line 352 of file G4LossTableManager.hh.

{
  if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
  return currentLoss ? currentLoss->GetKineticEnergy(range, couple) : 0.0;
}

References currentLoss, currentParticle, GetEnergyLossProcess(), and G4VEnergyLossProcess::GetKineticEnergy().

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

◆ GetEnergyLossProcess()

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

Definition at line 417 of file G4LossTableManager.cc.

{
  //G4cout << "G4LossTableManager::GetEnergyLossProcess: " 
  //<< aParticle << "  " << currentParticle << "  " << currentLoss << G4endl;
  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 = nullptr;
      if ((pos = loss_map.find(theGenericIon)) != loss_map.end()) {
        currentLoss = (*pos).second;
      }
    }
  }
  return currentLoss;
}

References currentLoss, currentParticle, loss_map, pos, and theGenericIon.

Referenced by G4EmBiasingManager::ApplyRangeCut(), G4EmCalculator::FindEnergyLossProcess(), GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetRange(), GetRangeFromRestricteDEDX(), and G4VMultipleScattering::StartTracking().

◆ GetEnergyLossProcessVector()

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

Definition at line 970 of file G4LossTableManager.cc.

{
  return loss_vector;
}

References loss_vector.

Referenced by G4EmModelActivator::ActivatePAI(), G4EmCalculator::ComputeDEDXForCutInRange(), G4EmCalculator::ComputeElectronicDEDX(), DumpHtml(), and G4EmCalculator::FindEnLossProcess().

◆ GetGammaGeneralProcess()

G4VEmProcess * G4LossTableManager::GetGammaGeneralProcess ( )

inline

Definition at line 417 of file G4LossTableManager.hh.

{
  return gGeneral;
} 

References gGeneral.

Referenced by G4BertiniElectroNuclearBuilder::Build(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), and G4EmExtraPhysics::ConstructProcess().

◆ GetMultipleScatteringVector()

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

Definition at line 985 of file G4LossTableManager.cc.

{
  return msc_vector;
}

References msc_vector.

Referenced by DumpHtml(), and G4EmCalculator::FindMscProcess().

◆ GetPositronGeneralProcess()

G4VEmProcess * G4LossTableManager::GetPositronGeneralProcess ( )

inline

Definition at line 445 of file G4LossTableManager.hh.

{
  return pGeneral;
} 

Referenced by G4EmExtraPhysics::ConstructGammaElectroNuclear().

◆ GetRange()

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

inline

Definition at line 341 of file G4LossTableManager.hh.

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

References currentLoss, currentParticle, DBL_MAX, GetEnergyLossProcess(), and G4VEnergyLossProcess::GetRange().

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

◆ GetRangeFromRestricteDEDX()

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

inline

Definition at line 329 of file G4LossTableManager.hh.

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

References currentLoss, currentParticle, DBL_MAX, GetEnergyLossProcess(), and G4VEnergyLossProcess::GetRange().

Referenced by G4EmCalculator::GetRangeFromRestricteDEDX().

◆ GetTableBuilder()

G4LossTableBuilder * G4LossTableManager::GetTableBuilder ( )

inline

Definition at line 403 of file G4LossTableManager.hh.

{
  return tableBuilder;
}

References tableBuilder.

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

◆ Instance()

G4LossTableManager * G4LossTableManager::Instance ( void )

static

Definition at line 87 of file G4LossTableManager.cc.

{
  if(!instance) {
    static G4ThreadLocalSingleton<G4LossTableManager> inst;
    instance = inst.Instance();
  }
  return instance;
}

References G4ThreadLocalSingleton< T >::Instance(), and instance.

◆ IsMaster()

G4bool G4LossTableManager::IsMaster ( ) const

inline

Definition at line 375 of file G4LossTableManager.hh.

{
  return isMaster;
}

References isMaster.

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

◆ LocalPhysicsTables()

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

Definition at line 547 of file G4LossTableManager.cc.

{
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::LocalPhysicsTable() for "
           << aParticle->GetParticleName()
           << " and process " << p->GetProcessName()
           << G4endl;
  }
 
  if(-1 == run && startInitialisation) {
    if(emConfigurator) { emConfigurator->Clear(); }
    firstParticle = aParticle; 
  }
 
  if(startInitialisation) {
    ++run;
    if(1 < verbose) {
      G4cout << "===== G4LossTableManager::LocalPhysicsTable() for run "
             << run << " =====" << G4endl;
    }
    currentParticle = nullptr;
    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] = nullptr;
      }
    }
  }
 
  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;
      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]] = p;
        //G4cout << "G4LossTableManager::LocalPhysicsTable " << part_vector[i]->GetParticleName()
        //     << " added to map " << p << G4endl;
      }
 
      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;
    }
  }
 
  if(1 < verbose) {
    G4cout << "### G4LossTableManager::LocalPhysicsTable end"
           << G4endl;
  }
  if(all_tables_are_built) { 
    if(1 < verbose) {
      G4cout << "%%%%% All dEdx and Range tables for worker are ready for run "
             << run << " %%%%%" << G4endl;
    }
  }
}

References all_tables_are_built, base_part_vector, G4VEnergyLossProcess::BaseParticle(), G4EmConfigurator::Clear(), currentParticle, dedx_vector, G4VEnergyLossProcess::DEDXTable(), emConfigurator, firstParticle, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), inv_range_vector, G4VEnergyLossProcess::InverseRangeTable(), isActive, G4VEnergyLossProcess::IsIonisationProcess(), loss_map, loss_vector, n_loss, part_vector, G4VEnergyLossProcess::Particle(), range_vector, G4VEnergyLossProcess::RangeTableForLoss(), run, startInitialisation, tables_are_built, and verbose.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ NIELCalculator()

G4NIELCalculator * G4LossTableManager::NIELCalculator ( )

Definition at line 1029 of file G4LossTableManager.cc.

{
  if(!nielCalculator) { 
    nielCalculator = new G4NIELCalculator(nullptr, verbose); 
  }
  return nielCalculator;
}

References nielCalculator, and verbose.

◆ operator=()

G4LossTableManager & G4LossTableManager::operator= ( const G4LossTableManager & right )

delete

◆ ParticleHaveNoLoss()

void G4LossTableManager::ParticleHaveNoLoss ( const G4ParticleDefinition * aParticle )

private

Definition at line 950 of file G4LossTableManager.cc.

{
  G4ExceptionDescription ed;
  ed << "Energy loss process not found for " << aParticle->GetParticleName() 
     << " !";
  G4Exception("G4LossTableManager::ParticleHaveNoLoss", "em0001",
              FatalException, ed);
}

References FatalException, G4Exception(), and G4ParticleDefinition::GetParticleName().

◆ PreparePhysicsTable() [1/3]

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

Definition at line 480 of file G4LossTableManager.cc.

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

References emConfigurator, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), isMaster, G4EmConfigurator::PrepareModels(), ResetParameters(), startInitialisation, and verbose.

◆ PreparePhysicsTable() [2/3]

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

Definition at line 439 of file G4LossTableManager.cc.

{
  if (1 < verbose) {
    G4cout << "G4LossTableManager::PreparePhysicsTable for " 
           << particle->GetParticleName() 
           << " and " << p->GetProcessName() << " run= " << run 
           << "   loss_vector " << loss_vector.size() << G4endl;
  }
 
  isMaster = theMaster;
 
  if(!startInitialisation) { 
    ResetParameters();
    if (1 < verbose) {
      G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
             << G4endl;
    } 
  }
 
  // start initialisation for the first run
  if( -1 == run ) {
    if(emConfigurator) { 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;
}

References emConfigurator, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), isMaster, loss_vector, n_loss, part_vector, G4EmConfigurator::PrepareModels(), ResetParameters(), startInitialisation, theGenericIon, and verbose.

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

◆ PreparePhysicsTable() [3/3]

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

Definition at line 508 of file G4LossTableManager.cc.

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

References emConfigurator, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), isMaster, G4EmConfigurator::PrepareModels(), ResetParameters(), startInitialisation, and verbose.

◆ PrintEWarning()

void G4LossTableManager::PrintEWarning	(	G4String	tit,
		G4double
	)

private

Definition at line 1059 of file G4LossTableManager.cc.

{
  G4String ss = "G4LossTableManager::" + tit; 
  G4ExceptionDescription ed;
  /*
  ed << "Parameter is out of range: " << val 
     << " it will have no effect!\n" << " ## " 
     << " nbins= " << nbinsLambda 
     << " nbinsPerDecade= " << nbinsPerDecade 
     << " Emin(keV)= " << minKinEnergy/keV 
     << " Emax(GeV)= " << maxKinEnergy/GeV;
  */
  G4Exception(ss, "em0044", JustWarning, ed);
}

References G4Exception(), and JustWarning.

◆ Register() [1/6]

void G4LossTableManager::Register ( G4VEmFluctuationModel * p )

Definition at line 369 of file G4LossTableManager.cc.

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

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

◆ Register() [2/6]

void G4LossTableManager::Register ( G4VEmModel * p )

Definition at line 344 of file G4LossTableManager.cc.

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

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

◆ Register() [3/6]

void G4LossTableManager::Register ( G4VEmProcess * p )

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

References emp_vector, G4cout, G4endl, G4VProcess::GetProcessName(), CLHEP::detail::n, and verbose.

◆ Register() [4/6]

void G4LossTableManager::Register ( G4VEnergyLossProcess * p )

Definition at line 197 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(nullptr);
  base_part_vector.push_back(nullptr);
  dedx_vector.push_back(nullptr);
  range_vector.push_back(nullptr);
  inv_range_vector.push_back(nullptr);
  tables_are_built.push_back(false);
  isActive.push_back(true);
  all_tables_are_built = false;
}

References all_tables_are_built, base_part_vector, dedx_vector, G4cout, G4endl, G4VProcess::GetProcessName(), inv_range_vector, isActive, loss_vector, n_loss, part_vector, range_vector, tables_are_built, and verbose.

Referenced by G4AnnihiToMuPair::G4AnnihiToMuPair(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), and G4VTransitionRadiation::G4VTransitionRadiation().

◆ Register() [5/6]

void G4LossTableManager::Register ( G4VMultipleScattering * p )

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

References G4cout, G4endl, G4VProcess::GetProcessName(), msc_vector, CLHEP::detail::n, and verbose.

◆ Register() [6/6]

void G4LossTableManager::Register ( G4VProcess * p )

Definition at line 314 of file G4LossTableManager.cc.

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

References G4cout, G4endl, G4VProcess::GetProcessName(), CLHEP::detail::n, p_vector, and verbose.

◆ RegisterExtraParticle()

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

Definition at line 390 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(nullptr);
  range_vector.push_back(nullptr);
  inv_range_vector.push_back(nullptr);
  tables_are_built.push_back(false);
  all_tables_are_built = false;
}

References all_tables_are_built, base_part_vector, G4VEnergyLossProcess::BaseParticle(), dedx_vector, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), inv_range_vector, loss_vector, n_loss, part_vector, range_vector, tables_are_built, and verbose.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ ResetParameters()

void G4LossTableManager::ResetParameters ( )

Definition at line 221 of file G4LossTableManager.cc.

{
  verbose = theParameters->Verbose();
  if(!isMaster) {
    verbose = theParameters->WorkerVerbose();
  } else {
    if(verbose > 0) { theParameters->Dump(); }
  }
  tableBuilder->SetInitialisationFlag(false); 
  emCorrections->SetVerbose(verbose); 
  if(nullptr != emConfigurator) { emConfigurator->SetVerbose(verbose); };
  if(nullptr != emElectronIonPair) { emElectronIonPair->SetVerbose(verbose); };
  if(nullptr != atomDeexcitation) {
    atomDeexcitation->SetVerboseLevel(verbose);
    atomDeexcitation->InitialiseAtomicDeexcitation();
  }
}

References atomDeexcitation, G4EmParameters::Dump(), emConfigurator, emCorrections, emElectronIonPair, G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), isMaster, G4LossTableBuilder::SetInitialisationFlag(), G4EmConfigurator::SetVerbose(), G4EmCorrections::SetVerbose(), G4ElectronIonPair::SetVerbose(), G4VAtomDeexcitation::SetVerboseLevel(), tableBuilder, theParameters, G4EmParameters::Verbose(), verbose, and G4EmParameters::WorkerVerbose().

Referenced by G4RadioactiveDecayPhysics::ConstructProcess(), and PreparePhysicsTable().

◆ SetAtomDeexcitation()

void G4LossTableManager::SetAtomDeexcitation ( G4VAtomDeexcitation * p )

Definition at line 1039 of file G4LossTableManager.cc.

{
  if(atomDeexcitation != p) {
    delete atomDeexcitation;
    atomDeexcitation = p;
  }
}

References atomDeexcitation.

◆ SetElectronGeneralProcess()

void G4LossTableManager::SetElectronGeneralProcess ( G4VEmProcess * ptr )

inline

Definition at line 424 of file G4LossTableManager.hh.

{
  eGeneral = ptr;
} 

References eGeneral.

◆ SetGammaGeneralProcess()

void G4LossTableManager::SetGammaGeneralProcess ( G4VEmProcess * ptr )

inline

Definition at line 410 of file G4LossTableManager.hh.

{
  gGeneral = ptr;
} 

References gGeneral.

Referenced by G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), and G4EmStandardPhysicsSS::ConstructProcess().

◆ SetNIELCalculator()

void G4LossTableManager::SetNIELCalculator ( G4NIELCalculator * ptr )

Definition at line 1019 of file G4LossTableManager.cc.

{
  if(ptr && ptr != nielCalculator) {
    delete nielCalculator;
    nielCalculator = ptr;
  }
}

References nielCalculator.

Referenced by G4NIELCalculator::G4NIELCalculator().

◆ SetPositronGeneralProcess()

void G4LossTableManager::SetPositronGeneralProcess ( G4VEmProcess * ptr )

inline

Definition at line 438 of file G4LossTableManager.hh.

{
  pGeneral = ptr;
} 

References pGeneral.

◆ SetSubCutProducer()

void G4LossTableManager::SetSubCutProducer ( G4VSubCutProducer * p )

Definition at line 1049 of file G4LossTableManager.cc.

{
  if(subcutProducer != p) {
    delete subcutProducer;
    subcutProducer = p;
  }
}

References subcutProducer.

◆ SetVerbose()

void G4LossTableManager::SetVerbose ( G4int val )

Definition at line 962 of file G4LossTableManager.cc.

{
  verbose = val;
}

References verbose.

◆ SubCutProducer()

G4VSubCutProducer * G4LossTableManager::SubCutProducer ( )

inline

Definition at line 396 of file G4LossTableManager.hh.

{ 
  return subcutProducer;
}

References subcutProducer.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

Friends And Related Function Documentation

◆ G4ThreadLocalSingleton< G4LossTableManager >

friend class G4ThreadLocalSingleton< G4LossTableManager >

friend

Definition at line 445 of file G4LossTableManager.hh.

Field Documentation

◆ all_tables_are_built

G4bool G4LossTableManager::all_tables_are_built

private

Definition at line 298 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), Clear(), G4LossTableManager(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ atomDeexcitation

G4VAtomDeexcitation* G4LossTableManager::atomDeexcitation

private

Definition at line 286 of file G4LossTableManager.hh.

Referenced by AtomDeexcitation(), BuildPhysicsTable(), G4LossTableManager(), ResetParameters(), SetAtomDeexcitation(), and ~G4LossTableManager().

◆ base_part_vector

std::vector<PD> G4LossTableManager::base_part_vector

private

Definition at line 262 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), Clear(), CopyTables(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ currentLoss

G4VEnergyLossProcess* G4LossTableManager::currentLoss

private

Definition at line 275 of file G4LossTableManager.hh.

Referenced by Clear(), G4LossTableManager(), GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetEnergyLossProcess(), GetRange(), and GetRangeFromRestricteDEDX().

◆ currentParticle

PD G4LossTableManager::currentParticle

private

Definition at line 276 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), Clear(), G4LossTableManager(), GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetEnergyLossProcess(), GetRange(), GetRangeFromRestricteDEDX(), and LocalPhysicsTables().

◆ dedx_vector

std::vector<G4PhysicsTable*> G4LossTableManager::dedx_vector

private

Definition at line 265 of file G4LossTableManager.hh.

Referenced by BuildTables(), Clear(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ eGeneral

G4VEmProcess* G4LossTableManager::eGeneral

private

Definition at line 291 of file G4LossTableManager.hh.

Referenced by G4LossTableManager(), GetElectronGeneralProcess(), and SetElectronGeneralProcess().

◆ emConfigurator

G4EmConfigurator* G4LossTableManager::emConfigurator

private

Definition at line 283 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), EmConfigurator(), G4LossTableManager(), LocalPhysicsTables(), PreparePhysicsTable(), ResetParameters(), and ~G4LossTableManager().

◆ emCorrections

G4EmCorrections* G4LossTableManager::emCorrections

private

Definition at line 282 of file G4LossTableManager.hh.

Referenced by EmCorrections(), G4LossTableManager(), ResetParameters(), and ~G4LossTableManager().

◆ emElectronIonPair

G4ElectronIonPair* G4LossTableManager::emElectronIonPair

private

Definition at line 284 of file G4LossTableManager.hh.

Referenced by ElectronIonPair(), G4LossTableManager(), ResetParameters(), and ~G4LossTableManager().

◆ emp_vector

std::vector<G4VEmProcess*> G4LossTableManager::emp_vector

private

Definition at line 269 of file G4LossTableManager.hh.

Referenced by DeRegister(), GetEmProcessVector(), Register(), and ~G4LossTableManager().

◆ firstParticle

PD G4LossTableManager::firstParticle

private

Definition at line 279 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), G4LossTableManager(), and LocalPhysicsTables().

◆ fmod_vector

std::vector<G4VEmFluctuationModel*> G4LossTableManager::fmod_vector

private

Definition at line 271 of file G4LossTableManager.hh.

Referenced by DeRegister(), Register(), and ~G4LossTableManager().

◆ gGeneral

G4VEmProcess* G4LossTableManager::gGeneral

private

Definition at line 290 of file G4LossTableManager.hh.

Referenced by G4LossTableManager(), GetGammaGeneralProcess(), and SetGammaGeneralProcess().

◆ instance

G4ThreadLocal G4LossTableManager * G4LossTableManager::instance = nullptr

staticprivate

Definition at line 254 of file G4LossTableManager.hh.

Referenced by Instance().

◆ inv_range_vector

std::vector<G4PhysicsTable*> G4LossTableManager::inv_range_vector

private

Definition at line 267 of file G4LossTableManager.hh.

Referenced by BuildTables(), Clear(), CopyTables(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ isActive

std::vector<G4bool> G4LossTableManager::isActive

private

Definition at line 264 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), Clear(), LocalPhysicsTables(), and Register().

◆ isMaster

G4bool G4LossTableManager::isMaster

private

Definition at line 300 of file G4LossTableManager.hh.

Referenced by G4LossTableManager(), IsMaster(), PreparePhysicsTable(), and ResetParameters().

◆ loss_map

std::map<PD,G4VEnergyLossProcess*,std::less<PD> > G4LossTableManager::loss_map

private

Definition at line 258 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), Clear(), CopyTables(), GetEnergyLossProcess(), and LocalPhysicsTables().

◆ loss_vector

std::vector<G4VEnergyLossProcess*> G4LossTableManager::loss_vector

private

Definition at line 260 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), Clear(), CopyTables(), DeRegister(), GetEnergyLossProcessVector(), LocalPhysicsTables(), PreparePhysicsTable(), Register(), RegisterExtraParticle(), and ~G4LossTableManager().

◆ mod_vector

std::vector<G4VEmModel*> G4LossTableManager::mod_vector

private

Definition at line 270 of file G4LossTableManager.hh.

Referenced by DeRegister(), Register(), and ~G4LossTableManager().

◆ msc_vector

std::vector<G4VMultipleScattering*> G4LossTableManager::msc_vector

private

Definition at line 268 of file G4LossTableManager.hh.

Referenced by DeRegister(), GetMultipleScatteringVector(), Register(), and ~G4LossTableManager().

◆ n_loss

G4int G4LossTableManager::n_loss

private

Definition at line 295 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), Clear(), CopyTables(), DeRegister(), G4LossTableManager(), LocalPhysicsTables(), PreparePhysicsTable(), Register(), RegisterExtraParticle(), and ~G4LossTableManager().

◆ nielCalculator

G4NIELCalculator* G4LossTableManager::nielCalculator

private

Definition at line 285 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), G4LossTableManager(), NIELCalculator(), SetNIELCalculator(), and ~G4LossTableManager().

◆ p_vector

std::vector<G4VProcess*> G4LossTableManager::p_vector

private

Definition at line 272 of file G4LossTableManager.hh.

Referenced by DeRegister(), Register(), and ~G4LossTableManager().

◆ part_vector

std::vector<PD> G4LossTableManager::part_vector

private

Definition at line 261 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), Clear(), CopyTables(), LocalPhysicsTables(), PreparePhysicsTable(), Register(), and RegisterExtraParticle().

◆ pGeneral

G4VEmProcess* G4LossTableManager::pGeneral

private

Definition at line 292 of file G4LossTableManager.hh.

Referenced by G4LossTableManager(), and SetPositronGeneralProcess().

◆ range_vector

std::vector<G4PhysicsTable*> G4LossTableManager::range_vector

private

Definition at line 266 of file G4LossTableManager.hh.

Referenced by BuildTables(), Clear(), CopyTables(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ run

G4int G4LossTableManager::run

private

Definition at line 296 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), and LocalPhysicsTables().

◆ startInitialisation

G4bool G4LossTableManager::startInitialisation

private

Definition at line 299 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), G4LossTableManager(), LocalPhysicsTables(), and PreparePhysicsTable().

◆ subcutProducer

G4VSubCutProducer* G4LossTableManager::subcutProducer

private

Definition at line 287 of file G4LossTableManager.hh.

Referenced by BuildTables(), G4LossTableManager(), SetSubCutProducer(), SubCutProducer(), and ~G4LossTableManager().

◆ tableBuilder

G4LossTableBuilder* G4LossTableManager::tableBuilder

private

Definition at line 281 of file G4LossTableManager.hh.

Referenced by BuildTables(), G4LossTableManager(), GetTableBuilder(), ResetParameters(), and ~G4LossTableManager().

◆ tables_are_built

std::vector<G4bool> G4LossTableManager::tables_are_built

private

Definition at line 263 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), Clear(), CopyTables(), LocalPhysicsTables(), Register(), and RegisterExtraParticle().

◆ theElectron

PD G4LossTableManager::theElectron

private

Definition at line 277 of file G4LossTableManager.hh.

Referenced by CopyTables(), and G4LossTableManager().

◆ theGenericIon

PD G4LossTableManager::theGenericIon

private

Definition at line 278 of file G4LossTableManager.hh.

Referenced by G4LossTableManager(), GetEnergyLossProcess(), and PreparePhysicsTable().

◆ theParameters

G4EmParameters* G4LossTableManager::theParameters

private

Definition at line 289 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), EmSaturation(), G4LossTableManager(), and ResetParameters().

◆ verbose

G4int G4LossTableManager::verbose

private

Definition at line 294 of file G4LossTableManager.hh.

Referenced by BuildPhysicsTable(), BuildTables(), CopyTables(), ElectronIonPair(), EmConfigurator(), G4LossTableManager(), LocalPhysicsTables(), NIELCalculator(), PreparePhysicsTable(), Register(), RegisterExtraParticle(), ResetParameters(), and SetVerbose().

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

source/processes/electromagnetic/utils/include/G4LossTableManager.hh
source/processes/electromagnetic/utils/src/G4LossTableManager.cc

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ PD

Constructor & Destructor Documentation

◆ ~G4LossTableManager()

◆ G4LossTableManager() [1/2]

◆ G4LossTableManager() [2/2]

Member Function Documentation

◆ AtomDeexcitation()

◆ BuildPhysicsTable() [1/2]

◆ BuildPhysicsTable() [2/2]

◆ BuildTables()

◆ Clear()

◆ CopyDEDXTables()

◆ CopyTables()

◆ DeRegister() [1/6]

◆ DeRegister() [2/6]

◆ DeRegister() [3/6]

◆ DeRegister() [4/6]

◆ DeRegister() [5/6]

◆ DeRegister() [6/6]

◆ DumpHtml()

◆ ElectronIonPair()

◆ EmConfigurator()

◆ EmCorrections()

◆ EmSaturation()

◆ GetCSDARange()

◆ GetDEDX()

◆ GetDEDXDispersion()

◆ GetElectronGeneralProcess()

◆ GetEmProcessVector()

◆ GetEnergy()

◆ GetEnergyLossProcess()

◆ GetEnergyLossProcessVector()

◆ GetGammaGeneralProcess()

◆ GetMultipleScatteringVector()

◆ GetPositronGeneralProcess()

◆ GetRange()

◆ GetRangeFromRestricteDEDX()

◆ GetTableBuilder()

◆ Instance()

◆ IsMaster()

◆ LocalPhysicsTables()

◆ NIELCalculator()

◆ operator=()

◆ ParticleHaveNoLoss()

◆ PreparePhysicsTable() [1/3]

◆ PreparePhysicsTable() [2/3]

◆ PreparePhysicsTable() [3/3]

◆ PrintEWarning()

◆ Register() [1/6]

◆ Register() [2/6]

◆ Register() [3/6]

◆ Register() [4/6]

◆ Register() [5/6]

◆ Register() [6/6]

◆ RegisterExtraParticle()

◆ ResetParameters()

◆ SetAtomDeexcitation()

◆ SetElectronGeneralProcess()

◆ SetGammaGeneralProcess()

◆ SetNIELCalculator()

◆ SetPositronGeneralProcess()

◆ SetSubCutProducer()

◆ SetVerbose()

◆ SubCutProducer()

Friends And Related Function Documentation

◆ G4ThreadLocalSingleton< G4LossTableManager >

Field Documentation

◆ all_tables_are_built

◆ atomDeexcitation

◆ base_part_vector

◆ currentLoss