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