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