G4LossTableManager Class Reference

#include <G4LossTableManager.hh>


Public Member Functions

 ~G4LossTableManager ()
void Clear ()
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)
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 RegisterIon (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *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)
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)
G4EnergyLossMessengerGetMessenger ()
G4bool BuildCSDARange () const
G4bool LPMFlag () const
G4bool SplineFlag () const
G4double BremsstrahlungTh () const
G4double FactorForAngleLimit () const
G4double MinKinEnergy () const
G4double MaxKinEnergy () const
const std::vector< G4VEnergyLossProcess * > & GetEnergyLossProcessVector ()
const std::vector< G4VEmProcess * > & GetEmProcessVector ()
const std::vector< G4VMultipleScattering * > & GetMultipleScatteringVector ()
G4VEnergyLossProcessGetEnergyLossProcess (const G4ParticleDefinition *)
G4EmCorrectionsEmCorrections ()
G4EmSaturationEmSaturation ()
G4EmConfiguratorEmConfigurator ()
G4ElectronIonPairElectronIonPair ()
G4VAtomDeexcitationAtomDeexcitation ()
G4LossTableBuilderGetTableBuilder ()
void SetAtomDeexcitation (G4VAtomDeexcitation *)

Static Public Member Functions

static G4LossTableManagerInstance ()


Detailed Description

Definition at line 99 of file G4LossTableManager.hh.


Constructor & Destructor Documentation

G4LossTableManager::~G4LossTableManager (  ) 

Definition at line 118 of file G4LossTableManager.cc.

References Clear().

00119 {
00120   for (G4int i=0; i<n_loss; ++i) {
00121     if( loss_vector[i] ) { delete loss_vector[i]; }
00122   }
00123   size_t msc = msc_vector.size();
00124   for (size_t j=0; j<msc; ++j) {
00125     if( msc_vector[j] ) { delete msc_vector[j]; }
00126   }
00127   size_t emp = emp_vector.size();
00128   for (size_t k=0; k<emp; ++k) {
00129     if( emp_vector[k] ) { delete emp_vector[k]; }
00130   }
00131   size_t mod = mod_vector.size();
00132   for (size_t a=0; a<mod; ++a) {
00133     if( mod_vector[a] ) { delete mod_vector[a]; }
00134   }
00135   size_t fmod = fmod_vector.size();
00136   for (size_t b=0; b<fmod; ++b) {
00137     if( fmod_vector[b] ) { delete fmod_vector[b]; }
00138   }
00139   Clear();
00140   delete theMessenger;
00141   delete tableBuilder;
00142   delete emCorrections;
00143   delete emSaturation;
00144   delete emConfigurator;
00145   delete emElectronIonPair;
00146   delete atomDeexcitation;
00147 }


Member Function Documentation

G4VAtomDeexcitation * G4LossTableManager::AtomDeexcitation (  ) 

