G4INCL::CrossSections

G4INCL::CrossSections Class Reference

#include <G4INCLCrossSections.hh>


Static Public Member Functions

static G4double elastic (Particle const *const p1, Particle const *const p2)
static G4double total (Particle const *const p1, Particle const *const p2)
static G4double pionNucleon (Particle const *const p1, Particle const *const p2)
static G4double recombination (Particle const *const p1, Particle const *const p2)
static G4double deltaProduction (Particle const *const p1, Particle const *const p2)
static G4double calculateNNDiffCrossSection (G4double energyCM, G4int iso)
 Calculate the slope of the NN DDXS.
static G4double interactionDistanceNN (const G4double projectileKineticEnergy)
 Compute the "interaction distance".
static G4double interactionDistancePiN (const G4double projectileKineticEnergy)
 Compute the "interaction distance".
static G4double interactionDistanceNN1GeV ()
 The interaction distance for nucleons at 1 GeV.
static G4double interactionDistancePiN1GeV ()
 The interaction distance for pions at 1 GeV.

Protected Member Functions

 CrossSections ()
 ~CrossSections ()

Detailed Description

Definition at line 45 of file G4INCLCrossSections.hh.

Constructor & Destructor Documentation

G4INCL::CrossSections::CrossSections (  )  [inline, protected]

Definition at line 112 of file G4INCLCrossSections.hh.

00112 {};

G4INCL::CrossSections::~CrossSections (  )  [inline, protected]

Definition at line 113 of file G4INCLCrossSections.hh.

00113 {};

Member Function Documentation

G4double G4INCL::CrossSections::calculateNNDiffCrossSection ( G4double  energyCM,
G4int  iso 
) [static]

Calculate the slope of the NN DDXS.

Parameters:
energyCM energy in the CM frame, in MeV
iso total isospin of the system
Returns:
the slope of the angular distribution

Definition at line 341 of file G4INCLCrossSections.cc.

Referenced by G4INCL::ElasticChannel::getFinalState().

00341                                                                             {
00342     G4double x = 0.001 * pl; // Change to GeV
00343     if(iso != 0) {
00344       if(pl <= 2000.0) {
00345         x = std::pow(x, 8);
00346         return 5.5e-6 * x/(7.7 + x);
00347       } else {
00348         return (5.34 + 0.67*(x - 2.0)) * 1.0e-6;
00349       }
00350     } else {
00351       if(pl < 800.0) {
00352         G4double b = (7.16 - 1.63*x) * 1.0e-6;
00353         return b/(1.0 + std::exp(-(x - 0.45)/0.05));
00354       } else if(pl < 1100.0) {
00355         return (9.87 - 4.88 * x) * 1.0e-6;
00356       } else {
00357         return (3.68 + 0.76*x) * 1.0e-6;
00358       }
00359     }
00360     return 0.0; // Should never reach this point
00361   }

G4double G4INCL::CrossSections::deltaProduction ( Particle const *const   p1,
Particle const *const   p2 
) [static]

Definition at line 187 of file G4INCLCrossSections.cc.

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::ParticleTable::effectivePionMass, G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::BinaryCollisionAvatar::getChannel(), recombination(), and total().

00187                                                                                               {
00188 // assert(p1->isNucleon() && p2->isNucleon());
00189     const G4double sqrts = KinematicsUtils::totalEnergyInCM(p1,p2);
00190     if(sqrts < ParticleTable::effectivePionMass + 2*ParticleTable::effectiveNucleonMass + 50.) { // approximately yields INCL4.6's hard-coded threshold in collis, 2065 MeV
00191       return 0.0;
00192     } else {
00193       const G4double pLab = KinematicsUtils::momentumInLab(p1,p2);
00194       const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
00195       return deltaProduction(isospin, pLab);
00196     }
00197   }

G4double G4INCL::CrossSections::elastic ( Particle const *const   p1,
Particle const *const   p2 
) [static]

Definition at line 333 of file G4INCLCrossSections.cc.

References G4INCL::Particle::isPion().

Referenced by G4INCL::BinaryCollisionAvatar::getChannel(), and total().

