Geant4 9.6.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 357 of file G4LightMedia.cc.

360 {
361 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
362 G4ParticleDefinition* aProton = G4Proton::Proton();
363 G4ParticleDefinition* anAntiSigmaPlus = G4AntiSigmaPlus::AntiSigmaPlus();
364 G4ParticleDefinition* anAntiSigmaMinus = G4AntiSigmaMinus::AntiSigmaMinus();
365 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
366
367 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
368
369 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
370
371 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
372 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
373 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
374 G4DynamicParticle* resultant = new G4DynamicParticle;
375 G4int irn = G4int( G4UniformRand()/0.2 );
376 if( targetParticle->GetDefinition() == aNeutron ) {
377
378 // LB N --> S+B P, LB N --> S0B N, LB N --> N LB,
379 // LB N --> N S0B, LB N --> P S+B
380
381 switch( irn ) {
382 case 0:
383 resultant->SetDefinition( anAntiSigmaPlus );
384 // targetParticle->SetDefinition( aProton );
385 break;
386 case 1:
387 resultant->SetDefinition( anAntiSigmaZero );
388 break;
389 case 2:
390 resultant->SetDefinition( aNeutron );
391 // targetParticle->SetDefinition( anAntiLambda );
392 break;
393 case 3:
394 resultant->SetDefinition( aNeutron );
395 // targetParticle->SetDefinition( anAntiSigmaZero );
396 break;
397 default:
398 resultant->SetDefinition( aProton );
399 // targetParticle->SetDefinition( anAntiSigmaPlus );
400 break;
401 }
402 } else { // target particle is a proton
403
404 // LB P --> S0B P, LB P --> S-B N, LB P --> P LB,
405 // LB P --> P S0B, LB P --> N S-B
406
407 switch( irn ) {
408 case 0:
409 resultant->SetDefinition( anAntiSigmaZero );
410 break;
411 case 1:
412 resultant->SetDefinition( anAntiSigmaMinus );
413 // targetParticle->SetDefinition( aNeutron );
414 break;
415 case 2:
416 resultant->SetDefinition( aProton );
417 // targetParticle->SetDefinition( anAntiLambda );
418 break;
419 case 3:
420 resultant->SetDefinition( aProton );
421 // targetParticle->SetDefinition( anAntiSigmaZero );
422 break;
423 default:
424 resultant->SetDefinition( aNeutron );
425 // targetParticle->SetDefinition( anAntiSigmaMinus );
426 break;
427 }
428 }
429 delete targetParticle;
430 return resultant;
431 }
432 delete targetParticle;
433 return (G4DynamicParticle*)NULL;
434 }
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:53
G4AntiSigmaMinus::AntiSigmaMinus
static G4AntiSigmaMinus * AntiSigmaMinus()
Definition: G4AntiSigmaMinus.cc:106
G4AntiSigmaPlus::AntiSigmaPlus
static G4AntiSigmaPlus * AntiSigmaPlus()
Definition: G4AntiSigmaPlus.cc:108
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:99
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:271
G4DynamicParticle::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93

Referenced by G4LElastic::ApplyYourself().

◆ AntiNeutronExchange()

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

Definition at line 252 of file G4LightMedia.cc.

