ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4LightMedia.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4LightMedia.cc
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 
46  const G4HadProjectile *incidentParticle,
47  const G4Nucleus & targetNucleus )
48  {
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 
76  const G4HadProjectile *,
77  const G4Nucleus& )
78  {
79  return (G4DynamicParticle*)NULL;
80  }
81 
84  const G4HadProjectile *incidentParticle,
85  const G4Nucleus& targetNucleus )
86  {
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 
118  const G4HadProjectile *incidentParticle,
119  const G4Nucleus& targetNucleus )
120  {
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 
156  const G4HadProjectile *,
157  const G4Nucleus& )
158  {
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 
171  const G4HadProjectile *,
172  const G4Nucleus& )
173  {
174  return (G4DynamicParticle*)NULL;
175  }
176 
179  const G4HadProjectile *incidentParticle,
180  const G4Nucleus& targetNucleus )
181  {
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 
205  const G4HadProjectile *incidentParticle,
206  const G4Nucleus& targetNucleus )
207  {
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 
232  const G4HadProjectile *incidentParticle,
233  const G4Nucleus& targetNucleus )
234  {
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 
258  const G4HadProjectile *incidentParticle,
259  const G4Nucleus& targetNucleus )
260  {
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 
285  const G4HadProjectile *incidentParticle,
286  const G4Nucleus& targetNucleus )
287  {
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 
363  const G4HadProjectile *incidentParticle,
364  const G4Nucleus& targetNucleus )
365  {
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 
443  const G4HadProjectile *incidentParticle,
444  const G4Nucleus& targetNucleus )
445  {
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 
505  const G4HadProjectile *incidentParticle,
506  const G4Nucleus& targetNucleus )
507  {
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 
567  const G4HadProjectile *incidentParticle,
568  const G4Nucleus& targetNucleus )
569  {
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 
626  const G4HadProjectile *incidentParticle,
627  const G4Nucleus& targetNucleus )
628  {
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 
686  const G4HadProjectile *incidentParticle,
687  const G4Nucleus& targetNucleus )
688  {
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 
771  const G4HadProjectile *incidentParticle,
772  const G4Nucleus& targetNucleus )
773  {
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 
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 
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 
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 
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 
1032  const G4HadProjectile *incidentParticle,
1033  const G4Nucleus& targetNucleus )
1034  {
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 
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 
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