00333                                                                                       {
00334     if(!p1->isPion() && !p2->isPion())
00335       //    return elasticNN(p1, p2); // New implementation
00336       return elasticNNLegacy(p1, p2); // Translated from INCL4.6 FORTRAN
00337     else
00338       return 0.0; // No pion-nucleon elastic scattering
00339   }

G4double G4INCL::CrossSections::interactionDistanceNN ( const G4double  projectileKineticEnergy  )  [static]

Compute the "interaction distance".

Defined on the basis of the average value of the N-N cross sections at the given kinetic energy.

Returns:
the interaction distance

Definition at line 363 of file G4INCLCrossSections.cc.

References G4INCL::Particle::adjustMomentumFromEnergy(), G4INCL::Particle::getMass(), G4INCL::Neutron, G4INCL::Proton, G4INCL::Particle::setEnergy(), G4INCL::Math::tenPi, and total().

Referenced by interactionDistanceNN1GeV().

00363                                                                                       {
00364     ThreeVector nullVector;
00365     ThreeVector unitVector(0., 0., 1.);
00366 
00367     Particle protonProjectile(Proton, unitVector, nullVector);
00368     protonProjectile.setEnergy(protonProjectile.getMass()+projectileKineticEnergy);
00369     protonProjectile.adjustMomentumFromEnergy();
00370     Particle neutronProjectile(Neutron, unitVector, nullVector);
00371     neutronProjectile.setEnergy(neutronProjectile.getMass()+projectileKineticEnergy);
00372     neutronProjectile.adjustMomentumFromEnergy();
00373 
00374     Particle protonTarget(Proton, nullVector, nullVector);
00375     Particle neutronTarget(Neutron, nullVector, nullVector);
00376     const G4double sigmapp = total(&protonProjectile, &protonTarget);
00377     const G4double sigmapn = total(&protonProjectile, &neutronTarget);
00378     const G4double sigmanp = total(&neutronProjectile, &protonTarget);
00379     const G4double sigmann = total(&neutronProjectile, &neutronTarget);
00380     /* We compute the interaction distance from the largest of the NN cross
00381      * sections. Note that this is different from INCL4.6, which just takes the
00382      * average of the four, and will in general lead to a different geometrical
00383      * cross section.
00384      */
00385     const G4double largestSigma = std::max(sigmapp, std::max(sigmapn, std::max(sigmanp,sigmann)));
00386     const G4double interactionDistance = std::sqrt(largestSigma/Math::tenPi);
00387 
00388     return interactionDistance;
00389   }

static G4double G4INCL::CrossSections::interactionDistanceNN1GeV (  )  [inline, static]

The interaction distance for nucleons at 1 GeV.

Used to determine the universe radius at any energy.

Definition at line 85 of file G4INCLCrossSections.hh.

References interactionDistanceNN().

00085                                                 {
00086       static G4double answer = CrossSections::interactionDistanceNN(1000.);
00087       return answer;
00088     }

G4double G4INCL::CrossSections::interactionDistancePiN ( const G4double  projectileKineticEnergy  )  [static]

Compute the "interaction distance".

Defined on the basis of the average value of the pi-N cross sections at the given kinetic energy.

Returns:
the interaction distance

Definition at line 391 of file G4INCLCrossSections.cc.

References G4INCL::Particle::adjustMomentumFromEnergy(), G4INCL::Particle::getMass(), G4INCL::Neutron, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::Particle::setEnergy(), G4INCL::Math::tenPi, and total().

Referenced by interactionDistancePiN1GeV().