255 {
256 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
257 G4ParticleDefinition* anAntiProton = G4AntiProton::AntiProton();
258
259 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
260
261 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
262
263 if( targetParticle->GetDefinition() == aNeutron ) {
264 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
265 G4int iplab = std::min( 9, G4int( incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
266 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
267 G4DynamicParticle* resultant = new G4DynamicParticle;
268 resultant->SetDefinition( anAntiProton );
269 // targetParticle->SetDefinition( aProton );
270 delete targetParticle;
271 return resultant;
272 }
273 }
274 delete targetParticle;
275 return (G4DynamicParticle*)NULL;
276 }
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93

Referenced by G4LElastic::ApplyYourself().

◆ AntiOmegaMinusExchange()

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

Definition at line 1123 of file G4LightMedia.cc.

1126 {
1127 // NOTE: The FORTRAN version of the cascade, CASAOM, simply called the
1128 // routine for the OmegaMinus particle. Hence, the Exchange function
1129 // below is just a copy of the Exchange from the OmegaMinus particle.
1130
1131 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
1132 G4ParticleDefinition* aProton = G4Proton::Proton();
1133 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
1134 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
1135 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
1136 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
1137 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
1138 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
1139
1140 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
1141
1142 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
1143
1144 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
1145 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
1146 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
1147 G4DynamicParticle* resultant = new G4DynamicParticle;
1148
1149 // introduce charge and strangeness exchange reactions
1150
1151 if( targetParticle->GetDefinition() == aNeutron ) {
1152 G4int irn = G4int( G4UniformRand()*7.0 );
1153 switch( irn ) {
1154 case 0:
1155 resultant->SetDefinition( aXiZero );
1156 // targetParticle->SetDefinition( aSigmaMinus );
1157 break;
1158 case 1:
1159 resultant->SetDefinition( aSigmaMinus );
1160 // targetParticle->SetDefinition( aXiZero );
1161 break;
1162 case 2:
1163 resultant->SetDefinition( aXiMinus );
1164 // targetParticle->SetDefinition( aLambda );
1165 break;
1166 case 3:
1167 resultant->SetDefinition( aLambda );
1168 // targetParticle->SetDefinition( aXiMinus );
1169 break;
1170 case 4:
1171 resultant->SetDefinition( aXiMinus );
1172 // targetParticle->SetDefinition( aSigmaZero );
1173 break;
1174 case 5:
1175 resultant->SetDefinition( aSigmaZero );
1176 // targetParticle->SetDefinition( aXiMinus );
1177 break;
1178 default:
1179 resultant->SetDefinition( aNeutron );
1180 // targetParticle->SetDefinition( anOmegaMinus );
1181 break;
1182 }
1183 } else { // target particle is a proton
1184 G4int irn = G4int( G4UniformRand()*7.0 );
1185 switch( irn ) {
1186 case 0:
1187 resultant->SetDefinition( aXiZero );
1188 // targetParticle->SetDefinition( aSigmaZero );
1189 break;
1190 case 1:
1191 resultant->SetDefinition( aSigmaZero );
1192 // targetParticle->SetDefinition( aXiZero );
1193 break;
1194 case 2:
1195 resultant->SetDefinition( aXiZero );
1196 // targetParticle->SetDefinition( aLambda );
1197 break;
1198 case 3:
1199 resultant->SetDefinition( aLambda );
1200 // targetParticle->SetDefinition( aXiZero );
1201 break;
1202 case 4:
1203 resultant->SetDefinition( aXiMinus );
1204 // targetParticle->SetDefinition( aSigmaPlus );
1205 break;
1206 case 5:
1207 resultant->SetDefinition( aSigmaPlus );
1208 // targetParticle->SetDefinition( aXiMinus );
1209 break;
1210 default:
1211 resultant->SetDefinition( aProton );
1212 // targetParticle->SetDefinition( anOmegaMinus );
1213 break;
1214 }
1215 }
1216 delete targetParticle;
1217 return resultant;
1218 }
1219 delete targetParticle;
1220 return (G4DynamicParticle*)NULL;
1221 }
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106

Referenced by G4LElastic::ApplyYourself().

◆ AntiProtonExchange()

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

Definition at line 199 of file G4LightMedia.cc.

202 {
203 G4ParticleDefinition* aProton = G4Proton::Proton();
204 G4ParticleDefinition* anAntiNeutron = G4AntiNeutron::AntiNeutron();
205
206 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
207
208 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
209
210 if( targetParticle->GetDefinition() == aProton ) {
211 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
212 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*10.0 ) );
213 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
214 G4DynamicParticle* resultant = new G4DynamicParticle;
215 resultant->SetDefinition( anAntiNeutron );
216 // targetParticle->SetDefinition( aNeutron );
217 delete targetParticle;
218 return resultant;
219 }
220 }
221 delete targetParticle;
222 return (G4DynamicParticle*)NULL;
223 }
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:103

Referenced by G4LElastic::ApplyYourself().

◆ AntiSigmaMinusExchange()

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

Definition at line 620 of file G4LightMedia.cc.

623 {
624 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
625 G4ParticleDefinition* aProton = G4Proton::Proton();
626 G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
627 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
628
629 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
630
631 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
632
633 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
634 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
635 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
636 G4DynamicParticle* resultant = new G4DynamicParticle;
637 G4int irn = G4int( G4UniformRand()/0.2 );
638 if( targetParticle->GetDefinition() == aNeutron ) {
639
640 // S-B N --> LB P, S-B N --> S0B P, S-B N --> N S-B,
641 // S-B N --> P LB, S-B N --> P S0B
642
643 switch( irn ) {
644 case 0:
645 resultant->SetDefinition( anAntiLambda );
646 // targetParticle->SetDefinition( aProton );
647 break;
648 case 1:
649 resultant->SetDefinition( anAntiSigmaZero );
650 // targetParticle->SetDefinition( aProton );
651 break;
652 case 2:
653 resultant->SetDefinition( aNeutron );
654 // targetParticle->SetDefinition( anAntiSigmaMinus );
655 break;
656 case 3:
657 resultant->SetDefinition( aProton );
658 // targetParticle->SetDefinition( anAntiLambda );
659 break;
660 default:
661 resultant->SetDefinition( aProton );
662 // targetParticle->SetDefinition( anAntiSigmaZero );
663 break;
664 }
665 } else { // target particle is a proton
666
667 // S-B P --> P S-B
668
669 resultant->SetDefinition( aProton );
670 // targetParticle->SetDefinition( anAntiSigmaMinus );
671 }
672 delete targetParticle;
673 return resultant;
674 }
675 delete targetParticle;
676 return (G4DynamicParticle*)NULL;
677 }
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition: G4AntiLambda.cc:108

