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 106147 2017-09-14 06:38:11Z 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 = "MuAtomicCapture"; 1049 tmp.processType = fHadronic; << 995 tmp.processType = 4; 1050 tmp.processSubType = fMuAtomicCapture; << 996 tmp.processSubType = 132; 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); << 1001 theTable->push_back(tmp); 1056 sizeOfTable += 1; << 1002 sizeOfTable +=1; 1057 << 1003 1058 tmp.processTypeName = "HadFission"; << 1004 tmp.processTypeName = "HadFission"; 1059 tmp.processType = fHadronic; << 1005 tmp.processType = 4; 1060 tmp.processSubType = fFission; << 1006 tmp.processSubType = 141; 1061 tmp.ordering[0] = -1; << 1007 tmp.ordering[0] = -1; 1062 tmp.ordering[1] = -1; << 1008 tmp.ordering[1] = -1; 1063 tmp.ordering[2] = 1000; << 1009 tmp.ordering[2] = 1000; 1064 tmp.isDuplicable = false; << 1010 tmp.isDuplicable = false; 1065 theTable->push_back(tmp); 1011 theTable->push_back(tmp); 1066 sizeOfTable += 1; << 1012 sizeOfTable +=1; 1067 1013 1068 tmp.processTypeName = "HadAtRest"; 1014 tmp.processTypeName = "HadAtRest"; 1069 tmp.processType = fHadronic; << 1015 tmp.processType = 4; 1070 tmp.processSubType = fHadronAtRest; << 1016 tmp.processSubType = 151; 1071 tmp.ordering[0] = 1000; << 1017 tmp.ordering[0] = 1000; 1072 tmp.ordering[1] = -1; << 1018 tmp.ordering[1] = -1; 1073 tmp.ordering[2] = -1; << 1019 tmp.ordering[2] = -1; 1074 tmp.isDuplicable = false; << 1020 tmp.isDuplicable = false; 1075 theTable->push_back(tmp); << 1021 theTable->push_back(tmp); 1076 sizeOfTable += 1; << 1022 sizeOfTable +=1; 1077 << 1023 1078 tmp.processTypeName = "HadCEX"; << 1024 tmp.processTypeName = "HadCEX"; 1079 tmp.processType = fHadronic; << 1025 tmp.processType = 4; 1080 tmp.processSubType = fChargeExchange; << 1026 tmp.processSubType = 161; 1081 tmp.ordering[0] = -1; << 1027 tmp.ordering[0] = -1; 1082 tmp.ordering[1] = -1; << 1028 tmp.ordering[1] = -1; 1083 tmp.ordering[2] = 1000; << 1029 tmp.ordering[2] = 1000; 1084 tmp.isDuplicable = false; << 1030 tmp.isDuplicable = false; 1085 theTable->push_back(tmp); << 1031 theTable->push_back(tmp); 1086 sizeOfTable += 1; << 1032 sizeOfTable +=1; 1087 << 1033 1088 tmp.processTypeName = "Decay"; << 1034 tmp.processTypeName = "Decay"; 1089 tmp.processType = fDecay; << 1035 tmp.processType = 6; 1090 tmp.processSubType = DECAY; << 1036 tmp.processSubType = 201; 1091 tmp.ordering[0] = 1000; << 1037 tmp.ordering[0] = 1000; 1092 tmp.ordering[1] = -1; << 1038 tmp.ordering[1] = -1; 1093 tmp.ordering[2] = 1000; << 1039 tmp.ordering[2] = 1000; 1094 tmp.isDuplicable = false; << 1040 tmp.isDuplicable = false; 1095 theTable->push_back(tmp); << 1041 theTable->push_back(tmp); 1096 sizeOfTable += 1; << 1042 sizeOfTable +=1; 1097 << 1043 1098 tmp.processTypeName = "DecayWSpin"; << 1044 tmp.processTypeName = "DecayWSpin"; 1099 tmp.processType = fDecay; << 1045 tmp.processType = 6; 1100 tmp.processSubType = DECAY_WithSpin; << 1046 tmp.processSubType = 202; 1101 tmp.ordering[0] = 1000; << 1047 tmp.ordering[0] = 1000; 1102 tmp.ordering[1] = -1; << 1048 tmp.ordering[1] = -1; 1103 tmp.ordering[2] = 1000; << 1049 tmp.ordering[2] = 1000; 1104 tmp.isDuplicable = false; << 1050 tmp.isDuplicable = false; 1105 theTable->push_back(tmp); << 1051 theTable->push_back(tmp); 1106 sizeOfTable += 1; << 1052 sizeOfTable +=1; 1107 << 1053 1108 tmp.processTypeName = "DecayPiSpin"; << 1054 tmp.processTypeName = "DecayPiSpin"; 1109 tmp.processType = fDecay; << 1055 tmp.processType = 6; 1110 tmp.processSubType = DECAY_PionMakeSpin; << 1056 tmp.processSubType = 203; 1111 tmp.ordering[0] = 1000; << 1057 tmp.ordering[0] = 1000; 1112 tmp.ordering[1] = -1; << 1058 tmp.ordering[1] = -1; 1113 tmp.ordering[2] = 1000; << 1059 tmp.ordering[2] = 1000; 1114 tmp.isDuplicable = false; << 1060 tmp.isDuplicable = false; 1115 theTable->push_back(tmp); << 1061 theTable->push_back(tmp); 1116 sizeOfTable += 1; << 1062 sizeOfTable +=1; 1117 << 1063 1118 tmp.processTypeName = "DecayRadio"; << 1064 tmp.processTypeName = "DecayRadio"; 1119 tmp.processType = fDecay; << 1065 tmp.processType = 6; 1120 tmp.processSubType = DECAY_Radioactive; << 1066 tmp.processSubType = 210; 1121 tmp.ordering[0] = 1000; << 1067 tmp.ordering[0] = 1000; 1122 tmp.ordering[1] = -1; << 1068 tmp.ordering[1] = -1; 1123 tmp.ordering[2] = 1000; << 1069 tmp.ordering[2] = 1000; 1124 tmp.isDuplicable = false; << 1070 tmp.isDuplicable = false; 1125 theTable->push_back(tmp); << 1071 theTable->push_back(tmp); 1126 sizeOfTable += 1; << 1072 sizeOfTable +=1; 1127 << 1073 1128 tmp.processTypeName = "DecayUnKnown"; << 1074 tmp.processTypeName = "DecayUnKnown"; 1129 tmp.processType = fDecay; << 1075 tmp.processType = 6; 1130 tmp.processSubType = DECAY_Unknown; << 1076 tmp.processSubType = 211; 1131 tmp.ordering[0] = -1; << 1077 tmp.ordering[0] = -1; 1132 tmp.ordering[1] = -1; << 1078 tmp.ordering[1] = -1; 1133 tmp.ordering[2] = 1000; << 1079 tmp.ordering[2] = 1000; 1134 tmp.isDuplicable = false; << 1080 tmp.isDuplicable = false; 1135 theTable->push_back(tmp); << 1081 theTable->push_back(tmp); 1136 sizeOfTable += 1; << 1082 sizeOfTable +=1; 1137 << 1083 1138 tmp.processTypeName = "DecayMuAtom"; << 1084 tmp.processTypeName = "DecayMuAtom"; 1139 tmp.processType = fDecay; << 1085 tmp.processType = 6; 1140 tmp.processSubType = DECAY_MuAtom; << 1086 tmp.processSubType = 221; 1141 tmp.ordering[0] = 1000; << 1087 tmp.ordering[0] = 1000; 1142 tmp.ordering[1] = -1; << 1088 tmp.ordering[1] = -1; 1143 tmp.ordering[2] = 1000; << 1089 tmp.ordering[2] = 1000; 1144 tmp.isDuplicable = false; << 1090 tmp.isDuplicable = false; 1145 theTable->push_back(tmp); << 1091 theTable->push_back(tmp); 1146 sizeOfTable += 1; << 1092 sizeOfTable +=1; 1147 << 1093 1148 tmp.processTypeName = "DecayExt"; << 1094 tmp.processTypeName = "DecayExt"; 1149 tmp.processType = fDecay; << 1095 tmp.processType = 6; 1150 tmp.processSubType = DECAY_External; << 1096 tmp.processSubType = 231; 1151 tmp.ordering[0] = 1000; << 1097 tmp.ordering[0] = 1000; 1152 tmp.ordering[1] = -1; << 1098 tmp.ordering[1] = -1; 1153 tmp.ordering[2] = 1000; << 1099 tmp.ordering[2] = 1000; 1154 tmp.isDuplicable = false; << 1100 tmp.isDuplicable = false; 1155 theTable->push_back(tmp); << 1101 theTable->push_back(tmp); 1156 sizeOfTable += 1; << 1102 sizeOfTable +=1; 1157 << 1103 1158 tmp.processTypeName = "StepLimiter"; << 1104 tmp.processTypeName = "StepLimiter"; 1159 tmp.processType = fGeneral; << 1105 tmp.processType = 7; 1160 tmp.processSubType = STEP_LIMITER; << 1106 tmp.processSubType = 401; 1161 tmp.ordering[0] = -1; << 1107 tmp.ordering[0] = -1; 1162 tmp.ordering[1] = -1; << 1108 tmp.ordering[1] = -1; 1163 tmp.ordering[2] = 1000; << 1109 tmp.ordering[2] = 1000; 1164 tmp.isDuplicable = false; << 1110 tmp.isDuplicable = false; 1165 theTable->push_back(tmp); << 1111 theTable->push_back(tmp); 1166 sizeOfTable += 1; << 1112 sizeOfTable +=1; 1167 << 1113 1168 tmp.processTypeName = "UsrSepcCuts"; << 1114 tmp.processTypeName = "UsrSepcCuts"; 1169 tmp.processType = fGeneral; << 1115 tmp.processType = 7; 1170 tmp.processSubType = USER_SPECIAL_CUTS; << 1116 tmp.processSubType = 402; 1171 tmp.ordering[0] = -1; << 1117 tmp.ordering[0] = -1; 1172 tmp.ordering[1] = -1; << 1118 tmp.ordering[1] = -1; 1173 tmp.ordering[2] = 1000; << 1119 tmp.ordering[2] = 1000; 1174 tmp.isDuplicable = false; << 1120 tmp.isDuplicable = false; 1175 theTable->push_back(tmp); << 1121 theTable->push_back(tmp); 1176 sizeOfTable += 1; << 1122 sizeOfTable +=1; 1177 << 1123 1178 tmp.processTypeName = "NeutronKiller"; << 1124 tmp.processTypeName = "NeutronKiller"; 1179 tmp.processType = fGeneral; << 1125 tmp.processType = 7; 1180 tmp.processSubType = NEUTRON_KILLER; << 1126 tmp.processSubType = 403; 1181 tmp.ordering[0] = -1; << 1127 tmp.ordering[0] = -1; 1182 tmp.ordering[1] = -1; << 1128 tmp.ordering[1] = -1; 1183 tmp.ordering[2] = 1000; << 1129 tmp.ordering[2] = 1000; 1184 tmp.isDuplicable = false; << 1130 tmp.isDuplicable = false; 1185 theTable->push_back(tmp); << 1131 theTable->push_back(tmp); 1186 sizeOfTable += 1; << 1132 sizeOfTable +=1; 1187 << 1133 1188 tmp.processTypeName = "ParallelWorld"; << 1134 tmp.processTypeName = "ParallelWorld"; 1189 tmp.processType = fParallel; << 1135 tmp.processType = 10; 1190 tmp.processSubType = PARALLEL_WORLD_PROCESS << 1136 tmp.processSubType = 491; 1191 tmp.ordering[0] = 9900; << 1137 tmp.ordering[0] = 9900; 1192 tmp.ordering[1] = 1; << 1138 tmp.ordering[1] = 1; 1193 tmp.ordering[2] = 9900; << 1139 tmp.ordering[2] = 9900; 1194 tmp.isDuplicable = true; << 1140 tmp.isDuplicable = true; 1195 theTable->push_back(tmp); 1141 theTable->push_back(tmp); 1196 sizeOfTable += 1; << 1142 sizeOfTable +=1; 1197 } 1143 } >> 1144 >> 1145 1198 1146