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