G4LossTableManager Class Reference

#include <G4LossTableManager.hh>

Public Member Functions
	~G4LossTableManager ()
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)
void	DumpHtml ()
G4double	GetDEDX (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 (G4VProcess *p)
void	DeRegister (G4VProcess *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	SetVerbose (G4int val)
void	ResetParameters ()
void	SetAtomDeexcitation (G4VAtomDeexcitation *)
void	SetSubCutProducer (G4VSubCutProducer *)
void	SetNIELCalculator (G4NIELCalculator *)
G4bool	IsMaster () const
G4VEnergyLossProcess *	GetEnergyLossProcess (const G4ParticleDefinition *)
const std::vector< G4VEnergyLossProcess * > &	GetEnergyLossProcessVector ()
const std::vector< G4VEmProcess * > &	GetEmProcessVector ()
const std::vector< G4VMultipleScattering * > &	GetMultipleScatteringVector ()
G4EmSaturation *	EmSaturation ()
G4EmConfigurator *	EmConfigurator ()
G4ElectronIonPair *	ElectronIonPair ()
G4NIELCalculator *	NIELCalculator ()
G4EmCorrections *	EmCorrections ()
G4VAtomDeexcitation *	AtomDeexcitation ()
G4VSubCutProducer *	SubCutProducer ()
G4LossTableBuilder *	GetTableBuilder ()
void	SetGammaGeneralProcess (G4VEmProcess *)
G4VEmProcess *	GetGammaGeneralProcess ()
void	SetElectronGeneralProcess (G4VEmProcess *)
G4VEmProcess *	GetElectronGeneralProcess ()
void	SetPositronGeneralProcess (G4VEmProcess *)
G4VEmProcess *	GetPositronGeneralProcess ()
	G4LossTableManager (G4LossTableManager &)=delete
G4LossTableManager &	operator= (const G4LossTableManager &right)=delete

Static Public Member Functions
static G4LossTableManager *	Instance ()

Friends
class	G4ThreadLocalSingleton< G4LossTableManager >

Detailed Description

Definition at line 77 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]; 
  }
  std::size_t msc = msc_vector.size();
  for (std::size_t j=0; j<msc; ++j) {
    delete msc_vector[j];
  }
  std::size_t emp = emp_vector.size();
  for (std::size_t k=0; k<emp; ++k) {
    delete emp_vector[k];
  }
  emp = p_vector.size();
  for (std::size_t k=0; k<emp; ++k) {
    delete p_vector[k];
  }
  std::size_t mod = mod_vector.size();
  std::size_t fmod = fmod_vector.size();
  //G4cout << "   Nmod" << mod << "  Nfluc= " << fmod << G4endl;
  for (std::size_t a=0; a<mod; ++a) {
    //G4cout << "Delete model #" << a << "  " <<  mod_vector[a] << G4endl;
    if( nullptr != mod_vector[a] ) { 
      for (std::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 (std::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;
}

G4LossTableManager()

G4LossTableManager::G4LossTableManager ( G4LossTableManager &  )

delete

Member Function Documentation

AtomDeexcitation()

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation ( )

inline

Definition at line 389 of file G4LossTableManager.hh.

{
  return atomDeexcitation;
}

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4EmCalculator::ComputeShellIonisationCrossSectionPerAtom(), LBE::ConstructGeneral(), G4RadioactiveDecayPhysics::ConstructProcess(), G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), G4EmCalculator::GetShellIonisationCrossSectionPerAtom(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4LivermorePolarizedComptonModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LowEPPolarizedComptonModel::Initialise(), G4MicroElecInelasticModel::Initialise(), G4MicroElecInelasticModel_new::Initialise(), G4PenelopeComptonModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4KleinNishinaModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4DNABornIonisationModel1::Initialise(), G4DNABornIonisationModel2::Initialise(), G4DNACPA100IonisationModel::Initialise(), G4DNAEmfietzoglouIonisationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), G4DNARPWBAIonisationModel::Initialise(), G4EmBuilder::PrepareEMPhysics(), and G4VEmProcess::PreparePhysicsTable().

BuildPhysicsTable() [1/2]

void G4LossTableManager::BuildPhysicsTable

(

const G4ParticleDefinition *

aParticle

)

Definition at line 537 of file G4LossTableManager.cc.

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

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

BuildPhysicsTable() [2/2]

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

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

DeRegister() [1/6]

void G4LossTableManager::DeRegister

(

G4VEmFluctuationModel *

p

)

Definition at line 380 of file G4LossTableManager.cc.

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

DeRegister() [2/6]

void G4LossTableManager::DeRegister

(

G4VEmModel *

p

)

Definition at line 355 of file G4LossTableManager.cc.

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

DeRegister() [3/6]

void G4LossTableManager::DeRegister

(

G4VEmProcess *

p

)

Definition at line 300 of file G4LossTableManager.cc.

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

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

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; }
  std::size_t msc = msc_vector.size();
  for (std::size_t i=0; i<msc; ++i) {
    if(msc_vector[i] == p) { 
      msc_vector[i] = nullptr;
      break;
    }
  }
}

