Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4PhysicsListHelper.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

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