00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include "G4LightMedia.hh"
00036 #include "G4SystemOfUnits.hh"
00037 #include "Randomize.hh"
00038
00039 G4DynamicParticle *
00040 G4LightMedia::PionPlusExchange(
00041 const G4HadProjectile *incidentParticle,
00042 const G4Nucleus & targetNucleus )
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
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
00061 delete targetParticle;
00062 return resultant;
00063 }
00064 }
00065 delete targetParticle;
00066 return (G4DynamicParticle*)NULL;
00067 }
00068
00069 G4DynamicParticle *
00070 G4LightMedia::PionMinusExchange(
00071 const G4HadProjectile *,
00072 const G4Nucleus& )
00073 {
00074 return (G4DynamicParticle*)NULL;
00075 }
00076
00077 G4DynamicParticle *
00078 G4LightMedia::KaonPlusExchange(
00079 const G4HadProjectile *incidentParticle,
00080 const G4Nucleus& targetNucleus )
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
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
00103 delete targetParticle;
00104 return resultant;
00105 }
00106 }
00107 delete targetParticle;
00108 return (G4DynamicParticle*)NULL;
00109 }
00110
00111 G4DynamicParticle *
00112 G4LightMedia::KaonZeroShortExchange(
00113 const G4HadProjectile *incidentParticle,
00114 const G4Nucleus& targetNucleus )
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
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
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 }
00148
00149 G4DynamicParticle *
00150 G4LightMedia::KaonZeroLongExchange(
00151 const G4HadProjectile *,
00152 const G4Nucleus& )
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 }
00163
00164 G4DynamicParticle *
00165 G4LightMedia::KaonMinusExchange(
00166 const G4HadProjectile *,
00167 const G4Nucleus& )
00168 {
00169 return (G4DynamicParticle*)NULL;
00170 }
00171
00172 G4DynamicParticle *
00173 G4LightMedia::ProtonExchange(
00174 const G4HadProjectile *incidentParticle,
00175 const G4Nucleus& targetNucleus )
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
00190 delete targetParticle;
00191 return resultant;
00192 }
00193 }
00194 delete targetParticle;
00195 return (G4DynamicParticle*)NULL;
00196 }
00197
00198 G4DynamicParticle *
00199 G4LightMedia::AntiProtonExchange(
00200 const G4HadProjectile *incidentParticle,
00201 const G4Nucleus& targetNucleus )
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
00217 delete targetParticle;
00218 return resultant;
00219 }
00220 }
00221 delete targetParticle;
00222 return (G4DynamicParticle*)NULL;
00223 }
00224
00225 G4DynamicParticle *
00226 G4LightMedia::NeutronExchange(
00227 const G4HadProjectile *incidentParticle,
00228 const G4Nucleus& targetNucleus )
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
00243 delete targetParticle;
00244 return resultant;
00245 }
00246 }
00247 delete targetParticle;
00248 return (G4DynamicParticle*)NULL;
00249 }
00250
00251 G4DynamicParticle *
00252 G4LightMedia::AntiNeutronExchange(
00253 const G4HadProjectile *incidentParticle,
00254 const G4Nucleus& targetNucleus )
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
00270 delete targetParticle;
00271 return resultant;
00272 }
00273 }
00274 delete targetParticle;
00275 return (G4DynamicParticle*)NULL;
00276 }
00277
00278 G4DynamicParticle *
00279 G4LightMedia::LambdaExchange(
00280 const G4HadProjectile *incidentParticle,
00281 const G4Nucleus& targetNucleus )
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
00301
00302 switch( irn ) {
00303 case 0:
00304 resultant->SetDefinition( aSigmaZero );
00305 break;
00306 case 1:
00307 resultant->SetDefinition( aSigmaMinus );
00308
00309 break;
00310 case 2:
00311 resultant->SetDefinition( aNeutron );
00312
00313 break;
00314 case 3:
00315 resultant->SetDefinition( aNeutron );
00316
00317 break;
00318 default:
00319 resultant->SetDefinition( aProton );
00320
00321 break;
00322 }
00323 } else {
00324
00325
00326
00327 switch( irn ) {
00328 case 0:
00329 resultant->SetDefinition( aSigmaPlus );
00330
00331 break;
00332 case 1:
00333 resultant->SetDefinition( aSigmaZero );
00334 break;
00335 case 2:
00336 resultant->SetDefinition( aProton );
00337
00338 break;
00339 case 3:
00340 resultant->SetDefinition( aProton );
00341
00342 break;
00343 default:
00344 resultant->SetDefinition( aNeutron );
00345
00346 break;
00347 }
00348 }
00349 delete targetParticle;
00350 return resultant;
00351 }
00352 delete targetParticle;
00353 return (G4DynamicParticle*)NULL;
00354 }
00355
00356 G4DynamicParticle *
00357 G4LightMedia::AntiLambdaExchange(
00358 const G4HadProjectile *incidentParticle,
00359 const G4Nucleus& targetNucleus )
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
00379
00380
00381 switch( irn ) {
00382 case 0:
00383 resultant->SetDefinition( anAntiSigmaPlus );
00384
00385 break;
00386 case 1:
00387 resultant->SetDefinition( anAntiSigmaZero );
00388 break;
00389 case 2:
00390 resultant->SetDefinition( aNeutron );
00391
00392 break;
00393 case 3:
00394 resultant->SetDefinition( aNeutron );
00395
00396 break;
00397 default:
00398 resultant->SetDefinition( aProton );
00399
00400 break;
00401 }
00402 } else {
00403
00404
00405
00406
00407 switch( irn ) {
00408 case 0:
00409 resultant->SetDefinition( anAntiSigmaZero );
00410 break;
00411 case 1:
00412 resultant->SetDefinition( anAntiSigmaMinus );
00413
00414 break;
00415 case 2:
00416 resultant->SetDefinition( aProton );
00417
00418 break;
00419 case 3:
00420 resultant->SetDefinition( aProton );
00421
00422 break;
00423 default:
00424 resultant->SetDefinition( aNeutron );
00425
00426 break;
00427 }
00428 }
00429 delete targetParticle;
00430 return resultant;
00431 }
00432 delete targetParticle;
00433 return (G4DynamicParticle*)NULL;
00434 }
00435
00436 G4DynamicParticle *
00437 G4LightMedia::SigmaPlusExchange(
00438 const G4HadProjectile *incidentParticle,
00439 const G4Nucleus& targetNucleus )
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
00456
00457 G4int irn = G4int( G4UniformRand()/0.2 );
00458 if( targetParticle->GetDefinition() == aNeutron ) {
00459
00460
00461
00462 switch( irn ) {
00463 case 0:
00464 resultant->SetDefinition( aSigmaZero );
00465
00466 break;
00467 case 1:
00468 resultant->SetDefinition( aLambda );
00469
00470 break;
00471 case 2:
00472 resultant->SetDefinition( aNeutron );
00473
00474 break;
00475 case 3:
00476 resultant->SetDefinition( aProton );
00477
00478 break;
00479 default:
00480 resultant->SetDefinition( aProton );
00481
00482 break;
00483 }
00484 } else {
00485
00486
00487
00488 resultant->SetDefinition( aProton );
00489
00490 }
00491 delete targetParticle;
00492 return resultant;
00493 }
00494 delete targetParticle;
00495 return (G4DynamicParticle*)NULL;
00496 }
00497
00498 G4DynamicParticle *
00499 G4LightMedia::SigmaMinusExchange(
00500 const G4HadProjectile *incidentParticle,
00501 const G4Nucleus& targetNucleus )
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
00518
00519 G4int irn = G4int( G4UniformRand()/0.2 );
00520 if( targetParticle->GetDefinition() == aNeutron ) {
00521
00522
00523
00524 resultant->SetDefinition( aNeutron );
00525
00526 } else {
00527
00528
00529
00530 switch( irn ) {
00531 case 0:
00532 resultant->SetDefinition( aSigmaZero );
00533
00534 break;
00535 case 1:
00536 resultant->SetDefinition( aLambda );
00537
00538 break;
00539 case 2:
00540 resultant->SetDefinition( aProton );
00541
00542 break;
00543 case 3:
00544 resultant->SetDefinition( aNeutron );
00545
00546 break;
00547 default:
00548 resultant->SetDefinition( aNeutron );
00549
00550 break;
00551 }
00552 }
00553 delete targetParticle;
00554 return resultant;
00555 }
00556 delete targetParticle;
00557 return (G4DynamicParticle*)NULL;
00558 }
00559
00560 G4DynamicParticle *
00561 G4LightMedia::AntiSigmaPlusExchange(
00562 const G4HadProjectile *incidentParticle,
00563 const G4Nucleus& targetNucleus )
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
00582
00583 resultant->SetDefinition( aNeutron );
00584
00585 } else {
00586
00587
00588
00589 switch( irn ) {
00590 case 0:
00591 resultant->SetDefinition( anAntiLambda );
00592
00593 break;
00594 case 1:
00595 resultant->SetDefinition( anAntiSigmaZero );
00596
00597 break;
00598 case 2:
00599 resultant->SetDefinition( aNeutron );
00600
00601 break;
00602 case 3:
00603 resultant->SetDefinition( aNeutron );
00604
00605 break;
00606 default:
00607 resultant->SetDefinition( aProton );
00608
00609 break;
00610 }
00611 }
00612 delete targetParticle;
00613 return resultant;
00614 }
00615 delete targetParticle;
00616 return (G4DynamicParticle*)NULL;
00617 }
00618
00619 G4DynamicParticle *
00620 G4LightMedia::AntiSigmaMinusExchange(
00621 const G4HadProjectile *incidentParticle,
00622 const G4Nucleus& targetNucleus )
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
00641
00642
00643 switch( irn ) {
00644 case 0:
00645 resultant->SetDefinition( anAntiLambda );
00646
00647 break;
00648 case 1:
00649 resultant->SetDefinition( anAntiSigmaZero );
00650
00651 break;
00652 case 2:
00653 resultant->SetDefinition( aNeutron );
00654
00655 break;
00656 case 3:
00657 resultant->SetDefinition( aProton );
00658
00659 break;
00660 default:
00661 resultant->SetDefinition( aProton );
00662
00663 break;
00664 }
00665 } else {
00666
00667
00668
00669 resultant->SetDefinition( aProton );
00670
00671 }
00672 delete targetParticle;
00673 return resultant;
00674 }
00675 delete targetParticle;
00676 return (G4DynamicParticle*)NULL;
00677 }
00678
00679 G4DynamicParticle *
00680 G4LightMedia::XiZeroExchange(
00681 const G4HadProjectile *incidentParticle,
00682 const G4Nucleus& targetNucleus )
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
00706 break;
00707 case 1:
00708 resultant->SetDefinition( aLambda );
00709
00710 break;
00711 case 2:
00712 resultant->SetDefinition( aXiMinus );
00713
00714 break;
00715 case 3:
00716 resultant->SetDefinition( aProton );
00717
00718 break;
00719 case 4:
00720 resultant->SetDefinition( aSigmaPlus );
00721
00722 break;
00723 case 5:
00724 resultant->SetDefinition( aSigmaMinus );
00725
00726 break;
00727 default:
00728 resultant->SetDefinition( aNeutron );
00729
00730 break;
00731 }
00732 } else {
00733 G4int irn = G4int( G4UniformRand()*5.0 );
00734 switch( irn ) {
00735 case 0:
00736 resultant->SetDefinition( aSigmaPlus );
00737
00738 break;
00739 case 1:
00740 resultant->SetDefinition( aSigmaZero );
00741
00742 break;
00743 case 2:
00744 resultant->SetDefinition( aSigmaPlus );
00745
00746 break;
00747 case 3:
00748 resultant->SetDefinition( aLambda );
00749
00750 break;
00751 default:
00752 resultant->SetDefinition( aProton );
00753
00754 break;
00755 }
00756 }
00757 delete targetParticle;
00758 return resultant;
00759 }
00760 delete targetParticle;
00761 return (G4DynamicParticle*)NULL;
00762 }
00763
00764 G4DynamicParticle *
00765 G4LightMedia::XiMinusExchange(
00766 const G4HadProjectile *incidentParticle,
00767 const G4Nucleus& targetNucleus )
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
00790 break;
00791 case 1:
00792 resultant->SetDefinition( aSigmaZero );
00793
00794 break;
00795 case 2:
00796 resultant->SetDefinition( aSigmaMinus );
00797
00798 break;
00799 case 3:
00800 resultant->SetDefinition( aLambda );
00801
00802 break;
00803 default:
00804 resultant->SetDefinition( aSigmaMinus );
00805
00806 break;
00807 }
00808 } else {
00809 G4int irn = G4int( G4UniformRand()*7.0 );
00810 switch( irn ) {
00811 case 0:
00812 resultant->SetDefinition( aXiZero );
00813
00814 break;
00815 case 1:
00816 resultant->SetDefinition( aNeutron );
00817
00818 break;
00819 case 2:
00820 resultant->SetDefinition( aSigmaZero );
00821
00822 break;
00823 case 3:
00824 resultant->SetDefinition( aLambda );
00825
00826 break;
00827 case 4:
00828 resultant->SetDefinition( aSigmaZero );
00829
00830 break;
00831 case 5:
00832 resultant->SetDefinition( aLambda );
00833
00834 break;
00835 default:
00836 resultant->SetDefinition( aProton );
00837
00838 break;
00839 }
00840 }
00841 delete targetParticle;
00842 return resultant;
00843 }
00844 delete targetParticle;
00845 return (G4DynamicParticle*)NULL;
00846 }
00847
00848 G4DynamicParticle *
00849 G4LightMedia::AntiXiZeroExchange(
00850 const G4HadProjectile *incidentParticle,
00851 const G4Nucleus& targetNucleus )
00852 {
00853
00854
00855
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
00879 break;
00880 case 1:
00881 resultant->SetDefinition( aLambda );
00882
00883 break;
00884 case 2:
00885 resultant->SetDefinition( aXiMinus );
00886
00887 break;
00888 case 3:
00889 resultant->SetDefinition( aProton );
00890
00891 break;
00892 case 4:
00893 resultant->SetDefinition( aSigmaPlus );
00894
00895 break;
00896 case 5:
00897 resultant->SetDefinition( aSigmaMinus );
00898
00899 break;
00900 default:
00901 resultant->SetDefinition( aNeutron );
00902
00903 break;
00904 }
00905 } else {
00906 G4int irn = G4int( G4UniformRand()*5.0 );
00907 switch( irn ) {
00908 case 0:
00909 resultant->SetDefinition( aSigmaPlus );
00910
00911 break;
00912 case 1:
00913 resultant->SetDefinition( aSigmaZero );
00914
00915 break;
00916 case 2:
00917 resultant->SetDefinition( aSigmaPlus );
00918
00919 break;
00920 case 3:
00921 resultant->SetDefinition( aLambda );
00922
00923 break;
00924 default:
00925 resultant->SetDefinition( aProton );
00926
00927 break;
00928 }
00929 }
00930 delete targetParticle;
00931 return resultant;
00932 }
00933 delete targetParticle;
00934 return (G4DynamicParticle*)NULL;
00935 }
00936
00937 G4DynamicParticle *
00938 G4LightMedia::AntiXiMinusExchange(
00939 const G4HadProjectile *incidentParticle,
00940 const G4Nucleus& targetNucleus )
00941 {
00942
00943
00944
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
00967 break;
00968 case 1:
00969 resultant->SetDefinition( aSigmaZero );
00970
00971 break;
00972 case 2:
00973 resultant->SetDefinition( aSigmaMinus );
00974
00975 break;
00976 case 3:
00977 resultant->SetDefinition( aLambda );
00978
00979 break;
00980 default:
00981 resultant->SetDefinition( aSigmaMinus );
00982
00983 break;
00984 }
00985 } else {
00986 G4int irn = G4int( G4UniformRand()*7.0 );
00987 switch( irn ) {
00988 case 0:
00989 resultant->SetDefinition( aXiZero );
00990
00991 break;
00992 case 1:
00993 resultant->SetDefinition( aNeutron );
00994
00995 break;
00996 case 2:
00997 resultant->SetDefinition( aSigmaZero );
00998
00999 break;
01000 case 3:
01001 resultant->SetDefinition( aLambda );
01002
01003 break;
01004 case 4:
01005 resultant->SetDefinition( aSigmaZero );
01006
01007 break;
01008 case 5:
01009 resultant->SetDefinition( aLambda );
01010
01011 break;
01012 default:
01013 resultant->SetDefinition( aProton );
01014
01015 break;
01016 }
01017 }
01018 delete targetParticle;
01019 return resultant;
01020 }
01021 delete targetParticle;
01022 return (G4DynamicParticle*)NULL;
01023 }
01024
01025 G4DynamicParticle *
01026 G4LightMedia::OmegaMinusExchange(
01027 const G4HadProjectile *incidentParticle,
01028 const G4Nucleus& targetNucleus )
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
01049
01050 if( targetParticle->GetDefinition() == aNeutron ) {
01051 G4int irn = G4int( G4UniformRand()*7.0 );
01052 switch( irn ) {
01053 case 0:
01054 resultant->SetDefinition( aXiZero );
01055
01056 break;
01057 case 1:
01058 resultant->SetDefinition( aSigmaMinus );
01059
01060 break;
01061 case 2:
01062 resultant->SetDefinition( aXiMinus );
01063
01064 break;
01065 case 3:
01066 resultant->SetDefinition( aLambda );
01067
01068 break;
01069 case 4:
01070 resultant->SetDefinition( aXiMinus );
01071
01072 break;
01073 case 5:
01074 resultant->SetDefinition( aSigmaZero );
01075
01076 break;
01077 default:
01078 resultant->SetDefinition( aNeutron );
01079
01080 break;
01081 }
01082 } else {
01083 G4int irn = G4int( G4UniformRand()*7.0 );
01084 switch( irn ) {
01085 case 0:
01086 resultant->SetDefinition( aXiZero );
01087
01088 break;
01089 case 1:
01090 resultant->SetDefinition( aSigmaZero );
01091
01092 break;
01093 case 2:
01094 resultant->SetDefinition( aXiZero );
01095
01096 break;
01097 case 3:
01098 resultant->SetDefinition( aLambda );
01099
01100 break;
01101 case 4:
01102 resultant->SetDefinition( aXiMinus );
01103
01104 break;
01105 case 5:
01106 resultant->SetDefinition( aSigmaPlus );
01107
01108 break;
01109 default:
01110 resultant->SetDefinition( aProton );
01111
01112 break;
01113 }
01114 }
01115 delete targetParticle;
01116 return resultant;
01117 }
01118 delete targetParticle;
01119 return (G4DynamicParticle*)NULL;
01120 }
01121
01122 G4DynamicParticle *
01123 G4LightMedia::AntiOmegaMinusExchange(
01124 const G4HadProjectile *incidentParticle,
01125 const G4Nucleus& targetNucleus )
01126 {
01127
01128
01129
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
01150
01151 if( targetParticle->GetDefinition() == aNeutron ) {
01152 G4int irn = G4int( G4UniformRand()*7.0 );
01153 switch( irn ) {
01154 case 0:
01155 resultant->SetDefinition( aXiZero );
01156
01157 break;
01158 case 1:
01159 resultant->SetDefinition( aSigmaMinus );
01160
01161 break;
01162 case 2:
01163 resultant->SetDefinition( aXiMinus );
01164
01165 break;
01166 case 3:
01167 resultant->SetDefinition( aLambda );
01168
01169 break;
01170 case 4:
01171 resultant->SetDefinition( aXiMinus );
01172
01173 break;
01174 case 5:
01175 resultant->SetDefinition( aSigmaZero );
01176
01177 break;
01178 default:
01179 resultant->SetDefinition( aNeutron );
01180
01181 break;
01182 }
01183 } else {
01184 G4int irn = G4int( G4UniformRand()*7.0 );
01185 switch( irn ) {
01186 case 0:
01187 resultant->SetDefinition( aXiZero );
01188
01189 break;
01190 case 1:
01191 resultant->SetDefinition( aSigmaZero );
01192
01193 break;
01194 case 2:
01195 resultant->SetDefinition( aXiZero );
01196
01197 break;
01198 case 3:
01199 resultant->SetDefinition( aLambda );
01200
01201 break;
01202 case 4:
01203 resultant->SetDefinition( aXiMinus );
01204
01205 break;
01206 case 5:
01207 resultant->SetDefinition( aSigmaPlus );
01208
01209 break;
01210 default:
01211 resultant->SetDefinition( aProton );
01212
01213 break;
01214 }
01215 }
01216 delete targetParticle;
01217 return resultant;
01218 }
01219 delete targetParticle;
01220 return (G4DynamicParticle*)NULL;
01221 }
01222
01223
01224