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