Referenced by G4LElastic::ApplyYourself().

◆ AntiSigmaPlusExchange()

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

Definition at line 561 of file G4LightMedia.cc.

564 {
565 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
566 G4ParticleDefinition* aProton = G4Proton::Proton();
567 G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
568 G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
569
570 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
571
572 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
573
574 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
575 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
576 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
577 G4DynamicParticle* resultant = new G4DynamicParticle;
578 G4int irn = G4int( G4UniformRand()/0.2 );
579 if( targetParticle->GetDefinition() == aNeutron ) {
580
581 // S+B N --> N S+B
582
583 resultant->SetDefinition( aNeutron );
584 // targetParticle->SetDefinition( anAntiSigmaPlus );
585 } else { // target particle is a proton
586
587 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
588
589 switch( irn ) {
590 case 0:
591 resultant->SetDefinition( anAntiLambda );
592 // targetParticle->SetDefinition( aNeutron );
593 break;
594 case 1:
595 resultant->SetDefinition( anAntiSigmaZero );
596 // targetParticle->SetDefinition( aNeutron );
597 break;
598 case 2:
599 resultant->SetDefinition( aNeutron );
600 // targetParticle->SetDefinition( anAntiLambda );
601 break;
602 case 3:
603 resultant->SetDefinition( aNeutron );
604 // targetParticle->SetDefinition( anAntiSigmaZero );
605 break;
606 default:
607 resultant->SetDefinition( aProton );
608 // targetParticle->SetDefinition( anAntiLambda );
609 break;
610 }
611 }
612 delete targetParticle;
613 return resultant;
614 }
615 delete targetParticle;
616 return (G4DynamicParticle*)NULL;
617 }

Referenced by G4LElastic::ApplyYourself().

◆ AntiXiMinusExchange()

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

Definition at line 938 of file G4LightMedia.cc.

941 {
942 // NOTE: The FORTRAN version of the cascade, CASAXM, simply called the
943 // routine for the XiMinus particle. Hence, the Exchange function
944 // below is just a copy of the Exchange from the XiMinus particle
945
946 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
947 G4ParticleDefinition* aProton = G4Proton::Proton();
948 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
949 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
950 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
951 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
952
953 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
954
955 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
956
957 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
958 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
959 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
960 G4DynamicParticle* resultant = new G4DynamicParticle;
961 if( targetParticle->GetDefinition() == aNeutron ) {
962 G4int irn = G4int( G4UniformRand()*5.0 );
963 switch( irn ) {
964 case 0:
965 resultant->SetDefinition( aNeutron );
966 // targetParticle->SetDefinition( aXiMinus );
967 break;
968 case 1:
969 resultant->SetDefinition( aSigmaZero );
970 // targetParticle->SetDefinition( aSigmaMinus );
971 break;
972 case 2:
973 resultant->SetDefinition( aSigmaMinus );
974 // targetParticle->SetDefinition( aSigmaZero );
975 break;
976 case 3:
977 resultant->SetDefinition( aLambda );
978 // targetParticle->SetDefinition( aSigmaMinus );
979 break;
980 default:
981 resultant->SetDefinition( aSigmaMinus );
982 // targetParticle->SetDefinition( aLambda );
983 break;
984 }
985 } else { // target particle is a proton
986 G4int irn = G4int( G4UniformRand()*7.0 );
987 switch( irn ) {
988 case 0:
989 resultant->SetDefinition( aXiZero );
990 // targetParticle->SetDefinition( aNeutron );
991 break;
992 case 1:
993 resultant->SetDefinition( aNeutron );
994 // targetParticle->SetDefinition( aXiZero );
995 break;
996 case 2:
997 resultant->SetDefinition( aSigmaZero );
998 // targetParticle->SetDefinition( aSigmaZero );
999 break;
1000 case 3:
1001 resultant->SetDefinition( aLambda );
1002 // targetParticle->SetDefinition( aLambda );
1003 break;
1004 case 4:
1005 resultant->SetDefinition( aSigmaZero );
1006 // targetParticle->SetDefinition( aLambda );
1007 break;
1008 case 5:
1009 resultant->SetDefinition( aLambda );
1010 // targetParticle->SetDefinition( aSigmaZero );
1011 break;
1012 default:
1013 resultant->SetDefinition( aProton );
1014 // targetParticle->SetDefinition( aXiMinus );
1015 break;
1016 }
1017 }
1018 delete targetParticle;
1019 return resultant;
1020 }
1021 delete targetParticle;
1022 return (G4DynamicParticle*)NULL;
1023 }

