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.

00044 { }

G4LightMedia::G4LightMedia ( const G4LightMedia &  right  )  [inline]

Definition at line 46 of file G4LightMedia.hh.

00047     { *this = right; }

G4LightMedia::~G4LightMedia (  )  [inline]

Definition at line 49 of file G4LightMedia.hh.

00049 { }

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(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00360   {
00361     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00362     G4ParticleDefinition* aProton = G4Proton::Proton();
00363     G4ParticleDefinition* anAntiSigmaPlus = G4AntiSigmaPlus::AntiSigmaPlus();
00364     G4ParticleDefinition* anAntiSigmaMinus = G4AntiSigmaMinus::AntiSigmaMinus();
00365     G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
00366     
00367     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00368     
00369     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00370     
00371     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00372     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00373     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00374       G4DynamicParticle* resultant = new G4DynamicParticle;
00375       G4int irn = G4int( G4UniformRand()/0.2 );
00376       if( targetParticle->GetDefinition() == aNeutron ) {
00377         
00378         // LB N --> S+B P, LB N --> S0B N, LB N --> N LB,
00379         // LB N --> N S0B, LB N --> P S+B
00380         
00381         switch( irn ) {
00382          case 0:
00383            resultant->SetDefinition( anAntiSigmaPlus );
00384            // targetParticle->SetDefinition( aProton );
00385            break;
00386          case 1:
00387            resultant->SetDefinition( anAntiSigmaZero );
00388            break;
00389          case 2:
00390            resultant->SetDefinition( aNeutron );
00391            // targetParticle->SetDefinition( anAntiLambda );
00392            break;
00393          case 3:
00394            resultant->SetDefinition( aNeutron );
00395            // targetParticle->SetDefinition( anAntiSigmaZero );
00396            break;
00397          default:
00398            resultant->SetDefinition( aProton );
00399            // targetParticle->SetDefinition( anAntiSigmaPlus );
00400            break;
00401         }
00402       } else {  // target particle is a proton
00403         
00404         // LB P --> S0B P, LB P --> S-B N, LB P --> P LB,
00405         // LB P --> P S0B, LB P --> N S-B
00406         
00407         switch( irn ) {
00408          case 0:
00409            resultant->SetDefinition( anAntiSigmaZero );
00410            break;
00411          case 1:
00412            resultant->SetDefinition( anAntiSigmaMinus );
00413            // targetParticle->SetDefinition( aNeutron );
00414            break;
00415          case 2:
00416            resultant->SetDefinition( aProton );
00417            // targetParticle->SetDefinition( anAntiLambda );
00418            break;
00419          case 3:
00420            resultant->SetDefinition( aProton );
00421            // targetParticle->SetDefinition( anAntiSigmaZero );
00422            break;
00423          default:
00424            resultant->SetDefinition( aNeutron );
00425            // targetParticle->SetDefinition( anAntiSigmaMinus );
00426            break;
00427         }
00428       }
00429       delete targetParticle;
00430       return resultant;
00431     }
00432     delete targetParticle;
00433     return (G4DynamicParticle*)NULL;
00434   }

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(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00255   {
00256     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00257     G4ParticleDefinition* anAntiProton = G4AntiProton::AntiProton();
00258     
00259     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00260     
00261     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00262     
00263     if( targetParticle->GetDefinition() == aNeutron ) {
00264       const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00265       G4int iplab = std::min( 9, G4int( incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00266       if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
00267         G4DynamicParticle* resultant = new G4DynamicParticle;
00268         resultant->SetDefinition( anAntiProton );
00269         // targetParticle->SetDefinition( aProton );
00270         delete targetParticle;
00271         return resultant;
00272       }
00273     }
00274     delete targetParticle;
00275     return (G4DynamicParticle*)NULL;
00276   }

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

Definition at line 1123 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

01126   {
01127     // NOTE:  The FORTRAN version of the cascade, CASAOM, simply called the
01128     //        routine for the OmegaMinus particle.  Hence, the Exchange function
01129     //        below is just a copy of the Exchange from the OmegaMinus particle.
01130     
01131     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
01132     G4ParticleDefinition* aProton = G4Proton::Proton();
01133     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
01134     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
01135     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
01136     G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
01137     G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
01138     G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
01139     
01140     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
01141     
01142     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
01143     
01144     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
01145     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
01146     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
01147       G4DynamicParticle* resultant = new G4DynamicParticle;
01148       
01149       // introduce charge and strangeness exchange reactions
01150       
01151       if( targetParticle->GetDefinition() == aNeutron ) {
01152         G4int irn = G4int( G4UniformRand()*7.0 );
01153         switch( irn ) {
01154          case 0:
01155            resultant->SetDefinition( aXiZero );
01156            // targetParticle->SetDefinition( aSigmaMinus );
01157            break;
01158          case 1:
01159            resultant->SetDefinition( aSigmaMinus );
01160            // targetParticle->SetDefinition( aXiZero );
01161            break;
01162          case 2:
01163            resultant->SetDefinition( aXiMinus );
01164            // targetParticle->SetDefinition( aLambda );
01165            break;
01166          case 3:
01167            resultant->SetDefinition( aLambda );
01168            // targetParticle->SetDefinition( aXiMinus );
01169            break;
01170          case 4:
01171            resultant->SetDefinition( aXiMinus );
01172            // targetParticle->SetDefinition( aSigmaZero );
01173            break;
01174          case 5:
01175            resultant->SetDefinition( aSigmaZero );
01176            // targetParticle->SetDefinition( aXiMinus );
01177            break;
01178          default:
01179            resultant->SetDefinition( aNeutron );
01180            // targetParticle->SetDefinition( anOmegaMinus );
01181            break;
01182         }
01183       } else {  // target particle is a proton
01184         G4int irn = G4int( G4UniformRand()*7.0 );        
01185         switch( irn ) {
01186          case 0:
01187            resultant->SetDefinition( aXiZero );
01188            // targetParticle->SetDefinition( aSigmaZero );
01189            break;
01190          case 1:
01191            resultant->SetDefinition( aSigmaZero );
01192            // targetParticle->SetDefinition( aXiZero );
01193            break;
01194          case 2:
01195            resultant->SetDefinition( aXiZero );
01196            // targetParticle->SetDefinition( aLambda );
01197            break;
01198          case 3:
01199            resultant->SetDefinition( aLambda );
01200            // targetParticle->SetDefinition( aXiZero );
01201            break;
01202          case 4:
01203            resultant->SetDefinition( aXiMinus );
01204            // targetParticle->SetDefinition( aSigmaPlus );
01205            break;
01206          case 5:
01207            resultant->SetDefinition( aSigmaPlus );
01208            // targetParticle->SetDefinition( aXiMinus );
01209            break;
01210          default:
01211            resultant->SetDefinition( aProton );
01212            // targetParticle->SetDefinition( anOmegaMinus );
01213            break;
01214         }
01215       }
01216       delete targetParticle;
01217       return resultant;
01218     }
01219     delete targetParticle;
01220     return (G4DynamicParticle*)NULL;
01221   }

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(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00202   {
00203     G4ParticleDefinition* aProton = G4Proton::Proton();
00204     G4ParticleDefinition* anAntiNeutron = G4AntiNeutron::AntiNeutron();
00205     
00206     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00207     
00208     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00209     
00210     if( targetParticle->GetDefinition() == aProton ) {
00211       const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
00212       G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*10.0 ) );
00213       if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.75) ) {
00214         G4DynamicParticle* resultant = new G4DynamicParticle;
00215         resultant->SetDefinition( anAntiNeutron );
00216         // targetParticle->SetDefinition( aNeutron );
00217         delete targetParticle;
00218         return resultant;
00219       }
00220     }
00221     delete targetParticle;
00222     return (G4DynamicParticle*)NULL;
00223   }

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(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00623   {
00624     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00625     G4ParticleDefinition* aProton = G4Proton::Proton();
00626     G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
00627     G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
00628     
00629     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00630     
00631     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00632     
00633     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00634     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00635     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00636       G4DynamicParticle* resultant = new G4DynamicParticle;
00637       G4int irn = G4int( G4UniformRand()/0.2 );
00638       if( targetParticle->GetDefinition() == aNeutron ) {
00639         
00640         // S-B N --> LB P, S-B N --> S0B P, S-B N --> N S-B,
00641         // S-B N --> P LB, S-B N --> P S0B        
00642         
00643         switch( irn ) {
00644          case 0:
00645            resultant->SetDefinition( anAntiLambda );
00646            // targetParticle->SetDefinition( aProton );
00647            break;
00648          case 1:
00649            resultant->SetDefinition( anAntiSigmaZero );
00650            // targetParticle->SetDefinition( aProton );
00651            break;
00652          case 2:
00653            resultant->SetDefinition( aNeutron );
00654            // targetParticle->SetDefinition( anAntiSigmaMinus );
00655            break;
00656          case 3:
00657            resultant->SetDefinition( aProton );
00658            // targetParticle->SetDefinition( anAntiLambda );
00659            break;
00660          default:
00661            resultant->SetDefinition( aProton );
00662            // targetParticle->SetDefinition( anAntiSigmaZero );
00663            break;
00664         }
00665       } else {  // target particle is a proton
00666         
00667         // S-B P --> P S-B
00668         
00669         resultant->SetDefinition( aProton );
00670         // targetParticle->SetDefinition( anAntiSigmaMinus );
00671       }
00672       delete targetParticle;
00673       return resultant;
00674     }
00675     delete targetParticle;
00676     return (G4DynamicParticle*)NULL;
00677   }

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(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00564   {
00565     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00566     G4ParticleDefinition* aProton = G4Proton::Proton();
00567     G4ParticleDefinition* anAntiLambda = G4AntiLambda::AntiLambda();
00568     G4ParticleDefinition* anAntiSigmaZero = G4AntiSigmaZero::AntiSigmaZero();
00569     
00570     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00571     
00572     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00573     
00574     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00575     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00576     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00577       G4DynamicParticle* resultant = new G4DynamicParticle;
00578       G4int irn = G4int( G4UniformRand()/0.2 );
00579       if( targetParticle->GetDefinition() == aNeutron ) {
00580         
00581         // S+B N --> N S+B
00582         
00583         resultant->SetDefinition( aNeutron );
00584         // targetParticle->SetDefinition( anAntiSigmaPlus );
00585       } else {  // target particle is a proton
00586         
00587         // S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
00588         
00589         switch( irn ) {
00590          case 0:
00591            resultant->SetDefinition( anAntiLambda );
00592            // targetParticle->SetDefinition( aNeutron );
00593            break;
00594          case 1:
00595            resultant->SetDefinition( anAntiSigmaZero );
00596            // targetParticle->SetDefinition( aNeutron );
00597            break;
00598          case 2:
00599            resultant->SetDefinition( aNeutron );
00600            // targetParticle->SetDefinition( anAntiLambda );
00601            break;
00602          case 3:
00603            resultant->SetDefinition( aNeutron );
00604            // targetParticle->SetDefinition( anAntiSigmaZero );
00605            break;
00606          default:
00607            resultant->SetDefinition( aProton );
00608            // targetParticle->SetDefinition( anAntiLambda );
00609            break;
00610         }
00611       }
00612       delete targetParticle;
00613       return resultant;
00614     }
00615     delete targetParticle;
00616     return (G4DynamicParticle*)NULL;
00617   }

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

