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