Definition at line 1106 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4RadioactiveDecay::BuildPhysicsTable(), G4EmCalculator::ComputeShellIonisationCrossSectionPerAtom(), G4NuclearDecayChannel::DecayIt(), G4EmCalculator::GetShellIonisationCrossSectionPerAtom(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopeComptonModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4MuElecInelasticModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LivermorePolarizedPhotoElectricModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4LivermoreComptonModifiedModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4KleinNishinaModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNABornIonisationModel::Initialise(), and G4VEmProcess::PreparePhysicsTable().

01107 {
01108   return atomDeexcitation;
01109 }

G4double G4LossTableManager::BremsstrahlungTh (  )  const

Definition at line 1043 of file G4LossTableManager.cc.

Referenced by G4eBremsstrahlung::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::PrintInfo().

01044 {
01045   return bremsTh;
01046 }

G4bool G4LossTableManager::BuildCSDARange (  )  const

Definition at line 762 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

00763 {
00764   return buildCSDARange;
00765 }

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

Definition at line 467 of file G4LossTableManager.cc.

References G4EmConfigurator::Clear(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), and G4VAtomDeexcitation::InitialiseAtomicDeexcitation().

00470 {
00471   if(1 < verbose) {
00472     G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
00473            << aParticle->GetParticleName()
00474            << " and process " << p->GetProcessName() << G4endl;
00475   }
00476   // clear configurator
00477   if(0 == run && startInitialisation) {
00478     emConfigurator->Clear();
00479     firstParticle = aParticle; 
00480   }
00481   if(startInitialisation && atomDeexcitation) {
00482     atomDeexcitation->InitialiseAtomicDeexcitation();
00483   }
00484   startInitialisation = false;
00485 
00486   // initialisation before any table is built
00487   if ( aParticle == firstParticle ) {
00488     all_tables_are_built = true;
00489 
00490     if(1 < verbose) {
00491       G4cout << "### G4LossTableManager start initilisation for first particle "
00492              << firstParticle->GetParticleName() 
00493              << G4endl;
00494     }
00495     for (G4int i=0; i<n_loss; ++i) {
00496       G4VEnergyLossProcess* el = loss_vector[i];
00497 
00498       if(el) {
00499         const G4ProcessManager* pm = el->GetProcessManager();
00500         isActive[i] = false;
00501         if(pm) { isActive[i] = pm->GetProcessActivation(el); }
00502         if(0 == run) { base_part_vector[i] = el->BaseParticle(); }
00503         tables_are_built[i] = false;
00504         all_tables_are_built= false;
00505         if(!isActive[i]) { el->SetIonisation(false); }
00506   
00507         if(1 < verbose) { 
00508           G4cout << i <<".   "<< el->GetProcessName();
00509           if(el->Particle()) {
00510             G4cout << "  for "  << el->Particle()->GetParticleName();
00511           }
00512           G4cout << "  active= " << isActive[i]
00513                  << "  table= " << tables_are_built[i]
00514                  << "  isIonisation= " << el->IsIonisationProcess();
00515           if(base_part_vector[i]) { 
00516             G4cout << "  base particle " << base_part_vector[i]->GetParticleName();
00517           }
00518           G4cout << G4endl;
00519         }
00520       } else {
00521         tables_are_built[i] = true;
00522         part_vector[i] = 0;
00523       }
00524     }
00525     ++run;
00526     currentParticle = 0;
00527   }
00528 
00529   // Set run time parameters 
00530   SetParameters(aParticle, p);
00531 
00532   if (all_tables_are_built) { return; }
00533 
00534   // Build tables for given particle
00535   all_tables_are_built = true;
00536 
00537   for(G4int i=0; i<n_loss; ++i) {
00538     if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
00539       const G4ParticleDefinition* curr_part = part_vector[i];
00540       if(1 < verbose) {
00541         G4cout << "### BuildPhysicsTable for " << p->GetProcessName()
00542                << " and " << curr_part->GetParticleName()
00543                << " start BuildTable " << G4endl;
00544       }
00545       G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
00546       if(curr_proc) { CopyTables(curr_part, curr_proc); }
00547     }
00548     if ( !tables_are_built[i] ) { all_tables_are_built = false; }
00549   }
00550 
00551   if(1 < verbose) {
00552     G4cout << "### G4LossTableManager::BuildDEDXTable end: "
00553            << "all_tables_are_built= " << all_tables_are_built
00554            << G4endl;
00555     
00556     if(all_tables_are_built) {
00557       G4cout << "### All dEdx and Range tables are built #####" << G4endl;
00558     }
00559   }
00560 }

void G4LossTableManager::BuildPhysicsTable ( const G4ParticleDefinition aParticle  ) 

Definition at line 458 of file G4LossTableManager.cc.

References G4EmConfigurator::Clear().

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

00459 {
00460   if(0 == run && startInitialisation) {
00461     emConfigurator->Clear();
00462   }
00463 }

void G4LossTableManager::Clear (  ) 

Definition at line 196 of file G4LossTableManager.cc.

Referenced by ~G4LossTableManager().

00197 {
00198   all_tables_are_built = false;
00199   currentLoss = 0;
00200   currentParticle = 0;
00201   if(n_loss)
00202     {
00203       dedx_vector.clear();
00204       range_vector.clear();
00205       inv_range_vector.clear();
00206       loss_map.clear();
00207       loss_vector.clear();
00208       part_vector.clear();
00209       base_part_vector.clear();
00210       tables_are_built.clear();
00211       isActive.clear();
00212       n_loss = 0;
00213     }
00214 }

void G4LossTableManager::DeRegister ( G4VEmFluctuationModel p  ) 

Definition at line 345 of file G4LossTableManager.cc.

References CLHEP::detail::n.

00346 {
00347   size_t n = fmod_vector.size();
00348   for (size_t i=0; i<n; ++i) {
00349     if(fmod_vector[i] == p) { fmod_vector[i] = 0; }
00350   }
00351 }

void G4LossTableManager::DeRegister ( G4VEmModel p  ) 

Definition at line 324 of file G4LossTableManager.cc.

References CLHEP::detail::n.

00325 {
00326   size_t n = mod_vector.size();
00327   for (size_t i=0; i<n; ++i) {
00328     if(mod_vector[i] == p) { mod_vector[i] = 0; }
00329   }
00330 }