Definition at line 938 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00941   {
00942     // NOTE:  The FORTRAN version of the cascade, CASAXM, simply called the
00943     //        routine for the XiMinus particle.  Hence, the Exchange function
00944     //        below is just a copy of the Exchange from the XiMinus particle
00945  
00946     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00947     G4ParticleDefinition* aProton = G4Proton::Proton();
00948     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00949     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00950     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
00951     G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
00952     
00953     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00954     
00955     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00956     
00957     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00958     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00959     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00960       G4DynamicParticle* resultant = new G4DynamicParticle;
00961       if( targetParticle->GetDefinition() == aNeutron ) {
00962         G4int irn = G4int( G4UniformRand()*5.0 );
00963         switch( irn ) {
00964          case 0:
00965            resultant->SetDefinition( aNeutron );
00966            // targetParticle->SetDefinition( aXiMinus );
00967            break;
00968          case 1:
00969            resultant->SetDefinition( aSigmaZero );
00970            // targetParticle->SetDefinition( aSigmaMinus );
00971            break;
00972          case 2:
00973            resultant->SetDefinition( aSigmaMinus );
00974            // targetParticle->SetDefinition( aSigmaZero );
00975            break;
00976          case 3:
00977            resultant->SetDefinition( aLambda );
00978            // targetParticle->SetDefinition( aSigmaMinus );
00979            break;
00980          default:
00981            resultant->SetDefinition( aSigmaMinus );
00982            // targetParticle->SetDefinition( aLambda );
00983            break;
00984         }
00985       } else {  // target particle is a proton
00986         G4int irn = G4int( G4UniformRand()*7.0 );        
00987         switch( irn ) {
00988          case 0:
00989            resultant->SetDefinition( aXiZero );
00990            // targetParticle->SetDefinition( aNeutron );
00991            break;
00992          case 1:
00993            resultant->SetDefinition( aNeutron );
00994            // targetParticle->SetDefinition( aXiZero );
00995            break;
00996          case 2:
00997            resultant->SetDefinition( aSigmaZero );
00998            // targetParticle->SetDefinition( aSigmaZero );
00999            break;
01000          case 3:
01001            resultant->SetDefinition( aLambda );
01002            // targetParticle->SetDefinition( aLambda );
01003            break;
01004          case 4:
01005            resultant->SetDefinition( aSigmaZero );
01006            // targetParticle->SetDefinition( aLambda );
01007            break;
01008          case 5:
01009            resultant->SetDefinition( aLambda );
01010            // targetParticle->SetDefinition( aSigmaZero );
01011            break;
01012          default:
01013            resultant->SetDefinition( aProton );
01014            // targetParticle->SetDefinition( aXiMinus );
01015            break;
01016         }
01017       }
01018       delete targetParticle;
01019       return resultant;
01020     }
01021     delete targetParticle;
01022     return (G4DynamicParticle*)NULL;
01023   }

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

