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