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 // ------------------------------------------- 26 // ------------------------------------------------------------------- 27 // 27 // 28 // GEANT4 Class file 28 // GEANT4 Class file 29 // 29 // 30 // 30 // 31 // File name: G4EmExtraParameters 31 // File name: G4EmExtraParameters 32 // 32 // 33 // Author: Vladimir Ivanchenko 33 // Author: Vladimir Ivanchenko 34 // 34 // 35 // Creation date: 07.05.2019 35 // Creation date: 07.05.2019 36 // 36 // 37 // ------------------------------------------- 37 // ------------------------------------------------------------------- 38 // 38 // 39 //....oooOO0OOooo........oooOO0OOooo........oo 39 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 40 //....oooOO0OOooo........oooOO0OOooo........oo 40 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 41 41 42 #include "G4EmExtraParameters.hh" 42 #include "G4EmExtraParameters.hh" 43 #include "G4ParticleDefinition.hh" 43 #include "G4ParticleDefinition.hh" 44 #include "G4PhysicalConstants.hh" 44 #include "G4PhysicalConstants.hh" 45 #include "G4UnitsTable.hh" 45 #include "G4UnitsTable.hh" 46 #include "G4SystemOfUnits.hh" 46 #include "G4SystemOfUnits.hh" 47 #include "G4VEmProcess.hh" 47 #include "G4VEmProcess.hh" 48 #include "G4VEnergyLossProcess.hh" 48 #include "G4VEnergyLossProcess.hh" 49 #include "G4EmExtraParametersMessenger.hh" 49 #include "G4EmExtraParametersMessenger.hh" 50 #include "G4RegionStore.hh" 50 #include "G4RegionStore.hh" 51 #include "G4Region.hh" 51 #include "G4Region.hh" 52 52 53 //....oooOO0OOooo........oooOO0OOooo........oo 53 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 54 54 55 G4EmExtraParameters::G4EmExtraParameters() 55 G4EmExtraParameters::G4EmExtraParameters() 56 { 56 { 57 theMessenger = new G4EmExtraParametersMessen 57 theMessenger = new G4EmExtraParametersMessenger(this); 58 Initialise(); 58 Initialise(); 59 } 59 } 60 60 61 //....oooOO0OOooo........oooOO0OOooo........oo 61 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 62 62 63 G4EmExtraParameters::~G4EmExtraParameters() 63 G4EmExtraParameters::~G4EmExtraParameters() 64 { 64 { 65 delete theMessenger; 65 delete theMessenger; 66 } 66 } 67 67 68 //....oooOO0OOooo........oooOO0OOooo........oo 68 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 69 69 70 void G4EmExtraParameters::Initialise() 70 void G4EmExtraParameters::Initialise() 71 { 71 { 72 quantumEntanglement = false; 72 quantumEntanglement = false; 73 directionalSplitting = false; 73 directionalSplitting = false; 74 directionalSplittingTarget.set(0.,0.,0.); 74 directionalSplittingTarget.set(0.,0.,0.); 75 directionalSplittingRadius = 0.; 75 directionalSplittingRadius = 0.; 76 76 77 dRoverRange = 0.2; 77 dRoverRange = 0.2; 78 finalRange = CLHEP::mm; 78 finalRange = CLHEP::mm; 79 dRoverRangeMuHad = 0.2; 79 dRoverRangeMuHad = 0.2; 80 finalRangeMuHad = 0.1*CLHEP::mm; 80 finalRangeMuHad = 0.1*CLHEP::mm; 81 dRoverRangeLIons = 0.2; 81 dRoverRangeLIons = 0.2; 82 finalRangeLIons = 0.1*CLHEP::mm; 82 finalRangeLIons = 0.1*CLHEP::mm; 83 dRoverRangeIons = 0.2; 83 dRoverRangeIons = 0.2; 84 finalRangeIons = 0.1*CLHEP::mm; 84 finalRangeIons = 0.1*CLHEP::mm; 85 85 86 m_regnamesForced.clear(); 86 m_regnamesForced.clear(); 87 m_procForced.clear(); 87 m_procForced.clear(); 88 m_lengthForced.clear(); 88 m_lengthForced.clear(); 89 m_weightForced.clear(); 89 m_weightForced.clear(); 90 m_regnamesSubCut.clear(); 90 m_regnamesSubCut.clear(); >> 91 m_subCuts.clear(); 91 } 92 } 92 93 93 //....oooOO0OOooo........oooOO0OOooo........oo 94 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 94 95 95 96 96 void G4EmExtraParameters::PrintWarning(G4Excep 97 void G4EmExtraParameters::PrintWarning(G4ExceptionDescription& ed) const 97 { 98 { 98 G4Exception("G4EmExtraParameters", "em0044", 99 G4Exception("G4EmExtraParameters", "em0044", JustWarning, ed); 99 } 100 } 100 101 101 G4String G4EmExtraParameters::CheckRegion(cons 102 G4String G4EmExtraParameters::CheckRegion(const G4String& reg) const 102 { 103 { 103 G4String r = reg; 104 G4String r = reg; 104 if(r == "" || r == "world" || r == "World") 105 if(r == "" || r == "world" || r == "World") { 105 r = "DefaultRegionForTheWorld"; 106 r = "DefaultRegionForTheWorld"; 106 } 107 } 107 return r; 108 return r; 108 } 109 } 109 110 110 void G4EmExtraParameters::SetStepFunction(G4do 111 void G4EmExtraParameters::SetStepFunction(G4double v1, G4double v2) 111 { 112 { 112 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 113 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 113 dRoverRange = v1; 114 dRoverRange = v1; 114 finalRange = v2; 115 finalRange = v2; 115 } else { 116 } else { 116 G4ExceptionDescription ed; 117 G4ExceptionDescription ed; 117 ed << "Values of step function are out of 118 ed << "Values of step function are out of range: " 118 << v1 << ", " << v2/CLHEP::mm << " mm - 119 << v1 << ", " << v2/CLHEP::mm << " mm - are ignored"; 119 PrintWarning(ed); 120 PrintWarning(ed); 120 } 121 } 121 } 122 } 122 123 123 G4double G4EmExtraParameters::GetStepFunctionP 124 G4double G4EmExtraParameters::GetStepFunctionP1() const 124 { 125 { 125 return dRoverRange; 126 return dRoverRange; 126 } 127 } 127 128 128 G4double G4EmExtraParameters::GetStepFunctionP 129 G4double G4EmExtraParameters::GetStepFunctionP2() const 129 { 130 { 130 return finalRange; 131 return finalRange; 131 } 132 } 132 133 133 void G4EmExtraParameters::SetStepFunctionMuHad 134 void G4EmExtraParameters::SetStepFunctionMuHad(G4double v1, G4double v2) 134 { 135 { 135 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 136 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 136 dRoverRangeMuHad = v1; 137 dRoverRangeMuHad = v1; 137 finalRangeMuHad = v2; 138 finalRangeMuHad = v2; 138 } else { 139 } else { 139 G4ExceptionDescription ed; 140 G4ExceptionDescription ed; 140 ed << "Values of step function are out of 141 ed << "Values of step function are out of range: " 141 << v1 << ", " << v2/CLHEP::mm << " mm - 142 << v1 << ", " << v2/CLHEP::mm << " mm - are ignored"; 142 PrintWarning(ed); 143 PrintWarning(ed); 143 } 144 } 144 } 145 } 145 146 146 G4double G4EmExtraParameters::GetStepFunctionM 147 G4double G4EmExtraParameters::GetStepFunctionMuHadP1() const 147 { 148 { 148 return dRoverRangeMuHad; 149 return dRoverRangeMuHad; 149 } 150 } 150 151 151 G4double G4EmExtraParameters::GetStepFunctionM 152 G4double G4EmExtraParameters::GetStepFunctionMuHadP2() const 152 { 153 { 153 return finalRangeMuHad; 154 return finalRangeMuHad; 154 } 155 } 155 156 156 void G4EmExtraParameters::SetStepFunctionLight 157 void G4EmExtraParameters::SetStepFunctionLightIons(G4double v1, G4double v2) 157 { 158 { 158 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 159 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 159 dRoverRangeLIons = v1; 160 dRoverRangeLIons = v1; 160 finalRangeLIons = v2; 161 finalRangeLIons = v2; 161 } else { 162 } else { 162 G4ExceptionDescription ed; 163 G4ExceptionDescription ed; 163 ed << "Values of step function are out of 164 ed << "Values of step function are out of range: " 164 << v1 << ", " << v2/CLHEP::mm << " mm - 165 << v1 << ", " << v2/CLHEP::mm << " mm - are ignored"; 165 PrintWarning(ed); 166 PrintWarning(ed); 166 } 167 } 167 } 168 } 168 169 169 G4double G4EmExtraParameters::GetStepFunctionL 170 G4double G4EmExtraParameters::GetStepFunctionLightIonsP1() const 170 { 171 { 171 return dRoverRangeLIons; 172 return dRoverRangeLIons; 172 } 173 } 173 174 174 G4double G4EmExtraParameters::GetStepFunctionL 175 G4double G4EmExtraParameters::GetStepFunctionLightIonsP2() const 175 { 176 { 176 return finalRangeLIons; 177 return finalRangeLIons; 177 } 178 } 178 179 179 void G4EmExtraParameters::SetStepFunctionIons( 180 void G4EmExtraParameters::SetStepFunctionIons(G4double v1, G4double v2) 180 { 181 { 181 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 182 if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) { 182 dRoverRangeIons = v1; 183 dRoverRangeIons = v1; 183 finalRangeIons = v2; 184 finalRangeIons = v2; 184 } else { 185 } else { 185 G4ExceptionDescription ed; 186 G4ExceptionDescription ed; 186 ed << "Values of step function are out of 187 ed << "Values of step function are out of range: " 187 << v1 << ", " << v2/CLHEP::mm << " mm - 188 << v1 << ", " << v2/CLHEP::mm << " mm - are ignored"; 188 PrintWarning(ed); 189 PrintWarning(ed); 189 } 190 } 190 } 191 } 191 192 192 G4double G4EmExtraParameters::GetStepFunctionI 193 G4double G4EmExtraParameters::GetStepFunctionIonsP1() const 193 { 194 { 194 return dRoverRangeIons; 195 return dRoverRangeIons; 195 } 196 } 196 197 197 G4double G4EmExtraParameters::GetStepFunctionI 198 G4double G4EmExtraParameters::GetStepFunctionIonsP2() const 198 { 199 { 199 return finalRangeIons; 200 return finalRangeIons; 200 } 201 } 201 202 202 void G4EmExtraParameters::FillStepFunction(con 203 void G4EmExtraParameters::FillStepFunction(const G4ParticleDefinition* part, G4VEnergyLossProcess* proc) const 203 { 204 { 204 // electron and positron 205 // electron and positron 205 if (11 == std::abs(part->GetPDGEncoding())) 206 if (11 == std::abs(part->GetPDGEncoding())) { 206 proc->SetStepFunction(dRoverRange, finalRa 207 proc->SetStepFunction(dRoverRange, finalRange); 207 208 208 // all heavy ions 209 // all heavy ions 209 } else if ("GenericIon" == part->GetParticle 210 } else if ("GenericIon" == part->GetParticleName()) { 210 proc->SetStepFunction(dRoverRangeIons, fin 211 proc->SetStepFunction(dRoverRangeIons, finalRangeIons); 211 212 212 // light nucleus and anti-nucleus 213 // light nucleus and anti-nucleus 213 } else if (part->GetParticleType() == "nucle 214 } else if (part->GetParticleType() == "nucleus" || part->GetParticleType() == "anti_nucleus") { 214 proc->SetStepFunction(dRoverRangeLIons, fi 215 proc->SetStepFunction(dRoverRangeLIons, finalRangeLIons); 215 216 216 // other particles 217 // other particles 217 } else { 218 } else { 218 proc->SetStepFunction(dRoverRangeMuHad, fi 219 proc->SetStepFunction(dRoverRangeMuHad, finalRangeMuHad); 219 } 220 } 220 } 221 } 221 222 222 void G4EmExtraParameters::AddPAIModel(const G4 223 void G4EmExtraParameters::AddPAIModel(const G4String& particle, 223 const G4 224 const G4String& region, 224 const G4 225 const G4String& type) 225 { 226 { 226 G4String r = CheckRegion(region); 227 G4String r = CheckRegion(region); 227 std::size_t nreg = m_regnamesPAI.size(); << 228 G4int nreg = m_regnamesPAI.size(); 228 << 229 for(G4int i=0; i<nreg; ++i) { 229 // in previously defined region other partic << 230 if((m_particlesPAI[i] == particle || 230 // type should be overrided for the same reg << 231 m_particlesPAI[i] == "all" || 231 for(std::size_t i=0; i<nreg; ++i) { << 232 particle == "all") && 232 if(m_regnamesPAI[i] == r) { << 233 (m_regnamesPAI[i] == r || 233 if (particle == "all") { << 234 m_regnamesPAI[i] == "DefaultRegionForTheWorld" || 234 m_particlesPAI[i] = particle; << 235 r == "DefaultRegionForTheWorld") ) { 235 m_typesPAI[i] = type; << 236 236 return; << 237 m_typesPAI[i] = type; 237 } else if(m_particlesPAI[i] == particle << 238 if(particle == "all") { m_particlesPAI[i] = particle; } 238 m_typesPAI[i] = type; << 239 if(r == "DefaultRegionForTheWorld") { m_regnamesPAI[i] = r; } 239 return; << 240 return; 240 } << 241 } 241 } 242 } 242 } 243 // new regions and/or particles << 244 m_particlesPAI.push_back(particle); 243 m_particlesPAI.push_back(particle); 245 m_regnamesPAI.push_back(std::move(r)); << 244 m_regnamesPAI.push_back(r); 246 m_typesPAI.push_back(type); 245 m_typesPAI.push_back(type); 247 } 246 } 248 247 249 const std::vector<G4String>& G4EmExtraParamete 248 const std::vector<G4String>& G4EmExtraParameters::ParticlesPAI() const 250 { 249 { 251 return m_particlesPAI; 250 return m_particlesPAI; 252 } 251 } 253 252 254 const std::vector<G4String>& G4EmExtraParamete 253 const std::vector<G4String>& G4EmExtraParameters::RegionsPAI() const 255 { 254 { 256 return m_regnamesPAI; 255 return m_regnamesPAI; 257 } 256 } 258 257 259 const std::vector<G4String>& G4EmExtraParamete 258 const std::vector<G4String>& G4EmExtraParameters::TypesPAI() const 260 { 259 { 261 return m_typesPAI; 260 return m_typesPAI; 262 } 261 } 263 262 264 void G4EmExtraParameters::AddPhysics(const G4S 263 void G4EmExtraParameters::AddPhysics(const G4String& region, 265 const G4S 264 const G4String& type) 266 { 265 { 267 G4String r = CheckRegion(region); 266 G4String r = CheckRegion(region); 268 std::size_t nreg = m_regnamesPhys.size(); << 267 G4int nreg = m_regnamesPhys.size(); 269 for(std::size_t i=0; i<nreg; ++i) { << 268 for(G4int i=0; i<nreg; ++i) { 270 if(r == m_regnamesPhys[i]) { return; } 269 if(r == m_regnamesPhys[i]) { return; } 271 } 270 } 272 m_regnamesPhys.push_back(std::move(r)); << 271 m_regnamesPhys.push_back(r); 273 m_typesPhys.push_back(type); 272 m_typesPhys.push_back(type); 274 } 273 } 275 274 276 const std::vector<G4String>& G4EmExtraParamete 275 const std::vector<G4String>& G4EmExtraParameters::RegionsPhysics() const 277 { 276 { 278 return m_regnamesPhys; 277 return m_regnamesPhys; 279 } 278 } 280 279 281 const std::vector<G4String>& G4EmExtraParamete 280 const std::vector<G4String>& G4EmExtraParameters::TypesPhysics() const 282 { 281 { 283 return m_typesPhys; 282 return m_typesPhys; 284 } 283 } 285 284 286 void G4EmExtraParameters::SetSubCutRegion(cons << 285 void G4EmExtraParameters::SetSubCutoff(G4bool val, const G4String& region) 287 { 286 { 288 const G4String& r = CheckRegion(region); 287 const G4String& r = CheckRegion(region); 289 std::size_t nreg = m_regnamesSubCut.size(); << 288 G4int nreg = m_regnamesSubCut.size(); 290 for(std::size_t i=0; i<nreg; ++i) { << 289 for(G4int i=0; i<nreg; ++i) { 291 if(r == m_regnamesSubCut[i]) { 290 if(r == m_regnamesSubCut[i]) { >> 291 m_subCuts[i] = val; 292 return; 292 return; 293 } 293 } 294 } 294 } 295 m_regnamesSubCut.push_back(r); 295 m_regnamesSubCut.push_back(r); >> 296 m_subCuts.push_back(val); 296 } 297 } 297 298 298 void 299 void 299 G4EmExtraParameters::SetProcessBiasingFactor(c 300 G4EmExtraParameters::SetProcessBiasingFactor(const G4String& procname, 300 G 301 G4double val, G4bool wflag) 301 { 302 { 302 if(val > 0.0) { 303 if(val > 0.0) { 303 std::size_t n = m_procBiasedXS.size(); << 304 G4int n = m_procBiasedXS.size(); 304 for(std::size_t i=0; i<n; ++i) { << 305 for(G4int i=0; i<n; ++i) { 305 if(procname == m_procBiasedXS[i]) { 306 if(procname == m_procBiasedXS[i]) { 306 m_factBiasedXS[i] = val; 307 m_factBiasedXS[i] = val; 307 m_weightBiasedXS[i]= wflag; 308 m_weightBiasedXS[i]= wflag; 308 return; 309 return; 309 } 310 } 310 } 311 } 311 m_procBiasedXS.push_back(procname); 312 m_procBiasedXS.push_back(procname); 312 m_factBiasedXS.push_back(val); 313 m_factBiasedXS.push_back(val); 313 m_weightBiasedXS.push_back(wflag); 314 m_weightBiasedXS.push_back(wflag); 314 } else { 315 } else { 315 G4ExceptionDescription ed; 316 G4ExceptionDescription ed; 316 ed << "Process: " << procname << " XS bias 317 ed << "Process: " << procname << " XS biasing factor " 317 << val << " is negative - ignored"; 318 << val << " is negative - ignored"; 318 PrintWarning(ed); 319 PrintWarning(ed); 319 } 320 } 320 } 321 } 321 322 322 void 323 void 323 G4EmExtraParameters::ActivateForcedInteraction 324 G4EmExtraParameters::ActivateForcedInteraction(const G4String& procname, 324 325 const G4String& region, 325 326 G4double length, 326 327 G4bool wflag) 327 { 328 { 328 const G4String& r = CheckRegion(region); 329 const G4String& r = CheckRegion(region); 329 if(length >= 0.0) { 330 if(length >= 0.0) { 330 std::size_t n = m_procForced.size(); << 331 G4int n = m_procForced.size(); 331 for(std::size_t i=0; i<n; ++i) { << 332 for(G4int i=0; i<n; ++i) { 332 if(procname == m_procForced[i] && r == m 333 if(procname == m_procForced[i] && r == m_regnamesForced[i] ) { 333 m_lengthForced[i] = length; 334 m_lengthForced[i] = length; 334 m_weightForced[i] = wflag; 335 m_weightForced[i] = wflag; 335 return; 336 return; 336 } 337 } 337 } 338 } 338 m_regnamesForced.push_back(r); 339 m_regnamesForced.push_back(r); 339 m_procForced.push_back(procname); 340 m_procForced.push_back(procname); 340 m_lengthForced.push_back(length); 341 m_lengthForced.push_back(length); 341 m_weightForced.push_back(wflag); 342 m_weightForced.push_back(wflag); 342 } else { 343 } else { 343 G4ExceptionDescription ed; 344 G4ExceptionDescription ed; 344 ed << "Process: " << procname << " in regi 345 ed << "Process: " << procname << " in region " << r 345 << " : forced interacttion length= " 346 << " : forced interacttion length= " 346 << length << " is negative - ignored"; 347 << length << " is negative - ignored"; 347 PrintWarning(ed); 348 PrintWarning(ed); 348 } 349 } 349 } 350 } 350 351 351 void 352 void 352 G4EmExtraParameters::ActivateSecondaryBiasing( 353 G4EmExtraParameters::ActivateSecondaryBiasing(const G4String& procname, 353 354 const G4String& region, 354 355 G4double factor, 355 356 G4double energyLim) 356 { 357 { 357 const G4String& r = CheckRegion(region); 358 const G4String& r = CheckRegion(region); 358 if(factor >= 0.0 && energyLim >= 0.0) { 359 if(factor >= 0.0 && energyLim >= 0.0) { 359 std::size_t n = m_procBiasedSec.size(); << 360 G4int n = m_procBiasedSec.size(); 360 for(std::size_t i=0; i<n; ++i) { << 361 for(G4int i=0; i<n; ++i) { 361 if(procname == m_procBiasedSec[i] && r = 362 if(procname == m_procBiasedSec[i] && r == m_regnamesBiasedSec[i] ) { 362 m_factBiasedSec[i] = factor; 363 m_factBiasedSec[i] = factor; 363 m_elimBiasedSec[i] = energyLim; 364 m_elimBiasedSec[i] = energyLim; 364 return; 365 return; 365 } 366 } 366 } 367 } 367 m_regnamesBiasedSec.push_back(r); 368 m_regnamesBiasedSec.push_back(r); 368 m_procBiasedSec.push_back(procname); 369 m_procBiasedSec.push_back(procname); 369 m_factBiasedSec.push_back(factor); 370 m_factBiasedSec.push_back(factor); 370 m_elimBiasedSec.push_back(energyLim); 371 m_elimBiasedSec.push_back(energyLim); 371 } else { 372 } else { 372 G4ExceptionDescription ed; 373 G4ExceptionDescription ed; 373 ed << "Process: " << procname << " in regi 374 ed << "Process: " << procname << " in region " << r 374 << " : secondary bised factor= " 375 << " : secondary bised factor= " 375 << factor << ", Elim= " << energyLim << 376 << factor << ", Elim= " << energyLim << " - ignored"; 376 PrintWarning(ed); 377 PrintWarning(ed); 377 } 378 } 378 } 379 } 379 380 380 void G4EmExtraParameters::DefineRegParamForLos 381 void G4EmExtraParameters::DefineRegParamForLoss(G4VEnergyLossProcess* ptr) const 381 { 382 { 382 const G4RegionStore* regionStore = G4RegionS << 383 G4RegionStore* regionStore = G4RegionStore::GetInstance(); 383 std::size_t n = m_regnamesSubCut.size(); << 384 G4int n = m_regnamesSubCut.size(); 384 for(std::size_t i=0; i<n; ++i) { << 385 for(G4int i=0; i<n; ++i) { 385 const G4Region* reg = regionStore->GetRegi 386 const G4Region* reg = regionStore->GetRegion(m_regnamesSubCut[i], false); 386 if(nullptr != reg) { ptr->ActivateSubCutof << 387 if(reg) { ptr->ActivateSubCutoff(m_subCuts[i], reg); } 387 } 388 } 388 n = m_procBiasedXS.size(); 389 n = m_procBiasedXS.size(); 389 for(std::size_t i=0; i<n; ++i) { << 390 for(G4int i=0; i<n; ++i) { 390 if(ptr->GetProcessName() == m_procBiasedXS 391 if(ptr->GetProcessName() == m_procBiasedXS[i]) { 391 ptr->SetCrossSectionBiasingFactor(m_fact 392 ptr->SetCrossSectionBiasingFactor(m_factBiasedXS[i], 392 m_weightBiasedXS[i]); 393 m_weightBiasedXS[i]); 393 break; 394 break; 394 } 395 } 395 } 396 } 396 n = m_procForced.size(); 397 n = m_procForced.size(); 397 for(std::size_t i=0; i<n; ++i) { << 398 for(G4int i=0; i<n; ++i) { 398 if(ptr->GetProcessName() == m_procForced[i 399 if(ptr->GetProcessName() == m_procForced[i]) { 399 ptr->ActivateForcedInteraction(m_lengthF 400 ptr->ActivateForcedInteraction(m_lengthForced[i], 400 m_regnamesForced[i], 401 m_regnamesForced[i], 401 m_weightForced[i]); 402 m_weightForced[i]); 402 break; 403 break; 403 } 404 } 404 } 405 } 405 n = m_procBiasedSec.size(); 406 n = m_procBiasedSec.size(); 406 for(std::size_t i=0; i<n; ++i) { << 407 for(G4int i=0; i<n; ++i) { 407 if(ptr->GetProcessName() == m_procBiasedSe 408 if(ptr->GetProcessName() == m_procBiasedSec[i]) { 408 ptr->ActivateSecondaryBiasing(m_regnames 409 ptr->ActivateSecondaryBiasing(m_regnamesBiasedSec[i], 409 m_factBiasedSec[i], 410 m_factBiasedSec[i], 410 m_elimBiasedSec[i]); 411 m_elimBiasedSec[i]); 411 break; 412 break; 412 } 413 } 413 } 414 } 414 } 415 } 415 416 416 void G4EmExtraParameters::DefineRegParamForEM( 417 void G4EmExtraParameters::DefineRegParamForEM(G4VEmProcess* ptr) const 417 { 418 { 418 std::size_t n = m_procBiasedXS.size(); << 419 G4int n = m_procBiasedXS.size(); 419 for(std::size_t i=0; i<n; ++i) { << 420 for(G4int i=0; i<n; ++i) { 420 if(ptr->GetProcessName() == m_procBiasedXS 421 if(ptr->GetProcessName() == m_procBiasedXS[i]) { 421 ptr->SetCrossSectionBiasingFactor(m_fact 422 ptr->SetCrossSectionBiasingFactor(m_factBiasedXS[i], 422 m_weightBiasedXS[i]); 423 m_weightBiasedXS[i]); 423 break; 424 break; 424 } 425 } 425 } 426 } 426 n = m_procForced.size(); 427 n = m_procForced.size(); 427 for(std::size_t i=0; i<n; ++i) { << 428 for(G4int i=0; i<n; ++i) { 428 if(ptr->GetProcessName() == m_procForced[i 429 if(ptr->GetProcessName() == m_procForced[i]) { 429 ptr->ActivateForcedInteraction(m_lengthF 430 ptr->ActivateForcedInteraction(m_lengthForced[i], 430 m_regnamesForced[i], 431 m_regnamesForced[i], 431 m_weightForced[i]); 432 m_weightForced[i]); 432 break; 433 break; 433 } 434 } 434 } 435 } 435 n = m_procBiasedSec.size(); 436 n = m_procBiasedSec.size(); 436 for(std::size_t i=0; i<n; ++i) { << 437 for(G4int i=0; i<n; ++i) { 437 if(ptr->GetProcessName() == m_procBiasedSe 438 if(ptr->GetProcessName() == m_procBiasedSec[i]) { 438 ptr->ActivateSecondaryBiasing(m_regnames 439 ptr->ActivateSecondaryBiasing(m_regnamesBiasedSec[i], 439 m_factBiasedSec[i], 440 m_factBiasedSec[i], 440 m_elimBiasedSec[i]); 441 m_elimBiasedSec[i]); 441 break; 442 break; 442 } 443 } 443 } 444 } 444 } 445 } 445 446 446 G4bool G4EmExtraParameters::QuantumEntanglemen 447 G4bool G4EmExtraParameters::QuantumEntanglement() 447 { 448 { 448 return quantumEntanglement; 449 return quantumEntanglement; 449 } 450 } 450 451 451 void G4EmExtraParameters::SetQuantumEntangleme 452 void G4EmExtraParameters::SetQuantumEntanglement(G4bool v) 452 { 453 { 453 quantumEntanglement = v; 454 quantumEntanglement = v; 454 } 455 } 455 456 456 G4bool G4EmExtraParameters::GetDirectionalSpli 457 G4bool G4EmExtraParameters::GetDirectionalSplitting() { 457 return directionalSplitting; 458 return directionalSplitting; 458 } 459 } 459 460 460 void G4EmExtraParameters::SetDirectionalSplitt 461 void G4EmExtraParameters::SetDirectionalSplitting(G4bool v) 461 { 462 { 462 directionalSplitting = v; 463 directionalSplitting = v; 463 } 464 } 464 465 465 void 466 void 466 G4EmExtraParameters::SetDirectionalSplittingTa 467 G4EmExtraParameters::SetDirectionalSplittingTarget(const G4ThreeVector& v) 467 { 468 { 468 directionalSplittingTarget = v; 469 directionalSplittingTarget = v; 469 } 470 } 470 471 471 G4ThreeVector G4EmExtraParameters::GetDirectio 472 G4ThreeVector G4EmExtraParameters::GetDirectionalSplittingTarget() const 472 { 473 { 473 return directionalSplittingTarget; 474 return directionalSplittingTarget; 474 } 475 } 475 476 476 void G4EmExtraParameters::SetDirectionalSplitt 477 void G4EmExtraParameters::SetDirectionalSplittingRadius(G4double r) 477 { 478 { 478 directionalSplittingRadius = r; 479 directionalSplittingRadius = r; 479 } 480 } 480 481 481 G4double G4EmExtraParameters::GetDirectionalSp 482 G4double G4EmExtraParameters::GetDirectionalSplittingRadius() 482 { 483 { 483 return directionalSplittingRadius; 484 return directionalSplittingRadius; 484 } 485 } 485 486 486 //....oooOO0OOooo........oooOO0OOooo........oo 487 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo..... 487 488