00391                                                                                        {
00392     ThreeVector nullVector;
00393     ThreeVector unitVector(0., 0., 1.);
00394 
00395     Particle piPlusProjectile(PiPlus, unitVector, nullVector);
00396     piPlusProjectile.setEnergy(piPlusProjectile.getMass()+projectileKineticEnergy);
00397     piPlusProjectile.adjustMomentumFromEnergy();
00398     Particle piZeroProjectile(PiZero, unitVector, nullVector);
00399     piZeroProjectile.setEnergy(piZeroProjectile.getMass()+projectileKineticEnergy);
00400     piZeroProjectile.adjustMomentumFromEnergy();
00401     Particle piMinusProjectile(PiMinus, unitVector, nullVector);
00402     piMinusProjectile.setEnergy(piMinusProjectile.getMass()+projectileKineticEnergy);
00403     piMinusProjectile.adjustMomentumFromEnergy();
00404 
00405     Particle protonTarget(Proton, nullVector, nullVector);
00406     Particle neutronTarget(Neutron, nullVector, nullVector);
00407     const G4double sigmapipp = total(&piPlusProjectile, &protonTarget);
00408     const G4double sigmapipn = total(&piPlusProjectile, &neutronTarget);
00409     const G4double sigmapi0p = total(&piZeroProjectile, &protonTarget);
00410     const G4double sigmapi0n = total(&piZeroProjectile, &neutronTarget);
00411     const G4double sigmapimp = total(&piMinusProjectile, &protonTarget);
00412     const G4double sigmapimn = total(&piMinusProjectile, &neutronTarget);
00413     /* We compute the interaction distance from the largest of the pi-N cross
00414      * sections. Note that this is different from INCL4.6, which just takes the
00415      * average of the six, and will in general lead to a different geometrical
00416      * cross section.
00417      */
00418     const G4double largestSigma = std::max(sigmapipp, std::max(sigmapipn, std::max(sigmapi0p, std::max(sigmapi0n, std::max(sigmapimp,sigmapimn)))));
00419     const G4double interactionDistance = std::sqrt(largestSigma/Math::tenPi);
00420 
00421     return interactionDistance;
00422   }

static G4double G4INCL::CrossSections::interactionDistancePiN1GeV (  )  [inline, static]

The interaction distance for pions at 1 GeV.

Used to determine the universe radius at any energy.

Definition at line 94 of file G4INCLCrossSections.hh.

References interactionDistancePiN().

00094                                                  {
00095       static G4double answer = CrossSections::interactionDistancePiN(1000.);
00096       return answer;
00097     }

G4double G4INCL::CrossSections::pionNucleon ( Particle const *const   p1,
Particle const *const   p2 
) [static]

Definition at line 62 of file G4INCLCrossSections.cc.

