Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4PhysicsListHelper.cc
Go to the documentation of this file.
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// G4PhysicsListHelper implementation
27//
28// Author: H.Kurashige, 29 April 2011
29// --------------------------------------------------------------------
30
31#include "G4PhysicsListHelper.hh"
32
33#include "G4CoupledTransportation.hh"
34#include "G4DecayProcessType.hh"
35#include "G4EmProcessSubType.hh"
36#include "G4HadronicProcessType.hh"
37#include "G4LowEnergyEmProcessSubType.hh"
38#include "G4OpProcessSubType.hh"
39#include "G4ParticleDefinition.hh"
40#include "G4ParticleTable.hh"
41#include "G4ProcessManager.hh"
42#include "G4ProcessType.hh"
43#include "G4RunManagerKernel.hh"
44#include "G4ScoringManager.hh"
45#include "G4Transportation.hh"
46#include "G4TransportationProcessType.hh"
47#include "G4ios.hh"
48#include "globals.hh"
49
50#include <fstream>
51#include <iomanip>
52
53G4ThreadLocal G4PhysicsListHelper* G4PhysicsListHelper::pPLHelper = nullptr;
54
55// --------------------------------------------------------------------
56G4PhysicsListHelper::G4PhysicsListHelper()
57{
58 // pointer to the particle table
59 theParticleTable = G4ParticleTable::GetParticleTable();
60 aParticleIterator = theParticleTable->GetIterator();
61
62 ReadOrdingParameterTable();
63
64#ifdef G4VERBOSE
65 if (verboseLevel > 1) {
66 DumpOrdingParameterTable();
67 }
68#endif
69}
70
71// --------------------------------------------------------------------
72G4PhysicsListHelper::~G4PhysicsListHelper()
73{
74 if (theTable != nullptr) {
75 theTable->clear();
76 delete theTable;
77 theTable = nullptr;
78 sizeOfTable = 0;
79 }
80}
81
82// --------------------------------------------------------------------
83G4PhysicsListHelper* G4PhysicsListHelper::GetPhysicsListHelper()
84{
85 if (pPLHelper == nullptr) {
86 static G4ThreadLocalSingleton<G4PhysicsListHelper> inst;
87 pPLHelper = inst.Instance();
88 }
89 return pPLHelper;
90}
91
92// --------------------------------------------------------------------
93void G4PhysicsListHelper::CheckParticleList() const
94{
95 G4bool isElectron = false;
96 G4bool isPositron = false;
97 G4bool isGamma = false;
98 G4bool isProton = false;
99 G4bool isGenericIon = false;
100 G4bool isAnyIon = false;
101 G4bool isAnyChargedBaryon = false;
102 G4bool isEmProc = false;
103
104 // loop over all particles in G4ParticleTable
105 aParticleIterator->reset();
106 while ((*aParticleIterator)()) {
107 G4ParticleDefinition* particle = aParticleIterator->value();
108 G4String name = particle->GetParticleName();
109 // check if any EM process exists
110 if (!isEmProc) {
111 G4ProcessVector* list = particle->GetProcessManager()->GetProcessList();
112 for (G4int idx = 0; idx < (G4int)list->size(); ++idx) {
113 isEmProc = ((*list)[idx])->GetProcessType() == fElectromagnetic;
114 if (isEmProc) break;
115 }
116 }
117
118 if (name == "e-")
119 isElectron = true;
120 else if (name == "e+")
121 isPositron = true;
122 else if (name == "gamma")
123 isGamma = true;
124 else if (name == "GenericIon")
125 isGenericIon = true;
126 else if (name == "proton")
127 isProton = true;
128 else if (particle->GetParticleType() == "nucleus")
129 isAnyIon = true;
130 else if (particle->GetParticleType() == "baryon") {
131 if (particle->GetPDGCharge() != 0.0) isAnyChargedBaryon = true;
132 }
133 }
134
135 if (!isEmProc) return;
136
137 // RULE 1
138 // e+, e- and gamma should exist
139 // if one of them exist
140 G4bool isEmBasic = isElectron || isPositron || isGamma;
141 G4bool isMissingEmBasic = !isElectron || !isPositron || !isGamma;
142 if (isEmBasic && isMissingEmBasic) {
143 G4String missingName = "";
144 if (!isElectron) missingName += "e- ";
145 if (!isPositron) missingName += "e+ ";
146 if (!isGamma) missingName += "gamma ";
147
148#ifdef G4VERBOSE
149 if (verboseLevel > 0) {
150 G4cout << "G4PhysicsListHelper::CheckParticleList: " << missingName << " do not exist "
151 << G4endl;
152 G4cout << " These particle are necessary for basic EM processes" << G4endl;
153 }
154#endif
155 G4Exception("G4PhysicsListHelper::CheckParticleList", "Run0101", FatalException,
156 "Missing EM basic particle");
157 }
158
159 // RULE 2
160 // proton should exist
161 // if any other charged baryon exist
162 if (!isProton && isAnyChargedBaryon) {
163 G4String missingName = "proton ";
164
165#ifdef G4VERBOSE
166 if (verboseLevel > 0) {
167 G4cout << "G4PhysicsListHelper::CheckParticleList: " << missingName << " does not exist "
168 << G4endl;
169 G4cout << " Proton is necessary for EM baryon processes" << G4endl;
170 }
171#endif
172 missingName += " should be created ";
173 G4Exception("G4PhysicsListHelper::CheckParticleList", "Run0102", FatalException,
174 "Missing Proton");
175 }
176
177 // RULE 3
178 // GenericIonn should exist
179 // if any other ion exist
180 if (!isGenericIon && isAnyIon) {
181 G4String missingName = "GenericIon ";
182
183#ifdef G4VERBOSE
184 if (verboseLevel > 0) {
185 G4cout << "G4PhysicsListHelper::CheckParticleList: " << missingName << " does not exist "
186 << G4endl;
187 G4cout << " GenericIon should be created if any ion is necessary" << G4endl;
188 }
189#endif
190 G4Exception("G4PhysicsListHelper::CheckParticleList", "Run0103", FatalException,
191 "Missing GenericIon");
192 }
193}
194
195// --------------------------------------------------------------------
196void G4PhysicsListHelper::AddTransportation()
197{
198 G4int verboseLevelTransport = 0;
199
200#ifdef G4VERBOSE
201 if (verboseLevel > 2) {
202 G4cout << "G4PhysicsListHelper::AddTransportation() " << G4endl;
203 }
204#endif
205
206 G4int nParaWorld = G4RunManagerKernel::GetRunManagerKernel()->GetNumberOfParallelWorld();
207
208 if (nParaWorld > 0 || useCoupledTransportation
209 || (G4ScoringManager::GetScoringManagerIfExist() != nullptr))
210 {
211 auto coupledTransport = new G4CoupledTransportation(verboseLevelTransport);
212 if (theLooperThresholds == 0) coupledTransport->SetLowLooperThresholds();
213 if (theLooperThresholds == 2) coupledTransport->SetHighLooperThresholds();
214 theTransportationProcess = coupledTransport;
215
216 if (verboseLevel > 0) {
217 G4cout << "--- G4CoupledTransportation is used " << G4endl;
218 }
219 }
220 else {
221 auto simpleTransport = new G4Transportation(verboseLevelTransport);
222 if (theLooperThresholds == 0) simpleTransport->SetLowLooperThresholds();
223 if (theLooperThresholds == 2) simpleTransport->SetHighLooperThresholds();
224 theTransportationProcess = simpleTransport;
225 }
226
227 // loop over all particles in G4ParticleTable
228 aParticleIterator->reset();
229 while ((*aParticleIterator)()) {
230 G4ParticleDefinition* particle = aParticleIterator->value();
231 G4ProcessManager* pmanager = particle->GetProcessManager();
232 // Add transportation process for all particles
233 if (pmanager == nullptr) {
234 // Error !! no process manager
235#ifdef G4VERBOSE
236 if (verboseLevel > 0) {
237 G4cout << "G4PhysicsListHelper::AddTransportation "
238 << " : No Process Manager for " << particle->GetParticleName() << G4endl;
239 }
240#endif
241 G4Exception("G4PhysicsListHelper::AddTransportation", "Run0104", FatalException,
242 "No process manager");
243 continue;
244 }
245 // Molecule use different type transportation
246 if (particle->GetParticleType() == "Molecule") continue;
247
248 // add transportation with ordering = ( -1, "first", "first" )
249 pmanager->AddProcess(theTransportationProcess);
250 pmanager->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
251 pmanager->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
252 }
253}
254
255// --------------------------------------------------------------------
256void G4PhysicsListHelper::ReadOrdingParameterTable()
257{
258 std::ifstream fIn;
259
260 // create OrdParamTable
261 if (theTable != nullptr) {
262 theTable->clear();
263 delete theTable;
264 theTable = nullptr;
265 sizeOfTable = 0;
266 }
267 theTable = new G4OrdParamTable();
268 sizeOfTable = 0;
269
270 ReadInDefaultOrderingParameter();
271
272 if (sizeOfTable == 0) {
273#ifdef G4VERBOSE
274 if (verboseLevel > 0) {
275 G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable "
276 << " Empty file " << ordParamFileName << G4endl;
277 }
278#endif
279 G4Exception("G4PhysicsListHelper::ReadOrdingParameterTable", "Run0106", JustWarning,
280 "The ordering parameter table is empty ");
281 delete theTable;
282 theTable = nullptr;
283 }
284 return;
285}
286
287// --------------------------------------------------------------------
288void G4PhysicsListHelper::DumpOrdingParameterTable(G4int subType) const
289{
290 if (theTable == nullptr) {
291#ifdef G4VERBOSE
292 if (verboseLevel > 0) {
293 G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable "
294 << " No ordering parameter table : " << ordParamFileName << G4endl;
295 }
296#endif
297 return;
298 }
299 G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable : " << ordParamFileName << G4endl;
300 G4cout << " TypeName "
301 << " ProcessType"
302 << " SubType"
303 << " AtRest"
304 << " AlongStep"
305 << " PostStep"
306 << " Duplicable" << G4endl;
307 for (G4int i = 0; i < sizeOfTable; ++i) {
308 G4PhysicsListOrderingParameter* tmp = &(theTable->at(i));
309 if ((subType >= 0) && (subType != tmp->processSubType)) continue;
310 G4cout << std::setw(18) << tmp->processTypeName << std::setw(15) << tmp->processType
311 << std::setw(15) << tmp->processSubType << std::setw(15) << tmp->ordering[0]
312 << std::setw(15) << tmp->ordering[1] << std::setw(15) << tmp->ordering[2];
313 if (tmp->isDuplicable) {
314 G4cout << " true";
315 }
316 else {
317 G4cout << " false";
318 }
319 G4cout << G4endl;
320 }
321}
322
323// --------------------------------------------------------------------
324G4PhysicsListOrderingParameter G4PhysicsListHelper::GetOrdingParameter(G4int subType) const
325{
326 G4PhysicsListOrderingParameter value;
327
328 if (theTable == nullptr) {
329#ifdef G4VERBOSE
330 if (verboseLevel > 0) {
331 G4cout << "G4PhysicsListHelper::GetOrderingParameter : "
332 << " No ordering parameter table : " << ordParamFileName << G4endl;
333 }
334#endif
335 return value;
336 }
337
338 for (G4int i = 0; i < sizeOfTable; ++i) {
339 G4PhysicsListOrderingParameter* tmp = &(theTable->at(i));
340 if (subType == tmp->processSubType) {
341 value.processTypeName = tmp->processTypeName;
342 value.processType = tmp->processType;
343 value.processSubType = tmp->processSubType;
344 value.ordering[0] = tmp->ordering[0];
345 value.ordering[1] = tmp->ordering[1];
346 value.ordering[2] = tmp->ordering[2];
347 value.isDuplicable = tmp->isDuplicable;
348 }
349 }
350 return value;
351}
352
353// --------------------------------------------------------------------
354G4bool G4PhysicsListHelper::RegisterProcess(G4VProcess* process, G4ParticleDefinition* particle)
355{
356 if (theTable == nullptr) {
357#ifdef G4VERBOSE
358 if (verboseLevel > 0) {
359 G4cout << "G4PhysicsListHelper::RegisterProcess :"
360 << " No ordering parameter table : " << ordParamFileName << G4endl;
361 }
362#endif
363 G4Exception("G4PhysicsListHelper::RegisterProcess", "Run0107", FatalException,
364 "No Ordering Parameter Table");
365 return false;
366 }
367
368 const G4String pName = process->GetProcessName();
369 const G4int pType = process->GetProcessType();
370 const G4int pSubType = process->GetProcessSubType();
371
372#ifdef G4VERBOSE
373 if (verboseLevel > 2) {
374 G4cout << "G4PhysicsListHelper::RegisterProcess :" << pName << " Process Type = " << pType
375 << " SubType = " << pSubType << " to " << particle->GetParticleName() << G4endl;
376 }
377#endif
378
379 // Check Process Type/SubType
380 if ((pType < 1) || (pSubType < 1)) {
381#ifdef G4VERBOSE
382 if (verboseLevel > 0) {
383 G4cout << "G4PhysicsListHelper::RegisterProcess :" << pName << " for "
384 << particle->GetParticleName() << " has illegal Process Type = " << pType
385 << " SubType = " << pSubType << G4endl;
386 }
387#endif
388 G4Exception("G4PhysicsListHelper::RegisterProcess", "Run0108", FatalException,
389 "No Matching process Type/SubType");
390 return false;
391 }
392
393 G4bool isFound = false;
394 G4int ord[3];
395 G4bool duplicable = false;
396 for (G4int i = 0; i < sizeOfTable; ++i) {
397 G4PhysicsListOrderingParameter* tmp = &(theTable->at(i));
398 if ((tmp->processType == pType) && (tmp->processSubType == pSubType)) {
399 ord[0] = tmp->ordering[0];
400 ord[1] = tmp->ordering[1];
401 ord[2] = tmp->ordering[2];
402 duplicable = tmp->isDuplicable;
403 isFound = true;
404 break;
405 }
406 }
407 if (!isFound) {
408#ifdef G4VERBOSE
409 if (verboseLevel > 0) {
410 G4cout << "G4PhysicsListHelper::RegisterProcess :" << pName << " for "
411 << particle->GetParticleName() << " with type/subtype =" << pType << "/" << pSubType
412 << " is not registered in OrdingParameterTable " << G4endl;
413 }
414#endif
415 G4Exception("G4PhysicsListHelper::RegisterProcess", "Run0109", FatalException,
416 "No Matching process Type/SubType");
417 return false;
418 }
419
420 // Check Process Manager
421 G4ProcessManager* pManager = particle->GetProcessManager();
422 if (pManager == nullptr) {
423 // Error !! no process manager
424#ifdef G4VERBOSE
425 if (verboseLevel > 0) {
426 G4cout << "G4PhysicsListHelper::RegisterProcess "
427 << " : No Process Manager for " << particle->GetParticleName() << G4endl;
428 }
429#endif
430 G4Exception("G4PhysicsListHelper::RegisterProcess ", "Riun0110", FatalException,
431 "No process manager");
432 return false;
433 }
434
435 // Check Duplication
436 if (!duplicable) {
437 G4bool duplicated = false;
438 G4ProcessVector* pList = pManager->GetProcessList();
439 for (G4int idx = 0; idx < (G4int)pList->size(); ++idx) {
440 const G4VProcess* p = (*pList)[idx];
441 if ((p->GetProcessType() == pType) && (p->GetProcessSubType() == pSubType)) {
442 duplicated = true;
443#ifdef G4VERBOSE
444 if (verboseLevel > 0) {
445 G4cout << "G4PhysicsListHelper::RegisterProcess :" << pName << " for "
446 << particle->GetParticleName() << " with type/subtype =" << pType << "/"
447 << pSubType << " is has same subType as " << p->GetProcessName() << " for "
448 << particle->GetParticleName() << G4endl;
449 G4cout << "It will not be added !!" << G4endl;
450 }
451#endif
452 G4Exception("G4PhysicsListHelper::RegisterProcess", "Run0111", JustWarning,
453 "Duplication of processes");
454 }
455 }
456 if (duplicated) return false;
457 }
458
459 // Add Process
460 G4int code = pManager->AddProcess(process);
461 if (code < 0) return false;
462
463 // Set Ordering Parameter
464 for (G4int idx = 0; idx < 3; ++idx) {
465 auto idxOrd = static_cast<G4ProcessVectorDoItIndex>(idx);
466 if (ord[idx] < 0) {
467 // Do Nothing because NO DOIT
468 }
469 else if (ord[idx] == 0) {
470 pManager->SetProcessOrderingToFirst(process, idxOrd);
471 }
472 else if (ord[idx] < 9999) {
473 pManager->SetProcessOrdering(process, idxOrd, ord[idx]);
474 }
475 else {
476 pManager->SetProcessOrderingToLast(process, idxOrd);
477 }
478 }
479#ifdef G4VERBOSE
480 if (verboseLevel > 1) {
481 G4cout << "G4PhysicsListHelper::RegisterProcess :" << pName << " for "
482 << particle->GetParticleName() << " with type/subtype =" << pType << "/" << pSubType
483 << " is successfully registered with ordering parameters " << ord[0] << ":" << ord[1]
484 << ":" << ord[2] << G4endl;
485 }
486#endif
487 return true;
488}
489
490// --------------------------------------------------------------------
491void G4PhysicsListHelper::ReadInDefaultOrderingParameter()
492{
493 G4PhysicsListOrderingParameter tmp;
494
495 // NOTE: please use enum values, rather than numerical values,
496 // for both the processType and processSubType below.
497
498 tmp.processTypeName = "Transportation";
499 tmp.processType = fTransportation;
500 tmp.processSubType = TRANSPORTATION;
501 tmp.ordering[0] = -1;
502 tmp.ordering[1] = 0;
503 tmp.ordering[2] = 0;
504 tmp.isDuplicable = false;
505 theTable->push_back(tmp);
506 sizeOfTable += 1;
507
508 tmp.processTypeName = "CoupleTrans";
509 tmp.processType = fTransportation;
510 tmp.processSubType = COUPLED_TRANSPORTATION;
511 tmp.ordering[0] = -1;
512 tmp.ordering[1] = 0;
513 tmp.ordering[2] = 0;
514 tmp.isDuplicable = false;
515 theTable->push_back(tmp);
516 sizeOfTable += 1;
517
518 tmp.processTypeName = "CoulombScat";
519 tmp.processType = fElectromagnetic;
520 tmp.processSubType = fCoulombScattering;
521 tmp.ordering[0] = -1;
522 tmp.ordering[1] = -1;
523 tmp.ordering[2] = 1000;
524 tmp.isDuplicable = false;
525 theTable->push_back(tmp);
526 sizeOfTable += 1;
527
528 tmp.processTypeName = "Ionisation";
529 tmp.processType = fElectromagnetic;
530 tmp.processSubType = fIonisation;
531 tmp.ordering[0] = -1;
532 tmp.ordering[1] = 2;
533 tmp.ordering[2] = 2;
534 tmp.isDuplicable = false;
535 theTable->push_back(tmp);
536 sizeOfTable += 1;
537
538 tmp.processTypeName = "Brems";
539 tmp.processType = fElectromagnetic;
540 tmp.processSubType = fBremsstrahlung;
541 tmp.ordering[0] = -1;
542 tmp.ordering[1] = -1;
543 tmp.ordering[2] = 3;
544 tmp.isDuplicable = false;
545 theTable->push_back(tmp);
546 sizeOfTable += 1;
547
548 tmp.processTypeName = "PairProdCharged";
549 tmp.processType = fElectromagnetic;
550 tmp.processSubType = fPairProdByCharged;
551 tmp.ordering[0] = -1;
552 tmp.ordering[1] = -1;
553 tmp.ordering[2] = 4;
554 tmp.isDuplicable = false;
555 theTable->push_back(tmp);
556 sizeOfTable += 1;
557
558 tmp.processTypeName = "Annih";
559 tmp.processType = fElectromagnetic;
560 tmp.processSubType = fAnnihilation;
561 tmp.ordering[0] = 5;
562 tmp.ordering[1] = -1;
563 tmp.ordering[2] = 5;
564 tmp.isDuplicable = false;
565 theTable->push_back(tmp);
566 sizeOfTable += 1;
567
568 tmp.processTypeName = "AnnihToMuMu";
569 tmp.processType = fElectromagnetic;
570 tmp.processSubType = fAnnihilationToMuMu;
571 tmp.ordering[0] = -1;
572 tmp.ordering[1] = -1;
573 tmp.ordering[2] = 6;
574 tmp.isDuplicable = false;
575 theTable->push_back(tmp);
576 sizeOfTable += 1;
577
578 tmp.processTypeName = "AnnihToTauTau";
579 tmp.processType = fElectromagnetic;
580 tmp.processSubType = fAnnihilationToTauTau;
581 tmp.ordering[0] = -1;
582 tmp.ordering[1] = -1;
583 tmp.ordering[2] = 7;
584 tmp.isDuplicable = false;
585 theTable->push_back(tmp);
586 sizeOfTable += 1;
587
588 tmp.processTypeName = "AnnihToHad";
589 tmp.processType = fElectromagnetic;
590 tmp.processSubType = fAnnihilationToHadrons;
591 tmp.ordering[0] = -1;
592 tmp.ordering[1] = -1;
593 tmp.ordering[2] = 8;
594 tmp.isDuplicable = false;
595 theTable->push_back(tmp);
596 sizeOfTable += 1;
597
598 tmp.processTypeName = "NuclearStopping";
599 tmp.processType = fElectromagnetic;
600 tmp.processSubType = fNuclearStopping;
601 tmp.ordering[0] = -1;
602 tmp.ordering[1] = 9;
603 tmp.ordering[2] = -1;
604 tmp.isDuplicable = false;
605 theTable->push_back(tmp);
606 sizeOfTable += 1;
607
608 tmp.processTypeName = "ElectronGeneral";
609 tmp.processType = fElectromagnetic;
610 tmp.processSubType = fElectronGeneralProcess;
611 tmp.ordering[0] = -1;
612 tmp.ordering[1] = 1;
613 tmp.ordering[2] = 1;
614 tmp.isDuplicable = false;
615 theTable->push_back(tmp);
616 sizeOfTable += 1;
617
618 tmp.processTypeName = "Msc";
619 tmp.processType = fElectromagnetic;
620 tmp.processSubType = fMultipleScattering;
621 tmp.ordering[0] = -1;
622 tmp.ordering[1] = 1;
623 tmp.ordering[2] = -1;
624 tmp.isDuplicable = false;
625 theTable->push_back(tmp);
626 sizeOfTable += 1;
627
628 tmp.processTypeName = "Rayleigh";
629 tmp.processType = fElectromagnetic;
630 tmp.processSubType = fRayleigh;
631 tmp.ordering[0] = -1;
632 tmp.ordering[1] = -1;
633 tmp.ordering[2] = 1000;
634 tmp.isDuplicable = false;
635 theTable->push_back(tmp);
636 sizeOfTable += 1;
637
638 tmp.processTypeName = "PhotoElectric";
639 tmp.processType = fElectromagnetic;
640 tmp.processSubType = fPhotoElectricEffect;
641 tmp.ordering[0] = -1;
642 tmp.ordering[1] = -1;
643 tmp.ordering[2] = 1000;
644 tmp.isDuplicable = false;
645 theTable->push_back(tmp);
646 sizeOfTable += 1;
647
648 tmp.processTypeName = "Compton";
649 tmp.processType = fElectromagnetic;
650 tmp.processSubType = fComptonScattering;
651 tmp.ordering[0] = -1;
652 tmp.ordering[1] = -1;
653 tmp.ordering[2] = 1000;
654 tmp.isDuplicable = false;
655 theTable->push_back(tmp);
656 sizeOfTable += 1;
657
658 tmp.processTypeName = "Conv";
659 tmp.processType = fElectromagnetic;
660 tmp.processSubType = fGammaConversion;
661 tmp.ordering[0] = -1;
662 tmp.ordering[1] = -1;
663 tmp.ordering[2] = 1000;
664 tmp.isDuplicable = false;
665 theTable->push_back(tmp);
666 sizeOfTable += 1;
667
668 tmp.processTypeName = "ConvToMuMu";
669 tmp.processType = fElectromagnetic;
670 tmp.processSubType = fGammaConversionToMuMu;
671 tmp.ordering[0] = -1;
672 tmp.ordering[1] = -1;
673 tmp.ordering[2] = 1000;
674 tmp.isDuplicable = false;
675 theTable->push_back(tmp);
676 sizeOfTable += 1;
677
678 tmp.processTypeName = "GammaGeneral";
679 tmp.processType = fElectromagnetic;
680 tmp.processSubType = fGammaGeneralProcess;
681 tmp.ordering[0] = -1;
682 tmp.ordering[1] = -1;
683 tmp.ordering[2] = 1000;
684 tmp.isDuplicable = false;
685 theTable->push_back(tmp);
686 sizeOfTable += 1;
687
688 tmp.processTypeName = "PositronGeneral";
689 tmp.processType = fElectromagnetic;
690 tmp.processSubType = fPositronGeneralProcess;
691 tmp.ordering[0] = 1;
692 tmp.ordering[1] = 1;
693 tmp.ordering[2] = 1;
694 tmp.isDuplicable = false;
695 theTable->push_back(tmp);
696 sizeOfTable += 1;
697
698 tmp.processTypeName = "MuPairByMuon";
699 tmp.processType = fElectromagnetic;
700 tmp.processSubType = fMuonPairProdByCharged;
701 tmp.ordering[0] = -1;
702 tmp.ordering[1] = -1;
703 tmp.ordering[2] = 10;
704 tmp.isDuplicable = false;
705 theTable->push_back(tmp);
706 sizeOfTable += 1;
707
708 tmp.processTypeName = "Cerenkov";
709 tmp.processType = fElectromagnetic;
710 tmp.processSubType = fCerenkov;
711 tmp.ordering[0] = -1;
712 tmp.ordering[1] = -1;
713 tmp.ordering[2] = 1000;
714 tmp.isDuplicable = false;
715 theTable->push_back(tmp);
716 sizeOfTable += 1;
717
718 tmp.processTypeName = "Scintillation";
719 tmp.processType = fElectromagnetic;
720 tmp.processSubType = fScintillation;
721 tmp.ordering[0] = 9999;
722 tmp.ordering[1] = -1;
723 tmp.ordering[2] = 9999;
724 tmp.isDuplicable = false;
725 theTable->push_back(tmp);
726 sizeOfTable += 1;
727
728 tmp.processTypeName = "SynchRad";
729 tmp.processType = fElectromagnetic;
730 tmp.processSubType = fSynchrotronRadiation;
731 tmp.ordering[0] = -1;
732 tmp.ordering[1] = -1;
733 tmp.ordering[2] = 1000;
734 tmp.isDuplicable = false;
735 theTable->push_back(tmp);
736 sizeOfTable += 1;
737
738 tmp.processTypeName = "TransRad";
739 tmp.processType = fElectromagnetic;
740 tmp.processSubType = fTransitionRadiation;
741 tmp.ordering[0] = -1;
742 tmp.ordering[1] = -1;
743 tmp.ordering[2] = 1000;
744 tmp.isDuplicable = false;
745 theTable->push_back(tmp);
746 sizeOfTable += 1;
747
748 tmp.processTypeName = "SurfaceRefl";
749 tmp.processType = fElectromagnetic;
750 tmp.processSubType = fSurfaceReflection;
751 tmp.ordering[0] = -1;
752 tmp.ordering[1] = -1;
753 tmp.ordering[2] = 1000;
754 tmp.isDuplicable = false;
755 theTable->push_back(tmp);
756 sizeOfTable += 1;
757
758 tmp.processTypeName = "OpAbsorb";
759 tmp.processType = fOptical;
760 tmp.processSubType = fOpAbsorption;
761 tmp.ordering[0] = -1;
762 tmp.ordering[1] = -1;
763 tmp.ordering[2] = 1000;
764 tmp.isDuplicable = false;
765 theTable->push_back(tmp);
766 sizeOfTable += 1;
767
768 tmp.processTypeName = "OpBoundary";
769 tmp.processType = fOptical;
770 tmp.processSubType = fOpBoundary;
771 tmp.ordering[0] = -1;
772 tmp.ordering[1] = -1;
773 tmp.ordering[2] = 1000;
774 tmp.isDuplicable = false;
775 theTable->push_back(tmp);
776 sizeOfTable += 1;
777
778 tmp.processTypeName = "OpRayleigh";
779 tmp.processType = fOptical;
780 tmp.processSubType = fOpRayleigh;
781 tmp.ordering[0] = -1;
782 tmp.ordering[1] = -1;
783 tmp.ordering[2] = 1000;
784 tmp.isDuplicable = false;
785 theTable->push_back(tmp);
786 sizeOfTable += 1;
787
788 tmp.processTypeName = "OpWLS";
789 tmp.processType = fOptical;
790 tmp.processSubType = fOpWLS;
791 tmp.ordering[0] = -1;
792 tmp.ordering[1] = -1;
793 tmp.ordering[2] = 1000;
794 tmp.isDuplicable = false;
795 theTable->push_back(tmp);
796 sizeOfTable += 1;
797
798 tmp.processTypeName = "OpMieHG";
799 tmp.processType = fOptical;
800 tmp.processSubType = fOpMieHG;
801 tmp.ordering[0] = -1;
802 tmp.ordering[1] = -1;
803 tmp.ordering[2] = 1000;
804 tmp.isDuplicable = false;
805 theTable->push_back(tmp);
806 sizeOfTable += 1;
807
808 tmp.processTypeName = "OpWLS2";
809 tmp.processType = fOptical;
810 tmp.processSubType = fOpWLS2;
811 tmp.ordering[0] = -1;
812 tmp.ordering[1] = -1;
813 tmp.ordering[2] = 1000;
814 tmp.isDuplicable = false;
815 theTable->push_back(tmp);
816 sizeOfTable += 1;
817
818 tmp.processTypeName = "DNAElastic";
819 tmp.processType = fElectromagnetic;
820 tmp.processSubType = fLowEnergyElastic;
821 tmp.ordering[0] = -1;
822 tmp.ordering[1] = -1;
823 tmp.ordering[2] = 1000;
824 tmp.isDuplicable = false;
825 theTable->push_back(tmp);
826 sizeOfTable += 1;
827
828 tmp.processTypeName = "DNAExcit";
829 tmp.processType = fElectromagnetic;
830 tmp.processSubType = fLowEnergyExcitation;
831 tmp.ordering[0] = -1;
832 tmp.ordering[1] = -1;
833 tmp.ordering[2] = 1000;
834 tmp.isDuplicable = false;
835 theTable->push_back(tmp);
836 sizeOfTable += 1;
837
838 tmp.processTypeName = "DNAIonisation";
839 tmp.processType = fElectromagnetic;
840 tmp.processSubType = fLowEnergyIonisation;
841 tmp.ordering[0] = -1;
842 tmp.ordering[1] = -1;
843 tmp.ordering[2] = 1000;
844 tmp.isDuplicable = false;
845 theTable->push_back(tmp);
846 sizeOfTable += 1;
847
848 tmp.processTypeName = "DNAVibExcit";
849 tmp.processType = fElectromagnetic;
850 tmp.processSubType = fLowEnergyVibrationalExcitation;
851 tmp.ordering[0] = -1;
852 tmp.ordering[1] = -1;
853 tmp.ordering[2] = 1000;
854 tmp.isDuplicable = false;
855 theTable->push_back(tmp);
856 sizeOfTable += 1;
857
858 tmp.processTypeName = "DNAAttachment";
859 tmp.processType = fElectromagnetic;
860 tmp.processSubType = fLowEnergyAttachment;
861 tmp.ordering[0] = -1;
862 tmp.ordering[1] = -1;
863 tmp.ordering[2] = 1000;
864 tmp.isDuplicable = false;
865 theTable->push_back(tmp);
866 sizeOfTable += 1;
867
868 tmp.processTypeName = "DNAChargeDec";
869 tmp.processType = fElectromagnetic;
870 tmp.processSubType = fLowEnergyChargeDecrease;
871 tmp.ordering[0] = -1;
872 tmp.ordering[1] = -1;
873 tmp.ordering[2] = 1000;
874 tmp.isDuplicable = false;
875 theTable->push_back(tmp);
876 sizeOfTable += 1;
877
878 tmp.processTypeName = "DNAChargeInc";
879 tmp.processType = fElectromagnetic;
880 tmp.processSubType = fLowEnergyChargeIncrease;
881 tmp.ordering[0] = -1;
882 tmp.ordering[1] = -1;
883 tmp.ordering[2] = 1000;
884 tmp.isDuplicable = false;
885 theTable->push_back(tmp);
886 sizeOfTable += 1;
887
888 tmp.processTypeName = "DNAElecSolv";
889 tmp.processType = fElectromagnetic;
890 tmp.processSubType = fLowEnergyElectronSolvation;
891 tmp.ordering[0] = -1;
892 tmp.ordering[1] = -1;
893 tmp.ordering[2] = 1000;
894 tmp.isDuplicable = false;
895 theTable->push_back(tmp);
896 sizeOfTable += 1;
897
898 tmp.processTypeName = "DNAMolecDecay";
899 tmp.processType = fDecay;
900 tmp.processSubType = fLowEnergyMolecularDecay;
901 tmp.ordering[0] = 1000;
902 tmp.ordering[1] = -1;
903 tmp.ordering[2] = -1;
904 tmp.isDuplicable = false;
905 theTable->push_back(tmp);
906 sizeOfTable += 1;
907
908 tmp.processTypeName = "ITTransport";
909 tmp.processType = fTransportation;
910 tmp.processSubType = fLowEnergyTransportation;
911 tmp.ordering[0] = -1;
912 tmp.ordering[1] = 0;
913 tmp.ordering[2] = 0;
914 tmp.isDuplicable = false;
915 theTable->push_back(tmp);
916 sizeOfTable += 1;
917
918 tmp.processTypeName = "DNABrownTrans";
919 tmp.processType = fTransportation;
920 tmp.processSubType = fLowEnergyBrownianTransportation;
921 tmp.ordering[0] = -1;
922 tmp.ordering[1] = 0;
923 tmp.ordering[2] = 0;
924 tmp.isDuplicable = false;
925 theTable->push_back(tmp);
926 sizeOfTable += 1;
927
928 tmp.processTypeName = "DNADoubleIoni";
929 tmp.processType = fElectromagnetic;
930 tmp.processSubType = fLowEnergyDoubleIonisation;
931 tmp.ordering[0] = -1;
932 tmp.ordering[1] = -1;
933 tmp.ordering[2] = 1000;
934 tmp.isDuplicable = false;
935 theTable->push_back(tmp);
936 sizeOfTable += 1;
937
938 tmp.processTypeName = "DNADoubleCap";
939 tmp.processType = fElectromagnetic;
940 tmp.processSubType = fLowEnergyDoubleCap;
941 tmp.ordering[0] = -1;
942 tmp.ordering[1] = -1;
943 tmp.ordering[2] = 1000;
944 tmp.isDuplicable = false;
945 theTable->push_back(tmp);
946 sizeOfTable += 1;
947
948 tmp.processTypeName = "DNAIoniTransfer";
949 tmp.processType = fElectromagnetic;
950 tmp.processSubType = fLowEnergyIoniTransfer;
951 tmp.ordering[0] = -1;
952 tmp.ordering[1] = -1;
953 tmp.ordering[2] = 1000;
954 tmp.isDuplicable = false;
955 theTable->push_back(tmp);
956 sizeOfTable += 1;
957
958 tmp.processTypeName = "DNAStaticMol";
959 tmp.processType = fUserDefined;
960 tmp.processSubType = fLowEnergyStaticMol;
961 tmp.ordering[0] = -1;
962 tmp.ordering[1] = -1;
963 tmp.ordering[2] = 1000;
964 tmp.isDuplicable = false;
965 theTable->push_back(tmp);
966 sizeOfTable += 1;
967
968 tmp.processTypeName = "DNAScavenger";
969 tmp.processType = fUserDefined;
970 tmp.processSubType = fLowEnergyScavenger;
971 tmp.ordering[0] = -1;
972 tmp.ordering[1] = -1;
973 tmp.ordering[2] = 1000;
974 tmp.isDuplicable = false;
975 theTable->push_back(tmp);
976 sizeOfTable += 1;
977
978 tmp.processTypeName = "HadElastic";
979 tmp.processType = fHadronic;
980 tmp.processSubType = fHadronElastic;
981 tmp.ordering[0] = -1;
982 tmp.ordering[1] = -1;
983 tmp.ordering[2] = 1000;
984 tmp.isDuplicable = false;
985 theTable->push_back(tmp);
986 sizeOfTable += 1;
987
988 tmp.processTypeName = "NeutronGeneral";
989 tmp.processType = fHadronic;
990 tmp.processSubType = fNeutronGeneral;
991 tmp.ordering[0] = -1;
992 tmp.ordering[1] = -1;
993 tmp.ordering[2] = 1000;
994 tmp.isDuplicable = false;
995 theTable->push_back(tmp);
996 sizeOfTable += 1;
997
998 tmp.processTypeName = "HadInelastic";
999 tmp.processType = fHadronic;
1000 tmp.processSubType = fHadronInelastic;
1001 tmp.ordering[0] = -1;
1002 tmp.ordering[1] = -1;
1003 tmp.ordering[2] = 1000;
1004 tmp.isDuplicable = false;
1005 theTable->push_back(tmp);
1006 sizeOfTable += 1;
1007
1008 tmp.processTypeName = "HadCapture";
1009 tmp.processType = fHadronic;
1010 tmp.processSubType = fCapture;
1011 tmp.ordering[0] = -1;
1012 tmp.ordering[1] = -1;
1013 tmp.ordering[2] = 1000;
1014 tmp.isDuplicable = false;
1015 theTable->push_back(tmp);
1016 sizeOfTable += 1;
1017
1018 tmp.processTypeName = "MuAtomCapture";
1019 tmp.processType = fHadronic;
1020 tmp.processSubType = fMuAtomicCapture;
1021 tmp.ordering[0] = -1;
1022 tmp.ordering[1] = -1;
1023 tmp.ordering[2] = 1000;
1024 tmp.isDuplicable = false;
1025 theTable->push_back(tmp);
1026 sizeOfTable += 1;
1027
1028 tmp.processTypeName = "HadFission";
1029 tmp.processType = fHadronic;
1030 tmp.processSubType = fFission;
1031 tmp.ordering[0] = -1;
1032 tmp.ordering[1] = -1;
1033 tmp.ordering[2] = 1000;
1034 tmp.isDuplicable = false;
1035 theTable->push_back(tmp);
1036 sizeOfTable += 1;
1037
1038 tmp.processTypeName = "HadAtRest";
1039 tmp.processType = fHadronic;
1040 tmp.processSubType = fHadronAtRest;
1041 tmp.ordering[0] = 1000;
1042 tmp.ordering[1] = -1;
1043 tmp.ordering[2] = -1;
1044 tmp.isDuplicable = false;
1045 theTable->push_back(tmp);
1046 sizeOfTable += 1;
1047
1048 tmp.processTypeName = "HadCEX";
1049 tmp.processType = fHadronic;
1050 tmp.processSubType = fChargeExchange;
1051 tmp.ordering[0] = -1;
1052 tmp.ordering[1] = -1;
1053 tmp.ordering[2] = 1000;
1054 tmp.isDuplicable = false;
1055 theTable->push_back(tmp);
1056 sizeOfTable += 1;
1057
1058 tmp.processTypeName = "Decay";
1059 tmp.processType = fDecay;
1060 tmp.processSubType = DECAY;
1061 tmp.ordering[0] = 1000;
1062 tmp.ordering[1] = -1;
1063 tmp.ordering[2] = 1000;
1064 tmp.isDuplicable = false;
1065 theTable->push_back(tmp);
1066 sizeOfTable += 1;
1067
1068 tmp.processTypeName = "DecayWSpin";
1069 tmp.processType = fDecay;
1070 tmp.processSubType = DECAY_WithSpin;
1071 tmp.ordering[0] = 1000;
1072 tmp.ordering[1] = -1;
1073 tmp.ordering[2] = 1000;
1074 tmp.isDuplicable = false;
1075 theTable->push_back(tmp);
1076 sizeOfTable += 1;
1077
1078 tmp.processTypeName = "DecayPiSpin";
1079 tmp.processType = fDecay;
1080 tmp.processSubType = DECAY_PionMakeSpin;
1081 tmp.ordering[0] = 1000;
1082 tmp.ordering[1] = -1;
1083 tmp.ordering[2] = 1000;
1084 tmp.isDuplicable = false;
1085 theTable->push_back(tmp);
1086 sizeOfTable += 1;
1087
1088 tmp.processTypeName = "DecayRadio";
1089 tmp.processType = fDecay;
1090 tmp.processSubType = DECAY_Radioactive;
1091 tmp.ordering[0] = 1000;
1092 tmp.ordering[1] = -1;
1093 tmp.ordering[2] = 1000;
1094 tmp.isDuplicable = false;
1095 theTable->push_back(tmp);
1096 sizeOfTable += 1;
1097
1098 tmp.processTypeName = "DecayUnKnown";
1099 tmp.processType = fDecay;
1100 tmp.processSubType = DECAY_Unknown;
1101 tmp.ordering[0] = -1;
1102 tmp.ordering[1] = -1;
1103 tmp.ordering[2] = 1000;
1104 tmp.isDuplicable = false;
1105 theTable->push_back(tmp);
1106 sizeOfTable += 1;
1107
1108 tmp.processTypeName = "DecayMuAtom";
1109 tmp.processType = fDecay;
1110 tmp.processSubType = DECAY_MuAtom;
1111 tmp.ordering[0] = 1000;
1112 tmp.ordering[1] = -1;
1113 tmp.ordering[2] = 1000;
1114 tmp.isDuplicable = false;
1115 theTable->push_back(tmp);
1116 sizeOfTable += 1;
1117
1118 tmp.processTypeName = "DecayExt";
1119 tmp.processType = fDecay;
1120 tmp.processSubType = DECAY_External;
1121 tmp.ordering[0] = 1000;
1122 tmp.ordering[1] = -1;
1123 tmp.ordering[2] = 1000;
1124 tmp.isDuplicable = false;
1125 theTable->push_back(tmp);
1126 sizeOfTable += 1;
1127
1128 tmp.processTypeName = "StepLimiter";
1129 tmp.processType = fGeneral;
1130 tmp.processSubType = STEP_LIMITER;
1131 tmp.ordering[0] = -1;
1132 tmp.ordering[1] = -1;
1133 tmp.ordering[2] = 1000;
1134 tmp.isDuplicable = false;
1135 theTable->push_back(tmp);
1136 sizeOfTable += 1;
1137
1138 tmp.processTypeName = "UsrSepcCuts";
1139 tmp.processType = fGeneral;
1140 tmp.processSubType = USER_SPECIAL_CUTS;
1141 tmp.ordering[0] = -1;
1142 tmp.ordering[1] = -1;
1143 tmp.ordering[2] = 1000;
1144 tmp.isDuplicable = false;
1145 theTable->push_back(tmp);
1146 sizeOfTable += 1;
1147
1148 tmp.processTypeName = "NeutronKiller";
1149 tmp.processType = fGeneral;
1150 tmp.processSubType = NEUTRON_KILLER;
1151 tmp.ordering[0] = -1;
1152 tmp.ordering[1] = -1;
1153 tmp.ordering[2] = 1000;
1154 tmp.isDuplicable = false;
1155 theTable->push_back(tmp);
1156 sizeOfTable += 1;
1157
1158 tmp.processTypeName = "ParallelWorld";
1159 tmp.processType = fParallel;
1160 tmp.processSubType = PARALLEL_WORLD_PROCESS;
1161 tmp.ordering[0] = 9900;
1162 tmp.ordering[1] = 1;
1163 tmp.ordering[2] = 9900;
1164 tmp.isDuplicable = true;
1165 theTable->push_back(tmp);
1166 sizeOfTable += 1;
1167}
DECAY_WithSpin
@ DECAY_WithSpin
Definition G4DecayProcessType.hh:45
DECAY_Unknown
@ DECAY_Unknown
Definition G4DecayProcessType.hh:48
DECAY_External
@ DECAY_External
Definition G4DecayProcessType.hh:50
DECAY_MuAtom
@ DECAY_MuAtom
Definition G4DecayProcessType.hh:49
DECAY_PionMakeSpin
@ DECAY_PionMakeSpin
Definition G4DecayProcessType.hh:46
DECAY_Radioactive
@ DECAY_Radioactive
Definition G4DecayProcessType.hh:47
fGammaConversionToMuMu
@ fGammaConversionToMuMu
Definition G4EmProcessSubType.hh:61
fAnnihilationToHadrons
@ fAnnihilationToHadrons
Definition G4EmProcessSubType.hh:51
fBremsstrahlung
@ fBremsstrahlung
Definition G4EmProcessSubType.hh:47
fCoulombScattering
@ fCoulombScattering
Definition G4EmProcessSubType.hh:45
fAnnihilationToTauTau
@ fAnnihilationToTauTau
Definition G4EmProcessSubType.hh:64
fGammaGeneralProcess
@ fGammaGeneralProcess
Definition G4EmProcessSubType.hh:62
fGammaConversion
@ fGammaConversion
Definition G4EmProcessSubType.hh:60
fRayleigh
@ fRayleigh
Definition G4EmProcessSubType.hh:57
fPositronGeneralProcess
@ fPositronGeneralProcess
Definition G4EmProcessSubType.hh:63
fIonisation
@ fIonisation
Definition G4EmProcessSubType.hh:46
fPairProdByCharged
@ fPairProdByCharged
Definition G4EmProcessSubType.hh:48
fSynchrotronRadiation
@ fSynchrotronRadiation
Definition G4EmProcessSubType.hh:68
fCerenkov
@ fCerenkov
Definition G4EmProcessSubType.hh:66
fAnnihilationToMuMu
@ fAnnihilationToMuMu
Definition G4EmProcessSubType.hh:50
fScintillation
@ fScintillation
Definition G4EmProcessSubType.hh:67
fNuclearStopping
@ fNuclearStopping
Definition G4EmProcessSubType.hh:52
fComptonScattering
@ fComptonScattering
Definition G4EmProcessSubType.hh:59
fTransitionRadiation
@ fTransitionRadiation
Definition G4EmProcessSubType.hh:69
fMuonPairProdByCharged
@ fMuonPairProdByCharged
Definition G4EmProcessSubType.hh:74
fElectronGeneralProcess
@ fElectronGeneralProcess
Definition G4EmProcessSubType.hh:53
fAnnihilation
@ fAnnihilation
Definition G4EmProcessSubType.hh:49
fSurfaceReflection
@ fSurfaceReflection
Definition G4EmProcessSubType.hh:72
fMultipleScattering
@ fMultipleScattering
Definition G4EmProcessSubType.hh:55
fPhotoElectricEffect
@ fPhotoElectricEffect
Definition G4EmProcessSubType.hh:58
JustWarning
@ JustWarning
Definition G4ExceptionSeverity.hh:71
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
fNeutronGeneral
@ fNeutronGeneral
Definition G4HadronicProcessType.hh:42
fChargeExchange
@ fChargeExchange
Definition G4HadronicProcessType.hh:49
fMuAtomicCapture
@ fMuAtomicCapture
Definition G4HadronicProcessType.hh:45
fHadronInelastic
@ fHadronInelastic
Definition G4HadronicProcessType.hh:43
fLowEnergyBrownianTransportation
@ fLowEnergyBrownianTransportation
Definition G4LowEnergyEmProcessSubType.hh:55
fLowEnergyVibrationalExcitation
@ fLowEnergyVibrationalExcitation
Definition G4LowEnergyEmProcessSubType.hh:48
fLowEnergyElectronSolvation
@ fLowEnergyElectronSolvation
Definition G4LowEnergyEmProcessSubType.hh:52
fOpRayleigh
@ fOpRayleigh
Definition G4OpProcessSubType.hh:47
fOpAbsorption
@ fOpAbsorption
Definition G4OpProcessSubType.hh:45
fOpBoundary
@ fOpBoundary
Definition G4OpProcessSubType.hh:46
G4ProcessVectorDoItIndex
G4ProcessVectorDoItIndex
Definition G4ProcessManager.hh:77
idxPostStep
@ idxPostStep
Definition G4ProcessManager.hh:81
idxAlongStep
@ idxAlongStep
Definition G4ProcessManager.hh:80
fOptical
@ fOptical
Definition G4ProcessType.hh:42
fParallel
@ fParallel
Definition G4ProcessType.hh:49
fGeneral
@ fGeneral
Definition G4ProcessType.hh:46
fDecay
@ fDecay
Definition G4ProcessType.hh:45
fElectromagnetic
@ fElectromagnetic
Definition G4ProcessType.hh:41
fHadronic
@ fHadronic
Definition G4ProcessType.hh:43
fUserDefined
@ fUserDefined
Definition G4ProcessType.hh:48
fTransportation
@ fTransportation
Definition G4ProcessType.hh:40
G4bool
bool G4bool
Definition G4Types.hh:86
G4int
int G4int
Definition G4Types.hh:85
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition G4ParticleDefinition.cc:218
G4ParticleDefinition::GetParticleType
const G4String & GetParticleType() const
Definition G4ParticleDefinition.hh:118
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition G4ParticleDefinition.hh:96
G4ParticleTableIterator::reset
void reset(G4bool ifSkipIon=true)
Definition G4ParticleTableIterator.hh:73
G4ParticleTable::GetIterator
G4PTblDicIterator * GetIterator() const
Definition G4ParticleTable.cc:598
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition G4ParticleTable.cc:82
G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition G4PhysicsListHelper.cc:354
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition G4PhysicsListHelper.cc:83
G4PhysicsListHelper::DumpOrdingParameterTable
void DumpOrdingParameterTable(G4int subType=-1) const
Definition G4PhysicsListHelper.cc:288
G4PhysicsListHelper::GetOrdingParameter
G4PhysicsListOrderingParameter GetOrdingParameter(G4int subType) const
Definition G4PhysicsListHelper.cc:324
G4ProcessManager::SetProcessOrdering
void SetProcessOrdering(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt, G4int ordDoIt=ordDefault)
Definition G4ProcessManager.cc:620
G4ProcessManager::GetProcessList
G4ProcessVector * GetProcessList() const
G4ProcessManager::AddProcess
G4int AddProcess(G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)
Definition G4ProcessManager.cc:405
G4ProcessManager::SetProcessOrderingToLast
void SetProcessOrderingToLast(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
Definition G4ProcessManager.cc:886
G4ProcessManager::SetProcessOrderingToFirst
void SetProcessOrderingToFirst(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
Definition G4ProcessManager.cc:707
G4ProcessVector::size
std::size_t size() const
G4RunManagerKernel::GetRunManagerKernel
static G4RunManagerKernel * GetRunManagerKernel()
Definition G4RunManagerKernel.cc:92
G4RunManagerKernel::GetNumberOfParallelWorld
G4int GetNumberOfParallelWorld() const
Definition G4RunManagerKernel.hh:154
G4ScoringManager::GetScoringManagerIfExist
static G4ScoringManager * GetScoringManagerIfExist()
Definition G4ScoringManager.cc:51
G4VProcess::GetProcessType
G4ProcessType GetProcessType() const
Definition G4VProcess.hh:392
G4VProcess::GetProcessSubType
G4int GetProcessSubType() const
Definition G4VProcess.hh:404
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition G4VProcess.hh:386
G4ThreadLocal
#define G4ThreadLocal
Definition tls.hh:77