G4LossTableManager Class Reference

#include <G4LossTableManager.hh>

Public Member Functions
	~G4LossTableManager ()
void	Clear ()
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p, G4bool theMaster)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEmProcess *p, G4bool theMaster)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VMultipleScattering *p, G4bool theMaster)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	LocalPhysicsTables (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
G4double	GetDEDX (const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4double	GetSubDEDX (const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4double	GetRange (const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4double	GetCSDARange (const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4double	GetRangeFromRestricteDEDX (const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4double	GetEnergy (const G4ParticleDefinition *aParticle, G4double range, const G4MaterialCutsCouple *couple)
G4double	GetDEDXDispersion (const G4MaterialCutsCouple *couple, const G4DynamicParticle *dp, G4double &length)
void	Register (G4VEnergyLossProcess *p)
void	DeRegister (G4VEnergyLossProcess *p)
void	Register (G4VMultipleScattering *p)
void	DeRegister (G4VMultipleScattering *p)
void	Register (G4VEmProcess *p)
void	DeRegister (G4VEmProcess *p)
void	Register (G4VEmModel *p)
void	DeRegister (G4VEmModel *p)
void	Register (G4VEmFluctuationModel *p)
void	DeRegister (G4VEmFluctuationModel *p)
void	RegisterExtraParticle (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	SetVerbose (G4int val)
void	SetAtomDeexcitation (G4VAtomDeexcitation *)
void	SetSubCutProducer (G4VSubCutProducer *)
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 ()
G4EmCorrections *	EmCorrections ()
G4VAtomDeexcitation *	AtomDeexcitation ()
G4VSubCutProducer *	SubCutProducer ()
G4LossTableBuilder *	GetTableBuilder ()

Static Public Member Functions
static G4LossTableManager *	Instance ()

Friends
class	G4ThreadLocalSingleton< G4LossTableManager >

Detailed Description

Definition at line 100 of file G4LossTableManager.hh.

Constructor & Destructor Documentation

G4LossTableManager::~G4LossTableManager

(

)

Definition at line 123 of file G4LossTableManager.cc.

{
  //G4cout << "### G4LossTableManager::~G4LossTableManager() "<< this << 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();
  //G4cout << "   Nmod" << mod << "  Nfluc= " << fmod << G4endl;
  for (size_t a=0; a<mod; ++a) {
    //G4cout << "Delete model #" << a << "  " <<  mod_vector[a] << G4endl;
    if( nullptr != mod_vector[a] ) { 
      for (size_t b=0; b<fmod; ++b) {
        if((G4VEmModel*)(fmod_vector[b]) == mod_vector[a]) {
          fmod_vector[b] = nullptr;
        }
      }
      delete mod_vector[a]; 
      mod_vector[a] = nullptr;
    }
  }
  for (size_t b=0; b<fmod; ++b) {
    if( fmod_vector[b] ) { delete fmod_vector[b]; }
  }
  Clear();
  delete tableBuilder;
  delete emCorrections;
  delete emConfigurator;
  delete emElectronIonPair;
  delete atomDeexcitation;
  delete subcutProducer;
}

Here is the call graph for this function:

Member Function Documentation

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation ( )

inline

Definition at line 444 of file G4LossTableManager.hh.

{
  return atomDeexcitation;
}

Here is the caller graph for this function:

void G4LossTableManager::BuildPhysicsTable

(

const G4ParticleDefinition *

aParticle

)

Definition at line 499 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:

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

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

 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:

void G4LossTableManager::Clear

(

)

Definition at line 198 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:

void G4LossTableManager::DeRegister

(

G4VEnergyLossProcess *

p

)

Definition at line 263 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:

void G4LossTableManager::DeRegister

(

G4VMultipleScattering *

p

)

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

void G4LossTableManager::DeRegister

(

G4VEmProcess *

p

)

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

void G4LossTableManager::DeRegister

(

G4VEmModel *

p

)

Definition at line 338 of file G4LossTableManager.cc.

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

void G4LossTableManager::DeRegister

(

G4VEmFluctuationModel *

p

)

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

G4ElectronIonPair * G4LossTableManager::ElectronIonPair

(

)

Definition at line 980 of file G4LossTableManager.cc.

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

G4EmConfigurator * G4LossTableManager::EmConfigurator

(

)

Definition at line 972 of file G4LossTableManager.cc.

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

G4EmCorrections * G4LossTableManager::EmCorrections ( )

inline

Definition at line 437 of file G4LossTableManager.hh.

{
  return emCorrections;
}

Here is the caller graph for this function:

G4EmSaturation * G4LossTableManager::EmSaturation

(

)

Definition at line 965 of file G4LossTableManager.cc.

{
  return theParameters->GetEmSaturation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Definition at line 361 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:

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

inline

Definition at line 335 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:

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

inline

Definition at line 416 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:

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

(

)

Definition at line 950 of file G4LossTableManager.cc.

{
  return emp_vector;
}

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

inline

Definition at line 403 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:

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

inline

Definition at line 313 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:

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

(

)

Definition at line 943 of file G4LossTableManager.cc.

{
  return loss_vector;
}

Here is the caller graph for this function:

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

(

)

Definition at line 958 of file G4LossTableManager.cc.

{
  return msc_vector;
}

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

inline

Definition at line 388 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:

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

inline

Definition at line 374 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:

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

inline

Definition at line 348 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:

G4LossTableBuilder * G4LossTableManager::GetTableBuilder ( )

inline

Definition at line 458 of file G4LossTableManager.hh.

{
  return tableBuilder;
}

Here is the caller graph for this function:

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:

G4bool G4LossTableManager::IsMaster ( ) const

inline

Definition at line 430 of file G4LossTableManager.hh.

{
  return isMaster;
}

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 400 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:

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

Definition at line 441 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:

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

Definition at line 469 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:

void G4LossTableManager::Register

(

G4VEnergyLossProcess *

p

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4LossTableManager::Register

(

G4VMultipleScattering *

p

)

Definition at line 273 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:

void G4LossTableManager::Register

(

G4VEmProcess *

p

)

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

void G4LossTableManager::Register

(

G4VEmModel *

p

)

Definition at line 327 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

void G4LossTableManager::Register

(

G4VEmFluctuationModel *

p

)

Definition at line 352 of file G4LossTableManager.cc.

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

Here is the call graph for this function:

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

Definition at line 373 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:

void G4LossTableManager::SetAtomDeexcitation

(

G4VAtomDeexcitation *

p

)

Definition at line 990 of file G4LossTableManager.cc.

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

Here is the caller graph for this function:

void G4LossTableManager::SetSubCutProducer

(

G4VSubCutProducer *

p

)

Definition at line 1000 of file G4LossTableManager.cc.

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

void G4LossTableManager::SetVerbose

(

G4int

val

)

Definition at line 935 of file G4LossTableManager.cc.

{
  verbose = val;
}

G4VSubCutProducer * G4LossTableManager::SubCutProducer ( )

inline

Definition at line 451 of file G4LossTableManager.hh.

{ 
  return subcutProducer;
}

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class G4ThreadLocalSingleton< G4LossTableManager >

friend

Definition at line 103 of file G4LossTableManager.hh.

---

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

• geant4.10.03.p01/source/processes/electromagnetic/utils/include/G4LossTableManager.hh
• geant4.10.03.p01/source/processes/electromagnetic/utils/src/G4LossTableManager.cc