DeRegister() [6/6]

void G4LossTableManager::DeRegister

(

G4VProcess *

p

)

Definition at line 330 of file G4LossTableManager.cc.

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

DumpHtml()

void G4LossTableManager::DumpHtml

(

)

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

ElectronIonPair()

G4ElectronIonPair * G4LossTableManager::ElectronIonPair

(

)

Definition at line 1004 of file G4LossTableManager.cc.

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

EmConfigurator()

G4EmConfigurator * G4LossTableManager::EmConfigurator

(

)

Definition at line 994 of file G4LossTableManager.cc.

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

Referenced by G4TransportationWithMsc::PreparePhysicsTable().

EmCorrections()

G4EmCorrections * G4LossTableManager::EmCorrections ( )

inline

Definition at line 382 of file G4LossTableManager.hh.

{
  return emCorrections;
}

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

EmSaturation()

G4EmSaturation * G4LossTableManager::EmSaturation

(

)

Definition at line 987 of file G4LossTableManager.cc.

{
  return theParameters->GetEmSaturation();
}

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

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

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

GetElectronGeneralProcess()

G4VEmProcess * G4LossTableManager::GetElectronGeneralProcess ( )

inline

Definition at line 431 of file G4LossTableManager.hh.

{
  return eGeneral;
} 

GetEmProcessVector()

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

(

)

Definition at line 972 of file G4LossTableManager.cc.

{
  return emp_vector;
}

Referenced by DumpHtml().

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

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

GetEnergyLossProcess()

G4VEnergyLossProcess * G4LossTableManager::GetEnergyLossProcess

(

const G4ParticleDefinition *

aParticle

)

Definition at line 417 of file G4LossTableManager.cc.

{
  if(aParticle != currentParticle) {
    currentParticle = aParticle;
    std::map<PD,G4VEnergyLossProcess*,std::less<PD> >::const_iterator pos;
    if ((pos = loss_map.find(aParticle)) != loss_map.end()) {
      currentLoss = (*pos).second;
    } else {
      currentLoss = nullptr;
      if(0.0 != aParticle->GetPDGCharge() && 
     (pos = loss_map.find(theGenericIon)) != loss_map.end()) {
    currentLoss = (*pos).second;
      }
    }
  }
  return currentLoss;
}

Referenced by GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetRange(), GetRangeFromRestricteDEDX(), G4EmCalculator::PrintDEDXTable(), G4EmCalculator::PrintInverseRangeTable(), G4EmCalculator::PrintRangeTable(), G4VMultipleScattering::StartTracking(), and G4TransportationWithMsc::StartTracking().

GetEnergyLossProcessVector()

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

(

)

Definition at line 965 of file G4LossTableManager.cc.

{
  return loss_vector;
}

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

GetGammaGeneralProcess()

G4VEmProcess * G4LossTableManager::GetGammaGeneralProcess ( )

inline

Definition at line 417 of file G4LossTableManager.hh.

{
  return gGeneral;
} 

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

GetMultipleScatteringVector()

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

(

)

Definition at line 980 of file G4LossTableManager.cc.

{
  return msc_vector;
}

Referenced by DumpHtml().

GetPositronGeneralProcess()

G4VEmProcess * G4LossTableManager::GetPositronGeneralProcess ( )

inline

Definition at line 445 of file G4LossTableManager.hh.

{
  return pGeneral;
} 

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

Referenced by G4ITStepProcessor::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;
}

Referenced by G4EmCalculator::GetRangeFromRestricteDEDX().

GetTableBuilder()

G4LossTableBuilder * G4LossTableManager::GetTableBuilder ( )

inline

Definition at line 403 of file G4LossTableManager.hh.