Definition at line 849 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00852   {
00853     // NOTE:  The FORTRAN version of the cascade, CASAXO, simply called the
00854     //        routine for the XiZero particle.  Hence, the Exchange function
00855     //        below is just a copy of the Exchange from the XiZero particle
00856  
00857     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00858     G4ParticleDefinition* aProton = G4Proton::Proton();
00859     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00860     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00861     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
00862     G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
00863     G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
00864     
00865     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00866     
00867     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00868     
00869     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00870     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00871     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00872       G4DynamicParticle* resultant = new G4DynamicParticle;
00873       if( targetParticle->GetDefinition() == aNeutron ) {
00874         G4int irn = G4int( G4UniformRand()*7.0 );
00875         switch( irn ) {
00876          case 0:
00877            resultant->SetDefinition( aSigmaZero );
00878            // targetParticle->SetDefinition( aSigmaZero );
00879            break;
00880          case 1:
00881            resultant->SetDefinition( aLambda );
00882            // targetParticle->SetDefinition( aLambda );
00883            break;
00884          case 2:
00885            resultant->SetDefinition( aXiMinus );
00886            // targetParticle->SetDefinition( aProton );
00887            break;
00888          case 3:
00889            resultant->SetDefinition( aProton );
00890            // targetParticle->SetDefinition( aXiMinus );
00891            break;
00892          case 4:
00893            resultant->SetDefinition( aSigmaPlus );
00894            // targetParticle->SetDefinition( aSigmaMinus );
00895            break;
00896          case 5:
00897            resultant->SetDefinition( aSigmaMinus );
00898            // targetParticle->SetDefinition( aSigmaPlus );
00899            break;
00900          default:
00901            resultant->SetDefinition( aNeutron );
00902            // targetParticle->SetDefinition( aXiZero );
00903            break;
00904         }
00905       } else {  // target particle is a proton
00906         G4int irn = G4int( G4UniformRand()*5.0 );
00907         switch( irn ) {
00908          case 0:
00909            resultant->SetDefinition( aSigmaPlus );
00910            // targetParticle->SetDefinition( aSigmaZero );
00911            break;
00912          case 1:
00913            resultant->SetDefinition( aSigmaZero );
00914            // targetParticle->SetDefinition( aSigmaPlus );
00915            break;
00916          case 2:
00917            resultant->SetDefinition( aSigmaPlus );
00918            // targetParticle->SetDefinition( aLambda );
00919            break;
00920          case 3:
00921            resultant->SetDefinition( aLambda );
00922            // targetParticle->SetDefinition( aSigmaPlus );
00923            break;
00924          default:
00925            resultant->SetDefinition( aProton );
00926            // targetParticle->SetDefinition( aXiZero );
00927            break;
00928         }
00929       }
00930       delete targetParticle;
00931       return resultant;
00932     }
00933     delete targetParticle;
00934     return (G4DynamicParticle*)NULL;
00935   }

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

