Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4LightMedia Class Reference

#include <G4LightMedia.hh>

Public Member Functions

 G4LightMedia ()
 
 G4LightMedia (const G4LightMedia &right)
 
 ~G4LightMedia ()
 
G4LightMedia & operator= (const G4LightMedia &)
 
G4bool operator== (const G4LightMedia &right) const
 
G4bool operator!= (const G4LightMedia &right) const
 
G4DynamicParticle * PionPlusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * PionMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * KaonPlusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * KaonZeroShortExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * KaonZeroLongExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * KaonMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * ProtonExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiProtonExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * NeutronExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiNeutronExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * LambdaExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiLambdaExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * SigmaPlusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * SigmaMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiSigmaPlusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiSigmaMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * XiZeroExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * XiMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiXiZeroExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiXiMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * OmegaMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 
G4DynamicParticle * AntiOmegaMinusExchange (const G4HadProjectile *incidentParticle, const G4Nucleus &aNucleus)
 

Detailed Description

Definition at line 40 of file G4LightMedia.hh.

Constructor & Destructor Documentation

◆ G4LightMedia() [1/2]

G4LightMedia::G4LightMedia ( )
inline

Definition at line 44 of file G4LightMedia.hh.

44{ }

◆ G4LightMedia() [2/2]

G4LightMedia::G4LightMedia ( const G4LightMedia &  right)
inline

Definition at line 46 of file G4LightMedia.hh.

47 { *this = right; }

◆ ~G4LightMedia()

G4LightMedia::~G4LightMedia ( )
inline

Definition at line 49 of file G4LightMedia.hh.

49{ }

Member Function Documentation

◆ AntiLambdaExchange()

G4DynamicParticle * G4LightMedia::AntiLambdaExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 362 of file G4LightMedia.cc.

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 }
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:52
G4AntiSigmaMinus::AntiSigmaMinus
static G4AntiSigmaMinus * AntiSigmaMinus()
Definition: G4AntiSigmaMinus.cc:105
G4AntiSigmaPlus::AntiSigmaPlus
static G4AntiSigmaPlus * AntiSigmaPlus()
Definition: G4AntiSigmaPlus.cc:107
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:102
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:325
G4DynamicParticle::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:111
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:103
G4Pow::GetInstance
static G4Pow * GetInstance()
Definition: G4Pow.cc:41
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:92

◆ AntiNeutronExchange()

G4DynamicParticle * G4LightMedia::AntiNeutronExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 257 of file G4LightMedia.cc.

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 }
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:92

◆ AntiOmegaMinusExchange()

G4DynamicParticle * G4LightMedia::AntiOmegaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 1128 of file G4LightMedia.cc.

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 }
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:107
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:105
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:107
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:101
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:105
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:105

◆ AntiProtonExchange()

G4DynamicParticle * G4LightMedia::AntiProtonExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 204 of file G4LightMedia.cc.

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 }
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:101

◆ AntiSigmaMinusExchange()

G4DynamicParticle * G4LightMedia::AntiSigmaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 625 of file G4LightMedia.cc.

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 }
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition: G4AntiLambda.cc:107

◆ AntiSigmaPlusExchange()

G4DynamicParticle * G4LightMedia::AntiSigmaPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 566 of file G4LightMedia.cc.

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 }

◆ AntiXiMinusExchange()

G4DynamicParticle * G4LightMedia::AntiXiMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 943 of file G4LightMedia.cc.

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 }

◆ AntiXiZeroExchange()

G4DynamicParticle * G4LightMedia::AntiXiZeroExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 854 of file G4LightMedia.cc.

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 }

◆ KaonMinusExchange()

G4DynamicParticle * G4LightMedia::KaonMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 170 of file G4LightMedia.cc.

173 {
174 return (G4DynamicParticle*)NULL;
175 }

◆ KaonPlusExchange()

G4DynamicParticle * G4LightMedia::KaonPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 83 of file G4LightMedia.cc.

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 }
G4KaonZeroLong::KaonZeroLong
static G4KaonZeroLong * KaonZeroLong()
Definition: G4KaonZeroLong.cc:114
G4KaonZeroShort::KaonZeroShort
static G4KaonZeroShort * KaonZeroShort()
Definition: G4KaonZeroShort.cc:103

◆ KaonZeroLongExchange()

G4DynamicParticle * G4LightMedia::KaonZeroLongExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 155 of file G4LightMedia.cc.

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 }

◆ KaonZeroShortExchange()

G4DynamicParticle * G4LightMedia::KaonZeroShortExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 117 of file G4LightMedia.cc.

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 }
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:112

◆ LambdaExchange()

G4DynamicParticle * G4LightMedia::LambdaExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 284 of file G4LightMedia.cc.

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 }

◆ NeutronExchange()

G4DynamicParticle * G4LightMedia::NeutronExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 231 of file G4LightMedia.cc.

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 }

◆ OmegaMinusExchange()

G4DynamicParticle * G4LightMedia::OmegaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 1031 of file G4LightMedia.cc.

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 }

◆ operator!=()

G4bool G4LightMedia::operator!= ( const G4LightMedia &  right) const
inline

Definition at line 57 of file G4LightMedia.hh.

58 { return ( this != (G4LightMedia *) &right ); }

◆ operator=()

G4LightMedia & G4LightMedia::operator= ( const G4LightMedia &  )
inline

Definition at line 51 of file G4LightMedia.hh.

52 { return *this; }

◆ operator==()

G4bool G4LightMedia::operator== ( const G4LightMedia &  right) const
inline

Definition at line 54 of file G4LightMedia.hh.

55 { return ( this == (G4LightMedia *) &right ); }

◆ PionMinusExchange()

G4DynamicParticle * G4LightMedia::PionMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 75 of file G4LightMedia.cc.

78 {
79 return (G4DynamicParticle*)NULL;
80 }

◆ PionPlusExchange()

G4DynamicParticle * G4LightMedia::PionPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 45 of file G4LightMedia.cc.

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 }
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:107

◆ ProtonExchange()

G4DynamicParticle * G4LightMedia::ProtonExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 178 of file G4LightMedia.cc.

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 }

◆ SigmaMinusExchange()

G4DynamicParticle * G4LightMedia::SigmaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 504 of file G4LightMedia.cc.

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 }

◆ SigmaPlusExchange()

G4DynamicParticle * G4LightMedia::SigmaPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 442 of file G4LightMedia.cc.

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 }

◆ XiMinusExchange()

G4DynamicParticle * G4LightMedia::XiMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 770 of file G4LightMedia.cc.

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 }

◆ XiZeroExchange()

G4DynamicParticle * G4LightMedia::XiZeroExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 685 of file G4LightMedia.cc.

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 }
The documentation for this class was generated from the following files: