G4EmManager Class Reference

#include <G4EmManager.hh>

Public Member Functions
	~G4EmManager ()
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VEmProcess *p)
void	PreparePhysicsTable (const G4ParticleDefinition *aParticle, G4VMultipleScattering *p)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle)
void	BuildPhysicsTable (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	InitialiseProcess (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *)
void	InitialiseProcess (const G4ParticleDefinition *aParticle, G4VEmProcess *)
void	InitialiseProcess (const G4ParticleDefinition *aParticle, G4VMultipleScattering *)
void	Register (G4VEnergyLossProcess *p)
void	Register (G4VMultipleScattering *p)
void	Register (G4VEmProcess *p)
void	RegisterExtraParticle (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	Register (G4PhysicsTable *p)
void	DeRegister (G4PhysicsTable *p)
void	SetLossFluctuations (G4bool val)
void	SetSubCutoff (G4bool val, const G4Region *r=0)
void	SetIntegral (G4bool val)
void	SetRandomStep (G4bool val)
void	SetMinSubRange (G4double val)
void	SetMinEnergy (G4double val)
void	SetMaxEnergy (G4double val)
void	SetMaxEnergyForCSDARange (G4double val)
void	SetMaxEnergyForMuons (G4double val)
void	SetDEDXBinning (G4int val)
void	SetDEDXBinningForCSDARange (G4int val)
void	SetLambdaBinning (G4int val)
G4int	GetNumberOfBinsPerDecade () const
void	SetStepFunction (G4double v1, G4double v2)
void	SetBuildCSDARange (G4bool val)
void	SetLPMFlag (G4bool val)
void	SetSplineFlag (G4bool val)
void	SetLinearLossLimit (G4double val)
void	SetBremsstrahlungTh (G4double val)
void	SetFactorForAngleLimit (G4double val)
void	SetVerbose (G4int val)
G4bool	BuildCSDARange () const
G4bool	LPMFlag () const
G4bool	SplineFlag () const
G4double	BremsstrahlungTh () const
G4double	FactorForAngleLimit () const
G4double	MinKinEnergy () const
G4double	MaxKinEnergy () const
G4EmSaturation *	EmSaturation ()
G4EmConfigurator *	EmConfigurator ()
G4ElectronIonPair *	ElectronIonPair ()
G4LossTableBuilder *	GetTableBuilder ()

Static Public Member Functions
static G4EmManager *	Instance ()

Detailed Description

Definition at line 80 of file G4EmManager.hh.

Constructor & Destructor Documentation

G4EmManager::~G4EmManager

(

)

Definition at line 83 of file G4EmManager.cc.

References G4cout, G4endl, and nmax.

{
  G4cout << "G4EmManager::~G4EmManager()" << G4endl;
  G4int nmax = dedx_vector.size();
  for (G4int i=0; i<nmax; ++i) {
    if( dedx_vector[i] ) { 
      dedx_vector[i]->clearAndDestroy(); 
      delete dedx_vector[i]; 
    }
  }
  nmax = range_vector.size();
  for (G4int i=0; i<nmax; ++i) {
    if( range_vector[i] ) { 
      range_vector[i]->clearAndDestroy(); 
      delete range_vector[i]; 
    }
  }
  nmax = inv_range_vector.size();
  for (G4int i=0; i<nmax; ++i) {
    if( inv_range_vector[i] ) { 
      inv_range_vector[i]->clearAndDestroy(); 
      delete inv_range_vector[i]; 
    }
  }
  nmax = xsection_vector.size();
  for (G4int i=0; i<nmax; ++i) {
    if( xsection_vector[i] ) { 
      xsection_vector[i]->clearAndDestroy(); 
      delete xsection_vector[i]; 
    }
  }
  G4cout << "G4EmManager::~G4EmManager() 1" << G4endl;
  delete theMessenger;
  delete tableBuilder;
  delete emSaturation;
  delete emConfigurator;
  delete emElectronIonPair;
  G4cout << "G4EmManager::~G4EmManager() 2" << G4endl;
}

Member Function Documentation

G4double G4EmManager::BremsstrahlungTh

(

)

const

Definition at line 897 of file G4EmManager.cc.

{
  return bremsTh;
}

G4bool G4EmManager::BuildCSDARange

(

)

const

Definition at line 613 of file G4EmManager.cc.

{
  return buildCSDARange;
}

void G4EmManager::BuildPhysicsTable

(

const G4ParticleDefinition *

aParticle

)

Definition at line 332 of file G4EmManager.cc.

References G4EmConfigurator::Clear().

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

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

Definition at line 342 of file G4EmManager.cc.

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

{
  if(1 < verbose) {
    G4cout << "### G4EmManager::BuildDEDXTable() is requested for "
           << aParticle->GetParticleName()
       << " and process " << p->GetProcessName() << G4endl;
  }
  // clear configurator
  if(0 == run && startInitialisation) {
    emConfigurator->Clear();
    firstParticle = aParticle; 
  }
  startInitialisation = false;

  // initialisation before any table is built
  if ( aParticle == firstParticle ) {
    all_tables_are_built = true;

    if(1 < verbose) {
      G4cout << "### G4EmManager start initilisation for first particle "
         << firstParticle->GetParticleName() 
         << G4endl;
    }
    for (G4int i=0; i<n_loss; ++i) {
      G4VEnergyLossProcess* el = loss_vector[i];

      if(el) {
    const G4ProcessManager* pm = el->GetProcessManager();
        isActive[i] = false;
        if(pm) { isActive[i] = pm->GetProcessActivation(el); }
        if(0 == run) { base_part_vector[i] = el->BaseParticle(); }
        tables_are_built[i] = false;
    all_tables_are_built= false;
        if(!isActive[i]) { el->SetIonisation(false); }
  
    if(1 < verbose) { 
      G4cout << i <<".   "<< el->GetProcessName();
          if(el->Particle()) {
        G4cout << "  for "  << el->Particle()->GetParticleName();
      }
      G4cout << "  active= " << isActive[i]
                 << "  table= " << tables_are_built[i]
         << "  isIonisation= " << el->IsIonisationProcess();
      if(base_part_vector[i]) { 
        G4cout << "  base particle " 
           << base_part_vector[i]->GetParticleName();
      }
      G4cout << G4endl;
    }
      } else {
        tables_are_built[i] = true;
        part_vector[i] = 0;
      }
    }
    ++run;
  }

  // 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 << "### BuildPhysicsTable for " << p->GetProcessName()
               << " and " << curr_part->GetParticleName()
               << " start BuildTable " << G4endl;
      }
      G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
      if(curr_proc) { CopyTables(curr_part, curr_proc); }
    }
    if ( !tables_are_built[i] ) { all_tables_are_built = false; }
  }

  if(1 < verbose) {
    G4cout << "### G4EmManager::BuildDEDXTable end: "
           << "all_tables_are_built= " << all_tables_are_built
           << G4endl;
    
    if(all_tables_are_built) {
      G4cout << "### All dEdx and Range tables are built #####" << G4endl;
    }
  }
}

