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