ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4PhysicsListHelper.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4PhysicsListHelper.cc
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 //
28 //
29 // ------------------------------------------------------------
30 // GEANT 4 class header file
31 //
32 // ------------------------------------------------------------
33 // History
34 // first version 29 Apr 2011 by H.Kurashige
35 // ------------------------------------------------------------
36 
37 #include "globals.hh"
38 #include "G4PhysicsListHelper.hh"
39 #include "G4ParticleDefinition.hh"
40 #include "G4ProcessManager.hh"
41 #include "G4ParticleTable.hh"
42 
43 #include "G4ios.hh"
44 #include <iomanip>
45 #include <fstream>
46 
48 G4ThreadLocal G4PhysicsListHelper* G4PhysicsListHelper::pPLHelper = nullptr;
49 
51 G4PhysicsListHelper::G4PhysicsListHelper()
52  : useCoupledTransportation(false),
53  theTransportationProcess(nullptr),
54  verboseLevel(1),
55  theTable(nullptr),
56  sizeOfTable(0),
57  ordParamFileName("")
58 {
59  // pointer to the particle table
60  theParticleTable = G4ParticleTable::GetParticleTable();
61  aParticleIterator = theParticleTable->GetIterator();
62 
63  ReadOrdingParameterTable();
64 
65 #ifdef G4VERBOSE
66  if (verboseLevel >1){
67  DumpOrdingParameterTable();
68  }
69 #endif
70 }
71 
73 G4PhysicsListHelper::~G4PhysicsListHelper()
74 {
75  if (theTable !=0) {
76  theTable->clear();
77  delete theTable;
78  theTable=0;
79  sizeOfTable=0;
80  }
81  /*
82  if (theTransportationProcess!=0) {
83  delete theTransportationProcess;
84  theTransportationProcess=0;
85  }
86  */
87 }
88 
90 G4PhysicsListHelper* G4PhysicsListHelper::GetPhysicsListHelper()
91 {
92  if (!pPLHelper)
93  {
94  static G4ThreadLocalSingleton<G4PhysicsListHelper> inst;
95  pPLHelper = inst.Instance();
96  }
97  return pPLHelper;
98 }
99 
101 void G4PhysicsListHelper::CheckParticleList() const
102 {
103  G4bool isElectron = false;
104  G4bool isPositron = false;
105  G4bool isGamma = false;
106  G4bool isProton = false;
107  G4bool isGenericIon = false;
108  G4bool isAnyIon = false;
109  G4bool isAnyChargedBaryon = false;
110  G4bool isEmProc = false;
111 
112  // loop over all particles in G4ParticleTable
113  aParticleIterator->reset();
114  while( (*aParticleIterator)() ){
115  G4ParticleDefinition* particle = aParticleIterator->value();
116  G4String name = particle->GetParticleName();
117  // check if any EM process exists
118  if (!isEmProc) {
119  G4ProcessVector* list = particle->GetProcessManager()->GetProcessList();
120  for (std::size_t idx=0; idx<list->size(); ++idx){
121  isEmProc = ((*list)[idx])->GetProcessType() == fElectromagnetic;
122  if (isEmProc) break;
123  }
124  }
125 
126  if ( name == "e-") isElectron = true;
127  else if ( name == "e+") isPositron = true;
128  else if ( name == "gamma") isGamma = true;
129  else if ( name == "GenericIon") isGenericIon = true;
130  else if ( name == "proton") isProton = true;
131  else if ( particle->GetParticleType() == "nucleus") isAnyIon = true;
132  else if ( particle->GetParticleType() == "baryon") {
133  if ( particle->GetPDGCharge() != 0.0 ) isAnyChargedBaryon = true;
134  }
135  }
136 
137  if (!isEmProc) return;
138 
139  // RULE 1
140  // e+, e- and gamma should exist
141  // if one of them exist
142  G4bool isEmBasic = isElectron || isPositron || isGamma;
143  G4bool isMissingEmBasic = !isElectron || !isPositron || !isGamma;
144  if (isEmBasic && isMissingEmBasic) {
145  G4String missingName="";
146  if (!isElectron) missingName += "e- ";
147  if (!isPositron) missingName += "e+ ";
148  if (!isGamma) missingName += "gamma ";
149 
150 #ifdef G4VERBOSE
151  if (verboseLevel >0){
152  G4cout << "G4PhysicsListHelper::CheckParticleList: "
153  << missingName << " do not exist " << G4endl;
154  G4cout << " These particle are necessary for basic EM processes"
155  << G4endl;
156  }
157 #endif
158  G4Exception("G4PhysicsListHelper::CheckParticleList",
159  "Run0101", FatalException,
160  "Missing EM basic particle");
161  }
162 
163  // RULE 2
164  // proton should exist
165  // if any other charged baryon exist
166  if (!isProton && isAnyChargedBaryon) {
167  G4String missingName="proton ";
168 
169 #ifdef G4VERBOSE
170  if (verboseLevel >0){
171  G4cout << "G4PhysicsListHelper::CheckParticleList: "
172  << missingName << " does not exist "<< G4endl;
173  G4cout << " Proton is necessary for EM baryon processes" << G4endl;
174  }
175 #endif
176  missingName += " should be created ";
177  G4Exception("G4PhysicsListHelper::CheckParticleList",
178  "Run0102", FatalException,
179  "Missing Proton");
180  }
181 
182  // RULE 3
183  // GenericIonn should exist
184  // if any other ion exist
185  if (!isGenericIon && isAnyIon) {
186  G4String missingName="GenericIon ";
187 
188 #ifdef G4VERBOSE
189  if (verboseLevel >0){
190  G4cout << "G4PhysicsListHelper::CheckParticleList: "
191  << missingName << " does not exist "<< G4endl;
192  G4cout << " GenericIon should be created if any ion is necessary" << G4endl;
193  }
194 #endif
195  G4Exception("G4PhysicsListHelper::CheckParticleList",
196  "Run0103", FatalException,
197  "Missing GenericIon");
198  }
199 
200 }
201 
202 
204 #include "G4Transportation.hh"
205 #include "G4CoupledTransportation.hh"
206 #include "G4RunManagerKernel.hh"
207 #include "G4ScoringManager.hh"
208 
209 void G4PhysicsListHelper::AddTransportation()
210 {
211  G4int verboseLevelTransport = 0;
212 
213 #ifdef G4VERBOSE
214  if (verboseLevel >2){
215  G4cout << "G4PhysicsListHelper::AddTransportation() "<< G4endl;
216  }
217 #endif
218 
219  G4int nParaWorld =
220  G4RunManagerKernel::GetRunManagerKernel()->GetNumberOfParallelWorld();
221 
222  if ( nParaWorld>0 ||
223  useCoupledTransportation ||
224  G4ScoringManager::GetScoringManagerIfExist())
225  {
226  auto coupledTransport= new G4CoupledTransportation(verboseLevelTransport);
227  if( theLooperThresholds == 0 ) coupledTransport->SetLowLooperThresholds();
228  if( theLooperThresholds == 2 ) coupledTransport->SetHighLooperThresholds();
229  theTransportationProcess = coupledTransport;
230 
231  if (verboseLevel >0) {
232  G4cout << "--- G4CoupledTransportation is used " << G4endl;
233  }
234  } else {
235  auto simpleTransport = new G4Transportation(verboseLevelTransport);
236  if( theLooperThresholds == 0 ) simpleTransport->SetLowLooperThresholds();
237  if( theLooperThresholds == 2 ) simpleTransport->SetHighLooperThresholds();
238  theTransportationProcess = simpleTransport;
239  }
240 
241  // loop over all particles in G4ParticleTable
242  aParticleIterator->reset();
243  while( (*aParticleIterator)() ){
244  G4ParticleDefinition* particle = aParticleIterator->value();
245  G4ProcessManager* pmanager = particle->GetProcessManager();
246  // Add transportation process for all particles
247  if ( pmanager == 0) {
248  // Error !! no process manager
249 #ifdef G4VERBOSE
250  if (verboseLevel>0){
251  G4cout << "G4PhysicsListHelper::AddTransportation "
252  <<" : No Process Manager for "
253  << particle->GetParticleName() << G4endl;
254  }
255 #endif
256  G4Exception("G4PhysicsListHelper::AddTransportation",
257  "Run0104", FatalException,
258  "No process manager");
259  continue;
260  }
261  // Molecule use different type transportation
262  if(particle->GetParticleType() == "Molecule") continue;
263 
264  // add transportation with ordering = ( -1, "first", "first" )
265  pmanager ->AddProcess(theTransportationProcess);
266  pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
267  pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
268  }
269 }
270 
272 #include "G4ProcessManager.hh"
273 
274 void G4PhysicsListHelper::ReadOrdingParameterTable()
275 {
276  G4bool readInFile = false;
277  std::ifstream fIn;
278 
279  if( std::getenv("G4ORDPARAMTABLE") ){
280  ordParamFileName = std::getenv("G4ORDPARAMTABLE");
281 #ifdef G4VERBOSE
282  if (verboseLevel >1){
283  G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable :"
284  << ordParamFileName << " is assigned to Ordering Parameter Table "
285  << G4endl;
286  }
287 #endif
288  // open input file //
289  fIn.open(ordParamFileName, std::ios::in);
290  // check if the file has been opened successfully
291  if (!fIn) {
292 #ifdef G4VERBOSE
293  if (verboseLevel >0) {
294  G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable "
295  << " Can not open file " << ordParamFileName << G4endl;
296  }
297 #endif
298  G4Exception("G4PhysicsListHelper::ReadOrdingParameterTable",
299  "Run0105", JustWarning,
300  "Fail to open ordering paramter table ");
301  } else {
302  readInFile = true;
303  }
304  }
305 
306 
307  // create OrdParamTable
308  if (theTable !=0) {
309  theTable->clear();
310  delete theTable;
311  theTable=0;
312  sizeOfTable=0;
313  }
314  theTable = new G4OrdParamTable();
315  sizeOfTable=0;
316 
317  if (readInFile){
318  // read in the file and fill the table
319  while(!fIn.eof()) {
320  G4PhysicsListOrderingParameter tmp;
321  G4int flag;
322  fIn >> tmp.processTypeName >> tmp.processType >> tmp.processSubType
323  >> tmp.ordering[0] >> tmp.ordering[1] >> tmp.ordering[2] >> flag;
324  tmp.isDuplicable = (flag!=0);
325  theTable->push_back(tmp);
326  sizeOfTable +=1;
327  }
328  fIn.close();
329  } else {
330  ReadInDefaultOrderingParameter();
331  }
332 
333  if (sizeOfTable==0){
334 #ifdef G4VERBOSE
335  if (verboseLevel >0) {
336  G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable "
337  << " Empty file " << ordParamFileName << G4endl;
338  }
339 #endif
340  G4Exception("G4PhysicsListHelper::ReadOrdingParameterTable",
341  "Run0106", JustWarning,
342  "The ordering parameter table is empty ");
343  delete theTable;
344  theTable=0;
345  }
346  return;
347 }
348 
350 void G4PhysicsListHelper::DumpOrdingParameterTable(G4int subType) const
351 {
352  if (theTable==0) {
353 #ifdef G4VERBOSE
354  if (verboseLevel >0) {
355  G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable "
356  << " No ordering parameter table : " << ordParamFileName
357  << G4endl;
358  }
359 #endif
360  return;
361  }
362  G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable : "
363  << ordParamFileName << G4endl;
364  G4cout << " TypeName "
365  << " ProcessType" << " SubType"
366  << " AtRest" << " AlongStep" << " PostStep"
367  << " Duplicable" << G4endl;
368  for (G4int i=0; i<sizeOfTable ; ++i){
369  G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
370  if ((subType>=0) && (subType!=tmp->processSubType)) continue;
371  G4cout << std::setw(18) << tmp->processTypeName
372  << std::setw(15) << tmp->processType
373  << std::setw(15) << tmp->processSubType
374  << std::setw(15) << tmp->ordering[0]
375  << std::setw(15) << tmp->ordering[1]
376  << std::setw(15) << tmp->ordering[2];
377  if (tmp->isDuplicable) {
378  G4cout << " true";
379  } else {
380  G4cout << " false";
381  }
382  G4cout <<G4endl;
383  }
384 }
385 
387 G4PhysicsListOrderingParameter G4PhysicsListHelper::GetOrdingParameter(G4int subType) const
388 {
389  G4PhysicsListOrderingParameter value;
390 
391  if (theTable==0) {
392 #ifdef G4VERBOSE
393  if (verboseLevel >0) {
394  G4cout << "G4PhysicsListHelper::GetOrderingParameter : "
395  << " No ordering parameter table : " << ordParamFileName
396  << G4endl;
397  }
398 #endif
399  return value;
400  }
401 
402  for (G4int i=0; i<sizeOfTable ; ++i){
403  G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
404  if (subType == tmp->processSubType){
405  value.processTypeName = tmp->processTypeName;
406  value.processType = tmp->processType;
407  value.processSubType = tmp->processSubType;
408  value.ordering[0] = tmp->ordering[0];
409  value.ordering[1] = tmp->ordering[1];
410  value.ordering[2] = tmp->ordering[2];
411  value.isDuplicable = tmp->isDuplicable;
412  }
413  }
414  return value;
415 }
416 
418 G4bool G4PhysicsListHelper::RegisterProcess(G4VProcess* process,
419  G4ParticleDefinition* particle)
420 {
421  if (theTable==0) {
422 #ifdef G4VERBOSE
423  if (verboseLevel >0) {
424  G4cout << "G4PhysicsListHelper::RegisterProcess :"
425  << " No ordering parameter table : " << ordParamFileName
426  << G4endl;
427  }
428 #endif
429  G4Exception("G4PhysicsListHelper::RegisterProcess",
430  "Run0107", FatalException,
431  "No Ordering Parameter Table");
432  return false;
433  }
434 
435  const G4String pName = process->GetProcessName();
436  const G4int pType = process->GetProcessType();
437  const G4int pSubType = process->GetProcessSubType();
438 
439 #ifdef G4VERBOSE
440  if (verboseLevel >2) {
441  G4cout << "G4PhysicsListHelper::RegisterProcess :"
442  << pName << " Process Type = " << pType
443  << " SubType = "<< pSubType
444  << " to " << particle->GetParticleName()
445  << G4endl;
446  }
447 #endif
448 
449  // Check Process Type/SubType
450  if ((pType <1)||(pSubType<1)) {
451 #ifdef G4VERBOSE
452  if (verboseLevel >0) {
453  G4cout << "G4PhysicsListHelper::RegisterProcess :"
454  << pName << " for " << particle->GetParticleName()
455  << " has illegal Process Type = " << pType
456  << " SubType = "<< pSubType << G4endl;
457  }
458 #endif
459  G4Exception("G4PhysicsListHelper::RegisterProcess",
460  "Run0108", FatalException,
461  "No Matching process Type/SubType");
462  return false;
463  }
464 
465  G4bool isFound = false;
466  G4int ord[3];
467  G4bool duplicable = false;
468  for (G4int i=0; i<sizeOfTable ; ++i){
469  G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
470  if ((tmp->processType==pType)&&(tmp->processSubType==pSubType)){
471  ord[0] = tmp->ordering[0];
472  ord[1] = tmp->ordering[1];
473  ord[2] = tmp->ordering[2];
474  duplicable = tmp->isDuplicable;
475  isFound = true;
476  break;
477  }
478  }
479  if (!isFound) {
480 #ifdef G4VERBOSE
481  if (verboseLevel >0) {
482  G4cout << "G4PhysicsListHelper::RegisterProcess :"
483  << pName << " for " << particle->GetParticleName()
484  << " with type/subtype ="
485  << pType << "/" << pSubType
486  << " is not reigstered in OrdingParameterTable "
487  << G4endl;
488  }
489 #endif
490  G4Exception("G4PhysicsListHelper::RegisterProcess",
491  "Run0109", FatalException,
492  "No Matching process Type/SubType");
493  return false;
494  }
495 
496  // Check Process Manager
497  G4ProcessManager* pManager = particle->GetProcessManager();
498  if ( pManager == 0) {
499  // Error !! no process manager
500 #ifdef G4VERBOSE
501  if (verboseLevel>0){
502  G4cout << "G4PhysicsListHelper::RegisterProcess "
503  <<" : No Process Manager for "
504  << particle->GetParticleName() << G4endl;
505  }
506 #endif
507  G4Exception("G4PhysicsListHelper::RegisterProcess ",
508  "Riun0110", FatalException,
509  "No process manager");
510  return false;
511  }
512 
513  // Check Duplication
514  if (!duplicable){
515  G4bool duplicated = false;
516  G4ProcessVector* pList = pManager->GetProcessList();
517  for (std::size_t idx=0; idx<pList->size(); ++idx) {
518  const G4VProcess* p = (*pList)[idx];
519  if ((p->GetProcessType()== pType) &&
520  (p->GetProcessSubType()== pSubType)){
521  duplicated = true;
522 #ifdef G4VERBOSE
523  if (verboseLevel >0) {
524  G4cout << "G4PhysicsListHelper::RegisterProcess :"
525  << pName << " for " << particle->GetParticleName()
526  << " with type/subtype ="
527  << pType << "/" << pSubType
528  << " is has same subType as "
529  << p->GetProcessName()
530  << " for " << particle->GetParticleName()
531  << G4endl;
532  G4cout << "It will not be added !!" << G4endl;
533  }
534 #endif
535  G4Exception("G4PhysicsListHelper::RegisterProcess",
536  "Run0111", JustWarning,
537  "Duplication of processes");
538  }
539  }
540  if (duplicated) return false;
541  }
542 
543  // Add Process
544  G4int code = pManager ->AddProcess(process);
545  if (code <0) return false;
546 
547  // Set Ordering Parameter
548  for(G4int idx=0; idx<3; ++idx){
549  G4ProcessVectorDoItIndex idxOrd = static_cast<G4ProcessVectorDoItIndex>(idx);
550  if (ord[idx]<0) {
551  // Do Nothing because NO DOIT
552  } else if (ord[idx]==0) {
553  pManager->SetProcessOrderingToFirst( process, idxOrd );
554  } else if (ord[idx]<9999) {
555  pManager->SetProcessOrdering( process, idxOrd , ord[idx]);
556  } else {
557  pManager->SetProcessOrderingToLast( process, idxOrd );
558  }
559  }
560 #ifdef G4VERBOSE
561  if (verboseLevel >1) {
562  G4cout << "G4PhysicsListHelper::RegisterProcess :"
563  << pName << " for " << particle->GetParticleName()
564  << " with type/subtype ="
565  << pType << "/" << pSubType
566  << " is sucessfully registered with ordering parameters "
567  << ord[0] << ":" << ord[1] << ":" << ord[2]
568  << G4endl;
569  }
570 #endif
571  return true;
572 }
573 
574 void G4PhysicsListHelper::ReadInDefaultOrderingParameter()
575 {
576 
577  G4PhysicsListOrderingParameter tmp;
578 
579  tmp.processTypeName = "Transportation";
580  tmp.processType = 1;
581  tmp.processSubType = 91;
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 = "CoupleTrans";
590  tmp.processType = 1;
591  tmp.processSubType = 92;
592  tmp.ordering[0] = -1;
593  tmp.ordering[1] = 0;
594  tmp.ordering[2] = 0;
595  tmp.isDuplicable = false;
596  theTable->push_back(tmp);
597  sizeOfTable +=1;
598 
599  tmp.processTypeName = "CoulombScat";
600  tmp.processType = 2;
601  tmp.processSubType = 1;
602  tmp.ordering[0] = -1;
603  tmp.ordering[1] = -1;
604  tmp.ordering[2] = 1000;
605  tmp.isDuplicable = false;
606  theTable->push_back(tmp);
607  sizeOfTable +=1;
608 
609  tmp.processTypeName = "Ionisation";
610  tmp.processType = 2;
611  tmp.processSubType = 2;
612  tmp.ordering[0] = -1;
613  tmp.ordering[1] = 2;
614  tmp.ordering[2] = 2;
615  tmp.isDuplicable = false;
616  theTable->push_back(tmp);
617  sizeOfTable +=1;
618 
619  tmp.processTypeName = "Brems";
620  tmp.processType = 2;
621  tmp.processSubType = 3;
622  tmp.ordering[0] = -1;
623  tmp.ordering[1] = -1;
624  tmp.ordering[2] = 3;
625  tmp.isDuplicable = false;
626  theTable->push_back(tmp);
627  sizeOfTable +=1;
628 
629  tmp.processTypeName = "PairProdCharged";
630  tmp.processType = 2;
631  tmp.processSubType = 4;
632  tmp.ordering[0] = -1;
633  tmp.ordering[1] = -1;
634  tmp.ordering[2] = 4;
635  tmp.isDuplicable = false;
636  theTable->push_back(tmp);
637  sizeOfTable +=1;
638 
639  tmp.processTypeName = "Annih";
640  tmp.processType = 2;
641  tmp.processSubType = 5;
642  tmp.ordering[0] = 5;
643  tmp.ordering[1] = -1;
644  tmp.ordering[2] = 5;
645  tmp.isDuplicable = false;
646  theTable->push_back(tmp);
647  sizeOfTable +=1;
648 
649  tmp.processTypeName = "AnnihToMuMu";
650  tmp.processType = 2;
651  tmp.processSubType = 6;
652  tmp.ordering[0] = -1;
653  tmp.ordering[1] = -1;
654  tmp.ordering[2] = 6;
655  tmp.isDuplicable = false;
656  theTable->push_back(tmp);
657  sizeOfTable +=1;
658 
659  tmp.processTypeName = "AnnihToHad";
660  tmp.processType = 2;
661  tmp.processSubType = 7;
662  tmp.ordering[0] = -1;
663  tmp.ordering[1] = -1;
664  tmp.ordering[2] = 7;
665  tmp.isDuplicable = false;
666  theTable->push_back(tmp);
667  sizeOfTable +=1;
668 
669  tmp.processTypeName = "NuclearStopp";
670  tmp.processType = 2;
671  tmp.processSubType = 8;
672  tmp.ordering[0] = -1;
673  tmp.ordering[1] = 8;
674  tmp.ordering[2] = -1;
675  tmp.isDuplicable = false;
676  theTable->push_back(tmp);
677  sizeOfTable +=1;
678 
679  tmp.processTypeName = "ElectronSuper";
680  tmp.processType = 2;
681  tmp.processSubType = 9;
682  tmp.ordering[0] = -1;
683  tmp.ordering[1] = 1;
684  tmp.ordering[2] = 1;
685  tmp.isDuplicable = false;
686  theTable->push_back(tmp);
687  sizeOfTable +=1;
688 
689  tmp.processTypeName = "Msc";
690  tmp.processType = 2;
691  tmp.processSubType = 10;
692  tmp.ordering[0] = -1;
693  tmp.ordering[1] = 1;
694  tmp.ordering[2] = -1;
695  tmp.isDuplicable = false;
696  theTable->push_back(tmp);
697  sizeOfTable +=1;
698 
699  tmp.processTypeName = "Rayleigh";
700  tmp.processType = 2;
701  tmp.processSubType = 11;
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 = "PhotoElectric";
710  tmp.processType = 2;
711  tmp.processSubType = 12;
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 = "Compton";
720  tmp.processType = 2;
721  tmp.processSubType = 13;
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 = "Conv";
730  tmp.processType = 2;
731  tmp.processSubType = 14;
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 = "ConvToMuMu";
740  tmp.processType = 2;
741  tmp.processSubType = 15;
742  tmp.ordering[0] = -1;
743  tmp.ordering[1] = -1;
744  tmp.ordering[2] = 1000;
745  tmp.isDuplicable = false;
746  theTable->push_back(tmp);
747  sizeOfTable +=1;
748 
749  tmp.processTypeName = "GammaSuper";
750  tmp.processType = 2;
751  tmp.processSubType = 16;
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 = "Cerenkov";
760  tmp.processType = 2;
761  tmp.processSubType = 21;
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 = "Scintillation";
770  tmp.processType = 2;
771  tmp.processSubType = 22;
772  tmp.ordering[0] = 9999;
773  tmp.ordering[1] = -1;
774  tmp.ordering[2] = 9999;
775  tmp.isDuplicable = false;
776  theTable->push_back(tmp);
777  sizeOfTable +=1;
778 
779  tmp.processTypeName = "SynchRad";
780  tmp.processType = 2;
781  tmp.processSubType = 23;
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 = "TransRad";
790  tmp.processType = 2;
791  tmp.processSubType = 24;
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 = "OpAbsorb";
800  tmp.processType = 3;
801  tmp.processSubType = 31;
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 = "OpBoundary";
810  tmp.processType = 3;
811  tmp.processSubType = 32;
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 = "OpRayleigh";
820  tmp.processType = 3;
821  tmp.processSubType = 33;
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 = "OpWLS";
830  tmp.processType = 3;
831  tmp.processSubType = 34;
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 = "OpMieHG";
840  tmp.processType = 3;
841  tmp.processSubType = 35;
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 = "DNAElastic";
850  tmp.processType = 2;
851  tmp.processSubType = 51;
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 = "DNAExcit";
860  tmp.processType = 2;
861  tmp.processSubType = 52;
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 = "DNAIonisation";
870  tmp.processType = 2;
871  tmp.processSubType = 53;
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 = "DNAVibExcit";
880  tmp.processType = 2;
881  tmp.processSubType = 54;
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 = "DNAAttachment";
890  tmp.processType = 2;
891  tmp.processSubType = 55;
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 = "DNAChargeDec";
900  tmp.processType = 2;
901  tmp.processSubType = 56;
902  tmp.ordering[0] = -1;
903  tmp.ordering[1] = -1;
904  tmp.ordering[2] = 1000;
905  tmp.isDuplicable = false;
906  theTable->push_back(tmp);
907  sizeOfTable +=1;
908 
909  tmp.processTypeName = "DNAChargeInc";
910  tmp.processType = 2;
911  tmp.processSubType = 57;
912  tmp.ordering[0] = -1;
913  tmp.ordering[1] = -1;
914  tmp.ordering[2] = 1000;
915  tmp.isDuplicable = false;
916  theTable->push_back(tmp);
917  sizeOfTable +=1;
918 
919  tmp.processTypeName = "DNAElectronSolvatation";
920  tmp.processType = 2;
921  tmp.processSubType = 58;
922  tmp.ordering[0] = -1;
923  tmp.ordering[1] = -1;
924  tmp.ordering[2] = 1000;
925  tmp.isDuplicable = false;
926  theTable->push_back(tmp);
927  sizeOfTable +=1;
928 
929  tmp.processTypeName = "DNAMolecularDecay";
930  tmp.processType = 6;
931  tmp.processSubType = 59;
932  tmp.ordering[0] = 1000;
933  tmp.ordering[1] = -1;
934  tmp.ordering[2] = -1;
935  tmp.isDuplicable = false;
936  theTable->push_back(tmp);
937  sizeOfTable +=1;
938 
939  tmp.processTypeName = "ITTransportation";
940  tmp.processType = 1;
941  tmp.processSubType = 60;
942  tmp.ordering[0] = -1;
943  tmp.ordering[1] = 0;
944  tmp.ordering[2] = 0;
945  tmp.isDuplicable = false;
946  theTable->push_back(tmp);
947  sizeOfTable +=1;
948 
949  tmp.processTypeName = "DNABrownianTransportation";
950  tmp.processType = 1;
951  tmp.processSubType = 61;
952  tmp.ordering[0] = -1;
953  tmp.ordering[1] = 0;
954  tmp.ordering[2] = 0;
955  tmp.isDuplicable = false;
956  theTable->push_back(tmp);
957  sizeOfTable +=1;
958 
959  tmp.processTypeName = "DNADoubleIonisation";
960  tmp.processType = 2;
961  tmp.processSubType = 62;
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 = "DNADoubleCapture";
970  tmp.processType = 2;
971  tmp.processSubType = 63;
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 = "DNAIonisingTransfer";
980  tmp.processType = 2;
981  tmp.processSubType = 64;
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 = "HadElastic";
990  tmp.processType = 4;
991  tmp.processSubType = 111;
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 = "HadInElastic";
1000  tmp.processType = 4;
1001  tmp.processSubType = 121;
1002  tmp.ordering[0] = -1;
1003  tmp.ordering[1] = -1;
1004  tmp.ordering[2] = 1000;
1005  tmp.isDuplicable = false;
1006  theTable->push_back(tmp);
1007  sizeOfTable +=1;
1008 
1009  tmp.processTypeName = "HadCapture";
1010  tmp.processType = 4;
1011  tmp.processSubType = 131;
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 = "MuAtomicCapture";
1020  tmp.processType = 4;
1021  tmp.processSubType = 132;
1022  tmp.ordering[0] = -1;
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 = "HadFission";
1030  tmp.processType = 4;
1031  tmp.processSubType = 141;
1032  tmp.ordering[0] = -1;
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 = "HadAtRest";
1040  tmp.processType = 4;
1041  tmp.processSubType = 151;
1042  tmp.ordering[0] = 1000;
1043  tmp.ordering[1] = -1;
1044  tmp.ordering[2] = -1;
1045  tmp.isDuplicable = false;
1046  theTable->push_back(tmp);
1047  sizeOfTable +=1;
1048 
1049  tmp.processTypeName = "HadCEX";
1050  tmp.processType = 4;
1051  tmp.processSubType = 161;
1052  tmp.ordering[0] = -1;
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 = "Decay";
1060  tmp.processType = 6;
1061  tmp.processSubType = 201;
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 = "DecayWSpin";
1070  tmp.processType = 6;
1071  tmp.processSubType = 202;
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 = "DecayPiSpin";
1080  tmp.processType = 6;
1081  tmp.processSubType = 203;
1082  tmp.ordering[0] = 1000;
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 = "DecayRadio";
1090  tmp.processType = 6;
1091  tmp.processSubType = 210;
1092  tmp.ordering[0] = 1000;
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 = "DecayUnKnown";
1100  tmp.processType = 6;
1101  tmp.processSubType = 211;
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  tmp.processTypeName = "DecayMuAtom";
1110  tmp.processType = 6;
1111  tmp.processSubType = 221;
1112  tmp.ordering[0] = 1000;
1113  tmp.ordering[1] = -1;
1114  tmp.ordering[2] = 1000;
1115  tmp.isDuplicable = false;
1116  theTable->push_back(tmp);
1117  sizeOfTable +=1;
1118 
1119  tmp.processTypeName = "DecayExt";
1120  tmp.processType = 6;
1121  tmp.processSubType = 231;
1122  tmp.ordering[0] = 1000;
1123  tmp.ordering[1] = -1;
1124  tmp.ordering[2] = 1000;
1125  tmp.isDuplicable = false;
1126  theTable->push_back(tmp);
1127  sizeOfTable +=1;
1128 
1129  tmp.processTypeName = "StepLimiter";
1130  tmp.processType = 7;
1131  tmp.processSubType = 401;
1132  tmp.ordering[0] = -1;
1133  tmp.ordering[1] = -1;
1134  tmp.ordering[2] = 1000;
1135  tmp.isDuplicable = false;
1136  theTable->push_back(tmp);
1137  sizeOfTable +=1;
1138 
1139  tmp.processTypeName = "UsrSepcCuts";
1140  tmp.processType = 7;
1141  tmp.processSubType = 402;
1142  tmp.ordering[0] = -1;
1143  tmp.ordering[1] = -1;
1144  tmp.ordering[2] = 1000;
1145  tmp.isDuplicable = false;
1146  theTable->push_back(tmp);
1147  sizeOfTable +=1;
1148 
1149  tmp.processTypeName = "NeutronKiller";
1150  tmp.processType = 7;
1151  tmp.processSubType = 403;
1152  tmp.ordering[0] = -1;
1153  tmp.ordering[1] = -1;
1154  tmp.ordering[2] = 1000;
1155  tmp.isDuplicable = false;
1156  theTable->push_back(tmp);
1157  sizeOfTable +=1;
1158 
1159  tmp.processTypeName = "ParallelWorld";
1160  tmp.processType = 10;
1161  tmp.processSubType = 491;
1162  tmp.ordering[0] = 9900;
1163  tmp.ordering[1] = 1;
1164  tmp.ordering[2] = 9900;
1165  tmp.isDuplicable = true;
1166  theTable->push_back(tmp);
1167  sizeOfTable +=1;
1168 }
1169 
1170