| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // -------------------------------------------
27 //
28 // GEANT4 Class file
29 //
30 // File name: G4EmParameters
31 //
32 // Author: Vladimir Ivanchenko
33 //
34 // Creation date: 18.05.2013
35 //
36 // Modifications:
37 //
38 // -------------------------------------------
39 //
40 //....oooOO0OOooo........oooOO0OOooo........oo
41 //....oooOO0OOooo........oooOO0OOooo........oo
42
43 #include "G4EmParameters.hh"
44 #include "G4PhysicalConstants.hh"
45 #include "G4UnitsTable.hh"
46 #include "G4SystemOfUnits.hh"
47 #include "G4VEmProcess.hh"
48 #include "G4VEnergyLossProcess.hh"
49 #include "G4VAtomDeexcitation.hh"
50 #include "G4EmExtraParameters.hh"
51 #include "G4EmLowEParameters.hh"
52 #include "G4EmParametersMessenger.hh"
53 #include "G4NistManager.hh"
54 #include "G4RegionStore.hh"
55 #include "G4Region.hh"
56 #include "G4ApplicationState.hh"
57 #include "G4StateManager.hh"
58 #include "G4Threading.hh"
59 #include "G4AutoLock.hh"
60
61 G4EmParameters* G4EmParameters::theInstance =
62
63 namespace
64 {
65 G4Mutex emParametersMutex = G4MUTEX_INITIALI
66 }
67
68 //....oooOO0OOooo........oooOO0OOooo........oo
69
70 G4EmParameters* G4EmParameters::Instance()
71 {
72 if(nullptr == theInstance) {
73 G4AutoLock l(&emParametersMutex);
74 if(nullptr == theInstance) {
75 static G4EmParameters manager;
76 theInstance = &manager;
77 }
78 l.unlock();
79 }
80 return theInstance;
81 }
82
83 //....oooOO0OOooo........oooOO0OOooo........oo
84
85 G4EmParameters::~G4EmParameters()
86 {
87 delete theMessenger;
88 delete fBParameters;
89 delete fCParameters;
90 delete emSaturation;
91 }
92
93 //....oooOO0OOooo........oooOO0OOooo........oo
94
95 G4EmParameters::G4EmParameters()
96 {
97 G4NistManager::Instance();
98 theMessenger = new G4EmParametersMessenger(t
99 Initialise();
100
101 fBParameters = new G4EmExtraParameters();
102 fCParameters = new G4EmLowEParameters();
103
104 fStateManager = G4StateManager::GetStateMana
105 emSaturation = nullptr;
106 }
107
108 void G4EmParameters::SetDefaults()
109 {
110 if(!IsLocked()) {
111 Initialise();
112 fBParameters->Initialise();
113 fCParameters->Initialise();
114 }
115 }
116
117 void G4EmParameters::Initialise()
118 {
119 lossFluctuation = true;
120 buildCSDARange = false;
121 flagLPM = true;
122 cutAsFinalRange = false;
123 applyCuts = false;
124 lateralDisplacement = true;
125 lateralDisplacementAlg96 = true;
126 muhadLateralDisplacement = false;
127 useAngGeneratorForIonisation = false;
128 useMottCorrection = false;
129 integral = true;
130 birks = false;
131 fICRU90 = false;
132 gener = false;
133 onIsolated = false;
134 fSamplingTable = false;
135 fPolarisation = false;
136 fMuDataFromFile = false;
137 fPEKShell = true;
138 fMscPosiCorr = true;
139 fUseEPICS2017XS = false;
140 f3GammaAnnihilationOnFly = false;
141 fUseRiGePairProductionModel = false;
142 fDNA = false;
143 fIsPrinted = false;
144
145 minKinEnergy = 0.1*CLHEP::keV;
146 maxKinEnergy = 100.0*CLHEP::TeV;
147 maxKinEnergyCSDA = 1.0*CLHEP::GeV;
148 max5DEnergyForMuPair = 0.0;
149 lowestElectronEnergy = 1.0*CLHEP::keV;
150 lowestMuHadEnergy = 1.0*CLHEP::keV;
151 lowestTripletEnergy = 1.0*CLHEP::MeV;
152 maxNIELEnergy = 0.0;
153 linLossLimit = 0.01;
154 bremsTh = bremsMuHadTh = maxKinEnergy;
155 lambdaFactor = 0.8;
156 factorForAngleLimit = 1.0;
157 thetaLimit = CLHEP::pi;
158 energyLimit = 100.0*CLHEP::MeV;
159 rangeFactor = 0.04;
160 rangeFactorMuHad = 0.2;
161 geomFactor = 2.5;
162 skin = 1.0;
163 safetyFactor = 0.6;
164 lambdaLimit = 1.0*CLHEP::mm;
165 factorScreen = 1.0;
166
167 nbinsPerDecade = 7;
168 verbose = 1;
169 workerVerbose = 0;
170 nForFreeVector = 2;
171 tripletConv = 0;
172
173 fTransportationWithMsc = G4TransportationWit
174 mscStepLimit = fUseSafety;
175 mscStepLimitMuHad = fMinimal;
176 nucFormfactor = fExponentialNF;
177 fSStype = fWVI;
178 fFluct = fUniversalFluctuation;
179 fPositronium = fSimplePositronium;
180
181 const char* data_dir = G4FindDataDir("G4LEDA
182 if (nullptr != data_dir) {
183 fDirLEDATA = G4String(data_dir);
184 }
185 else {
186 G4Exception("G4EmParameters::Initialise()"
187 "G4LEDATA data directory was n
188 }
189 }
190
191 void G4EmParameters::SetLossFluctuations(G4boo
192 {
193 if(IsLocked()) { return; }
194 lossFluctuation = val;
195 }
196
197 G4bool G4EmParameters::LossFluctuation() const
198 {
199 return lossFluctuation;
200 }
201
202 void G4EmParameters::SetBuildCSDARange(G4bool
203 {
204 if(IsLocked()) { return; }
205 buildCSDARange = val;
206 }
207
208 G4bool G4EmParameters::BuildCSDARange() const
209 {
210 return buildCSDARange;
211 }
212
213 void G4EmParameters::SetLPM(G4bool val)
214 {
215 if(IsLocked()) { return; }
216 flagLPM = val;
217 }
218
219 G4bool G4EmParameters::LPM() const
220 {
221 return flagLPM;
222 }
223
224 void G4EmParameters::SetUseCutAsFinalRange(G4b
225 {
226 if(IsLocked()) { return; }
227 cutAsFinalRange = val;
228 }
229
230 G4bool G4EmParameters::UseCutAsFinalRange() co
231 {
232 return cutAsFinalRange;
233 }
234
235 void G4EmParameters::SetApplyCuts(G4bool val)
236 {
237 if(IsLocked()) { return; }
238 applyCuts = val;
239 }
240
241 G4bool G4EmParameters::ApplyCuts() const
242 {
243 return applyCuts;
244 }
245
246 void G4EmParameters::SetFluo(G4bool val)
247 {
248 if(IsLocked()) { return; }
249 fCParameters->SetFluo(val);
250 }
251
252 G4bool G4EmParameters::Fluo() const
253 {
254 return fCParameters->Fluo();
255 }
256
257 G4EmFluoDirectory G4EmParameters::FluoDirector
258 {
259 return fCParameters->FluoDirectory();
260 }
261
262 void G4EmParameters::SetFluoDirectory(G4EmFluo
263 {
264 if(IsLocked()) { return; }
265 fCParameters->SetFluoDirectory(val);
266 }
267
268 void G4EmParameters::SetBeardenFluoDir(G4bool
269 {
270 if(IsLocked()) { return; }
271 fCParameters->SetBeardenFluoDir(val);
272 }
273
274 void G4EmParameters::SetANSTOFluoDir(G4bool va
275 {
276 if(IsLocked()) { return; }
277 fCParameters->SetANSTOFluoDir(val);
278 }
279
280 void G4EmParameters::SetXDB_EADLFluoDir(G4bool
281 {
282 if(IsLocked()) { return; }
283 fCParameters->SetXDB_EADLFluoDir(val);
284 }
285
286 void G4EmParameters::SetAuger(G4bool val)
287 {
288 if(IsLocked()) { return; }
289 fCParameters->SetAuger(val);
290 }
291
292 G4bool G4EmParameters::BeardenFluoDir()
293 {
294 auto dir = fCParameters->FluoDirectory();
295 return (dir == fluoBearden);
296 }
297
298 G4bool G4EmParameters::ANSTOFluoDir()
299 {
300 auto dir = fCParameters->FluoDirectory();
301 return (dir == fluoANSTO);
302 }
303
304 G4bool G4EmParameters::Auger() const
305 {
306 return fCParameters->Auger();
307 }
308
309 void G4EmParameters::SetPixe(G4bool val)
310 {
311 if(IsLocked()) { return; }
312 fCParameters->SetPixe(val);
313 }
314
315 G4bool G4EmParameters::Pixe() const
316 {
317 return fCParameters->Pixe();
318 }
319
320 void G4EmParameters::SetDeexcitationIgnoreCut(
321 {
322 if(IsLocked()) { return; }
323 fCParameters->SetDeexcitationIgnoreCut(val);
324 }
325
326 G4bool G4EmParameters::DeexcitationIgnoreCut()
327 {
328 return fCParameters->DeexcitationIgnoreCut()
329 }
330
331 void G4EmParameters::SetLateralDisplacement(G4
332 {
333 if(IsLocked()) { return; }
334 lateralDisplacement = val;
335 }
336
337 G4bool G4EmParameters::LateralDisplacement() c
338 {
339 return lateralDisplacement;
340 }
341
342 void G4EmParameters::SetLateralDisplacementAlg
343 {
344 if(IsLocked()) { return; }
345 lateralDisplacementAlg96 = val;
346 }
347
348 G4bool G4EmParameters::LateralDisplacementAlg9
349 {
350 return lateralDisplacementAlg96;
351 }
352
353 void G4EmParameters::SetMuHadLateralDisplaceme
354 {
355 if(IsLocked()) { return; }
356 muhadLateralDisplacement = val;
357 }
358
359 G4bool G4EmParameters::MuHadLateralDisplacemen
360 {
361 return muhadLateralDisplacement;
362 }
363
364 void G4EmParameters::ActivateAngularGeneratorF
365 {
366 if(IsLocked()) { return; }
367 useAngGeneratorForIonisation = val;
368 }
369
370 G4bool G4EmParameters::UseAngularGeneratorForI
371 {
372 return useAngGeneratorForIonisation;
373 }
374
375 void G4EmParameters::SetUseMottCorrection(G4bo
376 {
377 if(IsLocked()) { return; }
378 useMottCorrection = val;
379 }
380
381 G4bool G4EmParameters::UseMottCorrection() con
382 {
383 return useMottCorrection;
384 }
385
386 void G4EmParameters::SetIntegral(G4bool val)
387 {
388 if(IsLocked()) { return; }
389 integral = val;
390 }
391
392 G4bool G4EmParameters::Integral() const
393 {
394 return integral;
395 }
396
397 void G4EmParameters::SetEnablePolarisation(G4b
398 {
399 if(IsLocked()) { return; }
400 fPolarisation = val;
401 }
402
403 G4bool G4EmParameters::EnablePolarisation() co
404 {
405 return fPolarisation;
406 }
407
408 void G4EmParameters::SetBirksActive(G4bool val
409 {
410 if(IsLocked()) { return; }
411 birks = val;
412 if(birks && nullptr == emSaturation) { emSat
413 }
414
415 G4bool G4EmParameters::BirksActive() const
416 {
417 return birks;
418 }
419
420 void G4EmParameters::SetUseICRU90Data(G4bool v
421 {
422 if(IsLocked()) { return; }
423 fICRU90 = val;
424 }
425
426 G4bool G4EmParameters::UseICRU90Data() const
427 {
428 return fICRU90;
429 }
430
431 void G4EmParameters::SetDNAFast(G4bool val)
432 {
433 if(IsLocked()) { return; }
434 fCParameters->SetDNAFast(val);
435 if(val) { ActivateDNA(); }
436 }
437
438 G4bool G4EmParameters::DNAFast() const
439 {
440 return fCParameters->DNAFast();
441 }
442
443 void G4EmParameters::SetDNAStationary(G4bool v
444 {
445 if(IsLocked()) { return; }
446 fCParameters->SetDNAStationary(val);
447 if(val) { ActivateDNA(); }
448 }
449
450 G4bool G4EmParameters::DNAStationary() const
451 {
452 return fCParameters->DNAStationary();
453 }
454
455 void G4EmParameters::SetDNAElectronMsc(G4bool
456 {
457 if(IsLocked()) { return; }
458 fCParameters->SetDNAElectronMsc(val);
459 if(val) { ActivateDNA(); }
460 }
461
462 G4bool G4EmParameters::DNAElectronMsc() const
463 {
464 return fCParameters->DNAElectronMsc();
465 }
466
467 void G4EmParameters::SetGeneralProcessActive(G
468 {
469 if(IsLocked()) { return; }
470 gener = val;
471 }
472
473 G4bool G4EmParameters::GeneralProcessActive()
474 {
475 return gener;
476 }
477
478 void G4EmParameters::SetEmSaturation(G4EmSatur
479 {
480 if(IsLocked()) { return; }
481 birks = (nullptr != ptr);
482 if(emSaturation != ptr) {
483 delete emSaturation;
484 emSaturation = ptr;
485 }
486 }
487
488 G4bool G4EmParameters::RetrieveMuDataFromFile(
489 {
490 return fMuDataFromFile;
491 }
492
493 void G4EmParameters::SetRetrieveMuDataFromFile
494 {
495 fMuDataFromFile = v;
496 }
497
498 void G4EmParameters::SetOnIsolated(G4bool val)
499 {
500 if(IsLocked()) { return; }
501 onIsolated = val;
502 }
503
504 G4bool G4EmParameters::OnIsolated() const
505 {
506 return onIsolated;
507 }
508
509 void G4EmParameters::SetEnableSamplingTable(G4
510 {
511 if(IsLocked()) { return; }
512 fSamplingTable = val;
513 }
514
515 G4bool G4EmParameters::EnableSamplingTable() c
516 {
517 return fSamplingTable;
518 }
519
520 G4bool G4EmParameters::PhotoeffectBelowKShell(
521 {
522 return fPEKShell;
523 }
524
525 void G4EmParameters::SetPhotoeffectBelowKShell
526 {
527 if(IsLocked()) { return; }
528 fPEKShell = v;
529 }
530
531 G4bool G4EmParameters::MscPositronCorrection()
532 {
533 return fMscPosiCorr;
534 }
535
536 void G4EmParameters::SetMscPositronCorrection(
537 {
538 if(IsLocked()) { return; }
539 fMscPosiCorr = v;
540 }
541
542 G4bool G4EmParameters::UseEPICS2017XS() const
543 {
544 return fUseEPICS2017XS;
545 }
546
547 void G4EmParameters::SetUseEPICS2017XS(G4bool
548 {
549 if(IsLocked()) { return; }
550 fUseEPICS2017XS = v;
551 }
552
553 G4bool G4EmParameters::Use3GammaAnnihilationOn
554 {
555 return f3GammaAnnihilationOnFly;
556 }
557
558 void G4EmParameters::Set3GammaAnnihilationOnFl
559 {
560 if(IsLocked()) { return; }
561 f3GammaAnnihilationOnFly = v;
562 }
563
564 G4bool G4EmParameters::UseRiGePairProductionMo
565 {
566 return fUseRiGePairProductionModel;
567 }
568
569 void G4EmParameters::SetUseRiGePairProductionM
570 {
571 if (IsLocked()) { return; }
572 fUseRiGePairProductionModel = v;
573 }
574
575 void G4EmParameters::ActivateDNA()
576 {
577 if(IsLocked()) { return; }
578 fDNA = true;
579 }
580
581 void G4EmParameters::SetIsPrintedFlag(G4bool v
582 {
583 fIsPrinted = val;
584 }
585
586 G4bool G4EmParameters::IsPrintLocked() const
587 {
588 return fIsPrinted;
589 }
590
591 G4EmSaturation* G4EmParameters::GetEmSaturatio
592 {
593 if(nullptr == emSaturation) {
594 #ifdef G4MULTITHREADED
595 G4MUTEXLOCK(&emParametersMutex);
596 if(nullptr == emSaturation) {
597 #endif
598 emSaturation = new G4EmSaturation(1);
599 #ifdef G4MULTITHREADED
600 }
601 G4MUTEXUNLOCK(&emParametersMutex);
602 #endif
603 }
604 birks = true;
605 return emSaturation;
606 }
607
608 void G4EmParameters::SetMinEnergy(G4double val
609 {
610 if(IsLocked()) { return; }
611 if(val > 1.e-3*CLHEP::eV && val < maxKinEner
612 minKinEnergy = val;
613 } else {
614 G4ExceptionDescription ed;
615 ed << "Value of MinKinEnergy - is out of r
616 << " MeV is ignored";
617 PrintWarning(ed);
618 }
619 }
620
621 G4double G4EmParameters::MinKinEnergy() const
622 {
623 return minKinEnergy;
624 }
625
626 void G4EmParameters::SetMaxEnergy(G4double val
627 {
628 if(IsLocked()) { return; }
629 if(val > std::max(minKinEnergy,599.9*CLHEP::
630 maxKinEnergy = val;
631 } else {
632 G4ExceptionDescription ed;
633 ed << "Value of MaxKinEnergy is out of ran
634 << val/CLHEP::GeV
635 << " GeV is ignored; allowed range 600
636 PrintWarning(ed);
637 }
638 }
639
640 G4double G4EmParameters::MaxKinEnergy() const
641 {
642 return maxKinEnergy;
643 }
644
645 void G4EmParameters::SetMaxEnergyForCSDARange(
646 {
647 if(IsLocked()) { return; }
648 if(val > minKinEnergy && val <= 100*CLHEP::T
649 maxKinEnergyCSDA = val;
650 } else {
651 G4ExceptionDescription ed;
652 ed << "Value of MaxKinEnergyCSDA is out of
653 << val/CLHEP::GeV << " GeV is ignored;
654 << minKinEnergy << " MeV - 100 TeV";
655 PrintWarning(ed);
656 }
657 }
658
659 G4double G4EmParameters::MaxEnergyForCSDARange
660 {
661 return maxKinEnergyCSDA;
662 }
663
664 void G4EmParameters::SetLowestElectronEnergy(G
665 {
666 if(IsLocked()) { return; }
667 if(val >= 0.0) { lowestElectronEnergy = val;
668 }
669
670 G4double G4EmParameters::LowestElectronEnergy(
671 {
672 return lowestElectronEnergy;
673 }
674
675 void G4EmParameters::SetLowestMuHadEnergy(G4do
676 {
677 if(IsLocked()) { return; }
678 if(val >= 0.0) { lowestMuHadEnergy = val; }
679 }
680
681 G4double G4EmParameters::LowestMuHadEnergy() c
682 {
683 return lowestMuHadEnergy;
684 }
685
686 void G4EmParameters::SetLowestTripletEnergy(G4
687 {
688 if(IsLocked()) { return; }
689 if(val > 0.0) { lowestTripletEnergy = val; }
690 }
691
692 G4double G4EmParameters::LowestTripletEnergy()
693 {
694 return lowestTripletEnergy;
695 }
696
697 void G4EmParameters::SetMaxNIELEnergy(G4double
698 {
699 if(IsLocked()) { return; }
700 if(val >= 0.0) { maxNIELEnergy = val; }
701 }
702
703 G4double G4EmParameters::MaxNIELEnergy() const
704 {
705 return maxNIELEnergy;
706 }
707
708 void G4EmParameters::SetMaxEnergyFor5DMuPair(G
709 {
710 if(IsLocked()) { return; }
711 if(val > 0.0) { max5DEnergyForMuPair = val;
712 }
713
714 G4double G4EmParameters::MaxEnergyFor5DMuPair(
715 {
716 return max5DEnergyForMuPair;
717 }
718
719 void G4EmParameters::SetLinearLossLimit(G4doub
720 {
721 if(IsLocked()) { return; }
722 if(val > 0.0 && val < 0.5) {
723 linLossLimit = val;
724 } else {
725 G4ExceptionDescription ed;
726 ed << "Value of linLossLimit is out of ran
727 << " is ignored";
728 PrintWarning(ed);
729 }
730 }
731
732 G4double G4EmParameters::LinearLossLimit() con
733 {
734 return linLossLimit;
735 }
736
737 void G4EmParameters::SetBremsstrahlungTh(G4dou
738 {
739 if(IsLocked()) { return; }
740 if(val > 0.0) {
741 bremsTh = val;
742 } else {
743 G4ExceptionDescription ed;
744 ed << "Value of bremsstrahlung threshold i
745 << val/GeV << " GeV is ignored";
746 PrintWarning(ed);
747 }
748 }
749
750 G4double G4EmParameters::BremsstrahlungTh() co
751 {
752 return bremsTh;
753 }
754
755 void G4EmParameters::SetMuHadBremsstrahlungTh(
756 {
757 if(IsLocked()) { return; }
758 if(val > 0.0) {
759 bremsMuHadTh = val;
760 } else {
761 G4ExceptionDescription ed;
762 ed << "Value of bremsstrahlung threshold i
763 << val/GeV << " GeV is ignored";
764 PrintWarning(ed);
765 }
766 }
767
768 G4double G4EmParameters::MuHadBremsstrahlungTh
769 {
770 return bremsMuHadTh;
771 }
772
773 void G4EmParameters::SetLambdaFactor(G4double
774 {
775 if(IsLocked()) { return; }
776 if(val > 0.0 && val < 1.0) {
777 lambdaFactor = val;
778 } else {
779 G4ExceptionDescription ed;
780 ed << "Value of lambda factor is out of ra
781 << " is ignored";
782 PrintWarning(ed);
783 }
784 }
785
786 G4double G4EmParameters::LambdaFactor() const
787 {
788 return lambdaFactor;
789 }
790
791 void G4EmParameters::SetFactorForAngleLimit(G4
792 {
793 if(IsLocked()) { return; }
794 if(val > 0.0) {
795 factorForAngleLimit = val;
796 } else {
797 G4ExceptionDescription ed;
798 ed << "Value of factor for enegry limit is
799 << val << " is ignored";
800 PrintWarning(ed);
801 }
802 }
803
804 G4double G4EmParameters::FactorForAngleLimit()
805 {
806 return factorForAngleLimit;
807 }
808
809 void G4EmParameters::SetMscThetaLimit(G4double
810 {
811 if(IsLocked()) { return; }
812 if(val >= 0.0 && val <= pi) {
813 thetaLimit = val;
814 } else {
815 G4ExceptionDescription ed;
816 ed << "Value of polar angle limit is out o
817 << val << " is ignored";
818 PrintWarning(ed);
819 }
820 }
821
822 G4double G4EmParameters::MscThetaLimit() const
823 {
824 return thetaLimit;
825 }
826
827 void G4EmParameters::SetMscEnergyLimit(G4doubl
828 {
829 if(IsLocked()) { return; }
830 if(val >= 0.0) {
831 energyLimit = val;
832 } else {
833 G4ExceptionDescription ed;
834 ed << "Value of msc energy limit is out of
835 << val << " is ignored";
836 PrintWarning(ed);
837 }
838 }
839
840 G4double G4EmParameters::MscEnergyLimit() cons
841 {
842 return energyLimit;
843 }
844
845 void G4EmParameters::SetMscRangeFactor(G4doubl
846 {
847 if(IsLocked()) { return; }
848 if(val > 0.0 && val < 1.0) {
849 rangeFactor = val;
850 } else {
851 G4ExceptionDescription ed;
852 ed << "Value of rangeFactor is out of rang
853 << val << " is ignored";
854 PrintWarning(ed);
855 }
856 }
857
858 G4double G4EmParameters::MscRangeFactor() cons
859 {
860 return rangeFactor;
861 }
862
863 void G4EmParameters::SetMscMuHadRangeFactor(G4
864 {
865 if(IsLocked()) { return; }
866 if(val > 0.0 && val < 1.0) {
867 rangeFactorMuHad = val;
868 } else {
869 G4ExceptionDescription ed;
870 ed << "Value of rangeFactorMuHad is out of
871 << val << " is ignored";
872 PrintWarning(ed);
873 }
874 }
875
876 G4double G4EmParameters::MscMuHadRangeFactor()
877 {
878 return rangeFactorMuHad;
879 }
880
881 void G4EmParameters::SetMscGeomFactor(G4double
882 {
883 if(IsLocked()) { return; }
884 if(val >= 1.0) {
885 geomFactor = val;
886 } else {
887 G4ExceptionDescription ed;
888 ed << "Value of geomFactor is out of range
889 << val << " is ignored";
890 PrintWarning(ed);
891 }
892 }
893
894 G4double G4EmParameters::MscGeomFactor() const
895 {
896 return geomFactor;
897 }
898
899 void G4EmParameters::SetMscSafetyFactor(G4doub
900 {
901 if(IsLocked()) { return; }
902 if(val >= 0.1) {
903 safetyFactor = val;
904 } else {
905 G4ExceptionDescription ed;
906 ed << "Value of safetyFactor is out of ran
907 << val << " is ignored";
908 PrintWarning(ed);
909 }
910 }
911
912 G4double G4EmParameters::MscSafetyFactor() con
913 {
914 return safetyFactor;
915 }
916
917 void G4EmParameters::SetMscLambdaLimit(G4doubl
918 {
919 if(IsLocked()) { return; }
920 if(val >= 0.0) {
921 lambdaLimit = val;
922 } else {
923 G4ExceptionDescription ed;
924 ed << "Value of lambdaLimit is out of rang
925 << val << " is ignored";
926 PrintWarning(ed);
927 }
928 }
929
930 G4double G4EmParameters::MscLambdaLimit() cons
931 {
932 return lambdaLimit;
933 }
934
935 void G4EmParameters::SetMscSkin(G4double val)
936 {
937 if(IsLocked()) { return; }
938 if(val >= 1.0) {
939 skin = val;
940 } else {
941 G4ExceptionDescription ed;
942 ed << "Value of skin is out of range: "
943 << val << " is ignored";
944 PrintWarning(ed);
945 }
946 }
947
948 G4double G4EmParameters::MscSkin() const
949 {
950 return skin;
951 }
952
953 void G4EmParameters::SetScreeningFactor(G4doub
954 {
955 if(IsLocked()) { return; }
956 if(val > 0.0) {
957 factorScreen = val;
958 } else {
959 G4ExceptionDescription ed;
960 ed << "Value of factorScreen is out of ran
961 << val << " is ignored";
962 PrintWarning(ed);
963 }
964 }
965
966 G4double G4EmParameters::ScreeningFactor() con
967 {
968 return factorScreen;
969 }
970
971 void G4EmParameters::SetStepFunction(G4double
972 {
973 if(IsLocked()) { return; }
974 fBParameters->SetStepFunction(v1, v2);
975 }
976
977 void G4EmParameters::SetStepFunctionMuHad(G4do
978 {
979 if(IsLocked()) { return; }
980 fBParameters->SetStepFunctionMuHad(v1, v2);
981 }
982
983 void G4EmParameters::SetStepFunctionLightIons(
984 {
985 if(IsLocked()) { return; }
986 fBParameters->SetStepFunctionLightIons(v1, v
987 }
988
989 void G4EmParameters::SetStepFunctionIons(G4dou
990 {
991 if(IsLocked()) { return; }
992 fBParameters->SetStepFunctionIons(v1, v2);
993 }
994
995 void G4EmParameters::FillStepFunction(const G4
996 {
997 fBParameters->FillStepFunction(part, proc);
998 }
999
1000 G4int G4EmParameters::NumberOfBins() const
1001 {
1002 return nbinsPerDecade*G4lrint(std::log10(ma
1003 }
1004
1005 void G4EmParameters::SetNumberOfBinsPerDecade
1006 {
1007 if(IsLocked()) { return; }
1008 if(val >= 5 && val < 1000000) {
1009 nbinsPerDecade = val;
1010 } else {
1011 G4ExceptionDescription ed;
1012 ed << "Value of number of bins per decade
1013 << val << " is ignored";
1014 PrintWarning(ed);
1015 }
1016 }
1017
1018 G4int G4EmParameters::NumberOfBinsPerDecade()
1019 {
1020 return nbinsPerDecade;
1021 }
1022
1023 void G4EmParameters::SetVerbose(G4int val)
1024 {
1025 if(IsLocked()) { return; }
1026 verbose = val;
1027 workerVerbose = std::min(workerVerbose, ver
1028 }
1029
1030 G4int G4EmParameters::Verbose() const
1031 {
1032 return verbose;
1033 }
1034
1035 void G4EmParameters::SetWorkerVerbose(G4int v
1036 {
1037 if(IsLocked()) { return; }
1038 workerVerbose = val;
1039 }
1040
1041 G4int G4EmParameters::WorkerVerbose() const
1042 {
1043 return workerVerbose;
1044 }
1045
1046 void G4EmParameters::SetNumberForFreeVector(G
1047 {
1048 if(IsLocked()) { return; }
1049 nForFreeVector = val;
1050 }
1051
1052 G4int G4EmParameters::NumberForFreeVector() c
1053 {
1054 return nForFreeVector;
1055 }
1056
1057 void G4EmParameters::SetTransportationWithMsc
1058 {
1059 if(IsLocked()) { return; }
1060 fTransportationWithMsc = val;
1061 }
1062
1063 G4TransportationWithMscType G4EmParameters::T
1064 {
1065 return fTransportationWithMsc;
1066 }
1067
1068 void G4EmParameters::SetFluctuationType(G4EmF
1069 {
1070 if(IsLocked()) { return; }
1071 fFluct = val;
1072 }
1073
1074 G4EmFluctuationType G4EmParameters::Fluctuati
1075 {
1076 return fFluct;
1077 }
1078
1079 void G4EmParameters::SetPositronAtRestModelTy
1080 {
1081 if(IsLocked()) { return; }
1082 fPositronium = val;
1083 }
1084
1085 G4PositronAtRestModelType G4EmParameters::Pos
1086 {
1087 return fPositronium;
1088 }
1089
1090 void G4EmParameters::SetMscStepLimitType(G4Ms
1091 {
1092 if(IsLocked()) { return; }
1093 mscStepLimit = val;
1094 }
1095
1096 G4MscStepLimitType G4EmParameters::MscStepLim
1097 {
1098 return mscStepLimit;
1099 }
1100
1101 void G4EmParameters::SetMscMuHadStepLimitType
1102 {
1103 if(IsLocked()) { return; }
1104 mscStepLimitMuHad = val;
1105 }
1106
1107 G4MscStepLimitType G4EmParameters::MscMuHadSt
1108 {
1109 return mscStepLimitMuHad;
1110 }
1111
1112 void G4EmParameters::SetSingleScatteringType(
1113 {
1114 if(IsLocked()) { return; }
1115 fSStype = val;
1116 }
1117
1118 G4eSingleScatteringType G4EmParameters::Singl
1119 {
1120 return fSStype;
1121 }
1122
1123 void
1124 G4EmParameters::SetNuclearFormfactorType(G4Nu
1125 {
1126 if(IsLocked()) { return; }
1127 nucFormfactor = val;
1128 }
1129
1130 G4NuclearFormfactorType G4EmParameters::Nucle
1131 {
1132 return nucFormfactor;
1133 }
1134
1135 void G4EmParameters::SetDNAeSolvationSubType(
1136 {
1137 if(IsLocked()) { return; }
1138 fCParameters->SetDNAeSolvationSubType(val);
1139 ActivateDNA();
1140 }
1141
1142 G4DNAModelSubType G4EmParameters::DNAeSolvati
1143 {
1144 return fCParameters->DNAeSolvationSubType()
1145 }
1146
1147 void G4EmParameters::SetConversionType(G4int
1148 {
1149 if(IsLocked()) { return; }
1150 tripletConv = val;
1151 }
1152
1153 G4int G4EmParameters::GetConversionType() con
1154 {
1155 return tripletConv;
1156 }
1157
1158 void G4EmParameters::SetPIXECrossSectionModel
1159 {
1160 if(IsLocked()) { return; }
1161 fCParameters->SetPIXECrossSectionModel(sss)
1162 }
1163
1164 const G4String& G4EmParameters::PIXECrossSect
1165 {
1166 return fCParameters->PIXECrossSectionModel(
1167 }
1168
1169 void G4EmParameters::SetPIXEElectronCrossSect
1170 {
1171 if(IsLocked()) { return; }
1172 fCParameters->SetPIXEElectronCrossSectionMo
1173 }
1174
1175 const G4String& G4EmParameters::PIXEElectronC
1176 {
1177 return fCParameters->PIXEElectronCrossSecti
1178 }
1179
1180 void G4EmParameters::SetLivermoreDataDir(cons
1181 {
1182 if(IsLocked()) { return; }
1183 fCParameters->SetLivermoreDataDir(sss);
1184 }
1185
1186 const G4String& G4EmParameters::LivermoreData
1187 {
1188 return fCParameters->LivermoreDataDir();
1189 }
1190
1191 void G4EmParameters::PrintWarning(G4Exception
1192 {
1193 G4Exception("G4EmParameters", "em0044", Jus
1194 }
1195
1196 void G4EmParameters::AddPAIModel(const G4Stri
1197 const G4Stri
1198 const G4Stri
1199 {
1200 if(IsLocked()) { return; }
1201 fBParameters->AddPAIModel(particle, region,
1202 }
1203
1204 const std::vector<G4String>& G4EmParameters::
1205 {
1206 return fBParameters->ParticlesPAI();
1207 }
1208
1209 const std::vector<G4String>& G4EmParameters::
1210 {
1211 return fBParameters->RegionsPAI();
1212 }
1213
1214 const std::vector<G4String>& G4EmParameters::
1215 {
1216 return fBParameters->TypesPAI();
1217 }
1218
1219 void G4EmParameters::AddMicroElec(const G4Str
1220 {
1221 if(IsLocked()) { return; }
1222 fCParameters->AddMicroElec(region);
1223 }
1224
1225 const std::vector<G4String>& G4EmParameters::
1226 {
1227 return fCParameters->RegionsMicroElec();
1228 }
1229
1230 void G4EmParameters::AddDNA(const G4String& r
1231 {
1232 if(IsLocked()) { return; }
1233 fCParameters->AddDNA(region, type);
1234 ActivateDNA();
1235 }
1236
1237 const std::vector<G4String>& G4EmParameters::
1238 {
1239 return fCParameters->RegionsDNA();
1240 }
1241
1242 const std::vector<G4String>& G4EmParameters::
1243 {
1244 return fCParameters->TypesDNA();
1245 }
1246
1247 void G4EmParameters::AddPhysics(const G4Strin
1248 {
1249 if(IsLocked()) { return; }
1250 fBParameters->AddPhysics(region, type);
1251 }
1252
1253 const std::vector<G4String>& G4EmParameters::
1254 {
1255 return fBParameters->RegionsPhysics();
1256 }
1257
1258 const std::vector<G4String>& G4EmParameters::
1259 {
1260 return fBParameters->TypesPhysics();
1261 }
1262
1263 void G4EmParameters::SetSubCutRegion(const G4
1264 {
1265 if(IsLocked()) { return; }
1266 fBParameters->SetSubCutRegion(region);
1267 }
1268
1269 void
1270 G4EmParameters::SetDeexActiveRegion(const G4S
1271 G4bool aa
1272 {
1273 if(IsLocked()) { return; }
1274 fCParameters->SetDeexActiveRegion(region, a
1275 }
1276
1277 void
1278 G4EmParameters::SetProcessBiasingFactor(const
1279 G4dou
1280 {
1281 if(IsLocked()) { return; }
1282 fBParameters->SetProcessBiasingFactor(procn
1283 }
1284
1285 void
1286 G4EmParameters::ActivateForcedInteraction(con
1287 con
1288 G4d
1289 G4b
1290 {
1291 if(IsLocked() && !gener) { return; }
1292 fBParameters->ActivateForcedInteraction(pro
1293 }
1294
1295 void
1296 G4EmParameters::ActivateSecondaryBiasing(cons
1297 cons
1298 G4do
1299 G4do
1300 {
1301 if(IsLocked()) { return; }
1302 fBParameters->ActivateSecondaryBiasing(proc
1303 }
1304
1305 void G4EmParameters::DefineRegParamForLoss(G4
1306 {
1307 fBParameters->DefineRegParamForLoss(ptr);
1308 }
1309
1310 void G4EmParameters::DefineRegParamForEM(G4VE
1311 {
1312 fBParameters->DefineRegParamForEM(ptr);
1313 }
1314
1315 G4bool G4EmParameters::QuantumEntanglement()
1316 {
1317 return fBParameters->QuantumEntanglement();
1318 }
1319
1320 void G4EmParameters::SetQuantumEntanglement(G
1321 {
1322 if(IsLocked()) { return; }
1323 fBParameters->SetQuantumEntanglement(v);
1324 }
1325
1326 G4bool G4EmParameters::GetDirectionalSplittin
1327 return fBParameters->GetDirectionalSplittin
1328 }
1329
1330 void G4EmParameters::SetDirectionalSplitting(
1331 {
1332 if(IsLocked()) { return; }
1333 fBParameters->SetDirectionalSplitting(v);
1334 }
1335
1336 void G4EmParameters::SetDirectionalSplittingT
1337 {
1338 if(IsLocked()) { return; }
1339 fBParameters->SetDirectionalSplittingTarget
1340 }
1341
1342 G4ThreeVector G4EmParameters::GetDirectionalS
1343 {
1344 return fBParameters->GetDirectionalSplittin
1345 }
1346
1347 void G4EmParameters::SetDirectionalSplittingR
1348 {
1349 if(IsLocked()) { return; }
1350 fBParameters->SetDirectionalSplittingRadius
1351 }
1352
1353 G4double G4EmParameters::GetDirectionalSplitt
1354 {
1355 return fBParameters->GetDirectionalSplittin
1356 }
1357
1358 void G4EmParameters::DefineRegParamForDeex(G4
1359 {
1360 fCParameters->DefineRegParamForDeex(ptr);
1361 }
1362
1363 const G4String& G4EmParameters::GetDirLEDATA(
1364 {
1365 return fDirLEDATA;
1366 }
1367
1368 void G4EmParameters::StreamInfo(std::ostream&
1369 {
1370 G4long prec = os.precision(5);
1371 os << "====================================
1372 os << "====== Electromagnet
1373 os << "====================================
1374 os << "LPM effect enabled
1375 os << "Enable creation and use of sampling
1376 os << "Apply cuts on all EM processes
1377 const char* transportationWithMsc = "Disabl
1378 if(fTransportationWithMsc == G4Transportati
1379 transportationWithMsc = "Enabled";
1380 } else if (fTransportationWithMsc == G4Tran
1381 transportationWithMsc = "MultipleSteps";
1382 }
1383 os << "Use combined TransportationWithMsc
1384 os << "Use general process
1385 os << "Enable linear polarisation for gamma
1386 os << "Enable photoeffect sampling below K-
1387 os << "Enable sampling of quantum entanglem
1388 <<fBParameters->QuantumEntanglement() <
1389 os << "X-section factor for integral approa
1390 os << "Min kinetic energy for tables
1391 <<G4BestUnit(minKinEnergy,"Energy") << "
1392 os << "Max kinetic energy for tables
1393 <<G4BestUnit(maxKinEnergy,"Energy") << "
1394 os << "Number of bins per decade of a table
1395 os << "Verbose level
1396 os << "Verbose level for worker thread
1397 os << "Bremsstrahlung energy threshold abov
1398 << " primary e+- is added to the list o
1399 <<G4BestUnit(bremsTh,"Energy") << "\n";
1400 os << "Bremsstrahlung energy threshold abov
1401 << " muon/hadron is added to the list o
1402 <<G4BestUnit(bremsMuHadTh,"Energy") << "
1403 G4String name3g = "SimplePositronium";
1404 if (fPositronium == fAllisonPositronium) {
1405 else if (fPositronium == fOrePowell) { name
1406 else if (fPositronium == fOrePowellPolar) {
1407 os << "Positron annihilation at rest model
1408
1409 os << "Enable 3 gamma annihilation on fly
1410 << f3GammaAnnihilationOnFly << "\n";
1411 os << "Lowest triplet kinetic energy
1412 <<G4BestUnit(lowestTripletEnergy,"Energy
1413 os << "Enable sampling of gamma linear pola
1414 os << "5D gamma conversion model type
1415 os << "5D gamma conversion model on isolate
1416 if(max5DEnergyForMuPair>0.0) {
1417 os << "5D gamma conversion limit for muon p
1418 << max5DEnergyForMuPair/CLHEP::GeV << "
1419 }
1420 os << "Use Ricardo-Gerardo pair production
1421 << fUseRiGePairProductionModel << "\n";
1422 os << "Livermore data directory
1423 << fCParameters->LivermoreDataDir() << "
1424
1425 os << "====================================
1426 os << "====== Ionisation Pa
1427 os << "====================================
1428 os << "Step function for e+-
1429 <<"("<<fBParameters->GetStepFunctionP1()
1430 << fBParameters->GetStepFunctionP2()/CLH
1431 os << "Step function for muons/hadrons
1432 <<"("<<fBParameters->GetStepFunctionMuHa
1433 << fBParameters->GetStepFunctionMuHadP2(
1434 os << "Step function for light ions
1435 <<"("<<fBParameters->GetStepFunctionLigh
1436 << fBParameters->GetStepFunctionLightIon
1437 os << "Step function for general ions
1438 <<"("<<fBParameters->GetStepFunctionIons
1439 << fBParameters->GetStepFunctionIonsP2()
1440 os << "Lowest e+e- kinetic energy
1441 <<G4BestUnit(lowestElectronEnergy,"Energ
1442 os << "Lowest muon/hadron kinetic energy
1443 <<G4BestUnit(lowestMuHadEnergy,"Energy")
1444 os << "Use ICRU90 data
1445 os << "Fluctuations of dE/dx are enabled
1446 G4String namef = "Universal";
1447 if(fFluct == fUrbanFluctuation) { namef = "
1448 else if(fFluct == fDummyFluctuation) { name
1449 os << "Type of fluctuation model for lepton
1450 os << "Use built-in Birks satuaration
1451 os << "Build CSDA range enabled
1452 os << "Use cut as a final range enabled
1453 os << "Enable angular generator interface
1454 <<useAngGeneratorForIonisation << "\n";
1455 os << "Max kinetic energy for CSDA tables
1456 <<G4BestUnit(maxKinEnergyCSDA,"Energy")
1457 os << "Max kinetic energy for NIEL computat
1458 <<G4BestUnit(maxNIELEnergy,"Energy") <<
1459 os << "Linear loss limit
1460 os << "Read data from file for e+e- pair pr
1461
1462 os << "====================================
1463 os << "====== Multiple Scat
1464 os << "====================================
1465 os << "Type of msc step limit algorithm for
1466 os << "Type of msc step limit algorithm for
1467 os << "Msc lateral displacement for e+- ena
1468 os << "Msc lateral displacement for muons a
1469 os << "Urban msc model lateral displacement
1470 os << "Range factor for msc step limit for
1471 os << "Range factor for msc step limit for
1472 os << "Geometry factor for msc step limitat
1473 os << "Safety factor for msc step limit for
1474 os << "Skin parameter for msc step limitati
1475 os << "Lambda limit for msc step limit for
1476 os << "Use Mott correction for e- scatterin
1477 os << "Factor used for dynamic computation
1478 << " limit between single and multiple
1479 os << "Fixed angular limit between single \
1480 << " and multiple scattering
1481 << thetaLimit/CLHEP::rad << " rad\n";
1482 os << "Upper energy limit for e+- multiple
1483 << energyLimit/CLHEP::MeV << " MeV\n";
1484 os << "Type of electron single scattering m
1485 os << "Type of nuclear form-factor
1486 os << "Screening factor
1487 os << "====================================
1488
1489 if(fCParameters->Fluo()) {
1490 os << "====== Atomic Deexci
1491 os << "====================================
1492 os << "Fluorescence enabled
1493 G4String named = "fluor";
1494 G4EmFluoDirectory fdir = FluoDirectory();
1495 if(fdir == fluoBearden) { named = "fluor_Be
1496 else if(fdir == fluoANSTO) { named = "fluor
1497 else if(fdir == fluoXDB_EADL) { named = "fl
1498 os << "Directory in G4LEDATA for fluorescen
1499 os << "Auger electron cascade enabled
1500 <<fCParameters->Auger() << "\n";
1501 os << "PIXE atomic de-excitation enabled
1502 os << "De-excitation module ignores cuts
1503 <<fCParameters->DeexcitationIgnoreCut()
1504 os << "Type of PIXE cross section for hadro
1505 <<fCParameters->PIXECrossSectionModel()
1506 os << "Type of PIXE cross section for e+-
1507 <<fCParameters->PIXEElectronCrossSection
1508 os << "====================================
1509 }
1510 if(fDNA) {
1511 os << "====== DNA Physics P
1512 os << "====================================
1513 os << "Use fast sampling in DNA models
1514 << fCParameters->DNAFast() << "\n";
1515 os << "Use Stationary option in DNA models
1516 << fCParameters->DNAStationary() << "\n"
1517 os << "Use DNA with multiple scattering of
1518 << fCParameters->DNAElectronMsc() << "\n
1519 os << "Use DNA e- solvation model type
1520 << fCParameters->DNAeSolvationSubType()
1521 auto chemModel = fCParameters->GetChemTimeS
1522 if(fCParameters->GetChemTimeStepModel() !=
1523 {
1524 std::vector<G4String> ChemModel{"Unknown"
1525 os << "Use DNA Chemistry model
1526 << ChemModel.at((std::size_t)chemModel
1527 }
1528 os << "====================================
1529 }
1530 os.precision(prec);
1531 }
1532
1533 void G4EmParameters::Dump()
1534 {
1535 if(fIsPrinted) return;
1536
1537 #ifdef G4MULTITHREADED
1538 G4MUTEXLOCK(&emParametersMutex);
1539 #endif
1540 StreamInfo(G4cout);
1541 #ifdef G4MULTITHREADED
1542 G4MUTEXUNLOCK(&emParametersMutex);
1543 #endif
1544 }
1545
1546 std::ostream& operator<< (std::ostream& os, c
1547 {
1548 par.StreamInfo(os);
1549 return os;
1550 }
1551
1552 G4bool G4EmParameters::IsLocked() const
1553 {
1554 return (!G4Threading::IsMasterThread() ||
1555 (fStateManager->GetCurrentState() != G4St
1556 fStateManager->GetCurrentState() !
1557 fStateManager->GetCurrentState() != G4St
1558 }
1559
1560
1561 void G4EmParameters::SetTimeStepModel(const G
1562 {
1563 fCParameters-> SetChemTimeStepModel(model);
1564 }
1565
1566 G4ChemTimeStepModel G4EmParameters::GetTimeSt
1567 {
1568 return fCParameters->GetChemTimeStepModel()
1569 }
1570 //....oooOO0OOooo........oooOO0OOooo........o
1571