Context Navigation

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

Last change on this file since 962 was 819, checked in by garnier, 16 years ago
import all except CVS
File size: 44.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: