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