Definition at line 165 of file G4LightMedia.cc.

Referenced by G4LElastic::ApplyYourself().

00168   {
00169     return (G4DynamicParticle*)NULL;
00170   }

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

Definition at line 78 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00081   {
00082     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00083     G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
00084     G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
00085     
00086     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00087     
00088     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00089     
00090     if( targetParticle->GetDefinition() == aNeutron ) {
00091 
00092       // for k+ n reactions, change some of the elastic cross section to k0 p
00093       
00094       const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
00095       G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
00096       if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00097         G4DynamicParticle* resultant = new G4DynamicParticle;
00098         if( G4UniformRand() < 0.5 )
00099           resultant->SetDefinition( aKaonZS );
00100         else
00101           resultant->SetDefinition( aKaonZL );
00102         // targetParticle->SetDefinition( aProton );
00103         delete targetParticle;
00104         return resultant;
00105       }
00106     }
00107     delete targetParticle;
00108     return (G4DynamicParticle*)NULL;
00109   }

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

Definition at line 150 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00153   {
00154     G4ParticleDefinition* aKaonZS = G4KaonZeroShort::KaonZeroShort();
00155     
00156     if( G4UniformRand() >= 0.5 ) {
00157       G4DynamicParticle* resultant = new G4DynamicParticle;
00158       resultant->SetDefinition( aKaonZS );
00159       return resultant;
00160     }
00161     return (G4DynamicParticle*)NULL;    
00162   }

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

