#include <G4LossTableManager.hh>
Definition at line 99 of file G4LossTableManager.hh.
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 }
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().
G4double G4LossTableManager::BremsstrahlungTh | ( | ) | const |
Definition at line 1043 of file G4LossTableManager.cc.
Referenced by G4eBremsstrahlung::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::PrintInfo().
G4bool G4LossTableManager::BuildCSDARange | ( | ) | const |
Definition at line 762 of file G4LossTableManager.cc.
Referenced by G4VEnergyLossProcess::PreparePhysicsTable().
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 | ( | ) |
G4EmConfigurator * G4LossTableManager::EmConfigurator | ( | ) |
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().
G4EmSaturation * G4LossTableManager::EmSaturation | ( | ) |
Definition at line 1085 of file G4LossTableManager.cc.
Referenced by G4OpticalPhysics::ConstructProcess().
G4double G4LossTableManager::FactorForAngleLimit | ( | ) | const |
Definition at line 1057 of file G4LossTableManager.cc.
Referenced by G4WentzelVIRelXSection::Initialise(), G4WentzelOKandVIxSection::Initialise(), and G4CoulombScattering::InitialiseProcess().
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().
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().
G4EnergyLossMessenger * G4LossTableManager::GetMessenger | ( | ) |
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().
G4int G4LossTableManager::GetNumberOfBinsPerDecade | ( | ) | const |
Definition at line 908 of file G4LossTableManager.cc.
Referenced by G4LossTableBuilder::BuildTableForModel(), and G4VEmModel::InitialiseElementSelectors().
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().
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().
G4double G4LossTableManager::MaxKinEnergy | ( | ) | const |
Definition at line 1071 of file G4LossTableManager.cc.
Referenced by G4VMscModel::GetParticleChangeForMSC(), and G4VMultipleScattering::PreparePhysicsTable().
G4double G4LossTableManager::MinKinEnergy | ( | ) | const |
Definition at line 1064 of file G4LossTableManager.cc.
Referenced by G4VMscModel::GetParticleChangeForMSC().
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().
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().
void G4LossTableManager::SetBremsstrahlungTh | ( | G4double | val | ) |
Definition at line 1036 of file G4LossTableManager.cc.
Referenced by G4EmProcessOptions::SetBremsstrahlungTh().
void G4LossTableManager::SetBuildCSDARange | ( | G4bool | val | ) |
Definition at line 960 of file G4LossTableManager.cc.
Referenced by G4EmProcessOptions::SetBuildCSDARange().
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().
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().
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().
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 }
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 }
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 |