Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions
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::G4LightMedia ( )
inline

Definition at line 44 of file G4LightMedia.hh.

44 { }
G4LightMedia::G4LightMedia ( const G4LightMedia &  right)
inline

Definition at line 46 of file G4LightMedia.hh.

References right.

47  { *this = right; }
right
Definition: F04UserTrackInformation.hh:37
G4LightMedia::~G4LightMedia ( )
inline

Definition at line 49 of file G4LightMedia.hh.

49 { }

Member Function Documentation

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

Definition at line 357 of file G4LightMedia.cc.

References G4AntiSigmaMinus::AntiSigmaMinus(), G4AntiSigmaPlus::AntiSigmaPlus(), G4AntiSigmaZero::AntiSigmaZero(), G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4AntiSigmaPlus::AntiSigmaPlus
static G4AntiSigmaPlus * AntiSigmaPlus()
Definition: G4AntiSigmaPlus.cc:108
G4int
int G4int
Definition: G4Types.hh:78
G4AntiSigmaMinus::AntiSigmaMinus
static G4AntiSigmaMinus * AntiSigmaMinus()
Definition: G4AntiSigmaMinus.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:99
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiNeutronExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 252 of file G4LightMedia.cc.

References G4AntiProton::AntiProton(), G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiOmegaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 1123 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), G4SigmaZero::SigmaZero(), G4XiMinus::XiMinus(), and G4XiZero::XiZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiProtonExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 199 of file G4LightMedia.cc.

References G4AntiNeutron::AntiNeutron(), G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:103
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiSigmaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 620 of file G4LightMedia.cc.

References G4AntiLambda::AntiLambda(), G4AntiSigmaZero::AntiSigmaZero(), G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition: G4AntiLambda.cc:108
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:99
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiSigmaPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 561 of file G4LightMedia.cc.

References G4AntiLambda::AntiLambda(), G4AntiSigmaZero::AntiSigmaZero(), G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition: G4AntiLambda.cc:108
G4AntiSigmaZero::AntiSigmaZero
static G4AntiSigmaZero * AntiSigmaZero()
Definition: G4AntiSigmaZero.cc:99
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiXiMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 938 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaZero::SigmaZero(), and G4XiZero::XiZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::AntiXiZeroExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 849 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), G4SigmaZero::SigmaZero(), and G4XiMinus::XiMinus().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::KaonMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 165 of file G4LightMedia.cc.

168  {
169  return (G4DynamicParticle*)NULL;
170  }
G4DynamicParticle * G4LightMedia::KaonPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 78 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4KaonZeroShort::KaonZeroShort
static G4KaonZeroShort * KaonZeroShort()
Definition: G4KaonZeroShort.cc:104
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::KaonZeroLongExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 150 of file G4LightMedia.cc.

References G4UniformRand, G4KaonZeroShort::KaonZeroShort(), and G4DynamicParticle::SetDefinition().

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  }
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4KaonZeroShort::KaonZeroShort
static G4KaonZeroShort * KaonZeroShort()
Definition: G4KaonZeroShort.cc:104
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4DynamicParticle * G4LightMedia::KaonZeroShortExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 112 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4KaonPlus::KaonPlus(), G4KaonZeroLong::KaonZeroLong(), G4INCL::Math::min(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4KaonZeroLong::KaonZeroLong
static G4KaonZeroLong * KaonZeroLong()
Definition: G4KaonZeroLong.cc:115
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:113
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::LambdaExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 279 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), and G4SigmaZero::SigmaZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::NeutronExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 226 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::OmegaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 1026 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), G4SigmaZero::SigmaZero(), G4XiMinus::XiMinus(), and G4XiZero::XiZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4bool G4LightMedia::operator!= ( const G4LightMedia &  right) const
inline

Definition at line 57 of file G4LightMedia.hh.

58  { return ( this != (G4LightMedia *) &right ); }
G4LightMedia& G4LightMedia::operator= ( const G4LightMedia &  )
inline

Definition at line 51 of file G4LightMedia.hh.

52  { return *this; }
G4bool G4LightMedia::operator== ( const G4LightMedia &  right) const
inline

Definition at line 54 of file G4LightMedia.hh.

55  { return ( this == (G4LightMedia *) &right ); }
G4DynamicParticle * G4LightMedia::PionMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 70 of file G4LightMedia.cc.

73  {
74  return (G4DynamicParticle*)NULL;
75  }
G4DynamicParticle * G4LightMedia::PionPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 40 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4PionZero::PionZero(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::ProtonExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 173 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4INCL::Math::min(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::SigmaMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 499 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), and G4SigmaZero::SigmaZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::SigmaPlusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 437 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), and G4SigmaZero::SigmaZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::XiMinusExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 765 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaZero::SigmaZero(), and G4XiZero::XiZero().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
G4DynamicParticle * G4LightMedia::XiZeroExchange ( const G4HadProjectile *  incidentParticle,
const G4Nucleus &  aNucleus 
)

Definition at line 680 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), python.hepunit::GeV, G4Lambda::Lambda(), G4INCL::Math::min(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), G4SigmaZero::SigmaZero(), and G4XiMinus::XiMinus().

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  }
G4int
int G4int
Definition: G4Types.hh:78
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4double
double G4double
Definition: G4Types.hh:76
G4DynamicParticle::SetDefinition
void SetDefinition(const G4ParticleDefinition *aParticleDefinition)
Definition: G4DynamicParticle.cc:273
G4HadProjectile::GetTotalMomentum
G4double GetTotalMomentum() const
Definition: G4HadProjectile.hh:101
The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:38 for Geant4.10 by   doxygen 1.8.7