Definition at line 112 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4KaonPlus::KaonPlus(), G4KaonZeroLong::KaonZeroLong(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00115   {
00116     G4ParticleDefinition* aProton = G4Proton::Proton();
00117     G4ParticleDefinition* aKaonPlus = G4KaonPlus::KaonPlus();
00118     G4ParticleDefinition* aKaonZL = G4KaonZeroLong::KaonZeroLong();
00119     
00120     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00121     
00122     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00123     
00124     if( targetParticle->GetDefinition() == aProton ) {
00125       
00126       // for k0 p reactions, change some of the elastic cross section to k+ n
00127       
00128       const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
00129       G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ) );
00130       if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
00131         G4DynamicParticle* resultant = new G4DynamicParticle;
00132         resultant->SetDefinition( aKaonPlus );
00133         // targetParticle->SetDefinition( aNeutron );
00134         delete targetParticle;
00135         return resultant;
00136       }
00137     } else {
00138       if( G4UniformRand() >= 0.5 ) {
00139         G4DynamicParticle* resultant = new G4DynamicParticle;
00140         resultant->SetDefinition( aKaonZL );
00141         delete targetParticle;
00142         return resultant;
00143       }
00144     }
00145     delete targetParticle;
00146     return (G4DynamicParticle*)NULL;
00147   }

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

Definition at line 279 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00282   {
00283     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00284     G4ParticleDefinition* aProton = G4Proton::Proton();
00285     G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
00286     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
00287     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00288     
00289     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00290     
00291     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00292     
00293     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00294     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00295     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00296       G4DynamicParticle* resultant = new G4DynamicParticle;
00297       G4int irn = G4int( G4UniformRand()/0.2 );
00298       if( targetParticle->GetDefinition() == aNeutron ) {
00299         
00300         // LN --> S0 N, LN --> S- P, LN --> N L, LN --> N S0, LN --> P S-
00301         
00302         switch( irn ) {
00303          case 0:
00304            resultant->SetDefinition( aSigmaZero );
00305            break;
00306          case 1:
00307            resultant->SetDefinition( aSigmaMinus );
00308            // targetParticle->SetDefinition( aProton );
00309            break;
00310          case 2:
00311            resultant->SetDefinition( aNeutron );
00312            // targetParticle->SetDefinition( aLambda );
00313            break;
00314          case 3:
00315            resultant->SetDefinition( aNeutron );
00316            // targetParticle->SetDefinition( aSigmaZero );
00317            break;
00318          default:
00319            resultant->SetDefinition( aProton );
00320            // targetParticle->SetDefinition( aSigmaMinus );
00321            break;
00322         }
00323       } else {  // target particle is a proton
00324         
00325         // LP --> S+ N, LP --> S0 P, LP --> P L, LP --> P S0, LP --> N S+
00326         
00327         switch( irn ) {
00328          case 0:
00329            resultant->SetDefinition( aSigmaPlus );
00330            // targetParticle->SetDefinition( aNeutron );
00331            break;
00332          case 1:
00333            resultant->SetDefinition( aSigmaZero );
00334            break;
00335          case 2:
00336            resultant->SetDefinition( aProton );
00337            // targetParticle->SetDefinition( aLambda );
00338            break;
00339          case 3:
00340            resultant->SetDefinition( aProton );
00341            // targetParticle->SetDefinition( aSigmaZero );
00342            break;
00343          default:
00344            resultant->SetDefinition( aNeutron );
00345            // targetParticle->SetDefinition( aSigmaPlus );
00346            break;
00347         }
00348       }
00349       delete targetParticle;
00350       return resultant;
00351     }
00352     delete targetParticle;
00353     return (G4DynamicParticle*)NULL;
00354   }

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

Definition at line 226 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00229   {
00230     G4ParticleDefinition* aProton = G4Proton::Proton();
00231     
00232     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00233     
00234     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00235     
00236     if( targetParticle->GetDefinition() == aProton ) {
00237       const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
00238       G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00239       if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
00240         G4DynamicParticle* resultant = new G4DynamicParticle;
00241         resultant->SetDefinition( aProton );
00242         // targetParticle->SetDefinition( aNeutron );
00243         delete targetParticle;
00244         return resultant;
00245       }
00246     }
00247     delete targetParticle;
00248     return (G4DynamicParticle*)NULL;
00249   }

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

Definition at line 1026 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