References ERROR, G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isPion(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by total().

00062                                                                                                         {
00063     //      FUNCTION SPN(X,IND2T3,IPIT3,f17)
00064     // SIGMA(PI+ + P) IN THE (3,3) REGION
00065     // NEW FIT BY J.VANDERMEULEN  + FIT BY Th AOUST ABOVE (3,3) RES
00066     //                              CONST AT LOW AND VERY HIGH ENERGY
00067     //      COMMON/BL8/RATHR,RAMASS                                           REL21800
00068     //      integer f17
00069     // RATHR and RAMASS are always 0.0!!!
00070 
00071     G4double x = KinematicsUtils::totalEnergyInCM(particle1, particle2);
00072     if(x>10000.) return 0.0; // no cross section above this value
00073 
00074     G4int ipit3 = 0;
00075     G4int ind2t3 = 0;
00076     G4double ramass = 0.0;
00077 
00078     if(particle1->isPion()) {
00079       ipit3 = ParticleTable::getIsospin(particle1->getType());
00080     } else if(particle2->isPion()) {
00081       ipit3 = ParticleTable::getIsospin(particle2->getType());
00082     }
00083 
00084     if(particle1->isNucleon()) {
00085       ind2t3 = ParticleTable::getIsospin(particle1->getType());
00086     } else if(particle2->isNucleon()) {
00087       ind2t3 = ParticleTable::getIsospin(particle2->getType());
00088     }
00089 
00090     G4double y=x*x;
00091     G4double q2=(y-1076.0*1076.0)*(y-800.0*800.0)/y/4.0;
00092     if (q2 <= 0.) {
00093       return 0.0;
00094     }
00095     G4double q3 = std::pow(std::sqrt(q2),3);
00096     G4double f3 = q3/(q3 + 5832000.); // 5832000 = 180^3
00097     G4double spnResult = 326.5/(std::pow((x-1215.0-ramass)*2.0/(110.0-ramass), 2)+1.0);
00098     spnResult = spnResult*(1.0-5.0*ramass/1215.0);
00099     G4double cg = 4.0 + G4double(ind2t3)*G4double(ipit3);
00100     spnResult = spnResult*f3*cg/6.0;
00101 
00102     if(x < 1200.0  && spnResult < 5.0) {
00103       spnResult = 5.0;
00104     }
00105 
00106     // HE pi+ p and pi- n
00107     if(x > 1290.0) {
00108       if((ind2t3 == 1 && ipit3 == 2) || (ind2t3 == -1 && ipit3 == -2))
00109         spnResult=CrossSections::spnPiPlusPHE(x);
00110       else if((ind2t3 == 1 && ipit3 == -2) || (ind2t3 == -1 && ipit3 == 2))
00111         spnResult=CrossSections::spnPiMinusPHE(x);
00112       else if(ipit3 == 0) spnResult = (CrossSections::spnPiPlusPHE(x) + CrossSections::spnPiMinusPHE(x))/2.0; // (spnpipphe(x)+spnpimphe(x))/2.0
00113       else {
00114         ERROR("Unknown configuration!" << std::endl);
00115       }
00116     }
00117 
00118     return spnResult;
00119   }

G4double G4INCL::CrossSections::recombination ( Particle const *const   p1,
Particle const *const   p2 
) [static]

Definition at line 149 of file G4INCLCrossSections.cc.

References deltaProduction(), G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::ParticleTable::effectiveNucleonMass2, G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getMass(), G4INCL::Particle::getType(), G4INCL::Particle::isDelta(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by G4INCL::BinaryCollisionAvatar::getChannel(), and total().

00149                                                                                             {
00150     const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
00151     if(isospin==4 || isospin==-4) return 0.0;
00152 
00153     G4double s = KinematicsUtils::squareTotalEnergyInCM(p1, p2);
00154     G4double Ecm = std::sqrt(s);
00155     G4int deltaIsospin;
00156     G4double deltaMass;
00157     if(p1->isDelta()) {
00158       deltaIsospin = ParticleTable::getIsospin(p1->getType());
00159       deltaMass = p1->getMass();
00160     } else {
00161       deltaIsospin = ParticleTable::getIsospin(p2->getType());
00162       deltaMass = p2->getMass();
00163     }
00164 
00165     if(Ecm <= 938.3 + deltaMass) {
00166       return 0.0;
00167     }
00168 
00169     if(Ecm < 938.3 + deltaMass + 2.0) {
00170       Ecm = 938.3 + deltaMass + 2.0;
00171       s = Ecm*Ecm;
00172     }
00173     
00174     const G4double x = (s - 4.*ParticleTable::effectiveNucleonMass2) /
00175       (s - std::pow(ParticleTable::effectiveNucleonMass + deltaMass, 2));
00176     const G4double y = s/(s - std::pow(deltaMass - ParticleTable::effectiveNucleonMass, 2));
00177     /* Concerning the way we calculate the lab momentum, see the considerations
00178      * in CrossSections::elasticNNLegacy().
00179      */
00180     const G4double pLab = KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
00181     G4double result = 0.5 * x * y * deltaProduction(isospin, pLab);
00182     result *= 3.*(32.0 + isospin * isospin * (deltaIsospin * deltaIsospin - 5))/64.0;
00183     result /= 1.0 + 0.25 * isospin * isospin;
00184     return result;
00185   }

G4double G4INCL::CrossSections::total ( Particle const *const   p1,
Particle const *const   p2 
) [static]

Definition at line 45 of file G4INCLCrossSections.cc.

References deltaProduction(), elastic(), G4INCL::Particle::isDelta(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isPion(), pionNucleon(), and recombination().

Referenced by G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), interactionDistanceNN(), interactionDistancePiN(), and G4INCL::InteractionAvatar::preInteractionBlocking().

00045                                                                                     {
00046     G4double inelastic = 0.0;
00047     if(p1->isNucleon() && p2->isNucleon()) {
00048       inelastic = CrossSections::deltaProduction(p1, p2);
00049     } else if((p1->isNucleon() && p2->isDelta()) ||
00050               (p1->isDelta() && p2->isNucleon())) {
00051       inelastic = CrossSections::recombination(p1, p2);
00052     } else if((p1->isNucleon() && p2->isPion()) ||
00053         (p1->isPion() && p2->isNucleon())) {
00054       inelastic = CrossSections::pionNucleon(p1, p2);
00055     } else {
00056       inelastic = 0.0;
00057     }
00058 
00059     return inelastic + CrossSections::elastic(p1, p2);
00060   }

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