Geant4 9.6.0
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//
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