Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4PomeronCrossSection.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
32#include "G4SystemOfUnits.hh"
33#include "G4Pow.hh" // factorial()
34
36 pomeron_Alpha(0), pomeron_Alpha_Hard(0), pomeron_Alphaprime(0),
37 pomeron_C(0), pomeron_Gamma(0), pomeron_Gamma_Hard(0),
38 pomeron_Rsquare(0), pomeron_S(0)
39{}
40
41
43{;}
44//**********************************************************************************************
45
47 {
48 G4int Encoding = std::abs(particle->GetPDGEncoding());
49
50 if (std::abs(particle->GetBaryonNumber())!=0)
51 InitForNucleon();
52 else if (Encoding/100== 3 || Encoding/10 == 3)
53 InitForKaon();
54 else
55 InitForPion();
56 }
57
58//**********************************************************************************************
59
61{
62 InitForNucleon();
63}
65{
66 InitForNucleon();
67}
68
70{
71 InitForPion();
72}
74{
75 InitForPion();
76}
78{
79 InitForPion();
80}
81
83{
84 InitForKaon();
85}
87{
88 InitForKaon();
89}
91{
92 InitForKaon();
93}
95{
96 InitForKaon();
97}
99{
100 InitForKaon();
101}
103{
104 InitForGamma();
105}
106
108{
109 G4double FZ2= Expand(Z(S)/2);
110 return SigP(S) * FZ2;
111}
112
113
115{
116 return SigP(S)/pomeron_C *(Expand(Z(S)/2) - Expand(Z(S)));
117}
118
120{
121 return ( pomeron_C -1) * GetElasticCrossSection(S);
122}
123
125{
127}
128
129//-------------------------Probabilities ----------------------------
130
132 const G4double impactsquare)
133{
134 return 2/pomeron_C*(1-std::exp(-1*Eikonal(S,impactsquare)));
135}
136
138 const G4double impactsquare)
139{
140 return (pomeron_C-1)/pomeron_C *
141 (GetTotalProbability(S,impactsquare) -
142 GetNondiffractiveProbability(S,impactsquare));
143}
144
146 const G4double impactsquare)
147{
148 return (1-std::exp(-2*Eikonal(S,impactsquare)))/pomeron_C;
149}
150
152 const G4double impactsquare)
153{
154 return (GetTotalProbability(S,impactsquare) -
155 GetInelasticProbability(S,impactsquare));
156}
157
159 const G4double impactsquare)
160{
161 return GetNondiffractiveProbability(S,impactsquare) +
162 GetDiffractiveProbability(S,impactsquare);
163}
164
166 const G4double impactsquare, const G4int nPomerons)
167{
168 G4double factorial=G4Pow::GetInstance()->factorial(nPomerons);
169
170 return std::exp(-2*Eikonal(S,impactsquare))/pomeron_C*
171 std::pow(2*Eikonal(S,impactsquare),nPomerons)/factorial;
172}
173
174// ---------------Temporary --- GF
176{
177 pomeron_Gamma=agam/GeV/GeV;
178}
179
180
181//----------------- private/Implementation methods
182
183void G4PomeronCrossSection::InitForNucleon()
184{
185// pomeron_S= 3.0*GeV*GeV;
186 pomeron_S= 2.7*GeV*GeV;
187// pomeron_Gamma= 2.16/GeV/GeV;
188// pomeron_Gamma= 3.96/GeV/GeV;
189 pomeron_Gamma= (2.6+3.96)/GeV/GeV;
190 pomeron_C= 1.4;
191 pomeron_Rsquare= 3.56/GeV/GeV;
192// pomeron_Alpha= 1.0808;
193 pomeron_Alpha= 0.9808;
194 pomeron_Alphaprime= 0.25/GeV/GeV;
195 pomeron_Gamma_Hard = 0.0002/GeV/GeV; // Note! if pomeron_Gamma_Hard != 0 to fit total pp-crosscection
196 // pomeron_Gamma_Soft shold be 2.35/GeV/GeV
197 pomeron_Alpha_Hard = 1.47;
198}
199
200void G4PomeronCrossSection::InitForPion()
201{
202 pomeron_S= 1.5*GeV*GeV;
203// pomeron_Gamma= 1.46/GeV/GeV;
204 pomeron_Gamma= 2.17/GeV/GeV;
205 pomeron_C= 1.6;
206 pomeron_Rsquare= 2.36/GeV/GeV;
207 pomeron_Alpha= 1.0808;
208 pomeron_Alphaprime= 0.25/GeV/GeV;
209 pomeron_Gamma_Hard = 0.0002/GeV/GeV;
210 pomeron_Alpha_Hard = 1.47;
211}
212
213void G4PomeronCrossSection::InitForKaon()
214{
215 pomeron_S= 2.3*GeV*GeV;
216// pomeron_Gamma= 1.31/GeV/GeV;
217 pomeron_Gamma= 1.92/GeV/GeV;
218 pomeron_C= 1.8;
219 pomeron_Rsquare= 1.96/GeV/GeV;
220 pomeron_Alpha= 1.0808;
221 pomeron_Alphaprime= 0.25/GeV/GeV;
222 pomeron_Gamma_Hard = 0.0002/GeV/GeV;
223 pomeron_Alpha_Hard = 1.47;
224}
225
226void G4PomeronCrossSection::InitForGamma()
227{
228 pomeron_S= 1.7*GeV*GeV;
229// pomeron_Gamma= 1.42/GeV/GeV;
230 pomeron_Gamma= 2.07/GeV/GeV;
231 pomeron_C= 1.7;
232 pomeron_Rsquare= 2.16/GeV/GeV;
233 pomeron_Alpha= 1.0808;
234 pomeron_Alphaprime= 0.25/GeV/GeV;
235 pomeron_Gamma_Hard = 0.0002/GeV/GeV;
236 pomeron_Alpha_Hard = 1.47;
237}
238
239G4double G4PomeronCrossSection::Expand(G4double z)
240{
241
242 G4double sum=1.;
243 G4double current=1.;
244 for (G4int j=2; j<21; j++ )
245 {
246 current *= -z *(j-1)/sqr(j);
247 sum+=current;
248 }
249 return sum;
250}
251
252inline G4double G4PomeronCrossSection::Power(const G4double S)
253{
254 return pomeron_Gamma *std::pow(S/pomeron_S, pomeron_Alpha -1);
255}
256
257inline G4double G4PomeronCrossSection::Z(const G4double S)
258{
259 return 2*pomeron_C * Power(S) / Lambda(S);
260}
261
262inline G4double G4PomeronCrossSection::Lambda(const G4double S)
263{
264 return pomeron_Rsquare+pomeron_Alphaprime*std::log(S/pomeron_S);
265}
266
267inline G4double G4PomeronCrossSection::SigP(const G4double S)
268{
269 return 8 * pi * hbarc_squared * Power(S);
270}
271
272inline G4double G4PomeronCrossSection::Eikonal(const G4double S,
273 const G4double impactsquare)
274{
275 return Z(S)/2 * std::exp(-impactsquare/(4*Lambda(S)*hbarc_squared));
276}
277//*************************************************************************************************
278inline G4double G4PomeronCrossSection::PowerSoft(const G4double S)
279 {
280 return pomeron_Gamma *std::pow(S/pomeron_S, pomeron_Alpha -1);
281 }
282
283inline G4double G4PomeronCrossSection::PowerHard(const G4double S)
284 {
285 return pomeron_Gamma_Hard*std::pow(S/pomeron_S, pomeron_Alpha_Hard -1);
286 }
287
288inline G4double G4PomeronCrossSection::LambdaSoft(const G4double S)
289 {
290 return pomeron_Rsquare+pomeron_Alphaprime*std::log(S/pomeron_S);
291 }
292
293inline G4double G4PomeronCrossSection::LambdaHard(const G4double /*S*/)
294 {
295 return pomeron_Rsquare; //+pomeron_Alphaprime*std::log(s/pomeron_S);
296 }
297
298inline G4double G4PomeronCrossSection::Zsoft(const G4double S)
299 {
300 return 2*pomeron_C*PowerHard(S) / LambdaSoft(S);
301 }
302
303inline G4double G4PomeronCrossSection::Zhard(const G4double S)
304 {
305 return 2*pomeron_C*PowerHard(S)/LambdaHard(S);
306 }
307
309 {
310 return Zsoft(S)/2*std::exp(-impactsquare/LambdaSoft(S)/hbarc_squared/4);
311 }
312
314 {
315 return Zhard(S)/2*std::exp(-impactsquare/LambdaHard(S)/hbarc_squared/4);
316 }
317
318//*************************************************************************************************
double G4double
Definition: G4Types.hh:64
int G4int
Definition: G4Types.hh:66
G4double GetTotalCrossSection(const G4double s)
G4double GetElasticCrossSection(const G4double s)
G4double HardEikonal(G4double s, G4double impactsquare)
void Setgamma(const G4double agam)
G4double GetNondiffractiveProbability(const G4double s, const G4double impactsquare)
G4double GetInelasticProbability(const G4double s, const G4double impactsquare)
G4double GetDiffractiveProbability(const G4double s, const G4double impactsquare)
G4double GetCutPomeronProbability(const G4double s, const G4double impactsquare, const G4int nPomerons)
G4double GetInelasticCrossSection(const G4double s)
G4PomeronCrossSection(const G4ParticleDefinition *)
G4double SoftEikonal(G4double s, G4double impactsquare)
G4double GetDiffractiveCrossSection(const G4double s)
G4double GetElasticProbability(const G4double s, const G4double impactsquare)
G4double GetTotalProbability(const G4double s, const G4double impactsquare)
static G4Pow * GetInstance()
Definition: G4Pow.cc:50
G4double factorial(G4int Z)
Definition: G4Pow.hh:190
const G4double pi
T sqr(const T &x)
Definition: templates.hh:145