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