#include <G4LossTableManager.hh>

Collaboration diagram for G4LossTableManager:

Public Member Functions
	~G4LossTableManager ()

void	Clear ()

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

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

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

void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)

void	BuildPhysicsTable (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	LocalPhysicsTables (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

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

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

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

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

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

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

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

void	Register (G4VEnergyLossProcess *p)

void	DeRegister (G4VEnergyLossProcess *p)

void	Register (G4VMultipleScattering *p)

void	DeRegister (G4VMultipleScattering *p)

void	Register (G4VEmProcess *p)

void	DeRegister (G4VEmProcess *p)

void	Register (G4VEmModel *p)

void	DeRegister (G4VEmModel *p)

void	Register (G4VEmFluctuationModel *p)

void	DeRegister (G4VEmFluctuationModel *p)

void	RegisterExtraParticle (const G4ParticleDefinition aParticle, G4VEnergyLossProcess p)

void	SetLossFluctuations (G4bool val)

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

void	SetIntegral (G4bool val)

void	SetRandomStep (G4bool val)

void	SetMinSubRange (G4double val)

void	SetMinEnergy (G4double val)

void	SetMaxEnergy (G4double val)

void	SetMaxEnergyForCSDARange (G4double val)

void	SetMaxEnergyForMuons (G4double val)

void	SetDEDXBinning (G4int val)

void	SetDEDXBinningForCSDARange (G4int val)

void	SetLambdaBinning (G4int val)

void	SetStepFunction (G4double v1, G4double v2)

void	SetBuildCSDARange (G4bool val)

void	SetLinearLossLimit (G4double val)

void	SetVerbose (G4int val)

void	SetAtomDeexcitation (G4VAtomDeexcitation *)

void	SetSubCutProducer (G4VSubCutProducer *)

G4EnergyLossMessenger *	GetMessenger ()

G4bool	BuildCSDARange () const

G4bool	IsMaster () const

G4double	MinKinEnergy () const

G4double	MaxKinEnergy () const

G4int	GetNumberOfBinsPerDecade () 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 ()

G4EmCorrections *	EmCorrections ()

G4VAtomDeexcitation *	AtomDeexcitation ()

G4VSubCutProducer *	SubCutProducer ()

G4LossTableBuilder *	GetTableBuilder ()

Static Public Member Functions
static G4LossTableManager *	Instance ()

Private Types
typedef const G4ParticleDefinition *	PD

Private Member Functions
	G4LossTableManager ()

void	ResetParameters ()

G4VEnergyLossProcess *	BuildTables (const G4ParticleDefinition *aParticle)

void	CopyTables (const G4ParticleDefinition aParticle, G4VEnergyLossProcess )

void	ParticleHaveNoLoss (const G4ParticleDefinition *aParticle)

void	SetParameters (const G4ParticleDefinition aParticle, G4VEnergyLossProcess )

void	CopyDEDXTables ()

void	PrintEWarning (G4String, G4double)

	G4LossTableManager (G4LossTableManager &)

G4LossTableManager &	operator= (const G4LossTableManager &right)

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

std::vector< G4VEnergyLossProcess * >	loss_vector

std::vector< PD >	part_vector

std::vector< PD >	base_part_vector

std::vector< G4bool >	tables_are_built

std::vector< G4bool >	isActive

std::vector< G4PhysicsTable * >	dedx_vector

std::vector< G4PhysicsTable * >	range_vector

std::vector< G4PhysicsTable * >	inv_range_vector

std::vector< G4VMultipleScattering * >	msc_vector

std::vector< G4VEmProcess * >	emp_vector

std::vector< G4VEmModel * >	mod_vector

std::vector< G4VEmFluctuationModel * >	fmod_vector

G4VEnergyLossProcess *	currentLoss

PD	currentParticle

PD	theElectron

PD	theGenericIon

PD	firstParticle

G4int	n_loss

G4int	run

G4bool	all_tables_are_built

G4bool	startInitialisation

G4bool	subCutoffFlag

G4bool	integral

G4bool	integralActive

G4bool	stepFunctionActive

G4bool	isMaster

G4double	maxRangeVariation

G4double	maxFinalStep

G4LossTableBuilder *	tableBuilder

G4EnergyLossMessenger *	theMessenger

G4EmCorrections *	emCorrections

G4EmSaturation *	emSaturation

G4EmConfigurator *	emConfigurator

G4ElectronIonPair *	emElectronIonPair

G4VAtomDeexcitation *	atomDeexcitation

G4VSubCutProducer *	subcutProducer

G4EmParameters *	theParameters

G4int	verbose

Static Private Attributes
static G4ThreadLocal G4LossTableManager *	instance = 0

Friends
class	G4ThreadLocalSingleton< G4LossTableManager >

Detailed Description

Definition at line 102 of file G4LossTableManager.hh.

Member Typedef Documentation

◆ PD

typedef const G4ParticleDefinition* G4LossTableManager::PD

private

Definition at line 311 of file G4LossTableManager.hh.

Constructor & Destructor Documentation

◆ ~G4LossTableManager()

G4LossTableManager::~G4LossTableManager ( )

Definition at line 123 of file G4LossTableManager.cc.

 {
   //G4cout << "### G4LossTableManager::~G4LossTableManager()" << G4endl;
   for (G4int i=0; i<n_loss; ++i) {
     //G4cout << "### eloss #" << i << G4endl;
     if( loss_vector[i] ) { 
       delete loss_vector[i]; 
     }
   }
   size_t msc = msc_vector.size();
   for (size_t j=0; j<msc; ++j) {
     if( msc_vector[j] ) { delete msc_vector[j]; }
   }
   size_t emp = emp_vector.size();
   for (size_t k=0; k<emp; ++k) {
     if( emp_vector[k] ) { delete emp_vector[k]; }
   }
   size_t mod = mod_vector.size();
   size_t fmod = fmod_vector.size();
   for (size_t a=0; a<mod; ++a) {
     if( mod_vector[a] ) { 
       for (size_t b=0; b<fmod; ++b) {
         if((G4VEmModel*)(fmod_vector[b]) == mod_vector[a]) {
           fmod_vector[b] = 0;
         }
       }
       delete mod_vector[a]; 
     }
   }
   for (size_t b=0; b<fmod; ++b) {
     if( fmod_vector[b] ) { delete fmod_vector[b]; }
   }
   Clear();
   delete theMessenger;
   delete tableBuilder;
   delete emCorrections;
   delete emSaturation;
   delete emConfigurator;
   delete emElectronIonPair;
   delete atomDeexcitation;
   delete subcutProducer;
 }

Here is the call graph for this function:

◆ G4LossTableManager() [1/2]

G4LossTableManager::G4LossTableManager ( )

private

Definition at line 168 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;
   subCutoffFlag = false;
   maxRangeVariation = 0.2;
   maxFinalStep = CLHEP::mm;
   integral = true;
   integralActive = false;
   stepFunctionActive = false;
   isMaster = true;
   verbose = theParameters->Verbose();
   theMessenger = new G4EnergyLossMessenger();
   theElectron  = G4Electron::Electron();
   theGenericIon= nullptr;
   if(G4Threading::IsWorkerThread()) { 
     verbose = theParameters->WorkerVerbose();
     isMaster = false;
   }  
   tableBuilder = new G4LossTableBuilder();
   emCorrections= new G4EmCorrections(verbose);
   emSaturation = nullptr;
   emConfigurator = nullptr;
   emElectronIonPair = nullptr;
   atomDeexcitation = nullptr;
   subcutProducer = nullptr;
 }

Here is the call graph for this function:

◆ G4LossTableManager() [2/2]

G4LossTableManager::G4LossTableManager ( G4LossTableManager & )

private

Member Function Documentation

◆ AtomDeexcitation()

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation ( )

inline

Definition at line 528 of file G4LossTableManager.hh.

 {
   return atomDeexcitation;
 }

Here is the caller graph for this function:

◆ BuildCSDARange()

G4bool G4LossTableManager::BuildCSDARange ( ) const

inline

Definition at line 486 of file G4LossTableManager.hh.

 {
   return theParameters->BuildCSDARange();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable() [1/2]

void G4LossTableManager::BuildPhysicsTable ( const G4ParticleDefinition * aParticle )

Definition at line 506 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable() [2/2]

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

Definition at line 600 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 initilisation for first particle "
              << firstParticle->GetParticleName() 
              << G4endl;
     }
     for (G4int i=0; i<n_loss; ++i) {
       G4VEnergyLossProcess* el = loss_vector[i];
 
       if(el) {
         isActive[i] = true;
         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;
       }
     }
   }
 
   // Set run time parameters 
   SetParameters(aParticle, p);
 
   if (all_tables_are_built) { return; }
 
   // Build tables for given particle
   all_tables_are_built = true;
 
   for(G4int i=0; i<n_loss; ++i) {
     if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
       const G4ParticleDefinition* curr_part = part_vector[i];
       if(1 < verbose) {
         G4cout << "### Build Table for " << p->GetProcessName()
                << " and " << curr_part->GetParticleName() 
            << "  " << 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;
     }
   }
 }