Referenced by G4LElastic::ApplyYourself().

◆ AntiXiZeroExchange()

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

Definition at line 849 of file G4LightMedia.cc.

852 {
853 // NOTE: The FORTRAN version of the cascade, CASAXO, simply called the
854 // routine for the XiZero particle. Hence, the Exchange function
855 // below is just a copy of the Exchange from the XiZero particle
856
857 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
858 G4ParticleDefinition* aProton = G4Proton::Proton();
859 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
860 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
861 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
862 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
863 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
864
865 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
866
867 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
868
869 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
870 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
871 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
872 G4DynamicParticle* resultant = new G4DynamicParticle;
873 if( targetParticle->GetDefinition() == aNeutron ) {
874 G4int irn = G4int( G4UniformRand()*7.0 );
875 switch( irn ) {
876 case 0:
877 resultant->SetDefinition( aSigmaZero );
878 // targetParticle->SetDefinition( aSigmaZero );
879 break;
880 case 1:
881 resultant->SetDefinition( aLambda );
882 // targetParticle->SetDefinition( aLambda );
883 break;
884 case 2:
885 resultant->SetDefinition( aXiMinus );
886 // targetParticle->SetDefinition( aProton );
887 break;
888 case 3:
889 resultant->SetDefinition( aProton );
890 // targetParticle->SetDefinition( aXiMinus );
891 break;
892 case 4:
893 resultant->SetDefinition( aSigmaPlus );
894 // targetParticle->SetDefinition( aSigmaMinus );
895 break;
896 case 5:
897 resultant->SetDefinition( aSigmaMinus );
898 // targetParticle->SetDefinition( aSigmaPlus );
899 break;
900 default:
901 resultant->SetDefinition( aNeutron );
902 // targetParticle->SetDefinition( aXiZero );
903 break;
904 }
905 } else { // target particle is a proton
906 G4int irn = G4int( G4UniformRand()*5.0 );
907 switch( irn ) {
908 case 0:
909 resultant->SetDefinition( aSigmaPlus );
910 // targetParticle->SetDefinition( aSigmaZero );
911 break;
912 case 1:
913 resultant->SetDefinition( aSigmaZero );
914 // targetParticle->SetDefinition( aSigmaPlus );
915 break;
916 case 2:
917 resultant->SetDefinition( aSigmaPlus );
918 // targetParticle->SetDefinition( aLambda );
919 break;
920 case 3:
921 resultant->SetDefinition( aLambda );
922 // targetParticle->SetDefinition( aSigmaPlus );
923 break;
924 default:
925 resultant->SetDefinition( aProton );
926 // targetParticle->SetDefinition( aXiZero );
927 break;
928 }
929 }
930 delete targetParticle;
931 return resultant;
932 }
933 delete targetParticle;
934 return (G4DynamicParticle*)NULL;
935 }

Referenced by G4LElastic::ApplyYourself().

◆ KaonMinusExchange()

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

Definition at line 165 of file G4LightMedia.cc.

168 {
169 return (G4DynamicParticle*)NULL;
170 }

Referenced by G4LElastic::ApplyYourself().

◆ KaonPlusExchange()

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

Definition at line 78 of file G4LightMedia.cc.

81 {
82 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
83 G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
84 G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
85
86 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
87
88 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
89
90 if( targetParticle->GetDefinition() == aNeutron ) {
91
92 // for k+ n reactions, change some of the elastic cross section to k0 p
93
94 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
95 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
96 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
97 G4DynamicParticle* resultant = new G4DynamicParticle;
98 if( G4UniformRand() < 0.5 )
99 resultant->SetDefinition( aKaonZS );
100 else
101 resultant->SetDefinition( aKaonZL );
102 // targetParticle->SetDefinition( aProton );
103 delete targetParticle;
104 return resultant;
105 }
106 }
107 delete targetParticle;
108 return (G4DynamicParticle*)NULL;
109 }
G4KaonZeroLong::KaonZeroLong
static G4KaonZeroLong * KaonZeroLong()
Definition: G4KaonZeroLong.cc:115
G4KaonZeroShort::KaonZeroShort
static G4KaonZeroShort * KaonZeroShort()
Definition: G4KaonZeroShort.cc:104