void G4EmManager::DeRegister

(

G4PhysicsTable *

p

)

G4ElectronIonPair * G4EmManager::ElectronIonPair

(

)

Definition at line 946 of file G4EmManager.cc.

{
  return emElectronIonPair;
}

G4EmConfigurator * G4EmManager::EmConfigurator

(

)

Definition at line 939 of file G4EmManager.cc.

{
  return emConfigurator;
}

G4EmSaturation * G4EmManager::EmSaturation

(

)

Definition at line 932 of file G4EmManager.cc.

{
  return emSaturation;
}

G4double G4EmManager::FactorForAngleLimit

(

)

const

Definition at line 911 of file G4EmManager.cc.

{
  return factorForAngleLimit;
}

G4int G4EmManager::GetNumberOfBinsPerDecade

(

)

const

Definition at line 759 of file G4EmManager.cc.

{
  return nbinsPerDecade;
}

G4LossTableBuilder * G4EmManager::GetTableBuilder

(

)

Definition at line 953 of file G4EmManager.cc.

{
  return tableBuilder;
}

void G4EmManager::InitialiseProcess	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *
	)

Definition at line 840 of file G4EmManager.cc.

{
}

void G4EmManager::InitialiseProcess	(	const G4ParticleDefinition *	aParticle,
		G4VEmProcess *
	)

Definition at line 847 of file G4EmManager.cc.

{
}

void G4EmManager::InitialiseProcess	(	const G4ParticleDefinition *	aParticle,
		G4VMultipleScattering *
	)

Definition at line 854 of file G4EmManager.cc.

{
}

G4EmManager * G4EmManager::Instance ( void  )

static

Definition at line 72 of file G4EmManager.cc.

{
  if(0 == theInstance) {
    static G4EmManager manager;
    theInstance = &manager;
  }
  return theInstance;
}

G4bool G4EmManager::LPMFlag

(

)

const

Definition at line 868 of file G4EmManager.cc.

{
  return flagLPM;
}

G4double G4EmManager::MaxKinEnergy

(

)

const

Definition at line 925 of file G4EmManager.cc.

{
  return maxKinEnergy;
}

G4double G4EmManager::MinKinEnergy

(

)

const

Definition at line 918 of file G4EmManager.cc.

{
  return minKinEnergy;
}

void G4EmManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 264 of file G4EmManager.cc.

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

{
  if (1 < verbose) {
    G4cout << "G4EmManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << " run= " << run 
       << "   loss_vector " << loss_vector.size() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }

  // start initialisation for the first run
  startInitialisation = true;

  if( 0 == run ) {
    emConfigurator->PrepareModels(particle, p);

    // initialise particles for given process
    for (G4int j=0; j<n_loss; ++j) {
      if (p == loss_vector[j]) {
    if (!part_vector[j]) { part_vector[j] = particle; }
      }
    }
  }
}

void G4EmManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VEmProcess *	p
	)

Definition at line 293 of file G4EmManager.cc.

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

{
  if (1 < verbose) {
    G4cout << "G4EmManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }

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

void G4EmManager::PreparePhysicsTable	(	const G4ParticleDefinition *	aParticle,
		G4VMultipleScattering *	p
	)

Definition at line 313 of file G4EmManager.cc.

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

{
  if (1 < verbose) {
    G4cout << "G4EmManager::PreparePhysicsTable for " 
       << particle->GetParticleName() 
       << " and " << p->GetProcessName() << G4endl;
  }
  if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }

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

void G4EmManager::Register

(

G4VEnergyLossProcess *

p

)

Definition at line 172 of file G4EmManager.cc.

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

{
  if(!p) { return; }
  for (G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4EmManager::Register G4VEnergyLossProcess : " 
       << p->GetProcessName() << "  idx= " << n_loss << G4endl;
  }
  ++n_loss;
  loss_vector.push_back(p);
  part_vector.push_back(0);
  base_part_vector.push_back(0);
  dedx_vector.push_back(0);
  range_vector.push_back(0);
  inv_range_vector.push_back(0);
  tables_are_built.push_back(false);
  isActive.push_back(true);
  all_tables_are_built = false;
  if(!lossFluctuationFlag) { p->SetLossFluctuations(false); }
  if(subCutoffFlag)        { p->ActivateSubCutoff(true); }
  if(rndmStepFlag)         { p->SetRandomStep(true); }
  if(stepFunctionActive)   { 
    p->SetStepFunction(maxRangeVariation, maxFinalStep); 
  }
  if(integralActive)       { p->SetIntegral(integral); }
  if(minEnergyActive)      { p->SetMinKinEnergy(minKinEnergy); }
  if(maxEnergyActive)      { p->SetMaxKinEnergy(maxKinEnergy); }
}

void G4EmManager::Register

(

G4VMultipleScattering *

p

)

Definition at line 205 of file G4EmManager.cc.

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

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

void G4EmManager::Register

(

G4VEmProcess *

p

)

Definition at line 221 of file G4EmManager.cc.

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

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

void G4EmManager::Register

(

G4PhysicsTable *

p

)

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

Definition at line 237 of file G4EmManager.cc.

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

{ 
  if(!p || !part) { return; }
  for (G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i] == p) { return; }
  }
  if(verbose > 1) {
    G4cout << "G4EmManager::RegisterExtraParticle "
       << part->GetParticleName() << "  G4VEnergyLossProcess : " 
       << p->GetProcessName() << "  idx= " << n_loss << G4endl;
  }
  ++n_loss;
  loss_vector.push_back(p);
  part_vector.push_back(part);
  base_part_vector.push_back(p->BaseParticle());
  dedx_vector.push_back(0);
  range_vector.push_back(0);
  inv_range_vector.push_back(0);
  tables_are_built.push_back(false);
  all_tables_are_built = false;
}