01029   {
01030     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
01031     G4ParticleDefinition* aProton = G4Proton::Proton();
01032     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
01033     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
01034     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
01035     G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
01036     G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
01037     G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
01038     
01039     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
01040     
01041     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
01042     
01043     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
01044     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
01045     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
01046       G4DynamicParticle* resultant = new G4DynamicParticle;
01047       
01048       // introduce charge and strangeness exchange reactions
01049       
01050       if( targetParticle->GetDefinition() == aNeutron ) {
01051         G4int irn = G4int( G4UniformRand()*7.0 );
01052         switch( irn ) {
01053          case 0:
01054            resultant->SetDefinition( aXiZero );
01055            // targetParticle->SetDefinition( aSigmaMinus );
01056            break;
01057          case 1:
01058            resultant->SetDefinition( aSigmaMinus );
01059            // targetParticle->SetDefinition( aXiZero );
01060            break;
01061          case 2:
01062            resultant->SetDefinition( aXiMinus );
01063            // targetParticle->SetDefinition( aLambda );
01064            break;
01065          case 3:
01066            resultant->SetDefinition( aLambda );
01067            // targetParticle->SetDefinition( aXiMinus );
01068            break;
01069          case 4:
01070            resultant->SetDefinition( aXiMinus );
01071            // targetParticle->SetDefinition( aSigmaZero );
01072            break;
01073          case 5:
01074            resultant->SetDefinition( aSigmaZero );
01075            // targetParticle->SetDefinition( aXiMinus );
01076            break;
01077          default:
01078            resultant->SetDefinition( aNeutron );
01079            // targetParticle->SetDefinition( anOmegaMinus );
01080            break;
01081         }
01082       } else {  // target particle is a proton
01083         G4int irn = G4int( G4UniformRand()*7.0 );        
01084         switch( irn ) {
01085          case 0:
01086            resultant->SetDefinition( aXiZero );
01087            // targetParticle->SetDefinition( aSigmaZero );
01088            break;
01089          case 1:
01090            resultant->SetDefinition( aSigmaZero );
01091            // targetParticle->SetDefinition( aXiZero );
01092            break;
01093          case 2:
01094            resultant->SetDefinition( aXiZero );
01095            // targetParticle->SetDefinition( aLambda );
01096            break;
01097          case 3:
01098            resultant->SetDefinition( aLambda );
01099            // targetParticle->SetDefinition( aXiZero );
01100            break;
01101          case 4:
01102            resultant->SetDefinition( aXiMinus );
01103            // targetParticle->SetDefinition( aSigmaPlus );
01104            break;
01105          case 5:
01106            resultant->SetDefinition( aSigmaPlus );
01107            // targetParticle->SetDefinition( aXiMinus );
01108            break;
01109          default:
01110            resultant->SetDefinition( aProton );
01111            // targetParticle->SetDefinition( anOmegaMinus );
01112            break;
01113         }
01114       }
01115       delete targetParticle;
01116       return resultant;
01117     }
01118     delete targetParticle;
01119     return (G4DynamicParticle*)NULL;
01120   }

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

Definition at line 57 of file G4LightMedia.hh.

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

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

Definition at line 51 of file G4LightMedia.hh.

00052     { return *this; }

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

Definition at line 54 of file G4LightMedia.hh.

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

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

Definition at line 70 of file G4LightMedia.cc.

Referenced by G4LElastic::ApplyYourself().

00073   {
00074     return (G4DynamicParticle*)NULL;
00075   }

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

Definition at line 40 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4Neutron::Neutron(), G4PionZero::PionZero(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00043   {
00044     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00045     G4ParticleDefinition* aPiZero = G4PionZero::PionZero();
00046     
00047     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00048     
00049     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00050     
00051     if( targetParticle->GetDefinition() == aNeutron ) {
00052       
00053       // for pi+ n reactions, change some of the elastic cross section to pi0 p
00054       
00055       const G4double cech[] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.10,0.09,0.07};
00056       G4int iplab = G4int(std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*5.0 ));
00057       if( G4UniformRand() < cech[iplab]/std::pow(atomicNumber,0.42) ) {
00058         G4DynamicParticle* resultant = new G4DynamicParticle;
00059         resultant->SetDefinition( aPiZero );
00060         // targetParticle->SetDefinition( aProton );
00061         delete targetParticle;
00062         return resultant;
00063       }
00064     }
00065     delete targetParticle;
00066     return (G4DynamicParticle*)NULL;
00067   }

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

Definition at line 173 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4Neutron::Neutron(), G4Nucleus::ReturnTargetParticle(), and G4DynamicParticle::SetDefinition().

Referenced by G4LElastic::ApplyYourself().

00176   {
00177     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00178     
00179     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00180     
00181     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00182     
00183     if( targetParticle->GetDefinition() == aNeutron ) {
00184       const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.};
00185       G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00186       if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00187         G4DynamicParticle* resultant = new G4DynamicParticle;
00188         resultant->SetDefinition( aNeutron );
00189         // targetParticle->SetDefinition( aProton );
00190         delete targetParticle;
00191         return resultant;
00192       }
00193     }
00194     delete targetParticle;
00195     return (G4DynamicParticle*)NULL;
00196   }

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

Definition at line 499 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4Lambda::Lambda(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), and G4SigmaZero::SigmaZero().

Referenced by G4LElastic::ApplyYourself().