Referenced by G4LElastic::ApplyYourself().

◆ KaonZeroLongExchange()

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

Definition at line 150 of file G4LightMedia.cc.

153 {
154 G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
155
156 if( G4UniformRand() >= 0.5 ) {
157 G4DynamicParticle* resultant = new G4DynamicParticle;
158 resultant->SetDefinition( aKaonZS );
159 return resultant;
160 }
161 return (G4DynamicParticle*)NULL;
162 }

Referenced by G4LElastic::ApplyYourself().

◆ KaonZeroShortExchange()

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

Definition at line 112 of file G4LightMedia.cc.

115 {
116 G4ParticleDefinition* aProton = G4Proton::Proton();
117 G4ParticleDefinition* aKaonPlus = G4KaonPlus::KaonPlus();
118 G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
119
120 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
121
122 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
123
124 if( targetParticle->GetDefinition() == aProton ) {
125
126 // for k0 p reactions, change some of the elastic cross section to k+ n
127
128 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
129 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
130 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
131 G4DynamicParticle* resultant = new G4DynamicParticle;
132 resultant->SetDefinition( aKaonPlus );
133 // targetParticle->SetDefinition( aNeutron );
134 delete targetParticle;
135 return resultant;
136 }
137 } else {
138 if( G4UniformRand() >= 0.5 ) {
139 G4DynamicParticle* resultant = new G4DynamicParticle;
140 resultant->SetDefinition( aKaonZL );
141 delete targetParticle;
142 return resultant;
143 }
144 }
145 delete targetParticle;
146 return (G4DynamicParticle*)NULL;
147 }
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:113

Referenced by G4LElastic::ApplyYourself().

◆ LambdaExchange()

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

Definition at line 279 of file G4LightMedia.cc.

282 {
283 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
284 G4ParticleDefinition* aProton = G4Proton::Proton();
285 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
286 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
287 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
288
289 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
290
291 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
292
293 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
294 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
295 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
296 G4DynamicParticle* resultant = new G4DynamicParticle;
297 G4int irn = G4int( G4UniformRand()/0.2 );
298 if( targetParticle->GetDefinition() == aNeutron ) {
299
300 // LN --> S0 N, LN --> S- P, LN --> N L, LN --> N S0, LN --> P S-
301
302 switch( irn ) {
303 case 0:
304 resultant->SetDefinition( aSigmaZero );
305 break;
306 case 1:
307 resultant->SetDefinition( aSigmaMinus );
308 // targetParticle->SetDefinition( aProton );
309 break;
310 case 2:
311 resultant->SetDefinition( aNeutron );
312 // targetParticle->SetDefinition( aLambda );
313 break;
314 case 3:
315 resultant->SetDefinition( aNeutron );
316 // targetParticle->SetDefinition( aSigmaZero );
317 break;
318 default:
319 resultant->SetDefinition( aProton );
320 // targetParticle->SetDefinition( aSigmaMinus );
321 break;
322 }
323 } else { // target particle is a proton
324
325 // LP --> S+ N, LP --> S0 P, LP --> P L, LP --> P S0, LP --> N S+
326
327 switch( irn ) {
328 case 0:
329 resultant->SetDefinition( aSigmaPlus );
330 // targetParticle->SetDefinition( aNeutron );
331 break;
332 case 1:
333 resultant->SetDefinition( aSigmaZero );
334 break;
335 case 2:
336 resultant->SetDefinition( aProton );
337 // targetParticle->SetDefinition( aLambda );
338 break;
339 case 3:
340 resultant->SetDefinition( aProton );
341 // targetParticle->SetDefinition( aSigmaZero );
342 break;
343 default:
344 resultant->SetDefinition( aNeutron );
345 // targetParticle->SetDefinition( aSigmaPlus );
346 break;
347 }
348 }
349 delete targetParticle;
350 return resultant;
351 }
352 delete targetParticle;
353 return (G4DynamicParticle*)NULL;
354 }

Referenced by G4LElastic::ApplyYourself().

◆ NeutronExchange()

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

Definition at line 226 of file G4LightMedia.cc.

229 {
230 G4ParticleDefinition* aProton = G4Proton::Proton();
231
232 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
233
234 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
235
236 if( targetParticle->GetDefinition() == aProton ) {
237 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
238 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
239 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
240 G4DynamicParticle* resultant = new G4DynamicParticle;
241 resultant->SetDefinition( aProton );
242 // targetParticle->SetDefinition( aNeutron );
243 delete targetParticle;
244 return resultant;
245 }
246 }
247 delete targetParticle;
248 return (G4DynamicParticle*)NULL;
249 }

