| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // INCL++ intra-nuclear cascade model 26 // INCL++ intra-nuclear cascade model
27 // Alain Boudard, CEA-Saclay, France 27 // Alain Boudard, CEA-Saclay, France
28 // Joseph Cugnon, University of Liege, Belgium 28 // Joseph Cugnon, University of Liege, Belgium
29 // Jean-Christophe David, CEA-Saclay, France 29 // Jean-Christophe David, CEA-Saclay, France
30 // Pekka Kaitaniemi, CEA-Saclay, France, and H 30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
31 // Sylvie Leray, CEA-Saclay, France 31 // Sylvie Leray, CEA-Saclay, France
32 // Davide Mancusi, CEA-Saclay, France 32 // Davide Mancusi, CEA-Saclay, France
33 // 33 //
34 #define INCLXX_IN_GEANT4_MODE 1 34 #define INCLXX_IN_GEANT4_MODE 1
35 35
36 #include "globals.hh" 36 #include "globals.hh"
37 37
38 #include "G4INCLCrossSectionsINCL46.hh" 38 #include "G4INCLCrossSectionsINCL46.hh"
39 #include "G4INCLKinematicsUtils.hh" 39 #include "G4INCLKinematicsUtils.hh"
40 #include "G4INCLParticleTable.hh" 40 #include "G4INCLParticleTable.hh"
41 #include "G4INCLLogger.hh" 41 #include "G4INCLLogger.hh"
42 // #include <cassert> 42 // #include <cassert>
43 43
44 namespace G4INCL { 44 namespace G4INCL {
45 45
46 /* G4double elasticNNHighEnergy(const G4dou 46 /* G4double elasticNNHighEnergy(const G4double momentum) {
47 return 77.0/(momentum + 1.5); 47 return 77.0/(momentum + 1.5);
48 } 48 }
49 49
50 G4double elasticProtonNeutron(const G4doub 50 G4double elasticProtonNeutron(const G4double momentum) {
51 if(momentum < 0.450) { 51 if(momentum < 0.450) {
52 const G4double alp = std::log(momentum 52 const G4double alp = std::log(momentum);
53 return 6.3555*std::exp(-3.2481*alp-0.3 53 return 6.3555*std::exp(-3.2481*alp-0.377*alp*alp);
54 } else if(momentum >= 0.450 && momentum 54 } else if(momentum >= 0.450 && momentum < 0.8) {
55 return (33.0 + 196.0 * std::sqrt(std:: 55 return (33.0 + 196.0 * std::sqrt(std::pow(std::abs(momentum - 0.95), 5)));
56 } else if(momentum > 2.0) { 56 } else if(momentum > 2.0) {
57 return elasticNNHighEnergy(momentum); 57 return elasticNNHighEnergy(momentum);
58 } else { 58 } else {
59 return 31.0/std::sqrt(momentum); 59 return 31.0/std::sqrt(momentum);
60 } 60 }
61 } 61 }
62 62
63 G4double elasticProtonProtonOrNeutronNeutr 63 G4double elasticProtonProtonOrNeutronNeutron(const G4double momentum)
64 { 64 {
65 if(momentum < 0.440) { 65 if(momentum < 0.440) {
66 return 34.0*std::pow(momentum/0.4, -2. 66 return 34.0*std::pow(momentum/0.4, -2.104);
67 } else if(momentum < 0.8 && momentum >= 67 } else if(momentum < 0.8 && momentum >= 0.440) {
68 return (23.5 + 1000.0*std::pow(momentu 68 return (23.5 + 1000.0*std::pow(momentum-0.7, 4));
69 } else if(momentum < 2.0) { 69 } else if(momentum < 2.0) {
70 return (1250.0/(50.0 + momentum) - 4.0 70 return (1250.0/(50.0 + momentum) - 4.0*std::pow(momentum-1.3, 2));
71 } else { 71 } else {
72 return elasticNNHighEnergy(momentum); 72 return elasticNNHighEnergy(momentum);
73 } 73 }
74 } 74 }
75 75
76 G4double elasticNN(Particle const * const 76 G4double elasticNN(Particle const * const p1, Particle const * const p2) {
77 G4double momentum = 0.0; 77 G4double momentum = 0.0;
78 momentum = 0.001 * KinematicsUtils::mome 78 momentum = 0.001 * KinematicsUtils::momentumInLab(p1, p2);
79 if((p1->getType() == Proton && p2->getTy 79 if((p1->getType() == Proton && p2->getType() == Proton) ||
80 (p1->getType() == Neutron && p2->getT 80 (p1->getType() == Neutron && p2->getType() == Neutron)) {
81 return elasticProtonProtonOrNeutronNeu 81 return elasticProtonProtonOrNeutronNeutron(momentum);
82 } else if((p1->getType() == Proton && p2 82 } else if((p1->getType() == Proton && p2->getType() == Neutron) ||
83 (p1->getType() == Neutron && p 83 (p1->getType() == Neutron && p2->getType() == Proton)) {
84 return elasticProtonNeutron(momentum); 84 return elasticProtonNeutron(momentum);
85 } else { 85 } else {
86 INCL_ERROR("CrossSectionsINCL46::elast 86 INCL_ERROR("CrossSectionsINCL46::elasticNN: Bad input!" << '\n'
87 << p1->print() << p2->print() << 87 << p1->print() << p2->print() << '\n');
88 } 88 }
89 return 0.0; 89 return 0.0;
90 }:*/ 90 }:*/
91 91
92 G4double CrossSectionsINCL46::elasticNNLeg 92 G4double CrossSectionsINCL46::elasticNNLegacy(Particle const * const part1, Particle const * const part2) {
93 93
94 94
95 G4int i = ParticleTable::getIsospin(pa 95 G4int i = ParticleTable::getIsospin(part1->getType())
96 + ParticleTable::getIsospin(part2->get 96 + ParticleTable::getIsospin(part2->getType());
97 97
98 /* The NN cross section is parametrise 98 /* The NN cross section is parametrised as a function of the lab momentum
99 * of one of the nucleons. For NDelta 99 * of one of the nucleons. For NDelta or DeltaDelta, the physical
100 * assumption is that the cross sectio 100 * assumption is that the cross section is the same as NN *for the same
101 * total CM energy*. Thus, we calculat 101 * total CM energy*. Thus, we calculate s from the particles involved, and
102 * we convert this value to the lab mo 102 * we convert this value to the lab momentum of a nucleon *as if this were
103 * an NN collision*. 103 * an NN collision*.
104 */ 104 */
105 105
106 const G4double s = KinematicsUtils::sq 106 const G4double s = KinematicsUtils::squareTotalEnergyInCM(part1, part2);
107 G4double plab = 0.001*KinematicsUtils: 107 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
108 if(plab > 2.) { // NN, Delta-Nucleon a 108 if(plab > 2.) { // NN, Delta-Nucleon and Delta-Delta for plab > 2.0 GeV
109 return 77./(plab+1.5); 109 return 77./(plab+1.5);
110 } 110 }
111 else if (part1->isNucleon() && part2-> 111 else if (part1->isNucleon() && part2->isNucleon()){ // NN
112 if (i == 0) { // pn 112 if (i == 0) { // pn
113 if (plab < 0.450) { 113 if (plab < 0.450) {
114 G4double alp=std::log(plab 114 G4double alp=std::log(plab);
115 return 6.3555*std::exp(-3. 115 return 6.3555*std::exp(-3.2481*alp-0.377*alp*alp);
116 } 116 }
117 else if (plab < 0.800) { 117 else if (plab < 0.800) {
118 return (33.+196.*std::sqrt 118 return (33.+196.*std::sqrt(std::pow(std::abs(plab-0.95),5)));
119 } 119 }
120 else { 120 else {
121 return 31./std::sqrt(plab) 121 return 31./std::sqrt(plab);
122 } 122 }
123 } 123 }
124 else { // nn and pp 124 else { // nn and pp
125 if (plab < 0.440) { 125 if (plab < 0.440) {
126 return 34.*std::pow(plab/0 126 return 34.*std::pow(plab/0.4, (-2.104));
127 } 127 }
128 else if (plab < 0.800) { 128 else if (plab < 0.800) {
129 return (23.5+1000.*std::po 129 return (23.5+1000.*std::pow(plab-0.7, 4));
130 } 130 }
131 else { 131 else {
132 return (1250./(50.+plab)-4 132 return (1250./(50.+plab)-4.*std::pow(plab-1.3, 2));
133 } 133 }
134 } 134 }
135 } 135 }
136 else { // Delta-Nucleon and Delta-De 136 else { // Delta-Nucleon and Delta-Delta
137 if (plab < 0.440) { 137 if (plab < 0.440) {
138 return 34.*std::pow(plab/0.4, 138 return 34.*std::pow(plab/0.4, (-2.104));
139 } 139 }
140 else if (plab < 0.800) { 140 else if (plab < 0.800) {
141 return (23.5+1000.*std::pow(pl 141 return (23.5+1000.*std::pow(plab-0.7, 4));
142 } 142 }
143 else { 143 else {
144 return (1250./(50.+plab)-4.*st 144 return (1250./(50.+plab)-4.*std::pow(plab-1.3, 2));
145 } 145 }
146 } 146 }
147 } 147 }
148 148
149 G4double CrossSectionsINCL46::deltaProductio 149 G4double CrossSectionsINCL46::deltaProduction(const G4int isospin, const G4double pLab) {
150 G4double xs = 0.0; 150 G4double xs = 0.0;
151 // assert(isospin==-2 || isospin==0 || isospin 151 // assert(isospin==-2 || isospin==0 || isospin==2);
152 152
153 const G4double momentumGeV = 0.001 * pLab; 153 const G4double momentumGeV = 0.001 * pLab;
154 if(pLab < 800.0) { 154 if(pLab < 800.0) {
155 return 0.0; 155 return 0.0;
156 } 156 }
157 157
158 if(isospin==2 || isospin==-2) { // pp, nn 158 if(isospin==2 || isospin==-2) { // pp, nn
159 if(pLab >= 2000.0) { 159 if(pLab >= 2000.0) {
160 xs = (41.0 + (60.0*momentumGeV - 54.0) 160 xs = (41.0 + (60.0*momentumGeV - 54.0)*std::exp(-1.2*momentumGeV) - 77.0/(momentumGeV + 1.5));
161 } else if(pLab >= 1500.0 && pLab < 2000. 161 } else if(pLab >= 1500.0 && pLab < 2000.0) {
162 xs = (41.0 + 60.0*(momentumGeV - 0.9)* 162 xs = (41.0 + 60.0*(momentumGeV - 0.9)*std::exp(-1.2*momentumGeV) - 1250.0/(momentumGeV+50.0)+ 4.0*std::pow(momentumGeV - 1.3, 2));
163 } else if(pLab < 1500.0) { 163 } else if(pLab < 1500.0) {
164 xs = (23.5 + 24.6/(1.0 + std::exp(-10. 164 xs = (23.5 + 24.6/(1.0 + std::exp(-10.0*momentumGeV + 12.0))
165 -1250.0/(momentumGeV +50.0)+4.0* 165 -1250.0/(momentumGeV +50.0)+4.0*std::pow(momentumGeV - 1.3,2));
166 } 166 }
167 } else if(isospin==0) { // pn 167 } else if(isospin==0) { // pn
168 if(pLab >= 2000.0) { 168 if(pLab >= 2000.0) {
169 xs = (42.0 - 77.0/(momentumGeV + 1.5)) 169 xs = (42.0 - 77.0/(momentumGeV + 1.5));
170 } else if(pLab >= 1000.0 && pLab < 2000. 170 } else if(pLab >= 1000.0 && pLab < 2000.0) {
171 xs = (24.2 + 8.9*momentumGeV - 31.1/st 171 xs = (24.2 + 8.9*momentumGeV - 31.1/std::sqrt(momentumGeV));
172 } else if(pLab < 1000.0) { 172 } else if(pLab < 1000.0) {
173 xs = (33.0 + 196.0*std::sqrt(std::pow( 173 xs = (33.0 + 196.0*std::sqrt(std::pow(std::abs(momentumGeV - 0.95),5))
174 -31.1/std::sqrt(momentumGeV)); 174 -31.1/std::sqrt(momentumGeV));
175 } 175 }
176 } 176 }
177 177
178 if(xs < 0.0) return 0.0; 178 if(xs < 0.0) return 0.0;
179 else return xs; 179 else return xs;
180 } 180 }
181 181
182 G4double CrossSectionsINCL46::spnPiPlusPHE(c 182 G4double CrossSectionsINCL46::spnPiPlusPHE(const G4double x) {
183 // HE and LE pi- p and pi+ n 183 // HE and LE pi- p and pi+ n
184 if(x <= 1750.0) { 184 if(x <= 1750.0) {
185 return -2.33730e-06*std::pow(x, 3)+1.138 185 return -2.33730e-06*std::pow(x, 3)+1.13819e-02*std::pow(x,2)
186 -1.83993e+01*x+9893.4; 186 -1.83993e+01*x+9893.4;
187 } else if(x > 1750.0 && x <= 2175.0) { 187 } else if(x > 1750.0 && x <= 2175.0) {
188 return 1.13531e-06*std::pow(x, 3)-6.9169 188 return 1.13531e-06*std::pow(x, 3)-6.91694e-03*std::pow(x, 2)
189 +1.39907e+01*x-9360.76; 189 +1.39907e+01*x-9360.76;
190 } else { 190 } else {
191 return -3.18087*std::log(x)+52.9784; 191 return -3.18087*std::log(x)+52.9784;
192 } 192 }
193 } 193 }
194 194
195 G4double CrossSectionsINCL46::spnPiMinusPHE( 195 G4double CrossSectionsINCL46::spnPiMinusPHE(const G4double x) {
196 // HE pi- p and pi+ n 196 // HE pi- p and pi+ n
197 if(x <= 1475.0) { 197 if(x <= 1475.0) {
198 return 0.00120683*(x-1372.52)*(x-1372.52 198 return 0.00120683*(x-1372.52)*(x-1372.52)+26.2058;
199 } else if(x > 1475.0 && x <= 1565.0) { 199 } else if(x > 1475.0 && x <= 1565.0) {
200 return 1.15873e-05*x*x+49965.6/((x-1519. 200 return 1.15873e-05*x*x+49965.6/((x-1519.59)*(x-1519.59)+2372.55);
201 } else if(x > 1565.0 && x <= 2400.0) { 201 } else if(x > 1565.0 && x <= 2400.0) {
202 return 34.0248+43262.2/((x-1681.65)*(x-1 202 return 34.0248+43262.2/((x-1681.65)*(x-1681.65)+1689.35);
203 } else if(x > 2400.0 && x <= 7500.0) { 203 } else if(x > 2400.0 && x <= 7500.0) {
204 return 3.3e-7*(x-7500.0)*(x-7500.0)+24.5 204 return 3.3e-7*(x-7500.0)*(x-7500.0)+24.5;
205 } else { 205 } else {
206 return 24.5; 206 return 24.5;
207 } 207 }
208 } 208 }
209 209
210 G4double CrossSectionsINCL46::total(Particle 210 G4double CrossSectionsINCL46::total(Particle const * const p1, Particle const * const p2) {
211 G4double inelastic = 0.0; 211 G4double inelastic = 0.0;
212 if(p1->isNucleon() && p2->isNucleon()) { 212 if(p1->isNucleon() && p2->isNucleon()) {
213 inelastic = NNToNDelta(p1, p2); 213 inelastic = NNToNDelta(p1, p2);
214 } else if((p1->isNucleon() && p2->isDelta( 214 } else if((p1->isNucleon() && p2->isDelta()) ||
215 (p1->isDelta() && p2->isNucleon( 215 (p1->isDelta() && p2->isNucleon())) {
216 inelastic = NDeltaToNN(p1, p2); 216 inelastic = NDeltaToNN(p1, p2);
217 } else if((p1->isNucleon() && p2->isPion() 217 } else if((p1->isNucleon() && p2->isPion()) ||
218 (p1->isPion() && p2->isNucleon() 218 (p1->isPion() && p2->isNucleon())) {
219 inelastic = piNToDelta(p1, p2); 219 inelastic = piNToDelta(p1, p2);
220 } else { 220 } else {
221 inelastic = 0.0; 221 inelastic = 0.0;
222 } 222 }
223 223
224 return inelastic + elastic(p1, p2); 224 return inelastic + elastic(p1, p2);
225 } 225 }
226 226
227 G4double CrossSectionsINCL46::piNToDelta(Par 227 G4double CrossSectionsINCL46::piNToDelta(Particle const * const particle1, Particle const * const particle2) {
228 // FUNCTION SPN(X,IND2T3,IPIT3,f17) 228 // FUNCTION SPN(X,IND2T3,IPIT3,f17)
229 // SIGMA(PI+ + P) IN THE (3,3) REGION 229 // SIGMA(PI+ + P) IN THE (3,3) REGION
230 // NEW FIT BY J.VANDERMEULEN + FIT BY Th 230 // NEW FIT BY J.VANDERMEULEN + FIT BY Th AOUST ABOVE (3,3) RES
231 // CONST AT L 231 // CONST AT LOW AND VERY HIGH ENERGY
232 // COMMON/BL8/RATHR,RAMASS 232 // COMMON/BL8/RATHR,RAMASS REL21800
233 // integer f17 233 // integer f17
234 // RATHR and RAMASS are always 0.0!!! 234 // RATHR and RAMASS are always 0.0!!!
235 235
236 G4double x = KinematicsUtils::totalEnergyI 236 G4double x = KinematicsUtils::totalEnergyInCM(particle1, particle2);
237 if(x>10000.) return 0.0; // no cross secti 237 if(x>10000.) return 0.0; // no cross section above this value
238 238
239 G4int ipit3 = 0; 239 G4int ipit3 = 0;
240 G4int ind2t3 = 0; 240 G4int ind2t3 = 0;
241 G4double ramass = 0.0; 241 G4double ramass = 0.0;
242 242
243 if(particle1->isPion()) { 243 if(particle1->isPion()) {
244 ipit3 = ParticleTable::getIsospin(partic 244 ipit3 = ParticleTable::getIsospin(particle1->getType());
245 } else if(particle2->isPion()) { 245 } else if(particle2->isPion()) {
246 ipit3 = ParticleTable::getIsospin(partic 246 ipit3 = ParticleTable::getIsospin(particle2->getType());
247 } 247 }
248 248
249 if(particle1->isNucleon()) { 249 if(particle1->isNucleon()) {
250 ind2t3 = ParticleTable::getIsospin(parti 250 ind2t3 = ParticleTable::getIsospin(particle1->getType());
251 } else if(particle2->isNucleon()) { 251 } else if(particle2->isNucleon()) {
252 ind2t3 = ParticleTable::getIsospin(parti 252 ind2t3 = ParticleTable::getIsospin(particle2->getType());
253 } 253 }
254 254
255 G4double y=x*x; 255 G4double y=x*x;
256 G4double q2=(y-1076.0*1076.0)*(y-800.0*800 256 G4double q2=(y-1076.0*1076.0)*(y-800.0*800.0)/y/4.0;
257 if (q2 <= 0.) { 257 if (q2 <= 0.) {
258 return 0.0; 258 return 0.0;
259 } 259 }
260 G4double q3 = std::pow(std::sqrt(q2),3); 260 G4double q3 = std::pow(std::sqrt(q2),3);
261 G4double f3 = q3/(q3 + 5832000.); // 58320 261 G4double f3 = q3/(q3 + 5832000.); // 5832000 = 180^3
262 G4double spnResult = 326.5/(std::pow((x-12 262 G4double spnResult = 326.5/(std::pow((x-1215.0-ramass)*2.0/(110.0-ramass), 2)+1.0);
263 spnResult = spnResult*(1.0-5.0*ramass/1215 263 spnResult = spnResult*(1.0-5.0*ramass/1215.0);
264 G4double cg = 4.0 + G4double(ind2t3)*G4dou 264 G4double cg = 4.0 + G4double(ind2t3)*G4double(ipit3);
265 spnResult = spnResult*f3*cg/6.0; 265 spnResult = spnResult*f3*cg/6.0;
266 266
267 if(x < 1200.0 && spnResult < 5.0) { 267 if(x < 1200.0 && spnResult < 5.0) {
268 spnResult = 5.0; 268 spnResult = 5.0;
269 } 269 }
270 270
271 // HE pi+ p and pi- n 271 // HE pi+ p and pi- n
272 if(x > 1290.0) { 272 if(x > 1290.0) {
273 if((ind2t3 == 1 && ipit3 == 2) || (ind2t 273 if((ind2t3 == 1 && ipit3 == 2) || (ind2t3 == -1 && ipit3 == -2))
274 spnResult=spnPiPlusPHE(x); 274 spnResult=spnPiPlusPHE(x);
275 else if((ind2t3 == 1 && ipit3 == -2) || 275 else if((ind2t3 == 1 && ipit3 == -2) || (ind2t3 == -1 && ipit3 == 2))
276 spnResult=spnPiMinusPHE(x); 276 spnResult=spnPiMinusPHE(x);
277 else if(ipit3 == 0) spnResult = (spnPiPl 277 else if(ipit3 == 0) spnResult = (spnPiPlusPHE(x) + spnPiMinusPHE(x))/2.0; // (spnpipphe(x)+spnpimphe(x))/2.0
278 else { 278 else {
279 INCL_ERROR("Unknown configuration!" << 279 INCL_ERROR("Unknown configuration!" << '\n');
280 } 280 }
281 } 281 }
282 282
283 return spnResult; 283 return spnResult;
284 } 284 }
285 285
286 G4double CrossSectionsINCL46::NDeltaToNN(Par 286 G4double CrossSectionsINCL46::NDeltaToNN(Particle const * const p1, Particle const * const p2) {
287 const G4int isospin = ParticleTable::getIs 287 const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
288 if(isospin==4 || isospin==-4) return 0.0; 288 if(isospin==4 || isospin==-4) return 0.0;
289 289
290 G4double s = KinematicsUtils::squareTotalE 290 G4double s = KinematicsUtils::squareTotalEnergyInCM(p1, p2);
291 G4double Ecm = std::sqrt(s); 291 G4double Ecm = std::sqrt(s);
292 G4int deltaIsospin; 292 G4int deltaIsospin;
293 G4double deltaMass; 293 G4double deltaMass;
294 if(p1->isDelta()) { 294 if(p1->isDelta()) {
295 deltaIsospin = ParticleTable::getIsospin 295 deltaIsospin = ParticleTable::getIsospin(p1->getType());
296 deltaMass = p1->getMass(); 296 deltaMass = p1->getMass();
297 } else { 297 } else {
298 deltaIsospin = ParticleTable::getIsospin 298 deltaIsospin = ParticleTable::getIsospin(p2->getType());
299 deltaMass = p2->getMass(); 299 deltaMass = p2->getMass();
300 } 300 }
301 301
302 if(Ecm <= 938.3 + deltaMass) { 302 if(Ecm <= 938.3 + deltaMass) {
303 return 0.0; 303 return 0.0;
304 } 304 }
305 305
306 if(Ecm < 938.3 + deltaMass + 2.0) { 306 if(Ecm < 938.3 + deltaMass + 2.0) {
307 Ecm = 938.3 + deltaMass + 2.0; 307 Ecm = 938.3 + deltaMass + 2.0;
308 s = Ecm*Ecm; 308 s = Ecm*Ecm;
309 } 309 }
310 310
311 const G4double x = (s - 4.*ParticleTable:: 311 const G4double x = (s - 4.*ParticleTable::effectiveNucleonMass2) /
312 (s - std::pow(ParticleTable::effectiveNu 312 (s - std::pow(ParticleTable::effectiveNucleonMass + deltaMass, 2));
313 const G4double y = s/(s - std::pow(deltaMa 313 const G4double y = s/(s - std::pow(deltaMass - ParticleTable::effectiveNucleonMass, 2));
314 /* Concerning the way we calculate the lab 314 /* Concerning the way we calculate the lab momentum, see the considerations
315 * in CrossSections::elasticNNLegacy(). 315 * in CrossSections::elasticNNLegacy().
316 */ 316 */
317 const G4double pLab = KinematicsUtils::mom 317 const G4double pLab = KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
318 G4double result = 0.5 * x * y * deltaProdu 318 G4double result = 0.5 * x * y * deltaProduction(isospin, pLab);
319 result *= 3.*(32.0 + isospin * isospin * ( 319 result *= 3.*(32.0 + isospin * isospin * (deltaIsospin * deltaIsospin - 5))/64.0;
320 result /= 1.0 + 0.25 * isospin * isospin; 320 result /= 1.0 + 0.25 * isospin * isospin;
321 return result; 321 return result;
322 } 322 }
323 323
324 G4double CrossSectionsINCL46::NNToNDelta(Par 324 G4double CrossSectionsINCL46::NNToNDelta(Particle const * const p1, Particle const * const p2) {
325 // assert(p1->isNucleon() && p2->isNucleon()); 325 // assert(p1->isNucleon() && p2->isNucleon());
326 const G4double sqrts = KinematicsUtils::to 326 const G4double sqrts = KinematicsUtils::totalEnergyInCM(p1,p2);
327 if(sqrts < ParticleTable::effectivePionMas 327 if(sqrts < ParticleTable::effectivePionMass + 2*ParticleTable::effectiveNucleonMass + 50.) { // approximately yields INCL4.6's hard-coded threshold in collis, 2065 MeV
328 return 0.0; 328 return 0.0;
329 } else { 329 } else {
330 const G4double pLab = KinematicsUtils::m 330 const G4double pLab = KinematicsUtils::momentumInLab(p1,p2);
331 const G4int isospin = ParticleTable::get 331 const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
332 return deltaProduction(isospin, pLab); 332 return deltaProduction(isospin, pLab);
333 } 333 }
334 } 334 }
335 335
336 G4double CrossSectionsINCL46::elastic(Partic 336 G4double CrossSectionsINCL46::elastic(Particle const * const p1, Particle const * const p2) {
337 // if(!p1->isPion() && !p2->isPion()) 337 // if(!p1->isPion() && !p2->isPion())
338 if((p1->isNucleon()||p1->isDelta()) && (p2 338 if((p1->isNucleon()||p1->isDelta()) && (p2->isNucleon()||p2->isDelta()))
339 // return elasticNN(p1, p2); // New i 339 // return elasticNN(p1, p2); // New implementation
340 return elasticNNLegacy(p1, p2); // Trans 340 return elasticNNLegacy(p1, p2); // Translated from INCL4.6 FORTRAN
341 else 341 else
342 return 0.0; // No pion-nucleon elastic s 342 return 0.0; // No pion-nucleon elastic scattering
343 } 343 }
344 344
345 G4double CrossSectionsINCL46::calculateNNAng 345 G4double CrossSectionsINCL46::calculateNNAngularSlope(G4double pl, G4int iso) {
346 G4double x = 0.001 * pl; // Change to GeV 346 G4double x = 0.001 * pl; // Change to GeV
347 if(iso != 0) { 347 if(iso != 0) {
348 if(pl <= 2000.0) { 348 if(pl <= 2000.0) {
349 x = std::pow(x, 8); 349 x = std::pow(x, 8);
350 return 5.5e-6 * x/(7.7 + x); 350 return 5.5e-6 * x/(7.7 + x);
351 } else { 351 } else {
352 return (5.34 + 0.67*(x - 2.0)) * 1.0e- 352 return (5.34 + 0.67*(x - 2.0)) * 1.0e-6;
353 } 353 }
354 } else { 354 } else {
355 if(pl < 800.0) { 355 if(pl < 800.0) {
356 G4double b = (7.16 - 1.63*x) * 1.0e-6; 356 G4double b = (7.16 - 1.63*x) * 1.0e-6;
357 return b/(1.0 + std::exp(-(x - 0.45)/0 357 return b/(1.0 + std::exp(-(x - 0.45)/0.05));
358 } else if(pl < 1100.0) { 358 } else if(pl < 1100.0) {
359 return (9.87 - 4.88 * x) * 1.0e-6; 359 return (9.87 - 4.88 * x) * 1.0e-6;
360 } else { 360 } else {
361 return (3.68 + 0.76*x) * 1.0e-6; 361 return (3.68 + 0.76*x) * 1.0e-6;
362 } 362 }
363 } 363 }
364 return 0.0; // Should never reach this poi 364 return 0.0; // Should never reach this point
365 } 365 }
366 366
367 367
368 G4double CrossSectionsINCL46::NNToxPiNN(co 368 G4double CrossSectionsINCL46::NNToxPiNN(const G4int, Particle const * const, Particle const * const) {
369 return 0.; 369 return 0.;
370 } 370 }
371 371
372 G4double CrossSectionsINCL46::piNToxPiN(co 372 G4double CrossSectionsINCL46::piNToxPiN(const G4int, Particle const * const, Particle const * const) {
373 return 0.; 373 return 0.;
374 } 374 }
375 375
376 G4double CrossSectionsINCL46::piNToEtaN(Pa 376 G4double CrossSectionsINCL46::piNToEtaN(Particle const * const, Particle const * const) {
377 // 377 //
378 // Pion-Nucleon producing Eta cross se 378 // Pion-Nucleon producing Eta cross sections
379 // 379 //
380 return 0.; 380 return 0.;
381 } 381 }
382 382
383 G4double CrossSectionsINCL46::piNToOmegaN( 383 G4double CrossSectionsINCL46::piNToOmegaN(Particle const * const, Particle const * const) {
384 // 384 //
385 // Pion-Nucleon producing Omega cross 385 // Pion-Nucleon producing Omega cross sections
386 // 386 //
387 return 0.; 387 return 0.;
388 } 388 }
389 389
390 G4double CrossSectionsINCL46::piNToEtaPrim 390 G4double CrossSectionsINCL46::piNToEtaPrimeN(Particle const * const, Particle const * const) {
391 // 391 //
392 // Pion-Nucleon producing EtaPrime cro 392 // Pion-Nucleon producing EtaPrime cross sections
393 // 393 //
394 return 0.; 394 return 0.;
395 } 395 }
396 396
397 G4double CrossSectionsINCL46::etaNToPiN(Pa 397 G4double CrossSectionsINCL46::etaNToPiN(Particle const * const, Particle const * const) {
398 // 398 //
399 // Eta-Nucleon producing Pion cross se 399 // Eta-Nucleon producing Pion cross sections
400 // 400 //
401 return 0.; 401 return 0.;
402 } 402 }
403 403
404 404
405 G4double CrossSectionsINCL46::etaNToPiPiN 405 G4double CrossSectionsINCL46::etaNToPiPiN(Particle const * const, Particle const * const) {
406 // 406 //
407 // Eta-Nucleon producing Two Pions cro 407 // Eta-Nucleon producing Two Pions cross sections
408 // 408 //
409 return 0.; 409 return 0.;
410 } 410 }
411 411
412 G4double CrossSectionsINCL46::omegaNToPiN( 412 G4double CrossSectionsINCL46::omegaNToPiN(Particle const * const, Particle const * const) {
413 // 413 //
414 // Omega-Nucleon producing Pion cross 414 // Omega-Nucleon producing Pion cross sections
415 // 415 //
416 return 0.; 416 return 0.;
417 } 417 }
418 418
419 G4double CrossSectionsINCL46::omegaNToPiPi 419 G4double CrossSectionsINCL46::omegaNToPiPiN(Particle const * const, Particle const * const) {
420 // 420 //
421 // Omega-Nucleon producing Two Pions c 421 // Omega-Nucleon producing Two Pions cross sections
422 // 422 //
423 return 0.; 423 return 0.;
424 } 424 }
425 425
426 G4double CrossSectionsINCL46::etaPrimeNToP 426 G4double CrossSectionsINCL46::etaPrimeNToPiN(Particle const * const, Particle const * const) {
427 // 427 //
428 // EtaPrime-Nucleon producing Pion cro 428 // EtaPrime-Nucleon producing Pion cross sections
429 // 429 //
430 return 0.; 430 return 0.;
431 } 431 }
432 432
433 G4double CrossSectionsINCL46::NNToNNEta(Pa 433 G4double CrossSectionsINCL46::NNToNNEta(Particle const * const, Particle const * const) {
434 // 434 //
435 // Nucleon-Nucleon producing Eta cross 435 // Nucleon-Nucleon producing Eta cross sections
436 // 436 //
437 return 0.; 437 return 0.;
438 } 438 }
439 439
440 G4double CrossSectionsINCL46::NNToNNEtaEx 440 G4double CrossSectionsINCL46::NNToNNEtaExclu(Particle const * const, Particle const * const) {
441 // 441 //
442 // Nucleon-Nucleon producing Eta cross 442 // Nucleon-Nucleon producing Eta cross sections
443 // 443 //
444 return 0.; 444 return 0.;
445 } 445 }
446 446
447 G4double CrossSectionsINCL46::NNToNNEtaxPi 447 G4double CrossSectionsINCL46::NNToNNEtaxPi(const G4int, Particle const * const, Particle const * const) {
448 return 0.; 448 return 0.;
449 } 449 }
450 450
451 G4double CrossSectionsINCL46::NNToNDeltaE 451 G4double CrossSectionsINCL46::NNToNDeltaEta(Particle const * const, Particle const * const) {
452 // 452 //
453 // Nucleon-Nucleon producing N-Delta-E 453 // Nucleon-Nucleon producing N-Delta-Eta cross sections
454 // 454 //
455 return 0.; 455 return 0.;
456 } 456 }
457 457
458 G4double CrossSectionsINCL46::NNToNNOmega( 458 G4double CrossSectionsINCL46::NNToNNOmega(Particle const * const, Particle const * const) {
459 // 459 //
460 // Nucleon-Nucleon producing Omega cro 460 // Nucleon-Nucleon producing Omega cross sections
461 // 461 //
462 return 0.; 462 return 0.;
463 } 463 }
464 464
465 G4double CrossSectionsINCL46::NNToNNOmegaE 465 G4double CrossSectionsINCL46::NNToNNOmegaExclu(Particle const * const, Particle const * const) {
466 // 466 //
467 // Nucleon-Nucleon producing Omega cro 467 // Nucleon-Nucleon producing Omega cross sections
468 // 468 //
469 return 0.; 469 return 0.;
470 } 470 }
471 471
472 G4double CrossSectionsINCL46::NNToNNOmegax 472 G4double CrossSectionsINCL46::NNToNNOmegaxPi(const G4int, Particle const * const, Particle const * const) {
473 return 0.; 473 return 0.;
474 } 474 }
475 475
476 G4double CrossSectionsINCL46::NNToNDeltaOm 476 G4double CrossSectionsINCL46::NNToNDeltaOmega(Particle const * const, Particle const * const) {
477 // 477 //
478 // Nucleon-Nucleon producing N-Delta-Ome 478 // Nucleon-Nucleon producing N-Delta-Omega cross sections
479 // 479 //
480 return 0.; 480 return 0.;
481 } 481 }
482 482
483 483
484 484
485 G4double CrossSectionsINCL46::NYelastic(Pa 485 G4double CrossSectionsINCL46::NYelastic(Particle const * const , Particle const * const ) {
486 // 486 //
487 // Hyperon-Nucleon elastic cross 487 // Hyperon-Nucleon elastic cross sections
488 // 488 //
489 return 0.; 489 return 0.;
490 } 490 }
491 491
492 G4double CrossSectionsINCL46::NKelastic(Pa 492 G4double CrossSectionsINCL46::NKelastic(Particle const * const , Particle const * const ) {
493 // 493 //
494 // Kaon-Nucleon elastic cross sec 494 // Kaon-Nucleon elastic cross sections
495 // 495 //
496 return 0.; 496 return 0.;
497 } 497 }
498 498
499 G4double CrossSectionsINCL46::NKbelastic(P 499 G4double CrossSectionsINCL46::NKbelastic(Particle const * const , Particle const * const ) {
500 // 500 //
501 // antiKaon-Nucleon elastic cross 501 // antiKaon-Nucleon elastic cross sections
502 // 502 //
503 return 0.; 503 return 0.;
504 } 504 }
505 505
506 G4double CrossSectionsINCL46::NNToNLK(Partic 506 G4double CrossSectionsINCL46::NNToNLK(Particle const * const, Particle const * const) {
507 // 507 //
508 // Nucleon-Nucleon producing N-La 508 // Nucleon-Nucleon producing N-Lambda-Kaon cross sections
509 // 509 //
510 return 0.; 510 return 0.;
511 } 511 }
512 512
513 G4double CrossSectionsINCL46::NNToNSK(Part 513 G4double CrossSectionsINCL46::NNToNSK(Particle const * const, Particle const * const) {
514 // 514 //
515 // Nucleon-Nucleon producing N-Si 515 // Nucleon-Nucleon producing N-Sigma-Kaon cross sections
516 // 516 //
517 return 0.; 517 return 0.;
518 } 518 }
519 519
520 G4double CrossSectionsINCL46::NNToNLKpi(Pa 520 G4double CrossSectionsINCL46::NNToNLKpi(Particle const * const, Particle const * const) {
521 // 521 //
522 // Nucleon-Nucleon producing N-La 522 // Nucleon-Nucleon producing N-Lambda-Kaon-pion cross sections
523 // 523 //
524 return 0.; 524 return 0.;
525 } 525 }
526 526
527 G4double CrossSectionsINCL46::NNToNSKpi(Pa 527 G4double CrossSectionsINCL46::NNToNSKpi(Particle const * const, Particle const * const) {
528 // 528 //
529 // Nucleon-Nucleon producing N-Si 529 // Nucleon-Nucleon producing N-Sigma-Kaon-pion cross sections
530 // 530 //
531 return 0.; 531 return 0.;
532 } 532 }
533 533
534 G4double CrossSectionsINCL46::NNToNLK2pi(P 534 G4double CrossSectionsINCL46::NNToNLK2pi(Particle const * const, Particle const * const) {
535 // 535 //
536 // Nucleon-Nucleon producing N-Lam 536 // Nucleon-Nucleon producing N-Lambda-Kaon-2pion cross sections
537 // 537 //
538 return 0.; 538 return 0.;
539 } 539 }
540 540
541 G4double CrossSectionsINCL46::NNToNSK2pi(P 541 G4double CrossSectionsINCL46::NNToNSK2pi(Particle const * const, Particle const * const) {
542 // 542 //
543 // Nucleon-Nucleon producing N-Si 543 // Nucleon-Nucleon producing N-Sigma-Kaon-2pion cross sections
544 // 544 //
545 return 0.; 545 return 0.;
546 } 546 }
547 547
548 G4double CrossSectionsINCL46::NNToNNKKb(Pa 548 G4double CrossSectionsINCL46::NNToNNKKb(Particle const * const, Particle const * const) {
549 // 549 //
550 // Nucleon-Nucleon producing Nucl 550 // Nucleon-Nucleon producing Nucleon-Nucleon-Kaon-antiKaon cross sections
551 // 551 //
552 return 0.; 552 return 0.;
553 } 553 }
554 554
555 G4double CrossSectionsINCL46::NNToMissingS 555 G4double CrossSectionsINCL46::NNToMissingStrangeness(Particle const * const, Particle const * const) {
556 // 556 //
557 // Nucleon-Nucleon missing strang 557 // Nucleon-Nucleon missing strangeness production cross sections
558 // 558 //
559 return 0.; 559 return 0.;
560 } 560 }
561 561
562 G4double CrossSectionsINCL46::NDeltaToNLK( 562 G4double CrossSectionsINCL46::NDeltaToNLK(Particle const * const, Particle const * const) {
563 // Nucleon-Delta producing Nucleon Lam 563 // Nucleon-Delta producing Nucleon Lambda Kaon cross section
564 return 0; 564 return 0;
565 } 565 }
566 G4double CrossSectionsINCL46::NDeltaToNSK( 566 G4double CrossSectionsINCL46::NDeltaToNSK(Particle const * const, Particle const * const) {
567 // Nucleon-Delta producing Nucleon Sig 567 // Nucleon-Delta producing Nucleon Sigma Kaon cross section
568 return 0; 568 return 0;
569 } 569 }
570 G4double CrossSectionsINCL46::NDeltaToDelt 570 G4double CrossSectionsINCL46::NDeltaToDeltaLK(Particle const * const, Particle const * const) {
571 // Nucleon-Delta producing Delta Lambd 571 // Nucleon-Delta producing Delta Lambda Kaon cross section
572 return 0; 572 return 0;
573 } 573 }
574 G4double CrossSectionsINCL46::NDeltaToDelt 574 G4double CrossSectionsINCL46::NDeltaToDeltaSK(Particle const * const, Particle const * const) {
575 // Nucleon-Delta producing Delta Sigma 575 // Nucleon-Delta producing Delta Sigma Kaon cross section
576 return 0; 576 return 0;
577 } 577 }
578 578
579 G4double CrossSectionsINCL46::NDeltaToNNKK 579 G4double CrossSectionsINCL46::NDeltaToNNKKb(Particle const * const, Particle const * const) {
580 // Nucleon-Delta producing Nucleon-Nuc 580 // Nucleon-Delta producing Nucleon-Nucleon Kaon antiKaon cross section
581 return 0; 581 return 0;
582 } 582 }
583 583
584 G4double CrossSectionsINCL46::NpiToLK(Part 584 G4double CrossSectionsINCL46::NpiToLK(Particle const * const, Particle const * const) {
585 // 585 //
586 // Pion-Nucleon producing Lambda- 586 // Pion-Nucleon producing Lambda-Kaon cross sections
587 // 587 //
588 return 0.; 588 return 0.;
589 } 589 }
590 590
591 G4double CrossSectionsINCL46::NpiToSK(Part 591 G4double CrossSectionsINCL46::NpiToSK(Particle const * const, Particle const * const) {
592 // 592 //
593 // Pion-Nucleon producing Sigma-K 593 // Pion-Nucleon producing Sigma-Kaon cross sections
594 // 594 //
595 return 0.; 595 return 0.;
596 } 596 }
597 G4double CrossSectionsINCL46::p_pimToSmKp( 597 G4double CrossSectionsINCL46::p_pimToSmKp(Particle const * const, Particle const * const) {
598 return 0.; 598 return 0.;
599 } 599 }
600 G4double CrossSectionsINCL46::p_pimToSzKz( 600 G4double CrossSectionsINCL46::p_pimToSzKz(Particle const * const, Particle const * const) {
601 return 0.; 601 return 0.;
602 } 602 }
603 G4double CrossSectionsINCL46::p_pizToSzKp( 603 G4double CrossSectionsINCL46::p_pizToSzKp(Particle const * const, Particle const * const) {
604 return 0.; 604 return 0.;
605 } 605 }
606 606
607 G4double CrossSectionsINCL46::NpiToLKpi(Pa 607 G4double CrossSectionsINCL46::NpiToLKpi(Particle const * const, Particle const * const) {
608 // 608 //
609 // Pion-Nucleon producing Lambda- 609 // Pion-Nucleon producing Lambda-Kaon-pion cross sections
610 // 610 //
611 return 0.; 611 return 0.;
612 } 612 }
613 613
614 G4double CrossSectionsINCL46::NpiToSKpi(Pa 614 G4double CrossSectionsINCL46::NpiToSKpi(Particle const * const, Particle const * const) {
615 // 615 //
616 // Pion-Nucleon producing Sigma-K 616 // Pion-Nucleon producing Sigma-Kaon-pion cross sections
617 // 617 //
618 return 0.; 618 return 0.;
619 } 619 }
620 620
621 G4double CrossSectionsINCL46::NpiToLK2pi(P 621 G4double CrossSectionsINCL46::NpiToLK2pi(Particle const * const, Particle const * const) {
622 // 622 //
623 // Pion-Nucleon producing Lambda- 623 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
624 // 624 //
625 return 0.; 625 return 0.;
626 } 626 }
627 627
628 G4double CrossSectionsINCL46::NpiToSK2pi(P 628 G4double CrossSectionsINCL46::NpiToSK2pi(Particle const * const, Particle const * const) {
629 // 629 //
630 // Pion-Nucleon producing Lambda- 630 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
631 // 631 //
632 return 0.; 632 return 0.;
633 } 633 }
634 634
635 G4double CrossSectionsINCL46::NpiToNKKb(Pa 635 G4double CrossSectionsINCL46::NpiToNKKb(Particle const * const, Particle const * const) {
636 // 636 //
637 // Pion-Nucleon producing Nucleon 637 // Pion-Nucleon producing Nucleon-Kaon-antiKaon cross sections
638 // 638 //
639 return 0.; 639 return 0.;
640 } 640 }
641 641
642 G4double CrossSectionsINCL46::NpiToMissing 642 G4double CrossSectionsINCL46::NpiToMissingStrangeness(Particle const * const, Particle const * const) {
643 // 643 //
644 // Pion-Nucleon missing strangene 644 // Pion-Nucleon missing strangeness production cross sections
645 // 645 //
646 return 0.; 646 return 0.;
647 } 647 }
648 648
649 G4double CrossSectionsINCL46::NLToNS(Parti 649 G4double CrossSectionsINCL46::NLToNS(Particle const * const, Particle const * const) {
650 // 650 //
651 // Nucleon-Hyperon multiplet chan 651 // Nucleon-Hyperon multiplet changing cross sections
652 // 652 //
653 return 0.; 653 return 0.;
654 } 654 }
655 655
656 G4double CrossSectionsINCL46::NSToNL(Parti 656 G4double CrossSectionsINCL46::NSToNL(Particle const * const, Particle const * const) {
657 // 657 //
658 // Nucleon-Sigma quasi-elastic cr 658 // Nucleon-Sigma quasi-elastic cross sections
659 // 659 //
660 return 0.; 660 return 0.;
661 } 661 }
662 662
663 G4double CrossSectionsINCL46::NSToNS(Parti 663 G4double CrossSectionsINCL46::NSToNS(Particle const * const, Particle const * const) {
664 // 664 //
665 // Nucleon-Sigma quasi-elastic cr 665 // Nucleon-Sigma quasi-elastic cross sections
666 // 666 //
667 return 0.; 667 return 0.;
668 } 668 }
669 669
670 G4double CrossSectionsINCL46::NKToNK(Parti 670 G4double CrossSectionsINCL46::NKToNK(Particle const * const, Particle const * const) {
671 // 671 //
672 // Nucleon-Kaon quasi-elastic cro 672 // Nucleon-Kaon quasi-elastic cross sections
673 // 673 //
674 return 0.; 674 return 0.;
675 } 675 }
676 676
677 G4double CrossSectionsINCL46::NKToNKpi(Par 677 G4double CrossSectionsINCL46::NKToNKpi(Particle const * const, Particle const * const) {
678 // 678 //
679 // Nucleon-Kaon producing Nucleon 679 // Nucleon-Kaon producing Nucleon-Kaon-pion cross sections
680 // 680 //
681 return 0.; 681 return 0.;
682 } 682 }
683 683
684 G4double CrossSectionsINCL46::NKToNK2pi(Pa 684 G4double CrossSectionsINCL46::NKToNK2pi(Particle const * const, Particle const * const) {
685 // 685 //
686 // Nucleon-Kaon producing Nucleon 686 // Nucleon-Kaon producing Nucleon-Kaon-2pion cross sections
687 // 687 //
688 return 0.; 688 return 0.;
689 } 689 }
690 690
691 G4double CrossSectionsINCL46::NKbToNKb(Par 691 G4double CrossSectionsINCL46::NKbToNKb(Particle const * const, Particle const * const) {
692 // 692 //
693 // Nucleon-antiKaon quasi-elastic 693 // Nucleon-antiKaon quasi-elastic cross sections
694 // 694 //
695 return 0.; 695 return 0.;
696 } 696 }
697 697
698 G4double CrossSectionsINCL46::NKbToSpi(Par 698 G4double CrossSectionsINCL46::NKbToSpi(Particle const * const, Particle const * const) {
699 // 699 //
700 // Nucleon-antiKaon producing Sig 700 // Nucleon-antiKaon producing Sigma-pion cross sections
701 // 701 //
702 return 0.; 702 return 0.;
703 } 703 }
704 704
705 G4double CrossSectionsINCL46::NKbToLpi(Par 705 G4double CrossSectionsINCL46::NKbToLpi(Particle const * const, Particle const * const) {
706 // 706 //
707 // Nucleon-antiKaon producing Lam 707 // Nucleon-antiKaon producing Lambda-pion cross sections
708 // 708 //
709 return 0.; 709 return 0.;
710 } 710 }
711 711
712 G4double CrossSectionsINCL46::NKbToS2pi(Pa 712 G4double CrossSectionsINCL46::NKbToS2pi(Particle const * const, Particle const * const) {
713 // 713 //
714 // Nucleon-antiKaon producing Sig 714 // Nucleon-antiKaon producing Sigma-2pion cross sections
715 // 715 //
716 return 0.; 716 return 0.;
717 } 717 }
718 718
719 G4double CrossSectionsINCL46::NKbToL2pi(Pa 719 G4double CrossSectionsINCL46::NKbToL2pi(Particle const * const, Particle const * const) {
720 // 720 //
721 // Nucleon-antiKaon producing Lam 721 // Nucleon-antiKaon producing Lambda-2pion cross sections
722 // 722 //
723 return 0.; 723 return 0.;
724 } 724 }
725 725
726 G4double CrossSectionsINCL46::NKbToNKbpi(P 726 G4double CrossSectionsINCL46::NKbToNKbpi(Particle const * const, Particle const * const) {
727 // 727 //
728 // Nucleon-antiKaon producing Nuc 728 // Nucleon-antiKaon producing Nucleon-antiKaon-pion cross sections
729 // 729 //
730 return 0.; 730 return 0.;
731 } 731 }
732 732
733 G4double CrossSectionsINCL46::NKbToNKb2pi( 733 G4double CrossSectionsINCL46::NKbToNKb2pi(Particle const * const, Particle const * const) {
734 // 734 //
735 // Nucleon-antiKaon producing Nuc 735 // Nucleon-antiKaon producing Nucleon-antiKaon-2pion cross sections
736 // 736 //
737 return 0.; 737 return 0.;
738 } 738 }
739 << 739
740 G4double CrossSectionsINCL46::NNbarElastic <<
741 // <<
742 // Nucleon-AntiNucleon to Nucleon- <<
743 // <<
744 return 0.; <<
745 } <<
746 <<
747 G4double CrossSectionsINCL46::NNbarCEX(Par <<
748 // <<
749 // Nucleon-AntiNucleon charge exch <<
750 // <<
751 return 0.; <<
752 } <<
753 <<
754 G4double CrossSectionsINCL46::NNbarToLLbar <<
755 // <<
756 // Nucleon-AntiNucleon to Lambda-A <<
757 // <<
758 return 0.; <<
759 } <<
760 <<
761 G4double CrossSectionsINCL46::NNbarToNNbar <<
762 // <<
763 // Nucleon-AntiNucleon to Nucleon- <<
764 // <<
765 return 0.; <<
766 } <<
767 <<
768 G4double CrossSectionsINCL46::NNbarToNNbar <<
769 // <<
770 // Nucleon-AntiNucleon to Nucleon- <<
771 // <<
772 return 0.; <<
773 } <<
774 <<
775 G4double CrossSectionsINCL46::NNbarToNNbar <<
776 // <<
777 // Nucleon-AntiNucleon to Nucleon- <<
778 // <<
779 return 0.; <<
780 } <<
781 <<
782 G4double CrossSectionsINCL46::NNbarToAnnih <<
783 // <<
784 // Nucleon-AntiNucleon total annih <<
785 // <<
786 return 0.; <<
787 } <<
788 } // namespace G4INCL 740 } // namespace G4INCL
789 741
790 742