Here is the call graph for this function:

◆ BuildTables()

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

private

Definition at line 753 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 = 0;
   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, true);
   tableBuilder->BuildInverseRangeTable(range, invrange, true);
 
   //  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 (0 < nSubRegions) {
       dedx = p->BuildDEDXTable(fSubRestricted);
       p->SetDEDXTable(dedx,fSubRestricted);
       listSub.push_back(dedx);
       if(build_flags[i]) {
         p->SetSubLambdaTable(p->BuildLambdaTable(fSubRestricted));
         if(p != em) { em->AddCollaborativeProcess(p); }
       }
     }
     if(theParameters->BuildCSDARange()) { 
       dedx = p->BuildDEDXTable(fTotal);
       p->SetDEDXTable(dedx,fTotal);
       listCSDA.push_back(dedx); 
     }     
   }
 
   if (0 < nSubRegions) {
     G4PhysicsTable* dedxSub = em->IonisationTableForSubsec();
     if (1 < listSub.size()) {
       em->SetDEDXTable(dedxSub, fIsSubIonisation);
       dedxSub = 0;
       dedxSub = G4PhysicsTableHelper::PreparePhysicsTable(dedxSub);
       tableBuilder->BuildDEDXTable(dedxSub, listSub);
       em->SetDEDXTable(dedxSub, fSubRestricted);
     }
   }
   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, true);
     em->SetCSDARangeTable(rCSDA);
   }
 
   if (1 < verbose) {
     G4cout << "G4LossTableManager::BuildTables: Tables are built for "
            << aParticle->GetParticleName()
            << "; ionisation process: " << em->GetProcessName()
            << "  " << em
            << G4endl;
   }
   return em;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clear()