void G4LossTableManager::DeRegister ( G4VEmProcess p  ) 

Definition at line 302 of file G4LossTableManager.cc.

00303 {
00304   if(!p) { return; }
00305   size_t emp = emp_vector.size();
00306   for (size_t i=0; i<emp; ++i) {
00307     if(emp_vector[i] == p) { emp_vector[i] = 0; }
00308   }
00309 }

void G4LossTableManager::DeRegister ( G4VMultipleScattering p  ) 

Definition at line 275 of file G4LossTableManager.cc.

00276 {
00277   if(!p) { return; }
00278   size_t msc = msc_vector.size();
00279   for (size_t i=0; i<msc; ++i) {
00280     if(msc_vector[i] == p) { msc_vector[i] = 0; }
00281   }
00282 }

void G4LossTableManager::DeRegister ( G4VEnergyLossProcess p  ) 

Definition at line 249 of file G4LossTableManager.cc.

Referenced by G4VEmFluctuationModel::~G4VEmFluctuationModel(), G4VEmModel::~G4VEmModel(), and G4VMultipleScattering::~G4VMultipleScattering().

00250 {
00251   if(!p) { return; }
00252   for (G4int i=0; i<n_loss; ++i) {
00253     if(loss_vector[i] == p) { loss_vector[i] = 0; }
00254   }
00255 }

G4ElectronIonPair * G4LossTableManager::ElectronIonPair (  ) 

Definition at line 1099 of file G4LossTableManager.cc.

01100 {
01101   return emElectronIonPair;
01102 }

G4EmConfigurator * G4LossTableManager::EmConfigurator (  ) 

Definition at line 1092 of file G4LossTableManager.cc.

01093 {
01094   return emConfigurator;
01095 }

G4EmCorrections * G4LossTableManager::EmCorrections (  ) 

Definition at line 1078 of file G4LossTableManager.cc.

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

01079 {
01080   return emCorrections;
01081 }

G4EmSaturation * G4LossTableManager::EmSaturation (  ) 

Definition at line 1085 of file G4LossTableManager.cc.

Referenced by G4OpticalPhysics::ConstructProcess().

01086 {
01087   return emSaturation;
01088 }

G4double G4LossTableManager::FactorForAngleLimit (  )  const

Definition at line 1057 of file G4LossTableManager.cc.

Referenced by G4WentzelVIRelXSection::Initialise(), G4WentzelOKandVIxSection::Initialise(), and G4CoulombScattering::InitialiseProcess().

01058 {
01059   return factorForAngleLimit;
01060 }

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

Definition at line 1171 of file G4LossTableManager.cc.

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

Referenced by G4EmCalculator::GetCSDARange().

01174 {
01175   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01176   G4double x = DBL_MAX;
01177   if(currentLoss) { x = currentLoss->GetCSDARange(kineticEnergy, couple); }
01178   return x;
01179 }

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

Definition at line 1145 of file G4LossTableManager.cc.

References G4EnergyLossTables::GetDEDX(), G4VEnergyLossProcess::GetDEDX(), and GetEnergyLossProcess().

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

01148 {
01149   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01150   G4double x = 0.0;
01151   if(currentLoss) { x = currentLoss->GetDEDX(kineticEnergy, couple); }
01152   else            { x = G4EnergyLossTables::GetDEDX(currentParticle,
01153                                                     kineticEnergy,couple,false); }
01154   return x;
01155 }

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

Definition at line 1226 of file G4LossTableManager.cc.

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

01229 {
01230   const G4ParticleDefinition* aParticle = dp->GetParticleDefinition();
01231   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01232   G4double x = 0.0;
01233   if(currentLoss) { currentLoss->GetDEDXDispersion(couple, dp, length); }
01234   return x;
01235 }

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

Definition at line 992 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::ActivateForcedInteraction(), G4EmProcessOptions::ActivateSecondaryBiasingForGamma(), G4EmProcessOptions::SetApplyCuts(), G4EmProcessOptions::SetPolarAngleLimit(), G4EmProcessOptions::SetProcessBiasingFactor(), and G4EmProcessOptions::SetVerbose().

00993 {
00994   return emp_vector;
00995 }

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

Definition at line 1212 of file G4LossTableManager.cc.

References GetEnergyLossProcess(), G4VEnergyLossProcess::GetKineticEnergy(), and G4EnergyLossTables::GetPreciseEnergyFromRange().

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

01215 {
01216   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01217   G4double x;
01218   if(currentLoss) { x = currentLoss->GetKineticEnergy(range, couple); }
01219   else { x = G4EnergyLossTables::GetPreciseEnergyFromRange(currentParticle,range,
01220                                                            couple,false); }
01221   return x;
01222 }

