ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
B03PhysicsList.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file B03PhysicsList.cc
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 //
28 //
29 //
30 //
31 
32 #include "globals.hh"
33 #include <iomanip>
34 
35 #include "B03PhysicsList.hh"
36 
37 #include "G4ParticleDefinition.hh"
38 #include "G4ParticleWithCuts.hh"
39 #include "G4ProcessManager.hh"
40 #include "G4ProcessVector.hh"
41 #include "G4ParticleTypes.hh"
42 #include "G4ParticleTable.hh"
43 #include "G4BosonConstructor.hh"
44 #include "G4LeptonConstructor.hh"
45 #include "G4MesonConstructor.hh"
46 #include "G4BaryonConstructor.hh"
47 #include "G4IonConstructor.hh"
48 #include "G4ShortLivedConstructor.hh"
49 #include "G4Material.hh"
50 #include "G4MaterialTable.hh"
51 #include "G4SystemOfUnits.hh"
52 #include "G4HadronicParameters.hh"
53 
54 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
55 
56 B03PhysicsList::B03PhysicsList(G4String parallelname):
57 G4VUserPhysicsList(),
58 fBiasWorldName(parallelname)
59 {
60  fParaWorldName.clear();
61  SetVerboseLevel(1);
62 }
63 
64 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
65 
66 B03PhysicsList::~B03PhysicsList()
67 {
68  fParaWorldName.clear();
69 }
70 
71 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
72 
73 void B03PhysicsList::ConstructParticle()
74 {
75  // In this method, static member functions should be called
76  // for all particles which you want to use.
77  // This ensures that objects of these particle types will be
78  // created in the program.
79 
80  ConstructAllBosons();
81  ConstructAllLeptons();
82  ConstructAllMesons();
83  ConstructAllBaryons();
84  ConstructAllIons();
85  ConstructAllShortLiveds();
86 }
87 
88 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
89 
90 void B03PhysicsList::ConstructAllBosons()
91 {
92  // Construct all bosons
93  G4BosonConstructor pConstructor;
94  pConstructor.ConstructParticle();
95 }
96 
97 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
98 
99 void B03PhysicsList::ConstructAllLeptons()
100 {
101  // Construct all leptons
102  G4LeptonConstructor pConstructor;
103  pConstructor.ConstructParticle();
104 }
105 
106 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
107 
108 void B03PhysicsList::ConstructAllMesons()
109 {
110  // Construct all mesons
111  G4MesonConstructor pConstructor;
112  pConstructor.ConstructParticle();
113 }
114 
115 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
116 
117 void B03PhysicsList::ConstructAllBaryons()
118 {
119  // Construct all barions
120  G4BaryonConstructor pConstructor;
121  pConstructor.ConstructParticle();
122 }
123 
124 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
125 
126 void B03PhysicsList::ConstructAllIons()
127 {
128  // Construct light ions
129  G4IonConstructor pConstructor;
130  pConstructor.ConstructParticle();
131 }
132 
133 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
134 
135 void B03PhysicsList::ConstructAllShortLiveds()
136 {
137  // Construct resonaces and quarks
138  G4ShortLivedConstructor pConstructor;
139  pConstructor.ConstructParticle();
140 }
141 
142 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
143 
144 void B03PhysicsList::ConstructProcess()
145 {
146  AddTransportation();
147  AddScoringProcess();
148  AddBiasingProcess();
149  ConstructEM();
150  ConstructLeptHad();
151  ConstructHad();
152  ConstructGeneral();
153 }
154 
155 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
156 
157 #include "G4ComptonScattering.hh"
158 #include "G4GammaConversion.hh"
159 #include "G4PhotoElectricEffect.hh"
160 
161 #include "G4eMultipleScattering.hh"
162 #include "G4MuMultipleScattering.hh"
163 #include "G4hMultipleScattering.hh"
164 
165 #include "G4eIonisation.hh"
166 #include "G4eBremsstrahlung.hh"
167 #include "G4eplusAnnihilation.hh"
168 
169 #include "G4MuIonisation.hh"
170 #include "G4MuBremsstrahlung.hh"
171 #include "G4MuPairProduction.hh"
172 
173 #include "G4hIonisation.hh"
174 
175 void B03PhysicsList::ConstructEM()
176 {
177  auto particleIterator=GetParticleIterator();
178  particleIterator->reset();
179  while( (*particleIterator)() ){
180  G4ParticleDefinition* particle = particleIterator->value();
181  G4ProcessManager* pmanager = particle->GetProcessManager();
182  G4String particleName = particle->GetParticleName();
183 
184  if (particleName == "gamma") {
185  // gamma
186  // Construct processes for gamma
187  pmanager->AddDiscreteProcess(new G4GammaConversion());
188  pmanager->AddDiscreteProcess(new G4ComptonScattering());
189  pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
190 
191  } else if (particleName == "e-") {
192  //electron
193  // Construct processes for electron
194  pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
195  pmanager->AddProcess(new G4eIonisation(),-1,2,2);
196  pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
197 
198  } else if (particleName == "e+") {
199  //positron
200  // Construct processes for positron
201  pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
202 
203  pmanager->AddProcess(new G4eIonisation(),-1,2,2);
204  pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
205  pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
206 
207  } else if( particleName == "mu+" ||
208  particleName == "mu-" ) {
209  //muon
210  // Construct processes for muon+
211  pmanager->AddProcess(new G4MuMultipleScattering(),-1,1,1);
212  pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
213  pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
214  pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);
215 
216  } else if( particleName == "GenericIon" ) {
217  pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
218  pmanager->AddProcess(new G4hIonisation(),-1,2,2);
219  } else {
220  if ((particle->GetPDGCharge() != 0.0) &&
221  (particle->GetParticleName() != "chargedgeantino")&&
222  (!particle->IsShortLived()) ) {
223  // all others charged particles except geantino
224  pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
225  pmanager->AddProcess(new G4hIonisation(),-1,2,2);
226  }
227  }
228  }
229 }
230 
231 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
232 
233 // Hadron Processes
234 
235 #include "G4HadronElasticProcess.hh"
236 #include "G4HadronFissionProcess.hh"
237 #include "G4HadronCaptureProcess.hh"
238 
239 #include "G4PionPlusInelasticProcess.hh"
240 #include "G4PionMinusInelasticProcess.hh"
241 #include "G4KaonPlusInelasticProcess.hh"
242 #include "G4KaonZeroSInelasticProcess.hh"
243 #include "G4KaonZeroLInelasticProcess.hh"
244 #include "G4KaonMinusInelasticProcess.hh"
245 #include "G4ProtonInelasticProcess.hh"
246 #include "G4AntiProtonInelasticProcess.hh"
247 #include "G4NeutronInelasticProcess.hh"
248 #include "G4AntiNeutronInelasticProcess.hh"
249 #include "G4LambdaInelasticProcess.hh"
250 #include "G4AntiLambdaInelasticProcess.hh"
251 #include "G4SigmaPlusInelasticProcess.hh"
252 #include "G4SigmaMinusInelasticProcess.hh"
253 #include "G4AntiSigmaPlusInelasticProcess.hh"
254 #include "G4AntiSigmaMinusInelasticProcess.hh"
255 #include "G4XiZeroInelasticProcess.hh"
256 #include "G4XiMinusInelasticProcess.hh"
257 #include "G4AntiXiZeroInelasticProcess.hh"
258 #include "G4AntiXiMinusInelasticProcess.hh"
259 #include "G4DeuteronInelasticProcess.hh"
260 #include "G4TritonInelasticProcess.hh"
261 #include "G4AlphaInelasticProcess.hh"
262 #include "G4OmegaMinusInelasticProcess.hh"
263 #include "G4AntiOmegaMinusInelasticProcess.hh"
264 
265 // Low-energy Models
266 
267 #include "G4HadronElastic.hh"
268 #include "G4NeutronRadCapture.hh"
269 #include "G4LFission.hh"
270 
271 // -- generator models
272 #include "G4TheoFSGenerator.hh"
273 #include "G4ExcitationHandler.hh"
274 #include "G4CompetitiveFission.hh"
275 #include "G4GeneratorPrecompoundInterface.hh"
276 #include "G4Fancy3DNucleus.hh"
277 #include "G4CascadeInterface.hh"
278 #include "G4StringModel.hh"
279 #include "G4PreCompoundModel.hh"
280 #include "G4FTFModel.hh"
281 #include "G4QGSMFragmentation.hh"
282 #include "G4LundStringFragmentation.hh"
283 #include "G4ExcitedStringDecay.hh"
284 #include "G4QMDReaction.hh"
285 #include "G4BinaryLightIonReaction.hh"
286 
287 // Cross sections
288 #include "G4IonsShenCrossSection.hh"
289 #include "G4TripathiCrossSection.hh"
290 #include "G4TripathiLightCrossSection.hh"
291 #include "G4ComponentGGHadronNucleusXsc.hh"
292 #include "G4CrossSectionElastic.hh"
293 #include "G4CrossSectionInelastic.hh"
294 #include "G4NeutronInelasticXS.hh"
295 
296 //
297 // ConstructHad()
298 //
299 // Makes discrete physics processes for the hadrons
300 // The processes are: Elastic scattering, Inelastic scattering,
301 // Fission (for neutron only), and Capture (neutron).
302 //
303 
304 void B03PhysicsList::ConstructHad()
305 {
306  // this will be the model class for high energies
307  G4TheoFSGenerator* theTheoModel = new G4TheoFSGenerator;
308  G4TheoFSGenerator* antiBHighEnergyModel = new G4TheoFSGenerator;
309 
310  // Evaporation logic
311  G4ExcitationHandler* theHandler = new G4ExcitationHandler;
312  theHandler->SetMinEForMultiFrag(3*MeV);
313 
314  // Pre equilibrium stage
315  G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(theHandler);
316 
317  // a no-cascade generator-precompound interaface
318  G4GeneratorPrecompoundInterface* theCascade =
319  new G4GeneratorPrecompoundInterface;
320  theCascade->SetDeExcitation(thePreEquilib);
321 
322  // Bertini cascade
323  G4CascadeInterface* bertini = new G4CascadeInterface;
324  bertini->SetMaxEnergy(22*MeV);
325 
326  // here come the high energy parts
327  G4VPartonStringModel* theStringModel;
328  theStringModel = new G4FTFModel;
329  theTheoModel->SetTransport(theCascade);
330  theTheoModel->SetHighEnergyGenerator(theStringModel);
331  theTheoModel->SetMinEnergy(19*GeV);
332  theTheoModel->SetMaxEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() );
333 
334  G4VLongitudinalStringDecay* theFragmentation = new G4QGSMFragmentation;
335  G4ExcitedStringDecay* theStringDecay =
336  new G4ExcitedStringDecay(theFragmentation);
337  theStringModel->SetFragmentationModel(theStringDecay);
338 
339  // high energy model for anti-baryons
340  antiBHighEnergyModel = new G4TheoFSGenerator("ANTI-FTFP");
341  G4FTFModel* antiBStringModel = new G4FTFModel;
342  G4ExcitedStringDecay* stringDecay =
343  new G4ExcitedStringDecay(new G4LundStringFragmentation);
344  antiBStringModel->SetFragmentationModel(stringDecay);
345 
346  G4GeneratorPrecompoundInterface* antiBCascade =
347  new G4GeneratorPrecompoundInterface;
348  G4PreCompoundModel* preEquilib =
349  new G4PreCompoundModel(new G4ExcitationHandler);
350  antiBCascade->SetDeExcitation(preEquilib);
351 
352  antiBHighEnergyModel->SetTransport(antiBCascade);
353  antiBHighEnergyModel->SetHighEnergyGenerator(antiBStringModel);
354  antiBHighEnergyModel->SetMinEnergy(0.0);
355  antiBHighEnergyModel->SetMaxEnergy(20*TeV);
356 
357  // Light ion models
358  G4BinaryLightIonReaction* binaryCascade = new G4BinaryLightIonReaction;
359  binaryCascade->SetMinEnergy(0.0);
360  binaryCascade->SetMaxEnergy(110*MeV);
361 
362  G4QMDReaction* qmd = new G4QMDReaction;
363  qmd->SetMinEnergy(100*MeV);
364  qmd->SetMaxEnergy(10*GeV);
365 
366  G4IonsShenCrossSection* shenXS = new G4IonsShenCrossSection;
367  G4TripathiCrossSection* tripXS = new G4TripathiCrossSection;
368  G4TripathiLightCrossSection* tripLightXS = new G4TripathiLightCrossSection;
369 
370  G4ComponentGGHadronNucleusXsc * ggHNXsec = new G4ComponentGGHadronNucleusXsc();
371  G4VCrossSectionDataSet * theGGHNEl = new G4CrossSectionElastic(ggHNXsec);
372  G4VCrossSectionDataSet * theGGHNInel = new G4CrossSectionInelastic(ggHNXsec);
373 
374  // Elastic process
375  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
376  theElasticProcess->AddDataSet(theGGHNEl);
377  G4HadronElastic* theElasticModel = new G4HadronElastic;
378  theElasticProcess->RegisterMe(theElasticModel);
379 
380  auto particleIterator=GetParticleIterator();
381  particleIterator->reset();
382  while ((*particleIterator)()) {
383  G4ParticleDefinition* particle = particleIterator->value();
384  G4ProcessManager* pmanager = particle->GetProcessManager();
385  G4String particleName = particle->GetParticleName();
386 
387  if (particleName == "pi+") {
388  pmanager->AddDiscreteProcess(theElasticProcess);
389  G4PionPlusInelasticProcess* theInelasticProcess =
390  new G4PionPlusInelasticProcess("inelastic");
391  theInelasticProcess->AddDataSet(theGGHNInel);
392  theInelasticProcess->RegisterMe(bertini);
393  theInelasticProcess->RegisterMe(theTheoModel);
394  pmanager->AddDiscreteProcess(theInelasticProcess);
395  } else if (particleName == "pi-") {
396  pmanager->AddDiscreteProcess(theElasticProcess);
397  G4PionMinusInelasticProcess* theInelasticProcess =
398  new G4PionMinusInelasticProcess("inelastic");
399  theInelasticProcess->AddDataSet(theGGHNInel);
400  theInelasticProcess->RegisterMe(bertini);
401  theInelasticProcess->RegisterMe(theTheoModel);
402  pmanager->AddDiscreteProcess(theInelasticProcess);
403  } else if (particleName == "kaon+") {
404  pmanager->AddDiscreteProcess(theElasticProcess);
405  G4KaonPlusInelasticProcess* theInelasticProcess =
406  new G4KaonPlusInelasticProcess("inelastic");
407  theInelasticProcess->AddDataSet(theGGHNInel);
408  theInelasticProcess->RegisterMe(bertini);
409  theInelasticProcess->RegisterMe(theTheoModel);
410  pmanager->AddDiscreteProcess(theInelasticProcess);
411  }
412  else if (particleName == "kaon0S") {
413  pmanager->AddDiscreteProcess(theElasticProcess);
414  G4KaonZeroSInelasticProcess* theInelasticProcess =
415  new G4KaonZeroSInelasticProcess("inelastic");
416  theInelasticProcess->AddDataSet(theGGHNInel);
417  theInelasticProcess->RegisterMe(bertini);
418  theInelasticProcess->RegisterMe(theTheoModel);
419  pmanager->AddDiscreteProcess(theInelasticProcess);
420  }
421  else if (particleName == "kaon0L") {
422  pmanager->AddDiscreteProcess(theElasticProcess);
423  G4KaonZeroLInelasticProcess* theInelasticProcess =
424  new G4KaonZeroLInelasticProcess("inelastic");
425  theInelasticProcess->AddDataSet(theGGHNInel);
426  theInelasticProcess->RegisterMe(bertini);
427  theInelasticProcess->RegisterMe(theTheoModel);
428  pmanager->AddDiscreteProcess(theInelasticProcess);
429  }
430  else if (particleName == "kaon-") {
431  pmanager->AddDiscreteProcess(theElasticProcess);
432  G4KaonMinusInelasticProcess* theInelasticProcess =
433  new G4KaonMinusInelasticProcess("inelastic");
434  theInelasticProcess->AddDataSet(theGGHNInel);
435  theInelasticProcess->RegisterMe(bertini);
436  theInelasticProcess->RegisterMe(theTheoModel);
437  pmanager->AddDiscreteProcess(theInelasticProcess);
438  }
439  else if (particleName == "proton") {
440  pmanager->AddDiscreteProcess(theElasticProcess);
441  G4ProtonInelasticProcess* theInelasticProcess =
442  new G4ProtonInelasticProcess("inelastic");
443  theInelasticProcess->AddDataSet(theGGHNInel);
444  theInelasticProcess->RegisterMe(bertini);
445  theInelasticProcess->RegisterMe(theTheoModel);
446  pmanager->AddDiscreteProcess(theInelasticProcess);
447  }
448  else if (particleName == "anti_proton") {
449  pmanager->AddDiscreteProcess(theElasticProcess);
450  G4AntiProtonInelasticProcess* theInelasticProcess =
451  new G4AntiProtonInelasticProcess("inelastic");
452  theInelasticProcess->AddDataSet(theGGHNInel);
453  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
454  pmanager->AddDiscreteProcess(theInelasticProcess);
455 
456  } else if (particleName == "neutron") {
457  // elastic scattering
458  pmanager->AddDiscreteProcess(theElasticProcess);
459 
460  // inelastic scattering
461  G4NeutronInelasticProcess* theInelasticProcess =
462  new G4NeutronInelasticProcess("inelastic");
463  theInelasticProcess->AddDataSet(new G4NeutronInelasticXS());
464  theInelasticProcess->RegisterMe(bertini);
465  theInelasticProcess->RegisterMe(theTheoModel);
466  pmanager->AddDiscreteProcess(theInelasticProcess);
467 
468  // fission
469  G4HadronFissionProcess* theFissionProcess = new G4HadronFissionProcess;
470  G4LFission* theFissionModel = new G4LFission;
471  theFissionProcess->RegisterMe(theFissionModel);
472  pmanager->AddDiscreteProcess(theFissionProcess);
473 
474  // capture
475  G4HadronCaptureProcess* theCaptureProcess = new G4HadronCaptureProcess;
476  G4NeutronRadCapture* theCaptureModel = new G4NeutronRadCapture;
477  theCaptureProcess->RegisterMe(theCaptureModel);
478  pmanager->AddDiscreteProcess(theCaptureProcess);
479 
480  } else if (particleName == "anti_neutron") {
481  pmanager->AddDiscreteProcess(theElasticProcess);
482  G4AntiNeutronInelasticProcess* theInelasticProcess =
483  new G4AntiNeutronInelasticProcess("inelastic");
484  theInelasticProcess->AddDataSet(theGGHNInel);
485  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
486  pmanager->AddDiscreteProcess(theInelasticProcess);
487 
488  } else if (particleName == "lambda") {
489  pmanager->AddDiscreteProcess(theElasticProcess);
490  G4LambdaInelasticProcess* theInelasticProcess =
491  new G4LambdaInelasticProcess("inelastic");
492  theInelasticProcess->AddDataSet(theGGHNInel);
493  theInelasticProcess->RegisterMe(bertini);
494  theInelasticProcess->RegisterMe(theTheoModel);
495  pmanager->AddDiscreteProcess(theInelasticProcess);
496  }
497  else if (particleName == "anti_lambda") {
498  pmanager->AddDiscreteProcess(theElasticProcess);
499  G4AntiLambdaInelasticProcess* theInelasticProcess =
500  new G4AntiLambdaInelasticProcess("inelastic");
501  theInelasticProcess->AddDataSet(theGGHNInel);
502  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
503  pmanager->AddDiscreteProcess(theInelasticProcess);
504  }
505  else if (particleName == "sigma+") {
506  pmanager->AddDiscreteProcess(theElasticProcess);
507  G4SigmaPlusInelasticProcess* theInelasticProcess =
508  new G4SigmaPlusInelasticProcess("inelastic");
509  theInelasticProcess->AddDataSet(theGGHNInel);
510  theInelasticProcess->RegisterMe(bertini);
511  theInelasticProcess->RegisterMe(theTheoModel);
512  pmanager->AddDiscreteProcess(theInelasticProcess);
513  }
514  else if (particleName == "sigma-") {
515  pmanager->AddDiscreteProcess(theElasticProcess);
516  G4SigmaMinusInelasticProcess* theInelasticProcess =
517  new G4SigmaMinusInelasticProcess("inelastic");
518  theInelasticProcess->AddDataSet(theGGHNInel);
519  theInelasticProcess->RegisterMe(bertini);
520  theInelasticProcess->RegisterMe(theTheoModel);
521  pmanager->AddDiscreteProcess(theInelasticProcess);
522  }
523  else if (particleName == "anti_sigma+") {
524  pmanager->AddDiscreteProcess(theElasticProcess);
525  G4AntiSigmaPlusInelasticProcess* theInelasticProcess =
526  new G4AntiSigmaPlusInelasticProcess("inelastic");
527  theInelasticProcess->AddDataSet(theGGHNInel);
528  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
529  pmanager->AddDiscreteProcess(theInelasticProcess);
530  }
531  else if (particleName == "anti_sigma-") {
532  pmanager->AddDiscreteProcess(theElasticProcess);
533  G4AntiSigmaMinusInelasticProcess* theInelasticProcess =
534  new G4AntiSigmaMinusInelasticProcess("inelastic");
535  theInelasticProcess->AddDataSet(theGGHNInel);
536  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
537  pmanager->AddDiscreteProcess(theInelasticProcess);
538  }
539  else if (particleName == "xi0") {
540  pmanager->AddDiscreteProcess(theElasticProcess);
541  G4XiZeroInelasticProcess* theInelasticProcess =
542  new G4XiZeroInelasticProcess("inelastic");
543  theInelasticProcess->AddDataSet(theGGHNInel);
544  theInelasticProcess->RegisterMe(bertini);
545  theInelasticProcess->RegisterMe(theTheoModel);
546  pmanager->AddDiscreteProcess(theInelasticProcess);
547  }
548  else if (particleName == "xi-") {
549  pmanager->AddDiscreteProcess(theElasticProcess);
550  G4XiMinusInelasticProcess* theInelasticProcess =
551  new G4XiMinusInelasticProcess("inelastic");
552  theInelasticProcess->AddDataSet(theGGHNInel);
553  theInelasticProcess->RegisterMe(bertini);
554  theInelasticProcess->RegisterMe(theTheoModel);
555  pmanager->AddDiscreteProcess(theInelasticProcess);
556  }
557  else if (particleName == "anti_xi0") {
558  pmanager->AddDiscreteProcess(theElasticProcess);
559  G4AntiXiZeroInelasticProcess* theInelasticProcess =
560  new G4AntiXiZeroInelasticProcess("inelastic");
561  theInelasticProcess->AddDataSet(theGGHNInel);
562  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
563  pmanager->AddDiscreteProcess(theInelasticProcess);
564  }
565  else if (particleName == "anti_xi-") {
566  pmanager->AddDiscreteProcess(theElasticProcess);
567  G4AntiXiMinusInelasticProcess* theInelasticProcess =
568  new G4AntiXiMinusInelasticProcess("inelastic");
569  theInelasticProcess->AddDataSet(theGGHNInel);
570  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
571  pmanager->AddDiscreteProcess(theInelasticProcess);
572  }
573  else if (particleName == "deuteron") {
574  pmanager->AddDiscreteProcess(theElasticProcess);
575  G4DeuteronInelasticProcess* theInelasticProcess =
576  new G4DeuteronInelasticProcess("inelastic");
577  theInelasticProcess->RegisterMe(binaryCascade);
578  theInelasticProcess->RegisterMe(qmd);
579  theInelasticProcess->AddDataSet(shenXS);
580  theInelasticProcess->AddDataSet(tripXS);
581  theInelasticProcess->AddDataSet(tripLightXS);
582  pmanager->AddDiscreteProcess(theInelasticProcess);
583  }
584  else if (particleName == "triton") {
585  pmanager->AddDiscreteProcess(theElasticProcess);
586  G4TritonInelasticProcess* theInelasticProcess =
587  new G4TritonInelasticProcess("inelastic");
588  theInelasticProcess->RegisterMe(binaryCascade);
589  theInelasticProcess->RegisterMe(qmd);
590  theInelasticProcess->AddDataSet(shenXS);
591  theInelasticProcess->AddDataSet(tripXS);
592  theInelasticProcess->AddDataSet(tripLightXS);
593  pmanager->AddDiscreteProcess(theInelasticProcess);
594  }
595  else if (particleName == "alpha") {
596  pmanager->AddDiscreteProcess(theElasticProcess);
597  G4AlphaInelasticProcess* theInelasticProcess =
598  new G4AlphaInelasticProcess("inelastic");
599  theInelasticProcess->RegisterMe(binaryCascade);
600  theInelasticProcess->RegisterMe(qmd);
601  theInelasticProcess->AddDataSet(shenXS);
602  theInelasticProcess->AddDataSet(tripXS);
603  theInelasticProcess->AddDataSet(tripLightXS);
604  pmanager->AddDiscreteProcess(theInelasticProcess);
605 
606  } else if (particleName == "omega-") {
607  pmanager->AddDiscreteProcess(theElasticProcess);
608  G4OmegaMinusInelasticProcess* theInelasticProcess =
609  new G4OmegaMinusInelasticProcess("inelastic");
610  theInelasticProcess->AddDataSet(theGGHNInel);
611  theInelasticProcess->RegisterMe(bertini);
612  theInelasticProcess->RegisterMe(theTheoModel);
613  pmanager->AddDiscreteProcess(theInelasticProcess);
614 
615  } else if (particleName == "anti_omega-") {
616  pmanager->AddDiscreteProcess(theElasticProcess);
617  G4AntiOmegaMinusInelasticProcess* theInelasticProcess =
618  new G4AntiOmegaMinusInelasticProcess("inelastic");
619  theInelasticProcess->AddDataSet(theGGHNInel);
620  theInelasticProcess->RegisterMe(antiBHighEnergyModel);
621  pmanager->AddDiscreteProcess(theInelasticProcess);
622  }
623  }
624 }
625 
626 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
627 
628 void B03PhysicsList::ConstructLeptHad()
629 {;}
630 
631 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
632 
633 #include "G4Decay.hh"
634 void B03PhysicsList::ConstructGeneral()
635 {
636  G4Decay* theDecayProcess = new G4Decay();
637  auto particleIterator=GetParticleIterator();
638  particleIterator->reset();
639  while( (*particleIterator)() ){
640  G4ParticleDefinition* particle = particleIterator->value();
641  G4ProcessManager* pmanager = particle->GetProcessManager();
642  if (theDecayProcess->IsApplicable(*particle)) {
643  pmanager ->AddProcess(theDecayProcess);
644  pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
645  pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
646  }
647  }
648 }
649 
650 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
651 
652 void B03PhysicsList::SetCuts()
653 {
654  if (verboseLevel >0)
655  {
656  G4cout << "B03PhysicsList::SetCuts:";
657  G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
658  }
659  // "G4VUserPhysicsList::SetCutsWithDefault" method sets
660  // the default cut value for all particle types
661  SetCutsWithDefault();
662 }
663 
664 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
665 
666 #include "G4ParallelWorldProcess.hh"
667 void B03PhysicsList::AddScoringProcess(){
668 
669  G4int npw = fParaWorldName.size();
670  for ( G4int i = 0; i < npw; i++){
671  G4String procName = "ParaWorldProc_"+fParaWorldName[i];
672  G4ParallelWorldProcess* theParallelWorldProcess
673  = new G4ParallelWorldProcess(procName);
674  theParallelWorldProcess->SetParallelWorld(fParaWorldName[i]);
675 
676  auto particleIterator=GetParticleIterator();
677  particleIterator->reset();
678  while( (*particleIterator)() ){
679  G4ParticleDefinition* particle = particleIterator->value();
680  G4ProcessManager* pmanager = particle->GetProcessManager();
681  pmanager->AddProcess(theParallelWorldProcess);
682  if(theParallelWorldProcess->IsAtRestRequired(particle))
683  {pmanager->SetProcessOrdering(theParallelWorldProcess, idxAtRest, 9900);}
684  pmanager->SetProcessOrderingToSecond(theParallelWorldProcess, idxAlongStep);
685  pmanager->SetProcessOrdering(theParallelWorldProcess, idxPostStep, 9900);
686  }
687  }
688 
689 }
690 
691 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
692 
693 #include "G4ImportanceProcess.hh"
694 #include "G4IStore.hh"
695 void B03PhysicsList::AddBiasingProcess(){
696 
697  G4cout << " Preparing Importance Sampling with GhostWorld "
698  << fBiasWorldName << G4endl;
699 
700  G4IStore* iStore = G4IStore::GetInstance(fBiasWorldName);
701  G4GeometrySampler fGeomSampler(fBiasWorldName,"neutron");
702  fGeomSampler.SetParallel(true); // parallelworld
703  // fGeomSampler.SetWorld(iStore->GetParallelWorldVolumePointer());
704  // fGeomSampler->PrepareImportanceSampling(G4IStore::
705  // GetInstance(fBiasWorldName), 0);
706  static G4bool first = true;
707  if(first) {
708  fGeomSampler.PrepareImportanceSampling(iStore, 0);
709 
710  fGeomSampler.Configure();
711  G4cout << " GeomSampler Configured!!! " << G4endl;
712  first = false;
713  }
714 
715 #ifdef G4MULTITHREADED
716  if(!G4Threading::IsMasterThread()) fGeomSampler.AddProcess();
717 #else
718  G4cout << " Running in singlethreaded mode!!! " << G4endl;
719 #endif
720 
721 }
722 
723 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......