void G4LossTableManager::Clear ( )

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

Here is the caller graph for this function:

◆ CopyDEDXTables()

void G4LossTableManager::CopyDEDXTables ( )

private

◆ CopyTables()

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

private

Definition at line 711 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->DEDXTableForSubsec(),fSubRestricted);
       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->SetSubLambdaTable(base_proc->SubLambdaTable());
       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());
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeRegister() [1/5]

void G4LossTableManager::DeRegister ( G4VEnergyLossProcess * p )

Definition at line 274 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

◆ DeRegister() [2/5]

void G4LossTableManager::DeRegister ( G4VMultipleScattering * p )

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

◆ DeRegister() [3/5]

void G4LossTableManager::DeRegister ( G4VEmProcess * p )

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

◆ DeRegister() [4/5]

void G4LossTableManager::DeRegister ( G4VEmModel * p )

Definition at line 349 of file G4LossTableManager.cc.

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

◆ DeRegister() [5/5]

void G4LossTableManager::DeRegister ( G4VEmFluctuationModel * p )

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

◆ ElectronIonPair()

G4ElectronIonPair * G4LossTableManager::ElectronIonPair ( )

Definition at line 1136 of file G4LossTableManager.cc.

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

◆ EmConfigurator()

G4EmConfigurator * G4LossTableManager::EmConfigurator ( )

Definition at line 1128 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

◆ EmCorrections()

G4EmCorrections * G4LossTableManager::EmCorrections ( )

inline

Definition at line 521 of file G4LossTableManager.hh.

 {
   return emCorrections;
 }

Here is the caller graph for this function:

◆ EmSaturation()

G4EmSaturation * G4LossTableManager::EmSaturation ( )

Definition at line 1120 of file G4LossTableManager.cc.

 {
   if(!emSaturation) { emSaturation = new G4EmSaturation(verbose); }
   return emSaturation;
 }

Here is the caller graph for this function:

◆ GetCSDARange()

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

inline

Definition at line 417 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDEDX()

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

inline

Definition at line 391 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDEDXDispersion()

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

inline

Definition at line 472 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

