Geant4_10
DMXPhysicsList.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 // --------------------------------------------------------------
28 // GEANT 4 - Underground Dark Matter Detector Advanced Example
29 //
30 // For information related to this code contact: Alex Howard
31 // e-mail: alexander.howard@cern.ch
32 // --------------------------------------------------------------
33 // Comments
34 //
35 // Underground Advanced
36 // by A. Howard and H. Araujo
37 // (27th November 2001)
38 //
39 // PhysicsList program
40 //
41 // Modified:
42 //
43 // 14-02-03 Fix bugs in msc and hIon instanciation + cut per region
44 //
45 // 05-02-05 AH - changes to G4Decay - added is not short lived protection
46 // and redefined particles to allow non-static creation
47 // i.e. changed construction to G4MesonConstructor, G4BaryonConstructor
48 //
49 // 23-10-09 LP - migrated EM physics from the LowEnergy processes (not supported) to
50 // the new G4Livermore model implementation. Results unchanged.
51 //
52 // --------------------------------------------------------------
53 
54 #include <iomanip>
55 
56 #include "DMXPhysicsList.hh"
57 
58 #include "globals.hh"
59 #include "G4SystemOfUnits.hh"
60 #include "G4ProcessManager.hh"
61 #include "G4ProcessVector.hh"
62 
63 #include "G4ParticleDefinition.hh"
64 #include "G4ParticleWithCuts.hh"
65 #include "G4ParticleTypes.hh"
66 #include "G4ParticleTable.hh"
67 
68 #include "G4ios.hh"
69 #include "G4UserLimits.hh"
70 
71 // Constructor /////////////////////////////////////////////////////////////
73 {
74 
75  defaultCutValue = 1.0*micrometer; //
76  cutForGamma = defaultCutValue;
77  cutForElectron = 1.0*nanometer;
78  cutForPositron = defaultCutValue;
79 
80  VerboseLevel = 1;
81  OpVerbLevel = 0;
82 
83  SetVerboseLevel(VerboseLevel);
84 }
85 
86 
87 // Destructor //////////////////////////////////////////////////////////////
89 {;}
90 
91 
92 // Construct Particles /////////////////////////////////////////////////////
94 {
95 
96  // In this method, static member functions should be called
97  // for all particles which you want to use.
98  // This ensures that objects of these particle types will be
99  // created in the program.
100 
101  ConstructMyBosons();
102  ConstructMyLeptons();
103  ConstructMyHadrons();
104  ConstructMyShortLiveds();
105 
106 }
107 
108 
109 // construct Bosons://///////////////////////////////////////////////////
110 void DMXPhysicsList::ConstructMyBosons()
111 {
112  // pseudo-particles
115 
116  // gamma
118 
119  //OpticalPhotons
121 
122 }
123 
124 
125 // construct Leptons://///////////////////////////////////////////////////
126 void DMXPhysicsList::ConstructMyLeptons()
127 {
128  // leptons
133 
138 }
139 
140 
141 #include "G4MesonConstructor.hh"
142 #include "G4BaryonConstructor.hh"
143 #include "G4IonConstructor.hh"
144 
145 // construct Hadrons://///////////////////////////////////////////////////
146 void DMXPhysicsList::ConstructMyHadrons()
147 {
148  // mesons
149  G4MesonConstructor mConstructor;
150  mConstructor.ConstructParticle();
151 
152  // baryons
153  G4BaryonConstructor bConstructor;
154  bConstructor.ConstructParticle();
155 
156  // ions
157  G4IonConstructor iConstructor;
158  iConstructor.ConstructParticle();
159 
160 }
161 
162 
163 // construct Shortliveds://///////////////////////////////////////////////////
164 void DMXPhysicsList::ConstructMyShortLiveds()
165 {
166  // ShortLiveds
167  ;
168 }
169 
170 
171 
172 
173 // Construct Processes //////////////////////////////////////////////////////
175 {
176 
178 
179  ConstructEM();
180 
181  ConstructOp();
182 
183  ConstructHad();
184 
186 
187 }
188 
189 
190 // Transportation ///////////////////////////////////////////////////////////
191 #include "DMXMaxTimeCuts.hh"
192 #include "DMXMinEkineCuts.hh"
193 #include "G4StepLimiter.hh"
194 
196 
198 
199  theParticleIterator->reset();
200  while( (*theParticleIterator)() ){
201  G4ParticleDefinition* particle = theParticleIterator->value();
202  G4ProcessManager* pmanager = particle->GetProcessManager();
203  G4String particleName = particle->GetParticleName();
204  // time cuts for ONLY neutrons:
205  if(particleName == "neutron")
206  pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());
207  // Energy cuts to kill charged (embedded in method) particles:
208  pmanager->AddDiscreteProcess(new DMXMinEkineCuts());
209 
210  // Step limit applied to all particles:
211  pmanager->AddProcess(new G4StepLimiter, -1,-1,1);
212 
213  }
214 }
215 
216 
217 // Electromagnetic Processes ////////////////////////////////////////////////
218 // all charged particles
219 
220 // gamma
221 #include "G4PhotoElectricEffect.hh"
223 
224 #include "G4ComptonScattering.hh"
226 
227 #include "G4GammaConversion.hh"
229 
230 #include "G4RayleighScattering.hh"
232 
233 
234 // e-
235 #include "G4eMultipleScattering.hh"
236 
237 #include "G4eIonisation.hh"
239 
240 #include "G4eBremsstrahlung.hh"
242 
243 
244 // e+
245 #include "G4eIonisation.hh"
246 #include "G4eBremsstrahlung.hh"
247 #include "G4eplusAnnihilation.hh"
248 
249 
250 // alpha and GenericIon and deuterons, triton, He3:
251 
252 //muon:
253 #include "G4MuIonisation.hh"
254 #include "G4MuBremsstrahlung.hh"
255 #include "G4MuPairProduction.hh"
257 
258 //OTHERS:
259 #include "G4hIonisation.hh"
260 #include "G4hMultipleScattering.hh"
261 #include "G4hBremsstrahlung.hh"
262 #include "G4ionIonisation.hh"
264 
265 //em process options to allow msc step-limitation to be switched off
266 #include "G4EmProcessOptions.hh"
267 
269 
270  //set a finer grid of the physic tables in order to improve precision
271  //former LowEnergy models have 200 bins up to 100 GeV
272  G4EmProcessOptions opt;
273  opt.SetMaxEnergy(100*GeV);
274  opt.SetDEDXBinning(200);
275  opt.SetLambdaBinning(200);
276 
277  theParticleIterator->reset();
278  while( (*theParticleIterator)() ){
279  G4ParticleDefinition* particle = theParticleIterator->value();
280  G4ProcessManager* pmanager = particle->GetProcessManager();
281  G4String particleName = particle->GetParticleName();
282  G4String particleType = particle->GetParticleType();
283  G4double charge = particle->GetPDGCharge();
284 
285  if (particleName == "gamma")
286  {
287  //gamma
288  G4RayleighScattering* theRayleigh = new G4RayleighScattering();
289  theRayleigh->SetEmModel(new G4LivermoreRayleighModel()); //not strictly necessary
290  pmanager->AddDiscreteProcess(theRayleigh);
291 
292  G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
293  thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
294  pmanager->AddDiscreteProcess(thePhotoElectricEffect);
295 
296  G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
297  theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
298  pmanager->AddDiscreteProcess(theComptonScattering);
299 
300  G4GammaConversion* theGammaConversion = new G4GammaConversion();
301  theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
302  pmanager->AddDiscreteProcess(theGammaConversion);
303 
304  }
305  else if (particleName == "e-")
306  {
307  //electron
308  // process ordering: AddProcess(name, at rest, along step, post step)
309  // Multiple scattering
312  pmanager->AddProcess(msc,-1, 1, 1);
313 
314  // Ionisation
315  G4eIonisation* eIonisation = new G4eIonisation();
316  eIonisation->SetEmModel(new G4LivermoreIonisationModel());
317  eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking
318  pmanager->AddProcess(eIonisation,-1, 2, 2);
319 
320  // Bremsstrahlung
321  G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();
322  eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());
323  pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);
324  }
325  else if (particleName == "e+")
326  {
327  //positron
330  pmanager->AddProcess(msc,-1, 1, 1);
331 
332  // Ionisation
333  G4eIonisation* eIonisation = new G4eIonisation();
334  eIonisation->SetStepFunction(0.2, 100*um); //
335  pmanager->AddProcess(eIonisation, -1, 2, 2);
336 
337  //Bremsstrahlung (use default, no low-energy available)
338  pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);
339 
340  //Annihilation
341  pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);
342  }
343  else if( particleName == "mu+" ||
344  particleName == "mu-" )
345  {
346  //muon
347  pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
348  pmanager->AddProcess(new G4MuIonisation(), -1, 2, 2);
349  pmanager->AddProcess(new G4MuBremsstrahlung(), -1,-1, 3);
350  pmanager->AddProcess(new G4MuPairProduction(), -1,-1, 4);
351  if( particleName == "mu-" )
352  pmanager->AddProcess(new G4MuonMinusCaptureAtRest(), 0,-1,-1);
353  }
354  else if (particleName == "proton" ||
355  particleName == "pi+" ||
356  particleName == "pi-")
357  {
358  //multiple scattering
359  pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
360 
361  //ionisation
362  G4hIonisation* hIonisation = new G4hIonisation();
363  hIonisation->SetStepFunction(0.2, 50*um);
364  pmanager->AddProcess(hIonisation, -1, 2, 2);
365 
366  //bremmstrahlung
367  pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
368  }
369  else if(particleName == "alpha" ||
370  particleName == "deuteron" ||
371  particleName == "triton" ||
372  particleName == "He3")
373  {
374  //multiple scattering
375  pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
376 
377  //ionisation
378  G4ionIonisation* ionIoni = new G4ionIonisation();
379  ionIoni->SetStepFunction(0.1, 20*um);
380  pmanager->AddProcess(ionIoni, -1, 2, 2);
381  }
382  else if (particleName == "GenericIon")
383  {
384  // OBJECT may be dynamically created as either a GenericIon or nucleus
385  // G4Nucleus exists and therefore has particle type nucleus
386  // genericIon:
387 
388  //multiple scattering
389  pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
390 
391  //ionisation
392  G4ionIonisation* ionIoni = new G4ionIonisation();
393  ionIoni->SetEmModel(new G4IonParametrisedLossModel());
394  ionIoni->SetStepFunction(0.1, 20*um);
395  pmanager->AddProcess(ionIoni, -1, 2, 2);
396  }
397 
398  else if ((!particle->IsShortLived()) &&
399  (charge != 0.0) &&
400  (particle->GetParticleName() != "chargedgeantino"))
401  {
402  //all others charged particles except geantino
403  G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();
404  G4hIonisation* ahadronIon = new G4hIonisation();
405 
406  //multiple scattering
407  pmanager->AddProcess(aMultipleScattering,-1,1,1);
408 
409  //ionisation
410  pmanager->AddProcess(ahadronIon, -1,2,2);
411  }
412 
413  }
414 
415  // turn off msc step-limitation - especially as electron cut 1nm
417 
418  // switch on fluorescence, PIXE and Auger:
419  opt.SetFluo(true);
420  opt.SetPIXE(true);
421  opt.SetAuger(true);
422 
423 }
424 
425 
426 // Optical Processes ////////////////////////////////////////////////////////
427 #include "G4Scintillation.hh"
428 #include "G4OpAbsorption.hh"
429 //#include "G4OpRayleigh.hh"
430 #include "G4OpBoundaryProcess.hh"
431 
433 {
434  // default scintillation process
435  G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
436  // theScintProcessDef->DumpPhysicsTable();
437  theScintProcessDef->SetTrackSecondariesFirst(true);
438  theScintProcessDef->SetScintillationYieldFactor(1.0); //
439  theScintProcessDef->SetScintillationExcitationRatio(0.0); //
440  theScintProcessDef->SetVerboseLevel(OpVerbLevel);
441 
442  // scintillation process for alpha:
443  G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
444  // theScintProcessNuc->DumpPhysicsTable();
445  theScintProcessAlpha->SetTrackSecondariesFirst(true);
446  theScintProcessAlpha->SetScintillationYieldFactor(1.1);
447  theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
448  theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
449 
450  // scintillation process for heavy nuclei
451  G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
452  // theScintProcessNuc->DumpPhysicsTable();
453  theScintProcessNuc->SetTrackSecondariesFirst(true);
454  theScintProcessNuc->SetScintillationYieldFactor(0.2);
455  theScintProcessNuc->SetScintillationExcitationRatio(1.0);
456  theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
457 
458  // optical processes
459  G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
460  // G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
461  G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
462  // theAbsorptionProcess->DumpPhysicsTable();
463  // theRayleighScatteringProcess->DumpPhysicsTable();
464  theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
465  // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
466  theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
467 
468  theParticleIterator->reset();
469  while( (*theParticleIterator)() )
470  {
471  G4ParticleDefinition* particle = theParticleIterator->value();
472  G4ProcessManager* pmanager = particle->GetProcessManager();
473  G4String particleName = particle->GetParticleName();
474  if (theScintProcessDef->IsApplicable(*particle)) {
475  // if(particle->GetPDGMass() > 5.0*GeV)
476  if(particle->GetParticleName() == "GenericIon") {
477  pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
478  pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
479  pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
480  }
481  else if(particle->GetParticleName() == "alpha") {
482  pmanager->AddProcess(theScintProcessAlpha);
483  pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
484  pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
485  }
486  else {
487  pmanager->AddProcess(theScintProcessDef);
488  pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
489  pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
490  }
491  }
492 
493  if (particleName == "opticalphoton") {
494  pmanager->AddDiscreteProcess(theAbsorptionProcess);
495  // pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
496  pmanager->AddDiscreteProcess(theBoundaryProcess);
497  }
498  }
499 }
500 
501 
502 // Hadronic processes ////////////////////////////////////////////////////////
503 
504 // Elastic processes:
505 #include "G4HadronElasticProcess.hh"
506 #include "G4ChipsElasticModel.hh"
507 #include "G4ElasticHadrNucleusHE.hh"
508 
509 // Inelastic processes:
523 
524 // High energy FTFP model and Bertini cascade
525 #include "G4FTFModel.hh"
527 #include "G4ExcitedStringDecay.hh"
528 #include "G4PreCompoundModel.hh"
530 #include "G4TheoFSGenerator.hh"
531 #include "G4CascadeInterface.hh"
532 
533 // Cross sections
534 #include "G4VCrossSectionDataSet.hh"
536 
537 #include "G4CrossSectionElastic.hh"
538 #include "G4BGGPionElasticXS.hh"
539 #include "G4AntiNuclElastic.hh"
540 
543 #include "G4CrossSectionPairGG.hh"
547 
548 #include "G4HadronElastic.hh"
549 #include "G4HadronCaptureProcess.hh"
550 
551 // Neutron high-precision models: <20 MeV
552 #include "G4NeutronHPElastic.hh"
553 #include "G4NeutronHPElasticData.hh"
554 #include "G4NeutronHPCapture.hh"
555 #include "G4NeutronHPCaptureData.hh"
556 #include "G4NeutronHPInelastic.hh"
558 
559 // Stopping processes
563 
564 
565 
567 {
568  //Elastic models
569  const G4double elastic_elimitPi = 1.0*GeV;
570 
571  G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
572  G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
573  elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
574  G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
575  G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE();
576  elastic_he->SetMinEnergy( elastic_elimitPi );
577 
578 
579  // Inelastic scattering
580  const G4double theFTFMin0 = 0.0*GeV;
581  const G4double theFTFMin1 = 4.0*GeV;
582  const G4double theFTFMax = 100.0*TeV;
583  const G4double theBERTMin0 = 0.0*GeV;
584  const G4double theBERTMin1 = 19.0*MeV;
585  const G4double theBERTMax = 5.0*GeV;
586  const G4double theHPMin = 0.0*GeV;
587  const G4double theHPMax = 20.0*MeV;
588 
589  G4FTFModel * theStringModel = new G4FTFModel;
591  theStringModel->SetFragmentationModel( theStringDecay );
592  G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
593  G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
594 
595  G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
596  theFTFModel0->SetHighEnergyGenerator( theStringModel );
597  theFTFModel0->SetTransport( theCascade );
598  theFTFModel0->SetMinEnergy( theFTFMin0 );
599  theFTFModel0->SetMaxEnergy( theFTFMax );
600 
601  G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
602  theFTFModel1->SetHighEnergyGenerator( theStringModel );
603  theFTFModel1->SetTransport( theCascade );
604  theFTFModel1->SetMinEnergy( theFTFMin1 );
605  theFTFModel1->SetMaxEnergy( theFTFMax );
606 
607  G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
608  theBERTModel0->SetMinEnergy( theBERTMin0 );
609  theBERTModel0->SetMaxEnergy( theBERTMax );
610 
611  G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
612  theBERTModel1->SetMinEnergy( theBERTMin1 );
613  theBERTModel1->SetMaxEnergy( theBERTMax );
614 
618  GetCrossSectionDataSet(G4GGNuclNuclCrossSection::Default_Name());
619 
620 
621  theParticleIterator->reset();
622  while ((*theParticleIterator)())
623  {
624  G4ParticleDefinition* particle = theParticleIterator->value();
625  G4ProcessManager* pmanager = particle->GetProcessManager();
626  G4String particleName = particle->GetParticleName();
627 
628  if (particleName == "pi+")
629  {
630  // Elastic scattering
631  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
632  theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
633  theElasticProcess->RegisterMe( elastic_lhep1 );
634  theElasticProcess->RegisterMe( elastic_he );
635  pmanager->AddDiscreteProcess( theElasticProcess );
636  //Inelastic scattering
637  G4PionPlusInelasticProcess* theInelasticProcess =
638  new G4PionPlusInelasticProcess("inelastic");
639  theInelasticProcess->AddDataSet( thePiData );
640  theInelasticProcess->RegisterMe( theFTFModel1 );
641  theInelasticProcess->RegisterMe( theBERTModel0 );
642  pmanager->AddDiscreteProcess( theInelasticProcess );
643  }
644 
645  else if (particleName == "pi-")
646  {
647  // Elastic scattering
648  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
649  theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
650  theElasticProcess->RegisterMe( elastic_lhep1 );
651  theElasticProcess->RegisterMe( elastic_he );
652  pmanager->AddDiscreteProcess( theElasticProcess );
653  //Inelastic scattering
654  G4PionMinusInelasticProcess* theInelasticProcess =
655  new G4PionMinusInelasticProcess("inelastic");
656  theInelasticProcess->AddDataSet( thePiData );
657  theInelasticProcess->RegisterMe( theFTFModel1 );
658  theInelasticProcess->RegisterMe( theBERTModel0 );
659  pmanager->AddDiscreteProcess( theInelasticProcess );
660  //Absorption
662  }
663 
664  else if (particleName == "kaon+")
665  {
666  // Elastic scattering
667  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
668  theElasticProcess->RegisterMe( elastic_lhep0 );
669  pmanager->AddDiscreteProcess( theElasticProcess );
670  // Inelastic scattering
671  G4KaonPlusInelasticProcess* theInelasticProcess =
672  new G4KaonPlusInelasticProcess("inelastic");
673  theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
674  GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
675  theInelasticProcess->RegisterMe( theFTFModel1 );
676  theInelasticProcess->RegisterMe( theBERTModel0 );
677  pmanager->AddDiscreteProcess( theInelasticProcess );
678  }
679 
680  else if (particleName == "kaon0S")
681  {
682  // Elastic scattering
683  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
684  theElasticProcess->RegisterMe( elastic_lhep0 );
685  pmanager->AddDiscreteProcess( theElasticProcess );
686  // Inelastic scattering
687  G4KaonZeroSInelasticProcess* theInelasticProcess =
688  new G4KaonZeroSInelasticProcess("inelastic");
689  theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
690  GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
691  theInelasticProcess->RegisterMe( theFTFModel1 );
692  theInelasticProcess->RegisterMe( theBERTModel0 );
693  pmanager->AddDiscreteProcess( theInelasticProcess );
694  }
695 
696  else if (particleName == "kaon0L")
697  {
698  // Elastic scattering
699  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
700  theElasticProcess->RegisterMe( elastic_lhep0 );
701  pmanager->AddDiscreteProcess( theElasticProcess );
702  // Inelastic scattering
703  G4KaonZeroLInelasticProcess* theInelasticProcess =
704  new G4KaonZeroLInelasticProcess("inelastic");
705  theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
706  GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
707  theInelasticProcess->RegisterMe( theFTFModel1 );
708  theInelasticProcess->RegisterMe( theBERTModel0 );
709  pmanager->AddDiscreteProcess( theInelasticProcess );
710  }
711 
712  else if (particleName == "kaon-")
713  {
714  // Elastic scattering
715  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
716  theElasticProcess->RegisterMe( elastic_lhep0 );
717  pmanager->AddDiscreteProcess( theElasticProcess );
718  // Inelastic scattering
719  G4KaonMinusInelasticProcess* theInelasticProcess =
720  new G4KaonMinusInelasticProcess("inelastic");
721  theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
722  GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
723  theInelasticProcess->RegisterMe( theFTFModel1 );
724  theInelasticProcess->RegisterMe( theBERTModel0 );
725  pmanager->AddDiscreteProcess( theInelasticProcess );
727  }
728 
729  else if (particleName == "proton")
730  {
731  // Elastic scattering
732  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
734  GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
735  theElasticProcess->RegisterMe( elastic_chip );
736  pmanager->AddDiscreteProcess( theElasticProcess );
737  // Inelastic scattering
738  G4ProtonInelasticProcess* theInelasticProcess =
739  new G4ProtonInelasticProcess("inelastic");
740  theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
741  theInelasticProcess->RegisterMe( theFTFModel1 );
742  theInelasticProcess->RegisterMe( theBERTModel0 );
743  pmanager->AddDiscreteProcess( theInelasticProcess );
744  }
745  else if (particleName == "anti_proton")
746  {
747  // Elastic scattering
748  const G4double elastic_elimitAntiNuc = 100.0*CLHEP::MeV;
749  G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
750  elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
751  G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
752  G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
753  elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
754  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
755  theElasticProcess->AddDataSet( elastic_anucxs );
756  theElasticProcess->RegisterMe( elastic_lhep2 );
757  theElasticProcess->RegisterMe( elastic_anuc );
758  pmanager->AddDiscreteProcess( theElasticProcess );
759  // Inelastic scattering
760  G4AntiProtonInelasticProcess* theInelasticProcess =
761  new G4AntiProtonInelasticProcess("inelastic");
762  theInelasticProcess->AddDataSet( theAntiNucleonData );
763  theInelasticProcess->RegisterMe( theFTFModel0 );
764  pmanager->AddDiscreteProcess( theInelasticProcess );
765  // Absorption
767  }
768 
769  else if (particleName == "neutron") {
770  // elastic scattering
771  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
772  theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
773  G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
774  elastic_neutronChipsModel->SetMinEnergy( 19.0*CLHEP::MeV );
775  theElasticProcess->RegisterMe( elastic_neutronChipsModel );
776  G4NeutronHPElastic * theElasticNeutronHP = new G4NeutronHPElastic;
777  theElasticNeutronHP->SetMinEnergy( theHPMin );
778  theElasticNeutronHP->SetMaxEnergy( theHPMax );
779  theElasticProcess->RegisterMe( theElasticNeutronHP );
780  theElasticProcess->AddDataSet( new G4NeutronHPElasticData );
781  pmanager->AddDiscreteProcess( theElasticProcess );
782  // inelastic scattering
783  G4NeutronInelasticProcess* theInelasticProcess =
784  new G4NeutronInelasticProcess("inelastic");
785  theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
786  theInelasticProcess->RegisterMe( theFTFModel1 );
787  theInelasticProcess->RegisterMe( theBERTModel1 );
788  G4NeutronHPInelastic * theNeutronInelasticHPModel = new G4NeutronHPInelastic;
789  theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
790  theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
791  theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
792  theInelasticProcess->AddDataSet( new G4NeutronHPInelasticData );
793  pmanager->AddDiscreteProcess(theInelasticProcess);
794  // capture
795  G4HadronCaptureProcess* theCaptureProcess =
797  G4NeutronHPCapture * theLENeutronCaptureModel = new G4NeutronHPCapture;
798  theLENeutronCaptureModel->SetMinEnergy(theHPMin);
799  theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
800  theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
801  theCaptureProcess->AddDataSet( new G4NeutronHPCaptureData);
802  pmanager->AddDiscreteProcess(theCaptureProcess);
803 
804  }
805  else if (particleName == "anti_neutron")
806  {
807  // Elastic scattering
808  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
809  theElasticProcess->RegisterMe( elastic_lhep0 );
810  pmanager->AddDiscreteProcess( theElasticProcess );
811  // Inelastic scattering (include annihilation on-fly)
812  G4AntiNeutronInelasticProcess* theInelasticProcess =
813  new G4AntiNeutronInelasticProcess("inelastic");
814  theInelasticProcess->AddDataSet( theAntiNucleonData );
815  theInelasticProcess->RegisterMe( theFTFModel0 );
816  pmanager->AddDiscreteProcess( theInelasticProcess );
817  }
818 
819  else if (particleName == "deuteron")
820  {
821  // Elastic scattering
822  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
823  theElasticProcess->RegisterMe( elastic_lhep0 );
824  pmanager->AddDiscreteProcess( theElasticProcess );
825  // Inelastic scattering
826  G4DeuteronInelasticProcess* theInelasticProcess =
827  new G4DeuteronInelasticProcess("inelastic");
828  theInelasticProcess->AddDataSet( theGGNuclNuclData );
829  theInelasticProcess->RegisterMe( theFTFModel1 );
830  theInelasticProcess->RegisterMe( theBERTModel0 );
831  pmanager->AddDiscreteProcess( theInelasticProcess );
832  }
833 
834  else if (particleName == "triton")
835  {
836  // Elastic scattering
837  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
838  theElasticProcess->RegisterMe( elastic_lhep0 );
839  pmanager->AddDiscreteProcess( theElasticProcess );
840  // Inelastic scattering
841  G4TritonInelasticProcess* theInelasticProcess =
842  new G4TritonInelasticProcess("inelastic");
843  theInelasticProcess->AddDataSet( theGGNuclNuclData );
844  theInelasticProcess->RegisterMe( theFTFModel1 );
845  theInelasticProcess->RegisterMe( theBERTModel0 );
846  pmanager->AddDiscreteProcess( theInelasticProcess );
847  }
848  else if (particleName == "alpha")
849  {
850  // Elastic scattering
851  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
852  theElasticProcess->RegisterMe( elastic_lhep0 );
853  pmanager->AddDiscreteProcess( theElasticProcess );
854  // Inelastic scattering
855  G4AlphaInelasticProcess* theInelasticProcess =
856  new G4AlphaInelasticProcess("inelastic");
857  theInelasticProcess->AddDataSet( theGGNuclNuclData );
858  theInelasticProcess->RegisterMe( theFTFModel1 );
859  theInelasticProcess->RegisterMe( theBERTModel0 );
860  pmanager->AddDiscreteProcess( theInelasticProcess );
861  }
862 
863  }
864 }
865 
866 
867 // Decays ///////////////////////////////////////////////////////////////////
868 #include "G4Decay.hh"
869 #include "G4RadioactiveDecay.hh"
870 #include "G4IonTable.hh"
871 #include "G4Ions.hh"
872 
874 
875  // Add Decay Process
876  G4Decay* theDecayProcess = new G4Decay();
877  theParticleIterator->reset();
878  while( (*theParticleIterator)() )
879  {
880  G4ParticleDefinition* particle = theParticleIterator->value();
881  G4ProcessManager* pmanager = particle->GetProcessManager();
882 
883  if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived())
884  {
885  pmanager ->AddProcess(theDecayProcess);
886  // set ordering for PostStepDoIt and AtRestDoIt
887  pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
888  pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
889  }
890  }
891 
892  // Declare radioactive decay to the GenericIon in the IonTable.
893  const G4IonTable *theIonTable =
895  G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();
896 
897  for (G4int i=0; i<theIonTable->Entries(); i++)
898  {
899  G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
900  G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
901 
902  if (particleName == "GenericIon")
903  {
904  G4ProcessManager* pmanager =
905  theIonTable->GetParticle(i)->GetProcessManager();
906  pmanager->SetVerboseLevel(VerboseLevel);
907  pmanager ->AddProcess(theRadioactiveDecay);
908  pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
909  pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
910  }
911  }
912 }
913 
914 // Cuts /////////////////////////////////////////////////////////////////////
916 {
917 
918  if (verboseLevel >1)
919  G4cout << "DMXPhysicsList::SetCuts:";
920 
921  if (verboseLevel>0){
922  G4cout << "DMXPhysicsList::SetCuts:";
923  G4cout << "CutLength : "
924  << G4BestUnit(defaultCutValue,"Length") << G4endl;
925  }
926 
927  //special for low energy physics
928  G4double lowlimit=250*eV;
930 
931  // set cut values for gamma at first and for e- second and next for e+,
932  // because some processes for e+/e- need cut values for gamma
933  SetCutValue(cutForGamma, "gamma");
934  SetCutValue(cutForElectron, "e-");
935  SetCutValue(cutForPositron, "e+");
936 
938 }
939 
static G4Geantino * GeantinoDefinition()
Definition: G4Geantino.cc:82
static G4Electron * ElectronDefinition()
Definition: G4Electron.cc:89
static G4MuonPlus * MuonPlusDefinition()
Definition: G4MuonPlus.cc:94
void SetPIXE(G4bool val)
G4int Entries() const
Definition: G4IonTable.cc:1584
void SetCutValue(G4double aCut, const G4String &pname)
void SetEnergyRange(G4double lowedge, G4double highedge)
virtual void ConstructGeneral()
virtual G4bool IsApplicable(const G4ParticleDefinition &)
Definition: G4Decay.cc:89
void SetFragmentationModel(G4VStringFragmentation *aModel)
void SetScintillationExcitationRatio(const G4double excitationratio)
void SetStepFunction(G4double v1, G4double v2)
G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord=ordDefault)
void SetVerboseLevel(G4int value)
G4bool IsApplicable(const G4ParticleDefinition &aParticleType)
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
static void ConstructParticle()
static void ConstructParticle()
static const char * Default_Name()
G4ProcessManager * GetProcessManager() const
int G4int
Definition: G4Types.hh:78
G4ComponentAntiNuclNuclearXS * GetComponentCrossSection()
const G4String & GetParticleName() const
void SetFluo(G4bool val)
virtual void ConstructProcess()
void SetHighEnergyGenerator(G4VHighEnergyGenerator *const value)
static void ConstructParticle()
void SetAuger(G4bool val)
void RegisterMe(G4HadronicInteraction *a)
int nanometer
Definition: hepunit.py:35
void SetDEDXBinning(G4int val)
virtual void AddTransportation()
void SetScintillationYieldFactor(const G4double yieldfactor)
void SetMinEnergy(G4double anEnergy)
void SetEmModel(G4VEmModel *, G4int index=1)
void AddDataSet(G4VCrossSectionDataSet *aDataSet)
G4IonTable * GetIonTable() const
void DumpCutValuesTable(G4int flag=1)
G4GLOB_DLL std::ostream G4cout
void SetLambdaBinning(G4int val)
void SetVerboseLevel(G4int value)
G4int AddProcess(G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)
static G4NeutrinoE * NeutrinoEDefinition()
Definition: G4NeutrinoE.cc:80
static const char * Default_Name()
static G4AntiNeutrinoMu * AntiNeutrinoMuDefinition()
static G4CrossSectionDataSetRegistry * Instance()
static G4Proton * Proton()
Definition: G4Proton.cc:93
const G4String & GetParticleType() const
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
void SetProcessOrdering(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt, G4int ordDoIt=ordDefault)
void SetMaxEnergy(G4double val)
virtual void ConstructHad()
static G4Positron * PositronDefinition()
Definition: G4Positron.cc:89
static G4ProductionCutsTable * GetProductionCutsTable()
virtual void SetCuts()
static G4ParticleTable * GetParticleTable()
void SetTrackSecondariesFirst(const G4bool state)
void SetProcessOrderingToLast(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
void SetEmModel(G4VEmModel *, G4int index=1)
static G4MuonMinus * MuonMinusDefinition()
Definition: G4MuonMinus.cc:95
virtual void ConstructOp()
void SetMaxEnergy(const G4double anEnergy)
static G4ChargedGeantino * ChargedGeantinoDefinition()
static const char * Default_Name()
#define G4endl
Definition: G4ios.hh:61
void SetTransport(G4VIntraNuclearTransportModel *const value)
void SetMscStepLimitation(G4MscStepLimitType val)
G4int AddRestProcess(G4VProcess *aProcess, G4int ord=ordDefault)
static G4AntiNeutrinoE * AntiNeutrinoEDefinition()
static G4OpticalPhoton * OpticalPhotonDefinition()
double G4double
Definition: G4Types.hh:76
G4double GetPDGCharge() const
static G4NeutrinoMu * NeutrinoMuDefinition()
Definition: G4NeutrinoMu.cc:80
int micrometer
Definition: hepunit.py:34
#define theParticleIterator
virtual void ConstructParticle()
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:437
virtual void ConstructEM()
void SetStepLimitType(G4MscStepLimitType val)
static G4Gamma * GammaDefinition()
Definition: G4Gamma.cc:81
G4ParticleDefinition * GetParticle(G4int index) const
Definition: G4IonTable.cc:1538