| 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 // Authors: Francesco Longo, franzlongo1969@gm << 26 // Authors: Susanna Guatelli, susanna@uow.edu.au,
>> 27 // Authors: Jeremy Davis, jad028@uowmail.edu.au
27 // 28 //
28 // Code based on the hadrontherapy && radiopro 29 // Code based on the hadrontherapy && radioprotection advanced example
29 30
30 #include "GammaRayTelPhysicsList.hh" 31 #include "GammaRayTelPhysicsList.hh"
31 #include "GammaRayTelPhysicsListMessenger.hh" 32 #include "GammaRayTelPhysicsListMessenger.hh"
32 #include "G4PhysListFactory.hh" 33 #include "G4PhysListFactory.hh"
33 #include "G4VPhysicsConstructor.hh" 34 #include "G4VPhysicsConstructor.hh"
34 35
35 // Physics lists (contained inside the Geant4 << 36 // Physic lists (contained inside the Geant4 distribution)
>> 37 #include "G4EmStandardPhysics_option3.hh"
36 #include "G4EmLivermorePhysics.hh" 38 #include "G4EmLivermorePhysics.hh"
37 #include "G4EmLivermorePolarizedPhysics.hh" <<
38 #include "G4EmPenelopePhysics.hh" 39 #include "G4EmPenelopePhysics.hh"
39 #include "G4EmStandardPhysics_option3.hh" << 40 #include "G4EmLivermorePolarizedPhysics.hh" // TBC
40 #include "G4EmStandardPhysics_option4.hh" // t <<
41 41
42 #include "G4Decay.hh" <<
43 #include "G4DecayPhysics.hh" 42 #include "G4DecayPhysics.hh"
44 #include "G4HadronDElasticPhysics.hh" <<
45 #include "G4HadronElasticPhysics.hh" 43 #include "G4HadronElasticPhysics.hh"
>> 44 #include "G4HadronDElasticPhysics.hh"
46 #include "G4HadronElasticPhysicsHP.hh" 45 #include "G4HadronElasticPhysicsHP.hh"
47 #include "G4HadronPhysicsQGSP_BIC_HP.hh" <<
48 #include "G4IonBinaryCascadePhysics.hh" 46 #include "G4IonBinaryCascadePhysics.hh"
49 #include "G4IonFluctuations.hh" << 47 #include "G4Decay.hh"
50 #include "G4IonParametrisedLossModel.hh" <<
51 #include "G4LossTableManager.hh" <<
52 #include "G4ProcessManager.hh" <<
53 #include "G4RadioactiveDecayPhysics.hh" <<
54 #include "G4StepLimiter.hh" 48 #include "G4StepLimiter.hh"
55 #include "G4SystemOfUnits.hh" << 49 #include "G4LossTableManager.hh"
56 #include "G4UnitsTable.hh" 50 #include "G4UnitsTable.hh"
>> 51 #include "G4SystemOfUnits.hh"
>> 52 #include "G4ProcessManager.hh"
57 53
58 //....oooOO0OOooo........oooOO0OOooo........oo << 54 #include "G4IonFluctuations.hh"
59 << 55 #include "G4IonParametrisedLossModel.hh"
60 GammaRayTelPhysicsList::GammaRayTelPhysicsList << 56 #include "G4EmProcessOptions.hh"
61 G4LossTableManager::Instance(); << 57 #include "G4HadronPhysicsQGSP_BIC_HP.hh"
62 << 58 #include "G4RadioactiveDecayPhysics.hh"
63 constexpr auto DEFAULT_CUT_VALUE{100 * mic <<
64 defaultCutValue = DEFAULT_CUT_VALUE; <<
65 <<
66 SetVerboseLevel(1); <<
67 <<
68 constexpr auto ENERGY_LOWER_BOUND{250 * eV <<
69 constexpr auto ENERGY_UPPER_BOUND{1 * GeV} <<
70 <<
71 G4ProductionCutsTable::GetProductionCutsTa <<
72 SetDefaultCutValue (defaultCutValue); <<
73 DumpCutValuesTable(); <<
74 <<
75 helIsRegisted = false; <<
76 bicIsRegisted = false; <<
77 biciIsRegisted = false; <<
78 locIonIonInelasticIsRegistered = false; <<
79 radioactiveDecayIsRegisted = false; <<
80 <<
81 pMessenger = new GammaRayTelPhysicsListMes <<
82 <<
83 SetVerboseLevel(1); <<
84 <<
85 // EM physics <<
86 emPhysicsList = new G4EmStandardPhysics_op <<
87 emName = G4String("emstandard_opt3"); <<
88 <<
89 // Decay physics and all particles <<
90 decPhysicsList = new G4DecayPhysics(); <<
91 } <<
92 59
93 //....oooOO0OOooo........oooOO0OOooo........oo << 60 /////////////////////////////////////////////////////////////////////////////
>> 61 GammaRayTelPhysicsList::GammaRayTelPhysicsList() : G4VModularPhysicsList()
>> 62 {
>> 63 G4LossTableManager::Instance();
>> 64 defaultCutValue = 100*micrometer;
>> 65 cutForGamma = defaultCutValue;
>> 66 cutForElectron = defaultCutValue;
>> 67 cutForPositron = defaultCutValue;
>> 68
>> 69 helIsRegisted = false;
>> 70 bicIsRegisted = false;
>> 71 biciIsRegisted = false;
>> 72 locIonIonInelasticIsRegistered = false;
>> 73 radioactiveDecayIsRegisted = false;
>> 74
>> 75 pMessenger = new GammaRayTelPhysicsListMessenger(this);
>> 76
>> 77 SetVerboseLevel(1);
>> 78
>> 79 // EM physics
>> 80 emPhysicsList = new G4EmStandardPhysics_option3(1);
>> 81 emName = G4String("emstandard_opt3");
>> 82
>> 83 // Decay physics and all particles
>> 84 decPhysicsList = new G4DecayPhysics();
>> 85 }
>> 86
>> 87 /////////////////////////////////////////////////////////////////////////////
>> 88 GammaRayTelPhysicsList::~GammaRayTelPhysicsList()
>> 89 {
>> 90 delete pMessenger;
>> 91 delete emPhysicsList;
>> 92 delete decPhysicsList;
>> 93 for(size_t i=0; i<hadronPhys.size(); i++) {delete hadronPhys[i];}
>> 94 }
>> 95
>> 96 /////////////////////////////////////////////////////////////////////////////
>> 97 void GammaRayTelPhysicsList::AddPackage(const G4String& name)
>> 98 {
>> 99 G4PhysListFactory factory;
>> 100 G4VModularPhysicsList* phys =factory.GetReferencePhysList(name);
>> 101 G4int i=0;
>> 102 const G4VPhysicsConstructor* elem= phys->GetPhysics(i);
>> 103 G4VPhysicsConstructor* tmp = const_cast<G4VPhysicsConstructor*> (elem);
>> 104 while (elem !=0)
>> 105 {
>> 106 RegisterPhysics(tmp);
>> 107 elem= phys->GetPhysics(++i) ;
>> 108 tmp = const_cast<G4VPhysicsConstructor*> (elem);
>> 109 }
>> 110 }
>> 111
>> 112 /////////////////////////////////////////////////////////////////////////////
>> 113 void GammaRayTelPhysicsList::ConstructParticle()
>> 114 {
>> 115 decPhysicsList->ConstructParticle();
>> 116 }
>> 117
>> 118 /////////////////////////////////////////////////////////////////////////////
>> 119 void GammaRayTelPhysicsList::ConstructProcess()
>> 120 {
>> 121 // transportation
>> 122 //
>> 123 AddTransportation();
>> 124
>> 125 // electromagnetic physics list
>> 126 //
>> 127 emPhysicsList->ConstructProcess();
>> 128 em_config.AddModels();
>> 129
>> 130 // decay physics list
>> 131 //
>> 132 decPhysicsList->ConstructProcess();
>> 133
>> 134 // hadronic physics lists
>> 135 for(size_t i=0; i<hadronPhys.size(); i++) {
>> 136 hadronPhys[i]->ConstructProcess();
>> 137 }
>> 138
>> 139 // step limitation (as a full process)
>> 140 //
>> 141 // AddStepMax();
>> 142 }
>> 143
>> 144 /////////////////////////////////////////////////////////////////////////////
>> 145 void GammaRayTelPhysicsList::AddPhysicsList(const G4String& name)
>> 146 {
>> 147
>> 148 if (verboseLevel>1) {
>> 149 G4cout << "PhysicsList::AddPhysicsList: <" << name << ">" << G4endl;
>> 150 }
>> 151 if (name == emName) return;
>> 152
>> 153 /////////////////////////////////////////////////////////////////////////////
>> 154 // ELECTROMAGNETIC MODELS
>> 155 /////////////////////////////////////////////////////////////////////////////
94 156
95 GammaRayTelPhysicsList::~GammaRayTelPhysicsLis << 157 if (name == "standard_opt3") {
96 delete pMessenger; << 158 emName = name;
97 delete emPhysicsList; 159 delete emPhysicsList;
98 delete decPhysicsList; << 160 emPhysicsList = new G4EmStandardPhysics_option3();
>> 161 G4cout << "THE FOLLOWING ELECTROMAGNETIC PHYSICS LIST HAS BEEN ACTIVATED: G4EmStandardPhysics_option3" << G4endl;
99 162
100 for (auto &hadronPhy : hadronPhys) { << 163 } else if (name == "LowE_Livermore") {
101 delete hadronPhy; << 164 emName = name;
102 } << 165 delete emPhysicsList;
103 } << 166 emPhysicsList = new G4EmLivermorePhysics();
104 << 167 G4cout << "THE FOLLOWING ELECTROMAGNETIC PHYSICS LIST HAS BEEN ACTIVATED: G4EmLivermorePhysics" << G4endl;
105 //....oooOO0OOooo........oooOO0OOooo........oo << 168 } else if (name == "LowE_Penelope") {
106 << 169 emName = name;
107 void GammaRayTelPhysicsList::AddPackage(const << 170 delete emPhysicsList;
108 G4PhysListFactory factory; << 171 emPhysicsList = new G4EmPenelopePhysics();
109 auto *phys = factory.GetReferencePhysList( << 172 G4cout << "THE FOLLOWING ELECTROMAGNETIC PHYSICS LIST HAS BEEN ACTIVATED: G4EmLivermorePhysics" << G4endl;
110 << 173 } else if (name == "LowE_Polarized") {
111 G4int i = 0; << 174 emName = name;
112 const G4VPhysicsConstructor *element = phy << 175 delete emPhysicsList;
113 auto *tmp = const_cast<G4VPhysicsConstruct << 176 emPhysicsList = new G4EmLivermorePolarizedPhysics();
114 << 177 G4cout << "THE FOLLOWING ELECTROMAGNETIC PHYSICS LIST HAS BEEN ACTIVATED: G4EmLivermorePhysics" << G4endl;
115 while (element != nullptr) { <<
116 RegisterPhysics(tmp); <<
117 element = phys->GetPhysics(++i); <<
118 tmp = const_cast<G4VPhysicsConstructor <<
119 } <<
120 } <<
121 <<
122 //....oooOO0OOooo........oooOO0OOooo........oo <<
123 <<
124 void GammaRayTelPhysicsList::ConstructParticle <<
125 decPhysicsList->ConstructParticle(); <<
126 } <<
127 <<
128 //....oooOO0OOooo........oooOO0OOooo........oo <<
129 <<
130 void GammaRayTelPhysicsList::ConstructProcess( <<
131 // transportation <<
132 // <<
133 AddTransportation(); <<
134 <<
135 // electromagnetic physics list <<
136 // <<
137 emPhysicsList->ConstructProcess(); <<
138 emConfigurator.AddModels(); <<
139 <<
140 // decay physics list <<
141 // <<
142 decPhysicsList->ConstructProcess(); <<
143 <<
144 // hadronic physics lists <<
145 for (auto &hadronPhy : hadronPhys) { <<
146 hadronPhy->ConstructProcess(); <<
147 } <<
148 <<
149 // step limitation (as a full process) <<
150 // AddStepMax(); <<
151 } <<
152 <<
153 //....oooOO0OOooo........oooOO0OOooo........oo <<
154 <<
155 void GammaRayTelPhysicsList::AddPhysicsList(co <<
156 if (verboseLevel > 1) { <<
157 G4cout << "PhysicsList::AddPhysicsList <<
158 } <<
159 if (name == emName) { <<
160 return; <<
161 } <<
162 <<
163 //////////////////////////////// <<
164 // ELECTROMAGNETIC MODELS // <<
165 //////////////////////////////// <<
166 <<
167 if (name == "standard_opt3") { <<
168 emName = name; <<
169 delete emPhysicsList; <<
170 emPhysicsList = new G4EmStandardPhysic <<
171 G4cout << "THE FOLLOWING ELECTROMAGNET <<
172 } else if (name == "LowE_Livermore") { <<
173 emName = name; <<
174 delete emPhysicsList; <<
175 emPhysicsList = new G4EmLivermorePhysi <<
176 G4cout << "THE FOLLOWING ELECTROMAGNET <<
177 } else if (name == "LowE_Penelope") { <<
178 emName = name; <<
179 delete emPhysicsList; <<
180 emPhysicsList = new G4EmPenelopePhysic <<
181 G4cout << "THE FOLLOWING ELECTROMAGNET <<
182 } else if (name == "LowE_Polarized") { <<
183 emName = name; <<
184 delete emPhysicsList; <<
185 emPhysicsList = new G4EmLivermorePolar <<
186 G4cout << "THE FOLLOWING ELECTROMAGNET <<
187 } else if (name == "standard_opt4") { <<
188 emName = name; <<
189 delete emPhysicsList; <<
190 emPhysicsList = new G4EmStandardPhysic <<
191 G4cout << "THE FOLLOWING ELECTROMAGNET <<
192 <<
193 ///////////////////////// <<
194 // HADRONIC MODELS // <<
195 ///////////////////////// <<
196 <<
197 } else if (name == "elastic" && !helIsRegi <<
198 G4cout << "THE FOLLOWING HADRONIC ELAS <<
199 hadronPhys.push_back(new G4HadronElast <<
200 helIsRegisted = true; <<
201 } else if (name == "DElastic" && !helIsReg <<
202 hadronPhys.push_back(new G4HadronDElas <<
203 helIsRegisted = true; <<
204 } else if (name == "HPElastic" && !helIsRe <<
205 hadronPhys.push_back(new G4HadronElast <<
206 helIsRegisted = true; <<
207 } else if (name == "binary" && !bicIsRegis <<
208 hadronPhys.push_back(new G4HadronPhysi <<
209 bicIsRegisted = true; <<
210 G4cout << "THE FOLLOWING HADRONIC INEL <<
211 } else if (name == "binary_ion" && !biciIs <<
212 hadronPhys.push_back(new G4IonBinaryCa <<
213 biciIsRegisted = true; <<
214 G4cout << "THE FOLLOWING HADRONIC INEL <<
215 } else if (name == "radioactive_decay" && <<
216 hadronPhys.push_back(new G4Radioactive <<
217 radioactiveDecayIsRegisted = true; <<
218 G4cout << "THE FOLLOWING HADRONIC INEL <<
219 } else { <<
220 G4cout << "PhysicsList::AddPhysicsList <<
221 } <<
222 } <<
223 <<
224 //....oooOO0OOooo........oooOO0OOooo........oo <<
225 <<
226 void GammaRayTelPhysicsList::SetCutForGamma(G4 <<
227 SetParticleCuts(cut, G4Gamma::Gamma()); <<
228 } <<
229 <<
230 //....oooOO0OOooo........oooOO0OOooo........oo <<
231 178
232 void GammaRayTelPhysicsList::SetCutForElectron << 179 /////////////////////////////////////////////////////////////////////////////
233 SetParticleCuts(cut, G4Electron::Electron( << 180 // HADRONIC MODELS
>> 181 /////////////////////////////////////////////////////////////////////////////
>> 182 } else if (name == "elastic" && !helIsRegisted) {
>> 183 G4cout << "THE FOLLOWING HADRONIC ELASTIC PHYSICS LIST HAS BEEN ACTIVATED: G4HadronElasticPhysics()" << G4endl;
>> 184 hadronPhys.push_back( new G4HadronElasticPhysics());
>> 185 helIsRegisted = true;
>> 186
>> 187 } else if (name == "DElastic" && !helIsRegisted) {
>> 188 hadronPhys.push_back( new G4HadronDElasticPhysics());
>> 189 helIsRegisted = true;
>> 190
>> 191 } else if (name == "HPElastic" && !helIsRegisted) {
>> 192 hadronPhys.push_back( new G4HadronElasticPhysicsHP());
>> 193 helIsRegisted = true;
>> 194
>> 195 } else if (name == "binary" && !bicIsRegisted) {
>> 196 hadronPhys.push_back(new G4HadronPhysicsQGSP_BIC_HP());
>> 197 bicIsRegisted = true;
>> 198 G4cout << "THE FOLLOWING HADRONIC INELASTIC PHYSICS LIST HAS BEEN ACTIVATED: HadronPhysicsQGSP_BIC_HP()" << G4endl;
>> 199
>> 200 } else if (name == "binary_ion" && !biciIsRegisted) {
>> 201 hadronPhys.push_back(new G4IonBinaryCascadePhysics());
>> 202 biciIsRegisted = true;
>> 203 G4cout << "THE FOLLOWING HADRONIC INELASTIC PHYSICS LIST HAS BEEN ACTIVATED: G4IonBinaryCascadePhysics()" << G4endl;
>> 204 } else if (name == "radioactive_decay" && !radioactiveDecayIsRegisted ) {
>> 205 hadronPhys.push_back(new G4RadioactiveDecayPhysics());
>> 206 radioactiveDecayIsRegisted = true;
>> 207 G4cout << "THE FOLLOWING HADRONIC INELASTIC PHYSICS LIST HAS BEEN ACTIVATED: G4RadioactiveDecayPhysics()" << G4endl;
>> 208 } else {
>> 209
>> 210 G4cout << "PhysicsList::AddPhysicsList: <" << name << ">"
>> 211 << " is not defined"
>> 212 << G4endl;
>> 213 }
>> 214 }
>> 215
>> 216 /////////////////////////////////////////////////////////////////////////////
>> 217 void GammaRayTelPhysicsList::SetCuts()
>> 218 {
>> 219
>> 220 if (verboseLevel >0){
>> 221 G4cout << "PhysicsList::SetCuts:";
>> 222 G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
>> 223 }
>> 224
>> 225 G4double lowLimit = 250. * eV;
>> 226 G4double highLimit = 100. * GeV;
>> 227 G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowLimit, highLimit);
>> 228
>> 229 // set cut values for gamma at first and for e- second and next for e+,
>> 230 // because some processes for e+/e- need cut values for gamma
>> 231 SetCutValue(cutForGamma, "gamma");
>> 232 SetCutValue(cutForElectron, "e-");
>> 233 SetCutValue(cutForPositron, "e+");
>> 234
>> 235 if (verboseLevel>0) DumpCutValuesTable();
>> 236 }
>> 237
>> 238 void GammaRayTelPhysicsList::SetCutForGamma(G4double cut)
>> 239 {
>> 240 cutForGamma = cut;
>> 241 SetParticleCuts(cutForGamma, G4Gamma::Gamma());
>> 242 }
>> 243
>> 244 void GammaRayTelPhysicsList::SetCutForElectron(G4double cut)
>> 245 {
>> 246 cutForElectron = cut;
>> 247 SetParticleCuts(cutForElectron, G4Electron::Electron());
>> 248 }
>> 249
>> 250 void GammaRayTelPhysicsList::SetCutForPositron(G4double cut)
>> 251 {
>> 252 cutForPositron = cut;
>> 253 SetParticleCuts(cutForPositron, G4Positron::Positron());
234 } 254 }
235 255
236 //....oooOO0OOooo........oooOO0OOooo........oo <<
237 <<
238 void GammaRayTelPhysicsList::SetCutForPositron <<
239 SetParticleCuts(cut, G4Positron::Positron( <<
240 } <<
241 256