◆ GetEmProcessVector()

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

Definition at line 1105 of file G4LossTableManager.cc.

 {
   return emp_vector;
 }

Here is the caller graph for this function:

◆ GetEnergy()

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

inline

Definition at line 459 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEnergyLossProcess()

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

inline

Definition at line 369 of file G4LossTableManager.hh.

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

Here is the caller graph for this function:

◆ GetEnergyLossProcessVector()

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

Definition at line 1098 of file G4LossTableManager.cc.

 {
   return loss_vector;
 }

Here is the caller graph for this function:

◆ GetMessenger()

G4EnergyLossMessenger * G4LossTableManager::GetMessenger ( )

Definition at line 938 of file G4LossTableManager.cc.

 {
   return theMessenger;
 }

◆ GetMultipleScatteringVector()

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

Definition at line 1113 of file G4LossTableManager.cc.

 {
   return msc_vector;
 }

Here is the caller graph for this function:

◆ GetNumberOfBinsPerDecade()

G4int G4LossTableManager::GetNumberOfBinsPerDecade ( ) const

inline

Definition at line 514 of file G4LossTableManager.hh.

 {
   return theParameters->NumberOfBinsPerDecade();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRange()

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

inline

Definition at line 444 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRangeFromRestricteDEDX()

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

inline

Definition at line 430 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSubDEDX()

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

inline

Definition at line 404 of file G4LossTableManager.hh.

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

Here is the call graph for this function:

◆ GetTableBuilder()

G4LossTableBuilder * G4LossTableManager::GetTableBuilder ( )

inline

Definition at line 542 of file G4LossTableManager.hh.

 {
   return tableBuilder;
 }

Here is the caller graph for this function:

◆ Instance()

G4LossTableManager * G4LossTableManager::Instance ( void )

static

Definition at line 112 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

◆ IsMaster()

G4bool G4LossTableManager::IsMaster ( ) const

inline

Definition at line 493 of file G4LossTableManager.hh.

 {
   return isMaster;
 }

Here is the caller graph for this function:

◆ LocalPhysicsTables()

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

Definition at line 515 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;
     SetVerbose(verbose);
     if(1 < verbose) {
       G4cout << "===== G4LossTableManager::LocalPhysicsTable() for run "
              << run << " =====" << G4endl;
     }
     if(0 < verbose) { emSaturation->DumpG4BirksCoefficients(); }
     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;
     }
   }
 
   // Set run time parameters 
   SetParameters(aParticle, p);
 
   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;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MaxKinEnergy()

G4double G4LossTableManager::MaxKinEnergy ( ) const

inline

