source: trunk/source/processes/hadronic/util/src/G4LightMedia.cc@ 1350

Last change on this file since 1350 was 1315, checked in by garnier, 15 years ago

update geant4-09-04-beta-cand-01 interfaces-V09-03-09 vis-V09-03-08
File size: 44.5 KB
Line 
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// Hadronic Process: Light Media Charge and/or Strangeness Exchange
28// J.L. Chuma, TRIUMF, 21-Feb-1997
29// Last modified: 13-Mar-1997
30
31// 11-OCT-2007 F.W. Jones: fixed coding errors in inequalities for
32// charge exchange occurrence in PionPlusExchange,
33// KaonZeroShortExchange, and NeutronExchange.
34
35#include "G4LightMedia.hh"
36#include "Randomize.hh"
37
38 G4DynamicParticle *
39 G4LightMedia::PionPlusExchange(
40 const G4HadProjectile *incidentParticle,
41 const G4Nucleus & targetNucleus )
42 {
43 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
44 G4ParticleDefinition* aPiZero = G4PionZero::PionZero();
45
46 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
47
48 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
49
50 if( targetParticle->GetDefinition() == aNeutron ) {
51
52 // for pi+ n reactions, change some of the elastic cross section to pi0 p
53
54 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
55 G4int iplab = G4int(std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ));
56 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
57 G4DynamicParticle* resultant = new G4DynamicParticle;
58 resultant->SetDefinition( aPiZero );
59 // targetParticle->SetDefinition( aProton );
60 delete targetParticle;
61 return resultant;
62 }
63 }
64 delete targetParticle;
65 return (G4DynamicParticle*)NULL;
66 }
67
68 G4DynamicParticle *
69 G4LightMedia::PionMinusExchange(
70 const G4HadProjectile *,
71 const G4Nucleus& )
72 {
73 return (G4DynamicParticle*)NULL;
74 }
75
76 G4DynamicParticle *
77 G4LightMedia::KaonPlusExchange(
78 const G4HadProjectile *incidentParticle,
79 const G4Nucleus& targetNucleus )
80 {
81 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
82 G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
83 G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
84
85 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
86
87 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
88
89 if( targetParticle->GetDefinition() == aNeutron ) {
90
91 // for k+ n reactions, change some of the elastic cross section to k0 p
92
93 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
94 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
95 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
96 G4DynamicParticle* resultant = new G4DynamicParticle;
97 if( G4UniformRand() < 0.5 )
98 resultant->SetDefinition( aKaonZS );
99 else
100 resultant->SetDefinition( aKaonZL );
101 // targetParticle->SetDefinition( aProton );
102 delete targetParticle;
103 return resultant;
104 }
105 }
106 delete targetParticle;
107 return (G4DynamicParticle*)NULL;
108 }
109
110 G4DynamicParticle *
111 G4LightMedia::KaonZeroShortExchange(
112 const G4HadProjectile *incidentParticle,
113 const G4Nucleus& targetNucleus )
114 {
115 G4ParticleDefinition* aProton = G4Proton::Proton();
116 G4ParticleDefinition* aKaonPlus = G4KaonPlus::KaonPlus();
117 G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
118
119 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
120
121 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
122
123 if( targetParticle->GetDefinition() == aProton ) {
124
125 // for k0 p reactions, change some of the elastic cross section to k+ n
126
127 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
128 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
129 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
130 G4DynamicParticle* resultant = new G4DynamicParticle;
131 resultant->SetDefinition( aKaonPlus );
132 // targetParticle->SetDefinition( aNeutron );
133 delete targetParticle;
134 return resultant;
135 }
136 } else {
137 if( G4UniformRand() >= 0.5 ) {
138 G4DynamicParticle* resultant = new G4DynamicParticle;
139 resultant->SetDefinition( aKaonZL );
140 delete targetParticle;
141 return resultant;
142 }
143 }
144 delete targetParticle;
145 return (G4DynamicParticle*)NULL;
146 }
147
148 G4DynamicParticle *
149 G4LightMedia::KaonZeroLongExchange(
150 const G4HadProjectile *,
151 const G4Nucleus& )
152 {
153 G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
154
155 if( G4UniformRand() >= 0.5 ) {
156 G4DynamicParticle* resultant = new G4DynamicParticle;
157 resultant->SetDefinition( aKaonZS );
158 return resultant;
159 }
160 return (G4DynamicParticle*)NULL;
161 }
162
163 G4DynamicParticle *
164 G4LightMedia::KaonMinusExchange(
165 const G4HadProjectile *,
166 const G4Nucleus& )
167 {
168 return (G4DynamicParticle*)NULL;
169 }
170
171 G4DynamicParticle *
172 G4LightMedia::ProtonExchange(
173 const G4HadProjectile *incidentParticle,
174 const G4Nucleus& targetNucleus )
175 {
176 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
177
178 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
179
180 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
181
182 if( targetParticle->GetDefinition() == aNeutron ) {
183 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
184 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
185 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
186 G4DynamicParticle* resultant = new G4DynamicParticle;
187 resultant->SetDefinition( aNeutron );
188 // targetParticle->SetDefinition( aProton );
189 delete targetParticle;
190 return resultant;
191 }
192 }
193 delete targetParticle;
194 return (G4DynamicParticle*)NULL;
195 }
196
197 G4DynamicParticle *
198 G4LightMedia::AntiProtonExchange(
199 const G4HadProjectile *incidentParticle,
200 const G4Nucleus& targetNucleus )
201 {
202 G4ParticleDefinition* aProton = G4Proton::Proton();
203 G4ParticleDefinition* anAntiNeutron = G4AntiNeutron::AntiNeutron();
204
205 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
206
207 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
208
209 if( targetParticle->GetDefinition() == aProton ) {
210 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
211 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*10.0 ) );
212 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
213 G4DynamicParticle* resultant = new G4DynamicParticle;
214 resultant->SetDefinition( anAntiNeutron );
215 // targetParticle->SetDefinition( aNeutron );
216 delete targetParticle;
217 return resultant;
218 }
219 }
220 delete targetParticle;
221 return (G4DynamicParticle*)NULL;
222 }
223
224 G4DynamicParticle *
225 G4LightMedia::NeutronExchange(
226 const G4HadProjectile *incidentParticle,
227 const G4Nucleus& targetNucleus )
228 {
229 G4ParticleDefinition* aProton = G4Proton::Proton();
230
231 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
232
233 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
234
235 if( targetParticle->GetDefinition() == aProton ) {
236 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
237 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
238 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
239 G4DynamicParticle* resultant = new G4DynamicParticle;
240 resultant->SetDefinition( aProton );
241 // targetParticle->SetDefinition( aNeutron );
242 delete targetParticle;
243 return resultant;
244 }
245 }
246 delete targetParticle;
247 return (G4DynamicParticle*)NULL;
248 }
249
250 G4DynamicParticle *
251 G4LightMedia::AntiNeutronExchange(
252 const G4HadProjectile *incidentParticle,
253 const G4Nucleus& targetNucleus )
254 {
255 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
256 G4ParticleDefinition* anAntiProton = G4AntiProton::AntiProton();
257
258 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
259
260 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
261
262 if( targetParticle->GetDefinition() == aNeutron ) {
263 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
264 G4int iplab = std::min( 9, G4int( incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
265 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
266 G4DynamicParticle* resultant = new G4DynamicParticle;
267 resultant->SetDefinition( anAntiProton );
268 // targetParticle->SetDefinition( aProton );
269 delete targetParticle;
270 return resultant;
271 }
272 }
273 delete targetParticle;
274 return (G4DynamicParticle*)NULL;
275 }
276
277 G4DynamicParticle *
278 G4LightMedia::LambdaExchange(
279 const G4HadProjectile *incidentParticle,
280 const G4Nucleus& targetNucleus )
281 {
282 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
283 G4ParticleDefinition* aProton = G4Proton::Proton();
284 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
285 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
286 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
287
288 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
289
290 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
291
292 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
293 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
294 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
295 G4DynamicParticle* resultant = new G4DynamicParticle;
296 G4int irn = G4int( G4UniformRand()/0.2 );
297 if( targetParticle->GetDefinition() == aNeutron ) {
298
299 // LN --> S0 N, LN --> S- P, LN --> N L, LN --> N S0, LN --> P S-
300
301 switch( irn ) {
302 case 0:
303 resultant->SetDefinition( aSigmaZero );
304 break;
305 case 1:
306 resultant->SetDefinition( aSigmaMinus );
307 // targetParticle->SetDefinition( aProton );
308 break;
309 case 2:
310 resultant->SetDefinition( aNeutron );
311 // targetParticle->SetDefinition( aLambda );
312 break;
313 case 3:
314 resultant->SetDefinition( aNeutron );
315 // targetParticle->SetDefinition( aSigmaZero );
316 break;
317 default:
318 resultant->SetDefinition( aProton );
319 // targetParticle->SetDefinition( aSigmaMinus );
320 break;
321 }
322 } else { // target particle is a proton
323
324 // LP --> S+ N, LP --> S0 P, LP --> P L, LP --> P S0, LP --> N S+
325
326 switch( irn ) {
327 case 0:
328 resultant->SetDefinition( aSigmaPlus );
329 // targetParticle->SetDefinition( aNeutron );
330 break;
331 case 1:
332 resultant->SetDefinition( aSigmaZero );
333 break;
334 case 2:
335 resultant->SetDefinition( aProton );
336 // targetParticle->SetDefinition( aLambda );
337 break;
338 case 3:
339 resultant->SetDefinition( aProton );
340 // targetParticle->SetDefinition( aSigmaZero );
341 break;
342 default:
343 resultant->SetDefinition( aNeutron );
344 // targetParticle->SetDefinition( aSigmaPlus );
345 break;
346 }
347 }
348 delete targetParticle;
349 return resultant;
350 }
351 delete targetParticle;
352 return (G4DynamicParticle*)NULL;
353 }
354
355 G4DynamicParticle *
356 G4LightMedia::AntiLambdaExchange(
357 const G4HadProjectile *incidentParticle,
358 const G4Nucleus& targetNucleus )
359 {
360 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
361 G4ParticleDefinition* aProton = G4Proton::Proton();
362 G4ParticleDefinition* anAntiSigmaPlus = G4AntiSigmaPlus::AntiSigmaPlus();
363 G4ParticleDefinition* anAntiSigmaMinus = G4AntiSigmaMinus::AntiSigmaMinus();
364 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
365
366 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
367
368 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
369
370 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
371 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
372 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
373 G4DynamicParticle* resultant = new G4DynamicParticle;
374 G4int irn = G4int( G4UniformRand()/0.2 );
375 if( targetParticle->GetDefinition() == aNeutron ) {
376
377 // LB N --> S+B P, LB N --> S0B N, LB N --> N LB,
378 // LB N --> N S0B, LB N --> P S+B
379
380 switch( irn ) {
381 case 0:
382 resultant->SetDefinition( anAntiSigmaPlus );
383 // targetParticle->SetDefinition( aProton );
384 break;
385 case 1:
386 resultant->SetDefinition( anAntiSigmaZero );
387 break;
388 case 2:
389 resultant->SetDefinition( aNeutron );
390 // targetParticle->SetDefinition( anAntiLambda );
391 break;
392 case 3:
393 resultant->SetDefinition( aNeutron );
394 // targetParticle->SetDefinition( anAntiSigmaZero );
395 break;
396 default:
397 resultant->SetDefinition( aProton );
398 // targetParticle->SetDefinition( anAntiSigmaPlus );
399 break;
400 }
401 } else { // target particle is a proton
402
403 // LB P --> S0B P, LB P --> S-B N, LB P --> P LB,
404 // LB P --> P S0B, LB P --> N S-B
405
406 switch( irn ) {
407 case 0:
408 resultant->SetDefinition( anAntiSigmaZero );
409 break;
410 case 1:
411 resultant->SetDefinition( anAntiSigmaMinus );
412 // targetParticle->SetDefinition( aNeutron );
413 break;
414 case 2:
415 resultant->SetDefinition( aProton );
416 // targetParticle->SetDefinition( anAntiLambda );
417 break;
418 case 3:
419 resultant->SetDefinition( aProton );
420 // targetParticle->SetDefinition( anAntiSigmaZero );
421 break;
422 default:
423 resultant->SetDefinition( aNeutron );
424 // targetParticle->SetDefinition( anAntiSigmaMinus );
425 break;
426 }
427 }
428 delete targetParticle;
429 return resultant;
430 }
431 delete targetParticle;
432 return (G4DynamicParticle*)NULL;
433 }
434
435 G4DynamicParticle *
436 G4LightMedia::SigmaPlusExchange(
437 const G4HadProjectile *incidentParticle,
438 const G4Nucleus& targetNucleus )
439 {
440 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
441 G4ParticleDefinition* aProton = G4Proton::Proton();
442 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
443 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
444
445 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
446
447 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
448
449 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
450 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
451 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
452 G4DynamicParticle* resultant = new G4DynamicParticle;
453
454 // introduce charge and strangeness exchange reactions
455
456 G4int irn = G4int( G4UniformRand()/0.2 );
457 if( targetParticle->GetDefinition() == aNeutron ) {
458
459 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
460
461 switch( irn ) {
462 case 0:
463 resultant->SetDefinition( aSigmaZero );
464 // targetParticle->SetDefinition( aProton );
465 break;
466 case 1:
467 resultant->SetDefinition( aLambda );
468 // targetParticle->SetDefinition( aProton );
469 break;
470 case 2:
471 resultant->SetDefinition( aNeutron );
472 // targetParticle->SetDefinition( aSigmaPlus );
473 break;
474 case 3:
475 resultant->SetDefinition( aProton );
476 // targetParticle->SetDefinition( aSigmaZero );
477 break;
478 default:
479 resultant->SetDefinition( aProton );
480 // targetParticle->SetDefinition( aLambda );
481 break;
482 }
483 } else { // target particle is a proton
484
485 // S+ P --> P S+
486
487 resultant->SetDefinition( aProton );
488 // targetParticle->SetDefinition( aSigmaPlus );
489 }
490 delete targetParticle;
491 return resultant;
492 }
493 delete targetParticle;
494 return (G4DynamicParticle*)NULL;
495 }
496
497 G4DynamicParticle *
498 G4LightMedia::SigmaMinusExchange(
499 const G4HadProjectile *incidentParticle,
500 const G4Nucleus& targetNucleus )
501 {
502 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
503 G4ParticleDefinition* aProton = G4Proton::Proton();
504 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
505 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
506
507 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
508
509 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
510
511 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
512 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
513 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
514 G4DynamicParticle* resultant = new G4DynamicParticle;
515
516 // introduce charge and strangeness exchange reactions
517
518 G4int irn = G4int( G4UniformRand()/0.2 );
519 if( targetParticle->GetDefinition() == aNeutron ) {
520
521 // S- N --> N S-
522
523 resultant->SetDefinition( aNeutron );
524 // targetParticle->SetDefinition( aSigmaMinus );
525 } else { // target particle is a proton
526
527 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
528
529 switch( irn ) {
530 case 0:
531 resultant->SetDefinition( aSigmaZero );
532 // targetParticle->SetDefinition( aNeutron );
533 break;
534 case 1:
535 resultant->SetDefinition( aLambda );
536 // targetParticle->SetDefinition( aNeutron );
537 break;
538 case 2:
539 resultant->SetDefinition( aProton );
540 // targetParticle->SetDefinition( aSigmaMinus );
541 break;
542 case 3:
543 resultant->SetDefinition( aNeutron );
544 // targetParticle->SetDefinition( aSigmaZero );
545 break;
546 default:
547 resultant->SetDefinition( aNeutron );
548 // targetParticle->SetDefinition( aLambda );
549 break;
550 }
551 }
552 delete targetParticle;
553 return resultant;
554 }
555 delete targetParticle;
556 return (G4DynamicParticle*)NULL;
557 }
558
559 G4DynamicParticle *
560 G4LightMedia::AntiSigmaPlusExchange(
561 const G4HadProjectile *incidentParticle,
562 const G4Nucleus& targetNucleus )
563 {
564 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
565 G4ParticleDefinition* aProton = G4Proton::Proton();
566 G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
567 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
568
569 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
570
571 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
572
573 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
574 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
575 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
576 G4DynamicParticle* resultant = new G4DynamicParticle;
577 G4int irn = G4int( G4UniformRand()/0.2 );
578 if( targetParticle->GetDefinition() == aNeutron ) {
579
580 // S+B N --> N S+B
581
582 resultant->SetDefinition( aNeutron );
583 // targetParticle->SetDefinition( anAntiSigmaPlus );
584 } else { // target particle is a proton
585
586 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
587
588 switch( irn ) {
589 case 0:
590 resultant->SetDefinition( anAntiLambda );
591 // targetParticle->SetDefinition( aNeutron );
592 break;
593 case 1:
594 resultant->SetDefinition( anAntiSigmaZero );
595 // targetParticle->SetDefinition( aNeutron );
596 break;
597 case 2:
598 resultant->SetDefinition( aNeutron );
599 // targetParticle->SetDefinition( anAntiLambda );
600 break;
601 case 3:
602 resultant->SetDefinition( aNeutron );
603 // targetParticle->SetDefinition( anAntiSigmaZero );
604 break;
605 default:
606 resultant->SetDefinition( aProton );
607 // targetParticle->SetDefinition( anAntiLambda );
608 break;
609 }
610 }
611 delete targetParticle;
612 return resultant;
613 }
614 delete targetParticle;
615 return (G4DynamicParticle*)NULL;
616 }
617
618 G4DynamicParticle *
619 G4LightMedia::AntiSigmaMinusExchange(
620 const G4HadProjectile *incidentParticle,
621 const G4Nucleus& targetNucleus )
622 {
623 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
624 G4ParticleDefinition* aProton = G4Proton::Proton();
625 G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
626 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
627
628 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
629
630 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
631
632 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
633 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
634 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
635 G4DynamicParticle* resultant = new G4DynamicParticle;
636 G4int irn = G4int( G4UniformRand()/0.2 );
637 if( targetParticle->GetDefinition() == aNeutron ) {
638
639 // S-B N --> LB P, S-B N --> S0B P, S-B N --> N S-B,
640 // S-B N --> P LB, S-B N --> P S0B
641
642 switch( irn ) {
643 case 0:
644 resultant->SetDefinition( anAntiLambda );
645 // targetParticle->SetDefinition( aProton );
646 break;
647 case 1:
648 resultant->SetDefinition( anAntiSigmaZero );
649 // targetParticle->SetDefinition( aProton );
650 break;
651 case 2:
652 resultant->SetDefinition( aNeutron );
653 // targetParticle->SetDefinition( anAntiSigmaMinus );
654 break;
655 case 3:
656 resultant->SetDefinition( aProton );
657 // targetParticle->SetDefinition( anAntiLambda );
658 break;
659 default:
660 resultant->SetDefinition( aProton );
661 // targetParticle->SetDefinition( anAntiSigmaZero );
662 break;
663 }
664 } else { // target particle is a proton
665
666 // S-B P --> P S-B
667
668 resultant->SetDefinition( aProton );
669 // targetParticle->SetDefinition( anAntiSigmaMinus );
670 }
671 delete targetParticle;
672 return resultant;
673 }
674 delete targetParticle;
675 return (G4DynamicParticle*)NULL;
676 }
677
678 G4DynamicParticle *
679 G4LightMedia::XiZeroExchange(
680 const G4HadProjectile *incidentParticle,
681 const G4Nucleus& targetNucleus )
682 {
683 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
684 G4ParticleDefinition* aProton = G4Proton::Proton();
685 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
686 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
687 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
688 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
689 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
690
691 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
692
693 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
694
695 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
696 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
697 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
698 G4DynamicParticle* resultant = new G4DynamicParticle;
699 if( targetParticle->GetDefinition() == aNeutron ) {
700 G4int irn = G4int( G4UniformRand()*7.0 );
701 switch( irn ) {
702 case 0:
703 resultant->SetDefinition( aSigmaZero );
704 // targetParticle->SetDefinition( aSigmaZero );
705 break;
706 case 1:
707 resultant->SetDefinition( aLambda );
708 // targetParticle->SetDefinition( aLambda );
709 break;
710 case 2:
711 resultant->SetDefinition( aXiMinus );
712 // targetParticle->SetDefinition( aProton );
713 break;
714 case 3:
715 resultant->SetDefinition( aProton );
716 // targetParticle->SetDefinition( aXiMinus );
717 break;
718 case 4:
719 resultant->SetDefinition( aSigmaPlus );
720 // targetParticle->SetDefinition( aSigmaMinus );
721 break;
722 case 5:
723 resultant->SetDefinition( aSigmaMinus );
724 // targetParticle->SetDefinition( aSigmaPlus );
725 break;
726 default:
727 resultant->SetDefinition( aNeutron );
728 // targetParticle->SetDefinition( aXiZero );
729 break;
730 }
731 } else { // target particle is a proton
732 G4int irn = G4int( G4UniformRand()*5.0 );
733 switch( irn ) {
734 case 0:
735 resultant->SetDefinition( aSigmaPlus );
736 // targetParticle->SetDefinition( aSigmaZero );
737 break;
738 case 1:
739 resultant->SetDefinition( aSigmaZero );
740 // targetParticle->SetDefinition( aSigmaPlus );
741 break;
742 case 2:
743 resultant->SetDefinition( aSigmaPlus );
744 // targetParticle->SetDefinition( aLambda );
745 break;
746 case 3:
747 resultant->SetDefinition( aLambda );
748 // targetParticle->SetDefinition( aSigmaPlus );
749 break;
750 default:
751 resultant->SetDefinition( aProton );
752 // targetParticle->SetDefinition( aXiZero );
753 break;
754 }
755 }
756 delete targetParticle;
757 return resultant;
758 }
759 delete targetParticle;
760 return (G4DynamicParticle*)NULL;
761 }
762
763 G4DynamicParticle *
764 G4LightMedia::XiMinusExchange(
765 const G4HadProjectile *incidentParticle,
766 const G4Nucleus& targetNucleus )
767 {
768 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
769 G4ParticleDefinition* aProton = G4Proton::Proton();
770 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
771 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
772 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
773 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
774
775 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
776
777 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
778
779 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
780 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
781 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
782 G4DynamicParticle* resultant = new G4DynamicParticle;
783 if( targetParticle->GetDefinition() == aNeutron ) {
784 G4int irn = G4int( G4UniformRand()*5.0 );
785 switch( irn ) {
786 case 0:
787 resultant->SetDefinition( aNeutron );
788 // targetParticle->SetDefinition( aXiMinus );
789 break;
790 case 1:
791 resultant->SetDefinition( aSigmaZero );
792 // targetParticle->SetDefinition( aSigmaMinus );
793 break;
794 case 2:
795 resultant->SetDefinition( aSigmaMinus );
796 // targetParticle->SetDefinition( aSigmaZero );
797 break;
798 case 3:
799 resultant->SetDefinition( aLambda );
800 // targetParticle->SetDefinition( aSigmaMinus );
801 break;
802 default:
803 resultant->SetDefinition( aSigmaMinus );
804 // targetParticle->SetDefinition( aLambda );
805 break;
806 }
807 } else { // target particle is a proton
808 G4int irn = G4int( G4UniformRand()*7.0 );
809 switch( irn ) {
810 case 0:
811 resultant->SetDefinition( aXiZero );
812 // targetParticle->SetDefinition( aNeutron );
813 break;
814 case 1:
815 resultant->SetDefinition( aNeutron );
816 // targetParticle->SetDefinition( aXiZero );
817 break;
818 case 2:
819 resultant->SetDefinition( aSigmaZero );
820 // targetParticle->SetDefinition( aSigmaZero );
821 break;
822 case 3:
823 resultant->SetDefinition( aLambda );
824 // targetParticle->SetDefinition( aLambda );
825 break;
826 case 4:
827 resultant->SetDefinition( aSigmaZero );
828 // targetParticle->SetDefinition( aLambda );
829 break;
830 case 5:
831 resultant->SetDefinition( aLambda );
832 // targetParticle->SetDefinition( aSigmaZero );
833 break;
834 default:
835 resultant->SetDefinition( aProton );
836 // targetParticle->SetDefinition( aXiMinus );
837 break;
838 }
839 }
840 delete targetParticle;
841 return resultant;
842 }
843 delete targetParticle;
844 return (G4DynamicParticle*)NULL;
845 }
846
847 G4DynamicParticle *
848 G4LightMedia::AntiXiZeroExchange(
849 const G4HadProjectile *incidentParticle,
850 const G4Nucleus& targetNucleus )
851 {
852 // NOTE: The FORTRAN version of the cascade, CASAXO, simply called the
853 // routine for the XiZero particle. Hence, the Exchange function
854 // below is just a copy of the Exchange from the XiZero particle
855
856 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
857 G4ParticleDefinition* aProton = G4Proton::Proton();
858 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
859 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
860 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
861 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
862 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
863
864 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
865
866 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
867
868 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
869 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
870 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
871 G4DynamicParticle* resultant = new G4DynamicParticle;
872 if( targetParticle->GetDefinition() == aNeutron ) {
873 G4int irn = G4int( G4UniformRand()*7.0 );
874 switch( irn ) {
875 case 0:
876 resultant->SetDefinition( aSigmaZero );
877 // targetParticle->SetDefinition( aSigmaZero );
878 break;
879 case 1:
880 resultant->SetDefinition( aLambda );
881 // targetParticle->SetDefinition( aLambda );
882 break;
883 case 2:
884 resultant->SetDefinition( aXiMinus );
885 // targetParticle->SetDefinition( aProton );
886 break;
887 case 3:
888 resultant->SetDefinition( aProton );
889 // targetParticle->SetDefinition( aXiMinus );
890 break;
891 case 4:
892 resultant->SetDefinition( aSigmaPlus );
893 // targetParticle->SetDefinition( aSigmaMinus );
894 break;
895 case 5:
896 resultant->SetDefinition( aSigmaMinus );
897 // targetParticle->SetDefinition( aSigmaPlus );
898 break;
899 default:
900 resultant->SetDefinition( aNeutron );
901 // targetParticle->SetDefinition( aXiZero );
902 break;
903 }
904 } else { // target particle is a proton
905 G4int irn = G4int( G4UniformRand()*5.0 );
906 switch( irn ) {
907 case 0:
908 resultant->SetDefinition( aSigmaPlus );
909 // targetParticle->SetDefinition( aSigmaZero );
910 break;
911 case 1:
912 resultant->SetDefinition( aSigmaZero );
913 // targetParticle->SetDefinition( aSigmaPlus );
914 break;
915 case 2:
916 resultant->SetDefinition( aSigmaPlus );
917 // targetParticle->SetDefinition( aLambda );
918 break;
919 case 3:
920 resultant->SetDefinition( aLambda );
921 // targetParticle->SetDefinition( aSigmaPlus );
922 break;
923 default:
924 resultant->SetDefinition( aProton );
925 // targetParticle->SetDefinition( aXiZero );
926 break;
927 }
928 }
929 delete targetParticle;
930 return resultant;
931 }
932 delete targetParticle;
933 return (G4DynamicParticle*)NULL;
934 }
935
936 G4DynamicParticle *
937 G4LightMedia::AntiXiMinusExchange(
938 const G4HadProjectile *incidentParticle,
939 const G4Nucleus& targetNucleus )
940 {
941 // NOTE: The FORTRAN version of the cascade, CASAXM, simply called the
942 // routine for the XiMinus particle. Hence, the Exchange function
943 // below is just a copy of the Exchange from the XiMinus particle
944
945 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
946 G4ParticleDefinition* aProton = G4Proton::Proton();
947 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
948 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
949 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
950 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
951
952 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
953
954 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
955
956 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
957 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
958 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
959 G4DynamicParticle* resultant = new G4DynamicParticle;
960 if( targetParticle->GetDefinition() == aNeutron ) {
961 G4int irn = G4int( G4UniformRand()*5.0 );
962 switch( irn ) {
963 case 0:
964 resultant->SetDefinition( aNeutron );
965 // targetParticle->SetDefinition( aXiMinus );
966 break;
967 case 1:
968 resultant->SetDefinition( aSigmaZero );
969 // targetParticle->SetDefinition( aSigmaMinus );
970 break;
971 case 2:
972 resultant->SetDefinition( aSigmaMinus );
973 // targetParticle->SetDefinition( aSigmaZero );
974 break;
975 case 3:
976 resultant->SetDefinition( aLambda );
977 // targetParticle->SetDefinition( aSigmaMinus );
978 break;
979 default:
980 resultant->SetDefinition( aSigmaMinus );
981 // targetParticle->SetDefinition( aLambda );
982 break;
983 }
984 } else { // target particle is a proton
985 G4int irn = G4int( G4UniformRand()*7.0 );
986 switch( irn ) {
987 case 0:
988 resultant->SetDefinition( aXiZero );
989 // targetParticle->SetDefinition( aNeutron );
990 break;
991 case 1:
992 resultant->SetDefinition( aNeutron );
993 // targetParticle->SetDefinition( aXiZero );
994 break;
995 case 2:
996 resultant->SetDefinition( aSigmaZero );
997 // targetParticle->SetDefinition( aSigmaZero );
998 break;
999 case 3:
1000 resultant->SetDefinition( aLambda );
1001 // targetParticle->SetDefinition( aLambda );
1002 break;
1003 case 4:
1004 resultant->SetDefinition( aSigmaZero );
1005 // targetParticle->SetDefinition( aLambda );
1006 break;
1007 case 5:
1008 resultant->SetDefinition( aLambda );
1009 // targetParticle->SetDefinition( aSigmaZero );
1010 break;
1011 default:
1012 resultant->SetDefinition( aProton );
1013 // targetParticle->SetDefinition( aXiMinus );
1014 break;
1015 }
1016 }
1017 delete targetParticle;
1018 return resultant;
1019 }
1020 delete targetParticle;
1021 return (G4DynamicParticle*)NULL;
1022 }
1023
1024 G4DynamicParticle *
1025 G4LightMedia::OmegaMinusExchange(
1026 const G4HadProjectile *incidentParticle,
1027 const G4Nucleus& targetNucleus )
1028 {
1029 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
1030 G4ParticleDefinition* aProton = G4Proton::Proton();
1031 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
1032 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
1033 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
1034 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
1035 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
1036 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
1037
1038 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
1039
1040 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
1041
1042 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
1043 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
1044 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
1045 G4DynamicParticle* resultant = new G4DynamicParticle;
1046
1047 // introduce charge and strangeness exchange reactions
1048
1049 if( targetParticle->GetDefinition() == aNeutron ) {
1050 G4int irn = G4int( G4UniformRand()*7.0 );
1051 switch( irn ) {
1052 case 0:
1053 resultant->SetDefinition( aXiZero );
1054 // targetParticle->SetDefinition( aSigmaMinus );
1055 break;
1056 case 1:
1057 resultant->SetDefinition( aSigmaMinus );
1058 // targetParticle->SetDefinition( aXiZero );
1059 break;
1060 case 2:
1061 resultant->SetDefinition( aXiMinus );
1062 // targetParticle->SetDefinition( aLambda );
1063 break;
1064 case 3:
1065 resultant->SetDefinition( aLambda );
1066 // targetParticle->SetDefinition( aXiMinus );
1067 break;
1068 case 4:
1069 resultant->SetDefinition( aXiMinus );
1070 // targetParticle->SetDefinition( aSigmaZero );
1071 break;
1072 case 5:
1073 resultant->SetDefinition( aSigmaZero );
1074 // targetParticle->SetDefinition( aXiMinus );
1075 break;
1076 default:
1077 resultant->SetDefinition( aNeutron );
1078 // targetParticle->SetDefinition( anOmegaMinus );
1079 break;
1080 }
1081 } else { // target particle is a proton
1082 G4int irn = G4int( G4UniformRand()*7.0 );
1083 switch( irn ) {
1084 case 0:
1085 resultant->SetDefinition( aXiZero );
1086 // targetParticle->SetDefinition( aSigmaZero );
1087 break;
1088 case 1:
1089 resultant->SetDefinition( aSigmaZero );
1090 // targetParticle->SetDefinition( aXiZero );
1091 break;
1092 case 2:
1093 resultant->SetDefinition( aXiZero );
1094 // targetParticle->SetDefinition( aLambda );
1095 break;
1096 case 3:
1097 resultant->SetDefinition( aLambda );
1098 // targetParticle->SetDefinition( aXiZero );
1099 break;
1100 case 4:
1101 resultant->SetDefinition( aXiMinus );
1102 // targetParticle->SetDefinition( aSigmaPlus );
1103 break;
1104 case 5:
1105 resultant->SetDefinition( aSigmaPlus );
1106 // targetParticle->SetDefinition( aXiMinus );
1107 break;
1108 default:
1109 resultant->SetDefinition( aProton );
1110 // targetParticle->SetDefinition( anOmegaMinus );
1111 break;
1112 }
1113 }
1114 delete targetParticle;
1115 return resultant;
1116 }
1117 delete targetParticle;
1118 return (G4DynamicParticle*)NULL;
1119 }
1120
1121 G4DynamicParticle *
1122 G4LightMedia::AntiOmegaMinusExchange(
1123 const G4HadProjectile *incidentParticle,
1124 const G4Nucleus& targetNucleus )
1125 {
1126 // NOTE: The FORTRAN version of the cascade, CASAOM, simply called the
1127 // routine for the OmegaMinus particle. Hence, the Exchange function
1128 // below is just a copy of the Exchange from the OmegaMinus particle.
1129
1130 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
1131 G4ParticleDefinition* aProton = G4Proton::Proton();
1132 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
1133 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
1134 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
1135 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
1136 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
1137 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
1138
1139 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
1140
1141 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
1142
1143 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
1144 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
1145 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
1146 G4DynamicParticle* resultant = new G4DynamicParticle;
1147
1148 // introduce charge and strangeness exchange reactions
1149
1150 if( targetParticle->GetDefinition() == aNeutron ) {
1151 G4int irn = G4int( G4UniformRand()*7.0 );
1152 switch( irn ) {
1153 case 0:
1154 resultant->SetDefinition( aXiZero );
1155 // targetParticle->SetDefinition( aSigmaMinus );
1156 break;
1157 case 1:
1158 resultant->SetDefinition( aSigmaMinus );
1159 // targetParticle->SetDefinition( aXiZero );
1160 break;
1161 case 2:
1162 resultant->SetDefinition( aXiMinus );
1163 // targetParticle->SetDefinition( aLambda );
1164 break;
1165 case 3:
1166 resultant->SetDefinition( aLambda );
1167 // targetParticle->SetDefinition( aXiMinus );
1168 break;
1169 case 4:
1170 resultant->SetDefinition( aXiMinus );
1171 // targetParticle->SetDefinition( aSigmaZero );
1172 break;
1173 case 5:
1174 resultant->SetDefinition( aSigmaZero );
1175 // targetParticle->SetDefinition( aXiMinus );
1176 break;
1177 default:
1178 resultant->SetDefinition( aNeutron );
1179 // targetParticle->SetDefinition( anOmegaMinus );
1180 break;
1181 }
1182 } else { // target particle is a proton
1183 G4int irn = G4int( G4UniformRand()*7.0 );
1184 switch( irn ) {
1185 case 0:
1186 resultant->SetDefinition( aXiZero );
1187 // targetParticle->SetDefinition( aSigmaZero );
1188 break;
1189 case 1:
1190 resultant->SetDefinition( aSigmaZero );
1191 // targetParticle->SetDefinition( aXiZero );
1192 break;
1193 case 2:
1194 resultant->SetDefinition( aXiZero );
1195 // targetParticle->SetDefinition( aLambda );
1196 break;
1197 case 3:
1198 resultant->SetDefinition( aLambda );
1199 // targetParticle->SetDefinition( aXiZero );
1200 break;
1201 case 4:
1202 resultant->SetDefinition( aXiMinus );
1203 // targetParticle->SetDefinition( aSigmaPlus );
1204 break;
1205 case 5:
1206 resultant->SetDefinition( aSigmaPlus );
1207 // targetParticle->SetDefinition( aXiMinus );
1208 break;
1209 default:
1210 resultant->SetDefinition( aProton );
1211 // targetParticle->SetDefinition( anOmegaMinus );
1212 break;
1213 }
1214 }
1215 delete targetParticle;
1216 return resultant;
1217 }
1218 delete targetParticle;
1219 return (G4DynamicParticle*)NULL;
1220 }
1221
1222 /* end of file */
1223
Note: See TracBrowser for help on using the repository browser.