00502   {
00503     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00504     G4ParticleDefinition* aProton = G4Proton::Proton();
00505     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00506     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00507     
00508     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00509     
00510     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00511     
00512     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00513     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00514     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00515       G4DynamicParticle* resultant = new G4DynamicParticle;
00516       
00517       // introduce charge and strangeness exchange reactions
00518       
00519       G4int irn = G4int( G4UniformRand()/0.2 );
00520       if( targetParticle->GetDefinition() == aNeutron ) {
00521         
00522         // S- N --> N S-
00523         
00524         resultant->SetDefinition( aNeutron );
00525         // targetParticle->SetDefinition( aSigmaMinus );
00526       } else {  // target particle is a proton
00527         
00528         //  S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
00529         
00530         switch( irn ) {
00531          case 0:
00532            resultant->SetDefinition( aSigmaZero );
00533            // targetParticle->SetDefinition( aNeutron );
00534            break;
00535          case 1:
00536            resultant->SetDefinition( aLambda );
00537            // targetParticle->SetDefinition( aNeutron );
00538            break;
00539          case 2:
00540            resultant->SetDefinition( aProton );
00541            // targetParticle->SetDefinition( aSigmaMinus );
00542            break;
00543          case 3:
00544            resultant->SetDefinition( aNeutron );
00545            // targetParticle->SetDefinition( aSigmaZero );
00546            break;
00547          default:
00548            resultant->SetDefinition( aNeutron );
00549            // targetParticle->SetDefinition( aLambda );
00550            break;
00551         }
00552       }
00553       delete targetParticle;
00554       return resultant;
00555     }
00556     delete targetParticle;
00557     return (G4DynamicParticle*)NULL;
00558   }

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

Definition at line 437 of file G4LightMedia.cc.

References G4UniformRand, G4HadProjectile::GetTotalMomentum(), G4Nucleus::GetZ_asInt(), G4Lambda::Lambda(), G4Neutron::Neutron(), G4Proton::Proton(), G4Nucleus::ReturnTargetParticle(), G4DynamicParticle::SetDefinition(), and G4SigmaZero::SigmaZero().

Referenced by G4LElastic::ApplyYourself().

00440   {
00441     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00442     G4ParticleDefinition* aProton = G4Proton::Proton();
00443     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00444     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00445     
00446     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00447     
00448     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00449     
00450     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00451     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00452     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00453       G4DynamicParticle* resultant = new G4DynamicParticle;
00454       
00455       // introduce charge and strangeness exchange reactions
00456       
00457       G4int irn = G4int( G4UniformRand()/0.2 );
00458       if( targetParticle->GetDefinition() == aNeutron ) {
00459         
00460         //  S+ N --> S0 P, S+ N --> L P, S+ N --> N S+, S+ N --> P S0, S+ N --> P L
00461         
00462         switch( irn ) {
00463          case 0:
00464            resultant->SetDefinition( aSigmaZero );
00465            // targetParticle->SetDefinition( aProton );
00466            break;
00467          case 1:
00468            resultant->SetDefinition( aLambda );
00469            // targetParticle->SetDefinition( aProton );
00470            break;
00471          case 2:
00472            resultant->SetDefinition( aNeutron );
00473            // targetParticle->SetDefinition( aSigmaPlus );
00474            break;
00475          case 3:
00476            resultant->SetDefinition( aProton );
00477            // targetParticle->SetDefinition( aSigmaZero );
00478            break;
00479          default:
00480            resultant->SetDefinition( aProton );
00481            // targetParticle->SetDefinition( aLambda );
00482            break;
00483         }
00484       } else {  // target particle is a proton
00485         
00486         // S+ P --> P S+
00487         
00488         resultant->SetDefinition( aProton );
00489         // targetParticle->SetDefinition( aSigmaPlus );
00490       }
00491       delete targetParticle;
00492       return resultant;
00493     }
00494     delete targetParticle;
00495     return (G4DynamicParticle*)NULL;
00496   }

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

Definition at line 765 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00768   {
00769     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00770     G4ParticleDefinition* aProton = G4Proton::Proton();
00771     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00772     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00773     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
00774     G4ParticleDefinition* aXiZero = G4XiZero::XiZero();
00775     
00776     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00777     
00778     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00779     
00780     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00781     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00782     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00783       G4DynamicParticle* resultant = new G4DynamicParticle;
00784       if( targetParticle->GetDefinition() == aNeutron ) {
00785         G4int irn = G4int( G4UniformRand()*5.0 );
00786         switch( irn ) {
00787          case 0:
00788            resultant->SetDefinition( aNeutron );
00789            // targetParticle->SetDefinition( aXiMinus );
00790            break;
00791          case 1:
00792            resultant->SetDefinition( aSigmaZero );
00793            // targetParticle->SetDefinition( aSigmaMinus );
00794            break;
00795          case 2:
00796            resultant->SetDefinition( aSigmaMinus );
00797            // targetParticle->SetDefinition( aSigmaZero );
00798            break;
00799          case 3:
00800            resultant->SetDefinition( aLambda );
00801            // targetParticle->SetDefinition( aSigmaMinus );
00802            break;
00803          default:
00804            resultant->SetDefinition( aSigmaMinus );
00805            // targetParticle->SetDefinition( aLambda );
00806            break;
00807         }
00808       } else {  // target particle is a proton
00809         G4int irn = G4int( G4UniformRand()*7.0 );        
00810         switch( irn ) {
00811          case 0:
00812            resultant->SetDefinition( aXiZero );
00813            // targetParticle->SetDefinition( aNeutron );
00814            break;
00815          case 1:
00816            resultant->SetDefinition( aNeutron );
00817            // targetParticle->SetDefinition( aXiZero );
00818            break;
00819          case 2:
00820            resultant->SetDefinition( aSigmaZero );
00821            // targetParticle->SetDefinition( aSigmaZero );
00822            break;
00823          case 3:
00824            resultant->SetDefinition( aLambda );
00825            // targetParticle->SetDefinition( aLambda );
00826            break;
00827          case 4:
00828            resultant->SetDefinition( aSigmaZero );
00829            // targetParticle->SetDefinition( aLambda );
00830            break;
00831          case 5:
00832            resultant->SetDefinition( aLambda );
00833            // targetParticle->SetDefinition( aSigmaZero );
00834            break;
00835          default:
00836            resultant->SetDefinition( aProton );
00837            // targetParticle->SetDefinition( aXiMinus );
00838            break;
00839         }
00840       }
00841       delete targetParticle;
00842       return resultant;
00843     }
00844     delete targetParticle;
00845     return (G4DynamicParticle*)NULL;
00846   }

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