void G4EmManager::SetBremsstrahlungTh

(

G4double

val

)

Definition at line 890 of file G4EmManager.cc.

{
  bremsTh = val;
}

void G4EmManager::SetBuildCSDARange

(

G4bool

val

)

Definition at line 815 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

{
  buildCSDARange = val;
}

void G4EmManager::SetDEDXBinning

(

G4int

val

)

Definition at line 722 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetDEDXBinningForCSDARange

(

G4int

val

)

Definition at line 731 of file G4EmManager.cc.

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

void G4EmManager::SetFactorForAngleLimit

(

G4double

val

)

Definition at line 904 of file G4EmManager.cc.

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

void G4EmManager::SetIntegral

(

G4bool

val

)

Definition at line 640 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetLambdaBinning

(

G4int

val

)

Definition at line 740 of file G4EmManager.cc.

References G4cout, G4endl, and n.

Referenced by G4EmManagerMessenger::SetNewValue().

{
  G4int n = val/G4int(std::log10(maxKinEnergy/minKinEnergy) + 0.5);
  if(n < 5) {
    G4cout << "G4EmManager::SetLambdaBinning WARNING "
       << "too small number of bins " << val << "  ignored" 
       << G4endl;
    return;
  } 
  nbinsLambda = val;
  nbinsPerDecade = n;
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetLambdaBinning(val); }
  }
}

void G4EmManager::SetLinearLossLimit

(

G4double

val

)

Definition at line 806 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetLossFluctuations

(

G4bool

val

)

Definition at line 620 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetLPMFlag

(

G4bool

val

)

Definition at line 861 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

{
  flagLPM = val;
}

void G4EmManager::SetMaxEnergy

(

G4double

val

)

Definition at line 690 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetMaxEnergyForCSDARange

(

G4double

val

)

Definition at line 705 of file G4EmManager.cc.

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

void G4EmManager::SetMaxEnergyForMuons

(

G4double

val

)

Definition at line 714 of file G4EmManager.cc.

{
  maxEnergyForMuonsActive = true;
  maxKinEnergyForMuons = val;
}

void G4EmManager::SetMinEnergy

(

G4double

val

)

Definition at line 675 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetMinSubRange

(

G4double

val

)

Definition at line 655 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetRandomStep

(

G4bool

val

)

Definition at line 665 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetSplineFlag

(

G4bool

val

)

Definition at line 875 of file G4EmManager.cc.

References G4LossTableBuilder::SetSplineFlag().

Referenced by G4EmManagerMessenger::SetNewValue().

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

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

Definition at line 794 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

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

Definition at line 630 of file G4EmManager.cc.

Referenced by G4EmManagerMessenger::SetNewValue().

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

void G4EmManager::SetVerbose

(

G4int

val

)

Definition at line 766 of file G4EmManager.cc.

References G4cout, G4endl, G4EmSaturation::SetVerbose(), G4EmConfigurator::SetVerbose(), and G4ElectronIonPair::SetVerbose().

{
  verbose = val;
  /*
  for(G4int i=0; i<n_loss; ++i) {
    if(loss_vector[i]) { loss_vector[i]->SetVerboseLevel(val); }
  }
  size_t msc = msc_vector.size();
  for (size_t j=0; j<msc; ++j) {
    if(msc_vector[j]) { msc_vector[j]->SetVerboseLevel(val); }
  }
  size_t emp = emp_vector.size();
  for (size_t k=0; k<emp; ++k) {
    if(emp_vector[k]) { emp_vector[k]->SetVerboseLevel(val); }
  }
  */
  G4cout << "1 " << emConfigurator <<  G4endl;
  emConfigurator->SetVerbose(val);
  G4cout << "2 " << emSaturation << G4endl;
  //tableBuilder->SetVerbose(val);
  emSaturation->SetVerbose(val);
  G4cout << "3 " << emElectronIonPair << G4endl;
  emElectronIonPair->SetVerbose(val);
  G4cout << "4 " << G4endl;
}

G4bool G4EmManager::SplineFlag

(

)

const

Definition at line 883 of file G4EmManager.cc.

{
  return splineFlag;
}

---

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

• G4EmManager.hh
• G4EmManager.cc