Referenced by G4LElastic::ApplyYourself().

◆ OmegaMinusExchange()

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

Definition at line 1026 of file G4LightMedia.cc.

1029 {
1030 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
1031 G4ParticleDefinition* aProton = G4Proton::Proton();
1032 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
1033 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
1034 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
1035 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
1036 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
1037 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
1038
1039 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
1040
1041 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
1042
1043 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
1044 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
1045 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
1046 G4DynamicParticle* resultant = new G4DynamicParticle;
1047
1048 // introduce charge and strangeness exchange reactions
1049
1050 if( targetParticle->GetDefinition() == aNeutron ) {
1051 G4int irn = G4int( G4UniformRand()*7.0 );
1052 switch( irn ) {
1053 case 0:
1054 resultant->SetDefinition( aXiZero );
1055 // targetParticle->SetDefinition( aSigmaMinus );
1056 break;
1057 case 1:
1058 resultant->SetDefinition( aSigmaMinus );
1059 // targetParticle->SetDefinition( aXiZero );
1060 break;
1061 case 2:
1062 resultant->SetDefinition( aXiMinus );
1063 // targetParticle->SetDefinition( aLambda );
1064 break;
1065 case 3:
1066 resultant->SetDefinition( aLambda );
1067 // targetParticle->SetDefinition( aXiMinus );
1068 break;
1069 case 4:
1070 resultant->SetDefinition( aXiMinus );
1071 // targetParticle->SetDefinition( aSigmaZero );
1072 break;
1073 case 5:
1074 resultant->SetDefinition( aSigmaZero );
1075 // targetParticle->SetDefinition( aXiMinus );
1076 break;
1077 default:
1078 resultant->SetDefinition( aNeutron );
1079 // targetParticle->SetDefinition( anOmegaMinus );
1080 break;
1081 }
1082 } else { // target particle is a proton
1083 G4int irn = G4int( G4UniformRand()*7.0 );
1084 switch( irn ) {
1085 case 0:
1086 resultant->SetDefinition( aXiZero );
1087 // targetParticle->SetDefinition( aSigmaZero );
1088 break;
1089 case 1:
1090 resultant->SetDefinition( aSigmaZero );
1091 // targetParticle->SetDefinition( aXiZero );
1092 break;
1093 case 2:
1094 resultant->SetDefinition( aXiZero );
1095 // targetParticle->SetDefinition( aLambda );
1096 break;
1097 case 3:
1098 resultant->SetDefinition( aLambda );
1099 // targetParticle->SetDefinition( aXiZero );
1100 break;
1101 case 4:
1102 resultant->SetDefinition( aXiMinus );
1103 // targetParticle->SetDefinition( aSigmaPlus );
1104 break;
1105 case 5:
1106 resultant->SetDefinition( aSigmaPlus );
1107 // targetParticle->SetDefinition( aXiMinus );
1108 break;
1109 default:
1110 resultant->SetDefinition( aProton );
1111 // targetParticle->SetDefinition( anOmegaMinus );
1112 break;
1113 }
1114 }
1115 delete targetParticle;
1116 return resultant;
1117 }
1118 delete targetParticle;
1119 return (G4DynamicParticle*)NULL;
1120 }

Referenced by G4LElastic::ApplyYourself().

◆ 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 70 of file G4LightMedia.cc.

73 {
74 return (G4DynamicParticle*)NULL;
75 }

Referenced by G4LElastic::ApplyYourself().

◆ PionPlusExchange()

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

Definition at line 40 of file G4LightMedia.cc.

43 {
44 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
45 G4ParticleDefinition* aPiZero = G4PionZero::PionZero();
46
47 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
48
49 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
50
51 if( targetParticle->GetDefinition() == aNeutron ) {
52
53 // for pi+ n reactions, change some of the elastic cross section to pi0 p
54
55 const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
56 G4int iplab = G4int(std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ));
57 if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
58 G4DynamicParticle* resultant = new G4DynamicParticle;
59 resultant->SetDefinition( aPiZero );
60 // targetParticle->SetDefinition( aProton );
61 delete targetParticle;
62 return resultant;
63 }
64 }
65 delete targetParticle;
66 return (G4DynamicParticle*)NULL;
67 }
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:104

Referenced by G4LElastic::ApplyYourself().

◆ ProtonExchange()

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

Definition at line 173 of file G4LightMedia.cc.

