ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4EmParameters.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4EmParameters.cc
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
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........oooOO0OOooo........oooOO0OOooo....
41 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
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"
53 #include "G4NistManager.hh"
54 #include "G4RegionStore.hh"
55 #include "G4Region.hh"
56 #include "G4ApplicationState.hh"
57 #include "G4StateManager.hh"
58 
60 
61 #ifdef G4MULTITHREADED
62  G4Mutex G4EmParameters::emParametersMutex = G4MUTEX_INITIALIZER;
63 #endif
64 
65 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
66 
68 {
69  if(nullptr == theInstance) {
70 #ifdef G4MULTITHREADED
71  G4MUTEXLOCK(&emParametersMutex);
72  if(nullptr == theInstance) {
73 #endif
74  static G4EmParameters manager;
75  theInstance = &manager;
76 #ifdef G4MULTITHREADED
77  }
78  G4MUTEXUNLOCK(&emParametersMutex);
79 #endif
80  }
81  return theInstance;
82 }
83 
84 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
85 
87 {
88  delete theMessenger;
89  delete fBParameters;
90  delete fCParameters;
91  delete emSaturation;
92 }
93 
94 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
95 
97 {
100  Initialise();
101 
104 
106  emSaturation = nullptr;
107 }
108 
110 {
111  if(!IsLocked()) {
112  Initialise();
115  }
116 }
117 
119 {
120  lossFluctuation = true;
121  buildCSDARange = false;
122  flagLPM = true;
123  spline = true;
124  cutAsFinalRange = false;
125  applyCuts = false;
126  lateralDisplacement = true;
128  muhadLateralDisplacement = false;
131  useMottCorrection = false;
132  integral = true;
133  birks = false;
134  fICRU90 = false;
135  gener = false;
136  onIsolated = false;
137  fSamplingTable = false;
138  fPolarisation = false;
139  fMuDataFromFile = false;
140  fDNA = false;
141 
142  minSubRange = 1.0;
143  minKinEnergy = 0.1*CLHEP::keV;
144  maxKinEnergy = 100.0*CLHEP::TeV;
146  max5DEnergyForMuPair = 0.0;
150  maxNIELEnergy = 0.0;
151  linLossLimit = 0.01;
153  lambdaFactor = 0.8;
154  factorForAngleLimit = 1.0;
156  energyLimit = 100.0*CLHEP::MeV;
157  rangeFactor = 0.04;
158  rangeFactorMuHad = 0.2;
159  geomFactor = 2.5;
160  skin = 1.0;
161  safetyFactor = 0.6;
162  lambdaLimit = 1.0*CLHEP::mm;
163  factorScreen = 1.0;
164 
165  nbins = 84;
166  nbinsPerDecade = 7;
167  verbose = 1;
168  workerVerbose = 0;
169  tripletConv = 0;
170 
174 }
175 
177 {
178  if(IsLocked()) { return; }
179  lossFluctuation = val;
180 }
181 
183 {
184  return lossFluctuation;
185 }
186 
188 {
189  if(IsLocked()) { return; }
190  buildCSDARange = val;
191 }
192 
194 {
195  return buildCSDARange;
196 }
197 
199 {
200  if(IsLocked()) { return; }
201  flagLPM = val;
202 }
203 
205 {
206  return flagLPM;
207 }
208 
210 {
211  if(IsLocked()) { return; }
212  spline = val;
213 }
214 
216 {
217  return spline;
218 }
219 
221 {
222  if(IsLocked()) { return; }
223  cutAsFinalRange = val;
224 }
225 
227 {
228  return cutAsFinalRange;
229 }
230 
232 {
233  if(IsLocked()) { return; }
234  applyCuts = val;
235 }
236 
238 {
239  return applyCuts;
240 }
241 
243 {
244  if(IsLocked()) { return; }
245  fCParameters->SetFluo(val);
246 }
247 
249 {
250  return fCParameters->Fluo();
251 }
252 
254 {
255  if(IsLocked()) { return; }
257 }
258 
260 {
261  return fCParameters->BeardenFluoDir();
262 }
263 
265 {
266  if(IsLocked()) { return; }
267  fCParameters->SetAuger(val);
268 }
269 
271 {
272  return fCParameters->Auger();
273 }
274 
276 {
277  if(IsLocked()) { return; }
278  fCParameters->SetAuger(val);
279 }
280 
282 {
283  return fCParameters->Auger();
284 }
285 
287 {
288  if(IsLocked()) { return; }
289  fCParameters->SetPixe(val);
290 }
291 
293 {
294  return fCParameters->Pixe();
295 }
296 
298 {
299  if(IsLocked()) { return; }
301 }
302 
304 {
306 }
307 
309 {
310  if(IsLocked()) { return; }
311  lateralDisplacement = val;
312 }
313 
315 {
316  return lateralDisplacement;
317 }
318 
320 {
321  if(IsLocked()) { return; }
323 }
324 
326 {
328 }
329 
331 {
332  if(IsLocked()) { return; }
334 }
335 
337 {
339 }
340 
342 {
343  if(IsLocked()) { return; }
345 }
346 
348 {
350 }
351 
353 {
354  if(IsLocked()) { return; }
356 }
357 
359 {
361 }
362 
364 {
365  if(IsLocked()) { return; }
366  useMottCorrection = val;
367 }
368 
370 {
371  return useMottCorrection;
372 }
373 
375 {
376  if(IsLocked()) { return; }
377  integral = val;
378 }
379 
381 {
382  return integral;
383 }
384 
386 {
387  if(IsLocked()) { return; }
388  fPolarisation = val;
389 }
390 
392 {
393  return fPolarisation;
394 }
395 
397 {
398  birks = val;
399 #ifdef G4MULTITHREADED
400  G4MUTEXLOCK(&G4EmParameters::emParametersMutex);
401 #endif
402  if(birks) {
403  if(!emSaturation) { emSaturation = new G4EmSaturation(1); }
405  }
406 #ifdef G4MULTITHREADED
407  G4MUTEXUNLOCK(&G4EmParameters::emParametersMutex);
408 #endif
409 }
410 
412 {
413  return birks;
414 }
415 
417 {
418  if(IsLocked()) { return; }
419  fICRU90 = val;
420 }
421 
423 {
424  return fICRU90;
425 }
426 
428 {
429  if(IsLocked()) { return; }
430  fCParameters->SetDNAFast(val);
431  if(val) { ActivateDNA(); }
432 }
433 
435 {
436  return fCParameters->DNAFast();
437 }
438 
440 {
441  if(IsLocked()) { return; }
443  if(val) { ActivateDNA(); }
444 }
445 
447 {
448  return fCParameters->DNAStationary();
449 }
450 
452 {
453  if(IsLocked()) { return; }
455  if(val) { ActivateDNA(); }
456 }
457 
459 {
460  return fCParameters->DNAElectronMsc();
461 }
462 
464 {
465  if(IsLocked()) { return; }
466  gener = val;
467  // if general interaction is enabled then sub-cutoff and
468  // force interaction options should be disabled
469  if(gener) { fBParameters->Initialise(); }
470 }
471 
473 {
474  return gener;
475 }
476 
478 {
479  if(emSaturation != ptr) {
480  delete emSaturation;
481  emSaturation = ptr;
482  SetBirksActive(true);
483  }
484 }
485 
487 {
488  return fMuDataFromFile;
489 }
490 
492 {
493  fMuDataFromFile = v;
494 }
495 
497 {
498  if(IsLocked()) { return; }
499  onIsolated = val;
500 }
501 
503 {
504  return onIsolated;
505 }
506 
508 {
509  if(IsLocked()) { return; }
510  fSamplingTable = val;
511 }
512 
514 {
515  return fSamplingTable;
516 }
517 
519 {
520  if(IsLocked()) { return; }
521  fDNA = true;
522 }
523 
525 {
526  if(!emSaturation) { SetBirksActive(true); }
527  return emSaturation;
528 }
529 
531 {
532  if(IsLocked()) { return; }
533  if(val > 0.0 && val < 1.0) {
534  minSubRange = val;
535  } else {
537  ed << "Value of MinSubRange is out of range (0 - 1): " << val
538  << " is ignored";
539  PrintWarning(ed);
540  }
541 }
542 
544 {
545  return minSubRange;
546 }
547 
549 {
550  if(IsLocked()) { return; }
551  if(val > 1.e-3*eV && val < maxKinEnergy) {
552  minKinEnergy = val;
554  } else {
556  ed << "Value of MinKinEnergy - is out of range: " << val/MeV
557  << " MeV is ignored";
558  PrintWarning(ed);
559  }
560 }
561 
563 {
564  return minKinEnergy;
565 }
566 
568 {
569  if(IsLocked()) { return; }
570  if(val > std::max(minKinEnergy,9.99*MeV) && val < 1.e+7*TeV) {
571  maxKinEnergy = val;
573  } else {
575  ed << "Value of MaxKinEnergy is out of range: "
576  << val/GeV << " GeV is ignored; allowed range 10 MeV - 1.e+7 TeV";
577  PrintWarning(ed);
578  }
579 }
580 
582 {
583  return maxKinEnergy;
584 }
585 
587 {
588  if(IsLocked()) { return; }
589  if(val > minKinEnergy && val <= 100*TeV) {
590  maxKinEnergyCSDA = val;
591  } else {
593  ed << "Value of MaxKinEnergyCSDA is out of range: "
594  << val/GeV << " GeV is ignored; allowed range "
595  << minKinEnergy << " MeV - 100 TeV";
596  PrintWarning(ed);
597  }
598 }
599 
601 {
602  return maxKinEnergyCSDA;
603 }
604 
606 {
607  if(IsLocked()) { return; }
608  if(val >= 0.0) { lowestElectronEnergy = val; }
609 }
610 
612 {
613  return lowestElectronEnergy;
614 }
615 
617 {
618  if(IsLocked()) { return; }
619  if(val >= 0.0) { lowestMuHadEnergy = val; }
620 }
621 
623 {
624  return lowestMuHadEnergy;
625 }
626 
628 {
629  if(IsLocked()) { return; }
630  if(val > 0.0) { lowestTripletEnergy = val; }
631 }
632 
634 {
635  return lowestTripletEnergy;
636 }
637 
639 {
640  if(IsLocked()) { return; }
641  if(val >= 0.0) { maxNIELEnergy = val; }
642 }
643 
645 {
646  return maxNIELEnergy;
647 }
648 
650 {
651  if(IsLocked()) { return; }
652  if(val > 0.0) { max5DEnergyForMuPair = val; }
653 }
654 
656 {
657  return max5DEnergyForMuPair;
658 }
659 
661 {
662  if(IsLocked()) { return; }
663  if(val > 0.0 && val < 0.5) {
664  linLossLimit = val;
665  } else {
667  ed << "Value of linLossLimit is out of range: " << val
668  << " is ignored";
669  PrintWarning(ed);
670  }
671 }
672 
674 {
675  return linLossLimit;
676 }
677 
679 {
680  if(IsLocked()) { return; }
681  if(val > 0.0) {
682  bremsTh = val;
683  } else {
685  ed << "Value of bremsstrahlung threshold is out of range: "
686  << val/GeV << " GeV is ignored";
687  PrintWarning(ed);
688  }
689 }
690 
692 {
693  return bremsTh;
694 }
695 
697 {
698  if(IsLocked()) { return; }
699  if(val > 0.0 && val < 1.0) {
700  lambdaFactor = val;
701  } else {
703  ed << "Value of lambda factor is out of range: " << val
704  << " is ignored";
705  PrintWarning(ed);
706  }
707 }
708 
710 {
711  return lambdaFactor;
712 }
713 
715 {
716  if(IsLocked()) { return; }
717  if(val > 0.0) {
718  factorForAngleLimit = val;
719  } else {
721  ed << "Value of factor for enegry limit is out of range: "
722  << val << " is ignored";
723  PrintWarning(ed);
724  }
725 }
726 
728 {
729  return factorForAngleLimit;
730 }
731 
733 {
734  if(IsLocked()) { return; }
735  if(val >= 0.0 && val <= pi) {
736  thetaLimit = val;
737  } else {
739  ed << "Value of polar angle limit is out of range: "
740  << val << " is ignored";
741  PrintWarning(ed);
742  }
743 }
744 
746 {
747  return thetaLimit;
748 }
749 
751 {
752  if(IsLocked()) { return; }
753  if(val >= 0.0) {
754  energyLimit = val;
755  } else {
757  ed << "Value of msc energy limit is out of range: "
758  << val << " is ignored";
759  PrintWarning(ed);
760  }
761 }
762 
764 {
765  return energyLimit;
766 }
767 
769 {
770  if(IsLocked()) { return; }
771  if(val > 0.0 && val < 1.0) {
772  rangeFactor = val;
773  } else {
775  ed << "Value of rangeFactor is out of range: "
776  << val << " is ignored";
777  PrintWarning(ed);
778  }
779 }
780 
782 {
783  return rangeFactor;
784 }
785 
787 {
788  if(IsLocked()) { return; }
789  if(val > 0.0 && val < 1.0) {
790  rangeFactorMuHad = val;
791  } else {
793  ed << "Value of rangeFactorMuHad is out of range: "
794  << val << " is ignored";
795  PrintWarning(ed);
796  }
797 }
798 
800 {
801  return rangeFactorMuHad;
802 }
803 
805 {
806  if(IsLocked()) { return; }
807  if(val >= 1.0) {
808  geomFactor = val;
809  } else {
811  ed << "Value of geomFactor is out of range: "
812  << val << " is ignored";
813  PrintWarning(ed);
814  }
815 }
816 
818 {
819  return geomFactor;
820 }
821 
823 {
824  if(IsLocked()) { return; }
825  if(val >= 0.1) {
826  safetyFactor = val;
827  } else {
829  ed << "Value of safetyFactor is out of range: "
830  << val << " is ignored";
831  PrintWarning(ed);
832  }
833 }
834 
836 {
837  return safetyFactor;
838 }
839 
841 {
842  if(IsLocked()) { return; }
843  if(val >= 0.0) {
844  lambdaLimit = val;
845  } else {
847  ed << "Value of lambdaLimit is out of range: "
848  << val << " is ignored";
849  PrintWarning(ed);
850  }
851 }
852 
854 {
855  return lambdaLimit;
856 }
857 
859 {
860  if(IsLocked()) { return; }
861  if(val >= 1.0) {
862  skin = val;
863  } else {
865  ed << "Value of skin is out of range: "
866  << val << " is ignored";
867  PrintWarning(ed);
868  }
869 }
870 
872 {
873  return skin;
874 }
875 
877 {
878  if(IsLocked()) { return; }
879  if(val > 0.0) {
880  factorScreen = val;
881  } else {
883  ed << "Value of factorScreen is out of range: "
884  << val << " is ignored";
885  PrintWarning(ed);
886  }
887 }
888 
890 {
891  return factorScreen;
892 }
893 
895 {
896  if(IsLocked()) { return; }
897  fBParameters->SetStepFunction(v1, v2);
898 }
899 
901 {
902  if(IsLocked()) { return; }
904 }
905 
907 {
908  if(IsLocked()) { return; }
909  if(val >= 5 && val < 10000000) {
910  nbins = val;
912  } else {
914  ed << "Value of number of bins is out of range: "
915  << val << " is ignored";
916  PrintWarning(ed);
917  }
918 }
919 
921 {
922  return nbins;
923 }
924 
926 {
927  if(IsLocked()) { return; }
928  if(val >= 5 && val < 1000000) {
929  nbinsPerDecade = val;
931  } else {
933  ed << "Value of number of bins per decade is out of range: "
934  << val << " is ignored";
935  PrintWarning(ed);
936  }
937 }
938 
940 {
941  return nbinsPerDecade;
942 }
943 
945 {
946  if(IsLocked()) { return; }
947  verbose = val;
949 }
950 
952 {
953  return verbose;
954 }
955 
957 {
958  if(IsLocked()) { return; }
959  workerVerbose = val;
960 }
961 
963 {
964  return workerVerbose;
965 }
966 
968 {
969  if(IsLocked()) { return; }
970  mscStepLimit = val;
971 }
972 
974 {
975  return mscStepLimit;
976 }
977 
979 {
980  if(IsLocked()) { return; }
981  mscStepLimitMuHad = val;
982 }
983 
985 {
986  return mscStepLimitMuHad;
987 }
988 
989 void
991 {
992  if(IsLocked()) { return; }
993  nucFormfactor = val;
994 }
995 
997 {
998  return nucFormfactor;
999 }
1000 
1002 {
1003  if(IsLocked()) { return; }
1005  ActivateDNA();
1006 }
1007 
1009 {
1011 }
1012 
1014 {
1015  if(IsLocked()) { return; }
1016  tripletConv = val;
1017 }
1018 
1020 {
1021  return tripletConv;
1022 }
1023 
1025 {
1026  if(IsLocked()) { return; }
1028 }
1029 
1031 {
1033 }
1034 
1036 {
1037  if(IsLocked()) { return; }
1039 }
1040 
1042 {
1044 }
1045 
1047 {
1048  G4Exception("G4EmParameters", "em0044", JustWarning, ed);
1049 }
1050 
1052  const G4String& region,
1053  const G4String& type)
1054 {
1055  if(IsLocked()) { return; }
1056  fBParameters->AddPAIModel(particle, region, type);
1057 }
1058 
1059 const std::vector<G4String>& G4EmParameters::ParticlesPAI() const
1060 {
1061  return fBParameters->ParticlesPAI();
1062 }
1063 
1064 const std::vector<G4String>& G4EmParameters::RegionsPAI() const
1065 {
1066  return fBParameters->RegionsPAI();
1067 }
1068 
1069 const std::vector<G4String>& G4EmParameters::TypesPAI() const
1070 {
1071  return fBParameters->TypesPAI();
1072 }
1073 
1075 {
1076  if(IsLocked()) { return; }
1077  fCParameters->AddMicroElec(region);
1078 }
1079 
1080 const std::vector<G4String>& G4EmParameters::RegionsMicroElec() const
1081 {
1082  return fCParameters->RegionsMicroElec();
1083 }
1084 
1085 void G4EmParameters::AddDNA(const G4String& region, const G4String& type)
1086 {
1087  if(IsLocked()) { return; }
1088  fCParameters->AddDNA(region, type);
1089  ActivateDNA();
1090 }
1091 
1092 const std::vector<G4String>& G4EmParameters::RegionsDNA() const
1093 {
1094  return fCParameters->RegionsDNA();
1095 }
1096 
1097 const std::vector<G4String>& G4EmParameters::TypesDNA() const
1098 {
1099  return fCParameters->TypesDNA();
1100 }
1101 
1102 void G4EmParameters::AddPhysics(const G4String& region, const G4String& type)
1103 {
1104  if(IsLocked()) { return; }
1105  fBParameters->AddPhysics(region, type);
1106 }
1107 
1108 const std::vector<G4String>& G4EmParameters::RegionsPhysics() const
1109 {
1110  return fBParameters->RegionsPhysics();
1111 }
1112 
1113 const std::vector<G4String>& G4EmParameters::TypesPhysics() const
1114 {
1115  return fBParameters->TypesPhysics();
1116 }
1117 
1119 {
1120  if(IsLocked() && !gener) { return; }
1121  fBParameters->SetSubCutoff(val, region);
1122 }
1123 
1124 void
1126  G4bool aauger, G4bool apixe)
1127 {
1128  if(IsLocked()) { return; }
1129  fCParameters->SetDeexActiveRegion(region, adeex, aauger, apixe);
1130 }
1131 
1132 void
1134  G4double val, G4bool wflag)
1135 {
1136  if(IsLocked()) { return; }
1137  fBParameters->SetProcessBiasingFactor(procname, val, wflag);
1138 }
1139 
1140 void
1142  const G4String& region,
1143  G4double length,
1144  G4bool wflag)
1145 {
1146  if(IsLocked() && !gener) { return; }
1147  fBParameters->ActivateForcedInteraction(procname, region, length, wflag);
1148 }
1149 
1150 void
1152  const G4String& region,
1153  G4double factor,
1154  G4double energyLim)
1155 {
1156  if(IsLocked()) { return; }
1157  fBParameters->ActivateSecondaryBiasing(procname, region, factor, energyLim);
1158 }
1159 
1161  G4bool isElectron) const
1162 {
1163  fBParameters->DefineRegParamForLoss(ptr, isElectron);
1164 }
1165 
1167 {
1169 }
1170 
1172 {
1173  return fBParameters->QuantumEntanglement();
1174 }
1175 
1177 {
1178  if(IsLocked()) { return; }
1180 }
1181 
1184 }
1185 
1187 {
1188  if(IsLocked()) { return; }
1190 }
1191 
1193 {
1194  if(IsLocked()) { return; }
1196 }
1197 
1199 {
1201 }
1202 
1204 {
1205  if(IsLocked()) { return; }
1207 }
1208 
1210 {
1212 }
1213 
1215 {
1217 }
1218 
1219 void G4EmParameters::StreamInfo(std::ostream& os) const
1220 {
1221  G4int prec = os.precision(5);
1222  os << "=======================================================================" << "\n";
1223  os << "====== Electromagnetic Physics Parameters ========" << "\n";
1224  os << "=======================================================================" << "\n";
1225  os << "LPM effect enabled " <<flagLPM << "\n";
1226  os << "Spline of EM tables enabled " <<spline << "\n";
1227  os << "Enable creation and use of sampling tables " <<fSamplingTable << "\n";
1228  os << "Apply cuts on all EM processes " <<applyCuts << "\n";
1229  os << "Use integral approach for tracking " <<integral << "\n";
1230  os << "Use general process " <<gener << "\n";
1231  os << "Enable linear polarisation for gamma " <<fPolarisation << "\n";
1232  os << "Enable sampling of quantum entanglement "
1233  <<fBParameters->QuantumEntanglement() << "\n";
1234  os << "X-section factor for integral approach " <<lambdaFactor << "\n";
1235  os << "Min kinetic energy for tables "
1236  <<G4BestUnit(minKinEnergy,"Energy") << "\n";
1237  os << "Max kinetic energy for tables "
1238  <<G4BestUnit(maxKinEnergy,"Energy") << "\n";
1239  os << "Number of bins in tables " <<nbins << "\n";
1240  os << "Number of bins per decade of a table " <<nbinsPerDecade << "\n";
1241  os << "Verbose level " <<verbose << "\n";
1242  os << "Verbose level for worker thread " <<workerVerbose << "\n";
1243  os << "Bremsstrahlung energy threshold above which \n"
1244  << " primary is added to the list of secondary "
1245  <<G4BestUnit(bremsTh,"Energy") << "\n";
1246  os << "Lowest triplet kinetic energy "
1247  <<G4BestUnit(lowestTripletEnergy,"Energy") << "\n";
1248  os << "Enable sampling of gamma linear polarisation " <<fPolarisation << "\n";
1249  os << "5D gamma conversion model type " <<tripletConv << "\n";
1250  os << "5D gamma conversion model on isolated ion " <<onIsolated << "\n";
1251  if(max5DEnergyForMuPair>0.0) {
1252  os << "5D gamma conversion limit for muon pair "
1253  << max5DEnergyForMuPair/CLHEP::GeV << " GeV\n";
1254  }
1255 
1256  os << "=======================================================================" << "\n";
1257  os << "====== Ionisation Parameters ========" << "\n";
1258  os << "=======================================================================" << "\n";
1259  os << "Step function for e+- "
1260  <<"("<<fBParameters->GetStepFunctionP1() << ", "
1261  << fBParameters->GetStepFunctionP2()/CLHEP::mm << " mm)\n";
1262  os << "Step function for muons/hadrons "
1263  <<"("<<fBParameters->GetStepFunctionMuHadP1() << ", "
1264  << fBParameters->GetStepFunctionMuHadP2()/CLHEP::mm << " mm)\n";
1265  os << "Lowest e+e- kinetic energy "
1266  <<G4BestUnit(lowestElectronEnergy,"Energy") << "\n";
1267  os << "Lowest muon/hadron kinetic energy "
1268  <<G4BestUnit(lowestMuHadEnergy,"Energy") << "\n";
1269  os << "Fluctuations of dE/dx are enabled " <<lossFluctuation << "\n";
1270  os << "Use ICRU90 data " << fICRU90 << "\n";
1271  os << "Use built-in Birks satuaration " << birks << "\n";
1272  os << "Build CSDA range enabled " <<buildCSDARange << "\n";
1273  os << "Use cut as a final range enabled " <<cutAsFinalRange << "\n";
1274  os << "Enable angular generator interface "
1275  <<useAngGeneratorForIonisation << "\n";
1276  os << "Factor of cut reduction for sub-cutoff method " << minSubRange << "\n";
1277  os << "Max kinetic energy for CSDA tables "
1278  <<G4BestUnit(maxKinEnergyCSDA,"Energy") << "\n";
1279  os << "Max kinetic energy for NIEL computation "
1280  <<G4BestUnit(maxNIELEnergy,"Energy") << "\n";
1281  os << "Linear loss limit " <<linLossLimit << "\n";
1282  os << "Read data from file for e+e- pair production by mu " <<fMuDataFromFile << "\n";
1283 
1284  os << "=======================================================================" << "\n";
1285  os << "====== Multiple Scattering Parameters ========" << "\n";
1286  os << "=======================================================================" << "\n";
1287  os << "Type of msc step limit algorithm for e+- " <<mscStepLimit << "\n";
1288  os << "Type of msc step limit algorithm for muons/hadrons " <<mscStepLimitMuHad << "\n";
1289  os << "Msc lateral displacement for e+- enabled " <<lateralDisplacement << "\n";
1290  os << "Msc lateral displacement for muons and hadrons " <<muhadLateralDisplacement << "\n";
1291  os << "Urban msc model lateral displacement alg96 " <<lateralDisplacementAlg96 << "\n";
1292  os << "Msc lateral displacement beyond geometry safety " <<latDisplacementBeyondSafety << "\n";
1293  os << "Range factor for msc step limit for e+- " <<rangeFactor << "\n";
1294  os << "Range factor for msc step limit for muons/hadrons " <<rangeFactorMuHad << "\n";
1295  os << "Geometry factor for msc step limitation of e+- " <<geomFactor << "\n";
1296  os << "Safety factor for msc step limit for e+- " <<safetyFactor << "\n";
1297  os << "Skin parameter for msc step limitation of e+- " <<skin << "\n";
1298  os << "Lambda limit for msc step limit for e+- " <<lambdaLimit/CLHEP::mm << " mm\n";
1299  os << "Use Mott correction for e- scattering " << useMottCorrection << "\n";
1300  os << "Factor used for dynamic computation of angular \n"
1301  << " limit between single and multiple scattering " << factorForAngleLimit << "\n";
1302  os << "Fixed angular limit between single \n"
1303  << " and multiple scattering "
1304  << thetaLimit/CLHEP::rad << " rad\n";
1305  os << "Upper energy limit for e+- multiple scattering "
1306  << energyLimit/CLHEP::MeV << " MeV\n";
1307  os << "Type of nuclear form-factor " <<nucFormfactor << "\n";
1308  os << "Screening factor " <<factorScreen << "\n";
1309  os << "=======================================================================" << "\n";
1310 
1311  if(fCParameters->Fluo()) {
1312  os << "====== Atomic Deexcitation Parameters ========" << "\n";
1313  os << "=======================================================================" << "\n";
1314  os << "Fluorescence enabled " <<fCParameters->Fluo() << "\n";
1315  os << "Fluorescence Bearden data files enabled "
1316  <<fCParameters->BeardenFluoDir() << "\n";
1317  os << "Auger electron cascade enabled "
1318  <<fCParameters->Auger() << "\n";
1319  os << "PIXE atomic de-excitation enabled " <<fCParameters->Pixe() << "\n";
1320  os << "De-excitation module ignores cuts "
1321  <<fCParameters->DeexcitationIgnoreCut() << "\n";
1322  os << "Type of PIXE cross section for hadrons "
1323  <<fCParameters->PIXECrossSectionModel() << "\n";
1324  os << "Type of PIXE cross section for e+- "
1326  os << "=======================================================================" << "\n";
1327  }
1328  if(fDNA) {
1329  os << "====== DNA Physics Parameters ========" << "\n";
1330  os << "=======================================================================" << "\n";
1331  os << "Use fast sampling in DNA models "
1332  << fCParameters->DNAFast() << "\n";
1333  os << "Use Stationary option in DNA models "
1334  << fCParameters->DNAStationary() << "\n";
1335  os << "Use DNA with multiple scattering of e- "
1336  << fCParameters->DNAElectronMsc() << "\n";
1337  os << "Use DNA e- solvation model type "
1338  << fCParameters->DNAeSolvationSubType() << "\n";
1339  os << "=======================================================================" << "\n";
1340  }
1341  os.precision(prec);
1342 }
1343 
1345 {
1346 #ifdef G4MULTITHREADED
1347  G4MUTEXLOCK(&emParametersMutex);
1348 #endif
1349  StreamInfo(G4cout);
1350 #ifdef G4MULTITHREADED
1351  G4MUTEXUNLOCK(&emParametersMutex);
1352 #endif
1353 }
1354 
1355 std::ostream& operator<< (std::ostream& os, const G4EmParameters& par)
1356 {
1357  par.StreamInfo(os);
1358  return os;
1359 }
1360 
1362 {
1363  return (!G4Threading::IsMasterThread() ||
1367 }
1368 
1369 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....