| Geant4 Cross Reference |
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 // ClassName: G4HadronHElasticPhysics
29 //
30 // Author: 23 November 2006 V. Ivanchenko
31 //
32 // Modified:
33 // 21.03.07 (V.Ivanchenko) Use G4BGGNucleonElasticXS and G4BGGPionElasticXS;
34 // Reduce thresholds for HE and Q-models to zero
35 // 03.06.2010 V.Ivanchenko cleanup constructors and ConstructProcess method
36 // 06.06.2014 A.Ribon Use the current best elastic models.
37 //
38 //----------------------------------------------------------------------------
39 //
40
41 #include "G4HadronHElasticPhysics.hh"
42
43 #include "G4SystemOfUnits.hh"
44 #include "G4ParticleDefinition.hh"
45 #include "G4ProcessManager.hh"
46
47 #include "G4MesonConstructor.hh"
48 #include "G4BaryonConstructor.hh"
49 #include "G4IonConstructor.hh"
50 #include "G4Neutron.hh"
51
52 #include "G4HadronElasticProcess.hh"
53 #include "G4HadronElastic.hh"
54 #include "G4ChipsElasticModel.hh"
55 #include "G4AntiNuclElastic.hh"
56 #include "G4DiffuseElastic.hh"
57 #include "G4NuclNuclDiffuseElastic.hh"
58
59 #include "G4CrossSectionElastic.hh"
60 #include "G4BGGNucleonElasticXS.hh"
61 #include "G4BGGPionElasticXS.hh"
62 #include "G4NeutronElasticXS.hh"
63 #include "G4ChipsKaonMinusElasticXS.hh"
64 #include "G4ChipsKaonPlusElasticXS.hh"
65 #include "G4ChipsKaonZeroElasticXS.hh"
66 #include "G4ComponentGGHadronNucleusXsc.hh"
67 #include "G4ComponentGGNuclNuclXsc.hh"
68 #include "G4CrossSectionDataSetRegistry.hh"
69
70 #include "G4LMsdGenerator.hh"
71 #include "G4DiffElasticRatio.hh"
72
73 #include "G4HadronicParameters.hh"
74 #include "G4HadronicBuilder.hh"
75 #include "G4HadParticles.hh"
76 #include "G4HadProcesses.hh"
77 #include "G4PhysListUtil.hh"
78
79 // factory
80 #include "G4PhysicsConstructorFactory.hh"
81 //
82 G4_DECLARE_PHYSCONSTR_FACTORY( G4HadronHElasticPhysics );
83
84 G4HadronHElasticPhysics::G4HadronHElasticPhysics(G4int ver, G4bool diffraction)
85 : G4HadronElasticPhysics(ver, "hElastic_BEST"),
86 fDiffraction(diffraction)
87 {
88 if (ver > 1) {
89 G4cout << "### G4HadronHElasticPhysics: " << GetPhysicsName()
90 << " low-mass diffraction: " << fDiffraction << G4endl;
91 }
92 }
93
94 G4HadronHElasticPhysics::~G4HadronHElasticPhysics() {}
95
96 void G4HadronHElasticPhysics::ConstructProcess() {
97 G4HadronicParameters* param = G4HadronicParameters::Instance();
98 G4bool useFactorXS = param->ApplyFactorXS();
99 G4ParticleTable* table = G4ParticleTable::GetParticleTable();
100 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
101
102 const G4double elimitDiffuse = 10.0;
103 const G4double elimitAntiNuc = 100.0*MeV;
104 const G4double delta = 0.1*MeV;
105 G4double emax = std::max(param->GetMaxEnergy(), elimitAntiNuc+delta);
106 if (param->GetVerboseLevel() > 1 ) {
107 G4cout << "### HadronHElasticPhysics::ConstructProcess: lower energy limit for DiffuseElastic : "
108 << elimitDiffuse/GeV << " GeV" << G4endl
109 << " transition energy for anti-nuclei : "
110 << elimitAntiNuc/GeV << " GeV" << G4endl;
111 }
112 G4HadronElastic* lhep0 = new G4HadronElastic();
113 G4HadronElastic* lhep1 = new G4HadronElastic();
114 G4HadronElastic* lhep2 = new G4HadronElastic();
115 lhep0->SetMaxEnergy(emax);
116 lhep1->SetMaxEnergy(elimitDiffuse+delta);
117 lhep2->SetMaxEnergy(elimitAntiNuc+delta);
118
119 G4AntiNuclElastic* anuc = new G4AntiNuclElastic();
120 anuc->SetMinEnergy( elimitAntiNuc );
121 anuc->SetMaxEnergy(emax);
122
123 auto anucxs = G4HadProcesses::ElasticXS("AntiAGlauber");
124 auto xsNN = G4HadProcesses::ElasticXS("Glauber-Gribov Nucl-nucl");
125
126 G4LMsdGenerator* diffGen = nullptr;
127 G4DiffElasticRatio* diffRatio = nullptr;
128 if( fDiffraction ) {
129 diffGen = new G4LMsdGenerator("LMsdDiffraction");
130 diffRatio = new G4DiffElasticRatio();
131 }
132
133 // Use Chips elastic model only for the hydrogen element and above an energy threshold
134 G4ChipsElasticModel* chipsH = new G4ChipsElasticModel();
135 chipsH->SetMinEnergy( elimitDiffuse );
136 const G4ElementTable* theElementTable = G4Element::GetElementTable();
137 for ( size_t i_ele = 0; i_ele < theElementTable->size(); i_ele++ ) {
138 G4Element* element = (*theElementTable)[ i_ele ];
139 if ( element->GetZ() > 1.0 ) chipsH->DeActivateFor( element );
140 }
141
142 // p
143 G4ParticleDefinition* particle = G4Proton::Proton();
144 G4HadronElasticProcess* hel = new G4HadronElasticProcess();
145 hel->AddDataSet(new G4BGGNucleonElasticXS(particle));
146 G4DiffuseElastic* protonDiffuseElastic = new G4DiffuseElastic();
147 protonDiffuseElastic->SetMinEnergy( elimitDiffuse );
148 hel->RegisterMe( chipsH ); // Use Chips only for Hydrogen element
149 hel->RegisterMe( protonDiffuseElastic );
150 hel->RegisterMe( lhep1 );
151 if( fDiffraction) hel->SetDiffraction(diffGen, diffRatio);
152 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
153 ph->RegisterProcess(hel, particle);
154
155 // n
156 particle = G4Neutron::Neutron();
157 hel = new G4HadronElasticProcess();
158 hel->AddDataSet(new G4NeutronElasticXS());
159 G4DiffuseElastic* neutronDiffuseElastic = new G4DiffuseElastic();
160 neutronDiffuseElastic->SetMinEnergy( elimitDiffuse );
161 hel->RegisterMe( chipsH ); // Use Chips only for Hydrogen element
162 hel->RegisterMe( neutronDiffuseElastic );
163 hel->RegisterMe( lhep1 );
164 if( fDiffraction) hel->SetDiffraction(diffGen, diffRatio);
165 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
166 ph->RegisterProcess(hel, particle);
167
168 // pi+
169 particle = G4PionPlus::PionPlus();
170 hel = new G4HadronElasticProcess();
171 hel->AddDataSet(new G4BGGPionElasticXS(particle));
172 G4DiffuseElastic* dElastic = new G4DiffuseElastic();
173 dElastic->SetMinEnergy( elimitDiffuse );
174 hel->RegisterMe( chipsH ); // Use Chips only for Hydrogen element
175 hel->RegisterMe( dElastic );
176 hel->RegisterMe( lhep1 );
177 if( fDiffraction) hel->SetDiffraction(diffGen, diffRatio);
178 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
179 ph->RegisterProcess(hel, particle);
180
181 // pi-
182 particle = G4PionMinus::PionMinus();
183 hel = new G4HadronElasticProcess();
184 hel->AddDataSet(new G4BGGPionElasticXS(particle));
185 dElastic = new G4DiffuseElastic();
186 dElastic->SetMinEnergy( elimitDiffuse );
187 hel->RegisterMe( chipsH ); // Use Chips only for Hydrogen element
188 hel->RegisterMe( dElastic );
189 hel->RegisterMe( lhep1 );
190 if( fDiffraction) hel->SetDiffraction(diffGen, diffRatio);
191 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
192 ph->RegisterProcess(hel, particle);
193
194 // kaons
195 G4HadronicBuilder::BuildElastic( G4HadParticles::GetKaons() );
196
197 // d, t, He3, alpha
198 for( auto & pdg : G4HadParticles::GetLightIons() ) {
199 particle = table->FindParticle( pdg );
200 if ( particle == nullptr ) { continue; }
201
202 hel = new G4HadronElasticProcess();
203 hel->AddDataSet(xsNN);
204 hel->RegisterMe(lhep0);
205 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorHadronElastic() );
206 ph->RegisterProcess(hel, particle);
207 }
208
209 // high energy particles
210 if( emax > param->EnergyThresholdForHeavyHadrons() ) {
211
212 // pbar, nbar, anti light ions
213 for( auto & pdg : G4HadParticles::GetLightAntiIons() ) {
214 particle = table->FindParticle( pdg );
215 if ( particle == nullptr ) { continue; }
216
217 hel = new G4HadronElasticProcess();
218 hel->RegisterMe(lhep2);
219 hel->RegisterMe(anuc);
220 hel->AddDataSet(anucxs);
221 if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorHadronElastic() );
222 ph->RegisterProcess(hel, particle);
223 }
224
225 // hyperons
226 G4HadronicBuilder::BuildElastic( G4HadParticles::GetHyperons() );
227 G4HadronicBuilder::BuildElastic( G4HadParticles::GetAntiHyperons() );
228
229 // b-, c- baryons and mesons
230 if( G4HadronicParameters::Instance()->EnableBCParticles() ) {
231 G4HadronicBuilder::BuildElastic( G4HadParticles::GetBCHadrons() );
232 }
233 }
234 }
235