| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // G4VUserPhysicsList implementation <<
27 // 23 //
28 // Original author: H.Kurashige (Kobe Universi << 24 // $Id: G4VUserPhysicsList.cc,v 1.48 2003/11/10 15:49:39 kurasige Exp $
29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-06-00-patch-01 $
>> 26 //
>> 27 //
>> 28 // ------------------------------------------------------------
>> 29 // GEANT 4 class header file
>> 30 //
>> 31 // ------------------------------------------------------------
>> 32 // History
>> 33 // first version 09 Jan 1998 by H.Kurashige
>> 34 // Added SetEnergyRange 18 Jun 1998 by H.Kurashige
>> 35 // Change for short lived particles 27 Jun 1998 by H.Kurashige
>> 36 // G4BestUnit on output 12 nov 1998 by M.Maire
>> 37 // Added RemoveProcessManager 9 Feb 1999 by H.Kurashige
>> 38 // Fixed RemoveProcessManager 15 Apr 1999 by H.Kurashige
>> 39 // Removed ConstructAllParticles() 15 Apr 1999 by H.Kurashige
>> 40 // Modified for CUTS per REGION 10 Oct 2002 by H.Kurashige
>> 41 // Check if particle IsShortLived 18 Jun 2003 by V.Ivanchenko
>> 42 // ------------------------------------------------------------
30 43
>> 44 #include "globals.hh"
31 #include "G4VUserPhysicsList.hh" 45 #include "G4VUserPhysicsList.hh"
32 <<
33 #include "G4Material.hh" <<
34 #include "G4MaterialCutsCouple.hh" <<
35 #include "G4ParticleDefinition.hh" 46 #include "G4ParticleDefinition.hh"
36 #include "G4ParticleTable.hh" <<
37 #include "G4PhysicsListHelper.hh" <<
38 #include "G4ProcessManager.hh" 47 #include "G4ProcessManager.hh"
39 #include "G4ProductionCuts.hh" << 48 #include "G4ParticleTable.hh"
40 #include "G4ProductionCutsTable.hh" 49 #include "G4ProductionCutsTable.hh"
41 #include "G4Region.hh" << 50 #include "G4Material.hh"
42 #include "G4RegionStore.hh" << 51 #include "G4UserPhysicsListMessenger.hh"
43 #include "G4SystemOfUnits.hh" <<
44 #include "G4UImanager.hh" 52 #include "G4UImanager.hh"
45 #include "G4UnitsTable.hh" 53 #include "G4UnitsTable.hh"
46 #include "G4UserPhysicsListMessenger.hh" << 54 #include "G4RegionStore.hh"
47 #include "G4VTrackingManager.hh" << 55 #include "G4Region.hh"
48 #include "G4ios.hh" << 56 #include "G4ProductionCutsTable.hh"
49 #include "globals.hh" << 57 #include "G4ProductionCuts.hh"
>> 58 #include "G4MaterialCutsCouple.hh"
50 59
51 #include <fstream> << 60 #include "G4ios.hh"
52 #include <iomanip> 61 #include <iomanip>
53 #include <unordered_set> << 62 #include <fstream>
54 <<
55 // This static member is thread local. For eac <<
56 // size of G4VUPLData instances. <<
57 // <<
58 #define G4MT_theMessenger ((this->subInstanceM <<
59 #define G4MT_thePLHelper ((this->subInstanceMa <<
60 #define fIsPhysicsTableBuilt \ <<
61 ((this->subInstanceManager.offset[this->g4vu <<
62 #define fDisplayThreshold \ <<
63 ((this->subInstanceManager.offset[this->g4vu <<
64 #define theParticleIterator \ <<
65 ((this->subInstanceManager.offset[this->g4vu <<
66 <<
67 // This field helps to use the class G4VUPLMan <<
68 // <<
69 G4VUPLManager G4VUserPhysicsList::subInstanceM <<
70 <<
71 // ------------------------------------------- <<
72 void G4VUPLData::initialize() <<
73 { <<
74 _theParticleIterator = G4ParticleTable::GetP <<
75 _theMessenger = nullptr; <<
76 _thePLHelper = G4PhysicsListHelper::GetPhysi <<
77 _fIsPhysicsTableBuilt = false; <<
78 _fDisplayThreshold = 0; <<
79 } <<
80 63
81 // ------------------------------------------- << 64 ////////////////////////////////////////////////////////
82 G4VUserPhysicsList::G4VUserPhysicsList() 65 G4VUserPhysicsList::G4VUserPhysicsList()
>> 66 :verboseLevel(1),
>> 67 fRetrievePhysicsTable(false),
>> 68 fStoredInAscii(true),
>> 69 fIsCheckedForRetrievePhysicsTable(false),
>> 70 fIsRestoredCutValues(false),
>> 71 directoryPhysicsTable("."),
>> 72 fDisplayThreshold(0)
83 { 73 {
84 g4vuplInstanceID = subInstanceManager.Create <<
85 // default cut value (1.0mm) 74 // default cut value (1.0mm)
86 defaultCutValue = 1.0 * mm; << 75 defaultCutValue = 1.0*mm;
87 76
88 // pointer to the particle table 77 // pointer to the particle table
89 theParticleTable = G4ParticleTable::GetParti 78 theParticleTable = G4ParticleTable::GetParticleTable();
>> 79 theParticleIterator = theParticleTable->GetIterator();
90 80
91 // pointer to the cuts table 81 // pointer to the cuts table
92 fCutsTable = G4ProductionCutsTable::GetProdu << 82 fCutsTable = G4ProductionCutsTable::GetProductionCutsTable();
93 83
94 // set energy range for SetCut calcuration 84 // set energy range for SetCut calcuration
95 fCutsTable->SetEnergyRange(0.99 * keV, 100 * << 85 fCutsTable->SetEnergyRange(0.99*keV, 100*TeV);
96 86
97 // UI Messenger 87 // UI Messenger
98 G4MT_theMessenger = new G4UserPhysicsListMes << 88 theMessenger = new G4UserPhysicsListMessenger(this);
99 <<
100 // PhysicsListHelper <<
101 G4MT_thePLHelper->SetVerboseLevel(verboseLev <<
102 <<
103 fIsPhysicsTableBuilt = false; <<
104 fDisplayThreshold = 0; <<
105 } 89 }
106 90
107 // ------------------------------------------- << 91 ////////////////////////////////////////////////////////
108 void G4VUserPhysicsList::InitializeWorker() << 92 G4VUserPhysicsList::~G4VUserPhysicsList()
109 { 93 {
110 // Remember messengers are per-thread, so th << 94 if (theMessenger != 0) {
111 // worker and due to the presence of "this" << 95 delete theMessenger;
112 // G4VUPLData::initialize() << 96 theMessenger = 0;
113 G4MT_theMessenger = new G4UserPhysicsListMes << 97 }
114 } 98 }
115 99
116 // ------------------------------------------- << 100 ////////////////////////////////////////////////////////
117 void G4VUserPhysicsList::TerminateWorker() << 101 void G4VUserPhysicsList::SetVerboseLevel(G4int value)
118 { 102 {
119 RemoveProcessManager(); << 103 verboseLevel = value;
120 RemoveTrackingManager(); << 104 // set verboseLevel for G4ProductionCutsTable same as one for G4VUserPhysicsList:
121 delete G4MT_theMessenger; << 105 fCutsTable->SetVerboseLevel(value);
122 G4MT_theMessenger = nullptr; << 106
>> 107 #ifdef G4VERBOSE
>> 108 if (verboseLevel >1){
>> 109 G4cout << "G4VUserPhysicsList::SetVerboseLevel :";
>> 110 G4cout << " Verbose level is set to " << verboseLevel << G4endl;
>> 111 }
>> 112 #endif
123 } 113 }
124 114
125 // ------------------------------------------- << 115 ////////////////////////////////////////////////////////
126 G4VUserPhysicsList::~G4VUserPhysicsList() << 116 void G4VUserPhysicsList::AddProcessManager(G4ParticleDefinition* newParticle,
>> 117 G4ProcessManager* newManager)
127 { 118 {
128 delete G4MT_theMessenger; << 119 if (newParticle == 0) return;
129 G4MT_theMessenger = nullptr; << 120 if (newParticle->GetProcessManager() != 0) {
130 << 121 #ifdef G4VERBOSE
131 RemoveProcessManager(); << 122 if (verboseLevel >1){
132 RemoveTrackingManager(); << 123 G4cout << "G4VUserPhysicsList::AddProcessManager: ";
>> 124 G4cout << newParticle->GetParticleName();
>> 125 G4cout << " already has ProcessManager " << G4endl;
>> 126 }
>> 127 #endif
>> 128 return;
>> 129 }
133 130
134 // invoke DeleteAllParticle << 131 // create new process manager if newManager == 0
135 theParticleTable->DeleteAllParticles(); << 132 if (newManager == 0){
136 } << 133 // Add ProcessManager
>> 134 if (newParticle->GetParticleType() == "nucleus") {
>> 135 // Create a copy of the process manager of "GenericIon" in case of "nucleus"
>> 136 G4ParticleDefinition* genericIon =
>> 137 (G4ParticleTable::GetParticleTable())->FindParticle("GenericIon");
137 138
138 // ------------------------------------------- << 139 if (genericIon != 0) {
139 G4VUserPhysicsList::G4VUserPhysicsList(const G << 140 G4ProcessManager* ionMan = genericIon->GetProcessManager();
140 : verboseLevel(right.verboseLevel), << 141 if (ionMan != 0) {
141 defaultCutValue(right.defaultCutValue), << 142 newManager = new G4ProcessManager(*ionMan);
142 isSetDefaultCutValue(right.isSetDefaultCut << 143 } else {
143 fRetrievePhysicsTable(right.fRetrievePhysi << 144 // no process manager has been registered yet
144 fStoredInAscii(right.fStoredInAscii), << 145 newManager = new G4ProcessManager(newParticle);
145 fIsCheckedForRetrievePhysicsTable(right.fI << 146 }
146 fIsRestoredCutValues(right.fIsRestoredCutV << 147 } else {
147 directoryPhysicsTable(right.directoryPhysi << 148 // "GenericIon" does not exist
148 fDisableCheckParticleList(right.fDisableCh << 149 newManager = new G4ProcessManager(newParticle);
149 { << 150 }
150 g4vuplInstanceID = subInstanceManager.Create <<
151 // pointer to the particle table <<
152 theParticleTable = G4ParticleTable::GetParti <<
153 theParticleIterator = theParticleTable->GetI <<
154 // pointer to the cuts table <<
155 fCutsTable = G4ProductionCutsTable::GetProdu <<
156 151
157 // UI Messenger << 152 } else {
158 G4MT_theMessenger = new G4UserPhysicsListMes << 153 // create process manager for particles other than "nucleus"
>> 154 newManager = new G4ProcessManager(newParticle);
>> 155 }
>> 156 }
159 157
160 // PhysicsListHelper << 158 // set particle type
161 G4MT_thePLHelper = G4PhysicsListHelper::GetP << 159 newManager->SetParticleType(newParticle);
162 G4MT_thePLHelper->SetVerboseLevel(verboseLev <<
163 160
164 fIsPhysicsTableBuilt = << 161 // add the process manager
165 right.GetSubInstanceManager().offset[right << 162 newParticle->SetProcessManager(newManager);
166 fDisplayThreshold = <<
167 right.GetSubInstanceManager().offset[right <<
168 } <<
169 163
170 // ------------------------------------------- << 164 #ifdef G4VERBOSE
171 G4VUserPhysicsList& G4VUserPhysicsList::operat << 165 if (verboseLevel >2){
172 { << 166 G4cout << "G4VUserPhysicsList::AddProcessManager: ";
173 if (this != &right) { << 167 G4cout << "adds ProcessManager to ";
174 verboseLevel = right.verboseLevel; << 168 G4cout << newParticle->GetParticleName() << G4endl;
175 defaultCutValue = right.defaultCutValue; << 169 newManager->DumpInfo();
176 isSetDefaultCutValue = right.isSetDefaultC <<
177 fRetrievePhysicsTable = right.fRetrievePhy <<
178 fStoredInAscii = right.fStoredInAscii; <<
179 fIsCheckedForRetrievePhysicsTable = right. <<
180 fIsRestoredCutValues = right.fIsRestoredCu <<
181 directoryPhysicsTable = right.directoryPhy <<
182 fIsPhysicsTableBuilt = <<
183 right.GetSubInstanceManager().offset[rig <<
184 fDisplayThreshold = <<
185 right.GetSubInstanceManager().offset[rig <<
186 fDisableCheckParticleList = right.fDisable <<
187 } 170 }
188 return *this; << 171 #endif
>> 172 if (newParticle->GetParticleType() == "nucleus") BuildPhysicsTable(newParticle);
189 } 173 }
190 174
191 // ------------------------------------------- <<
192 void G4VUserPhysicsList::AddProcessManager(G4P <<
193 { <<
194 if (newParticle == nullptr) return; <<
195 G4Exception("G4VUserPhysicsList::AddProcessM <<
196 "This method is obsolete"); <<
197 } <<
198 175
199 // ------------------------------------------- << 176 ////////////////////////////////////////////////////////
200 void G4VUserPhysicsList::InitializeProcessMana 177 void G4VUserPhysicsList::InitializeProcessManager()
201 { 178 {
202 // Request lock for particle table access. S <<
203 // this critical region. <<
204 #ifdef G4MULTITHREADED <<
205 G4MUTEXLOCK(&G4ParticleTable::particleTableM <<
206 G4ParticleTable::lockCount()++; <<
207 #endif <<
208 G4ParticleDefinition* gion = G4ParticleTable <<
209 <<
210 // loop over all particles in G4ParticleTabl 179 // loop over all particles in G4ParticleTable
211 theParticleIterator->reset(); 180 theParticleIterator->reset();
212 while ((*theParticleIterator)()) { << 181 while( (*theParticleIterator)() ){
213 G4ParticleDefinition* particle = thePartic 182 G4ParticleDefinition* particle = theParticleIterator->value();
214 G4ProcessManager* pmanager = particle->Get 183 G4ProcessManager* pmanager = particle->GetProcessManager();
215 << 184 if (pmanager==0) {
216 if (pmanager == nullptr) { << 185 // create process manager if the particle has no its one
217 // create process manager if the particl <<
218 pmanager = new G4ProcessManager(particle 186 pmanager = new G4ProcessManager(particle);
219 particle->SetProcessManager(pmanager); 187 particle->SetProcessManager(pmanager);
220 if (particle->GetMasterProcessManager() <<
221 particle->SetMasterProcessManager(pman <<
222 #ifdef G4VERBOSE <<
223 if (verboseLevel > 2) { <<
224 G4cout << "G4VUserPhysicsList::Initial <<
225 "ProcessManager to " <<
226 << particle->GetParticleName() <<
227 } <<
228 #endif <<
229 } 188 }
230 } 189 }
231 <<
232 if (gion != nullptr) { <<
233 G4ProcessManager* gionPM = gion->GetProces <<
234 // loop over all particles once again (thi <<
235 theParticleIterator->reset(false); <<
236 while ((*theParticleIterator)()) { <<
237 G4ParticleDefinition* particle = thePart <<
238 if (particle->IsGeneralIon()) { <<
239 particle->SetProcessManager(gionPM); <<
240 #ifdef G4VERBOSE <<
241 if (verboseLevel > 2) { <<
242 G4cout << "G4VUserPhysicsList::Initi <<
243 "ProcessManager to " <<
244 << particle->GetParticleName( <<
245 } <<
246 #endif <<
247 } <<
248 } <<
249 } <<
250 <<
251 // release lock for particle table access <<
252 #ifdef G4MULTITHREADED <<
253 G4MUTEXUNLOCK(&G4ParticleTable::particleTabl <<
254 #endif <<
255 } 190 }
256 191
257 // ------------------------------------------- << 192 ////////////////////////////////////////////////////////
258 void G4VUserPhysicsList::RemoveProcessManager( 193 void G4VUserPhysicsList::RemoveProcessManager()
259 { 194 {
260 // Request lock for particle table access. S <<
261 // this critical region. <<
262 #ifdef G4MULTITHREADED <<
263 G4MUTEXLOCK(&G4ParticleTable::particleTableM <<
264 G4ParticleTable::lockCount()++; <<
265 #endif <<
266 <<
267 // loop over all particles in G4ParticleTabl 195 // loop over all particles in G4ParticleTable
268 theParticleIterator->reset(); 196 theParticleIterator->reset();
269 while ((*theParticleIterator)()) { << 197 while( (*theParticleIterator)() ){
270 G4ParticleDefinition* particle = thePartic 198 G4ParticleDefinition* particle = theParticleIterator->value();
271 if (particle->GetInstanceID() < G4Particle << 199 G4ProcessManager* pmanager = particle->GetProcessManager();
272 if (particle->GetParticleSubType() != "g << 200 if (pmanager!=0) delete pmanager;
273 || particle->GetParticleName() == "G << 201 particle->SetProcessManager(0);
274 { << 202 #ifdef G4VERBOSE
275 G4ProcessManager* pmanager = particle- << 203 if (verboseLevel >2){
276 << 204 G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
277 delete pmanager; << 205 G4cout << "remove ProcessManager from ";
278 #ifdef G4VERBOSE << 206 G4cout << particle->GetParticleName() << G4endl;
279 if (verboseLevel > 2) { <<
280 G4cout << "G4VUserPhysicsList::Remov <<
281 G4cout << "remove ProcessManager fro <<
282 G4cout << particle->GetParticleName( <<
283 } <<
284 #endif <<
285 } <<
286 particle->SetProcessManager(nullptr); <<
287 } 207 }
288 } <<
289 <<
290 // release lock for particle table access <<
291 #ifdef G4MULTITHREADED <<
292 G4MUTEXUNLOCK(&G4ParticleTable::particleTabl <<
293 #endif 208 #endif
>> 209 }
294 } 210 }
295 211
296 // ------------------------------------------- << 212
297 void G4VUserPhysicsList::RemoveTrackingManager << 213 ////////////////////////////////////////////////////////
>> 214 #include "G4Transportation.hh"
>> 215 void G4VUserPhysicsList::AddTransportation()
298 { 216 {
299 // One tracking manager may be registered fo << 217 G4Transportation* theTransportationProcess= new G4Transportation();
300 // to delete every object only once. << 218
301 std::unordered_set<G4VTrackingManager*> trac << 219 #ifdef G4VERBOSE
>> 220 if (verboseLevel >2){
>> 221 G4cout << "G4VUserPhysicsList::AddTransportation() "<< G4endl;
>> 222 }
>> 223 #endif
302 224
303 // loop over all particles in G4ParticleTabl 225 // loop over all particles in G4ParticleTable
304 theParticleIterator->reset(); 226 theParticleIterator->reset();
305 while ((*theParticleIterator)()) { << 227 while( (*theParticleIterator)() ){
306 G4ParticleDefinition* particle = thePartic 228 G4ParticleDefinition* particle = theParticleIterator->value();
307 if (auto* trackingManager = particle->GetT << 229 G4ProcessManager* pmanager = particle->GetProcessManager();
308 #ifdef G4VERBOSE << 230 if (!particle->IsShortLived()) {
309 if (verboseLevel > 2) { << 231 // Add transportation process for all particles other than "shortlived"
310 G4cout << "G4VUserPhysicsList::RemoveT << 232 if ( pmanager == 0) {
311 G4cout << "remove TrackingManager from << 233 // Error !! no process manager
312 G4cout << particle->GetParticleName() << 234 G4String particleName = particle->GetParticleName();
>> 235 G4Exception("G4VUserPhysicsList::AddTransportation","No process manager",
>> 236 RunMustBeAborted, particleName );
>> 237 } else {
>> 238 // add transportation with ordering = ( -1, "first", "first" )
>> 239 pmanager ->AddProcess(theTransportationProcess);
>> 240 pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
>> 241 pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
313 } 242 }
314 #endif << 243 } else {
315 trackingManagers.insert(trackingManager) << 244 // shortlived particle case
316 particle->SetTrackingManager(nullptr); <<
317 } 245 }
318 } 246 }
319 <<
320 for (G4VTrackingManager* tm : trackingManage <<
321 delete tm; <<
322 } <<
323 } 247 }
324 248
325 // ------------------------------------------- <<
326 void G4VUserPhysicsList::SetCuts() <<
327 { <<
328 if (!isSetDefaultCutValue) { <<
329 SetDefaultCutValue(defaultCutValue); <<
330 } <<
331 <<
332 #ifdef G4VERBOSE <<
333 if (verboseLevel > 1) { <<
334 G4cout << "G4VUserPhysicsList::SetCuts: <<
335 G4cout << "Cut for gamma: " << GetCutValue <<
336 G4cout << "Cut for e-: " << GetCutValue(" <<
337 G4cout << "Cut for e+: " << GetCutValue(" <<
338 G4cout << "Cut for proton: " << GetCutVal <<
339 } <<
340 #endif <<
341 <<
342 // dump Cut values if verboseLevel==3 <<
343 if (verboseLevel > 2) { <<
344 DumpCutValuesTable(); <<
345 } <<
346 } <<
347 249
348 // ------------------------------------------- << 250 ////////////////////////////////////////////////////////
349 void G4VUserPhysicsList::SetDefaultCutValue(G4 251 void G4VUserPhysicsList::SetDefaultCutValue(G4double value)
350 { 252 {
351 if (value < 0.0) { << 253 if (value<=0.0) {
352 #ifdef G4VERBOSE 254 #ifdef G4VERBOSE
353 if (verboseLevel > 0) { << 255 if (verboseLevel >0){
354 G4cout << "G4VUserPhysicsList::SetDefaul << 256 G4cout << "G4VUserPhysicsList::SetDefaultCutValue: negative cut values";
355 << " :" << value / mm << "[mm]" << 257 G4cout << " :" << value/mm << "[mm]" << G4endl;
356 } << 258 }
357 #endif 259 #endif
358 return; << 260 } else {
359 } <<
360 <<
361 defaultCutValue = value; <<
362 isSetDefaultCutValue = true; <<
363 <<
364 // set cut values for gamma at first and for <<
365 SetCutValue(defaultCutValue, "gamma"); <<
366 SetCutValue(defaultCutValue, "e-"); <<
367 SetCutValue(defaultCutValue, "e+"); <<
368 SetCutValue(defaultCutValue, "proton"); <<
369 <<
370 #ifdef G4VERBOSE 261 #ifdef G4VERBOSE
371 if (verboseLevel > 1) { << 262 if (verboseLevel >1){
372 G4cout << "G4VUserPhysicsList::SetDefaultC << 263 G4cout << "G4VUserPhysicsList::SetDefaultCutValue:";
373 << "default cut value is changed to << 264 G4cout << "default cut value is changed to :" ;
374 } << 265 G4cout << value/mm << "[mm]" << G4endl;
>> 266 }
375 #endif 267 #endif
376 } << 268 defaultCutValue = value;
377 269
378 // ------------------------------------------- << 270 }
379 G4double G4VUserPhysicsList::GetCutValue(const <<
380 { <<
381 std::size_t nReg = (G4RegionStore::GetInstan <<
382 if (nReg == 0) { <<
383 #ifdef G4VERBOSE <<
384 if (verboseLevel > 0) { <<
385 G4cout << "G4VUserPhysicsList::GetCutVal <<
386 << " : No Default Region " << G4e <<
387 } <<
388 #endif <<
389 G4Exception("G4VUserPhysicsList::GetCutVal <<
390 return -1. * mm; <<
391 } <<
392 G4Region* region = G4RegionStore::GetInstanc <<
393 return region->GetProductionCuts()->GetProdu <<
394 } 271 }
395 272
396 // ------------------------------------------- << 273
>> 274 ////////////////////////////////////////////////////////
397 void G4VUserPhysicsList::SetCutValue(G4double 275 void G4VUserPhysicsList::SetCutValue(G4double aCut, const G4String& name)
398 { 276 {
399 SetParticleCuts(aCut, name); << 277 G4ParticleDefinition* particle = theParticleTable->FindParticle(name);
>> 278 if (particle != 0){
>> 279 if (!particle->IsShortLived()) {
>> 280 //set cut value
>> 281 SetParticleCuts( aCut ,particle );
>> 282 }
>> 283 }
400 } 284 }
401 285
402 // ------------------------------------------- << 286 ////////////////////////////////////////////////////////
403 void G4VUserPhysicsList::SetCutValue(G4double << 287 void G4VUserPhysicsList::SetCutValue
>> 288 (G4double aCut, const G4String& pname, const G4String& rname)
404 { 289 {
>> 290 G4ParticleDefinition* particle = theParticleTable->FindParticle(pname);
405 G4Region* region = G4RegionStore::GetInstanc 291 G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
406 if (region != nullptr) { << 292 if (particle != 0 && region != 0){
407 // set cut value << 293 if (!particle->IsShortLived()) {
408 SetParticleCuts(aCut, pname, region); << 294 //set cut value
409 } << 295 SetParticleCuts( aCut ,particle, region );
410 else { <<
411 #ifdef G4VERBOSE <<
412 if (verboseLevel > 0) { <<
413 G4cout << "G4VUserPhysicsList::SetCutVal <<
414 << " : No Region of " << rname << <<
415 } 296 }
416 #endif <<
417 } 297 }
418 } 298 }
419 299
420 // ------------------------------------------- << 300
>> 301
>> 302 ////////////////////////////////////////////////////////
421 void G4VUserPhysicsList::SetCutsWithDefault() 303 void G4VUserPhysicsList::SetCutsWithDefault()
422 { 304 {
423 SetDefaultCutValue(defaultCutValue); << 305 // default cut value
424 G4VUserPhysicsList::SetCuts(); << 306 G4double cut = defaultCutValue;
>> 307
>> 308 #ifdef G4VERBOSE
>> 309 if (verboseLevel >1){
>> 310 G4cout << "G4VUserPhysicsList::SetCutsWithDefault:";
>> 311 G4cout << "CutLength : " << cut/mm << " (mm)" << G4endl;
>> 312 }
>> 313 #endif
>> 314
>> 315 // set cut values for gamma at first and for e- and e+
>> 316 SetCutValue(cut, "gamma");
>> 317 SetCutValue(cut, "e-");
>> 318 SetCutValue(cut, "e+");
>> 319
>> 320 // dump Cut values if verboseLevel==3
>> 321 if (verboseLevel>2) {
>> 322 DumpCutValuesTable();
>> 323 }
425 } 324 }
426 325
427 // ------------------------------------------- << 326
>> 327 ////////////////////////////////////////////////////////
428 void G4VUserPhysicsList::SetCutsForRegion(G4do 328 void G4VUserPhysicsList::SetCutsForRegion(G4double aCut, const G4String& rname)
429 { 329 {
430 // set cut values for gamma at first and for 330 // set cut values for gamma at first and for e- and e+
431 SetCutValue(aCut, "gamma", rname); 331 SetCutValue(aCut, "gamma", rname);
432 SetCutValue(aCut, "e-", rname); 332 SetCutValue(aCut, "e-", rname);
433 SetCutValue(aCut, "e+", rname); 333 SetCutValue(aCut, "e+", rname);
434 SetCutValue(aCut, "proton", rname); <<
435 } 334 }
436 335
437 // ------------------------------------------- <<
438 void G4VUserPhysicsList::SetParticleCuts(G4dou <<
439 G4Reg <<
440 { <<
441 SetParticleCuts(cut, particle->GetParticleNa <<
442 } <<
443 <<
444 // ------------------------------------------- <<
445 void G4VUserPhysicsList::SetParticleCuts(G4dou <<
446 G4Reg <<
447 { <<
448 if (cut < 0.0) { <<
449 #ifdef G4VERBOSE <<
450 if (verboseLevel > 0) { <<
451 G4cout << "G4VUserPhysicsList::SetPartic <<
452 << " :" << cut / mm << "[mm]" <<
453 << " for " << particleName << G4e <<
454 } <<
455 #endif <<
456 return; <<
457 } <<
458 336
459 G4Region* world_region = <<
460 G4RegionStore::GetInstance()->GetRegion("D <<
461 if (region == nullptr) { <<
462 std::size_t nReg = G4RegionStore::GetInsta <<
463 if (nReg == 0) { <<
464 #ifdef G4VERBOSE <<
465 if (verboseLevel > 0) { <<
466 G4cout << "G4VUserPhysicsList::SetPart <<
467 << " : No Default Region " << G <<
468 } <<
469 #endif <<
470 G4Exception("G4VUserPhysicsList::SetPart <<
471 "No Default Region"); <<
472 return; <<
473 } <<
474 region = world_region; <<
475 } <<
476 <<
477 if (!isSetDefaultCutValue) { <<
478 SetDefaultCutValue(defaultCutValue); <<
479 } <<
480 337
>> 338 ////////////////////////////////////////////////////////
>> 339 ////////////////////////////////////////////////////////
>> 340 void G4VUserPhysicsList::SetParticleCuts( G4double cut, G4ParticleDefinition* particle, G4Region* region)
>> 341 {
>> 342 if(!region) region = (*(G4RegionStore::GetInstance()))[0];
481 G4ProductionCuts* pcuts = region->GetProduct 343 G4ProductionCuts* pcuts = region->GetProductionCuts();
482 if (region != world_region << 344 pcuts->SetProductionCut(cut,particle);
483 && pcuts == G4ProductionCutsTable::GetPr <<
484 { // This region had no unique cuts yet but <<
485 // Need to create a new object before set <<
486 pcuts = new G4ProductionCuts( <<
487 *(G4ProductionCutsTable::GetProductionCu <<
488 region->SetProductionCuts(pcuts); <<
489 } <<
490 pcuts->SetProductionCut(cut, particleName); <<
491 #ifdef G4VERBOSE <<
492 if (verboseLevel > 2) { <<
493 G4cout << "G4VUserPhysicsList::SetParticle <<
494 << " :" << cut / mm << "[mm]" <<
495 << " for " << particleName << G4end <<
496 } <<
497 #endif <<
498 } 345 }
499 346
500 // ------------------------------------------- << 347 ///////////////////////////////////////////////////////////////
501 void G4VUserPhysicsList::BuildPhysicsTable() 348 void G4VUserPhysicsList::BuildPhysicsTable()
502 { 349 {
503 // Prepare Physics table for all particles <<
504 theParticleIterator->reset(); <<
505 while ((*theParticleIterator)()) { <<
506 G4ParticleDefinition* particle = thePartic <<
507 PreparePhysicsTable(particle); <<
508 } <<
509 <<
510 // ask processes to prepare physics table <<
511 if (fRetrievePhysicsTable) { 350 if (fRetrievePhysicsTable) {
512 fIsRestoredCutValues = fCutsTable->Retriev << 351 if (!fIsRestoredCutValues) fIsRestoredCutValues = fCutsTable->RetrieveCutsTable(directoryPhysicsTable, fStoredInAscii);
513 // check if retrieve Cut Table successfull 352 // check if retrieve Cut Table successfully
514 if (!fIsRestoredCutValues) { 353 if (!fIsRestoredCutValues) {
515 #ifdef G4VERBOSE 354 #ifdef G4VERBOSE
516 if (verboseLevel > 0) { << 355 if (verboseLevel>0){
517 G4cout << "G4VUserPhysicsList::BuildPh << 356 G4cout << "G4VUserPhysicsList::BuildPhysicsTable";
518 << " Retrieve Cut Table failed << 357 G4cout << " Retrieve Cut Table failed !!" << G4endl;
519 } << 358 }
520 #endif << 359 #endif
521 G4Exception("G4VUserPhysicsList::BuildPh << 360 G4Exception("G4VUserPhysicsList::BuildPhysicsTable","Fail to Retreive",
522 "Fail to retrieve Production << 361 RunMustBeAborted,"Production Cut Table can not be retreived");
523 } << 362 } else {
524 else { << 363 #ifdef G4VERBOSE
525 #ifdef G4VERBOSE << 364 if (verboseLevel>2){
526 if (verboseLevel > 2) { << 365 G4cout << "G4VUserPhysicsList::BuildPhysicsTable";
527 G4cout << "G4VUserPhysicsList::BuildPh << 366 G4cout << " Retrieve Cut Table successfully " << G4endl;
528 << " Retrieve Cut Table succes <<
529 } 367 }
530 #endif << 368 #endif
531 } << 369 }
532 } <<
533 else { <<
534 #ifdef G4VERBOSE <<
535 if (verboseLevel > 2) { <<
536 G4cout << "G4VUserPhysicsList::BuildPhys <<
537 << " does not retrieve Cut Table <<
538 } <<
539 #endif <<
540 } 370 }
541 <<
542 // Sets a value to particle 371 // Sets a value to particle
543 // set cut values for gamma at first and for 372 // set cut values for gamma at first and for e- and e+
544 G4String particleName; 373 G4String particleName;
545 G4ParticleDefinition* GammaP = theParticleTa 374 G4ParticleDefinition* GammaP = theParticleTable->FindParticle("gamma");
546 if (GammaP != nullptr) BuildPhysicsTable(Gam << 375 if(GammaP) BuildPhysicsTable(GammaP);
547 G4ParticleDefinition* EMinusP = theParticleT 376 G4ParticleDefinition* EMinusP = theParticleTable->FindParticle("e-");
548 if (EMinusP != nullptr) BuildPhysicsTable(EM << 377 if(EMinusP) BuildPhysicsTable(EMinusP);
549 G4ParticleDefinition* EPlusP = theParticleTa 378 G4ParticleDefinition* EPlusP = theParticleTable->FindParticle("e+");
550 if (EPlusP != nullptr) BuildPhysicsTable(EPl << 379 if(EPlusP) BuildPhysicsTable(EPlusP);
551 G4ParticleDefinition* ProtonP = theParticleT 380 G4ParticleDefinition* ProtonP = theParticleTable->FindParticle("proton");
552 if (ProtonP != nullptr) BuildPhysicsTable(Pr << 381 if(ProtonP) BuildPhysicsTable(ProtonP);
>> 382
553 383
554 theParticleIterator->reset(); 384 theParticleIterator->reset();
555 while ((*theParticleIterator)()) { << 385 while( (*theParticleIterator)() ){
556 G4ParticleDefinition* particle = thePartic 386 G4ParticleDefinition* particle = theParticleIterator->value();
557 if (particle != GammaP && particle != EMin << 387 if( particle!=GammaP &&
558 BuildPhysicsTable(particle); << 388 particle!=EMinusP &&
>> 389 particle!=EPlusP &&
>> 390 particle!=ProtonP ){
>> 391 BuildPhysicsTable(particle);
559 } 392 }
560 } 393 }
561 <<
562 // Set flag <<
563 fIsPhysicsTableBuilt = true; <<
564 } 394 }
565 << 395 ///////////////////////////////////////////////////////////////
566 // ------------------------------------------- <<
567 void G4VUserPhysicsList::BuildPhysicsTable(G4P 396 void G4VUserPhysicsList::BuildPhysicsTable(G4ParticleDefinition* particle)
568 { 397 {
569 if (auto* trackingManager = particle->GetTra <<
570 #ifdef G4VERBOSE <<
571 if (verboseLevel > 2) { <<
572 G4cout << "G4VUserPhysicsList::BuildPhys <<
573 << "Calculate Physics Table for " <<
574 << " via custom TrackingManager" <<
575 } <<
576 #endif <<
577 trackingManager->BuildPhysicsTable(*partic <<
578 return; <<
579 } <<
580 <<
581 // Change in order to share physics tables f <<
582 <<
583 if (particle->GetMasterProcessManager() == n <<
584 #ifdef G4VERBOSE <<
585 if (verboseLevel > 0) { <<
586 G4cout << "#### G4VUserPhysicsList::Buil <<
587 << particle->GetParticleName() << <<
588 } <<
589 #endif <<
590 return; <<
591 } <<
592 if (fRetrievePhysicsTable) { 398 if (fRetrievePhysicsTable) {
593 if (!fIsRestoredCutValues) { << 399 if ( !fIsRestoredCutValues){
594 // fail to retrieve cut tables << 400 // fail to retreive cut tables
595 #ifdef G4VERBOSE 401 #ifdef G4VERBOSE
596 if (verboseLevel > 0) { << 402 if (verboseLevel>0){
597 G4cout << "G4VUserPhysicsList::BuildPh << 403 G4cout << "G4VUserPhysicsList::BuildPhysicsTable ";
598 << "Physics table can not be re << 404 G4cout << "Physics table can not be retreived and will be calculated "<< G4endl;
599 } 405 }
600 #endif 406 #endif
601 fRetrievePhysicsTable = false; << 407 fRetrievePhysicsTable = false;
602 } << 408
603 else { << 409 } else {
604 #ifdef G4VERBOSE 410 #ifdef G4VERBOSE
605 if (verboseLevel > 2) { << 411 if (verboseLevel>2){
606 G4cout << "G4VUserPhysicsList::BuildPh << 412 G4cout << "G4VUserPhysicsList::BuildPhysicsTable ";
607 << " Retrieve Physics Table for << 413 G4cout << " Retrieve Physics Table for ";
>> 414 G4cout << particle->GetParticleName() << G4endl;
608 } 415 }
609 #endif 416 #endif
610 // Retrieve PhysicsTable from files for 417 // Retrieve PhysicsTable from files for proccesses
611 RetrievePhysicsTable(particle, directory 418 RetrievePhysicsTable(particle, directoryPhysicsTable, fStoredInAscii);
>> 419 return;
612 } 420 }
613 } 421 }
614 422
615 #ifdef G4VERBOSE 423 #ifdef G4VERBOSE
616 if (verboseLevel > 2) { << 424 if (verboseLevel>2){
617 G4cout << "G4VUserPhysicsList::BuildPhysic << 425 G4cout << "G4VUserPhysicsList::BuildPhysicsTable ";
618 << "Calculate Physics Table for " < << 426 G4cout << "Calculate Physics Table for " << particle->GetParticleName() << G4endl;
619 } 427 }
620 #endif 428 #endif
621 // Rebuild the physics tables for every proc 429 // Rebuild the physics tables for every process for this particle type
622 // if particle is not ShortLived 430 // if particle is not ShortLived
623 if (!particle->IsShortLived()) { << 431 if(!particle->IsShortLived()) {
624 G4ProcessManager* pManager = particle->Get << 432 G4ProcessVector* pVector = particle->GetProcessManager()->GetProcessList();
625 if (pManager == nullptr) { << 433 for (G4int j=0; j < pVector->size(); ++j) {
626 #ifdef G4VERBOSE << 434 (*pVector)[j]->BuildPhysicsTable(*particle);
627 if (verboseLevel > 0) { <<
628 G4cout << "G4VUserPhysicsList::BuildPh <<
629 << " : No Process Manager for " <<
630 G4cout << particle->GetParticleName() <<
631 } <<
632 #endif <<
633 G4Exception("G4VUserPhysicsList::BuildPh <<
634 "No process manager"); <<
635 return; <<
636 } <<
637 <<
638 // Get processes from master thread; <<
639 G4ProcessManager* pManagerShadow = particl <<
640 <<
641 G4ProcessVector* pVector = pManager->GetPr <<
642 if (pVector == nullptr) { <<
643 #ifdef G4VERBOSE <<
644 if (verboseLevel > 0) { <<
645 G4cout << "G4VUserPhysicsList::BuildPh <<
646 << " : No Process Vector for " <<
647 } <<
648 #endif <<
649 G4Exception("G4VUserPhysicsList::BuildPh <<
650 "No process Vector"); <<
651 return; <<
652 } <<
653 #ifdef G4VERBOSE <<
654 if (verboseLevel > 2) { <<
655 G4cout << "G4VUserPhysicsList::BuildPhys <<
656 << G4endl; <<
657 G4cout << " ProcessManager : " << pManag <<
658 << G4endl; <<
659 for (G4int iv1 = 0; iv1 < (G4int)pVector <<
660 G4cout << " " << iv1 << " - " << (*pV <<
661 } <<
662 G4cout << "----------------------------- <<
663 G4ProcessVector* pVectorShadow = pManage <<
664 <<
665 for (G4int iv2 = 0; iv2 < (G4int)pVector <<
666 G4cout << " " << iv2 << " - " << (*pV <<
667 } <<
668 } 435 }
669 #endif <<
670 for (G4int j = 0; j < (G4int)pVector->size <<
671 // Andrea July 16th 2013 : migration to <<
672 // Infer if we are in a worker thread or <<
673 // Master thread is the one in which the <<
674 // and process manager shadow pointers a <<
675 if (pManagerShadow == pManager) { <<
676 (*pVector)[j]->BuildPhysicsTable(*part <<
677 } <<
678 else { <<
679 (*pVector)[j]->BuildWorkerPhysicsTable <<
680 } <<
681 <<
682 } // End loop on processes vector <<
683 } // End if short-lived <<
684 } <<
685 <<
686 // ------------------------------------------- <<
687 void G4VUserPhysicsList::PreparePhysicsTable(G <<
688 { <<
689 if (auto* trackingManager = particle->GetTra <<
690 trackingManager->PreparePhysicsTable(*part <<
691 return; <<
692 } 436 }
693 <<
694 if ((particle->GetMasterProcessManager()) == <<
695 return; <<
696 } <<
697 // Prepare the physics tables for every proc <<
698 // if particle is not ShortLived <<
699 if (!particle->IsShortLived()) { <<
700 G4ProcessManager* pManager = particle->Get <<
701 if (pManager == nullptr) { <<
702 #ifdef G4VERBOSE <<
703 if (verboseLevel > 0) { <<
704 G4cout << "G4VUserPhysicsList::Prepare <<
705 << ": No Process Manager for " <<
706 G4cout << particle->GetParticleName() <<
707 } <<
708 #endif <<
709 G4Exception("G4VUserPhysicsList::Prepare <<
710 "No process manager"); <<
711 return; <<
712 } <<
713 <<
714 // Get processes from master thread <<
715 G4ProcessManager* pManagerShadow = particl <<
716 <<
717 G4ProcessVector* pVector = pManager->GetPr <<
718 if (pVector == nullptr) { <<
719 #ifdef G4VERBOSE <<
720 if (verboseLevel > 0) { <<
721 G4cout << "G4VUserPhysicsList::Prepare <<
722 << ": No Process Vector for " < <<
723 } <<
724 #endif <<
725 G4Exception("G4VUserPhysicsList::Prepare <<
726 "No process Vector"); <<
727 return; <<
728 } <<
729 for (G4int j = 0; j < (G4int)pVector->size <<
730 // Andrea July 16th 2013 : migration to <<
731 // Infer if we are in a worker thread or <<
732 // Master thread is the one in which the <<
733 // and process manager shadow pointers a <<
734 if (pManagerShadow == pManager) { <<
735 (*pVector)[j]->PreparePhysicsTable(*pa <<
736 } <<
737 else { <<
738 (*pVector)[j]->PrepareWorkerPhysicsTab <<
739 } <<
740 } // End loop on processes vector <<
741 } // End if pn ShortLived <<
742 } 437 }
743 438
744 // ------------------------------------------- << 439 ///////////////////////////////////////////////////////////////
745 void G4VUserPhysicsList::BuildIntegralPhysicsT << 440 void G4VUserPhysicsList::BuildIntegralPhysicsTable(G4VProcess* process,
746 << 441 G4ParticleDefinition* particle)
747 { 442 {
748 // TODO Should we change this function? << 443 //*********************************************************************
749 //****************************************** << 444 // temporary addition to make the integral schema of electromagnetic
750 // Temporary addition to make the integral s <<
751 // processes work. 445 // processes work.
>> 446 //
752 447
753 if ((process->GetProcessName() == "Imsc") || << 448 if ( (process->GetProcessName() == "Imsc") ||
754 || (process->GetProcessName() == "IeBrem << 449 (process->GetProcessName() == "IeIoni") ||
755 || (process->GetProcessName() == "IhIoni << 450 (process->GetProcessName() == "IeBrems") ||
756 || (process->GetProcessName() == "IMuBre << 451 (process->GetProcessName() == "Iannihil") ||
757 { << 452 (process->GetProcessName() == "IhIoni") ||
758 #ifdef G4VERBOSE << 453 (process->GetProcessName() == "IMuIoni") ||
759 if (verboseLevel > 2) { << 454 (process->GetProcessName() == "IMuBrems") ||
760 G4cout << "G4VUserPhysicsList::BuildInte << 455 (process->GetProcessName() == "IMuPairProd") ) {
761 << " BuildPhysicsTable is invoked << 456 #ifdef G4VERBOSE
762 << particle->GetParticleName() << << 457 if (verboseLevel>2){
>> 458 G4cout << "G4VUserPhysicsList::BuildIntegralPhysicsTable ";
>> 459 G4cout << " BuildPhysicsTable is invoked for ";
>> 460 G4cout << process->GetProcessName();
>> 461 G4cout << "(" << particle->GetParticleName() << ")" << G4endl;
763 } 462 }
764 #endif 463 #endif
765 process->BuildPhysicsTable(*particle); 464 process->BuildPhysicsTable(*particle);
766 } 465 }
767 } 466 }
768 467
769 // ------------------------------------------- << 468 ///////////////////////////////////////////////////////////////
770 void G4VUserPhysicsList::DumpList() const 469 void G4VUserPhysicsList::DumpList() const
771 { 470 {
772 theParticleIterator->reset(); 471 theParticleIterator->reset();
773 G4int idx = 0; 472 G4int idx = 0;
774 while ((*theParticleIterator)()) { << 473 while( (*theParticleIterator)() ){
775 G4ParticleDefinition* particle = thePartic 474 G4ParticleDefinition* particle = theParticleIterator->value();
776 G4cout << particle->GetParticleName(); 475 G4cout << particle->GetParticleName();
777 if ((idx++ % 4) == 3) { 476 if ((idx++ % 4) == 3) {
778 G4cout << G4endl; 477 G4cout << G4endl;
779 } << 478 } else {
780 else { <<
781 G4cout << ", "; 479 G4cout << ", ";
782 } << 480 }
783 } 481 }
784 G4cout << G4endl; 482 G4cout << G4endl;
785 } 483 }
786 484
787 // ------------------------------------------- << 485
788 void G4VUserPhysicsList::DumpCutValuesTable(G4 << 486
789 { << 487 ///////////////////////////////////////////////////////////////
790 fDisplayThreshold = flag; << 488 void G4VUserPhysicsList::DumpCutValuesTable(G4int nParticles)
>> 489 {
>> 490 fDisplayThreshold = nParticles;
791 } 491 }
792 492
793 // ------------------------------------------- << 493 ///////////////////////////////////////////////////////////////
794 void G4VUserPhysicsList::DumpCutValuesTableIfR 494 void G4VUserPhysicsList::DumpCutValuesTableIfRequested()
795 { 495 {
796 if (fDisplayThreshold == 0) return; << 496 if(fDisplayThreshold==0) return;
797 G4ProductionCutsTable::GetProductionCutsTabl 497 G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
798 fDisplayThreshold = 0; 498 fDisplayThreshold = 0;
799 } 499 }
800 500
801 // ------------------------------------------- << 501
>> 502 ///////////////////////////////////////////////////////////////
>> 503 ///////////////////////////////////////////////////////////////
802 G4bool G4VUserPhysicsList::StorePhysicsTable(c 504 G4bool G4VUserPhysicsList::StorePhysicsTable(const G4String& directory)
803 { 505 {
804 G4bool ascii = fStoredInAscii; << 506 G4bool ascii = fStoredInAscii;
805 G4String dir = directory; << 507 G4String dir = directory;
806 if (dir.empty()) << 508 if (dir.isNull()) dir = directoryPhysicsTable;
807 dir = directoryPhysicsTable; << 509 else directoryPhysicsTable = dir;
808 else << 510
809 directoryPhysicsTable = dir; <<
810 <<
811 // store CutsTable info 511 // store CutsTable info
812 if (!fCutsTable->StoreCutsTable(dir, ascii)) 512 if (!fCutsTable->StoreCutsTable(dir, ascii)) {
813 G4Exception("G4VUserPhysicsList::StorePhys << 513 G4Exception("G4VUserPhysicsList::StorePhysicsTable","Faile to store ",
814 "Fail to store Cut Table"); << 514 JustWarning,"Cut Table can not be stored");
815 return false; 515 return false;
816 } 516 }
817 #ifdef G4VERBOSE << 517 #ifdef G4VERBOSE
818 if (verboseLevel > 2) { << 518 if (verboseLevel>2){
819 G4cout << "G4VUserPhysicsList::StorePhysic << 519 G4cout << "G4VUserPhysicsList::StorePhysicsTable ";
820 << " Store material and cut values << 520 G4cout << " Store material and cut values successfully" << G4endl;
821 } 521 }
822 #endif 522 #endif
823 523
824 G4bool success = true; << 524 G4bool success= true;
825 525
826 // loop over all particles in G4ParticleTabl << 526 // loop over all particles in G4ParticleTable
827 theParticleIterator->reset(); 527 theParticleIterator->reset();
828 while ((*theParticleIterator)()) { << 528 while( (*theParticleIterator)() ){
829 G4ParticleDefinition* particle = thePartic 529 G4ParticleDefinition* particle = theParticleIterator->value();
830 // Store physics tables for every process 530 // Store physics tables for every process for this particle type
831 G4ProcessVector* pVector = (particle->GetP 531 G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
832 for (G4int j = 0; j < (G4int)pVector->size << 532 G4int j;
833 if (!(*pVector)[j]->StorePhysicsTable(pa << 533 for ( j=0; j < pVector->size(); ++j) {
834 G4String comment = "Fail to store phys << 534 if (!(*pVector)[j]->StorePhysicsTable(particle,dir,ascii)){
835 comment += (*pVector)[j]->GetProcessNa << 535 G4String comment = "Fail to store for " + (*pVector)[j]->GetProcessName();
836 comment += "(" + particle->GetParticle << 536 comment += "(" + particle->GetParticleName() + ")";
837 G4Exception("G4VUserPhysicsList::Store << 537 G4Exception("G4VUserPhysicsList::StorePhysicsTable","Faile to store ",
838 success = false; << 538 JustWarning,comment);
>> 539 success = false;
839 } 540 }
840 } 541 }
841 // end loop over processes 542 // end loop over processes
842 } 543 }
843 // end loop over particles 544 // end loop over particles
844 return success; 545 return success;
845 } 546 }
846 547
847 // ------------------------------------------- << 548
848 void G4VUserPhysicsList::SetPhysicsTableRetrie << 549
>> 550 ///////////////////////////////////////////////////////////////
>> 551 void G4VUserPhysicsList::SetPhysicsTableRetrieved(const G4String& directory)
849 { 552 {
850 fRetrievePhysicsTable = true; 553 fRetrievePhysicsTable = true;
851 if (!directory.empty()) { << 554 if(!directory.isNull()) {
852 directoryPhysicsTable = directory; 555 directoryPhysicsTable = directory;
853 } 556 }
854 fIsCheckedForRetrievePhysicsTable = false; << 557 fIsCheckedForRetrievePhysicsTable=false;
855 fIsRestoredCutValues = false; 558 fIsRestoredCutValues = false;
856 } 559 }
857 560
858 // ------------------------------------------- << 561 ///////////////////////////////////////////////////////////////
859 void G4VUserPhysicsList::RetrievePhysicsTable( << 562 void G4VUserPhysicsList::RetrievePhysicsTable(G4ParticleDefinition* particle,
860 << 563 const G4String& directory,
>> 564 G4bool ascii)
861 { 565 {
862 G4bool success[100]; << 566 G4int j;
>> 567 G4bool success[100];
863 // Retrieve physics tables for every process 568 // Retrieve physics tables for every process for this particle type
864 G4ProcessVector* pVector = (particle->GetPro 569 G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
865 for (G4int j = 0; j < (G4int)pVector->size() << 570 for ( j=0; j < pVector->size(); ++j) {
866 success[j] = (*pVector)[j]->RetrievePhysic << 571 success[j] =
>> 572 (*pVector)[j]->RetrievePhysicsTable(particle,directory,ascii);
867 573
868 if (!success[j]) { 574 if (!success[j]) {
869 #ifdef G4VERBOSE << 575 #ifdef G4VERBOSE
870 if (verboseLevel > 2) { << 576 if (verboseLevel>2){
871 G4cout << "G4VUserPhysicsList::Retriev << 577 G4cout << "G4VUserPhysicsList::RetrievePhysicsTable ";
872 << " Fail to retrieve Physics T << 578 G4cout << " Fail to retrieve Physics Table for ";
873 << G4endl; << 579 G4cout << (*pVector)[j]->GetProcessName() << G4endl;
874 G4cout << "Calculate Physics Table for << 580 G4cout << "Calculate Physics Table for " << particle->GetParticleName() << G4endl;
875 } 581 }
876 #endif 582 #endif
877 (*pVector)[j]->BuildPhysicsTable(*partic 583 (*pVector)[j]->BuildPhysicsTable(*particle);
878 } 584 }
879 } 585 }
880 for (G4int j = 0; j < (G4int)pVector->size() << 586 for ( j=0; j < pVector->size(); ++j) {
881 // temporary addition to make the integral 587 // temporary addition to make the integral schema
882 if (!success[j]) BuildIntegralPhysicsTable << 588 if (!success[j]) BuildIntegralPhysicsTable((*pVector)[j], particle);
883 } 589 }
884 } 590 }
885 591
886 // ------------------------------------------- << 592 void G4VUserPhysicsList::ResetCuts()
>> 593 {
>> 594 #ifdef G4VERBOSE
>> 595 if (verboseLevel>0){
>> 596 G4cout << "G4VUserPhysicsList::ResetCuts() is obsolete.";
>> 597 G4cout << " This method gives no effect and you can remove it. "<< G4endl;
>> 598 }
>> 599 #endif
>> 600 }
>> 601
887 void G4VUserPhysicsList::SetApplyCuts(G4bool v 602 void G4VUserPhysicsList::SetApplyCuts(G4bool value, const G4String& name)
888 { 603 {
889 #ifdef G4VERBOSE << 604 #ifdef G4VERBOSE
890 if (verboseLevel > 2) { << 605 if (verboseLevel>2){
891 G4cout << "G4VUserPhysicsList::SetApplyCut 606 G4cout << "G4VUserPhysicsList::SetApplyCuts for " << name << G4endl;
892 } 607 }
893 #endif 608 #endif
894 if (name == "all") { << 609 if(name=="all") {
895 theParticleTable->FindParticle("gamma")->S 610 theParticleTable->FindParticle("gamma")->SetApplyCutsFlag(value);
896 theParticleTable->FindParticle("e-")->SetA 611 theParticleTable->FindParticle("e-")->SetApplyCutsFlag(value);
897 theParticleTable->FindParticle("e+")->SetA 612 theParticleTable->FindParticle("e+")->SetApplyCutsFlag(value);
898 theParticleTable->FindParticle("proton")-> << 613 } else {
899 } <<
900 else { <<
901 theParticleTable->FindParticle(name)->SetA 614 theParticleTable->FindParticle(name)->SetApplyCutsFlag(value);
902 } 615 }
903 } 616 }
904 617
905 // ------------------------------------------- <<
906 G4bool G4VUserPhysicsList::GetApplyCuts(const 618 G4bool G4VUserPhysicsList::GetApplyCuts(const G4String& name) const
907 { 619 {
908 return theParticleTable->FindParticle(name)- 620 return theParticleTable->FindParticle(name)->GetApplyCutsFlag();
909 } 621 }
910 622
911 // ------------------------------------------- <<
912 void G4VUserPhysicsList::CheckParticleList() <<
913 { <<
914 if (!fDisableCheckParticleList) { <<
915 G4MT_thePLHelper->CheckParticleList(); <<
916 } <<
917 } <<
918 <<
919 // ------------------------------------------- <<
920 void G4VUserPhysicsList::AddTransportation() <<
921 { <<
922 G4MT_thePLHelper->AddTransportation(); <<
923 } <<
924 623
925 // ------------------------------------------- <<
926 void G4VUserPhysicsList::UseCoupledTransportat <<
927 { <<
928 G4MT_thePLHelper->UseCoupledTransportation(v <<
929 } <<
930 624
931 // ------------------------------------------- <<
932 G4bool G4VUserPhysicsList::RegisterProcess(G4V <<
933 { <<
934 return G4MT_thePLHelper->RegisterProcess(pro <<
935 } <<
936 625
937 // ------------------------------------------- <<
938 G4ParticleTable::G4PTblDicIterator* G4VUserPhy <<
939 { <<
940 return (subInstanceManager.offset[g4vuplInst <<
941 } <<
942 626
943 // ------------------------------------------- <<
944 void G4VUserPhysicsList::SetVerboseLevel(G4int <<
945 { <<
946 verboseLevel = value; <<
947 // set verboseLevel for G4ProductionCutsTabl <<
948 // G4VUserPhysicsList: <<
949 fCutsTable->SetVerboseLevel(verboseLevel); <<
950 <<
951 G4MT_thePLHelper->SetVerboseLevel(verboseLev <<
952 627
953 #ifdef G4VERBOSE <<
954 if (verboseLevel > 1) { <<
955 G4cout << "G4VUserPhysicsList::SetVerboseL <<
956 << " Verbose level is set to " << v <<
957 } <<
958 #endif <<
959 } <<
960 628