176 {
177 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
178
179 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
180
181 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
182
183 if( targetParticle->GetDefinition() == aNeutron ) {
184 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
185 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
186 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
187 G4DynamicParticle* resultant = new G4DynamicParticle;
188 resultant->SetDefinition( aNeutron );
189 // targetParticle->SetDefinition( aProton );
190 delete targetParticle;
191 return resultant;
192 }
193 }
194 delete targetParticle;
195 return (G4DynamicParticle*)NULL;
196 }

Referenced by G4LElastic::ApplyYourself().

◆ SigmaMinusExchange()

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

Definition at line 499 of file G4LightMedia.cc.

502 {
503 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
504 G4ParticleDefinition* aProton = G4Proton::Proton();
505 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
506 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
507
508 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
509
510 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
511
512 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
513 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
514 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
515 G4DynamicParticle* resultant = new G4DynamicParticle;
516
517 // introduce charge and strangeness exchange reactions
518
519 G4int irn = G4int( G4UniformRand()/0.2 );
520 if( targetParticle->GetDefinition() == aNeutron ) {
521
522 // S- N --> N S-
523
524 resultant->SetDefinition( aNeutron );
525 // targetParticle->SetDefinition( aSigmaMinus );
526 } else { // target particle is a proton
527
528 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
529
530 switch( irn ) {
531 case 0:
532 resultant->SetDefinition( aSigmaZero );
533 // targetParticle->SetDefinition( aNeutron );
534 break;
535 case 1:
536 resultant->SetDefinition( aLambda );
537 // targetParticle->SetDefinition( aNeutron );
538 break;
539 case 2:
540 resultant->SetDefinition( aProton );
541 // targetParticle->SetDefinition( aSigmaMinus );
542 break;
543 case 3:
544 resultant->SetDefinition( aNeutron );
545 // targetParticle->SetDefinition( aSigmaZero );
546 break;
547 default:
548 resultant->SetDefinition( aNeutron );
549 // targetParticle->SetDefinition( aLambda );
550 break;
551 }
552 }
553 delete targetParticle;
554 return resultant;
555 }
556 delete targetParticle;
557 return (G4DynamicParticle*)NULL;
558 }

Referenced by G4LElastic::ApplyYourself().

◆ SigmaPlusExchange()

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

Definition at line 437 of file G4LightMedia.cc.

440 {
441 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
442 G4ParticleDefinition* aProton = G4Proton::Proton();
443 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
444 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
445
446 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
447
448 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
449
450 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
451 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
452 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
453 G4DynamicParticle* resultant = new G4DynamicParticle;
454
455 // introduce charge and strangeness exchange reactions
456
457 G4int irn = G4int( G4UniformRand()/0.2 );
458 if( targetParticle->GetDefinition() == aNeutron ) {
459
460 // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
461
462 switch( irn ) {
463 case 0:
464 resultant->SetDefinition( aSigmaZero );
465 // targetParticle->SetDefinition( aProton );
466 break;
467 case 1:
468 resultant->SetDefinition( aLambda );
469 // targetParticle->SetDefinition( aProton );
470 break;
471 case 2:
472 resultant->SetDefinition( aNeutron );
473 // targetParticle->SetDefinition( aSigmaPlus );
474 break;
475 case 3:
476 resultant->SetDefinition( aProton );
477 // targetParticle->SetDefinition( aSigmaZero );
478 break;
479 default:
480 resultant->SetDefinition( aProton );
481 // targetParticle->SetDefinition( aLambda );
482 break;
483 }
484 } else { // target particle is a proton
485
486 // S+ P --> P S+
487
488 resultant->SetDefinition( aProton );
489 // targetParticle->SetDefinition( aSigmaPlus );
490 }
491 delete targetParticle;
492 return resultant;
493 }
494 delete targetParticle;
495 return (G4DynamicParticle*)NULL;
496 }

Referenced by G4LElastic::ApplyYourself().

◆ XiMinusExchange()

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

Definition at line 765 of file G4LightMedia.cc.