G4VEnergyLossProcess * G4LossTableManager::GetEnergyLossProcess ( const G4ParticleDefinition  ) 

Definition at line 1128 of file G4LossTableManager.cc.

Referenced by GetCSDARange(), GetDEDX(), GetDEDXDispersion(), GetEnergy(), GetRange(), GetRangeFromRestricteDEDX(), GetSubDEDX(), and G4VMultipleScattering::StartTracking().

01129 {
01130   if(aParticle != currentParticle) {
01131     currentParticle = aParticle;
01132     std::map<PD,G4VEnergyLossProcess*,std::less<PD> >::const_iterator pos;
01133     if ((pos = loss_map.find(aParticle)) != loss_map.end()) {
01134       currentLoss = (*pos).second;
01135     } else {
01136       currentLoss = 0;
01137       //ParticleHaveNoLoss(aParticle);
01138     }
01139   }
01140   return currentLoss;
01141 }

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

Definition at line 985 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::ActivateForcedInteraction(), G4EmProcessOptions::ActivateSecondaryBiasing(), G4EmCalculator::ComputeElectronicDEDX(), G4EmProcessOptions::SetLambdaFactor(), G4EmProcessOptions::SetProcessBiasingFactor(), and G4EmProcessOptions::SetVerbose().

00986 {
00987   return loss_vector;
00988 }

G4EnergyLossMessenger * G4LossTableManager::GetMessenger (  ) 

Definition at line 742 of file G4LossTableManager.cc.

00743 {
00744   return theMessenger;
00745 }

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

Definition at line 1000 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMscGeomFactor(), G4EmProcessOptions::SetMscLateralDisplacement(), G4EmProcessOptions::SetMscRangeFactor(), G4EmProcessOptions::SetMscStepLimitation(), G4EmProcessOptions::SetPolarAngleLimit(), G4EmProcessOptions::SetSkin(), and G4EmProcessOptions::SetVerbose().

01001 {
01002   return msc_vector;
01003 }

G4int G4LossTableManager::GetNumberOfBinsPerDecade (  )  const

Definition at line 908 of file G4LossTableManager.cc.

Referenced by G4LossTableBuilder::BuildTableForModel(), and G4VEmModel::InitialiseElementSelectors().

00909 {
00910   return nbinsPerDecade;
00911 }

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

Definition at line 1198 of file G4LossTableManager.cc.

References GetEnergyLossProcess(), G4EnergyLossTables::GetRange(), and G4VEnergyLossProcess::GetRange().

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

01201 {
01202   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01203   G4double x;
01204   if(currentLoss) { x = currentLoss->GetRange(kineticEnergy, couple); }
01205   else { x = G4EnergyLossTables::GetRange(currentParticle,kineticEnergy,
01206                                           couple,false); }
01207   return x;
01208 }

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

Definition at line 1184 of file G4LossTableManager.cc.

References GetEnergyLossProcess(), G4EnergyLossTables::GetRange(), and G4VEnergyLossProcess::GetRangeForLoss().

Referenced by G4EmCalculator::GetRangeFromRestricteDEDX().

01187 {
01188   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01189   G4double x;
01190   if(currentLoss) { x = currentLoss->GetRangeForLoss(kineticEnergy, couple); }
01191   else { x = G4EnergyLossTables::GetRange(currentParticle,kineticEnergy,
01192                                           couple,false); }
01193   return x;
01194 }

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

Definition at line 1159 of file G4LossTableManager.cc.

References G4VEnergyLossProcess::GetDEDXForSubsec(), and GetEnergyLossProcess().

01162 {
01163   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
01164   G4double x = 0.0;
01165   if(currentLoss) { x = currentLoss->GetDEDXForSubsec(kineticEnergy, couple); }
01166   return x;
01167 }

G4LossTableBuilder * G4LossTableManager::GetTableBuilder (  ) 

Definition at line 1113 of file G4LossTableManager.cc.

