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 ]

Diff markup

Differences between /run/src/G4PhysicsListHelper.cc (Version 11.3.0) and /run/src/G4PhysicsListHelper.cc (Version 10.0.p4)


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