| 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 "G4INCLNNToNSK2piChannel.hh" 38 #include "G4INCLNNToNSK2piChannel.hh"
39 #include "G4INCLKinematicsUtils.hh" 39 #include "G4INCLKinematicsUtils.hh"
40 #include "G4INCLBinaryCollisionAvatar.hh" 40 #include "G4INCLBinaryCollisionAvatar.hh"
41 #include "G4INCLRandom.hh" 41 #include "G4INCLRandom.hh"
42 #include "G4INCLGlobals.hh" 42 #include "G4INCLGlobals.hh"
43 #include "G4INCLLogger.hh" 43 #include "G4INCLLogger.hh"
44 #include <algorithm> 44 #include <algorithm>
45 #include "G4INCLPhaseSpaceGenerator.hh" 45 #include "G4INCLPhaseSpaceGenerator.hh"
46 46
47 namespace G4INCL { 47 namespace G4INCL {
48 48
49 const G4double NNToNSK2piChannel::angularSlo 49 const G4double NNToNSK2piChannel::angularSlope = 2.; // What is the exact effect? Sould be check
50 50
51 NNToNSK2piChannel::NNToNSK2piChannel(Particl 51 NNToNSK2piChannel::NNToNSK2piChannel(Particle *p1, Particle *p2)
52 : particle1(p1), particle2(p2) 52 : particle1(p1), particle2(p2)
53 {} 53 {}
54 54
55 NNToNSK2piChannel::~NNToNSK2piChannel(){} 55 NNToNSK2piChannel::~NNToNSK2piChannel(){}
56 56
57 void NNToNSK2piChannel::fillFinalState(Final 57 void NNToNSK2piChannel::fillFinalState(FinalState *fs) {
58 58
59 /* Equipartition in all channel with facto 59 /* Equipartition in all channel with factor N(pi)!
60 */ 60 */
61 61
62 const G4double sqrtS = KinematicsUtils::to 62 const G4double sqrtS = KinematicsUtils::totalEnergyInCM(particle1, particle2);
63 63
64 const G4int iso = ParticleTable::getIsospi 64 const G4int iso = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
65 65
66 ParticleType KaonType; 66 ParticleType KaonType;
67 ParticleType Pion1Type; 67 ParticleType Pion1Type;
68 ParticleType Pion2Type; 68 ParticleType Pion2Type;
69 69
70 G4double rdm = Random::shoot(); 70 G4double rdm = Random::shoot();
71 71
72 if(iso == 2){ 72 if(iso == 2){
73 if(rdm*20. < 1.){ 73 if(rdm*20. < 1.){
74 particle1->setType(Neutron); 74 particle1->setType(Neutron);
75 particle2->setType(SigmaPlus); 75 particle2->setType(SigmaPlus);
76 KaonType = KZero; 76 KaonType = KZero;
77 Pion1Type = PiZero; 77 Pion1Type = PiZero;
78 Pion2Type = PiPlus; 78 Pion2Type = PiPlus;
79 } 79 }
80 else if(rdm*20. < 3.){ 80 else if(rdm*20. < 3.){
81 particle1->setType(Neutron); 81 particle1->setType(Neutron);
82 particle2->setType(SigmaZero); 82 particle2->setType(SigmaZero);
83 KaonType = KZero; 83 KaonType = KZero;
84 Pion1Type = PiPlus; 84 Pion1Type = PiPlus;
85 Pion2Type = PiPlus; 85 Pion2Type = PiPlus;
86 } 86 }
87 else if(rdm*20. < 4.){ 87 else if(rdm*20. < 4.){
88 particle1->setType(Neutron); 88 particle1->setType(Neutron);
89 particle2->setType(SigmaPlus); 89 particle2->setType(SigmaPlus);
90 KaonType = KPlus; 90 KaonType = KPlus;
91 Pion1Type = PiMinus; 91 Pion1Type = PiMinus;
92 Pion2Type = PiPlus; 92 Pion2Type = PiPlus;
93 } 93 }
94 else if(rdm*20. < 6.){ 94 else if(rdm*20. < 6.){
95 particle1->setType(Neutron); 95 particle1->setType(Neutron);
96 particle2->setType(SigmaPlus); 96 particle2->setType(SigmaPlus);
97 KaonType = KPlus; 97 KaonType = KPlus;
98 Pion1Type = PiZero; 98 Pion1Type = PiZero;
99 Pion2Type = PiZero; 99 Pion2Type = PiZero;
100 } 100 }
101 else if(rdm*20. < 7.){ 101 else if(rdm*20. < 7.){
102 particle1->setType(Neutron); 102 particle1->setType(Neutron);
103 particle2->setType(SigmaZero); 103 particle2->setType(SigmaZero);
104 KaonType = KPlus; 104 KaonType = KPlus;
105 Pion1Type = PiZero; 105 Pion1Type = PiZero;
106 Pion2Type = PiPlus; 106 Pion2Type = PiPlus;
107 } 107 }
108 else if(rdm*20. < 9.){ 108 else if(rdm*20. < 9.){
109 particle1->setType(Neutron); 109 particle1->setType(Neutron);
110 particle2->setType(SigmaMinus); 110 particle2->setType(SigmaMinus);
111 KaonType = KPlus; 111 KaonType = KPlus;
112 Pion1Type = PiPlus; 112 Pion1Type = PiPlus;
113 Pion2Type = PiPlus; 113 Pion2Type = PiPlus;
114 } 114 }
115 else if(rdm*20. < 10.){ 115 else if(rdm*20. < 10.){
116 particle1->setType(Proton); 116 particle1->setType(Proton);
117 particle2->setType(SigmaPlus); 117 particle2->setType(SigmaPlus);
118 KaonType = KZero; 118 KaonType = KZero;
119 Pion1Type = PiMinus; 119 Pion1Type = PiMinus;
120 Pion2Type = PiPlus; 120 Pion2Type = PiPlus;
121 } 121 }
122 else if(rdm*20. < 12.){ 122 else if(rdm*20. < 12.){
123 particle1->setType(Proton); 123 particle1->setType(Proton);
124 particle2->setType(SigmaPlus); 124 particle2->setType(SigmaPlus);
125 KaonType = KZero; 125 KaonType = KZero;
126 Pion1Type = PiZero; 126 Pion1Type = PiZero;
127 Pion2Type = PiZero; 127 Pion2Type = PiZero;
128 } 128 }
129 else if(rdm*20. < 13.){ 129 else if(rdm*20. < 13.){
130 particle1->setType(Proton); 130 particle1->setType(Proton);
131 particle2->setType(SigmaZero); 131 particle2->setType(SigmaZero);
132 KaonType = KZero; 132 KaonType = KZero;
133 Pion1Type = PiZero; 133 Pion1Type = PiZero;
134 Pion2Type = PiPlus; 134 Pion2Type = PiPlus;
135 } 135 }
136 else if(rdm*20. < 15.){ 136 else if(rdm*20. < 15.){
137 particle1->setType(Proton); 137 particle1->setType(Proton);
138 particle2->setType(SigmaMinus); 138 particle2->setType(SigmaMinus);
139 KaonType = KZero; 139 KaonType = KZero;
140 Pion1Type = PiPlus; 140 Pion1Type = PiPlus;
141 Pion2Type = PiPlus; 141 Pion2Type = PiPlus;
142 } 142 }
143 else if(rdm*20. < 16.){ 143 else if(rdm*20. < 16.){
144 particle1->setType(Proton); 144 particle1->setType(Proton);
145 particle2->setType(SigmaPlus); 145 particle2->setType(SigmaPlus);
146 KaonType = KPlus; 146 KaonType = KPlus;
147 Pion1Type = PiMinus; 147 Pion1Type = PiMinus;
148 Pion2Type = PiZero; 148 Pion2Type = PiZero;
149 } 149 }
150 else if(rdm*20. < 17.){ 150 else if(rdm*20. < 17.){
151 particle1->setType(Proton); 151 particle1->setType(Proton);
152 particle2->setType(SigmaZero); 152 particle2->setType(SigmaZero);
153 KaonType = KPlus; 153 KaonType = KPlus;
154 Pion1Type = PiMinus; 154 Pion1Type = PiMinus;
155 Pion2Type = PiPlus; 155 Pion2Type = PiPlus;
156 } 156 }
157 else if(rdm*20. < 19.){ 157 else if(rdm*20. < 19.){
158 particle1->setType(Proton); 158 particle1->setType(Proton);
159 particle2->setType(SigmaZero); 159 particle2->setType(SigmaZero);
160 KaonType = KPlus; 160 KaonType = KPlus;
161 Pion1Type = PiZero; 161 Pion1Type = PiZero;
162 Pion2Type = PiZero; 162 Pion2Type = PiZero;
163 } 163 }
164 else{ 164 else{
165 particle1->setType(Proton); 165 particle1->setType(Proton);
166 particle2->setType(SigmaMinus); 166 particle2->setType(SigmaMinus);
167 KaonType = KPlus; 167 KaonType = KPlus;
168 Pion1Type = PiZero; 168 Pion1Type = PiZero;
169 Pion2Type = PiPlus; 169 Pion2Type = PiPlus;
170 } 170 }
171 171
172 172
173 }if(iso == -2){ 173 }if(iso == -2){
174 if(rdm*20. < 1.){ 174 if(rdm*20. < 1.){
175 particle1->setType(Neutron); 175 particle1->setType(Neutron);
176 particle2->setType(SigmaPlus); 176 particle2->setType(SigmaPlus);
177 KaonType = KZero; 177 KaonType = KZero;
178 Pion1Type = PiMinus; 178 Pion1Type = PiMinus;
179 Pion2Type = PiZero; 179 Pion2Type = PiZero;
180 } 180 }
181 else if(rdm*20. < 2.){ 181 else if(rdm*20. < 2.){
182 particle1->setType(Neutron); 182 particle1->setType(Neutron);
183 particle2->setType(SigmaZero); 183 particle2->setType(SigmaZero);
184 KaonType = KZero; 184 KaonType = KZero;
185 Pion1Type = PiMinus; 185 Pion1Type = PiMinus;
186 Pion2Type = PiPlus; 186 Pion2Type = PiPlus;
187 } 187 }
188 else if(rdm*20. < 4.){ 188 else if(rdm*20. < 4.){
189 particle1->setType(Neutron); 189 particle1->setType(Neutron);
190 particle2->setType(SigmaZero); 190 particle2->setType(SigmaZero);
191 KaonType = KZero; 191 KaonType = KZero;
192 Pion1Type = PiZero; 192 Pion1Type = PiZero;
193 Pion2Type = PiZero; 193 Pion2Type = PiZero;
194 } 194 }
195 else if(rdm*20. < 5.){ 195 else if(rdm*20. < 5.){
196 particle1->setType(Neutron); 196 particle1->setType(Neutron);
197 particle2->setType(SigmaMinus); 197 particle2->setType(SigmaMinus);
198 KaonType = KZero; 198 KaonType = KZero;
199 Pion1Type = PiZero; 199 Pion1Type = PiZero;
200 Pion2Type = PiPlus; 200 Pion2Type = PiPlus;
201 } 201 }
202 else if(rdm*20. < 7.){ 202 else if(rdm*20. < 7.){
203 particle1->setType(Neutron); 203 particle1->setType(Neutron);
204 particle2->setType(SigmaPlus); 204 particle2->setType(SigmaPlus);
205 KaonType = KPlus; 205 KaonType = KPlus;
206 Pion1Type = PiMinus; 206 Pion1Type = PiMinus;
207 Pion2Type = PiMinus; 207 Pion2Type = PiMinus;
208 } 208 }
209 else if(rdm*20. < 8.){ 209 else if(rdm*20. < 8.){
210 particle1->setType(Neutron); 210 particle1->setType(Neutron);
211 particle2->setType(SigmaZero); 211 particle2->setType(SigmaZero);
212 KaonType = KPlus; 212 KaonType = KPlus;
213 Pion1Type = PiMinus; 213 Pion1Type = PiMinus;
214 Pion2Type = PiZero; 214 Pion2Type = PiZero;
215 } 215 }
216 else if(rdm*20. < 9.){ 216 else if(rdm*20. < 9.){
217 particle1->setType(Neutron); 217 particle1->setType(Neutron);
218 particle2->setType(SigmaMinus); 218 particle2->setType(SigmaMinus);
219 KaonType = KPlus; 219 KaonType = KPlus;
220 Pion1Type = PiMinus; 220 Pion1Type = PiMinus;
221 Pion2Type = PiPlus; 221 Pion2Type = PiPlus;
222 } 222 }
223 else if(rdm*20. < 11.){ 223 else if(rdm*20. < 11.){
224 particle1->setType(Neutron); 224 particle1->setType(Neutron);
225 particle2->setType(SigmaMinus); 225 particle2->setType(SigmaMinus);
226 KaonType = KPlus; 226 KaonType = KPlus;
227 Pion1Type = PiZero; 227 Pion1Type = PiZero;
228 Pion2Type = PiZero; 228 Pion2Type = PiZero;
229 } 229 }
230 else if(rdm*20. < 13.){ 230 else if(rdm*20. < 13.){
231 particle1->setType(Proton); 231 particle1->setType(Proton);
232 particle2->setType(SigmaPlus); 232 particle2->setType(SigmaPlus);
233 KaonType = KZero; 233 KaonType = KZero;
234 Pion1Type = PiMinus; 234 Pion1Type = PiMinus;
235 Pion2Type = PiMinus; 235 Pion2Type = PiMinus;
236 } 236 }
237 else if(rdm*20. < 14.){ 237 else if(rdm*20. < 14.){
238 particle1->setType(Proton); 238 particle1->setType(Proton);
239 particle2->setType(SigmaZero); 239 particle2->setType(SigmaZero);
240 KaonType = KZero; 240 KaonType = KZero;
241 Pion1Type = PiMinus; 241 Pion1Type = PiMinus;
242 Pion2Type = PiZero; 242 Pion2Type = PiZero;
243 } 243 }
244 else if(rdm*20. < 15.){ 244 else if(rdm*20. < 15.){
245 particle1->setType(Proton); 245 particle1->setType(Proton);
246 particle2->setType(SigmaMinus); 246 particle2->setType(SigmaMinus);
247 KaonType = KZero; 247 KaonType = KZero;
248 Pion1Type = PiMinus; 248 Pion1Type = PiMinus;
249 Pion2Type = PiPlus; 249 Pion2Type = PiPlus;
250 } 250 }
251 else if(rdm*20. < 17.){ 251 else if(rdm*20. < 17.){
252 particle1->setType(Proton); 252 particle1->setType(Proton);
253 particle2->setType(SigmaMinus); 253 particle2->setType(SigmaMinus);
254 KaonType = KZero; 254 KaonType = KZero;
255 Pion1Type = PiZero; 255 Pion1Type = PiZero;
256 Pion2Type = PiZero; 256 Pion2Type = PiZero;
257 } 257 }
258 else if(rdm*20. < 19.){ 258 else if(rdm*20. < 19.){
259 particle1->setType(Proton); 259 particle1->setType(Proton);
260 particle2->setType(SigmaZero); 260 particle2->setType(SigmaZero);
261 KaonType = KPlus; 261 KaonType = KPlus;
262 Pion1Type = PiMinus; 262 Pion1Type = PiMinus;
263 Pion2Type = PiMinus; 263 Pion2Type = PiMinus;
264 } 264 }
265 else{ 265 else{
266 particle1->setType(Proton); 266 particle1->setType(Proton);
267 particle2->setType(SigmaMinus); 267 particle2->setType(SigmaMinus);
268 KaonType = KPlus; 268 KaonType = KPlus;
269 Pion1Type = PiMinus; 269 Pion1Type = PiMinus;
270 Pion2Type = PiZero; 270 Pion2Type = PiZero;
271 } 271 }
272 272
273 } 273 }
274 else{ 274 else{
275 if(rdm*22. < 1.){ 275 if(rdm*22. < 1.){
276 particle1->setType(Neutron); 276 particle1->setType(Neutron);
277 particle2->setType(SigmaPlus); 277 particle2->setType(SigmaPlus);
278 KaonType = KZero; 278 KaonType = KZero;
279 Pion1Type = PiMinus; 279 Pion1Type = PiMinus;
280 Pion2Type = PiPlus; 280 Pion2Type = PiPlus;
281 } 281 }
282 else if(rdm*22. < 3.){ 282 else if(rdm*22. < 3.){
283 particle1->setType(Neutron); 283 particle1->setType(Neutron);
284 particle2->setType(SigmaPlus); 284 particle2->setType(SigmaPlus);
285 KaonType = KZero; 285 KaonType = KZero;
286 Pion1Type = PiZero; 286 Pion1Type = PiZero;
287 Pion2Type = PiZero; 287 Pion2Type = PiZero;
288 } 288 }
289 else if(rdm*22. < 4.){ 289 else if(rdm*22. < 4.){
290 particle1->setType(Neutron); 290 particle1->setType(Neutron);
291 particle2->setType(SigmaZero); 291 particle2->setType(SigmaZero);
292 KaonType = KZero; 292 KaonType = KZero;
293 Pion1Type = PiZero; 293 Pion1Type = PiZero;
294 Pion2Type = PiPlus; 294 Pion2Type = PiPlus;
295 } 295 }
296 else if(rdm*22. < 6.){ 296 else if(rdm*22. < 6.){
297 particle1->setType(Neutron); 297 particle1->setType(Neutron);
298 particle2->setType(SigmaMinus); 298 particle2->setType(SigmaMinus);
299 KaonType = KZero; 299 KaonType = KZero;
300 Pion1Type = PiPlus; 300 Pion1Type = PiPlus;
301 Pion2Type = PiPlus; 301 Pion2Type = PiPlus;
302 } 302 }
303 else if(rdm*22. < 7.){ 303 else if(rdm*22. < 7.){
304 particle1->setType(Neutron); 304 particle1->setType(Neutron);
305 particle2->setType(SigmaPlus); 305 particle2->setType(SigmaPlus);
306 KaonType = KPlus; 306 KaonType = KPlus;
307 Pion1Type = PiMinus; 307 Pion1Type = PiMinus;
308 Pion2Type = PiZero; 308 Pion2Type = PiZero;
309 } 309 }
310 else if(rdm*22. < 8.){ 310 else if(rdm*22. < 8.){
311 particle1->setType(Neutron); 311 particle1->setType(Neutron);
312 particle2->setType(SigmaZero); 312 particle2->setType(SigmaZero);
313 KaonType = KPlus; 313 KaonType = KPlus;
314 Pion1Type = PiMinus; 314 Pion1Type = PiMinus;
315 Pion2Type = PiPlus; 315 Pion2Type = PiPlus;
316 } 316 }
317 else if(rdm*22. < 10.){ 317 else if(rdm*22. < 10.){
318 particle1->setType(Neutron); 318 particle1->setType(Neutron);
319 particle2->setType(SigmaZero); 319 particle2->setType(SigmaZero);
320 KaonType = KPlus; 320 KaonType = KPlus;
321 Pion1Type = PiZero; 321 Pion1Type = PiZero;
322 Pion2Type = PiZero; 322 Pion2Type = PiZero;
323 } 323 }
324 else if(rdm*22. < 11.){ 324 else if(rdm*22. < 11.){
325 particle1->setType(Neutron); 325 particle1->setType(Neutron);
326 particle2->setType(SigmaMinus); 326 particle2->setType(SigmaMinus);
327 KaonType = KPlus; 327 KaonType = KPlus;
328 Pion1Type = PiZero; 328 Pion1Type = PiZero;
329 Pion2Type = PiPlus; 329 Pion2Type = PiPlus;
330 } 330 }
331 else if(rdm*22. < 12.){ 331 else if(rdm*22. < 12.){
332 particle1->setType(Proton); 332 particle1->setType(Proton);
333 particle2->setType(SigmaPlus); 333 particle2->setType(SigmaPlus);
334 KaonType = KZero; 334 KaonType = KZero;
335 Pion1Type = PiMinus; 335 Pion1Type = PiMinus;
336 Pion2Type = PiZero; 336 Pion2Type = PiZero;
337 } 337 }
338 else if(rdm*22. < 13.){ 338 else if(rdm*22. < 13.){
339 particle1->setType(Proton); 339 particle1->setType(Proton);
340 particle2->setType(SigmaZero); 340 particle2->setType(SigmaZero);
341 KaonType = KZero; 341 KaonType = KZero;
342 Pion1Type = PiMinus; 342 Pion1Type = PiMinus;
343 Pion2Type = PiPlus; 343 Pion2Type = PiPlus;
344 } 344 }
345 else if(rdm*22. < 15.){ 345 else if(rdm*22. < 15.){
346 particle1->setType(Proton); 346 particle1->setType(Proton);
347 particle2->setType(SigmaZero); 347 particle2->setType(SigmaZero);
348 KaonType = KZero; 348 KaonType = KZero;
349 Pion1Type = PiZero; 349 Pion1Type = PiZero;
350 Pion2Type = PiZero; 350 Pion2Type = PiZero;
351 } 351 }
352 else if(rdm*22. < 16.){ 352 else if(rdm*22. < 16.){
353 particle1->setType(Proton); 353 particle1->setType(Proton);
354 particle2->setType(SigmaMinus); 354 particle2->setType(SigmaMinus);
355 KaonType = KZero; 355 KaonType = KZero;
356 Pion1Type = PiZero; 356 Pion1Type = PiZero;
357 Pion2Type = PiPlus; 357 Pion2Type = PiPlus;
358 } 358 }
359 else if(rdm*22. < 18.){ 359 else if(rdm*22. < 18.){
360 particle1->setType(Proton); 360 particle1->setType(Proton);
361 particle2->setType(SigmaPlus); 361 particle2->setType(SigmaPlus);
362 KaonType = KPlus; 362 KaonType = KPlus;
363 Pion1Type = PiMinus; 363 Pion1Type = PiMinus;
364 Pion2Type = PiMinus; 364 Pion2Type = PiMinus;
365 } 365 }
366 else if(rdm*22. < 19.){ 366 else if(rdm*22. < 19.){
367 particle1->setType(Proton); 367 particle1->setType(Proton);
368 particle2->setType(SigmaZero); 368 particle2->setType(SigmaZero);
369 KaonType = KPlus; 369 KaonType = KPlus;
370 Pion1Type = PiMinus; 370 Pion1Type = PiMinus;
371 Pion2Type = PiZero; 371 Pion2Type = PiZero;
372 } 372 }
373 else if(rdm*22. < 20.){ 373 else if(rdm*22. < 20.){
374 particle1->setType(Proton); 374 particle1->setType(Proton);
375 particle2->setType(SigmaMinus); 375 particle2->setType(SigmaMinus);
376 KaonType = KPlus; 376 KaonType = KPlus;
377 Pion1Type = PiMinus; 377 Pion1Type = PiMinus;
378 Pion2Type = PiPlus; 378 Pion2Type = PiPlus;
379 } 379 }
380 else{ 380 else{
381 particle1->setType(Proton); 381 particle1->setType(Proton);
382 particle2->setType(SigmaMinus); 382 particle2->setType(SigmaMinus);
383 KaonType = KPlus; 383 KaonType = KPlus;
384 Pion1Type = PiZero; 384 Pion1Type = PiZero;
385 Pion2Type = PiZero; 385 Pion2Type = PiZero;
386 } 386 }
387 387
388 } 388 }
389 389
390 390
391 ParticleList list; 391 ParticleList list;
392 list.push_back(particle1); 392 list.push_back(particle1);
393 list.push_back(particle2); 393 list.push_back(particle2);
394 const ThreeVector &rcol1 = particle1->getP 394 const ThreeVector &rcol1 = particle1->getPosition();
395 const ThreeVector &rcol2 = particle2->getP 395 const ThreeVector &rcol2 = particle2->getPosition();
396 const ThreeVector zero; 396 const ThreeVector zero;
397 Particle *pion1 = new Particle(Pion1Type,z 397 Particle *pion1 = new Particle(Pion1Type,zero,rcol1);
398 Particle *pion2 = new Particle(Pion2Type,z 398 Particle *pion2 = new Particle(Pion2Type,zero,rcol1);
399 Particle *kaon = new Particle(KaonType,zer 399 Particle *kaon = new Particle(KaonType,zero,rcol2);
400 list.push_back(kaon); 400 list.push_back(kaon);
401 list.push_back(pion1); 401 list.push_back(pion1);
402 list.push_back(pion2); 402 list.push_back(pion2);
403 403
404 if(Random::shoot()<0.5) PhaseSpaceGenerato 404 if(Random::shoot()<0.5) PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
405 else PhaseSpaceGenerator::generateBiased(s 405 else PhaseSpaceGenerator::generateBiased(sqrtS, list, 1, angularSlope);
406 406
407 fs->addModifiedParticle(particle1); 407 fs->addModifiedParticle(particle1);
408 fs->addModifiedParticle(particle2); 408 fs->addModifiedParticle(particle2);
409 fs->addCreatedParticle(kaon); 409 fs->addCreatedParticle(kaon);
410 fs->addCreatedParticle(pion1); 410 fs->addCreatedParticle(pion1);
411 fs->addCreatedParticle(pion2); 411 fs->addCreatedParticle(pion2);
412 412
413 } 413 }
414 } 414 }
415 415