Referenced by G4VMscModel::GetParticleChangeForMSC(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEmProcess::PreparePhysicsTable().

01114 {
01115   return tableBuilder;
01116 }

G4LossTableManager * G4LossTableManager::Instance (  )  [static]

Definition at line 107 of file G4LossTableManager.cc.

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4RadioactiveDecay::BuildPhysicsTable(), G4LossTableBuilder::BuildTableForModel(), G4EmCalculator::ComputeElectronicDEDX(), G4OpticalPhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmDNAPhysicsChemistry::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), G4NuclearDecayChannel::DecayIt(), G4BetheBlochModel::G4BetheBlochModel(), G4BraggModel::G4BraggModel(), G4EmCalculator::G4EmCalculator(), G4EmLivermorePhysics::G4EmLivermorePhysics(), G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(), G4EmLowEPPhysics::G4EmLowEPPhysics(), G4EmPenelopePhysics::G4EmPenelopePhysics(), G4EmProcessOptions::G4EmProcessOptions(), G4EmStandardPhysics::G4EmStandardPhysics(), G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(), G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(), G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(), G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(), G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel(), G4ionIonisation::G4ionIonisation(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4MuBetheBlochModel::G4MuBetheBlochModel(), G4QAtomicPhysics::G4QAtomicPhysics(), G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4UrbanMscModel90::G4UrbanMscModel90(), G4UrbanMscModel92::G4UrbanMscModel92(), G4UrbanMscModel93::G4UrbanMscModel93(), G4UrbanMscModel95::G4UrbanMscModel95(), G4UrbanMscModel96::G4UrbanMscModel96(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMscModel::G4VMscModel(), G4VMultipleScattering::G4VMultipleScattering(), G4WentzelVIModel::G4WentzelVIModel(), G4WentzelVIRelModel::G4WentzelVIRelModel(), G4EnergyLossTables::GetDEDX(), G4EnergyLossTables::GetPreciseDEDX(), G4EnergyLossTables::GetPreciseEnergyFromRange(), G4EnergyLossTables::GetPreciseRangeFromEnergy(), G4EnergyLossTables::GetRange(), G4WentzelVIRelXSection::Initialise(), G4WentzelOKandVIxSection::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopeComptonModel::Initialise(), G4PEEffectFluoModel::Initialise(), G4MuElecInelasticModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LivermorePolarizedPhotoElectricModel::Initialise(), G4LivermorePhotoElectricModel::Initialise(), G4LivermoreComptonModifiedModel::Initialise(), G4LivermoreComptonModel::Initialise(), G4KleinNishinaModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNABornIonisationModel::Initialise(), G4BraggIonModel::Initialise(), G4VEmModel::InitialiseElementSelectors(), G4mplIonisation::InitialiseEnergyLossProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eBremsstrahlung::InitialiseEnergyLossProcess(), G4CoulombScattering::InitialiseProcess(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4VEmProcess::LambdaPhysicsVector(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4eBremsstrahlung::PrintInfo(), G4VEnergyLossProcess::PrintInfoDefinition(), G4VEmProcess::RetrievePhysicsTable(), G4VEmFluctuationModel::~G4VEmFluctuationModel(), G4VEmModel::~G4VEmModel(), G4VEmProcess::~G4VEmProcess(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

00108 {
00109   if(0 == theInstance) {
00110     static G4LossTableManager manager;
00111     theInstance = &manager;
00112   }
00113   return theInstance;
00114 }

G4bool G4LossTableManager::LPMFlag (  )  const

Definition at line 1014 of file G4LossTableManager.cc.

Referenced by G4eBremsstrahlung::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::PrintInfo().

01015 {
01016   return flagLPM;
01017 }

G4double G4LossTableManager::MaxKinEnergy (  )  const

Definition at line 1071 of file G4LossTableManager.cc.

Referenced by G4VMscModel::GetParticleChangeForMSC(), and G4VMultipleScattering::PreparePhysicsTable().

01072 {
01073   return maxKinEnergy;
01074 }

G4double G4LossTableManager::MinKinEnergy (  )  const

Definition at line 1064 of file G4LossTableManager.cc.

Referenced by G4VMscModel::GetParticleChangeForMSC().

01065 {
01066   return minKinEnergy;
01067 }

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

Definition at line 439 of file G4LossTableManager.cc.

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

00441 {
00442   if (1 < verbose) {
00443     G4cout << "G4LossTableManager::PreparePhysicsTable for " 
00444            << particle->GetParticleName() 
00445            << " and " << p->GetProcessName() << G4endl;
00446   }
00447   if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
00448 
00449   // start initialisation for the first run
00450   if( 0 == run ) {
00451     emConfigurator->PrepareModels(particle, p);
00452   } 
00453 }

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

Definition at line 419 of file G4LossTableManager.cc.

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

00421 {
00422   if (1 < verbose) {
00423     G4cout << "G4LossTableManager::PreparePhysicsTable for " 
00424            << particle->GetParticleName() 
00425            << " and " << p->GetProcessName() << G4endl;
00426   }
00427   if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
00428 
00429   // start initialisation for the first run
00430   if( 0 == run ) {
00431     emConfigurator->PrepareModels(particle, p);
00432   }
00433   startInitialisation = true;
00434 }

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

Definition at line 390 of file G4LossTableManager.cc.

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

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

00392 {
00393   if (1 < verbose) {
00394     G4cout << "G4LossTableManager::PreparePhysicsTable for " 
00395            << particle->GetParticleName() 
00396            << " and " << p->GetProcessName() << " run= " << run 
00397            << "   loss_vector " << loss_vector.size() << G4endl;
00398   }
00399   if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
00400 
00401   // start initialisation for the first run
00402   startInitialisation = true;
00403 
00404   if( 0 == run ) {
00405     emConfigurator->PrepareModels(particle, p);
00406 
00407     // initialise particles for given process
00408     for (G4int j=0; j<n_loss; ++j) {
00409       if (p == loss_vector[j]) {
00410         if (!part_vector[j]) { part_vector[j] = particle; }
00411       }
00412     }
00413   }
00414 }

void G4LossTableManager::Register ( G4VEmFluctuationModel p  ) 

Definition at line 334 of file G4LossTableManager.cc.

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

00335 {
00336   fmod_vector.push_back(p);
00337   if(verbose > 1) {
00338     G4cout << "G4LossTableManager::Register G4VEmFluctuationModel : " 
00339            << p->GetName() << G4endl;
00340   }
00341 }

void G4LossTableManager::Register ( G4VEmModel p  ) 

Definition at line 313 of file G4LossTableManager.cc.

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

00314 {
00315   mod_vector.push_back(p);
00316   if(verbose > 1) {
00317     G4cout << "G4LossTableManager::Register G4VEmModel : " 
00318            << p->GetName() << G4endl;
00319   }
00320 }

void G4LossTableManager::Register ( G4VEmProcess p  ) 

Definition at line 286 of file G4LossTableManager.cc.

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

00287 {
00288   if(!p) { return; }
00289   G4int n = emp_vector.size();
00290   for (G4int i=0; i<n; ++i) {
00291     if(emp_vector[i] == p) { return; }
00292   }
00293   if(verbose > 1) {
00294     G4cout << "G4LossTableManager::Register G4VEmProcess : " 
00295            << p->GetProcessName() << "  idx= " << emp_vector.size() << G4endl;
00296   }
00297   emp_vector.push_back(p);
00298 }

void G4LossTableManager::Register ( G4VMultipleScattering p  ) 

Definition at line 259 of file G4LossTableManager.cc.

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

00260 {
00261   if(!p) { return; }
00262   G4int n = msc_vector.size();
00263   for (G4int i=0; i<n; ++i) {
00264     if(msc_vector[i] == p) { return; }
00265   }
00266   if(verbose > 1) {
00267     G4cout << "G4LossTableManager::Register G4VMultipleScattering : " 
00268            << p->GetProcessName() << "  idx= " << msc_vector.size() << G4endl;
00269   }
00270   msc_vector.push_back(p);
00271 }

void G4LossTableManager::Register ( G4VEnergyLossProcess p  ) 

Definition at line 218 of file G4LossTableManager.cc.

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

Referenced by G4VEmFluctuationModel::G4VEmFluctuationModel(), G4VEmModel::G4VEmModel(), and G4VMultipleScattering::G4VMultipleScattering().

00219 {
00220   if(!p) { return; }
00221   for (G4int i=0; i<n_loss; ++i) {
00222     if(loss_vector[i] == p) { return; }
00223   }
00224   if(verbose > 1) {
00225     G4cout << "G4LossTableManager::Register G4VEnergyLossProcess : " 
00226            << p->GetProcessName() << "  idx= " << n_loss << G4endl;
00227   }
00228   ++n_loss;
00229   loss_vector.push_back(p);
00230   part_vector.push_back(0);
00231   base_part_vector.push_back(0);
00232   dedx_vector.push_back(0);
00233   range_vector.push_back(0);
00234   inv_range_vector.push_back(0);
00235   tables_are_built.push_back(false);
00236   isActive.push_back(true);
00237   all_tables_are_built = false;
00238   if(!lossFluctuationFlag) { p->SetLossFluctuations(false); }
00239   if(subCutoffFlag)        { p->ActivateSubCutoff(true); }
00240   if(rndmStepFlag)         { p->SetRandomStep(true); }
00241   if(stepFunctionActive)   { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
00242   if(integralActive)       { p->SetIntegral(integral); }
00243   if(minEnergyActive)      { p->SetMinKinEnergy(minKinEnergy); }
00244   if(maxEnergyActive)      { p->SetMaxKinEnergy(maxKinEnergy); }
00245 }

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

Definition at line 363 of file G4LossTableManager.cc.

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

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

00366 { 
00367   if(!p || !part) { return; }
00368   for (G4int i=0; i<n_loss; ++i) {
00369     if(loss_vector[i] == p) { return; }
00370   }
00371   if(verbose > 1) {
00372     G4cout << "G4LossTableManager::RegisterExtraParticle "
00373            << part->GetParticleName() << "  G4VEnergyLossProcess : " 
00374            << p->GetProcessName() << "  idx= " << n_loss << G4endl;
00375   }
00376   ++n_loss;
00377   loss_vector.push_back(p);
00378   part_vector.push_back(part);
00379   base_part_vector.push_back(p->BaseParticle());
00380   dedx_vector.push_back(0);
00381   range_vector.push_back(0);
00382   inv_range_vector.push_back(0);
00383   tables_are_built.push_back(false);
00384   all_tables_are_built = false;
00385 }

void G4LossTableManager::RegisterIon ( const G4ParticleDefinition aParticle,
G4VEnergyLossProcess p 
)

Definition at line 355 of file G4LossTableManager.cc.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

00357 {
00358   loss_map[ion] = p;
00359 }

void G4LossTableManager::SetAtomDeexcitation ( G4VAtomDeexcitation  ) 

Definition at line 1120 of file G4LossTableManager.cc.

Referenced by G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmDNAPhysicsChemistry::ConstructProcess(), and G4EmDNAPhysics::ConstructProcess().

01121 {
01122   atomDeexcitation = p;
01123 }

void G4LossTableManager::SetBremsstrahlungTh ( G4double  val  ) 

Definition at line 1036 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetBremsstrahlungTh().

01037 {
01038   bremsTh = val;
01039 }

void G4LossTableManager::SetBuildCSDARange ( G4bool  val  ) 

Definition at line 960 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetBuildCSDARange().

00961 {
00962   buildCSDARange = val;
00963 }

void G4LossTableManager::SetDEDXBinning ( G4int  val  ) 

Definition at line 871 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetDEDXBinning().

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

void G4LossTableManager::SetDEDXBinningForCSDARange ( G4int  val  ) 

Definition at line 880 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetDEDXBinningForCSDARange().

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

void G4LossTableManager::SetFactorForAngleLimit ( G4double  val  ) 

Definition at line 1050 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetFactorForAngleLimit().

01051 {
01052   if(val > 0.0) { factorForAngleLimit = val; }
01053 }

void G4LossTableManager::SetIntegral ( G4bool  val  ) 

Definition at line 789 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetIntegral().

00790 {
00791   integral = val;
00792   integralActive = true;
00793   for(G4int i=0; i<n_loss; ++i) {
00794     if(loss_vector[i]) { loss_vector[i]->SetIntegral(val); }
00795   }
00796   size_t emp = emp_vector.size();
00797   for (size_t k=0; k<emp; ++k) {
00798     if(emp_vector[k]) { emp_vector[k]->SetIntegral(val); }
00799   }
00800 }

void G4LossTableManager::SetLambdaBinning ( G4int  val  ) 

Definition at line 889 of file G4LossTableManager.cc.

References G4cout, G4endl, and CLHEP::detail::n.

Referenced by G4EmProcessOptions::SetLambdaBinning().

00890 {
00891   G4int n = val/G4int(std::log10(maxKinEnergy/minKinEnergy) + 0.5);
00892   if(n < 5) {
00893     G4cout << "G4LossTableManager::SetLambdaBinning WARNING "
00894            << "too small number of bins " << val << "  ignored" 
00895            << G4endl;
00896     return;
00897   } 
00898   nbinsLambda = val;
00899   nbinsPerDecade = n;
00900   size_t emp = emp_vector.size();
00901   for (size_t k=0; k<emp; ++k) {
00902     if(emp_vector[k]) { emp_vector[k]->SetLambdaBinning(val); }
00903   }
00904 }

void G4LossTableManager::SetLinearLossLimit ( G4double  val  ) 

Definition at line 951 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetLinearLossLimit().

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

void G4LossTableManager::SetLossFluctuations ( G4bool  val  ) 

Definition at line 769 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetLossFluctuations().

00770 {
00771   lossFluctuationFlag = val;
00772   for(G4int i=0; i<n_loss; ++i) {
00773     if(loss_vector[i]) { loss_vector[i]->SetLossFluctuations(val); }
00774   }
00775 }

void G4LossTableManager::SetLPMFlag ( G4bool  val  ) 

Definition at line 1007 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetLPMFlag().

01008 {
01009   flagLPM = val;
01010 }

void G4LossTableManager::SetMaxEnergy ( G4double  val  ) 

Definition at line 839 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMaxEnergy().

00840 {
00841   maxEnergyActive = true;
00842   maxKinEnergy = val;
00843   for(G4int i=0; i<n_loss; ++i) {
00844     if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergy(val); }
00845   }
00846   size_t emp = emp_vector.size();
00847   for (size_t k=0; k<emp; ++k) {
00848     if(emp_vector[k]) { emp_vector[k]->SetMaxKinEnergy(val); }
00849   }
00850 }

void G4LossTableManager::SetMaxEnergyForCSDARange ( G4double  val  ) 

Definition at line 854 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMaxEnergyForCSDARange().

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

void G4LossTableManager::SetMaxEnergyForMuons ( G4double  val  ) 

Definition at line 863 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMaxEnergyForMuons().

00864 {
00865   maxEnergyForMuonsActive = true;
00866   maxKinEnergyForMuons = val;
00867 }

void G4LossTableManager::SetMinEnergy ( G4double  val  ) 

Definition at line 824 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMinEnergy().

00825 {
00826   minEnergyActive = true;
00827   minKinEnergy = val;
00828   for(G4int i=0; i<n_loss; ++i) {
00829     if(loss_vector[i]) { loss_vector[i]->SetMinKinEnergy(val); }
00830   }
00831   size_t emp = emp_vector.size();
00832   for (size_t k=0; k<emp; ++k) {
00833     if(emp_vector[k]) { emp_vector[k]->SetMinKinEnergy(val); }
00834   }
00835 }

void G4LossTableManager::SetMinSubRange ( G4double  val  ) 

Definition at line 804 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetMinSubRange().

00805 {
00806   minSubRange = val;
00807   for(G4int i=0; i<n_loss; ++i) {
00808     if(loss_vector[i]) { loss_vector[i]->SetMinSubRange(val); }
00809   }
00810 }

void G4LossTableManager::SetRandomStep ( G4bool  val  ) 

Definition at line 814 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetRandomStep().

00815 {
00816   rndmStepFlag = val;
00817   for(G4int i=0; i<n_loss; ++i) {
00818     if(loss_vector[i]) { loss_vector[i]->SetRandomStep(val); }
00819   }
00820 }

void G4LossTableManager::SetSplineFlag ( G4bool  val  ) 

Definition at line 1021 of file G4LossTableManager.cc.

References G4LossTableBuilder::SetSplineFlag().

Referenced by G4EmProcessOptions::SetSplineFlag().

01022 {
01023   splineFlag = val;
01024   tableBuilder->SetSplineFlag(splineFlag);
01025 }

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

Definition at line 939 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetStepFunction().

00940 {
00941   stepFunctionActive = true;
00942   maxRangeVariation = v1;
00943   maxFinalStep = v2;
00944   for(G4int i=0; i<n_loss; ++i) {
00945     if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
00946   }
00947 }

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

Definition at line 779 of file G4LossTableManager.cc.

Referenced by G4EmProcessOptions::SetSubCutoff().

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

void G4LossTableManager::SetVerbose ( G4int  val  ) 

Definition at line 915 of file G4LossTableManager.cc.

References G4ElectronIonPair::SetVerbose(), G4EmSaturation::SetVerbose(), G4EmConfigurator::SetVerbose(), and G4VAtomDeexcitation::SetVerboseLevel().

Referenced by G4EmProcessOptions::SetVerbose().

00916 {
00917   verbose = val;
00918   for(G4int i=0; i<n_loss; ++i) {
00919     if(loss_vector[i]) { loss_vector[i]->SetVerboseLevel(val); }
00920   }
00921   size_t msc = msc_vector.size();
00922   for (size_t j=0; j<msc; ++j) {
00923     if(msc_vector[j]) { msc_vector[j]->SetVerboseLevel(val); }
00924   }
00925   size_t emp = emp_vector.size();
00926   for (size_t k=0; k<emp; ++k) {
00927     if(emp_vector[k]) { emp_vector[k]->SetVerboseLevel(val); }
00928   }
00929   emConfigurator->SetVerbose(val);
00930   //tableBuilder->SetVerbose(val);
00931   //emCorrections->SetVerbose(val);
00932   emSaturation->SetVerbose(val);
00933   emElectronIonPair->SetVerbose(val);
00934   if(atomDeexcitation) { atomDeexcitation->SetVerboseLevel(val); }
00935 }

G4bool G4LossTableManager::SplineFlag (  )  const

Definition at line 1029 of file G4LossTableManager.cc.

01030 {
01031   return splineFlag;
01032 }


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:27 2013 for Geant4 by  doxygen 1.4.7