Geant4_10
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 
G4LightMedia::SigmaPlusExchange
G4DynamicParticle * SigmaPlusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:437
G4LightMedia::LambdaExchange
G4DynamicParticle * LambdaExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:279
G4LightMedia::AntiNeutronExchange
G4DynamicParticle * AntiNeutronExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:252
G4LightMedia::AntiLambdaExchange
G4DynamicParticle * AntiLambdaExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:357
G4LightMedia::ProtonExchange
G4DynamicParticle * ProtonExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:173
G4KaonZeroLong::KaonZeroLong
static G4KaonZeroLong * KaonZeroLong()
Definition: G4KaonZeroLong.cc:115
G4AntiSigmaPlus::AntiSigmaPlus
static G4AntiSigmaPlus * AntiSigmaPlus()
Definition: G4AntiSigmaPlus.cc:108
G4int
int G4int
Definition: G4Types.hh:78
G4Nucleus::ReturnTargetParticle
G4DynamicParticle * ReturnTargetParticle() const
Definition: G4Nucleus.cc:227
G4LightMedia::OmegaMinusExchange
G4DynamicParticle * OmegaMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:1026
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4LightMedia::AntiXiMinusExchange
G4DynamicParticle * AntiXiMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:938
G4AntiSigmaMinus::AntiSigmaMinus
static G4AntiSigmaMinus * AntiSigmaMinus()
Definition: G4AntiSigmaMinus.cc:106
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4KaonZeroShort::KaonZeroShort
static G4KaonZeroShort * KaonZeroShort()
Definition: G4KaonZeroShort.cc:104
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4LightMedia::KaonPlusExchange
G4DynamicParticle * KaonPlusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:78
G4LightMedia::AntiOmegaMinusExchange
G4DynamicParticle * AntiOmegaMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:1123
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4LightMedia::KaonZeroShortExchange
G4DynamicParticle * KaonZeroShortExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:112
G4LightMedia::KaonZeroLongExchange
G4DynamicParticle * KaonZeroLongExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:150
Randomize.hh
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:104
G4LightMedia::KaonMinusExchange
G4DynamicParticle * KaonMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:165
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4LightMedia.hh
G4LightMedia::AntiSigmaPlusExchange
G4DynamicParticle * AntiSigmaPlusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:561
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition: G4AntiLambda.cc:108
G4LightMedia::AntiProtonExchange
G4DynamicParticle * AntiProtonExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:199
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:99
G4Nucleus::GetZ_asInt
G4int GetZ_asInt() const
Definition: G4Nucleus.hh:115
G4LightMedia::PionPlusExchange
G4DynamicParticle * PionPlusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:40
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4LightMedia::AntiXiZeroExchange
G4DynamicParticle * AntiXiZeroExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:849
G4LightMedia::XiZeroExchange
G4DynamicParticle * XiZeroExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:680
G4LightMedia::XiMinusExchange
G4DynamicParticle * XiMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:765
G4LightMedia::NeutronExchange
G4DynamicParticle * NeutronExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:226
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4SystemOfUnits.hh
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:113
G4LightMedia::AntiSigmaMinusExchange
G4DynamicParticle * AntiSigmaMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:620
G4LightMedia::SigmaMinusExchange
G4DynamicParticle * SigmaMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:499
G4LightMedia::PionMinusExchange
G4DynamicParticle * PionMinusExchange(const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
Definition: G4LightMedia.cc:70
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:103
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
Generated on Sat Dec 14 2013 14:35:04 for Geant4_10 by   doxygen 1.8.5