Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer << 3 // * DISCLAIMER * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers * 6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which * 7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: * 8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license * 9 // * include a list of copyright holders. << 10 // * 9 // * * 11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file << 14 // * use. * 16 // * for the full disclaimer and the limitatio << 17 // * 15 // * * 18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the * 19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. * 20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work * 21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this * 22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. * 23 // * acceptance of all terms of the Geant4 Sof << 24 // ******************************************* 21 // ******************************************************************** 25 // 22 // >> 23 // $Id: G4LossTableManager.cc,v 1.40 2004/01/21 18:05:10 vnivanch Exp $ >> 24 // GEANT4 tag $Name: geant4-06-00-patch-01 $ >> 25 // 26 // ------------------------------------------- 26 // ------------------------------------------------------------------- 27 // 27 // 28 // GEANT4 Class file 28 // GEANT4 Class file 29 // 29 // 30 // 30 // 31 // File name: G4LossTableManager 31 // File name: G4LossTableManager 32 // 32 // 33 // Author: Vladimir Ivanchenko 33 // Author: Vladimir Ivanchenko 34 // 34 // 35 // Creation date: 03.01.2002 35 // Creation date: 03.01.2002 36 // 36 // 37 // Modifications: by V.Ivanchenko << 37 // Modifications: 38 // 38 // >> 39 // 20-01-03 Migrade to cut per region (V.Ivanchenko) >> 40 // 15-02-03 Lambda table can be scaled (V.Ivanchenko) >> 41 // 17-02-03 Fix problem of store/restore tables (V.Ivanchenko) >> 42 // 10-03-03 Add Ion registration (V.Ivanchenko) >> 43 // 25-03-03 Add deregistration (V.Ivanchenko) >> 44 // 02-04-03 Change messenger (V.Ivanchenko) >> 45 // 26-04-03 Fix retrieve tables (V.Ivanchenko) >> 46 // 13-05-03 Add calculation of precise range (V.Ivanchenko) >> 47 // 23-07-03 Add exchange with G4EnergyLossTables (V.Ivanchenko) >> 48 // 05-10-03 Add G4VEmProcesses registration and Verbose command (V.Ivanchenko) >> 49 // 17-10-03 Add SetParameters method (V.Ivanchenko) >> 50 // 23-10-03 Add control on inactive processes (V.Ivanchenko) >> 51 // 04-11-03 Add checks in RetrievePhysicsTable (V.Ivanchenko) >> 52 // 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko) >> 53 // 14-01-04 Activate precise range calculation (V.Ivanchenko) 39 // 54 // 40 // Class Description: 55 // Class Description: 41 // 56 // 42 // ------------------------------------------- 57 // ------------------------------------------------------------------- 43 // 58 // 44 //....oooOO0OOooo........oooOO0OOooo........oo 59 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 45 //....oooOO0OOooo........oooOO0OOooo........oo 60 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 46 61 47 #include "G4LossTableManager.hh" 62 #include "G4LossTableManager.hh" 48 #include "G4SystemOfUnits.hh" << 63 #include "G4EnergyLossMessenger.hh" 49 << 50 #include "G4VMultipleScattering.hh" << 51 #include "G4VEmProcess.hh" << 52 << 53 #include "G4EmParameters.hh" << 54 #include "G4EmSaturation.hh" << 55 #include "G4EmConfigurator.hh" << 56 #include "G4ElectronIonPair.hh" << 57 #include "G4NIELCalculator.hh" << 58 #include "G4EmCorrections.hh" << 59 #include "G4LossTableBuilder.hh" << 60 #include "G4VAtomDeexcitation.hh" << 61 #include "G4VSubCutProducer.hh" << 62 << 63 #include "G4PhysicsTable.hh" 64 #include "G4PhysicsTable.hh" 64 #include "G4ParticleDefinition.hh" 65 #include "G4ParticleDefinition.hh" 65 #include "G4MaterialCutsCouple.hh" 66 #include "G4MaterialCutsCouple.hh" 66 #include "G4ProcessManager.hh" 67 #include "G4ProcessManager.hh" 67 #include "G4Electron.hh" 68 #include "G4Electron.hh" 68 #include "G4Proton.hh" 69 #include "G4Proton.hh" >> 70 #include "G4VMultipleScattering.hh" >> 71 #include "G4VEmProcess.hh" 69 #include "G4ProductionCutsTable.hh" 72 #include "G4ProductionCutsTable.hh" 70 #include "G4PhysicsTableHelper.hh" << 71 #include "G4EmTableType.hh" << 72 #include "G4Region.hh" << 73 #include "G4PhysicalConstants.hh" << 74 << 75 #include "G4Gamma.hh" << 76 #include "G4Positron.hh" << 77 #include "G4OpticalPhoton.hh" << 78 #include "G4Neutron.hh" << 79 #include "G4MuonPlus.hh" << 80 #include "G4MuonMinus.hh" << 81 #include "G4GenericIon.hh" << 82 73 83 //....oooOO0OOooo........oooOO0OOooo........oo << 74 G4LossTableManager* G4LossTableManager::theInstance = 0; 84 75 85 static std::once_flag applyOnce; << 76 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 86 G4ThreadLocal G4LossTableManager* G4LossTableM << 87 77 88 G4LossTableManager* G4LossTableManager::Instan 78 G4LossTableManager* G4LossTableManager::Instance() 89 { 79 { 90 if(nullptr == instance) { << 80 if(0 == theInstance) { 91 static G4ThreadLocalSingleton<G4LossTableM << 81 static G4LossTableManager manager; 92 instance = inst.Instance(); << 82 theInstance = &manager; 93 } 83 } 94 return instance; << 84 return theInstance; 95 } 85 } 96 86 97 //....oooOO0OOooo........oooOO0OOooo........oo 87 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 98 88 99 G4LossTableManager::~G4LossTableManager() 89 G4LossTableManager::~G4LossTableManager() 100 { 90 { 101 for (auto const & p : loss_vector) { delete << 91 for (G4int i=0; i<n_loss; i++) { 102 for (auto const & p : msc_vector) { delete p << 92 if( loss_vector[i] ) delete loss_vector[i]; 103 for (auto const & p : emp_vector) { delete p << 93 } 104 for (auto const & p : p_vector) { delete p; << 94 size_t msc = msc_vector.size(); 105 << 95 for (size_t j=0; j<msc; j++) { 106 std::size_t mod = mod_vector.size(); << 96 if(msc_vector[j] ) delete msc_vector[j]; 107 std::size_t fmod = fmod_vector.size(); << 97 } 108 for (std::size_t a=0; a<mod; ++a) { << 98 size_t emp = emp_vector.size(); 109 if( nullptr != mod_vector[a] ) { << 99 for (size_t k=0; k<emp; k++) { 110 for (std::size_t b=0; b<fmod; ++b) { << 100 if(emp_vector[k] ) delete emp_vector[k]; 111 if((G4VEmModel*)(fmod_vector[b]) == mo << 112 fmod_vector[b] = nullptr; << 113 } << 114 } << 115 delete mod_vector[a]; << 116 mod_vector[a] = nullptr; << 117 } << 118 } 101 } 119 for (auto const & p : fmod_vector) { delete << 120 << 121 Clear(); 102 Clear(); >> 103 delete theMessenger; 122 delete tableBuilder; 104 delete tableBuilder; 123 delete emCorrections; << 124 delete emConfigurator; << 125 delete emElectronIonPair; << 126 delete nielCalculator; << 127 delete atomDeexcitation; << 128 delete subcutProducer; << 129 } 105 } 130 106 131 //....oooOO0OOooo........oooOO0OOooo........oo 107 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 132 108 133 G4LossTableManager::G4LossTableManager() 109 G4LossTableManager::G4LossTableManager() 134 { 110 { 135 theParameters = G4EmParameters::Instance(); << 111 n_loss = 0; 136 theElectron = G4Electron::Electron(); << 112 first_entry = true; 137 << 113 all_tables_are_built = false; 138 // only one thread is the master << 114 all_tables_are_stored = false; 139 std::call_once(applyOnce, [this]() { isMaste << 115 electron_table_are_built = false; 140 verbose = isMaster ? theParameters->Verbose( << 116 currentLoss = 0; 141 << 117 currentParticle = 0; 142 tableBuilder = new G4LossTableBuilder(isMast << 118 lossFluctuationFlag = true; 143 emCorrections = new G4EmCorrections(verbose) << 119 subCutoffFlag = false; 144 << 120 rndmStepFlag = false; 145 std::size_t n = 70; << 121 minSubRange = 0.0; 146 loss_vector.reserve(n); << 122 maxRangeVariation = 1.0; 147 part_vector.reserve(n); << 123 maxFinalStep = 0.0; 148 base_part_vector.reserve(n); << 124 eIonisation = 0; 149 dedx_vector.reserve(n); << 125 minKinEnergy = 0.1*keV; 150 range_vector.reserve(n); << 126 maxKinEnergy = 100.0*TeV; 151 inv_range_vector.reserve(n); << 127 maxKinEnergyForMuons = 100.*TeV; 152 tables_are_built.reserve(n); << 128 theMessenger = new G4EnergyLossMessenger(); 153 isActive.reserve(n); << 129 theElectron = G4Electron::Electron(); 154 msc_vector.reserve(10); << 130 tableBuilder = new G4LossTableBuilder(); 155 emp_vector.reserve(16); << 131 integral = true; 156 mod_vector.reserve(150); << 132 integralActive = false; 157 fmod_vector.reserve(60); << 133 buildPreciseRange = false; >> 134 minEnergyActive = false; >> 135 maxEnergyActive = false; >> 136 maxEnergyForMuonsActive = false; >> 137 stepFunctionActive = false; >> 138 verbose = 0; 158 } 139 } 159 140 160 //....oooOO0OOooo........oooOO0OOooo........oo 141 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 161 142 162 void G4LossTableManager::Clear() 143 void G4LossTableManager::Clear() 163 { 144 { 164 all_tables_are_built = false; 145 all_tables_are_built = false; 165 currentLoss = nullptr; << 146 electron_table_are_built = false; 166 currentParticle = nullptr; << 147 eIonisation = 0; 167 if(n_loss) { << 148 currentLoss = 0; 168 dedx_vector.clear(); << 149 currentParticle = 0; 169 range_vector.clear(); << 150 if(n_loss) 170 inv_range_vector.clear(); << 151 { 171 loss_map.clear(); << 152 dedx_vector.clear(); 172 loss_vector.clear(); << 153 range_vector.clear(); 173 part_vector.clear(); << 154 inv_range_vector.clear(); 174 base_part_vector.clear(); << 155 loss_map.clear(); 175 tables_are_built.clear(); << 156 loss_vector.clear(); 176 isActive.clear(); << 157 part_vector.clear(); 177 n_loss = 0; << 158 base_part_vector.clear(); 178 } << 159 tables_are_built.clear(); >> 160 n_loss = 0; >> 161 } 179 } 162 } 180 163 181 //....oooOO0OOooo........oooOO0OOooo........oo 164 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 182 165 183 void G4LossTableManager::Register(G4VEnergyLos 166 void G4LossTableManager::Register(G4VEnergyLossProcess* p) 184 { 167 { 185 if (nullptr == p) { return; } << 168 n_loss++; 186 for (G4int i=0; i<n_loss; ++i) { << 187 if(loss_vector[i] == p) { return; } << 188 } << 189 if(verbose > 1) { << 190 G4cout << "G4LossTableManager::Register G4 << 191 << p->GetProcessName() << " idx= " << 192 } << 193 ++n_loss; << 194 loss_vector.push_back(p); 169 loss_vector.push_back(p); 195 part_vector.push_back(nullptr); << 170 part_vector.push_back(0); 196 base_part_vector.push_back(nullptr); << 171 base_part_vector.push_back(0); 197 dedx_vector.push_back(nullptr); << 172 dedx_vector.push_back(0); 198 range_vector.push_back(nullptr); << 173 range_vector.push_back(0); 199 inv_range_vector.push_back(nullptr); << 174 inv_range_vector.push_back(0); 200 tables_are_built.push_back(false); 175 tables_are_built.push_back(false); 201 isActive.push_back(true); << 202 all_tables_are_built = false; 176 all_tables_are_built = false; 203 } << 177 if(!lossFluctuationFlag) p->SetLossFluctuations(false); 204 << 178 if(subCutoffFlag) p->SetSubCutoff(true); 205 //....oooOO0OOooo........oooOO0OOooo........oo << 179 if(rndmStepFlag) p->SetRandomStep(true); 206 << 180 if(stepFunctionActive) p->SetStepFunction(maxRangeVariation, maxFinalStep); 207 void G4LossTableManager::ResetParameters() << 181 if(integralActive) p->SetIntegral(integral); 208 { << 182 if(minEnergyActive) p->SetMinKinEnergy(minKinEnergy); 209 // initialisation once per run << 183 if(maxEnergyActive) p->SetMaxKinEnergy(maxKinEnergy); 210 if (!resetParam) { return; } << 211 resetParam = false; << 212 startInitialisation = true; << 213 verbose = theParameters->Verbose(); << 214 if(!isMaster) { << 215 verbose = theParameters->WorkerVerbose(); << 216 } else { << 217 if(verbose > 0) { theParameters->Dump(); } << 218 } << 219 << 220 tableBuilder->InitialiseBaseMaterials(); << 221 if (nullptr != nielCalculator) { nielCalcula << 222 << 223 emCorrections->SetVerbose(verbose); << 224 if(nullptr != emConfigurator) { emConfigurat << 225 if(nullptr != emElectronIonPair) { emElectro << 226 if(nullptr != atomDeexcitation) { << 227 atomDeexcitation->SetVerboseLevel(verbose) << 228 atomDeexcitation->InitialiseAtomicDeexcita << 229 } << 230 if (1 < verbose) { << 231 G4cout << "====== G4LossTableManager::Rese << 232 << " Nloss=" << loss_vector.size() << 233 << " run=" << run << " master=" << isMast << 234 << G4endl; << 235 } << 236 } 184 } 237 185 238 //....oooOO0OOooo........oooOO0OOooo........oo 186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 239 187 240 void G4LossTableManager::DeRegister(G4VEnergyL 188 void G4LossTableManager::DeRegister(G4VEnergyLossProcess* p) 241 { 189 { 242 if (nullptr == p) { return; } << 190 for (G4int i=0; i<n_loss; i++) { 243 for (G4int i=0; i<n_loss; ++i) { << 191 if(loss_vector[i] == p) loss_vector[i] = 0; 244 if(loss_vector[i] == p) { << 245 loss_vector[i] = nullptr; << 246 break; << 247 } << 248 } 192 } 249 } 193 } 250 194 251 //....oooOO0OOooo........oooOO0OOooo........oo 195 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 252 196 253 void G4LossTableManager::Register(G4VMultipleS 197 void G4LossTableManager::Register(G4VMultipleScattering* p) 254 { 198 { 255 if (nullptr == p) { return; } << 256 std::size_t n = msc_vector.size(); << 257 for (std::size_t i=0; i<n; ++i) { << 258 if(msc_vector[i] == p) { return; } << 259 } << 260 if(verbose > 1) { << 261 G4cout << "G4LossTableManager::Register G4 << 262 << p->GetProcessName() << " idx= " << 263 } << 264 msc_vector.push_back(p); 199 msc_vector.push_back(p); 265 } 200 } 266 201 267 //....oooOO0OOooo........oooOO0OOooo........oo 202 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 268 203 269 void G4LossTableManager::DeRegister(G4VMultipl 204 void G4LossTableManager::DeRegister(G4VMultipleScattering* p) 270 { 205 { 271 if (nullptr == p) { return; } << 206 size_t msc = msc_vector.size(); 272 std::size_t msc = msc_vector.size(); << 207 for (size_t i=0; i<msc; i++) { 273 for (std::size_t i=0; i<msc; ++i) { << 208 if(msc_vector[i] == p) msc_vector[i] = 0; 274 if(msc_vector[i] == p) { << 275 msc_vector[i] = nullptr; << 276 break; << 277 } << 278 } 209 } 279 } 210 } 280 211 281 //....oooOO0OOooo........oooOO0OOooo........oo 212 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 282 213 283 void G4LossTableManager::Register(G4VEmProcess 214 void G4LossTableManager::Register(G4VEmProcess* p) 284 { 215 { 285 if (nullptr == p) { return; } << 286 std::size_t n = emp_vector.size(); << 287 for (std::size_t i=0; i<n; ++i) { << 288 if(emp_vector[i] == p) { return; } << 289 } << 290 if(verbose > 1) { << 291 G4cout << "G4LossTableManager::Register G4 << 292 << p->GetProcessName() << " idx= " << 293 } << 294 emp_vector.push_back(p); 216 emp_vector.push_back(p); 295 } 217 } 296 218 297 //....oooOO0OOooo........oooOO0OOooo........oo 219 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 298 220 299 void G4LossTableManager::DeRegister(G4VEmProce 221 void G4LossTableManager::DeRegister(G4VEmProcess* p) 300 { 222 { 301 if (nullptr == p) { return; } << 223 size_t emp = emp_vector.size(); 302 std::size_t emp = emp_vector.size(); << 224 for (size_t i=0; i<emp; i++) { 303 for (std::size_t i=0; i<emp; ++i) { << 225 if(emp_vector[i] == p) emp_vector[i] = 0; 304 if(emp_vector[i] == p) { << 305 emp_vector[i] = nullptr; << 306 break; << 307 } << 308 } 226 } 309 } 227 } 310 228 311 //....oooOO0OOooo........oooOO0OOooo........oo 229 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 312 230 313 void G4LossTableManager::Register(G4VProcess* << 231 void G4LossTableManager::RegisterIon(const G4ParticleDefinition* ion, G4VEnergyLossProcess* p) 314 { 232 { 315 if (nullptr == p) { return; } << 233 loss_map[ion] = p; 316 std::size_t n = p_vector.size(); << 317 for (std::size_t i=0; i<n; ++i) { << 318 if(p_vector[i] == p) { return; } << 319 } << 320 if(verbose > 1) { << 321 G4cout << "G4LossTableManager::Register G4 << 322 << p->GetProcessName() << " idx= " << 323 } << 324 p_vector.push_back(p); << 325 } 234 } 326 235 327 //....oooOO0OOooo........oooOO0OOooo........oo 236 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 328 237 329 void G4LossTableManager::DeRegister(G4VProcess << 238 G4EnergyLossMessenger* G4LossTableManager::GetMessenger() 330 { 239 { 331 if (nullptr == p) { return; } << 240 return theMessenger; 332 std::size_t emp = p_vector.size(); << 333 for (std::size_t i=0; i<emp; ++i) { << 334 if(p_vector[i] == p) { << 335 p_vector[i] = nullptr; << 336 break; << 337 } << 338 } << 339 } 241 } 340 242 341 //....oooOO0OOooo........oooOO0OOooo........oo 243 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 342 244 343 void G4LossTableManager::Register(G4VEmModel* << 245 void G4LossTableManager::ParticleHaveNoLoss(const G4ParticleDefinition* aParticle) 344 { 246 { 345 mod_vector.push_back(p); << 247 G4String s = "G4LossTableManager:: dE/dx table not found for " 346 if(verbose > 1) { << 248 + aParticle->GetParticleName() + "!"; 347 G4cout << "G4LossTableManager::Register G4 << 249 G4Exception(s); 348 << p->GetName() << " " << p << " << 250 exit(1); 349 } << 350 } 251 } 351 252 352 //....oooOO0OOooo........oooOO0OOooo........oo 253 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 353 254 354 void G4LossTableManager::DeRegister(G4VEmModel << 255 G4bool G4LossTableManager::IsRecalcNeeded(const G4ParticleDefinition* aParticle) 355 { 256 { 356 //G4cout << "G4LossTableManager::DeRegister << 257 G4bool isNeeded = !all_tables_are_built; 357 std::size_t n = mod_vector.size(); << 258 if (first_entry || (aParticle == firstParticle && all_tables_are_built) ) { 358 for (std::size_t i=0; i<n; ++i) { << 259 isNeeded = true; 359 if(mod_vector[i] == p) { << 260 all_tables_are_built = false; 360 mod_vector[i] = nullptr; << 261 electron_table_are_built = false; 361 break; << 262 loss_map.clear(); >> 263 for (G4int i=0; i<n_loss; i++) { >> 264 if(loss_vector[i]) { >> 265 const G4ProcessManager* pm = loss_vector[i]->GetProcessManager(); >> 266 if (pm->GetProcessActivation(loss_vector[i])) tables_are_built[i] = false; >> 267 else tables_are_built[i] = true; >> 268 } else { >> 269 tables_are_built[i] = true; >> 270 part_vector[i] = 0; >> 271 } 362 } 272 } >> 273 Initialise(); 363 } 274 } 364 } << 365 << 366 //....oooOO0OOooo........oooOO0OOooo........oo << 367 << 368 void G4LossTableManager::Register(G4VEmFluctua << 369 { << 370 fmod_vector.push_back(p); << 371 if(verbose > 1) { << 372 G4cout << "G4LossTableManager::Register G4 << 373 << p->GetName() << " " << fmod_vec << 374 } << 375 } << 376 << 377 //....oooOO0OOooo........oooOO0OOooo........oo << 378 275 379 void G4LossTableManager::DeRegister(G4VEmFluct << 276 if (first_entry) { 380 { << 277 first_entry = false; 381 std::size_t n = fmod_vector.size(); << 278 firstParticle = aParticle; 382 for (std::size_t i=0; i<n; ++i) { << 383 if(fmod_vector[i] == p) { fmod_vector[i] = << 384 } 279 } 385 } << 386 << 387 //....oooOO0OOooo........oooOO0OOooo........oo << 388 280 389 void G4LossTableManager::RegisterExtraParticle << 281 return isNeeded; 390 const G4ParticleDefinition* part, << 391 G4VEnergyLossProcess* p) << 392 { << 393 if (nullptr == p || nullptr == part) { retur << 394 for (G4int i=0; i<n_loss; ++i) { << 395 if(loss_vector[i] == p) { return; } << 396 } << 397 if(verbose > 1) { << 398 G4cout << "G4LossTableManager::RegisterExt << 399 << part->GetParticleName() << " G4 << 400 << p->GetProcessName() << " idx= " << 401 } << 402 ++n_loss; << 403 loss_vector.push_back(p); << 404 part_vector.push_back(part); << 405 base_part_vector.push_back(p->BaseParticle() << 406 dedx_vector.push_back(nullptr); << 407 range_vector.push_back(nullptr); << 408 inv_range_vector.push_back(nullptr); << 409 tables_are_built.push_back(false); << 410 all_tables_are_built = false; << 411 } 282 } 412 283 413 //....oooOO0OOooo........oooOO0OOooo........oo 284 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 414 285 415 G4VEnergyLossProcess* << 286 void G4LossTableManager::Initialise() 416 G4LossTableManager::GetEnergyLossProcess(const << 417 { 287 { 418 if(aParticle != currentParticle) { << 419 currentParticle = aParticle; << 420 std::map<PD,G4VEnergyLossProcess*,std::les << 421 if ((pos = loss_map.find(aParticle)) != lo << 422 currentLoss = (*pos).second; << 423 } else { << 424 currentLoss = nullptr; << 425 if(0.0 != aParticle->GetPDGCharge() && << 426 (pos = loss_map.find(theGenericIon)) != los << 427 currentLoss = (*pos).second; << 428 } << 429 } << 430 } << 431 return currentLoss; << 432 } << 433 288 434 //....oooOO0OOooo........oooOO0OOooo........oo << 289 for(G4int j=0; j<n_loss; j++) { 435 290 436 void << 291 if (loss_vector[j]) { 437 G4LossTableManager::PreparePhysicsTable(const << 292 const G4ParticleDefinition* pd = loss_vector[j]->Particle(); 438 G4VEne << 293 if (!pd) { 439 { << 294 pd = loss_vector[j]->GetProcessManager()->GetParticleType(); 440 if (1 < verbose) { << 295 loss_vector[j]->SetParticle(pd); 441 G4cout << "G4LossTableManager::PreparePhys << 296 } 442 << particle->GetParticleName() << 297 if(maxEnergyForMuonsActive) { 443 << " and " << p->GetProcessName() < << 298 G4double dm = abs(pd->GetPDGMass() - 105.7*MeV); 444 << " loss_vector " << loss_vector << 299 if(dm < 5.*MeV) loss_vector[j]->SetMaxKinEnergy(maxKinEnergyForMuons); 445 << " run=" << run << " master=" << isMast << 300 } 446 << G4endl; << 301 if(!tables_are_built[j]) all_tables_are_built = false; 447 } << 302 if(pd != part_vector[j]) { 448 << 303 part_vector[j] = pd; 449 // start initialisation for the first run << 304 base_part_vector[j] = loss_vector[j]->BaseParticle(); 450 if( -1 == run ) { << 305 } 451 if (nullptr != emConfigurator) { emConfigu << 306 if(0 < verbose) { 452 << 307 G4String nm = "unknown"; 453 // initialise particles for given process << 308 if(pd) nm = pd->GetParticleName(); 454 for (G4int j=0; j<n_loss; ++j) { << 309 G4cout << "For " << loss_vector[j]->GetProcessName() 455 if (p == loss_vector[j] && nullptr == pa << 310 << " for " << nm 456 part_vector[j] = particle; << 311 << " tables_are_built= " << tables_are_built[j] 457 if (particle->GetParticleName() == "Ge << 312 << " procFlag= " << loss_vector[j]->TablesAreBuilt() 458 theGenericIon = particle; << 313 << " all_tables_are_built= " << all_tables_are_built 459 } << 314 << G4endl; 460 } 315 } 461 } 316 } 462 } 317 } 463 ResetParameters(); << 464 } << 465 << 466 //....oooOO0OOooo........oooOO0OOooo........oo << 467 << 468 void << 469 G4LossTableManager::PreparePhysicsTable(const << 470 G4VEmP << 471 { << 472 if (1 < verbose) { << 473 G4cout << "G4LossTableManager::PreparePhys << 474 << particle->GetParticleName() << 475 << " and " << p->GetProcessName() << 476 << " run=" << run << " master=" << isMast << 477 << G4endl; << 478 } << 479 << 480 // start initialisation for the first run << 481 if( -1 == run ) { << 482 if (nullptr != emConfigurator) { emConfigu << 483 } << 484 << 485 ResetParameters(); << 486 } << 487 << 488 //....oooOO0OOooo........oooOO0OOooo........oo << 489 318 490 void << 319 if(0 < verbose) { 491 G4LossTableManager::PreparePhysicsTable(const << 320 G4cout << "G4LossTableManager::Initialise:" 492 G4VMul << 321 << " electron_table_are_built= " << electron_table_are_built 493 { << 322 << " all_tables_are_built= " << all_tables_are_built 494 if (1 < verbose) { << 323 << G4endl; 495 G4cout << "G4LossTableManager::PreparePhys << 496 << particle->GetParticleName() << 497 << " and " << p->GetProcessName() << 498 << " run=" << run << " master=" << isMast << 499 << G4endl; << 500 } 324 } 501 325 502 // start initialisation for the first run << 503 if ( -1 == run ) { << 504 if (nullptr != emConfigurator) { emConfigu << 505 } << 506 << 507 ResetParameters(); << 508 } 326 } 509 327 510 //....oooOO0OOooo........oooOO0OOooo........oo << 328 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 511 329 512 void << 330 void G4LossTableManager::BuildPhysicsTable(const G4ParticleDefinition* aParticle) 513 G4LossTableManager::BuildPhysicsTable(const G4 << 514 { 331 { 515 if(-1 == run && startInitialisation) { << 516 if (nullptr != emConfigurator) { emConfigu << 517 } << 518 if (startInitialisation) { resetParam = true << 519 } << 520 332 521 //....oooOO0OOooo........oooOO0OOooo........oo << 333 if(0 < verbose) { 522 << 334 G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for " 523 void G4LossTableManager::LocalPhysicsTables( << 524 const G4ParticleDefinition* aParticle, << 525 G4VEnergyLossProcess* p) << 526 { << 527 if (1 < verbose) { << 528 G4cout << "### G4LossTableManager::LocalPh << 529 << aParticle->GetParticleName() 335 << aParticle->GetParticleName() 530 << " and process " << p->GetProcess << 531 << G4endl; 336 << G4endl; 532 } 337 } 533 338 534 if(-1 == run && startInitialisation) { << 339 if(aParticle == theElectron) { 535 if (nullptr != emConfigurator) { emConfigu << 340 if(!electron_table_are_built) { 536 firstParticle = aParticle; << 341 eIonisation = BuildTables(theElectron); 537 } << 342 electron_table_are_built = true; 538 << 343 for(G4int i=0; i<n_loss; i++) { 539 if (startInitialisation) { << 344 G4VEnergyLossProcess* em = loss_vector[i]; 540 ++run; << 345 if(aParticle == part_vector[i]) SetParameters(loss_vector[i]); 541 if (1 < verbose) { << 346 if (tables_are_built[i] && em->SecondaryParticle() == theElectron && eIonisation ) { 542 G4cout << "===== G4LossTableManager::Loc << 347 em->SetSecondaryRangeTable(eIonisation->RangeTable()); 543 << run << " =====" << G4endl; << 348 } 544 } << 545 currentParticle = nullptr; << 546 startInitialisation = false; << 547 resetParam = true; << 548 for (G4int i=0; i<n_loss; ++i) { << 549 if (nullptr != loss_vector[i]) { << 550 tables_are_built[i] = false; << 551 } else { << 552 tables_are_built[i] = true; << 553 part_vector[i] = nullptr; << 554 } 349 } 555 } 350 } 556 } << 557 351 558 all_tables_are_built= true; << 352 } else { 559 for (G4int i=0; i<n_loss; ++i) { << 353 for(G4int i=0; i<n_loss; i++) { 560 if(p == loss_vector[i]) { << 561 tables_are_built[i] = true; << 562 isActive[i] = true; << 563 part_vector[i] = p->Particle(); << 564 base_part_vector[i] = p->BaseParticle(); << 565 dedx_vector[i] = p->DEDXTable(); << 566 range_vector[i] = p->RangeTableForLoss() << 567 inv_range_vector[i] = p->InverseRangeTab << 568 if(0 == run && p->IsIonisationProcess()) << 569 loss_map[part_vector[i]] = p; << 570 } << 571 354 572 if(1 < verbose) { << 355 if(aParticle == part_vector[i] && !tables_are_built[i]) { 573 G4cout << i <<". "<< p->GetProcessNa << 356 SetParameters(loss_vector[i]); 574 if(part_vector[i]) { << 357 // if(tables_are_built[i]) break; 575 G4cout << " for " << part_vector[i << 358 if(!base_part_vector[i]) { >> 359 G4VEnergyLossProcess* hIonisation = BuildTables(aParticle); >> 360 for(G4int j=0; j<n_loss; j++) { >> 361 if (aParticle == base_part_vector[j]) { >> 362 tables_are_built[j] = true; >> 363 G4VEnergyLossProcess* em = loss_vector[j]; >> 364 em->Initialise(); >> 365 em->SetDEDXTable(hIonisation->DEDXTable()); >> 366 em->SetRangeTable(hIonisation->RangeTable()); >> 367 em->SetRangeTableForLoss(hIonisation->RangeTableForLoss()); >> 368 em->SetInverseRangeTable(hIonisation->InverseRangeTable()); >> 369 em->SetLambdaTable(hIonisation->LambdaTable()); >> 370 em->SetSubLambdaTable(hIonisation->SubLambdaTable()); >> 371 loss_map[part_vector[j]] = em; >> 372 if (em->SecondaryParticle() == theElectron && eIonisation) { >> 373 em->SetSecondaryRangeTable(eIonisation->RangeTable()); >> 374 } >> 375 if (0 < verbose) { >> 376 G4cout << "For " << loss_vector[j]->GetProcessName() >> 377 << " for " << part_vector[j]->GetParticleName() >> 378 << " base_part= " << base_part_vector[j]->GetParticleName() >> 379 << " tables are assigned " >> 380 << G4endl; >> 381 } >> 382 } >> 383 } >> 384 } else { >> 385 G4VEnergyLossProcess* em = loss_vector[i]; >> 386 for(G4int j=0; j<n_loss; j++) { >> 387 if (tables_are_built[j] && part_vector[j] == base_part_vector[i]) { >> 388 G4VEnergyLossProcess* hIonisation = loss_vector[j]; >> 389 tables_are_built[i] = true; >> 390 em->Initialise(); >> 391 em->SetDEDXTable(hIonisation->DEDXTable()); >> 392 em->SetRangeTable(hIonisation->RangeTable()); >> 393 em->SetRangeTableForLoss(hIonisation->RangeTableForLoss()); >> 394 em->SetInverseRangeTable(hIonisation->InverseRangeTable()); >> 395 em->SetLambdaTable(hIonisation->LambdaTable()); >> 396 em->SetSubLambdaTable(hIonisation->SubLambdaTable()); >> 397 loss_map[part_vector[i]] = em; >> 398 if (em->SecondaryParticle() == theElectron && eIonisation) >> 399 em->SetSecondaryRangeTable(eIonisation->RangeTable()); >> 400 if (0 < verbose) { >> 401 G4cout << "For " << em->GetProcessName() >> 402 << " for " << part_vector[i]->GetParticleName() >> 403 << " base_part= " << base_part_vector[i]->GetParticleName() >> 404 << " tables are assigned= " << G4endl; >> 405 } >> 406 break; >> 407 } >> 408 } 576 } 409 } 577 G4cout << " active= " << isActive[i] << 410 break; 578 << " table= " << tables_are_bu << 579 << " isIonisation= " << p->IsI << 580 << G4endl; << 581 } 411 } 582 break; << 412 } 583 } else if(!tables_are_built[i]) { << 413 } >> 414 >> 415 if(all_tables_are_built) return; >> 416 all_tables_are_built = true; >> 417 for (G4int ii=0; ii<n_loss; ii++) { >> 418 if ( !tables_are_built[ii] ) { 584 all_tables_are_built = false; 419 all_tables_are_built = false; >> 420 break; 585 } 421 } 586 } 422 } 587 423 588 if(1 < verbose) { << 424 if(0 < verbose) { 589 G4cout << "### G4LossTableManager::LocalPh << 425 G4cout << "### G4LossTableManager::BuildDEDXTable end: " >> 426 << "all_tables_are_built= " << all_tables_are_built 590 << G4endl; 427 << G4endl; 591 } 428 } 592 if(all_tables_are_built) { << 429 if(all_tables_are_built) { 593 if(1 < verbose) { << 430 G4cout << "### All dEdx and Range tables are built #####" << G4endl; 594 G4cout << "%%%%% All dEdx and Range tabl << 595 << run << " %%%%%" << G4endl; << 596 } << 597 } 431 } 598 } 432 } 599 433 600 //....oooOO0OOooo........oooOO0OOooo........oo << 434 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 601 435 602 void G4LossTableManager::BuildPhysicsTable( << 436 void G4LossTableManager::RetrievePhysicsTables(const G4ParticleDefinition* aParticle, 603 const G4ParticleDefinition* aParticle, << 437 G4VEnergyLossProcess* theLoss) 604 G4VEnergyLossProcess* p) << 605 { 438 { 606 if(1 < verbose) { << 439 if(0 < verbose) { 607 G4cout << "### G4LossTableManager::BuildPh << 440 G4cout << "G4LossTableManager::RetrievePhysicsTable() for " 608 << aParticle->GetParticleName() 441 << aParticle->GetParticleName() 609 << " and process " << p->GetProcess << 442 << "; all_tables_are_built= " << all_tables_are_built >> 443 << G4endl; 610 } 444 } 611 // clear configurator << 445 if(all_tables_are_built) return; 612 if(-1 == run && startInitialisation) { << 613 if( nullptr != emConfigurator) { emConfigu << 614 firstParticle = aParticle; << 615 } << 616 if(startInitialisation) { << 617 ++run; << 618 resetParam = true; << 619 startInitialisation = false; << 620 if(1 < verbose) { << 621 G4cout << "===== G4LossTableManager::Bui << 622 << run << " ===== " << atomDeexci << 623 } << 624 currentParticle = nullptr; << 625 all_tables_are_built = false; << 626 446 627 for (G4int i=0; i<n_loss; ++i) { << 447 G4bool hasRange = false; 628 G4VEnergyLossProcess* el = loss_vector[i << 448 G4bool isLast = false; 629 << 449 G4int i; 630 if(nullptr != el) { << 450 for (i=0; i<n_loss; i++) { 631 isActive[i] = true; << 451 if ( theLoss == loss_vector[i] ) { 632 part_vector[i] = el->Particle(); << 452 if((n_loss-1 == i && part_vector[n_loss-1] != G4Proton::Proton()) || 633 base_part_vector[i] = el->BaseParticle << 453 (n_loss-2 == i && part_vector[n_loss-1] == G4Proton::Proton())) isLast = true; 634 tables_are_built[i] = false; << 454 tables_are_built[i] = true; 635 if(1 < verbose) { << 455 if (theLoss->RangeTable()) { 636 G4cout << i <<". "<< el->GetProces << 456 if (part_vector[i] == theElectron) { 637 if(el->Particle()) { << 457 eIonisation = theLoss; 638 G4cout << " for " << el->Particl << 458 electron_table_are_built = true; 639 } << 459 } 640 G4cout << " active= " << isActive[i << 460 loss_map[part_vector[i]] = theLoss; 641 << " table= " << tables_are_ << 461 hasRange = true; 642 << " isIonisation= " << el-> << 462 if (0 < verbose) { 643 if(base_part_vector[i]) { << 463 G4cout << "dEdx and Range tables are defined for " 644 G4cout << " base particle " << 464 << aParticle->GetParticleName() 645 << base_part_vector[i]->Get << 465 << G4endl; 646 } << 647 G4cout << G4endl; << 648 } 466 } 649 } else { << 650 tables_are_built[i] = true; << 651 part_vector[i] = nullptr; << 652 isActive[i] = false; << 653 } 467 } >> 468 if (electron_table_are_built && theLoss->SecondaryParticle() == theElectron) >> 469 theLoss->SetSecondaryRangeTable(eIonisation->RangeTable()); >> 470 break; 654 } 471 } 655 } 472 } 656 473 657 if (all_tables_are_built) { << 474 if ( hasRange ) { 658 theParameters->SetIsPrintedFlag(true); << 475 for (G4int j=0; j<n_loss; j++) { 659 return; << 476 if ( base_part_vector[j] == aParticle && !tables_are_built[j] ) { 660 } << 477 G4VEnergyLossProcess* em = loss_vector[j]; 661 << 478 tables_are_built[j] = true; 662 // Build tables for given particle << 479 em->Initialise(); 663 all_tables_are_built = true; << 480 em->SetDEDXTable(theLoss->DEDXTable()); 664 << 481 em->SetRangeTable(theLoss->RangeTable()); 665 for(G4int i=0; i<n_loss; ++i) { << 482 em->SetRangeTableForLoss(theLoss->RangeTableForLoss()); 666 if(p == loss_vector[i] && !tables_are_buil << 483 em->SetInverseRangeTable(theLoss->InverseRangeTable()); 667 const G4ParticleDefinition* curr_part = << 484 em->SetLambdaTable(theLoss->LambdaTable()); 668 if(1 < verbose) { << 485 em->SetSubLambdaTable(theLoss->SubLambdaTable()); 669 G4cout << "### Build Table for " << p- << 486 if (electron_table_are_built && em->SecondaryParticle() == theElectron) 670 << " and " << curr_part->GetPar << 487 em->SetSecondaryRangeTable(eIonisation->RangeTable()); 671 << " " << tables_are_built[i] << 488 loss_map[part_vector[j]] = em; 672 << G4endl; << 489 if (1 < verbose) { 673 } << 490 G4String nm = "0"; 674 G4VEnergyLossProcess* curr_proc = BuildT << 491 G4String nm1= "0"; 675 if(curr_proc) { << 492 G4String nm2= "0"; 676 CopyTables(curr_part, curr_proc); << 493 const G4ParticleDefinition* pd = part_vector[j]; 677 if(p == curr_proc && 0 == run && p->Is << 494 const G4ParticleDefinition* bpd = base_part_vector[j]; 678 loss_map[aParticle] = p; << 495 if (pd) nm = pd->GetParticleName(); 679 //G4cout << "G4LossTableManager::Bui << 496 if (bpd) nm2 = bpd->GetParticleName(); 680 // << aParticle->GetParticleName << 497 if (part_vector[j]) nm1 = part_vector[j]->GetParticleName(); 681 // << " added to map " << p << 498 G4cout << "For " << loss_vector[j]->GetProcessName() >> 499 << " for " << nm >> 500 << " (" << nm1 << ") " >> 501 << " base_part= " << nm2 >> 502 << " tables_are_built= " << tables_are_built[j] >> 503 << G4endl; 682 } 504 } 683 } 505 } 684 } 506 } 685 if ( !tables_are_built[i] ) { all_tables_a << 686 } << 687 if(1 < verbose) { << 688 G4cout << "### G4LossTableManager::BuildPh << 689 << "all_tables_are_built= " << all_ << 690 << aParticle->GetParticleName() << << 691 } 507 } 692 } << 693 508 694 //....oooOO0OOooo........oooOO0OOooo........oo << 509 all_tables_are_built = true; 695 << 510 for (G4int ii=0; ii<n_loss; ii++) { 696 void G4LossTableManager::CopyTables(const G4Pa << 511 if ( !tables_are_built[ii] ) { 697 G4VEnergyL << 512 all_tables_are_built = false; 698 { << 513 break; 699 for (G4int j=0; j<n_loss; ++j) { << 700 << 701 G4VEnergyLossProcess* proc = loss_vector[j << 702 << 703 if (!tables_are_built[j] && part == base_p << 704 tables_are_built[j] = true; << 705 // for base particle approach only ionis << 706 proc->SetDEDXTable(base_proc->Ionisation << 707 proc->SetDEDXTable(base_proc->DEDXunRest << 708 proc->SetCSDARangeTable(base_proc->CSDAR << 709 proc->SetRangeTableForLoss(base_proc->Ra << 710 proc->SetInverseRangeTable(base_proc->In << 711 proc->SetLambdaTable(base_proc->LambdaTa << 712 if(proc->IsIonisationProcess()) { << 713 range_vector[j] = base_proc->RangeTabl << 714 inv_range_vector[j] = base_proc->Inver << 715 loss_map[part_vector[j]] = proc; << 716 //G4cout << "G4LossTableManager::CopyT << 717 // << part_vector[j]->GetParticl << 718 // << " added to map " << proc < << 719 } << 720 if (1 < verbose) { << 721 G4cout << " CopyTables for " << pro << 722 << " for " << part_vector[j]-> << 723 << " base_part= " << part->Get << 724 << " tables are assigned" << 725 << G4endl; << 726 } << 727 } 514 } 728 } 515 } >> 516 >> 517 if(0 < verbose) { >> 518 G4cout << "G4LossTableManager::RetrievePhysicsTable end: " >> 519 << "all_tables_are_built= " << all_tables_are_built >> 520 << " i= " << i << " n_loss= " << n_loss >> 521 << G4endl; >> 522 } >> 523 if(all_tables_are_built) { >> 524 G4cout << "##### All dEdx and Range tables are retrieved #####" << G4endl; >> 525 } else if(isLast) { >> 526 G4Exception("G4LossTableManager ERROR: not all dEdx and Range tables are retrieved"); >> 527 } 729 } 528 } 730 529 731 //....oooOO0OOooo........oooOO0OOooo........oo << 530 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 732 531 733 G4VEnergyLossProcess* G4LossTableManager::Buil << 532 G4VEnergyLossProcess* G4LossTableManager::BuildTables(const G4ParticleDefinition* aParticle) 734 const G4ParticleDefiniti << 735 { 533 { 736 if(1 < verbose) { << 534 if(0 < verbose) { 737 G4cout << " G4LossTableManager::BuildTab << 535 G4cout << "G4LossTableManager::BuildTables() for " 738 << aParticle->GetParticleName() << 536 << aParticle->GetParticleName() << G4endl; 739 } 537 } 740 538 741 std::vector<G4PhysicsTable*> t_list; << 539 // Check is it new particle or all tables have to be rebuilt >> 540 std::vector<G4PhysicsTable*> list; >> 541 list.clear(); 742 std::vector<G4VEnergyLossProcess*> loss_list 542 std::vector<G4VEnergyLossProcess*> loss_list; 743 std::vector<G4bool> build_flags; << 543 loss_list.clear(); 744 G4VEnergyLossProcess* em = nullptr; << 544 G4VEnergyLossProcess* em = 0; 745 G4VEnergyLossProcess* p = nullptr; << 746 G4int iem = 0; 545 G4int iem = 0; 747 G4PhysicsTable* dedx = nullptr; << 546 G4bool no_el = true; 748 G4int i; << 749 547 750 G4ProcessVector* pvec = << 548 for (G4int i=0; i<n_loss; i++) { 751 aParticle->GetProcessManager()->GetProcess << 549 if (aParticle == part_vector[i] && !tables_are_built[i]) { 752 G4int nvec = (G4int)pvec->size(); << 550 loss_vector[i]->Initialise(); 753 << 551 if(no_el && loss_vector[i]->SecondaryParticle() == theElectron) { 754 for (i=0; i<n_loss; ++i) { << 552 em = loss_vector[i]; 755 p = loss_vector[i]; << 553 iem= i; 756 if (nullptr != p) { << 554 no_el = false; 757 G4bool yes = (aParticle == part_vector[i << 555 } 758 << 556 if(!em) { 759 // possible case of process sharing betw << 557 em = loss_vector[i]; 760 if(!yes) { << 558 iem= i; 761 auto ptr = static_cast<G4VProcess*>(p) << 762 for(G4int j=0; j<nvec; ++j) { << 763 //G4cout << "j= " << j << " " << (*p << 764 if(ptr == (*pvec)[j]) { << 765 yes = true; << 766 break; << 767 } << 768 } << 769 } << 770 // process belong to this particle << 771 if(yes && isActive[i]) { << 772 if (p->IsIonisationProcess() || !em) { << 773 em = p; << 774 iem= i; << 775 } << 776 // tables may be shared between partic << 777 G4bool val = false; << 778 if (!tables_are_built[i]) { << 779 val = true; << 780 dedx = p->BuildDEDXTable(fRestricted << 781 //G4cout << "===Build DEDX table for << 782 // << " idx= " << i << " dedx:" << d << 783 p->SetDEDXTable(dedx,fRestricted); << 784 tables_are_built[i] = true; << 785 } else { << 786 dedx = p->DEDXTable(); << 787 } << 788 t_list.push_back(dedx); << 789 loss_list.push_back(p); << 790 build_flags.push_back(val); << 791 } 559 } >> 560 tables_are_built[i] = true; >> 561 list.push_back(loss_vector[i]->BuildDEDXTable()); >> 562 loss_list.push_back(loss_vector[i]); 792 } 563 } 793 } 564 } 794 565 795 G4int n_dedx = (G4int)t_list.size(); << 566 G4int n_dedx = list.size(); 796 if (0 == n_dedx || !em) { << 567 if (!n_dedx) return 0; 797 G4cout << "G4LossTableManager WARNING: no << 568 798 << aParticle->GetParticleName() << << 569 if (aParticle == theElectron) eIonisation = em; 799 return nullptr; << 800 } << 801 G4int nSubRegions = em->NumberOfSubCutoffReg << 802 570 803 if (1 < verbose) { 571 if (1 < verbose) { 804 G4cout << " Start to build the sum of << 572 G4cout << "G4LossTableManager::BuildTables() start to build range tables" 805 << " iem= " << iem << " em= " << em << 573 << " and the sum of " << n_dedx << " processes" 806 << " buildCSDARange= " << theParame << 574 << G4endl; 807 << " nSubRegions= " << nSubRegions; << 808 if(subcutProducer) { << 809 G4cout << " SubCutProducer " << subcutPr << 810 } << 811 G4cout << G4endl; << 812 } 575 } 813 // do not build tables if producer class is << 814 if(subcutProducer) { nSubRegions = 0; } << 815 << 816 dedx = em->DEDXTable(); << 817 em->SetDEDXTable(dedx, fIsIonisation); << 818 576 >> 577 G4PhysicsTable* dedx = list[0]; 819 if (1 < n_dedx) { 578 if (1 < n_dedx) { 820 dedx = nullptr; << 579 dedx = tableBuilder->BuildDEDXTable(list); 821 dedx = G4PhysicsTableHelper::PreparePhysic << 580 for(G4int i=0; i<n_dedx; i++) { 822 tableBuilder->BuildDEDXTable(dedx, t_list) << 581 list[i]->clearAndDestroy(); 823 em->SetDEDXTable(dedx, fRestricted); << 582 } 824 } 583 } 825 << 584 em->SetDEDXTable(dedx); 826 dedx_vector[iem] = dedx; 585 dedx_vector[iem] = dedx; 827 << 586 G4PhysicsTable* range = tableBuilder->BuildRangeTable(dedx); 828 G4PhysicsTable* range = em->RangeTableForLos << 587 G4PhysicsTable* invrange = tableBuilder->BuildInverseRangeTable(dedx, range); 829 if(!range) range = G4PhysicsTableHelper::Pr << 830 range_vector[iem] = range; << 831 << 832 G4PhysicsTable* invrange = em->InverseRangeT << 833 if(!invrange) invrange = G4PhysicsTableHelpe << 834 inv_range_vector[iem] = invrange; << 835 << 836 tableBuilder->BuildRangeTable(dedx, range); << 837 tableBuilder->BuildInverseRangeTable(range, << 838 << 839 em->SetRangeTableForLoss(range); << 840 em->SetInverseRangeTable(invrange); 588 em->SetInverseRangeTable(invrange); >> 589 inv_range_vector[iem] = invrange; >> 590 em->SetRangeTableForLoss(range); 841 591 842 std::vector<G4PhysicsTable*> listCSDA; << 592 if(buildPreciseRange) { 843 << 593 std::vector<G4PhysicsTable*> newlist; 844 for (i=0; i<n_dedx; ++i) { << 594 newlist.clear(); 845 p = loss_list[i]; << 595 for (G4int i=0; i<n_dedx; i++) { 846 if(build_flags[i]) { << 596 newlist.push_back(loss_list[i]->BuildDEDXTableForPreciseRange()); 847 p->SetLambdaTable(p->BuildLambdaTable(fR << 597 } >> 598 G4PhysicsTable* dedxForRange = newlist[0]; >> 599 if (1 < n_dedx) dedxForRange = tableBuilder->BuildDEDXTable(newlist); >> 600 range = tableBuilder->BuildRangeTable(dedxForRange); >> 601 for(G4int j=0; j<n_dedx; j++) { >> 602 newlist[j]->clearAndDestroy(); 848 } 603 } 849 if(theParameters->BuildCSDARange()) { << 604 newlist.clear(); 850 dedx = p->BuildDEDXTable(fTotal); << 851 p->SetDEDXTable(dedx,fTotal); << 852 listCSDA.push_back(dedx); << 853 } << 854 } 605 } 855 606 856 if(theParameters->BuildCSDARange()) { << 607 em->SetRangeTable(range); 857 G4PhysicsTable* dedxCSDA = em->DEDXunRestr << 608 range_vector[iem] = range; 858 if (1 < n_dedx) { << 609 859 dedxCSDA = G4PhysicsTableHelper::Prepare << 610 loss_map[aParticle] = em; 860 tableBuilder->BuildDEDXTable(dedxCSDA, l << 611 for (G4int j=0; j<n_dedx; j++) { 861 em->SetDEDXTable(dedxCSDA,fTotal); << 612 if(loss_list[j]->SecondaryParticle() == theElectron && eIonisation) >> 613 loss_list[j]->SetSecondaryRangeTable(eIonisation->RangeTable()); >> 614 >> 615 G4PhysicsTable* lambdaTable = loss_list[j]->BuildLambdaTable(); >> 616 loss_list[j]->SetLambdaTable(lambdaTable); >> 617 if (0 < loss_list[j]->NumberOfSubCutoffRegions()) { >> 618 lambdaTable = loss_list[j]->BuildLambdaSubTable(); >> 619 loss_list[j]->SetSubLambdaTable(lambdaTable); 862 } 620 } 863 G4PhysicsTable* rCSDA = em->CSDARangeTable << 864 if(!rCSDA) { rCSDA = G4PhysicsTableHelper: << 865 tableBuilder->BuildRangeTable(dedxCSDA, rC << 866 em->SetCSDARangeTable(rCSDA); << 867 } 621 } 868 << 622 if (0 < verbose) { 869 if (1 < verbose) { << 870 G4cout << "G4LossTableManager::BuildTables 623 G4cout << "G4LossTableManager::BuildTables: Tables are built for " 871 << aParticle->GetParticleName() 624 << aParticle->GetParticleName() 872 << "; ionisation process: " << em-> << 625 << "; ionisation process: " << em->GetProcessName() 873 << " " << em << 874 << G4endl; 626 << G4endl; 875 } 627 } >> 628 list.clear(); >> 629 loss_list.clear(); 876 return em; 630 return em; 877 } 631 } 878 632 879 //....oooOO0OOooo........oooOO0OOooo........oo << 633 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 880 634 881 void G4LossTableManager::ParticleHaveNoLoss( << 635 void G4LossTableManager::SetLossFluctuations(G4bool val) 882 const G4ParticleDefinition* aParticle) << 883 { 636 { 884 G4ExceptionDescription ed; << 637 lossFluctuationFlag = val; 885 ed << "Energy loss process not found for " < << 638 for(G4int i=0; i<n_loss; i++) { 886 << " !"; << 639 if(loss_vector[i]) loss_vector[i]->SetLossFluctuations(val); 887 G4Exception("G4LossTableManager::ParticleHav << 640 } 888 FatalException, ed); << 889 } 641 } 890 642 891 //....oooOO0OOooo........oooOO0OOooo........oo << 643 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 892 644 893 void G4LossTableManager::SetVerbose(G4int val) << 645 void G4LossTableManager::SetSubCutoff(G4bool val) 894 { 646 { 895 verbose = val; << 647 subCutoffFlag = val; >> 648 for(G4int i=0; i<n_loss; i++) { >> 649 if(loss_vector[i]) loss_vector[i]->SetSubCutoff(val); >> 650 } 896 } 651 } 897 652 898 //....oooOO0OOooo........oooOO0OOooo........oo << 653 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 899 654 900 const std::vector<G4VEnergyLossProcess*>& << 655 void G4LossTableManager::SetIntegral(G4bool val) 901 G4LossTableManager::GetEnergyLossProcessVector << 902 { 656 { 903 return loss_vector; << 657 integral = val; >> 658 integralActive = true; >> 659 for(G4int i=0; i<n_loss; i++) { >> 660 if(loss_vector[i]) loss_vector[i]->SetIntegral(val); >> 661 } 904 } 662 } 905 663 906 //....oooOO0OOooo........oooOO0OOooo........oo << 664 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 907 665 908 const std::vector<G4VEmProcess*>& G4LossTableM << 666 void G4LossTableManager::SetMinSubRange(G4double val) 909 { 667 { 910 return emp_vector; << 668 minSubRange = val; >> 669 for(G4int i=0; i<n_loss; i++) { >> 670 if(loss_vector[i]) loss_vector[i]->SetMinSubRange(val); >> 671 } 911 } 672 } 912 673 913 //....oooOO0OOooo........oooOO0OOooo........oo << 674 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 914 675 915 const std::vector<G4VMultipleScattering*>& << 676 void G4LossTableManager::SetRandomStep(G4bool val) 916 G4LossTableManager::GetMultipleScatteringVecto << 917 { 677 { 918 return msc_vector; << 678 rndmStepFlag = val; >> 679 for(G4int i=0; i<n_loss; i++) { >> 680 if(loss_vector[i]) loss_vector[i]->SetRandomStep(val); >> 681 } 919 } 682 } 920 683 921 //....oooOO0OOooo........oooOO0OOooo........oo 684 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 922 685 923 G4EmSaturation* G4LossTableManager::EmSaturati << 686 void G4LossTableManager::SetMinEnergy(G4double val) 924 { 687 { 925 return theParameters->GetEmSaturation(); << 688 minEnergyActive = true; >> 689 minKinEnergy = val; >> 690 for(G4int i=0; i<n_loss; i++) { >> 691 if(loss_vector[i]) loss_vector[i]->SetMinKinEnergy(val); >> 692 } >> 693 size_t msc = msc_vector.size(); >> 694 for (size_t j=0; j<msc; j++) { >> 695 if(msc_vector[j]) msc_vector[j]->SetMinKinEnergy(val); >> 696 } >> 697 size_t emp = emp_vector.size(); >> 698 for (size_t k=0; k<emp; k++) { >> 699 if(emp_vector[k]) emp_vector[k]->SetMinKinEnergy(val); >> 700 } 926 } 701 } 927 702 928 //....oooOO0OOooo........oooOO0OOooo........oo 703 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 929 704 930 G4EmConfigurator* G4LossTableManager::EmConfig << 705 void G4LossTableManager::SetMaxEnergy(G4double val) 931 { 706 { 932 if(!emConfigurator) { << 707 maxEnergyActive = true; 933 emConfigurator = new G4EmConfigurator(verb << 708 maxKinEnergy = val; >> 709 for(G4int i=0; i<n_loss; i++) { >> 710 if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergy(val); >> 711 } >> 712 size_t msc = msc_vector.size(); >> 713 for (size_t j=0; j<msc; j++) { >> 714 if(msc_vector[j]) msc_vector[j]->SetMaxKinEnergy(val); >> 715 } >> 716 size_t emp = emp_vector.size(); >> 717 for (size_t k=0; k<emp; k++) { >> 718 if(emp_vector[k]) emp_vector[k]->SetMaxKinEnergy(val); 934 } 719 } 935 return emConfigurator; << 936 } 720 } 937 721 938 //....oooOO0OOooo........oooOO0OOooo........oo 722 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 939 723 940 G4ElectronIonPair* G4LossTableManager::Electro << 724 void G4LossTableManager::SetMaxEnergyForPreciseRange(G4double val) 941 { 725 { 942 if(!emElectronIonPair) { << 726 for(G4int i=0; i<n_loss; i++) { 943 emElectronIonPair = new G4ElectronIonPair( << 727 if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergyForPreciseRange(val); 944 } 728 } 945 return emElectronIonPair; << 946 } 729 } 947 730 948 //....oooOO0OOooo........oooOO0OOooo........oo 731 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 949 732 950 void G4LossTableManager::SetNIELCalculator(G4N << 733 void G4LossTableManager::SetMaxEnergyForMuons(G4double val) 951 { 734 { 952 if(nullptr != ptr && ptr != nielCalculator) << 735 maxEnergyForMuonsActive = true; 953 delete nielCalculator; << 736 maxKinEnergyForMuons = val; 954 nielCalculator = ptr; << 955 } << 956 } 737 } 957 738 958 //....oooOO0OOooo........oooOO0OOooo........oo 739 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 959 740 960 G4NIELCalculator* G4LossTableManager::NIELCalc << 741 void G4LossTableManager::SetDEDXBinning(G4int val) 961 { 742 { 962 if(!nielCalculator) { << 743 for(G4int i=0; i<n_loss; i++) { 963 nielCalculator = new G4NIELCalculator(null << 744 if(loss_vector[i]) loss_vector[i]->SetDEDXBinning(val); 964 } 745 } 965 return nielCalculator; << 966 } 746 } 967 747 968 //....oooOO0OOooo........oooOO0OOooo........oo << 748 969 << 749 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 970 void G4LossTableManager::SetAtomDeexcitation(G << 750 >> 751 void G4LossTableManager::SetDEDXBinningForPreciseRange(G4int val) 971 { 752 { 972 if(atomDeexcitation != p) { << 753 for(G4int i=0; i<n_loss; i++) { 973 delete atomDeexcitation; << 754 if(loss_vector[i]) loss_vector[i]->SetDEDXBinningForPreciseRange(val); 974 atomDeexcitation = p; << 975 } 755 } 976 } 756 } 977 757 978 //....oooOO0OOooo........oooOO0OOooo........oo << 758 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 979 759 980 void G4LossTableManager::SetSubCutProducer(G4V << 760 void G4LossTableManager::SetLambdaBinning(G4int val) 981 { 761 { 982 if(subcutProducer != p) { << 762 for(G4int i=0; i<n_loss; i++) { 983 delete subcutProducer; << 763 if(loss_vector[i]) loss_vector[i]->SetLambdaBinning(val); 984 subcutProducer = p; << 764 } >> 765 size_t msc = msc_vector.size(); >> 766 for (size_t j=0; j<msc; j++) { >> 767 if(msc_vector[j]) msc_vector[j]->SetBinning(val); >> 768 } >> 769 size_t emp = emp_vector.size(); >> 770 for (size_t k=0; k<emp; k++) { >> 771 if(emp_vector[k]) emp_vector[k]->SetLambdaBinning(val); 985 } 772 } 986 } 773 } 987 774 988 //....oooOO0OOooo........oooOO0OOooo........oo << 775 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 989 776 990 void G4LossTableManager::PrintEWarning(G4Strin << 777 void G4LossTableManager::SetVerbose(G4int val) 991 { 778 { 992 G4String ss = "G4LossTableManager::" + tit; << 779 verbose = val; 993 G4ExceptionDescription ed; << 780 for(G4int i=0; i<n_loss; i++) { 994 /* << 781 if(loss_vector[i]) loss_vector[i]->SetVerboseLevel(val); 995 ed << "Parameter is out of range: " << val << 782 } 996 << " it will have no effect!\n" << " ## " << 783 size_t msc = msc_vector.size(); 997 << " nbins= " << nbinsLambda << 784 for (size_t j=0; j<msc; j++) { 998 << " nbinsPerDecade= " << nbinsPerDecade << 785 if(msc_vector[j]) msc_vector[j]->SetVerboseLevel(val); 999 << " Emin(keV)= " << minKinEnergy/keV << 786 } 1000 << " Emax(GeV)= " << maxKinEnergy/GeV; << 787 size_t emp = emp_vector.size(); 1001 */ << 788 for (size_t k=0; k<emp; k++) { 1002 G4Exception(ss, "em0044", JustWarning, ed); << 789 if(emp_vector[k]) emp_vector[k]->SetVerboseLevel(val); >> 790 } 1003 } 791 } 1004 792 1005 //....oooOO0OOooo........oooOO0OOooo........o << 793 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 1006 794 1007 void G4LossTableManager::DumpHtml() << 795 void G4LossTableManager::SetStepLimits(G4double v1, G4double v2) 1008 { 796 { 1009 // Automatic generation of html documentati << 797 stepFunctionActive = true; 1010 // List processes and models for the most i << 798 maxRangeVariation = v1; 1011 // particles in descending order of importa << 799 maxFinalStep = v2; 1012 // NB. for model names with length > 18 cha << 800 for(G4int i=0; i<n_loss; i++) { 1013 // to be edited by hand. Or modify G4EmMod << 801 if(loss_vector[i]) loss_vector[i]->SetStepFunction(v1, v2); 1014 << 802 } 1015 char* dirName = std::getenv("G4PhysListDocD << 803 } 1016 char* physList = std::getenv("G4PhysListNam << 1017 if (dirName && physList) { << 1018 G4String physListName = G4String(physList << 1019 G4String pathName = G4String(dirName) + " << 1020 << 1021 std::ofstream outFile; << 1022 outFile.open(pathName); << 1023 << 1024 outFile << physListName << G4endl; << 1025 outFile << std::string(physListName.lengt << 1026 << 1027 std::vector<G4ParticleDefinition*> partic << 1028 G4Gamma::Gamma(), << 1029 G4Electron::Electron(), << 1030 G4Positron::Positron(), << 1031 G4Proton::ProtonDefinition(), << 1032 G4MuonPlus::MuonPlusDefinition(), << 1033 G4MuonMinus::MuonMinusDefinition(), << 1034 }; << 1035 << 1036 std::vector<G4VEmProcess*> emproc_vector << 1037 std::vector<G4VEnergyLossProcess*> enloss << 1038 GetEnergyLossProcessVector(); << 1039 std::vector<G4VMultipleScattering*> mscat << 1040 GetMultipleScatteringVector(); << 1041 << 1042 for (auto theParticle : particles) { << 1043 outFile << G4endl << "**" << theParticl << 1044 << "**" << G4endl << G4endl << << 1045 << 1046 G4ProcessManager* pm = theParticle->Get << 1047 G4ProcessVector* pv = pm->GetProcessLi << 1048 G4int plen = pm->GetProcessListLength() << 1049 << 1050 for (auto emproc : emproc_vector) { << 1051 for (G4int i = 0; i < plen; ++i) { << 1052 G4VProcess* proc = (*pv)[i]; << 1053 if (proc == emproc) { << 1054 outFile << G4endl; << 1055 proc->ProcessDescription(outFile) << 1056 break; << 1057 } << 1058 } << 1059 } << 1060 804 1061 for (auto mscproc : mscat_vector) { << 805 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 1062 for (G4int i = 0; i < plen; ++i) { << 1063 G4VProcess* proc = (*pv)[i]; << 1064 if (proc == mscproc) { << 1065 outFile << G4endl; << 1066 proc->ProcessDescription(outFile) << 1067 break; << 1068 } << 1069 } << 1070 } << 1071 806 1072 for (auto enlossproc : enloss_vector) { << 807 void G4LossTableManager::SetBuildPreciseRange(G4bool val) 1073 for (G4int i = 0; i < plen; ++i) { << 808 { 1074 G4VProcess* proc = (*pv)[i]; << 809 buildPreciseRange = val; 1075 if (proc == enlossproc) { << 1076 outFile << G4endl; << 1077 proc->ProcessDescription(outFile) << 1078 break; << 1079 } << 1080 } << 1081 } << 1082 } << 1083 outFile.close(); << 1084 } << 1085 } 810 } 1086 811 1087 //....oooOO0OOooo........oooOO0OOooo........o << 812 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 1088 813 >> 814 void G4LossTableManager::SetParameters(G4VEnergyLossProcess* p) >> 815 { >> 816 if(stepFunctionActive) p->SetStepFunction(maxRangeVariation, maxFinalStep); >> 817 if(integralActive) p->SetIntegral(integral); >> 818 if(minEnergyActive) p->SetMinKinEnergy(minKinEnergy); >> 819 if(maxEnergyActive) p->SetMaxKinEnergy(maxKinEnergy); >> 820 } >> 821 >> 822 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 1089 823