Definition at line 507 of file G4LossTableManager.hh.

 {
   return theParameters->MaxKinEnergy();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MinKinEnergy()

G4double G4LossTableManager::MinKinEnergy ( ) const

inline

Definition at line 500 of file G4LossTableManager.hh.

 {
   return theParameters->MinKinEnergy();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

private

◆ ParticleHaveNoLoss()

void G4LossTableManager::ParticleHaveNoLoss ( const G4ParticleDefinition * aParticle )

private

Definition at line 945 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

◆ PreparePhysicsTable() [1/3]

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreparePhysicsTable() [2/3]

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

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

Here is the call graph for this function:

◆ PreparePhysicsTable() [3/3]

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

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

Here is the call graph for this function:

◆ PrintEWarning()

void G4LossTableManager::PrintEWarning	(	G4String	tit,
		G4double
	)

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Register() [1/5]

void G4LossTableManager::Register ( G4VEnergyLossProcess * p )

Definition at line 226 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;
   if(subCutoffFlag)        { p->ActivateSubCutoff(true); }
   if(stepFunctionActive)   { p->SetStepFunction(maxRangeVariation, 
                                                 maxFinalStep); }
   if(integralActive)       { p->SetIntegral(integral); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Register() [2/5]

void G4LossTableManager::Register ( G4VMultipleScattering * p )

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

Here is the call graph for this function:

◆ Register() [3/5]

void G4LossTableManager::Register ( G4VEmProcess * p )

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

Here is the call graph for this function:

◆ Register() [4/5]

void G4LossTableManager::Register ( G4VEmModel * p )

Definition at line 338 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

◆ Register() [5/5]

void G4LossTableManager::Register ( G4VEmFluctuationModel * p )

Definition at line 359 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

◆ RegisterExtraParticle()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetParameters()

void G4LossTableManager::ResetParameters ( )

private

Definition at line 254 of file G4LossTableManager.cc.

 {
   verbose = theParameters->Verbose();
   if(!isMaster) {
     verbose = theParameters->WorkerVerbose();
   }
   tableBuilder->SetSplineFlag(theParameters->Spline());
   tableBuilder->SetInitialisationFlag(false); 
   emCorrections->SetVerbose(verbose); 
   if(emSaturation) { emSaturation->SetVerbose(verbose); } 
   if(emConfigurator) { emConfigurator->SetVerbose(verbose); };
   if(emElectronIonPair) { emElectronIonPair->SetVerbose(verbose); };
   if(atomDeexcitation) {
     atomDeexcitation->SetVerboseLevel(verbose);
     atomDeexcitation->InitialiseAtomicDeexcitation();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAtomDeexcitation()

void G4LossTableManager::SetAtomDeexcitation ( G4VAtomDeexcitation * p )

Definition at line 1146 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

◆ SetBuildCSDARange()

void G4LossTableManager::SetBuildCSDARange ( G4bool val )

Definition at line 1078 of file G4LossTableManager.cc.

1079 {

1080 }

Here is the caller graph for this function:

◆ SetDEDXBinning()

void G4LossTableManager::SetDEDXBinning ( G4int val )

Definition at line 1028 of file G4LossTableManager.cc.

 {
   theParameters->SetNumberOfBins(val);
 }

Here is the call graph for this function:

◆ SetDEDXBinningForCSDARange()

void G4LossTableManager::SetDEDXBinningForCSDARange ( G4int val )

Definition at line 1035 of file G4LossTableManager.cc.

1036 {

1037 }

◆ SetIntegral()

void G4LossTableManager::SetIntegral ( G4bool val )

Definition at line 973 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

◆ SetLambdaBinning()

void G4LossTableManager::SetLambdaBinning ( G4int val )

Definition at line 1041 of file G4LossTableManager.cc.

 {
   theParameters->SetNumberOfBins(val);
 }

Here is the call graph for this function:

◆ SetLinearLossLimit()

void G4LossTableManager::SetLinearLossLimit ( G4double val )

Definition at line 1072 of file G4LossTableManager.cc.

1073 {

1074 }

Here is the caller graph for this function:

◆ SetLossFluctuations()

void G4LossTableManager::SetLossFluctuations ( G4bool val )

Definition at line 957 of file G4LossTableManager.cc.

958 {

959 }

Here is the caller graph for this function:

◆ SetMaxEnergy()

void G4LossTableManager::SetMaxEnergy ( G4double val )

Definition at line 1007 of file G4LossTableManager.cc.

 {
   theParameters->SetMaxEnergy(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaxEnergyForCSDARange()

void G4LossTableManager::SetMaxEnergyForCSDARange ( G4double val )

Definition at line 1014 of file G4LossTableManager.cc.

 {
   theParameters->SetMaxEnergyForCSDARange(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaxEnergyForMuons()

void G4LossTableManager::SetMaxEnergyForMuons ( G4double val )

Definition at line 1021 of file G4LossTableManager.cc.

 {
   theParameters->SetMaxEnergy(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMinEnergy()

void G4LossTableManager::SetMinEnergy ( G4double val )

Definition at line 1000 of file G4LossTableManager.cc.

 {
   theParameters->SetMinEnergy(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMinSubRange()

void G4LossTableManager::SetMinSubRange ( G4double val )

Definition at line 988 of file G4LossTableManager.cc.

989 {

990 }

Here is the caller graph for this function:

◆ SetParameters()

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

private

Definition at line 1085 of file G4LossTableManager.cc.

 {
   if(stepFunctionActive) { 
     p->SetStepFunction(maxRangeVariation, maxFinalStep); 
   }
   if(integralActive)     { p->SetIntegral(integral); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetRandomStep()

void G4LossTableManager::SetRandomStep ( G4bool val )

Definition at line 994 of file G4LossTableManager.cc.

995 {

996 }

Here is the caller graph for this function:

◆ SetStepFunction()

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

Definition at line 1054 of file G4LossTableManager.cc.

 {
   if(0.0 < v1 && 0.0 < v2 && v2 < 1.e+50) { 
     stepFunctionActive = true;
     maxRangeVariation = v1;
     maxFinalStep = v2;
     for(G4int i=0; i<n_loss; ++i) {
       if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
     }
   } else if(v1 <= 0.0) {
     PrintEWarning("SetStepFunction", v1); 
   } else {
     PrintEWarning("SetStepFunction", v2); 
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSubCutoff()

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

Definition at line 963 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

◆ SetSubCutProducer()

void G4LossTableManager::SetSubCutProducer ( G4VSubCutProducer * p )

Definition at line 1156 of file G4LossTableManager.cc.

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

◆ SetVerbose()

void G4LossTableManager::SetVerbose ( G4int val )

Definition at line 1048 of file G4LossTableManager.cc.

1049 {

1050 }

Here is the caller graph for this function:

◆ SubCutProducer()

G4VSubCutProducer * G4LossTableManager::SubCutProducer ( )

inline

Definition at line 535 of file G4LossTableManager.hh.

 { 
   return subcutProducer;
 }

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ G4ThreadLocalSingleton< G4LossTableManager >

friend class G4ThreadLocalSingleton< G4LossTableManager >

friend

Definition at line 105 of file G4LossTableManager.hh.

Member Data Documentation

◆ all_tables_are_built

G4bool G4LossTableManager::all_tables_are_built

private

Definition at line 338 of file G4LossTableManager.hh.

◆ atomDeexcitation

G4VAtomDeexcitation* G4LossTableManager::atomDeexcitation

private

Definition at line 356 of file G4LossTableManager.hh.

◆ base_part_vector

std::vector<PD> G4LossTableManager::base_part_vector

private

Definition at line 317 of file G4LossTableManager.hh.

◆ currentLoss

G4VEnergyLossProcess* G4LossTableManager::currentLoss

private

Definition at line 329 of file G4LossTableManager.hh.

◆ currentParticle

PD G4LossTableManager::currentParticle

private

Definition at line 330 of file G4LossTableManager.hh.

◆ dedx_vector

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

private

Definition at line 320 of file G4LossTableManager.hh.

◆ emConfigurator

G4EmConfigurator* G4LossTableManager::emConfigurator

private

Definition at line 354 of file G4LossTableManager.hh.

◆ emCorrections

G4EmCorrections* G4LossTableManager::emCorrections

private

Definition at line 352 of file G4LossTableManager.hh.

◆ emElectronIonPair

G4ElectronIonPair* G4LossTableManager::emElectronIonPair

private

Definition at line 355 of file G4LossTableManager.hh.

◆ emp_vector

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

private

Definition at line 324 of file G4LossTableManager.hh.

◆ emSaturation

G4EmSaturation* G4LossTableManager::emSaturation

private

Definition at line 353 of file G4LossTableManager.hh.

◆ firstParticle

PD G4LossTableManager::firstParticle

private

Definition at line 333 of file G4LossTableManager.hh.

◆ fmod_vector

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

private

Definition at line 326 of file G4LossTableManager.hh.

◆ instance

G4ThreadLocal G4LossTableManager * G4LossTableManager::instance = 0

staticprivate

Definition at line 309 of file G4LossTableManager.hh.

◆ integral

G4bool G4LossTableManager::integral

private

Definition at line 342 of file G4LossTableManager.hh.

◆ integralActive

G4bool G4LossTableManager::integralActive

private

Definition at line 343 of file G4LossTableManager.hh.

◆ inv_range_vector

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

private

Definition at line 322 of file G4LossTableManager.hh.

◆ isActive

std::vector<G4bool> G4LossTableManager::isActive

private

Definition at line 319 of file G4LossTableManager.hh.

◆ isMaster

G4bool G4LossTableManager::isMaster

private

Definition at line 345 of file G4LossTableManager.hh.

◆ loss_map

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

private

Definition at line 313 of file G4LossTableManager.hh.

◆ loss_vector

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

private

Definition at line 315 of file G4LossTableManager.hh.

◆ maxFinalStep

G4double G4LossTableManager::maxFinalStep

private

Definition at line 348 of file G4LossTableManager.hh.

◆ maxRangeVariation

G4double G4LossTableManager::maxRangeVariation

private

Definition at line 347 of file G4LossTableManager.hh.

◆ mod_vector

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

private

Definition at line 325 of file G4LossTableManager.hh.

◆ msc_vector

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

private

Definition at line 323 of file G4LossTableManager.hh.

◆ n_loss

G4int G4LossTableManager::n_loss

private

Definition at line 335 of file G4LossTableManager.hh.

◆ part_vector

std::vector<PD> G4LossTableManager::part_vector

private

Definition at line 316 of file G4LossTableManager.hh.

◆ range_vector

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

private

Definition at line 321 of file G4LossTableManager.hh.

◆ run

G4int G4LossTableManager::run

private

Definition at line 336 of file G4LossTableManager.hh.

◆ startInitialisation

G4bool G4LossTableManager::startInitialisation

private

Definition at line 339 of file G4LossTableManager.hh.

◆ stepFunctionActive

G4bool G4LossTableManager::stepFunctionActive

private

Definition at line 344 of file G4LossTableManager.hh.

◆ subCutoffFlag

G4bool G4LossTableManager::subCutoffFlag

private

Definition at line 341 of file G4LossTableManager.hh.

◆ subcutProducer

G4VSubCutProducer* G4LossTableManager::subcutProducer

private

Definition at line 357 of file G4LossTableManager.hh.

◆ tableBuilder

G4LossTableBuilder* G4LossTableManager::tableBuilder

private

Definition at line 350 of file G4LossTableManager.hh.

◆ tables_are_built

std::vector<G4bool> G4LossTableManager::tables_are_built

private

Definition at line 318 of file G4LossTableManager.hh.

◆ theElectron

PD G4LossTableManager::theElectron

private

Definition at line 331 of file G4LossTableManager.hh.

◆ theGenericIon

PD G4LossTableManager::theGenericIon

private

Definition at line 332 of file G4LossTableManager.hh.

◆ theMessenger

G4EnergyLossMessenger* G4LossTableManager::theMessenger

private

Definition at line 351 of file G4LossTableManager.hh.

◆ theParameters

G4EmParameters* G4LossTableManager::theParameters

private

Definition at line 359 of file G4LossTableManager.hh.

◆ verbose

G4int G4LossTableManager::verbose

private

Definition at line 361 of file G4LossTableManager.hh.

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

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

◆ BuildCSDARange()

◆ BuildPhysicsTable() [1/2]

◆ BuildPhysicsTable() [2/2]

◆ BuildTables()

◆ Clear()

◆ CopyDEDXTables()

◆ CopyTables()

◆ DeRegister() [1/5]

◆ DeRegister() [2/5]

◆ DeRegister() [3/5]

◆ DeRegister() [4/5]

◆ DeRegister() [5/5]

◆ ElectronIonPair()

◆ EmConfigurator()

◆ EmCorrections()

◆ EmSaturation()

◆ GetCSDARange()

◆ GetDEDX()

◆ GetDEDXDispersion()

◆ GetEmProcessVector()

◆ GetEnergy()

◆ GetEnergyLossProcess()

◆ GetEnergyLossProcessVector()

◆ GetMessenger()

◆ GetMultipleScatteringVector()

◆ GetNumberOfBinsPerDecade()

◆ GetRange()

◆ GetRangeFromRestricteDEDX()

◆ GetSubDEDX()

◆ GetTableBuilder()

◆ Instance()

◆ IsMaster()

◆ LocalPhysicsTables()

◆ MaxKinEnergy()

◆ MinKinEnergy()

◆ operator=()

◆ ParticleHaveNoLoss()

◆ PreparePhysicsTable() [1/3]

◆ PreparePhysicsTable() [2/3]

◆ PreparePhysicsTable() [3/3]

◆ PrintEWarning()

◆ Register() [1/5]

◆ Register() [2/5]

◆ Register() [3/5]

◆ Register() [4/5]

◆ Register() [5/5]

◆ RegisterExtraParticle()

◆ ResetParameters()

◆ SetAtomDeexcitation()

◆ SetBuildCSDARange()

◆ SetDEDXBinning()

◆ SetDEDXBinningForCSDARange()

◆ SetIntegral()

◆ SetLambdaBinning()

◆ SetLinearLossLimit()

◆ SetLossFluctuations()

◆ SetMaxEnergy()

◆ SetMaxEnergyForCSDARange()

◆ SetMaxEnergyForMuons()

◆ SetMinEnergy()

◆ SetMinSubRange()

◆ SetParameters()

◆ SetRandomStep()

◆ SetStepFunction()