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