{
  return 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(), G4TransportationWithMsc::PreparePhysicsTable(), and G4VEnergyLossProcess::SetLambdaTable().

Instance()

G4LossTableManager * G4LossTableManager::Instance ( )

static

Definition at line 87 of file G4LossTableManager.cc.

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

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4BertiniElectroNuclearBuilder::Build(), G4GammaGeneralProcess::BuildPhysicsTable(), G4EmCalculator::ComputeDEDXForCutInRange(), G4EmCalculator::ComputeElectronicDEDX(), LBE::ConstructGeneral(), G4RadioactiveDecayPhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4EmExtraPhysics::ConstructProcess(), G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4AtimaEnergyLossModel::G4AtimaEnergyLossModel(), G4BetheBlochModel::G4BetheBlochModel(), G4BraggModel::G4BraggModel(), G4EmCalculator::G4EmCalculator(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel(), G4ionIonisation::G4ionIonisation(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4LindhardSorensenIonModel::G4LindhardSorensenIonModel(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4NIELCalculator::G4NIELCalculator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransportationWithMsc::G4TransportationWithMsc(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4UrbanAdjointMscModel::G4UrbanAdjointMscModel(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4EnergyLossTables::GetDEDX(), G4VMscModel::GetParticleChangeForMSC(), G4EnergyLossTables::GetPreciseDEDX(), G4EnergyLossTables::GetPreciseEnergyFromRange(), G4EnergyLossTables::GetPreciseRangeFromEnergy(), G4EnergyLossTables::GetRange(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4LivermorePolarizedComptonModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LowEPPolarizedComptonModel::Initialise(), G4MicroElecInelasticModel::Initialise(), G4MicroElecInelasticModel_new::Initialise(), G4PenelopeComptonModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4BraggIonModel::Initialise(), G4KleinNishinaModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4DNABornIonisationModel1::Initialise(), G4DNABornIonisationModel2::Initialise(), G4DNACPA100IonisationModel::Initialise(), G4DNAEmfietzoglouIonisationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), G4DNARPWBAIonisationModel::Initialise(), G4GammaGeneralProcess::InitialiseProcess(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), G4EmBuilder::PrepareEMPhysics(), G4GammaGeneralProcess::PreparePhysicsTable(), and G4EmSaturation::VisibleEnergyDeposition().

IsMaster()

G4bool G4LossTableManager::IsMaster ( ) const

inline

Definition at line 375 of file G4LossTableManager.hh.

{
  return isMaster;
}

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

LocalPhysicsTables()

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

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

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

NIELCalculator()

G4NIELCalculator * G4LossTableManager::NIELCalculator

(

)

Definition at line 1024 of file G4LossTableManager.cc.

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

operator=()

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

delete

PreparePhysicsTable() [1/3]

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

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

PreparePhysicsTable() [2/3]

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

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

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

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

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

Register() [3/6]

void G4LossTableManager::Register

(

G4VEmProcess *

p

)

Definition at line 284 of file G4LossTableManager.cc.

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

Register() [4/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;
}

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; }
  std::size_t n = msc_vector.size();
  for (std::size_t 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);
}

Register() [6/6]

void G4LossTableManager::Register

(

G4VProcess *

p

)

Definition at line 314 of file G4LossTableManager.cc.

{
  if(!p) { return; }
  std::size_t n = p_vector.size();
  for (std::size_t 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);
}

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

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

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

SetAtomDeexcitation()

void G4LossTableManager::SetAtomDeexcitation

(

G4VAtomDeexcitation *

p

)

Definition at line 1034 of file G4LossTableManager.cc.

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

Referenced by LBE::ConstructGeneral(), G4RadioactiveDecayPhysics::ConstructProcess(), and G4EmBuilder::PrepareEMPhysics().

SetElectronGeneralProcess()

void G4LossTableManager::SetElectronGeneralProcess ( G4VEmProcess *  ptr )

inline

Definition at line 424 of file G4LossTableManager.hh.

{
  eGeneral = ptr;
} 

SetGammaGeneralProcess()

void G4LossTableManager::SetGammaGeneralProcess ( G4VEmProcess *  ptr )

inline

Definition at line 410 of file G4LossTableManager.hh.

{
  gGeneral = ptr;
} 

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 1014 of file G4LossTableManager.cc.

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

Referenced by G4NIELCalculator::G4NIELCalculator().

SetPositronGeneralProcess()

void G4LossTableManager::SetPositronGeneralProcess ( G4VEmProcess *  ptr )

inline

Definition at line 438 of file G4LossTableManager.hh.

{
  pGeneral = ptr;
} 

SetSubCutProducer()

void G4LossTableManager::SetSubCutProducer

(

G4VSubCutProducer *

p

)

Definition at line 1044 of file G4LossTableManager.cc.

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

SetVerbose()

void G4LossTableManager::SetVerbose

(

G4int

val

)

Definition at line 957 of file G4LossTableManager.cc.

{
  verbose = val;
}

SubCutProducer()

G4VSubCutProducer * G4LossTableManager::SubCutProducer ( )

inline

Definition at line 396 of file G4LossTableManager.hh.

{ 
  return 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.

---

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

• G4LossTableManager.hh
• G4LossTableManager.cc