Definition at line 680 of file G4LightMedia.cc.

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

Referenced by G4LElastic::ApplyYourself().

00683   {
00684     G4ParticleDefinition* aNeutron = G4Neutron::Neutron();
00685     G4ParticleDefinition* aProton = G4Proton::Proton();
00686     G4ParticleDefinition* aLambda = G4Lambda::Lambda();
00687     G4ParticleDefinition* aSigmaZero = G4SigmaZero::SigmaZero();
00688     G4ParticleDefinition* aSigmaMinus = G4SigmaMinus::SigmaMinus();
00689     G4ParticleDefinition* aSigmaPlus = G4SigmaPlus::SigmaPlus();
00690     G4ParticleDefinition* aXiMinus = G4XiMinus::XiMinus();
00691     
00692     const G4double atomicNumber = G4double(targetNucleus.GetZ_asInt());
00693     
00694     G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
00695     
00696     const G4double cech[] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
00697     G4int iplab = G4int( std::min( 9.0, incidentParticle->GetTotalMomentum()/GeV*2.5 ) );
00698     if( G4UniformRand() <= cech[iplab]/std::pow(atomicNumber,0.42) ) {
00699       G4DynamicParticle* resultant = new G4DynamicParticle;
00700       if( targetParticle->GetDefinition() == aNeutron ) {
00701         G4int irn = G4int( G4UniformRand()*7.0 );
00702         switch( irn ) {
00703          case 0:
00704            resultant->SetDefinition( aSigmaZero );
00705            // targetParticle->SetDefinition( aSigmaZero );
00706            break;
00707          case 1:
00708            resultant->SetDefinition( aLambda );
00709            // targetParticle->SetDefinition( aLambda );
00710            break;
00711          case 2:
00712            resultant->SetDefinition( aXiMinus );
00713            // targetParticle->SetDefinition( aProton );
00714            break;
00715          case 3:
00716            resultant->SetDefinition( aProton );
00717            // targetParticle->SetDefinition( aXiMinus );
00718            break;
00719          case 4:
00720            resultant->SetDefinition( aSigmaPlus );
00721            // targetParticle->SetDefinition( aSigmaMinus );
00722            break;
00723          case 5:
00724            resultant->SetDefinition( aSigmaMinus );
00725            // targetParticle->SetDefinition( aSigmaPlus );
00726            break;
00727          default:
00728            resultant->SetDefinition( aNeutron );
00729            // targetParticle->SetDefinition( aXiZero );
00730            break;
00731         }
00732       } else {  // target particle is a proton
00733         G4int irn = G4int( G4UniformRand()*5.0 );
00734         switch( irn ) {
00735          case 0:
00736            resultant->SetDefinition( aSigmaPlus );
00737            // targetParticle->SetDefinition( aSigmaZero );
00738            break;
00739          case 1:
00740            resultant->SetDefinition( aSigmaZero );
00741            // targetParticle->SetDefinition( aSigmaPlus );
00742            break;
00743          case 2:
00744            resultant->SetDefinition( aSigmaPlus );
00745            // targetParticle->SetDefinition( aLambda );
00746            break;
00747          case 3:
00748            resultant->SetDefinition( aLambda );
00749            // targetParticle->SetDefinition( aSigmaPlus );
00750            break;
00751          default:
00752            resultant->SetDefinition( aProton );
00753            // targetParticle->SetDefinition( aXiZero );
00754            break;
00755         }
00756       }
00757       delete targetParticle;
00758       return resultant;
00759     }
00760     delete targetParticle;
00761     return (G4DynamicParticle*)NULL;
00762   }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:25 2013 for Geant4 by  doxygen 1.4.7