768 {
769 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
770 G4ParticleDefinition* aProton = G4Proton::Proton();
771 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
772 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
773 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
774 G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
775
776 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
777
778 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
779
780 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
781 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
782 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
783 G4DynamicParticle* resultant = new G4DynamicParticle;
784 if( targetParticle->GetDefinition() == aNeutron ) {
785 G4int irn = G4int( G4UniformRand()*5.0 );
786 switch( irn ) {
787 case 0:
788 resultant->SetDefinition( aNeutron );
789 // targetParticle->SetDefinition( aXiMinus );
790 break;
791 case 1:
792 resultant->SetDefinition( aSigmaZero );
793 // targetParticle->SetDefinition( aSigmaMinus );
794 break;
795 case 2:
796 resultant->SetDefinition( aSigmaMinus );
797 // targetParticle->SetDefinition( aSigmaZero );
798 break;
799 case 3:
800 resultant->SetDefinition( aLambda );
801 // targetParticle->SetDefinition( aSigmaMinus );
802 break;
803 default:
804 resultant->SetDefinition( aSigmaMinus );
805 // targetParticle->SetDefinition( aLambda );
806 break;
807 }
808 } else { // target particle is a proton
809 G4int irn = G4int( G4UniformRand()*7.0 );
810 switch( irn ) {
811 case 0:
812 resultant->SetDefinition( aXiZero );
813 // targetParticle->SetDefinition( aNeutron );
814 break;
815 case 1:
816 resultant->SetDefinition( aNeutron );
817 // targetParticle->SetDefinition( aXiZero );
818 break;
819 case 2:
820 resultant->SetDefinition( aSigmaZero );
821 // targetParticle->SetDefinition( aSigmaZero );
822 break;
823 case 3:
824 resultant->SetDefinition( aLambda );
825 // targetParticle->SetDefinition( aLambda );
826 break;
827 case 4:
828 resultant->SetDefinition( aSigmaZero );
829 // targetParticle->SetDefinition( aLambda );
830 break;
831 case 5:
832 resultant->SetDefinition( aLambda );
833 // targetParticle->SetDefinition( aSigmaZero );
834 break;
835 default:
836 resultant->SetDefinition( aProton );
837 // targetParticle->SetDefinition( aXiMinus );
838 break;
839 }
840 }
841 delete targetParticle;
842 return resultant;
843 }
844 delete targetParticle;
845 return (G4DynamicParticle*)NULL;
846 }

Referenced by G4LElastic::ApplyYourself().

◆ XiZeroExchange()

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

Definition at line 680 of file G4LightMedia.cc.

683 {
684 G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
685 G4ParticleDefinition* aProton = G4Proton::Proton();
686 G4ParticleDefinition* aLambda = G4Lambda::Lambda();
687 G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
688 G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
689 G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
690 G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
691
692 const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
693
694 G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
695
696 const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
697 G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
698 if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
699 G4DynamicParticle* resultant = new G4DynamicParticle;
700 if( targetParticle->GetDefinition() == aNeutron ) {
701 G4int irn = G4int( G4UniformRand()*7.0 );
702 switch( irn ) {
703 case 0:
704 resultant->SetDefinition( aSigmaZero );
705 // targetParticle->SetDefinition( aSigmaZero );
706 break;
707 case 1:
708 resultant->SetDefinition( aLambda );
709 // targetParticle->SetDefinition( aLambda );
710 break;
711 case 2:
712 resultant->SetDefinition( aXiMinus );
713 // targetParticle->SetDefinition( aProton );
714 break;
715 case 3:
716 resultant->SetDefinition( aProton );
717 // targetParticle->SetDefinition( aXiMinus );
718 break;
719 case 4:
720 resultant->SetDefinition( aSigmaPlus );
721 // targetParticle->SetDefinition( aSigmaMinus );
722 break;
723 case 5:
724 resultant->SetDefinition( aSigmaMinus );
725 // targetParticle->SetDefinition( aSigmaPlus );
726 break;
727 default:
728 resultant->SetDefinition( aNeutron );
729 // targetParticle->SetDefinition( aXiZero );
730 break;
731 }
732 } else { // target particle is a proton
733 G4int irn = G4int( G4UniformRand()*5.0 );
734 switch( irn ) {
735 case 0:
736 resultant->SetDefinition( aSigmaPlus );
737 // targetParticle->SetDefinition( aSigmaZero );
738 break;
739 case 1:
740 resultant->SetDefinition( aSigmaZero );
741 // targetParticle->SetDefinition( aSigmaPlus );
742 break;
743 case 2:
744 resultant->SetDefinition( aSigmaPlus );
745 // targetParticle->SetDefinition( aLambda );
746 break;
747 case 3:
748 resultant->SetDefinition( aLambda );
749 // targetParticle->SetDefinition( aSigmaPlus );
750 break;
751 default:
752 resultant->SetDefinition( aProton );
753 // targetParticle->SetDefinition( aXiZero );
754 break;
755 }
756 }
757 delete targetParticle;
758 return resultant;
759 }
760 delete targetParticle;
761 return (G4DynamicParticle*)NULL;
762 }

Referenced by G4LElastic::ApplyYourself().

The documentation for this class was generated from the following files: