Geant4-11
Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes
G4INCL::CrossSectionsMultiPionsAndResonances Class Reference

Multipion and mesonic Resonances cross sections. More...

#include <G4INCLCrossSectionsMultiPionsAndResonances.hh>

Inheritance diagram for G4INCL::CrossSectionsMultiPionsAndResonances:
G4INCL::CrossSectionsMultiPions G4INCL::ICrossSections G4INCL::CrossSectionsStrangeness

Public Member Functions

virtual G4double calculateNNAngularSlope (G4double energyCM, G4int iso)
 Calculate the slope of the NN DDXS. More...
 
 CrossSectionsMultiPionsAndResonances ()
 
virtual G4double elastic (Particle const *const p1, Particle const *const p2)
 new elastic particle-particle cross section More...
 
virtual G4double etaNToPiN (Particle const *const p1, Particle const *const p2)
 Cross sections for mesonic resonance absorption on nucleon - piN Channel. More...
 
virtual G4double etaNToPiPiN (Particle const *const p1, Particle const *const p2)
 Cross sections for mesonic resonance absorption on nucleon - pipiN Channel. More...
 
virtual G4double etaPrimeNToPiN (Particle const *const p1, Particle const *const p2)
 Cross section for EtaPrimeN->PiN. More...
 
virtual G4double NDeltaToDeltaLK (Particle const *const p1, Particle const *const p2)
 
virtual G4double NDeltaToDeltaSK (Particle const *const p1, Particle const *const p2)
 
virtual G4double NDeltaToNLK (Particle const *const p1, Particle const *const p2)
 Nucleon-Delta to Stange particles cross sections. More...
 
virtual G4double NDeltaToNN (Particle const *const p1, Particle const *const p2)
 Cross section for NDelta->NN. More...
 
virtual G4double NDeltaToNNKKb (Particle const *const p1, Particle const *const p2)
 
virtual G4double NDeltaToNSK (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbelastic (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToL2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToLpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToNKb (Particle const *const p1, Particle const *const p2)
 Nucleon-antiKaon quasi-elastic and inelastic cross sections. More...
 
virtual G4double NKbToNKb2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToNKbpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToS2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKbToSpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKelastic (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKToNK (Particle const *const p1, Particle const *const p2)
 Nucleon-Kaon quasi-elastic and inelastic cross sections. More...
 
virtual G4double NKToNK2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NKToNKpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NLToNS (Particle const *const p1, Particle const *const p2)
 Nucleon-Hyperon cross sections. More...
 
virtual G4double NNToMissingStrangeness (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNDelta (Particle const *const p1, Particle const *const p2)
 Cross section for Delta production - NN Channel. More...
 
virtual G4double NNToNDeltaEta (Particle const *const p1, Particle const *const p2)
 Cross section for N-Delta-Eta production - NNEta Channel. More...
 
virtual G4double NNToNDeltaOmega (Particle const *const p1, Particle const *const p2)
 Cross section for N-Delta-Eta production - NNOmega Channel. More...
 
virtual G4double NNToNLK (Particle const *const p1, Particle const *const p2)
 Nucleon-Nucleon to Stange particles cross sections. More...
 
virtual G4double NNToNLK2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNLKpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNNEta (Particle const *const particle1, Particle const *const particle2)
 Cross section for Eta production (inclusive) - NN entrance channel. More...
 
virtual G4double NNToNNEtaExclu (Particle const *const particle1, Particle const *const particle2)
 Cross section for Eta production (exclusive) - NN entrance channel. More...
 
virtual G4double NNToNNEtaxPi (const G4int xpi, Particle const *const p1, Particle const *const p2)
 Cross section for X pion production - NNEta Channel. More...
 
virtual G4double NNToNNKKb (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNNOmega (Particle const *const particle1, Particle const *const particle2)
 Cross section for Omega production (inclusive) - NN entrance channel. More...
 
virtual G4double NNToNNOmegaExclu (Particle const *const particle1, Particle const *const particle2)
 Cross section for Omega production (exclusive) - NN entrance channel. More...
 
virtual G4double NNToNNOmegaxPi (const G4int xpi, Particle const *const p1, Particle const *const p2)
 Cross section for X pion production - NNOmega Channel. More...
 
virtual G4double NNToNSK (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNSK2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToNSKpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NNToxPiNN (const G4int xpi, Particle const *const p1, Particle const *const p2)
 Cross section for X pion production - NN Channel. More...
 
virtual G4double NpiToLK (Particle const *const p1, Particle const *const p2)
 Nucleon-Pion to Stange particles cross sections. More...
 
virtual G4double NpiToLK2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToLKpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToMissingStrangeness (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToNKKb (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToSK (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToSK2pi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NpiToSKpi (Particle const *const p1, Particle const *const p2)
 
virtual G4double NSToNL (Particle const *const p1, Particle const *const p2)
 
virtual G4double NSToNS (Particle const *const p1, Particle const *const p2)
 
virtual G4double NYelastic (Particle const *const p1, Particle const *const p2)
 elastic scattering for Nucleon-Strange Particles cross sections More...
 
virtual G4double omegaNToPiN (Particle const *const p1, Particle const *const p2)
 Cross section for OmegaN->PiN. More...
 
virtual G4double p_pimToSmKp (Particle const *const p1, Particle const *const p2)
 
virtual G4double p_pimToSzKz (Particle const *const p1, Particle const *const p2)
 
virtual G4double p_pizToSzKp (Particle const *const p1, Particle const *const p2)
 
virtual G4double piNToDelta (Particle const *const p1, Particle const *const p2)
 Cross section for Delta production - piN Channel. More...
 
virtual G4double piNToEtaN (Particle const *const p1, Particle const *const p2)
 Cross sections for mesonic resonance production - piN Channel. More...
 
virtual G4double piNToEtaPrimeN (Particle const *const p1, Particle const *const p2)
 Cross section for PiN->EtaPrimeN. More...
 
virtual G4double piNToOmegaN (Particle const *const p1, Particle const *const p2)
 Cross section for PiN->OmegaN. More...
 
virtual G4double piNToxPiN (const G4int xpi, Particle const *const p1, Particle const *const p2)
 Cross section for X pion production - piN Channel (modified due to the mesonic resonances) More...
 
virtual G4double total (Particle const *const p1, Particle const *const p2)
 new total particle-particle cross section More...
 

Protected Member Functions

virtual G4double etaNElastic (Particle const *const p1, Particle const *const p2)
 Cross sections for mesonic resonance absorption on nucleon - elastic Channel. More...
 
G4double NNElastic (Particle const *const part1, Particle const *const part2)
 Internal implementation of the NN elastic cross section. More...
 
G4double NNElasticFixed (const G4double s, const G4int i)
 Internal implementation of the NN elastic cross section with fixed isospin. More...
 
virtual G4double NNFourPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 4-pion production - NN entrance channel. More...
 
G4double NNInelasticIso (const G4double ener, const G4int iso)
 Internal implementation of the isospin dependent NN reaction cross section. More...
 
virtual G4double NNOnePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NN entrance channel. More...
 
virtual G4double NNOnePiOrDelta (const G4double ener, const G4int iso, const G4double xsiso)
 Cross section for direct 1-pion production + delta production - NN entrance channel. More...
 
virtual G4double NNOnePiOrDelta (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NN entrance channel. More...
 
virtual G4double NNThreePi (const G4double ener, const G4int iso, const G4double xsiso, const G4double xs1pi, const G4double xs2pi)
 Cross section for direct 3-pion production - NN entrance channel. More...
 
virtual G4double NNThreePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 3-pion production - NN entrance channel. More...
 
virtual G4double NNToNNEtaExcluIso (const G4double ener, const G4int iso)
 Isotopic Cross section for Eta production (exclusive) - NN entrance channel. More...
 
virtual G4double NNToNNEtaFourPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 4-pion production - NNEta channel. More...
 
virtual G4double NNToNNEtaIso (const G4double ener, const G4int iso)
 Cross section for One (more) pion production - piN entrance channel. More...
 
virtual G4double NNToNNEtaOnePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NNEta channel. More...
 
virtual G4double NNToNNEtaOnePiOrDelta (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NNEta channel. More...
 
virtual G4double NNToNNEtaThreePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 3-pion production - NNEta channel. More...
 
virtual G4double NNToNNEtaTwoPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 2-pion production - NNEta channel. More...
 
virtual G4double NNToNNOmegaExcluIso (const G4double ener, const G4int iso)
 Isotopic Cross section for Omega production (exclusive) - NN entrance channel. More...
 
virtual G4double NNToNNOmegaFourPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 4-pion production - NNOmega channel. More...
 
virtual G4double NNToNNOmegaIso (const G4double ener, const G4int iso)
 Isotopic Cross section for Omega production (inclusive) - NN entrance channel. More...
 
virtual G4double NNToNNOmegaOnePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NNOmega channel. More...
 
virtual G4double NNToNNOmegaOnePiOrDelta (Particle const *const part1, Particle const *const part2)
 Cross section for direct 1-pion production - NNOmega channel. More...
 
virtual G4double NNToNNOmegaThreePi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 3-pion production - NNOmega channel. More...
 
virtual G4double NNToNNOmegaTwoPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 2-pion production - NNOmega channel. More...
 
G4double NNTot (Particle const *const part1, Particle const *const part2)
 Internal implementation of the NN total cross section. More...
 
G4double NNTotFixed (const G4double s, const G4int i)
 Internal implementation of the NN total cross section with fixed isospin. More...
 
virtual G4double NNTwoPi (const G4double ener, const G4int iso, const G4double xsiso)
 Cross section for direct 2-pion production - NN entrance channel. More...
 
virtual G4double NNTwoPi (Particle const *const part1, Particle const *const part2)
 Cross section for direct 2-pion production - NN entrance channel. More...
 
virtual G4double omegaNElastic (Particle const *const p1, Particle const *const p2)
 
virtual G4double omegaNInelastic (Particle const *const p1, Particle const *const p2)
 Cross sections for mesonic resonance absorption on nucleon - inelastic Channel. More...
 
virtual G4double omegaNToPiPiN (Particle const *const p1, Particle const *const p2)
 Cross sections for omega-induced 2Pi emission on nucleon. More...
 
G4double piMinuspIne (Particle const *const p1, Particle const *const p2)
 
G4double piMinuspOnePi (Particle const *const p1, Particle const *const p2)
 
G4double piMinuspToEtaN (const G4double ECM)
 
G4double piMinuspToEtaN (Particle const *const p1, Particle const *const p2)
 Internal function for pion cross sections. More...
 
G4double piMinuspToOmegaN (const G4double ECM)
 
G4double piMinuspToOmegaN (Particle const *const p1, Particle const *const p2)
 
G4double piMinuspTwoPi (Particle const *const p1, Particle const *const p2)
 
G4double piNIne (Particle const *const p1, Particle const *const p2)
 
virtual G4double piNOnePi (Particle const *const p1, Particle const *const p2)
 Cross section for One (more) pion production - piN entrance channel. More...
 
G4double piNTopiN (Particle const *const p1, Particle const *const p2)
 
G4double piNTot (Particle const *const p1, Particle const *const p2)
 
virtual G4double piNTwoPi (Particle const *const p1, Particle const *const p2)
 Cross section for Two (more) pion production - piN entrance channel. More...
 
G4double piPluspIne (Particle const *const p1, Particle const *const p2)
 
G4double piPluspOnePi (Particle const *const p1, Particle const *const p2)
 
G4double piPluspTwoPi (Particle const *const p1, Particle const *const p2)
 
G4double spnPiMinusPHE (const G4double x)
 Internal function for pion cross sections. More...
 
G4double spnPiPlusPHE (const G4double x)
 Internal function for pion cross sections. More...
 

Protected Attributes

const HornerC8 s01ppHC
 Horner coefficients for s01pp. More...
 
const HornerC4 s01pzHC
 Horner coefficients for s01pz. More...
 
const HornerC6 s02pmHC
 Horner coefficients for s02pm. More...
 
const HornerC4 s02pzHC
 Horner coefficients for s02pz. More...
 
const HornerC4 s11pmHC
 Horner coefficients for s11pm. More...
 
const HornerC7 s11pzHC
 Horner coefficients for s11pz. More...
 
const HornerC4 s12mzHC
 Horner coefficients for s12mz. More...
 
const HornerC5 s12pmHC
 Horner coefficients for s12pm. More...
 
const HornerC3 s12ppHC
 Horner coefficients for s12pp. More...
 
const HornerC4 s12zzHC
 Horner coefficients for s12zz. More...
 

Static Protected Attributes

static const G4int nMaxPiNN = 4
 Maximum number of outgoing pions in NN collisions. More...
 
static const G4int nMaxPiPiN = 4
 Maximum number of outgoing pions in piN collisions. More...
 
static const G4double s01ppOOT = 0.003421025623481919853
 One over threshold for s01pp. More...
 
static const G4double s01pzOOT = 0.0035739814152966403123
 One over threshold for s01pz. More...
 
static const G4double s02pmOOT = 0.0016661112962345883443
 One over threshold for s02pm. More...
 
static const G4double s02pzOOT = 0.00125
 One over threshold for s02pz. More...
 
static const G4double s11pmOOT = 0.0034855350296270480281
 One over threshold for s11pm. More...
 
static const G4double s11pzOOT = 0.0035761542037692665889
 One over threshold for s11pz. More...
 
static const G4double s12mzOOT = 0.0017047391749062392793
 One over threshold for s12mz. More...
 
static const G4double s12pmOOT = 0.0016672224074691565119
 One over threshold for s12pm. More...
 
static const G4double s12ppOOT = 0.0016507643038726931312
 One over threshold for s12pp. More...
 
static const G4double s12zzOOT = 0.0011111111111111111111
 One over threshold for s12zz. More...
 

Detailed Description

Multipion and mesonic Resonances cross sections.

Definition at line 54 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

Constructor & Destructor Documentation

◆ CrossSectionsMultiPionsAndResonances()

G4INCL::CrossSectionsMultiPionsAndResonances::CrossSectionsMultiPionsAndResonances ( )

Definition at line 77 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

77 :
78 s11pzHC(-2.228000000000294018,8.7560000000005723725,-0.61000000000023239325,-5.4139999999999780324,3.3338333333333348023,-0.75835000000000022049,0.060623611111111114688),
79 s01ppHC(2.0570000000126518344,-6.029000000012135826,36.768500000002462784,-45.275666666666553533,25.112666666666611953,-7.2174166666666639187,1.0478875000000000275,-0.060804365079365080846),
80 s01pzHC(0.18030000000000441851,7.8700999999999953598,-4.0548999999999990425,0.555199999999999959),
81 s11pmHC(0.20590000000000031866,3.3450999999999993936,-1.4401999999999997825,0.17076666666666664973),
82 s12pmHC(-0.77235999999999901328,4.2626599999999991117,-1.9008899999999997323,0.30192266666666663379,-0.012270833333333331986),
83 s12ppHC(-0.75724999999999975664,2.0934399999999998565,-0.3803099999999999814),
84 s12zzHC(-0.89599999999996965072,7.882999999999978632,-7.1049999999999961928,1.884333333333333089),
85 s02pzHC(-1.0579999999999967036,11.113999999999994089,-8.5259999999999990196,2.0051666666666666525),
86 s02pmHC(2.4009000000012553286,-7.7680000000013376183,20.619000000000433505,-16.429666666666723928,5.2525708333333363472,-0.58969166666666670206),
87 s12mzHC(-0.21858699999999976269,1.9148999999999999722,-0.31727500000000001065,-0.027695000000000000486)
88 {
89 }

Member Function Documentation

◆ calculateNNAngularSlope()

G4double G4INCL::CrossSectionsMultiPions::calculateNNAngularSlope ( G4double  energyCM,
G4int  iso 
)
virtualinherited

Calculate the slope of the NN DDXS.

Parameters
energyCMenergy in the CM frame, in MeV
isototal isospin of the system
Returns
the slope of the angular distribution

Implements G4INCL::ICrossSections.

Definition at line 826 of file G4INCLCrossSectionsMultiPions.cc.

826 {
827 G4double x = 0.001 * pl; // Change to GeV
828 if(iso != 0) {
829 if(pl <= 2000.0) {
830 x = std::pow(x, 8);
831 return 5.5e-6 * x/(7.7 + x);
832 } else {
833 return (5.34 + 0.67*(x - 2.0)) * 1.0e-6;
834 }
835 } else {
836 if(pl < 800.0) {
837 G4double b = (7.16 - 1.63*x) * 1.0e-6;
838 return b/(1.0 + std::exp(-(x - 0.45)/0.05));
839 } else if(pl < 1100.0) {
840 return (9.87 - 4.88 * x) * 1.0e-6;
841 } else {
842 return (3.68 + 0.76*x) * 1.0e-6;
843 }
844 }
845 return 0.0; // Should never reach this point
846 }
G4double
double G4double
Definition: G4Types.hh:83

◆ elastic()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::elastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

new elastic particle-particle cross section

Reimplemented from G4INCL::CrossSectionsMultiPions.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 118 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

118 {
119 if((p1->isNucleon()||p1->isDelta()) && (p2->isNucleon()||p2->isDelta())){
120 return CrossSectionsMultiPions::elastic(p1, p2);
121 }
122 else if ((p1->isNucleon() && p2->isPion()) || (p2->isNucleon() && p1->isPion())){
123 return CrossSectionsMultiPions::elastic(p1, p2);
124 }
125 else if ((p1->isNucleon() && p2->isEta()) || (p2->isNucleon() && p1->isEta())){
126 return etaNElastic(p1, p2);
127 }
128 else if ((p1->isNucleon() && p2->isOmega()) || (p2->isNucleon() && p1->isOmega())){
129 return omegaNElastic(p1, p2);
130 }
131 else {
132 return 0.0;
133 }
134 }
G4INCL::CrossSectionsMultiPionsAndResonances::etaNElastic
virtual G4double etaNElastic(Particle const *const p1, Particle const *const p2)
Cross sections for mesonic resonance absorption on nucleon - elastic Channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:340
G4INCL::CrossSectionsMultiPionsAndResonances::omegaNElastic
virtual G4double omegaNElastic(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:405
G4INCL::CrossSectionsMultiPions::elastic
virtual G4double elastic(Particle const *const p1, Particle const *const p2)
Elastic particle-particle cross section.
Definition: G4INCLCrossSectionsMultiPions.cc:807

References G4INCL::CrossSectionsMultiPions::elastic(), etaNElastic(), G4INCL::Particle::isDelta(), G4INCL::Particle::isEta(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isOmega(), G4INCL::Particle::isPion(), and omegaNElastic().

Referenced by total().

◆ etaNElastic()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::etaNElastic ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtual

Cross sections for mesonic resonance absorption on nucleon - elastic Channel.

Definition at line 340 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

340 {
341 //
342 // Eta-Nucleon elastic cross sections
343 //
344// assert((particle1->isNucleon() && particle2->isEta()) || (particle1->isEta() && particle2->isNucleon()));
345
346 G4double sigma=0.;
347
348 const Particle *eta;
349 const Particle *nucleon;
350
351 if (particle1->isEta()) {
352 eta = particle1;
353 nucleon = particle2;
354 }
355 else {
356 eta = particle2;
357 nucleon = particle1;
358 }
359
360 const G4double pLab = KinematicsUtils::momentumInLab(eta, nucleon);
361
362 if (pLab < 700.)
363 sigma = 3.6838e-15*std::pow(pLab,6) - 9.7815e-12*std::pow(pLab,5) + 9.7914e-9*std::pow(pLab,4) -
364 4.3222e-06*std::pow(pLab,3) + 7.9188e-04*std::pow(pLab,2) - 1.8379e-01*pLab + 84.965;
365 else if (pLab < 1400.)
366 sigma = 3.562630e-16*std::pow(pLab,6) - 2.384766e-12*std::pow(pLab,5) + 6.601312e-9*std::pow(pLab,4) -
367 9.667078e-06*std::pow(pLab,3) + 7.894845e-03*std::pow(pLab,2) - 3.409200*pLab + 609.8501;
368 else if (pLab < 2025.)
369 sigma = -1.041950E-03*pLab + 2.110529E+00;
370 else
371 sigma=0.;
372
373 if (sigma < 0.) sigma = 0.;
374 return sigma; // Parameterization from the ANL-Osaka DCC model [PRC88(2013)035209]
375 }
G4INCL::KinematicsUtils::momentumInLab
G4double momentumInLab(Particle const *const p1, Particle const *const p2)
gives the momentum in the lab frame of two particles.
Definition: G4INCLKinematicsUtils.cc:135
G4InuclParticleNames::nucleon
G4bool nucleon(G4int ityp)
Definition: G4InuclParticleNames.hh:94

References G4INCL::Particle::isEta(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by elastic(), and G4INCL::CrossSectionsStrangeness::elastic().

◆ etaNToPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross sections for mesonic resonance absorption on nucleon - piN Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 256 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

256 {
257 //
258 // Eta-Nucleon producing Pion cross sections
259 //
260// assert((particle1->isNucleon() && particle2->isEta()) || (particle1->isEta() && particle2->isNucleon()));
261
262 const Particle *eta;
263 const Particle *nucleon;
264
265 if (particle1->isEta()) {
266 eta = particle1;
267 nucleon = particle2;
268 }
269 else {
270 eta = particle2;
271 nucleon = particle1;
272 }
273
274 const G4double pLab = KinematicsUtils::momentumInLab(eta, nucleon);
275 G4double sigma=0.;
276
277 if (pLab <= 574.)
278 sigma= 1.511147E-13*std::pow(pLab,6)- 3.603636E-10*std::pow(pLab,5)+ 3.443487E-07*std::pow(pLab,4)- 1.681980E-04*std::pow(pLab,3)+ 4.437913E-02*std::pow(pLab,2)- 6.172108E+00*pLab+ 4.031449E+02;
279 else if (pLab <= 850.)
280 sigma= -8.00018E-14*std::pow(pLab,6)+ 3.50041E-10*std::pow(pLab,5)- 6.33891E-07*std::pow(pLab,4)+ 6.07658E-04*std::pow(pLab,3)- 3.24936E-01*std::pow(pLab,2)+ 9.18098E+01*pLab- 1.06943E+04;
281 else if (pLab <= 1300.)
282 sigma= 6.56364E-09*std::pow(pLab,3)- 2.07653E-05*std::pow(pLab,2)+ 1.84148E-02*pLab- 1.70427E+00;
283 else {
284 G4double ECM=KinematicsUtils::totalEnergyInCM(eta, nucleon);
285 G4double massPiZero=ParticleTable::getINCLMass(PiZero);
286 G4double massPiMinus=ParticleTable::getINCLMass(PiMinus);
287 G4double massProton=ParticleTable::getINCLMass(Proton);
288 G4double masseta;
289 G4double massnucleon;
290 G4double pCM_eta;
291 masseta=eta->getMass();
292 massnucleon=nucleon->getMass();
293 pCM_eta=KinematicsUtils::momentumInCM(ECM, masseta, massnucleon);
294 G4double pCM_PiZero=KinematicsUtils::momentumInCM(ECM, massPiZero, massProton);
295 G4double pCM_PiMinus=KinematicsUtils::momentumInCM(ECM, massPiMinus, massProton); // = pCM_PiPlus (because massPiMinus = massPiPlus)
296 sigma = (piMinuspToEtaN(ECM)/2.) * std::pow((pCM_PiZero/pCM_eta), 2) + piMinuspToEtaN(ECM) * std::pow((pCM_PiMinus/pCM_eta), 2);
297 }
298 if (sigma < 0.) sigma=0.;
299
300 return sigma;
301 }
G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN
G4double piMinuspToEtaN(Particle const *const p1, Particle const *const p2)
Internal function for pion cross sections.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:505
G4INCL::KinematicsUtils::totalEnergyInCM
G4double totalEnergyInCM(Particle const *const p1, Particle const *const p2)
Definition: G4INCLKinematicsUtils.cc:94
G4INCL::KinematicsUtils::momentumInCM
G4double momentumInCM(Particle const *const p1, Particle const *const p2)
gives the momentum in the CM frame of two particles.
Definition: G4INCLKinematicsUtils.cc:107
G4INCL::ParticleTable::getINCLMass
G4double getINCLMass(const G4int A, const G4int Z, const G4int S)
Get INCL nuclear mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:809

References G4INCL::ParticleTable::getINCLMass(), G4INCL::Particle::getMass(), G4INCL::Particle::isEta(), G4INCL::KinematicsUtils::momentumInCM(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::PiMinus, piMinuspToEtaN(), G4INCL::PiZero, G4INCL::Proton, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by etaNToPiPiN(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ etaNToPiPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiPiN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross sections for mesonic resonance absorption on nucleon - pipiN Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 303 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

303 {
304 //
305 // Eta-Nucleon producing Two Pions cross sections
306 //
307// assert((particle1->isNucleon() && particle2->isEta()) || (particle1->isEta() && particle2->isNucleon()));
308
309 G4double sigma=0.;
310
311 const Particle *eta;
312 const Particle *nucleon;
313
314 if (particle1->isEta()) {
315 eta = particle1;
316 nucleon = particle2;
317 }
318 else {
319 eta = particle2;
320 nucleon = particle1;
321 }
322
323 const G4double pLab = KinematicsUtils::momentumInLab(eta, nucleon);
324
325 if (pLab < 450.)
326 sigma = 2.01854221E-13*std::pow(pLab,6) - 3.49750459E-10*std::pow(pLab,5) + 2.46011585E-07*std::pow(pLab,4) - 9.01422901E-05*std::pow(pLab,3) + 1.83382964E-02*std::pow(pLab,2) - 2.03113098E+00*pLab + 1.10358550E+02;
327 else if (pLab < 600.)
328 sigma = 2.01854221E-13*std::pow(450.,6) - 3.49750459E-10*std::pow(450.,5) + 2.46011585E-07*std::pow(450.,4) - 9.01422901E-05*std::pow(450.,3) + 1.83382964E-02*std::pow(450.,2) - 2.03113098E+00*450. + 1.10358550E+02;
329 else if (pLab <= 1300.)
330 sigma = -6.32793049e-16*std::pow(pLab,6) + 3.95985900e-12*std::pow(pLab,5) - 1.01727714e-8*std::pow(pLab,4) +
331 1.37055547e-05*std::pow(pLab,3) - 1.01830486e-02*std::pow(pLab,2) + 3.93492126*pLab - 609.447145;
332 else
333 sigma = etaNToPiN(particle1,particle2);
334
335 if (sigma < 0.) sigma = 0.;
336 return sigma; // Parameterization from the ANL-Osaka DCC model [PRC88(2013)035209] - eta p --> "pi+pi0 n" + "pi0 pi0 p" total XS
337 }
G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN
virtual G4double etaNToPiN(Particle const *const p1, Particle const *const p2)
Cross sections for mesonic resonance absorption on nucleon - piN Channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:256

References etaNToPiN(), G4INCL::Particle::isEta(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by total(), and G4INCL::CrossSectionsStrangeness::total().

◆ etaPrimeNToPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for EtaPrimeN->PiN.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 493 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

493 {
494#else
495 G4double CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN(Particle const * const particle1, Particle const * const particle2) {
496#endif
497 //
498 // EtaPrime-Nucleon producing Pion cross sections
499 //
500// assert((particle1->isNucleon() && particle2->isEtaPrime()) || (particle1->isEtaPrime() && particle2->isNucleon()));
501
502 return 0.;
503 }
G4INCL::CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN
virtual G4double etaPrimeNToPiN(Particle const *const p1, Particle const *const p2)
Cross section for EtaPrimeN->PiN.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:493

References etaPrimeNToPiN().

Referenced by etaPrimeNToPiN(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ NDeltaToDeltaLK()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToDeltaLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1424 of file G4INCLCrossSectionsMultiPions.cc.

1424 {
1425 // Nucleon-Delta producing Delta Lambda Kaon cross section
1426 return 0;
1427 }

◆ NDeltaToDeltaSK()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToDeltaSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1428 of file G4INCLCrossSectionsMultiPions.cc.

1428 {
1429 // Nucleon-Delta producing Delta Sigma Kaon cross section
1430 return 0;
1431 }

◆ NDeltaToNLK()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToNLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-Delta to Stange particles cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1416 of file G4INCLCrossSectionsMultiPions.cc.

1416 {
1417 // Nucleon-Delta producing Nucleon Lambda Kaon cross section
1418 return 0;
1419 }

◆ NDeltaToNN()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToNN ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Cross section for NDelta->NN.

Implements G4INCL::ICrossSections.

Definition at line 749 of file G4INCLCrossSectionsMultiPions.cc.

749 {
750 const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
751 if(isospin==4 || isospin==-4) return 0.0;
752
753 G4double s = KinematicsUtils::squareTotalEnergyInCM(p1, p2);
754 G4double Ecm = std::sqrt(s);
755 G4int deltaIsospin;
756 G4double deltaMass;
757 if(p1->isDelta()) {
758 deltaIsospin = ParticleTable::getIsospin(p1->getType());
759 deltaMass = p1->getMass();
760 } else {
761 deltaIsospin = ParticleTable::getIsospin(p2->getType());
762 deltaMass = p2->getMass();
763 }
764
765 if(Ecm <= 938.3 + deltaMass) {
766 return 0.0;
767 }
768
769 if(Ecm < 938.3 + deltaMass + 2.0) {
770 Ecm = 938.3 + deltaMass + 2.0;
771 s = Ecm*Ecm;
772 }
773
774 const G4double x = (s - 4.*ParticleTable::effectiveNucleonMass2) /
775 (s - std::pow(ParticleTable::effectiveNucleonMass + deltaMass, 2));
776 const G4double y = s/(s - std::pow(deltaMass - ParticleTable::effectiveNucleonMass, 2));
777 /* Concerning the way we calculate the lab momentum, see the considerations
778 * in CrossSections::elasticNNLegacy().
779 */
780 G4double sDelta;
781 const G4double xsiso2=NNInelasticIso(Ecm, 2);
782 if (isospin != 0)
783 sDelta = NNOnePiOrDelta(Ecm, isospin, xsiso2);
784 else {
785 const G4double xsiso0=NNInelasticIso(Ecm, 0);
786 sDelta = 0.25*(NNOnePiOrDelta(Ecm, 0, xsiso0)+ NNOnePiOrDelta(Ecm, 2, xsiso2));
787 }
788 G4double result = 0.5 * x * y * sDelta;
789 /* modification for pion-induced cascade (see JC and MC LEMAIRE,NPA489(88)781
790 * result=3.*result
791 * pi absorption increased also for internal pions (7/3/01)
792 */
793 result *= 3.*(32.0 + isospin * isospin * (deltaIsospin * deltaIsospin - 5))/64.0;
794 result /= 1.0 + 0.25 * (isospin * isospin);
795 return result;
796 }
s
static constexpr double s
Definition: G4SIunits.hh:154
G4int
int G4int
Definition: G4Types.hh:85
G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta
virtual G4double NNOnePiOrDelta(const G4double ener, const G4int iso, const G4double xsiso)
Cross section for direct 1-pion production + delta production - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPions.cc:248
G4INCL::CrossSectionsMultiPions::NNInelasticIso
G4double NNInelasticIso(const G4double ener, const G4int iso)
Internal implementation of the isospin dependent NN reaction cross section.
Definition: G4INCLCrossSectionsMultiPions.cc:224
G4INCL::KinematicsUtils::squareTotalEnergyInCM
G4double squareTotalEnergyInCM(Particle const *const p1, Particle const *const p2)
Definition: G4INCLKinematicsUtils.cc:98
G4INCL::ParticleTable::effectiveNucleonMass2
const G4double effectiveNucleonMass2
Definition: G4INCLParticleTable.hh:70
G4INCL::ParticleTable::getIsospin
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
Definition: G4INCLParticleTable.cc:478
G4INCL::ParticleTable::effectiveNucleonMass
const G4double effectiveNucleonMass
Definition: G4INCLParticleTable.hh:69

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::ParticleTable::effectiveNucleonMass2, G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getMass(), G4INCL::Particle::getType(), G4INCL::Particle::isDelta(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), s, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::NNTot(), G4INCL::CrossSectionsMultiPions::total(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ NDeltaToNNKKb()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToNNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1433 of file G4INCLCrossSectionsMultiPions.cc.

1433 {
1434 // Nucleon-Delta producing Nucleon-Nucleon Kaon antiKaon cross section
1435 return 0;
1436 }

◆ NDeltaToNSK()

G4double G4INCL::CrossSectionsMultiPions::NDeltaToNSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1420 of file G4INCLCrossSectionsMultiPions.cc.

1420 {
1421 // Nucleon-Delta producing Nucleon Sigma Kaon cross section
1422 return 0;
1423 }

◆ NKbelastic()

G4double G4INCL::CrossSectionsMultiPions::NKbelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1352 of file G4INCLCrossSectionsMultiPions.cc.

1352 {
1353 //
1354 // antiKaon-Nucleon elastic cross sections
1355 //
1356 return 0.;
1357 }

◆ NKbToL2pi()

G4double G4INCL::CrossSectionsMultiPions::NKbToL2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1574 of file G4INCLCrossSectionsMultiPions.cc.

1574 {
1575 //
1576 // Nucleon-antiKaon producing Lambda-2pion cross sections
1577 //
1578 return 0.;
1579 }

◆ NKbToLpi()

G4double G4INCL::CrossSectionsMultiPions::NKbToLpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1560 of file G4INCLCrossSectionsMultiPions.cc.

1560 {
1561 //
1562 // Nucleon-antiKaon producing Lambda-pion cross sections
1563 //
1564 return 0.;
1565 }

◆ NKbToNKb()

G4double G4INCL::CrossSectionsMultiPions::NKbToNKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-antiKaon quasi-elastic and inelastic cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1546 of file G4INCLCrossSectionsMultiPions.cc.

1546 {
1547 //
1548 // Nucleon-antiKaon quasi-elastic cross sections
1549 //
1550 return 0.;
1551 }

◆ NKbToNKb2pi()

G4double G4INCL::CrossSectionsMultiPions::NKbToNKb2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1588 of file G4INCLCrossSectionsMultiPions.cc.

1588 {
1589 //
1590 // Nucleon-antiKaon producing Nucleon-antiKaon-2pion cross sections
1591 //
1592 return 0.;
1593 }

◆ NKbToNKbpi()

G4double G4INCL::CrossSectionsMultiPions::NKbToNKbpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1581 of file G4INCLCrossSectionsMultiPions.cc.

1581 {
1582 //
1583 // Nucleon-antiKaon producing Nucleon-antiKaon-pion cross sections
1584 //
1585 return 0.;
1586 }

◆ NKbToS2pi()

G4double G4INCL::CrossSectionsMultiPions::NKbToS2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1567 of file G4INCLCrossSectionsMultiPions.cc.

1567 {
1568 //
1569 // Nucleon-antiKaon producing Sigma-2pion cross sections
1570 //
1571 return 0.;
1572 }

◆ NKbToSpi()

G4double G4INCL::CrossSectionsMultiPions::NKbToSpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1553 of file G4INCLCrossSectionsMultiPions.cc.

1553 {
1554 //
1555 // Nucleon-antiKaon producing Sigma-pion cross sections
1556 //
1557 return 0.;
1558 }

◆ NKelastic()

G4double G4INCL::CrossSectionsMultiPions::NKelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1345 of file G4INCLCrossSectionsMultiPions.cc.

1345 {
1346 //
1347 // Kaon-Nucleon elastic cross sections
1348 //
1349 return 0.;
1350 }

◆ NKToNK()

G4double G4INCL::CrossSectionsMultiPions::NKToNK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-Kaon quasi-elastic and inelastic cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1525 of file G4INCLCrossSectionsMultiPions.cc.

1525 {
1526 //
1527 // Nucleon-Kaon quasi-elastic cross sections
1528 //
1529 return 0.;
1530 }

◆ NKToNK2pi()

G4double G4INCL::CrossSectionsMultiPions::NKToNK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1539 of file G4INCLCrossSectionsMultiPions.cc.

1539 {
1540 //
1541 // Nucleon-Kaon producing Nucleon-Kaon-2pion cross sections
1542 //
1543 return 0.;
1544 }

◆ NKToNKpi()

G4double G4INCL::CrossSectionsMultiPions::NKToNKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1532 of file G4INCLCrossSectionsMultiPions.cc.

1532 {
1533 //
1534 // Nucleon-Kaon producing Nucleon-Kaon-pion cross sections
1535 //
1536 return 0.;
1537 }

◆ NLToNS()

G4double G4INCL::CrossSectionsMultiPions::NLToNS ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-Hyperon cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1504 of file G4INCLCrossSectionsMultiPions.cc.

1504 {
1505 //
1506 // Nucleon-Hyperon multiplet changing cross sections
1507 //
1508 return 0.;
1509 }

◆ NNElastic()

G4double G4INCL::CrossSectionsMultiPions::NNElastic ( Particle const *const  part1,
Particle const *const  part2 
)
protectedinherited

Internal implementation of the NN elastic cross section.

Definition at line 85 of file G4INCLCrossSectionsMultiPions.cc.

85 {
86
87 /* The NN cross section is parametrised as a function of the lab momentum
88 * of one of the nucleons. For NDelta or DeltaDelta, the physical
89 * assumption is that the cross section is the same as NN *for the same
90 * total CM energy*. Thus, we calculate s from the particles involved, and
91 * we convert this value to the lab momentum of a nucleon *as if this were
92 * an NN collision*.
93 */
94 const G4double s = KinematicsUtils::squareTotalEnergyInCM(part1, part2);
95
96 if(part1->isNucleon() && part2->isNucleon()) { // NN
97 const G4int i = ParticleTable::getIsospin(part1->getType())
98 + ParticleTable::getIsospin(part2->getType());
99 return NNElasticFixed(s, i);
100 }
101 else { // Nucleon-Delta and Delta-Delta
102 const G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
103 if (plab < 0.440) {
104 return 34.*std::pow(plab/0.4, (-2.104));
105 }
106 else if (plab < 0.800) {
107 return 23.5+1000.*std::pow(plab-0.7, 4);
108 }
109 else if (plab <= 2.0) {
110 return 1250./(50.+plab)-4.*std::pow(plab-1.3, 2);
111 }
112 else {
113 return 77./(plab+1.5);
114 }
115 }
116 }
G4INCL::CrossSectionsMultiPions::NNElasticFixed
G4double NNElasticFixed(const G4double s, const G4int i)
Internal implementation of the NN elastic cross section with fixed isospin.
Definition: G4INCLCrossSectionsMultiPions.cc:118

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::CrossSectionsMultiPions::NNElasticFixed(), s, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::CrossSectionsTruncatedMultiPions::elastic(), and G4INCL::CrossSectionsMultiPions::NNFourPi().

◆ NNElasticFixed()

G4double G4INCL::CrossSectionsMultiPions::NNElasticFixed ( const G4double  s,
const G4int  i 
)
protectedinherited

Internal implementation of the NN elastic cross section with fixed isospin.

Definition at line 118 of file G4INCLCrossSectionsMultiPions.cc.

118 {
119
120 /* From NNElastic, with isospin fixed and for NN only.
121 */
122
123 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
124 G4double sigma = 0.;
125
126 if (i == 0) { // pn
127 if (plab < 0.446) {
128 G4double alp=std::log(plab);
129 sigma = 6.3555*std::exp(-3.2481*alp-0.377*alp*alp);
130 }
131 else if (plab < 0.851) {
132 sigma = 33.+196.*std::pow(std::fabs(plab-0.95),2.5);
133 }
134 else if (plab <= 2.0) {
135 sigma = 31./std::sqrt(plab);
136 }
137 else {
138 sigma = 77./(plab+1.5);
139 }
140 //if(plab < 0.9 && plab > 0.802) sigma -= 0.1387*std::exp(-std::pow((plab-0.861),2)/0.0006861); //correction if totalcx-sumcx < 0.1
141 //if(plab < 1.4 && plab > 1.31) sigma -= 0.1088*std::exp(-std::pow((plab-1.35),2)/0.00141); //correction if totalcx-sumcx < 0.1
142 return sigma;
143 }
144 else { // pp and nn
145 if (plab < 0.440) {
146 return 34.*std::pow(plab/0.4, (-2.104));
147 }
148 else if (plab < 0.8067) {
149 return 23.5+1000.*std::pow(plab-0.7, 4);
150 }
151 else if (plab <= 2.0) {
152 return 1250./(50.+plab)-4.*std::pow(plab-1.3, 2);
153 }
154 else if (plab <= 3.0956) {
155 return 77./(plab+1.5);
156 }
157 else {
158 G4double alp=std::log(plab);
159 return 11.2+25.5*std::pow(plab, -1.12)+0.151*std::pow(alp, 2)-1.62*alp;
160 }
161 }
162 }

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::KinematicsUtils::momentumInLab(), and s.

Referenced by G4INCL::CrossSectionsMultiPions::NNElastic(), and G4INCL::CrossSectionsMultiPions::NNInelasticIso().

◆ NNFourPi()

G4double G4INCL::CrossSectionsMultiPions::NNFourPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtualinherited

Cross section for direct 4-pion production - NN entrance channel.

Definition at line 524 of file G4INCLCrossSectionsMultiPions.cc.

524 {
525 const G4double s = KinematicsUtils::squareTotalEnergyInCM(particle1, particle2);
526 if(s<6.25E6)
527 return 0.;
528 const G4double sigma = NNTot(particle1, particle2) - NNElastic(particle1, particle2) - NNOnePiOrDelta(particle1, particle2) - NNTwoPi(particle1, particle2) - NNThreePi(particle1, particle2);
529 return ((sigma>1.e-9) ? sigma : 0.);
530 }
G4INCL::CrossSectionsMultiPions::NNTot
G4double NNTot(Particle const *const part1, Particle const *const part2)
Internal implementation of the NN total cross section.
Definition: G4INCLCrossSectionsMultiPions.cc:164
G4INCL::CrossSectionsMultiPions::NNTwoPi
virtual G4double NNTwoPi(const G4double ener, const G4int iso, const G4double xsiso)
Cross section for direct 2-pion production - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPions.cc:331
G4INCL::CrossSectionsMultiPions::NNElastic
G4double NNElastic(Particle const *const part1, Particle const *const part2)
Internal implementation of the NN elastic cross section.
Definition: G4INCLCrossSectionsMultiPions.cc:85
G4INCL::CrossSectionsMultiPions::NNThreePi
virtual G4double NNThreePi(const G4double ener, const G4int iso, const G4double xsiso, const G4double xs1pi, const G4double xs2pi)
Cross section for direct 3-pion production - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPions.cc:423

References G4INCL::CrossSectionsMultiPions::NNElastic(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsMultiPions::NNTot(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), s, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::NNToxPiNN().

◆ NNInelasticIso()

G4double G4INCL::CrossSectionsMultiPions::NNInelasticIso ( const G4double  ener,
const G4int  iso 
)
protectedinherited

Internal implementation of the isospin dependent NN reaction cross section.

Definition at line 224 of file G4INCLCrossSectionsMultiPions.cc.

224 {
225
226 const G4double s = ener*ener;
227 G4double sincl;
228
229 if (iso != 0) {
230 if(s>=4074595.287720512986) { // plab>800 MeV/c
231 sincl = NNTotFixed(s, 2)-NNElasticFixed(s, 2);
232 }
233 else {
234 sincl = 0. ;
235 }
236 } else {
237 if(s>=4074595.287720512986) { // plab>800 MeV/c
238 sincl = 2*(NNTotFixed(s, 0)-NNElasticFixed(s, 0))-(NNTotFixed(s, 2)-NNElasticFixed(s, 2));
239 }
240 else {
241 return 0. ;
242 }
243 }
244 if (sincl < 0.) sincl = 0.;
245 return sincl;
246 }
G4INCL::CrossSectionsMultiPions::NNTotFixed
G4double NNTotFixed(const G4double s, const G4int i)
Internal implementation of the NN total cross section with fixed isospin.
Definition: G4INCLCrossSectionsMultiPions.cc:181

References G4INCL::CrossSectionsMultiPions::NNElasticFixed(), G4INCL::CrossSectionsMultiPions::NNTotFixed(), and s.

Referenced by G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NNOnePi(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), NNToNDeltaEta(), NNToNDeltaOmega(), G4INCL::CrossSectionsStrangeness::NNToNLK2pi(), G4INCL::CrossSectionsStrangeness::NNToNLKpi(), NNToNNEtaFourPi(), NNToNNEtaOnePi(), NNToNNEtaOnePiOrDelta(), NNToNNEtaThreePi(), NNToNNEtaTwoPi(), NNToNNEtaxPi(), NNToNNOmegaFourPi(), NNToNNOmegaOnePi(), NNToNNOmegaOnePiOrDelta(), NNToNNOmegaThreePi(), NNToNNOmegaTwoPi(), NNToNNOmegaxPi(), G4INCL::CrossSectionsStrangeness::NNToNSK2pi(), G4INCL::CrossSectionsStrangeness::NNToNSKpi(), and G4INCL::CrossSectionsMultiPions::NNTwoPi().

◆ NNOnePi()

G4double G4INCL::CrossSectionsMultiPions::NNOnePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtualinherited

Cross section for direct 1-pion production - NN entrance channel.

Definition at line 455 of file G4INCLCrossSectionsMultiPions.cc.

455 {
456 // Cross section for nucleon-nucleon directly producing one pion
457
458 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
459 if (iso!=0) // If pp or nn we choose to always pass by the N-N to N-Delta channel
460 return 0.;
461
462 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
463
464 const G4double xsiso2=NNInelasticIso(ener, 2);
465 const G4double xsiso0=NNInelasticIso(ener, 0);
466 return 0.25*(NNOnePiOrDelta(ener, 0, xsiso0)+ NNOnePiOrDelta(ener, 2, xsiso2));
467 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::NNToxPiNN().

◆ NNOnePiOrDelta() [1/2]

G4double G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta ( const G4double  ener,
const G4int  iso,
const G4double  xsiso 
)
protectedvirtualinherited

Cross section for direct 1-pion production + delta production - NN entrance channel.

Definition at line 248 of file G4INCLCrossSectionsMultiPions.cc.

248 {
249
250 /* Article J. Physique 48 (1987)1901-1924 "Energy dependence of
251 nucleon-cucleon inelastic total cross-sections."
252 J. Bystricky, P. La France, F. Lehar, F. Perrot, T. Siemiarczuk & P. Winternitz
253 S11PZ= section pp->pp pi0
254 S01PP= section pp->pn pi+
255 S01PZ= section pn->pn pi0
256 S11PM= section pn->pp pi-
257 S= X-Section, 1st number : 1 if pp and 0 if pn
258 2nd number = number of pions, PP= pi+; PZ= pi0 ; PM= pi-
259 */
260
261 const G4double s = ener*ener;
262 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
263
264 G4double snnpit1=0.;
265 G4double snnpit=0.;
266 G4double s11pz=0.;
267 G4double s01pp=0.;
268 G4double s01pz=0.;
269 G4double s11pm=0.;
270
271 if ((iso != 0) && (plab < 2.1989)) {
272 snnpit = xsiso - NNTwoPi(ener, iso, xsiso);
273 if (snnpit < 1.e-8) snnpit=0.;
274 return snnpit;
275 }
276 else if ((iso == 0) && (plab < 1.7369)) {
277 snnpit = xsiso;
278 if (snnpit < 1.e-8) snnpit=0.;
279 return snnpit;
280 }
281
282//s11pz
283 if (plab > 18.) {
284 s11pz=55.185/std::pow((0.1412*plab+5),2);
285 }
286 else if (plab > 13.9) {
287 G4double alp=std::log(plab);
288 s11pz=6.67-13.3*std::pow(plab, -6.18)+0.456*alp*alp-3.29*alp;
289 }
290 else if (plab >= 0.7765) {
291 const G4double b=BystrickyEvaluator<7>::eval(plab,s11pzOOT,s11pzHC);
292 s11pz=b*b;
293 }
294//s01pp
295 if (plab >= 0.79624) {
296 const G4double b=BystrickyEvaluator<8>::eval(plab,s01ppOOT,s01ppHC);
297 s01pp=b*b;
298 }
299
300// channel T=1
301 snnpit1=s11pz+s01pp;
302 if (snnpit1 < 1.e-8) snnpit1=0.;
303 if (iso != 0) {
304 return snnpit1;
305 }
306
307//s01pz
308 if (plab > 4.5) {
309 s01pz=15289.4/std::pow((11.573*plab+5),2);
310 }
311 else if (plab >= 0.777) {
312 const G4double b=BystrickyEvaluator<4>::eval(plab,s01pzOOT,s01pzHC);
313 s01pz=b*b;
314 }
315//s11pm
316 if (plab > 14.) {
317 s11pm=46.68/std::pow((0.2231*plab+5),2);
318 }
319 else if (plab >= 0.788) {
320 const G4double b=BystrickyEvaluator<4>::eval(plab,s11pmOOT,s11pmHC);
321 s11pm=b*b;
322 }
323
324// channel T=0
325// snnpit=s01pz+2*s11pm-snnpit1; //modif 2*(s01pz+2*s11pm)-snnpit1;
326 snnpit = 2*(s01pz+2*s11pm)-snnpit1;
327 if (snnpit < 1.e-8) snnpit=0.;
328 return snnpit;
329 }
G4INCL::CrossSectionsMultiPions::s01pzHC
const HornerC4 s01pzHC
Horner coefficients for s01pz.
Definition: G4INCLCrossSectionsMultiPions.hh:197
G4INCL::CrossSectionsMultiPions::s11pmOOT
static const G4double s11pmOOT
One over threshold for s11pm.
Definition: G4INCLCrossSectionsMultiPions.hh:220
G4INCL::CrossSectionsMultiPions::s01pzOOT
static const G4double s01pzOOT
One over threshold for s01pz.
Definition: G4INCLCrossSectionsMultiPions.hh:218
G4INCL::CrossSectionsMultiPions::s01ppOOT
static const G4double s01ppOOT
One over threshold for s01pp.
Definition: G4INCLCrossSectionsMultiPions.hh:216
G4INCL::CrossSectionsMultiPions::s11pzOOT
static const G4double s11pzOOT
One over threshold for s11pz.
Definition: G4INCLCrossSectionsMultiPions.hh:214
G4INCL::CrossSectionsMultiPions::s01ppHC
const HornerC8 s01ppHC
Horner coefficients for s01pp.
Definition: G4INCLCrossSectionsMultiPions.hh:195
G4INCL::CrossSectionsMultiPions::s11pmHC
const HornerC4 s11pmHC
Horner coefficients for s11pm.
Definition: G4INCLCrossSectionsMultiPions.hh:199
G4INCL::CrossSectionsMultiPions::s11pzHC
const HornerC7 s11pzHC
Horner coefficients for s11pz.
Definition: G4INCLCrossSectionsMultiPions.hh:193
G4INCL::BystrickyEvaluator::eval
static G4double eval(const G4double pLab, const G4double oneOverThreshold, HornerCoefficients< N > const &coeffs)
Definition: G4INCLCrossSectionsMultiPions.cc:48

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::BystrickyEvaluator< N >::eval(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), s, G4INCL::CrossSectionsMultiPions::s01ppHC, G4INCL::CrossSectionsMultiPions::s01ppOOT, G4INCL::CrossSectionsMultiPions::s01pzHC, G4INCL::CrossSectionsMultiPions::s01pzOOT, G4INCL::CrossSectionsMultiPions::s11pmHC, G4INCL::CrossSectionsMultiPions::s11pmOOT, G4INCL::CrossSectionsMultiPions::s11pzHC, and G4INCL::CrossSectionsMultiPions::s11pzOOT.

Referenced by G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NNFourPi(), G4INCL::CrossSectionsMultiPions::NNOnePi(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsMultiPions::NNToNDelta(), G4INCL::CrossSectionsStrangeness::NNToNLK2pi(), G4INCL::CrossSectionsStrangeness::NNToNLKpi(), NNToNNEtaOnePi(), NNToNNEtaOnePiOrDelta(), NNToNNEtaThreePi(), NNToNNOmegaOnePi(), NNToNNOmegaOnePiOrDelta(), NNToNNOmegaThreePi(), G4INCL::CrossSectionsStrangeness::NNToNSK2pi(), G4INCL::CrossSectionsStrangeness::NNToNSKpi(), and G4INCL::CrossSectionsMultiPions::NNTwoPi().

◆ NNOnePiOrDelta() [2/2]

G4double G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtualinherited

Cross section for direct 1-pion production - NN entrance channel.

Definition at line 469 of file G4INCLCrossSectionsMultiPions.cc.

469 {
470 // Cross section for nucleon-nucleon directly producing one pion or producing a nucleon-delta pair
471 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
472 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
473
474 const G4double xsiso2=NNInelasticIso(ener, 2);
475 if (iso != 0)
476 return NNOnePiOrDelta(ener, iso, xsiso2);
477 else {
478 const G4double xsiso0=NNInelasticIso(ener, 0);
479 return 0.5*(NNOnePiOrDelta(ener, 0, xsiso0)+ NNOnePiOrDelta(ener, 2, xsiso2));
480 }
481 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNThreePi() [1/2]

G4double G4INCL::CrossSectionsMultiPions::NNThreePi ( const G4double  ener,
const G4int  iso,
const G4double  xsiso,
const G4double  xs1pi,
const G4double  xs2pi 
)
protectedvirtualinherited

Cross section for direct 3-pion production - NN entrance channel.

Definition at line 423 of file G4INCLCrossSectionsMultiPions.cc.

423 {
424
425 const G4double s = ener*ener;
426 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
427
428 G4double snn3pit=0.;
429
430 if (iso == 0) {
431// channel T=0
432 if (plab > 7.2355) {
433 return 46.72/std::pow((plab - 5.8821),2);
434 }
435 else {
436 snn3pit=xsiso-xs1pi-xs2pi;
437 if (snn3pit < 1.e-8) snn3pit=0.;
438 return snn3pit;
439 }
440 }
441 else {
442// channel T=1
443 if (plab > 7.206) {
444 return 5592.92/std::pow((plab+14.9764),2);
445 }
446 else if (plab > 2.1989){
447 snn3pit=xsiso-xs1pi-xs2pi;
448 if (snn3pit < 1.e-8) snn3pit=0.;
449 return snn3pit;
450 }
451 else return snn3pit;
452 }
453 }

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::KinematicsUtils::momentumInLab(), and s.

Referenced by G4INCL::CrossSectionsMultiPions::NNFourPi(), G4INCL::CrossSectionsMultiPions::NNThreePi(), NNToNNEtaThreePi(), NNToNNOmegaThreePi(), and G4INCL::CrossSectionsMultiPions::NNToxPiNN().

◆ NNThreePi() [2/2]

G4double G4INCL::CrossSectionsMultiPions::NNThreePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtualinherited

Cross section for direct 3-pion production - NN entrance channel.

Definition at line 502 of file G4INCLCrossSectionsMultiPions.cc.

502 {
503 //
504 // Nucleon-Nucleon producing one pion cross sections
505 //
506
507 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
508 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
509
510
511 const G4double xsiso2=NNInelasticIso(ener, 2);
512 const G4double xs1pi2=NNOnePiOrDelta(ener, 2, xsiso2);
513 const G4double xs2pi2=NNTwoPi(ener, 2, xsiso2);
514 if (iso != 0)
515 return NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2);
516 else {
517 const G4double xsiso0=NNInelasticIso(ener, 0);
518 const G4double xs1pi0=NNOnePiOrDelta(ener, 0, xsiso0);
519 const G4double xs2pi0=NNTwoPi(ener, 0, xsiso0);
520 return 0.5*(NNThreePi(ener, 0, xsiso0, xs1pi0, xs2pi0)+ NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2));
521 }
522 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToMissingStrangeness()

G4double G4INCL::CrossSectionsMultiPions::NNToMissingStrangeness ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1409 of file G4INCLCrossSectionsMultiPions.cc.

1409 {
1410 //
1411 // Nucleon-Nucleon missing strangeness production cross sections
1412 //
1413 return 0.;
1414 }

◆ NNToNDelta()

G4double G4INCL::CrossSectionsMultiPions::NNToNDelta ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Cross section for Delta production - NN Channel.

Implements G4INCL::ICrossSections.

Definition at line 798 of file G4INCLCrossSectionsMultiPions.cc.

798 {
799// assert(p1->isNucleon() && p2->isNucleon());
800 const G4int isospin = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
801 G4double sigma = NNOnePiOrDelta(p1, p2);
802 if(isospin==0)
803 sigma *= 0.5;
804 return sigma;
805 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), and G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta().

◆ NNToNDeltaEta()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaEta ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for N-Delta-Eta production - NNEta Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1092 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1092 {
1093// assert(p1->isNucleon() && p2->isNucleon());
1094 const G4int i = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1095 const G4double ener=KinematicsUtils::totalEnergyInCM(p1, p2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
1096 if (ener < 2018.563) return 0.;
1097 G4double xsinelas;
1098 if (i!=0)
1099 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1100 else
1101 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1102 if (xsinelas <= 1.e-9) return 0.;
1103 G4double ratio=(NNToNNEta(p1, p2)-NNToNNEtaExclu(p1, p2))/xsinelas;
1104 G4double sigma = NNToNNEtaOnePiOrDelta(p1, p2)*ratio;
1105 if(i==0)
1106 sigma *= 0.5;
1107 return sigma;
1108 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta
virtual G4double NNToNNEta(Particle const *const particle1, Particle const *const particle2)
Cross section for Eta production (inclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:691
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu
virtual G4double NNToNNEtaExclu(Particle const *const particle1, Particle const *const particle2)
Cross section for Eta production (exclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:767
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta
virtual G4double NNToNNEtaOnePiOrDelta(Particle const *const part1, Particle const *const part2)
Cross section for direct 1-pion production - NNEta channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:983

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNEta(), NNToNNEtaExclu(), NNToNNEtaOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNDeltaOmega()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaOmega ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for N-Delta-Eta production - NNOmega Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1241 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1241 {
1242// assert(p1->isNucleon() && p2->isNucleon());
1243//jcd to be removed
1244// return 0.;
1245//jcd
1246 const G4int i = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1247 const G4double ener=KinematicsUtils::totalEnergyInCM(p1, p2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1248 if (ener < 2018.563) return 0.;
1249 G4double xsinelas;
1250 if (i!=0)
1251 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1252 else
1253 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1254 if (xsinelas <= 1.e-9) return 0.;
1255 G4double ratio=(NNToNNOmega(p1, p2)-NNToNNOmegaExclu(p1, p2))/xsinelas;
1256 G4double sigma = NNToNNOmegaOnePiOrDelta(p1, p2)*ratio;
1257 if(i==0)
1258 sigma *= 0.5;
1259 return sigma;
1260 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu
virtual G4double NNToNNOmegaExclu(Particle const *const particle1, Particle const *const particle2)
Cross section for Omega production (exclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:875
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta
virtual G4double NNToNNOmegaOnePiOrDelta(Particle const *const part1, Particle const *const part2)
Cross section for direct 1-pion production - NNOmega channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1127
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega
virtual G4double NNToNNOmega(Particle const *const particle1, Particle const *const particle2)
Cross section for Omega production (inclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:815

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNOmega(), NNToNNOmegaExclu(), NNToNNOmegaOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNLK()

G4double G4INCL::CrossSectionsMultiPions::NNToNLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-Nucleon to Stange particles cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1360 of file G4INCLCrossSectionsMultiPions.cc.

1360 {
1361 //
1362 // Nucleon-Nucleon producing N-Lambda-Kaon cross sections
1363 //
1364 return 0.;
1365 }

◆ NNToNLK2pi()

G4double G4INCL::CrossSectionsMultiPions::NNToNLK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1388 of file G4INCLCrossSectionsMultiPions.cc.

1388 {
1389 //
1390 // Nucleon-Nucleon producing N-Lambda-Kaon-2pion cross sections
1391 //
1392 return 0.;
1393 }

◆ NNToNLKpi()

G4double G4INCL::CrossSectionsMultiPions::NNToNLKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1374 of file G4INCLCrossSectionsMultiPions.cc.

1374 {
1375 //
1376 // Nucleon-Nucleon producing N-Lambda-Kaon-pion cross sections
1377 //
1378 return 0.;
1379 }

◆ NNToNNEta()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta ( Particle const *const  particle1,
Particle const *const  particle2 
)
virtual

Cross section for Eta production (inclusive) - NN entrance channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 691 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

691 {
692
693 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
694 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
695
696 if (iso != 0) {
697 return NNToNNEtaIso(ener, iso);
698 }
699 else {
700 return 0.5*(NNToNNEtaIso(ener, 0)+NNToNNEtaIso(ener, 2));
701 }
702 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso
virtual G4double NNToNNEtaIso(const G4double ener, const G4int iso)
Cross section for One (more) pion production - piN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:638

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), NNToNNEtaIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaEta(), NNToNNEtaFourPi(), NNToNNEtaxPi(), NNToxPiNN(), and G4INCL::CrossSectionsStrangeness::NNToxPiNN().

◆ NNToNNEtaExclu()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu ( Particle const *const  particle1,
Particle const *const  particle2 
)
virtual

Cross section for Eta production (exclusive) - NN entrance channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 767 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

767 {
768
769 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
770 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
771
772 if (iso != 0) {
773 return NNToNNEtaExcluIso(ener, iso);
774 }
775 else {
776 return 0.5*(NNToNNEtaExcluIso(ener, 0)+NNToNNEtaExcluIso(ener, 2));
777 }
778 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso
virtual G4double NNToNNEtaExcluIso(const G4double ener, const G4int iso)
Isotopic Cross section for Eta production (exclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:704

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), NNToNNEtaExcluIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaEta(), NNToNNEtaFourPi(), and NNToNNEtaxPi().

◆ NNToNNEtaExcluIso()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso ( const G4double  ener,
const G4int  iso 
)
protectedvirtual

Isotopic Cross section for Eta production (exclusive) - NN entrance channel.

Definition at line 704 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

704 {
705
706 const G4double Ecm=0.001*ener;
707 G4double sNNEta; // pp->pp+eta
708 G4double sNNEta1; // np->np+eta
709 G4double sNNEta2; // np->d+eta (d wil be considered as np - How far is this right?)
710
711 if(Ecm>=3.875) { // By hand (JCD)
712 sNNEta = -13.008*Ecm*Ecm + 84.531*Ecm + 36.234;
713 }
714 else if(Ecm>=2.725) { // By hand (JCD)
715 sNNEta = -913.2809*std::pow(Ecm,5) + 15564.27*std::pow(Ecm,4) - 105054.9*std::pow(Ecm,3) + 351294.2*std::pow(Ecm,2) - 582413.9*Ecm + 383474.7;
716 }
717 else if(Ecm>=2.575) { // By hand (JCD)
718 sNNEta = -2640.3*Ecm*Ecm + 14692*Ecm - 20225;
719 }
720 else {
721 sNNEta = -147043.497285*std::pow(Ecm,4) + 1487222.5438123*std::pow(Ecm,3) - 5634399.900744*std::pow(Ecm,2) + 9477290.199378*Ecm - 5972174.353438;
722 }
723
724 G4double Mn=ParticleTable::getRealMass(Neutron)/1000.;
725 G4double Mp=ParticleTable::getRealMass(Proton)/1000.;
726 G4double Meta=ParticleTable::getRealMass(Eta)/1000.;
727 G4double Thr0=0.;
728 if (iso > 0) {
729 Thr0=2.*Mp+Meta;
730 }
731 else if (iso < 0) {
732 Thr0=2.*Mn+Meta;
733 }
734 else {
735 Thr0=Mn+Mp+Meta;
736 }
737
738 if (sNNEta < 1.e-9 || Ecm < Thr0) sNNEta = 0.; // Thr0: Ecm threshold
739
740 if (iso != 0) {
741 return sNNEta/1000.; // parameterization in microbarn (not millibarn)!
742 }
743
744 if(Ecm>=3.9) {
745 sNNEta1 = sNNEta;
746 }
747 else if (Ecm >= 3.5) {
748 sNNEta1 = -1916.2*Ecm*Ecm*Ecm + 21556.0*Ecm*Ecm - 80828.0*Ecm + 101200.0;
749 }
750 else if (Ecm >= 2.525) {
751 sNNEta1 = -4433.586*Ecm*Ecm*Ecm*Ecm + 56581.54*Ecm*Ecm*Ecm - 270212.6*Ecm*Ecm + 571650.6*Ecm - 451091.6;
752 }
753 else {
754 sNNEta1 = 17570.217219*Ecm*Ecm - 84910.985402*Ecm + 102585.55847;
755 }
756
757 sNNEta2 = -10220.89518466*Ecm*Ecm+51227.30841724*Ecm-64097.96025731;
758 if (sNNEta2 < 0.) sNNEta2=0.;
759
760 sNNEta = 2*(sNNEta1+sNNEta2)-sNNEta;
761 if (sNNEta < 1.e-9 || Ecm < Thr0) sNNEta = 0.; // Thr0: Ecm threshold
762
763 return sNNEta/1000.; // parameterization in microbarn (not millibarn)!
764
765 }
G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:725

References G4INCL::Eta, G4INCL::ParticleTable::getRealMass(), G4INCL::Neutron, and G4INCL::Proton.

Referenced by NNToNNEtaExclu(), and NNToNNEtaIso().

◆ NNToNNEtaFourPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 4-pion production - NNEta channel.

Definition at line 1039 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1039 {
1040 //
1041 // Nucleon-Nucleon producing one eta and four pions
1042 //
1043
1044 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
1045 if (ener < 2018.563) return 0.;
1046 const G4double s = ener*ener;
1047 const G4int i = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1048 G4double xsinelas;
1049 if (i!=0)
1050 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1051 else
1052 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1053 if (xsinelas <= 1.e-9) return 0.;
1054 G4double ratio=(NNToNNEta(particle1, particle2)-NNToNNEtaExclu(particle1, particle2))/xsinelas;
1055 if(s<6.25E6)
1056 return 0.;
1057 const G4double sigma = NNToNNEta(particle1, particle2) - NNToNNEtaExclu(particle1, particle2) - ratio*(NNToNNEtaOnePiOrDelta(particle1, particle2) + NNToNNEtaTwoPi(particle1, particle2) + NNToNNEtaThreePi(particle1, particle2));
1058 return ((sigma>1.e-9) ? sigma : 0.);
1059 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi
virtual G4double NNToNNEtaThreePi(Particle const *const part1, Particle const *const part2)
Cross section for direct 3-pion production - NNEta channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1016
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi
virtual G4double NNToNNEtaTwoPi(Particle const *const part1, Particle const *const part2)
Cross section for direct 2-pion production - NNEta channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:997

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNEta(), NNToNNEtaExclu(), NNToNNEtaOnePiOrDelta(), NNToNNEtaThreePi(), NNToNNEtaTwoPi(), s, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNEtaxPi().

◆ NNToNNEtaIso()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso ( const G4double  ener,
const G4int  iso 
)
protectedvirtual

Cross section for One (more) pion production - piN entrance channel.

Cross section for Two (more) pion production - piN entrance channel

Cross section for Three (more) pion production - piN entrance channel virtual G4double piNThreePi(Particle const * const p1, Particle const * const p2);

Isotopic Cross section for Eta production (inclusive) - NN entrance channel

Definition at line 638 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

638 {
639
640 const G4double Ecm=0.001*ener;
641 G4double sNNEta; // pp->pp+eta(+X)
642 G4double sNNEta1; // np->np+eta(+X)
643 G4double sNNEta2; // np->d+eta (d will be considered as np - How far is this right?)
644 G4double x=Ecm*Ecm/5.88;
645
646//jcd
647 if (Ecm >= 3.05) {
648 sNNEta = 2.5*std::pow((x-1.),1.47)*std::pow(x,-1.25)*1000.;
649 }
650 else if(Ecm >= 2.6) {
651 sNNEta = -327.29*Ecm*Ecm*Ecm + 2870.*Ecm*Ecm - 7229.3*Ecm + 5273.3;
652 if (sNNEta <= NNToNNEtaExcluIso(ener, 2)*1000.) sNNEta = NNToNNEtaExcluIso(ener, 2)*1000.;
653 }
654 else {
655 sNNEta = NNToNNEtaExcluIso(ener, 2)*1000.;
656 }
657//jcd
658 if (sNNEta < 1.e-9) sNNEta = 0.;
659
660 if (iso != 0) {
661 return sNNEta/1000.; // parameterization in microbarn (not millibarn)!
662 }
663
664 if(Ecm >= 6.25) {
665 sNNEta1 = sNNEta;
666 }
667 else if (Ecm >= 2.6) {
668 sNNEta1 = sNNEta*std::exp(-(-5.53151576/Ecm+0.8850425));
669 }
670 else if (Ecm >= 2.525) { // = exclusive pn
671 sNNEta1 = -4433.586*Ecm*Ecm*Ecm*Ecm + 56581.54*Ecm*Ecm*Ecm - 270212.6*Ecm*Ecm + 571650.6*Ecm - 451091.6;
672 }
673 else { // = exclusive pn
674 sNNEta1 = 17570.217219*Ecm*Ecm - 84910.985402*Ecm + 102585.55847;
675 }
676
677 sNNEta2 = -10220.89518466*Ecm*Ecm+51227.30841724*Ecm-64097.96025731;
678 if (sNNEta2 < 0.) sNNEta2=0.;
679
680 sNNEta = 2*(sNNEta1+sNNEta2)-sNNEta;
681
682 G4double Mn=ParticleTable::getRealMass(Neutron)/1000.;
683 G4double Mp=ParticleTable::getRealMass(Proton)/1000.;
684 G4double Meta=ParticleTable::getRealMass(Eta)/1000.;
685 if (sNNEta < 1.e-9 || Ecm < Mn+Mp+Meta) sNNEta = 0.;
686
687 return sNNEta/1000.; // parameterization in microbarn (not millibarn)!
688 }

References G4INCL::Eta, G4INCL::ParticleTable::getRealMass(), G4INCL::Neutron, NNToNNEtaExcluIso(), and G4INCL::Proton.

Referenced by NNToNNEta().

◆ NNToNNEtaOnePi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 1-pion production - NNEta channel.

Definition at line 967 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

967 {
968 // Cross section for nucleon-nucleon producing one eta and one pion
969
970 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
971 if (iso!=0)
972 return 0.;
973
974 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta (= 2705.55 - 2018.563; 4074595.287720512986=2018.563*2018.563)
975 if (ener < 2018.563) return 0.;
976
977 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
978 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
979
980 return 0.25*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
981 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNEtaxPi().

◆ NNToNNEtaOnePiOrDelta()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 1-pion production - NNEta channel.

Definition at line 983 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

983 {
984 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
985 if (ener < 2018.563) return 0.;
986 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
987
988 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
989 if (iso != 0)
990 return CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
991 else {
992 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
993 return 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
994 }
995 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaEta(), and NNToNNEtaFourPi().

◆ NNToNNEtaThreePi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 3-pion production - NNEta channel.

Definition at line 1016 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1016 {
1017 //
1018 // Nucleon-Nucleon producing one eta and three pions
1019 //
1020
1021 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
1022 if (ener < 2018.563) return 0.;
1023 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1024
1025
1026 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1027 const G4double xs1pi2=CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2);
1028 const G4double xs2pi2=CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
1029 if (iso != 0)
1030 return CrossSectionsMultiPions::NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2);
1031 else {
1032 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1033 const G4double xs1pi0=CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0);
1034 const G4double xs2pi0=CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0);
1035 return 0.5*(CrossSectionsMultiPions::NNThreePi(ener, 0, xsiso0, xs1pi0, xs2pi0)+ CrossSectionsMultiPions::NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2));
1036 }
1037 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNEtaFourPi(), and NNToNNEtaxPi().

◆ NNToNNEtaTwoPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 2-pion production - NNEta channel.

Definition at line 997 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

997 {
998 //
999 // Nucleon-Nucleon producing one eta and two pions
1000 //
1001 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
1002 if (ener < 2018.563) return 0.;
1003 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1004
1005
1006 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1007 if (iso != 0) {
1008 return CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
1009 }
1010 else {
1011 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1012 return 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
1013 }
1014 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNEtaFourPi(), and NNToNNEtaxPi().

◆ NNToNNEtaxPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi ( const G4int  xpi,
Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for X pion production - NNEta Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1061 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1061 {
1062 //
1063 // Nucleon-Nucleon producing one eta and xpi pions
1064 //
1065// assert(xpi>0 && xpi<=nMaxPiNN);
1066// assert(particle1->isNucleon() && particle2->isNucleon());
1067
1068 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 581.437; // 581.437 MeV translation to open pion production in NNEta
1069 if (ener < 2018.563) return 0.;
1070 const G4int i = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1071 G4double xsinelas;
1072 if (i!=0)
1073 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1074 else
1075 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1076 if (xsinelas <= 1.e-9) return 0.;
1077 G4double ratio=(NNToNNEta(particle1, particle2)-NNToNNEtaExclu(particle1, particle2))/xsinelas;
1078
1079 if (xpi == 1)
1080 return NNToNNEtaOnePi(particle1, particle2)*ratio;
1081 else if (xpi == 2)
1082 return NNToNNEtaTwoPi(particle1, particle2)*ratio;
1083 else if (xpi == 3)
1084 return NNToNNEtaThreePi(particle1, particle2)*ratio;
1085 else if (xpi == 4)
1086 return NNToNNEtaFourPi(particle1, particle2);
1087 else // should never reach this point
1088 return 0.;
1089 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi
virtual G4double NNToNNEtaFourPi(Particle const *const part1, Particle const *const part2)
Cross section for direct 4-pion production - NNEta channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1039
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi
virtual G4double NNToNNEtaOnePi(Particle const *const part1, Particle const *const part2)
Cross section for direct 1-pion production - NNEta channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:967

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNEta(), NNToNNEtaExclu(), NNToNNEtaFourPi(), NNToNNEtaOnePi(), NNToNNEtaThreePi(), NNToNNEtaTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNNKKb()

G4double G4INCL::CrossSectionsMultiPions::NNToNNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1402 of file G4INCLCrossSectionsMultiPions.cc.

1402 {
1403 //
1404 // Nucleon-Nucleon producing Nucleon-Nucleon-Kaon-antiKaon cross sections
1405 //
1406 return 0.;
1407 }

◆ NNToNNOmega()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega ( Particle const *const  particle1,
Particle const *const  particle2 
)
virtual

Cross section for Omega production (inclusive) - NN entrance channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 815 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

815 {
816
817 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
818 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
819//jcd to be removed
820// return 0.;
821//jcd
822 if (iso != 0) {
823 return NNToNNOmegaIso(ener, iso);
824 }
825 else {
826 return 0.5*(NNToNNOmegaIso(ener, 0)+NNToNNOmegaIso(ener, 2));
827 }
828 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaIso
virtual G4double NNToNNOmegaIso(const G4double ener, const G4int iso)
Isotopic Cross section for Omega production (inclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:781

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), NNToNNOmegaIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaOmega(), NNToNNOmegaFourPi(), NNToNNOmegaxPi(), NNToxPiNN(), and G4INCL::CrossSectionsStrangeness::NNToxPiNN().

◆ NNToNNOmegaExclu()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu ( Particle const *const  particle1,
Particle const *const  particle2 
)
virtual

Cross section for Omega production (exclusive) - NN entrance channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 875 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

875 {
876//jcd to be removed
877// return 0.;
878//jcd
879
880 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
881 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
882
883 if (iso != 0) {
884 return NNToNNOmegaExcluIso(ener, iso);
885 }
886 else {
887 return 0.5*(NNToNNOmegaExcluIso(ener, 0)+NNToNNOmegaExcluIso(ener, 2));
888 }
889 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso
virtual G4double NNToNNOmegaExcluIso(const G4double ener, const G4int iso)
Isotopic Cross section for Omega production (exclusive) - NN entrance channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:830

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), NNToNNOmegaExcluIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaOmega(), NNToNNOmegaFourPi(), and NNToNNOmegaxPi().

◆ NNToNNOmegaExcluIso()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso ( const G4double  ener,
const G4int  iso 
)
protectedvirtual

Isotopic Cross section for Omega production (exclusive) - NN entrance channel.

Definition at line 830 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

830 {
831
832 const G4double Ecm=0.001*ener;
833 G4double sNNOmega; // pp->pp+eta
834 G4double sNNOmega1; // np->np+eta
835 G4double sthroot=std::sqrt(7.06);
836
837 if(Ecm>=3.0744) { // By hand (JCD)
838 sNNOmega = 330.*(Ecm-sthroot)/(1.05+std::pow((Ecm-sthroot),2));
839 }
840 else if(Ecm>=2.65854){
841 sNNOmega = -1208.09757*std::pow(Ecm,3) + 10773.3322*std::pow(Ecm,2) - 31661.0223*Ecm + 30728.7241 ;
842 }
843 else {
844 sNNOmega = 0. ;
845 }
846
847 G4double Mn=ParticleTable::getRealMass(Neutron)/1000.;
848 G4double Mp=ParticleTable::getRealMass(Proton)/1000.;
849 G4double Momega=ParticleTable::getRealMass(Omega)/1000.;
850 G4double Thr0=0.;
851 if (iso > 0) {
852 Thr0=2.*Mp+Momega;
853 }
854 else if (iso < 0) {
855 Thr0=2.*Mn+Momega;
856 }
857 else {
858 Thr0=Mn+Mp+Momega;
859 }
860
861 if (sNNOmega < 1.e-9 || Ecm < Thr0) sNNOmega = 0.; // Thr0: Ecm threshold
862
863 if (iso != 0) {
864 return sNNOmega/1000.; // parameterization in microbarn (not millibarn)!
865 }
866
867 sNNOmega1 = 3*sNNOmega; // 3.0: ratio pn/pp
868
869 sNNOmega = 2*sNNOmega1-sNNOmega;
870 if (sNNOmega < 1.e-9 || Ecm < Thr0) sNNOmega = 0.;
871
872 return sNNOmega/1000.; // parameterization in microbarn (not millibarn)!
873 }

References G4INCL::ParticleTable::getRealMass(), G4INCL::Neutron, G4INCL::Omega, and G4INCL::Proton.

Referenced by NNToNNOmegaExclu(), and NNToNNOmegaIso().

◆ NNToNNOmegaFourPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 4-pion production - NNOmega channel.

Definition at line 1182 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1182 {
1183 //
1184 // Nucleon-Nucleon producing one omega and four pions
1185 //
1186//jcd to be removed
1187// return 0.;
1188//jcd
1189
1190 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1191 if (ener < 2018.563) return 0.;
1192 const G4double s = ener*ener;
1193 const G4int i = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1194 G4double xsinelas;
1195 if (i!=0)
1196 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1197 else
1198 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1199 if (xsinelas <= 1.e-9) return 0.;
1200 G4double ratio=(NNToNNOmega(particle1, particle2)-NNToNNOmegaExclu(particle1, particle2))/xsinelas;
1201 if(s<6.25E6)
1202 return 0.;
1203 const G4double sigma = NNToNNOmega(particle1, particle2) - NNToNNOmegaExclu(particle1, particle2) - ratio*(NNToNNOmegaOnePiOrDelta(particle1, particle2) + NNToNNOmegaTwoPi(particle1, particle2) + NNToNNOmegaThreePi(particle1, particle2));
1204 return ((sigma>1.e-9) ? sigma : 0.);
1205 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi
virtual G4double NNToNNOmegaTwoPi(Particle const *const part1, Particle const *const part2)
Cross section for direct 2-pion production - NNOmega channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1141
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi
virtual G4double NNToNNOmegaThreePi(Particle const *const part1, Particle const *const part2)
Cross section for direct 3-pion production - NNOmega channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1159

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNOmega(), NNToNNOmegaExclu(), NNToNNOmegaOnePiOrDelta(), NNToNNOmegaThreePi(), NNToNNOmegaTwoPi(), s, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNOmegaxPi().

◆ NNToNNOmegaIso()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaIso ( const G4double  ener,
const G4int  iso 
)
protectedvirtual

Isotopic Cross section for Omega production (inclusive) - NN entrance channel.

Definition at line 781 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

781 {
782
783 const G4double Ecm=0.001*ener;
784 G4double sNNOmega; // pp->pp+eta(+X)
785 G4double sNNOmega1; // np->np+eta(+X)
786 G4double x=Ecm*Ecm/7.06;
787
788 if(Ecm>4.0) {
789 sNNOmega = 2.5*std::pow(x-1, 1.47)*std::pow(x, -1.11) ;
790 }
791 else if(Ecm>2.802) { // 2802 MeV -> threshold to open inclusive (based on multipion threshold and omega mass)
792 sNNOmega = (568.5254*Ecm*Ecm - 2694.045*Ecm + 3106.247)/1000.;
793 if (sNNOmega <= NNToNNOmegaExcluIso(ener, 2)) sNNOmega = NNToNNOmegaExcluIso(ener, 2);
794 }
795 else {
796 sNNOmega = NNToNNOmegaExcluIso(ener, 2);
797 }
798
799 if (sNNOmega < 1.e-9) sNNOmega = 0.;
800
801 if (iso != 0) {
802 return sNNOmega;
803 }
804
805 sNNOmega1 = 3.*sNNOmega; // 3.0: ratio pn/pp (5 from theory; 2 from experiments)
806
807 sNNOmega = 2.*sNNOmega1-sNNOmega;
808
809 if (sNNOmega < 1.e-9) sNNOmega = 0.;
810
811 return sNNOmega;
812 }

References NNToNNOmegaExcluIso().

Referenced by NNToNNOmega().

◆ NNToNNOmegaOnePi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 1-pion production - NNOmega channel.

Definition at line 1111 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1111 {
1112 // Cross section for nucleon-nucleon producing one omega and one pion
1113
1114 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1115 if (iso!=0)
1116 return 0.;
1117
1118 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega (= 2802. - 2018.563; 4074595.287720512986=2018.563*2018.563)
1119 if (ener < 2018.563) return 0.;
1120
1121 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1122 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1123
1124 return 0.25*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
1125 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNOmegaxPi().

◆ NNToNNOmegaOnePiOrDelta()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 1-pion production - NNOmega channel.

Definition at line 1127 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1127 {
1128 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1129 if (ener < 2018.563) return 0.;
1130 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1131
1132 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1133 if (iso != 0)
1134 return CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
1135 else {
1136 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1137 return 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
1138 }
1139 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNDeltaOmega(), and NNToNNOmegaFourPi().

◆ NNToNNOmegaThreePi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 3-pion production - NNOmega channel.

Definition at line 1159 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1159 {
1160 //
1161 // Nucleon-Nucleon producing one omega and three pions
1162 //
1163
1164 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1165 if (ener < 2018.563) return 0.;
1166 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1167
1168
1169 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1170 const G4double xs1pi2=CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2);
1171 const G4double xs2pi2=CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
1172 if (iso != 0)
1173 return CrossSectionsMultiPions::NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2);
1174 else {
1175 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1176 const G4double xs1pi0=CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0);
1177 const G4double xs2pi0=CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0);
1178 return 0.5*(CrossSectionsMultiPions::NNThreePi(ener, 0, xsiso0, xs1pi0, xs2pi0)+ CrossSectionsMultiPions::NNThreePi(ener, 2, xsiso2, xs1pi2, xs2pi2));
1179 }
1180 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNOmegaFourPi(), and NNToNNOmegaxPi().

◆ NNToNNOmegaTwoPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtual

Cross section for direct 2-pion production - NNOmega channel.

Definition at line 1141 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1141 {
1142 //
1143 // Nucleon-Nucleon producing one omega and two pions
1144 //
1145 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1146 if (ener < 2018.563) return 0.;
1147 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1148
1149 const G4double xsiso2=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1150 if (iso != 0) {
1151 return CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
1152 }
1153 else {
1154 const G4double xsiso0=CrossSectionsMultiPions::NNInelasticIso(ener, 0);
1155 return 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
1156 }
1157 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by NNToNNOmegaFourPi(), and NNToNNOmegaxPi().

◆ NNToNNOmegaxPi()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi ( const G4int  xpi,
Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for X pion production - NNOmega Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1207 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

1207 {
1208 //
1209 // Nucleon-Nucleon producing one omega and xpi pions
1210 //
1211// assert(xpi>0 && xpi<=nMaxPiNN);
1212// assert(particle1->isNucleon() && particle2->isNucleon());
1213//jcd to be removed
1214// return 0.;
1215//jcd
1216
1217 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2) - 783.437; // 783.437 MeV translation to open pion production in NNOmega
1218 if (ener < 2018.563) return 0.;
1219 const G4int i = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
1220 G4double xsinelas;
1221 if (i!=0)
1222 xsinelas=CrossSectionsMultiPions::NNInelasticIso(ener, 2);
1223 else
1224 xsinelas=0.5*(CrossSectionsMultiPions::NNInelasticIso(ener, 0)+CrossSectionsMultiPions::NNInelasticIso(ener, 2));
1225 if (xsinelas <= 1.e-9) return 0.;
1226 G4double ratio=(NNToNNOmega(particle1, particle2)-NNToNNOmegaExclu(particle1, particle2))/xsinelas;
1227
1228 if (xpi == 1)
1229 return NNToNNOmegaOnePi(particle1, particle2)*ratio;
1230 else if (xpi == 2)
1231 return NNToNNOmegaTwoPi(particle1, particle2)*ratio;
1232 else if (xpi == 3)
1233 return NNToNNOmegaThreePi(particle1, particle2)*ratio;
1234 else if (xpi == 4)
1235 return NNToNNOmegaFourPi(particle1, particle2);
1236 else // should never reach this point
1237 return 0.;
1238 }
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi
virtual G4double NNToNNOmegaFourPi(Particle const *const part1, Particle const *const part2)
Cross section for direct 4-pion production - NNOmega channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1182
G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi
virtual G4double NNToNNOmegaOnePi(Particle const *const part1, Particle const *const part2)
Cross section for direct 1-pion production - NNOmega channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:1111

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), NNToNNOmega(), NNToNNOmegaExclu(), NNToNNOmegaFourPi(), NNToNNOmegaOnePi(), NNToNNOmegaThreePi(), NNToNNOmegaTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNSK()

G4double G4INCL::CrossSectionsMultiPions::NNToNSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1367 of file G4INCLCrossSectionsMultiPions.cc.

1367 {
1368 //
1369 // Nucleon-Nucleon producing N-Sigma-Kaon cross sections
1370 //
1371 return 0.;
1372 }

◆ NNToNSK2pi()

G4double G4INCL::CrossSectionsMultiPions::NNToNSK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1395 of file G4INCLCrossSectionsMultiPions.cc.

1395 {
1396 //
1397 // Nucleon-Nucleon producing N-Sigma-Kaon-2pion cross sections
1398 //
1399 return 0.;
1400 }

◆ NNToNSKpi()

G4double G4INCL::CrossSectionsMultiPions::NNToNSKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1381 of file G4INCLCrossSectionsMultiPions.cc.

1381 {
1382 //
1383 // Nucleon-Nucleon producing N-Sigma-Kaon-pion cross sections
1384 //
1385 return 0.;
1386 }

◆ NNTot()

G4double G4INCL::CrossSectionsMultiPions::NNTot ( Particle const *const  part1,
Particle const *const  part2 
)
protectedinherited

Internal implementation of the NN total cross section.

Definition at line 164 of file G4INCLCrossSectionsMultiPions.cc.

164 {
165
166 G4int i = ParticleTable::getIsospin(part1->getType())
167 + ParticleTable::getIsospin(part2->getType());
168
169 if(part1->isNucleon() && part2->isNucleon()) { // NN
170 const G4double s = KinematicsUtils::squareTotalEnergyInCM(part1, part2);
171 return NNTotFixed(s, i);
172 }
173 else if (part1->isDelta() && part2->isDelta()) { // Delta-Delta
174 return elastic(part1, part2);
175 }
176 else { // Nucleon-Delta
177 return NDeltaToNN(part1, part2) + elastic(part1, part2);
178 }
179 }
G4INCL::CrossSectionsMultiPions::NDeltaToNN
virtual G4double NDeltaToNN(Particle const *const p1, Particle const *const p2)
Cross section for NDelta->NN.
Definition: G4INCLCrossSectionsMultiPions.cc:749

References G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isDelta(), G4INCL::Particle::isNucleon(), G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NNTotFixed(), s, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::NNFourPi(), G4INCL::CrossSectionsMultiPions::total(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ NNTotFixed()

G4double G4INCL::CrossSectionsMultiPions::NNTotFixed ( const G4double  s,
const G4int  i 
)
protectedinherited

Internal implementation of the NN total cross section with fixed isospin.

Definition at line 181 of file G4INCLCrossSectionsMultiPions.cc.

181 {
182
183 /* From NNTot, with isospin fixed and for NN only.
184 */
185
186 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
187
188 if (i == 0) { // pn
189 if (plab < 0.446) {
190 G4double alp=std::log(plab);
191 return 6.3555*std::exp(-3.2481*alp-0.377*std::pow(alp, 2));
192 }
193 else if (plab < 1.0) {
194 return 33.+196.*std::sqrt(std::pow(std::fabs(plab-0.95),5));
195 }
196 else if (plab < 1.924) {
197 return 24.2+8.9*plab;
198 }
199 else {
200 G4double alp=std::log(plab);
201 return 48.9-33.7*std::pow(plab, -3.08)+0.619*std::pow(alp, 2)-5.12*alp;
202 }
203 }
204 else { // pp and nn
205 if (plab < 0.440) {
206 return 34.*std::pow(plab/0.4, (-2.104));
207 }
208 else if (plab < 0.8734) {
209 return 23.5+1000.*std::pow(plab-0.7, 4);
210 }
211 else if (plab < 1.5) {
212 return 23.5+24.6/(1.+std::exp(-10.*(plab-1.2)));
213 }
214 else if (plab < 3.0044) {
215 return 41.+60.*(plab-0.9)*std::exp(-1.2*plab);
216 }
217 else {
218 G4double alp=std::log(plab);
219 return 45.6+219.*std::pow(plab, -4.23)+0.41*std::pow(alp, 2)-3.41*alp;
220 }
221 }
222 }

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::KinematicsUtils::momentumInLab(), and s.

Referenced by G4INCL::CrossSectionsMultiPions::NNInelasticIso(), and G4INCL::CrossSectionsMultiPions::NNTot().

◆ NNToxPiNN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::NNToxPiNN ( const G4int  xpi,
Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for X pion production - NN Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 892 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

892 {
893 //
894 // Nucleon-Nucleon producing xpi pions cross sections
895 //
896// assert(xpi>0 && xpi<=nMaxPiNN);
897// assert(particle1->isNucleon() && particle2->isNucleon());
898
899 G4double oldXS1Pi=CrossSectionsMultiPions::NNToxPiNN(1,particle1, particle2);
900 G4double oldXS2Pi=CrossSectionsMultiPions::NNToxPiNN(2,particle1, particle2);
901 G4double oldXS3Pi=CrossSectionsMultiPions::NNToxPiNN(3,particle1, particle2);
902 G4double oldXS4Pi=CrossSectionsMultiPions::NNToxPiNN(4,particle1, particle2);
903 G4double xsEtaOmega=NNToNNEta(particle1, particle2)+NNToNNOmega(particle1, particle2);
904 G4double newXS1Pi=0.;
905 G4double newXS2Pi=0.;
906 G4double newXS3Pi=0.;
907 G4double newXS4Pi=0.;
908
909 if (xpi == 1) {
910 if (oldXS4Pi != 0. || oldXS3Pi != 0.)
911 newXS1Pi=oldXS1Pi;
912 else if (oldXS2Pi != 0.) {
913 newXS2Pi=oldXS2Pi-xsEtaOmega;
914 if (newXS2Pi < 0.)
915 newXS1Pi=oldXS1Pi-(xsEtaOmega-oldXS2Pi);
916 else
917 newXS1Pi=oldXS1Pi;
918 }
919 else
920 newXS1Pi=oldXS1Pi-xsEtaOmega;
921 return newXS1Pi;
922 }
923 else if (xpi == 2) {
924 if (oldXS4Pi != 0.)
925 newXS2Pi=oldXS2Pi;
926 else if (oldXS3Pi != 0.) {
927 newXS3Pi=oldXS3Pi-xsEtaOmega;
928 if (newXS3Pi < 0.)
929 newXS2Pi=oldXS2Pi-(xsEtaOmega-oldXS3Pi);
930 else
931 newXS2Pi=oldXS2Pi;
932 }
933 else {
934 newXS2Pi=oldXS2Pi-xsEtaOmega;
935 if (newXS2Pi < 0.)
936 newXS2Pi=0.;
937 }
938 return newXS2Pi;
939 }
940 else if (xpi == 3) {
941 if (oldXS4Pi != 0.) {
942 newXS4Pi=oldXS4Pi-xsEtaOmega;
943 if (newXS4Pi < 0.)
944 newXS3Pi=oldXS3Pi-(xsEtaOmega-oldXS4Pi);
945 else
946 newXS3Pi=oldXS3Pi;
947 }
948 else {
949 newXS3Pi=oldXS3Pi-xsEtaOmega;
950 if (newXS3Pi < 0.)
951 newXS3Pi=0.;
952 }
953 return newXS3Pi;
954 }
955 else if (xpi == 4) {
956 newXS4Pi=oldXS4Pi-xsEtaOmega;
957 if (newXS4Pi < 0.)
958 newXS4Pi=0.;
959 return newXS4Pi;
960 }
961
962 else // should never reach this point
963 return 0.;
964 }
G4INCL::CrossSectionsMultiPions::NNToxPiNN
virtual G4double NNToxPiNN(const G4int xpi, Particle const *const p1, Particle const *const p2)
Cross section for X pion production - NN Channel.
Definition: G4INCLCrossSectionsMultiPions.cc:532

References NNToNNEta(), NNToNNOmega(), and G4INCL::CrossSectionsMultiPions::NNToxPiNN().

◆ NNTwoPi() [1/2]

G4double G4INCL::CrossSectionsMultiPions::NNTwoPi ( const G4double  ener,
const G4int  iso,
const G4double  xsiso 
)
protectedvirtualinherited

Cross section for direct 2-pion production - NN entrance channel.

Definition at line 331 of file G4INCLCrossSectionsMultiPions.cc.

331 {
332
333 /* Article J. Physique 48 (1987)1901-1924 "Energy dependence of nucleon-cucleon inelastic total cross-sections."
334 J. Bystricky, P. La France, F. Lehar, F. Perrot, T. Siemiarczuk & P. Winternitz
335 S12PM : pp -> pp Pi+ Pi-
336 S12ZZ : pp -> pp Pi0 Pi0
337 S12PP : pp -> nn Pi+ Pi+
338 S02PZ : pp -> pn Pi+ Pi0
339 S02PM : pn -> pn Pi+ Pi-
340 S12MZ : pn -> pp Pi- Pi0
341 */
342
343 const G4double s = ener*ener;
344 G4double plab = 0.001*KinematicsUtils::momentumInLab(s, ParticleTable::effectiveNucleonMass, ParticleTable::effectiveNucleonMass);
345
346 G4double snn2pit=0.;
347 G4double s12pm=0.;
348 G4double s12pp=0.;
349 G4double s12zz=0.;
350 G4double s02pz=0.;
351 G4double s02pm=0.;
352 G4double s12mz=0.;
353
354 if (iso==0 && plab<3.33) {
355 snn2pit = xsiso - NNOnePiOrDelta(ener, iso, xsiso);
356 if (snn2pit < 1.e-8) snn2pit=0.;
357 return snn2pit;
358 }
359
360 if (iso != 0) {
361//s12pm
362 if (plab > 15.) {
363 s12pm=25.977/plab;
364 }
365 else if (plab >= 1.3817) {
366 const G4double b=BystrickyEvaluator<5>::eval(plab,s12pmOOT,s12pmHC);
367 s12pm=b*b;
368 }
369//s12pp
370 if (plab > 10.) {
371 s12pp=141.505/std::pow((-0.1016*plab-7),2);
372 }
373 else if (plab >= 1.5739) {
374 const G4double b=BystrickyEvaluator<3>::eval(plab,s12ppOOT,s12ppHC);
375 s12pp=b*b;
376 }
377 }
378//s12zz
379 if (plab > 4.) {
380 s12zz=97.355/std::pow((1.1579*plab+5),2);
381 }
382 else if (plab >= 1.72207) {
383 const G4double b=BystrickyEvaluator<4>::eval(plab,s12zzOOT,s12zzHC);
384 s12zz=b*b;
385 }
386//s02pz
387 if (plab > 4.5) {
388 s02pz=178.082/std::pow((0.2014*plab+5),2);
389 }
390 else if (plab >= 1.5656) {
391 const G4double b=BystrickyEvaluator<4>::eval(plab,s02pzOOT,s02pzHC);
392 s02pz=b*b;
393 }
394
395// channel T=1
396 if (iso != 0) {
397 snn2pit=s12pm+s12pp+s12zz+s02pz;
398 if (snn2pit < 1.e-8) snn2pit=0.;
399 return snn2pit;
400 }
401
402//s02pm
403 if (plab > 5.) {
404 s02pm=135.826/std::pow(plab,2);
405 }
406 else if (plab >= 1.21925) {
407 const G4double b=BystrickyEvaluator<6>::eval(plab,s02pmOOT,s02pmHC);
408 s02pm=b*b;
409 }
410//s12mz
411 if (plab >= 1.29269) {
412 const G4double b=BystrickyEvaluator<4>::eval(plab,s12mzOOT,s12mzHC);
413 s12mz=b*b;
414 }
415
416// channel T=0
417// snn2pit=3*(0.5*s02pm+0.5*s12mz-0.5*s02pz-s12zz); //modif snn2pit=3*(s02pm+0.5*s12mz-0.5*s02pz-s12zz);
418 snn2pit=3*(s02pm+0.5*s12mz-0.5*s02pz-s12zz);
419 if (snn2pit < 1.e-8) snn2pit=0.;
420 return snn2pit;
421 }
G4INCL::CrossSectionsMultiPions::s02pmOOT
static const G4double s02pmOOT
One over threshold for s02pm.
Definition: G4INCLCrossSectionsMultiPions.hh:230
G4INCL::CrossSectionsMultiPions::s12zzHC
const HornerC4 s12zzHC
Horner coefficients for s12zz.
Definition: G4INCLCrossSectionsMultiPions.hh:205
G4INCL::CrossSectionsMultiPions::s02pmHC
const HornerC6 s02pmHC
Horner coefficients for s02pm.
Definition: G4INCLCrossSectionsMultiPions.hh:209
G4INCL::CrossSectionsMultiPions::s02pzOOT
static const G4double s02pzOOT
One over threshold for s02pz.
Definition: G4INCLCrossSectionsMultiPions.hh:228
G4INCL::CrossSectionsMultiPions::s12zzOOT
static const G4double s12zzOOT
One over threshold for s12zz.
Definition: G4INCLCrossSectionsMultiPions.hh:226
G4INCL::CrossSectionsMultiPions::s12mzOOT
static const G4double s12mzOOT
One over threshold for s12mz.
Definition: G4INCLCrossSectionsMultiPions.hh:232
G4INCL::CrossSectionsMultiPions::s12ppOOT
static const G4double s12ppOOT
One over threshold for s12pp.
Definition: G4INCLCrossSectionsMultiPions.hh:224
G4INCL::CrossSectionsMultiPions::s12pmOOT
static const G4double s12pmOOT
One over threshold for s12pm.
Definition: G4INCLCrossSectionsMultiPions.hh:222
G4INCL::CrossSectionsMultiPions::s12ppHC
const HornerC3 s12ppHC
Horner coefficients for s12pp.
Definition: G4INCLCrossSectionsMultiPions.hh:203
G4INCL::CrossSectionsMultiPions::s12mzHC
const HornerC4 s12mzHC
Horner coefficients for s12mz.
Definition: G4INCLCrossSectionsMultiPions.hh:211
G4INCL::CrossSectionsMultiPions::s12pmHC
const HornerC5 s12pmHC
Horner coefficients for s12pm.
Definition: G4INCLCrossSectionsMultiPions.hh:201
G4INCL::CrossSectionsMultiPions::s02pzHC
const HornerC4 s02pzHC
Horner coefficients for s02pz.
Definition: G4INCLCrossSectionsMultiPions.hh:207

References G4INCL::ParticleTable::effectiveNucleonMass, G4INCL::BystrickyEvaluator< N >::eval(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), s, G4INCL::CrossSectionsMultiPions::s02pmHC, G4INCL::CrossSectionsMultiPions::s02pmOOT, G4INCL::CrossSectionsMultiPions::s02pzHC, G4INCL::CrossSectionsMultiPions::s02pzOOT, G4INCL::CrossSectionsMultiPions::s12mzHC, G4INCL::CrossSectionsMultiPions::s12mzOOT, G4INCL::CrossSectionsMultiPions::s12pmHC, G4INCL::CrossSectionsMultiPions::s12pmOOT, G4INCL::CrossSectionsMultiPions::s12ppHC, G4INCL::CrossSectionsMultiPions::s12ppOOT, G4INCL::CrossSectionsMultiPions::s12zzHC, and G4INCL::CrossSectionsMultiPions::s12zzOOT.

Referenced by G4INCL::CrossSectionsMultiPions::NNFourPi(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsStrangeness::NNToNLK2pi(), G4INCL::CrossSectionsStrangeness::NNToNLKpi(), NNToNNEtaThreePi(), NNToNNEtaTwoPi(), NNToNNOmegaThreePi(), NNToNNOmegaTwoPi(), G4INCL::CrossSectionsStrangeness::NNToNSK2pi(), G4INCL::CrossSectionsStrangeness::NNToNSKpi(), G4INCL::CrossSectionsMultiPions::NNToxPiNN(), and G4INCL::CrossSectionsMultiPions::NNTwoPi().

◆ NNTwoPi() [2/2]

G4double G4INCL::CrossSectionsMultiPions::NNTwoPi ( Particle const *const  part1,
Particle const *const  part2 
)
protectedvirtualinherited

Cross section for direct 2-pion production - NN entrance channel.

Definition at line 483 of file G4INCLCrossSectionsMultiPions.cc.

483 {
484 //
485 // Nucleon-Nucleon producing one pion cross sections
486 //
487 const G4double ener=KinematicsUtils::totalEnergyInCM(particle1, particle2);
488 const G4int iso=ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
489
490
491 const G4double xsiso2=NNInelasticIso(ener, 2);
492 if (iso != 0) {
493 return NNTwoPi(ener, 2, xsiso2);
494 }
495 else {
496 const G4double xsiso0=NNInelasticIso(ener, 0);
497 return 0.5*(NNTwoPi(ener, 0, xsiso0)+ NNTwoPi(ener, 2, xsiso2));
498 }
499 return 0.0; // Should never reach this point
500 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::CrossSectionsMultiPions::NNInelasticIso(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NpiToLK()

G4double G4INCL::CrossSectionsMultiPions::NpiToLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Nucleon-Pion to Stange particles cross sections.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1439 of file G4INCLCrossSectionsMultiPions.cc.

1439 {
1440 //
1441 // Pion-Nucleon producing Lambda-Kaon cross sections
1442 //
1443 return 0.;
1444 }

◆ NpiToLK2pi()

G4double G4INCL::CrossSectionsMultiPions::NpiToLK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1476 of file G4INCLCrossSectionsMultiPions.cc.

1476 {
1477 //
1478 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
1479 //
1480 return 0.;
1481 }

◆ NpiToLKpi()

G4double G4INCL::CrossSectionsMultiPions::NpiToLKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1462 of file G4INCLCrossSectionsMultiPions.cc.

1462 {
1463 //
1464 // Pion-Nucleon producing Lambda-Kaon-pion cross sections
1465 //
1466 return 0.;
1467 }

◆ NpiToMissingStrangeness()

G4double G4INCL::CrossSectionsMultiPions::NpiToMissingStrangeness ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1497 of file G4INCLCrossSectionsMultiPions.cc.

1497 {
1498 //
1499 // Pion-Nucleon missing strangeness production cross sections
1500 //
1501 return 0.;
1502 }

◆ NpiToNKKb()

G4double G4INCL::CrossSectionsMultiPions::NpiToNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1490 of file G4INCLCrossSectionsMultiPions.cc.

1490 {
1491 //
1492 // Pion-Nucleon producing Nucleon-Kaon-antiKaon cross sections
1493 //
1494 return 0.;
1495 }

◆ NpiToSK()

G4double G4INCL::CrossSectionsMultiPions::NpiToSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1446 of file G4INCLCrossSectionsMultiPions.cc.

1446 {
1447 //
1448 // Pion-Nucleon producing Sigma-Kaon cross sections
1449 //
1450 return 0.;
1451 }

◆ NpiToSK2pi()

G4double G4INCL::CrossSectionsMultiPions::NpiToSK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1483 of file G4INCLCrossSectionsMultiPions.cc.

1483 {
1484 //
1485 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
1486 //
1487 return 0.;
1488 }

◆ NpiToSKpi()

G4double G4INCL::CrossSectionsMultiPions::NpiToSKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1469 of file G4INCLCrossSectionsMultiPions.cc.

1469 {
1470 //
1471 // Pion-Nucleon producing Sigma-Kaon-pion cross sections
1472 //
1473 return 0.;
1474 }

◆ NSToNL()

G4double G4INCL::CrossSectionsMultiPions::NSToNL ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1511 of file G4INCLCrossSectionsMultiPions.cc.

1511 {
1512 //
1513 // Nucleon-Sigma quasi-elastic cross sections
1514 //
1515 return 0.;
1516 }

◆ NSToNS()

G4double G4INCL::CrossSectionsMultiPions::NSToNS ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1518 of file G4INCLCrossSectionsMultiPions.cc.

1518 {
1519 //
1520 // Nucleon-Sigma quasi-elastic cross sections
1521 //
1522 return 0.;
1523 }

◆ NYelastic()

G4double G4INCL::CrossSectionsMultiPions::NYelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

elastic scattering for Nucleon-Strange Particles cross sections

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1338 of file G4INCLCrossSectionsMultiPions.cc.

1338 {
1339 //
1340 // Hyperon-Nucleon elastic cross sections
1341 //
1342 return 0.;
1343 }

◆ omegaNElastic()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::omegaNElastic ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtual

Definition at line 405 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

405 {
406 //
407 // Omega-Nucleon elastic cross sections
408 //
409// assert((particle1->isNucleon() && particle2->isOmega()) || (particle1->isOmega() && particle2->isNucleon()));
410
411 G4double sigma=0.;
412
413 const Particle *omega;
414 const Particle *nucleon;
415
416 if (particle1->isOmega()) {
417 omega = particle1;
418 nucleon = particle2;
419 }
420 else {
421 omega = particle2;
422 nucleon = particle1;
423 }
424
425 const G4double pLab = KinematicsUtils::momentumInLab(omega, nucleon)/1000.; // GeV/c
426
427 sigma = 5.4 + 10.*std::exp(-0.6*pLab); // Eq.(21) in G.I. Lykasov et al., EPJA 6, 71-81 (1999)
428
429 return sigma;
430 }

References G4INCL::Particle::isOmega(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by elastic().

◆ omegaNInelastic()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::omegaNInelastic ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtual

Cross sections for mesonic resonance absorption on nucleon - inelastic Channel.

Definition at line 377 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

377 {
378 //
379 // Omega-Nucleon inelastic cross sections
380 //
381// assert((particle1->isNucleon() && particle2->isOmega()) || (particle1->isOmega() && particle2->isNucleon()));
382
383 G4double sigma=0.;
384
385 const Particle *omega;
386 const Particle *nucleon;
387
388 if (particle1->isOmega()) {
389 omega = particle1;
390 nucleon = particle2;
391 }
392 else {
393 omega = particle2;
394 nucleon = particle1;
395 }
396
397 const G4double pLab = KinematicsUtils::momentumInLab(omega, nucleon)/1000.; // GeV/c
398
399 sigma = 20. + 4.0/pLab; // Eq.(24) in G.I. Lykasov et al., EPJA 6, 71-81 (1999)
400
401 return sigma;
402 }

References G4INCL::Particle::isOmega(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by omegaNToPiN(), omegaNToPiPiN(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ omegaNToPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for OmegaN->PiN.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 433 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

433 {
434 //
435 // Omega-Nucleon producing Pion cross sections
436 //
437// assert((particle1->isNucleon() && particle2->isOmega()) || (particle1->isOmega() && particle2->isNucleon()));
438
439 G4double ECM=KinematicsUtils::totalEnergyInCM(particle1, particle2);
440
441 G4double massPiZero=ParticleTable::getINCLMass(PiZero);
442 G4double massPiMinus=ParticleTable::getINCLMass(PiMinus);
443 G4double massProton=ParticleTable::getINCLMass(Proton);
444
445 G4double massomega;
446 G4double massnucleon;
447 G4double pCM_omega;
448 G4double pLab_omega;
449
450 G4double sigma=0.;
451
452 if (particle1->isOmega()) {
453 massomega=particle1->getMass();
454 massnucleon=particle2->getMass();
455 }
456 else {
457 massomega=particle2->getMass();
458 massnucleon=particle1->getMass();
459 }
460 pCM_omega=KinematicsUtils::momentumInCM(ECM, massomega, massnucleon);
461 pLab_omega=KinematicsUtils::momentumInLab(ECM*ECM, massomega, massnucleon);
462
463 G4double pCM_PiZero=KinematicsUtils::momentumInCM(ECM, massPiZero, massProton);
464 G4double pCM_PiMinus=KinematicsUtils::momentumInCM(ECM, massPiMinus, massProton); // = pCM_PiPlus (because massPiMinus = massPiPlus)
465
466 sigma = (piMinuspToOmegaN(ECM)/2.) * std::pow((pCM_PiZero/pCM_omega), 2)
467 + piMinuspToOmegaN(ECM) * std::pow((pCM_PiMinus/pCM_omega), 2);
468
469 if (sigma > omegaNInelastic(particle1, particle2) || (pLab_omega < 200.)) {
470// if (sigma > omegaNInelastic(particle1, particle2)) {
471 sigma = omegaNInelastic(particle1, particle2);
472 }
473
474 return sigma;
475 }
G4INCL::CrossSectionsMultiPionsAndResonances::omegaNInelastic
virtual G4double omegaNInelastic(Particle const *const p1, Particle const *const p2)
Cross sections for mesonic resonance absorption on nucleon - inelastic Channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:377
G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN
G4double piMinuspToOmegaN(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:584

References G4INCL::ParticleTable::getINCLMass(), G4INCL::Particle::getMass(), G4INCL::Particle::isOmega(), G4INCL::KinematicsUtils::momentumInCM(), G4INCL::KinematicsUtils::momentumInLab(), omegaNInelastic(), G4INCL::PiMinus, piMinuspToOmegaN(), G4INCL::PiZero, G4INCL::Proton, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by omegaNToPiPiN().

◆ omegaNToPiPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiPiN ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtual

Cross sections for omega-induced 2Pi emission on nucleon.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 478 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

478 {
479 //
480 // Omega-Nucleon producing 2 PionS cross sections
481 //
482// assert((particle1->isNucleon() && particle2->isOmega()) || (particle1->isOmega() && particle2->isNucleon()));
483
484 G4double sigma=0.;
485
486 sigma = omegaNInelastic(particle1,particle2) - omegaNToPiN(particle1,particle2) ;
487
488 return sigma;
489 }
G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN
virtual G4double omegaNToPiN(Particle const *const p1, Particle const *const p2)
Cross section for OmegaN->PiN.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:433

References omegaNInelastic(), and omegaNToPiN().

◆ p_pimToSmKp()

G4double G4INCL::CrossSectionsMultiPions::p_pimToSmKp ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1452 of file G4INCLCrossSectionsMultiPions.cc.

1452 {
1453 return 0.;
1454 }

◆ p_pimToSzKz()

G4double G4INCL::CrossSectionsMultiPions::p_pimToSzKz ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1455 of file G4INCLCrossSectionsMultiPions.cc.

1455 {
1456 return 0.;
1457 }

◆ p_pizToSzKp()

G4double G4INCL::CrossSectionsMultiPions::p_pizToSzKp ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 1458 of file G4INCLCrossSectionsMultiPions.cc.

1458 {
1459 return 0.;
1460 }

◆ piMinuspIne()

G4double G4INCL::CrossSectionsMultiPions::piMinuspIne ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 1026 of file G4INCLCrossSectionsMultiPions.cc.

1026 {
1027 // piMinusp inelastic cross section (Delta excluded)
1028
1029 const Particle *pion;
1030 const Particle *nucleon;
1031 if(particle1->isNucleon()) {
1032 nucleon = particle1;
1033 pion = particle2;
1034 } else {
1035 pion = particle1;
1036 nucleon = particle2;
1037 }
1038// assert(pion->isPion());
1039
1040 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1041
1042 // these limits correspond to sqrt(s)=1230 and 20000 MeV
1043 if(pLab>212677. || pLab<296.367)
1044 return 0.0;
1045
1046// const G4int ipit3 = ParticleTable::getIsospin(pion->getType());
1047// const G4int ind2t3 = ParticleTable::getIsospin(nucleon->getType());
1048// const G4int cg = 4 + ind2t3*ipit3;
1049// assert(cg==2 || cg==4 || cg==6);
1050
1051 const G4double p1=1e-3*pLab;
1052 const G4double p2=std::log(p1);
1053 G4double xpimp = 0.0;
1054
1055 // x-section pi- p inelastique :
1056 if(p1 <= 0.4731)
1057 xpimp=0;
1058 else
1059 xpimp=26.6-7.18*std::pow(p1, -1.86)+0.327*p2*p2-2.81*p2;
1060 if(xpimp<0.)
1061 xpimp=0;
1062
1063 // cas pi- p et pi+ n
1064 return xpimp;
1065
1066 }
G4InuclParticleNames::pion
G4bool pion(G4int ityp)
Definition: G4InuclParticleNames.hh:90

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), and G4InuclParticleNames::pion().

Referenced by G4INCL::CrossSectionsMultiPions::piMinuspOnePi(), G4INCL::CrossSectionsMultiPions::piMinuspTwoPi(), and G4INCL::CrossSectionsMultiPions::piNIne().

◆ piMinuspOnePi()

G4double G4INCL::CrossSectionsMultiPions::piMinuspOnePi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 1105 of file G4INCLCrossSectionsMultiPions.cc.

1105 {
1106 const Particle *pion;
1107 const Particle *nucleon;
1108 if(particle1->isNucleon()) {
1109 nucleon = particle1;
1110 pion = particle2;
1111 } else {
1112 pion = particle1;
1113 nucleon = particle2;
1114 }
1115// assert(pion->isPion());
1116
1117 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1118
1119 // this limit corresponds to sqrt(s)=1230 MeV
1120 if(pLab<296.367)
1121 return 0.0;
1122
1123 // const G4int ipi = ParticleTable::getIsospin(pion->getType());
1124 // const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
1125 // const G4int cg = 4 + ind2*ipi;
1126 // assert(cg==2 || cg==4 || cg==6);
1127
1128 const G4double p1=1e-3*pLab;
1129 G4double tamp2=0.;
1130
1131 // X-SECTION PI- P INELASTIQUE :
1132 if (pLab < 1228.06) // corresponds to sqrt(s)=1794 MeV
1133 tamp2=piMinuspIne(particle1, particle2);
1134 else
1135 tamp2=9.04*std::pow(p1, -1.17)+18.*std::pow(p1, -1.21); // tamp2=9.04*std::pow(p1, -1.17)+(13.5*std::pow(p1, -1.21))*4./3.;
1136 if (tamp2 < 0.0) tamp2=0;
1137
1138 // CAS PI- P ET PI+ N
1139 return tamp2;
1140 }
G4INCL::CrossSectionsMultiPions::piMinuspIne
G4double piMinuspIne(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:1026

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::CrossSectionsMultiPions::piMinuspIne(), and G4InuclParticleNames::pion().

Referenced by G4INCL::CrossSectionsMultiPions::piMinuspTwoPi(), and G4INCL::CrossSectionsMultiPions::piNOnePi().

◆ piMinuspToEtaN() [1/2]

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN ( const G4double  ECM)
protected

Definition at line 550 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

550 {
551 //
552 // Pion-Nucleon producing Eta cross sections
553 //
554
555 const G4double masspion = ParticleTable::getRealMass(PiMinus);
556 const G4double massnucleon = ParticleTable::getRealMass(Proton);
557
558 G4double plab=KinematicsUtils::momentumInLab(ECM*ECM, masspion, massnucleon)/1000.; // GeV/c
559
560 G4double sigma;
561
562// new parameterization (JCD) - end of february 2016
563 if (ECM < 1486.5) sigma=0.;
564 else
565 {
566 if (ECM < 1535.)
567 {
568 sigma = -0.0000003689197974814*std::pow(ECM,4) + 0.002260193900097*std::pow(ECM,3) - 5.193105877187*std::pow(ECM,2) + 5303.505273919*ECM - 2031265.900648;
569 }
570 else if (ECM < 1670.)
571 {
572 sigma = -0.0000000337986446*std::pow(ECM,4) + 0.000218279989*std::pow(ECM,3) - 0.528276144*std::pow(ECM,2) + 567.828367*ECM - 228709.42;
573 }
574 else if (ECM < 1714.)
575 {
576 sigma = 0.000003737765*std::pow(ECM,2) - 0.005664062*ECM;
577 }
578 else sigma=1.47*std::pow(plab, -1.68);
579 }
580
581 return sigma;
582 }

References G4INCL::ParticleTable::getRealMass(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::PiMinus, and G4INCL::Proton.

◆ piMinuspToEtaN() [2/2]

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN ( Particle const *const  p1,
Particle const *const  p2 
)
protected

Internal function for pion cross sections.

Definition at line 505 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

505 {
506 //
507 // Pion-Nucleon producing Eta cross sections
508 //
509// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
510
511 G4double masspion;
512 G4double massnucleon;
513 if (particle1->isPion()) {
514 masspion=particle1->getMass();
515 massnucleon=particle2->getMass();
516 }
517 else {
518 masspion=particle2->getMass();
519 massnucleon=particle1->getMass();
520 }
521
522 G4double ECM=KinematicsUtils::totalEnergyInCM(particle1, particle2);
523 G4double plab=KinematicsUtils::momentumInLab(ECM*ECM, masspion, massnucleon)/1000.; // GeV/c
524
525 G4double sigma;
526
527// new parameterization (JCD) - end of february 2016
528 if (ECM < 1486.5) sigma=0.;
529 else
530 {
531 if (ECM < 1535.)
532 {
533 sigma = -0.0000003689197974814*std::pow(ECM,4) + 0.002260193900097*std::pow(ECM,3) - 5.193105877187*std::pow(ECM,2) + 5303.505273919*ECM - 2031265.900648;
534 }
535 else if (ECM < 1670.)
536 {
537 sigma = -0.0000000337986446*std::pow(ECM,4) + 0.000218279989*std::pow(ECM,3) - 0.528276144*std::pow(ECM,2) + 567.828367*ECM - 228709.42;
538 }
539 else if (ECM < 1714.)
540 {
541 sigma = 0.000003737765*std::pow(ECM,2) - 0.005664062*ECM;
542 }
543 else sigma=1.47*std::pow(plab, -1.68);
544 }
545//
546
547 return sigma;
548 }

References G4INCL::Particle::getMass(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by etaNToPiN(), and piNToEtaN().

◆ piMinuspToOmegaN() [1/2]

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN ( const G4double  ECM)
protected

Definition at line 615 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

615 {
616 //
617 // Pion-Nucleon producing Omega cross sections
618 //
619//jcd to be removed
620// return 0.;
621//jcd
622
623// G4double param=1.095 ; // Deneye (Thesis)
624 G4double param=1.0903 ; // JCD (threshold taken into account)
625
626 const G4double masspion = ParticleTable::getRealMass(PiMinus);
627 const G4double massnucleon = ParticleTable::getRealMass(Proton);
628
629 G4double plab=KinematicsUtils::momentumInLab(ECM*ECM, masspion, massnucleon)/1000.; // GeV/c
630
631 G4double sigma;
632 if (plab < param) sigma=0.;
633 else sigma=13.76*(plab-param)/(std::pow(plab, 3.33)-1.07);
634
635 return sigma;
636 }

References G4INCL::ParticleTable::getRealMass(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::PiMinus, and G4INCL::Proton.

◆ piMinuspToOmegaN() [2/2]

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN ( Particle const *const  p1,
Particle const *const  p2 
)
protected

Definition at line 584 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

584 {
585 //
586 // Pion-Nucleon producing Omega cross sections
587 //
588// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
589//jcd to be removed
590// return 0.;
591//jcd
592
593// G4double param=1.095 ; // Deneye (Thesis)
594 G4double param=1.0903 ; // JCD (threshold taken into account)
595
596 G4double masspion;
597 G4double massnucleon;
598 if (particle1->isPion()) {
599 masspion=particle1->getMass();
600 massnucleon=particle2->getMass();
601 }
602 else {
603 masspion=particle2->getMass();
604 massnucleon=particle1->getMass();
605 }
606 G4double ECM=KinematicsUtils::totalEnergyInCM(particle1, particle2);
607 G4double plab=KinematicsUtils::momentumInLab(ECM*ECM, masspion, massnucleon)/1000.; // GeV/c
608
609 G4double sigma;
610 if (plab < param) sigma=0.;
611 else sigma=13.76*(plab-param)/(std::pow(plab, 3.33) - 1.07); // Phys. Rev. C 41, 1701–1718 (1990)
612
613 return sigma;
614}

References G4INCL::Particle::getMass(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by omegaNToPiN(), and piNToOmegaN().

◆ piMinuspTwoPi()

G4double G4INCL::CrossSectionsMultiPions::piMinuspTwoPi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 1183 of file G4INCLCrossSectionsMultiPions.cc.

1183 {
1184 //
1185 // pion-nucleon interaction, producing 2 pions
1186 // fit from Landolt-Bornstein multiplied by factor determined with evaluation of total xs
1187 //
1188
1189 const Particle *pion;
1190 const Particle *nucleon;
1191 if(particle1->isNucleon()) {
1192 nucleon = particle1;
1193 pion = particle2;
1194 } else {
1195 pion = particle1;
1196 nucleon = particle2;
1197 }
1198// assert(pion->isPion());
1199
1200 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1201
1202 // this limit corresponds to sqrt(s)=1230 MeV
1203 if(pLab<296.367)
1204 return 0.0;
1205
1206 // const G4int ipi = ParticleTable::getIsospin(pion->getType());
1207 // const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
1208 // const G4int cg = 4 + ind2*ipi;
1209 // assert(cg==2 || cg==4 || cg==6);
1210
1211 const G4double p1=1e-3*pLab;
1212 G4double tamp2=0.;
1213
1214 // X-SECTION PI- P INELASTIQUE :
1215 if(pLab<2083.63) // corresponds to sqrt(s)=2195 MeV
1216 tamp2=piMinuspIne(particle1, particle2)-piMinuspOnePi(particle1, particle2);
1217 else
1218 tamp2=2.457794117647+18.066176470588*std::pow(p1, -0.92); // tamp2=(0.619+4.55*std::pow(p1, -0.92))*135./34.;
1219
1220 // CAS PI- P ET PI+ N
1221 return tamp2;
1222}
G4INCL::CrossSectionsMultiPions::piMinuspOnePi
G4double piMinuspOnePi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:1105

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::CrossSectionsMultiPions::piMinuspIne(), G4INCL::CrossSectionsMultiPions::piMinuspOnePi(), and G4InuclParticleNames::pion().

Referenced by G4INCL::CrossSectionsMultiPions::piNTwoPi().

◆ piNIne()

G4double G4INCL::CrossSectionsMultiPions::piNIne ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 632 of file G4INCLCrossSectionsMultiPions.cc.

632 {
633 // piN inelastic cross section (Delta excluded)
634
635 const Particle *pion;
636 const Particle *nucleon;
637 if(particle1->isNucleon()) {
638 nucleon = particle1;
639 pion = particle2;
640 } else {
641 pion = particle1;
642 nucleon = particle2;
643 }
644// assert(pion->isPion());
645
646 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
647
648 // these limits correspond to sqrt(s)=1230 and 20000 MeV
649 if(pLab>212677. || pLab<296.367)
650 return 0.0;
651
652 const G4int ipit3 = ParticleTable::getIsospin(pion->getType());
653 const G4int ind2t3 = ParticleTable::getIsospin(nucleon->getType());
654 const G4int cg = 4 + ind2t3*ipit3;
655// assert(cg==2 || cg==4 || cg==6);
656
657// const G4double p1=1e-3*pLab;
658// const G4double p2=std::log(p1);
659 G4double xpipp = 0.0;
660 G4double xpimp = 0.0;
661
662 if(cg!=2) {
663 // x-section pi+ p inelastique :
664 xpipp=piPluspIne(pion,nucleon);
665
666 if(cg==6) // cas pi+ p et pi- n
667 return xpipp;
668 }
669
670 // x-section pi- p inelastique :
671 xpimp=piMinuspIne(pion,nucleon);
672
673 if(cg==2) // cas pi- p et pi+ n
674 return xpimp;
675 else // cas pi0 p et pi0 n
676 return 0.5*(xpipp+xpimp);
677 }
G4INCL::CrossSectionsMultiPions::piPluspIne
G4double piPluspIne(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:987

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::CrossSectionsMultiPions::piMinuspIne(), G4InuclParticleNames::pion(), and G4INCL::CrossSectionsMultiPions::piPluspIne().

Referenced by G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::CrossSectionsTruncatedMultiPions::elastic(), G4INCL::CrossSectionsMultiPions::piNOnePi(), and G4INCL::CrossSectionsMultiPions::piNToxPiN().

◆ piNOnePi()

G4double G4INCL::CrossSectionsMultiPions::piNOnePi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtualinherited

Cross section for One (more) pion production - piN entrance channel.

Definition at line 883 of file G4INCLCrossSectionsMultiPions.cc.

883 {
884 const Particle *pion;
885 const Particle *nucleon;
886 if(particle1->isNucleon()) {
887 nucleon = particle1;
888 pion = particle2;
889 } else {
890 pion = particle1;
891 nucleon = particle2;
892 }
893// assert(pion->isPion());
894
895 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
896
897 // this limit corresponds to sqrt(s)=1230 MeV
898 if(pLab<296.367)
899 return 0.0;
900
901 const G4int ipi = ParticleTable::getIsospin(pion->getType());
902 const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
903 const G4int cg = 4 + ind2*ipi;
904// assert(cg==2 || cg==4 || cg==6);
905
906 // const G4double p1=1e-3*pLab;
907 G4double tamp6=0.;
908 G4double tamp2=0.;
909 const G4double elas = elastic(particle1, particle2);
910
911 // X-SECTION PI+ P INELASTIQUE :
912 if(cg != 2) {
913 tamp6=piPluspOnePi(particle1,particle2);
914 if (cg == 6){ // CAS PI+ P ET PI- N
915 if(tamp6 >= elas && pLab < 410.) tamp6 = elas;
916 return tamp6;
917 }
918 }
919
920 // X-SECTION PI- P INELASTIQUE :
921 tamp2=piMinuspOnePi(particle1,particle2);
922 if (tamp2 < 0.0) tamp2=0;
923
924 if (cg == 2) // CAS PI- P ET PI+ N
925 return tamp2;
926 else { // CAS PI0 P ET PI0 N
927 G4double s1pin = 0.5*(tamp6+tamp2);
928 const G4double inelastic = piNIne(particle1, particle2);
929 if(s1pin >= elas && pLab < 410.) s1pin = 0.;
930 if (s1pin > inelastic)
931 s1pin = inelastic;
932 return s1pin;
933 }
934 }
G4INCL::CrossSectionsMultiPions::piNIne
G4double piNIne(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:632
G4INCL::CrossSectionsMultiPions::piPluspOnePi
G4double piPluspOnePi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:1068

References G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::CrossSectionsMultiPions::piMinuspOnePi(), G4INCL::CrossSectionsMultiPions::piNIne(), G4InuclParticleNames::pion(), and G4INCL::CrossSectionsMultiPions::piPluspOnePi().

Referenced by G4INCL::CrossSectionsMultiPions::piNToxPiN().

◆ piNToDelta()

G4double G4INCL::CrossSectionsMultiPions::piNToDelta ( Particle const *const  p1,
Particle const *const  p2 
)
virtualinherited

Cross section for Delta production - piN Channel.

Implements G4INCL::ICrossSections.

Reimplemented in G4INCL::CrossSectionsTruncatedMultiPions.

Definition at line 679 of file G4INCLCrossSectionsMultiPions.cc.

679 {
680 // piN Delta production
681
682 G4double x = KinematicsUtils::totalEnergyInCM(particle1, particle2);
683 if(x>20000.) return 0.0; // no cross section above this value
684
685 G4int ipit3 = 0;
686 G4int ind2t3 = 0;
687 const G4double ramass = 0.0;
688
689 if(particle1->isPion()) {
690 ipit3 = ParticleTable::getIsospin(particle1->getType());
691 ind2t3 = ParticleTable::getIsospin(particle2->getType());
692 } else if(particle2->isPion()) {
693 ipit3 = ParticleTable::getIsospin(particle2->getType());
694 ind2t3 = ParticleTable::getIsospin(particle1->getType());
695 }
696
697 const G4double y=x*x;
698 const G4double q2=(y-1076.0*1076.0)*(y-800.0*800.0)/y/4.0;
699 if (q2 <= 0.) {
700 return 0.0;
701 }
702 const G4double q3 = std::pow(std::sqrt(q2),3);
703 const G4double f3 = q3/(q3 + 5832000.); // 5832000 = 180^3
704 G4double sdelResult = 326.5/(std::pow((x-1215.0-ramass)*2.0/(110.0-ramass), 2)+1.0);
705 sdelResult = sdelResult*(1.0-5.0*ramass/1215.0);
706 const G4int cg = 4 + ind2t3*ipit3;
707 sdelResult = sdelResult*f3*cg/6.0;
708
709 return sdelResult;
710 }

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

Referenced by G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::CrossSectionsTruncatedMultiPions::elastic(), and G4INCL::CrossSectionsTruncatedMultiPions::piNToDelta().

◆ piNToEtaN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross sections for mesonic resonance production - piN Channel.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 195 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

195 {
196 //
197 // Pion-Nucleon producing Eta cross sections
198 //
199// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
200
201 G4double sigma;
202 sigma=piMinuspToEtaN(particle1,particle2);
203
204 const G4int isoin = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
205
206 if (isoin == -1) {
207 if ((particle1->getType()) == Proton || (particle2->getType()) == Proton) return sigma;
208 else return 0.5 * sigma;
209 }
210 else if (isoin == 1) {
211 if ((particle1->getType()) == Neutron || (particle2->getType()) == Neutron) return sigma;
212 else return 0.5 * sigma;
213 }
214 else return 0. ; // should never return 0. (?) // pi+ p and pi- n return 0.
215
216// return sigma;
217 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Neutron, piMinuspToEtaN(), and G4INCL::Proton.

Referenced by piNToxPiN(), and G4INCL::CrossSectionsStrangeness::piNToxPiN().

◆ piNToEtaPrimeN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaPrimeN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for PiN->EtaPrimeN.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 244 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

244 {
245#else
246 G4double CrossSectionsMultiPionsAndResonances::piNToEtaPrimeN(Particle const * const particle1, Particle const * const particle2) {
247#endif
248 //
249 // Pion-Nucleon producing EtaPrime cross sections
250 //
251// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
252
253 return 0.;
254 }
G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaPrimeN
virtual G4double piNToEtaPrimeN(Particle const *const p1, Particle const *const p2)
Cross section for PiN->EtaPrimeN.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:244

References piNToEtaPrimeN().

Referenced by piNToEtaPrimeN().

◆ piNToOmegaN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piNToOmegaN ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for PiN->OmegaN.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 219 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

219 {
220 //
221 // Pion-Nucleon producing Omega cross sections
222 //
223// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
224
225 G4double sigma;
226 sigma=piMinuspToOmegaN(particle1,particle2);
227
228 const G4int isoin = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
229
230 if (isoin == -1) {
231 if ((particle1->getType()) == Proton || (particle2->getType()) == Proton) return sigma;
232 else return 0.5 * sigma;
233 }
234 else if (isoin == 1) {
235 if ((particle1->getType()) == Neutron || (particle2->getType()) == Neutron) return sigma;
236 else return 0.5 * sigma;
237 }
238 else return 0. ; // should never return 0. (?) // pi+ p and pi- n return 0.
239
240// return sigma;
241 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Neutron, piMinuspToOmegaN(), and G4INCL::Proton.

Referenced by piNToxPiN(), and G4INCL::CrossSectionsStrangeness::piNToxPiN().

◆ piNTopiN()

G4double G4INCL::CrossSectionsMultiPions::piNTopiN ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

◆ piNTot()

G4double G4INCL::CrossSectionsMultiPions::piNTot ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 712 of file G4INCLCrossSectionsMultiPions.cc.

712 {
713 // FUNCTION SPN(X,IND2T3,IPIT3,f17)
714 // SIGMA(PI+ + P) IN THE (3,3) REGION
715 // NEW FIT BY J.VANDERMEULEN + FIT BY Th AOUST ABOVE (3,3) RES
716 // CONST AT LOW AND VERY HIGH ENERGY
717 // COMMON/BL8/RATHR,RAMASS REL21800
718 // integer f17
719 // RATHR and RAMASS are always 0.0!!!
720
721 G4double x = KinematicsUtils::totalEnergyInCM(particle1, particle2);
722
723 G4int ipit3 = 0;
724 G4int ind2t3 = 0;
725
726 if(particle1->isPion()) {
727 ipit3 = ParticleTable::getIsospin(particle1->getType());
728 ind2t3 = ParticleTable::getIsospin(particle2->getType());
729 } else if(particle2->isPion()) {
730 ipit3 = ParticleTable::getIsospin(particle2->getType());
731 ind2t3 = ParticleTable::getIsospin(particle1->getType());
732 }
733
734 G4double spnResult=0.0;
735
736 // HE pi+ p and pi- n
737 if((ind2t3 == 1 && ipit3 == 2) || (ind2t3 == -1 && ipit3 == -2))
738 spnResult=spnPiPlusPHE(x);
739 else if((ind2t3 == 1 && ipit3 == -2) || (ind2t3 == -1 && ipit3 == 2))
740 spnResult=spnPiMinusPHE(x);
741 else if(ipit3 == 0) spnResult = (spnPiPlusPHE(x) + spnPiMinusPHE(x))/2.0; // (spnpipphe(x)+spnpimphe(x))/2.0
742 else {
743 INCL_ERROR("Unknown configuration!\n" << particle1->print() << particle2->print() << '\n');
744 }
745
746 return spnResult;
747 }
INCL_ERROR
#define INCL_ERROR(x)
Definition: G4INCLLogger.hh:225
G4INCL::CrossSectionsMultiPions::spnPiPlusPHE
G4double spnPiPlusPHE(const G4double x)
Internal function for pion cross sections.
Definition: G4INCLCrossSectionsMultiPions.cc:552
G4INCL::CrossSectionsMultiPions::spnPiMinusPHE
G4double spnPiMinusPHE(const G4double x)
Internal function for pion cross sections.
Definition: G4INCLCrossSectionsMultiPions.cc:582

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), INCL_ERROR, G4INCL::Particle::isPion(), G4INCL::Particle::print(), G4INCL::CrossSectionsMultiPions::spnPiMinusPHE(), G4INCL::CrossSectionsMultiPions::spnPiPlusPHE(), and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::CrossSectionsTruncatedMultiPions::elastic(), G4INCL::CrossSectionsMultiPions::total(), total(), and G4INCL::CrossSectionsStrangeness::total().

◆ piNToxPiN()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::piNToxPiN ( const G4int  xpi,
Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for X pion production - piN Channel (modified due to the mesonic resonances)

Reimplemented from G4INCL::CrossSectionsMultiPions.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 137 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

137 {
138 //
139 // pion-Nucleon producing xpi pions cross sections (corrected due to eta and omega)
140 //
141// assert(xpi>1 && xpi<=nMaxPiPiN);
142// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
143
144 const G4double oldXS2Pi=CrossSectionsMultiPions::piNToxPiN(2,particle1, particle2);
145 const G4double oldXS3Pi=CrossSectionsMultiPions::piNToxPiN(3,particle1, particle2);
146 const G4double oldXS4Pi=CrossSectionsMultiPions::piNToxPiN(4,particle1, particle2);
147 const G4double xsEta=piNToEtaN(particle1, particle2);
148 const G4double xsOmega=piNToOmegaN(particle1, particle2);
149 G4double newXS2Pi=0.;
150 G4double newXS3Pi=0.;
151 G4double newXS4Pi=0.;
152
153 if (xpi == 2) {
154 if (oldXS4Pi != 0.)
155 newXS2Pi=oldXS2Pi;
156 else if (oldXS3Pi != 0.) {
157 newXS3Pi=oldXS3Pi-xsEta-xsOmega;
158 if (newXS3Pi < 1.e-09)
159 newXS2Pi=oldXS2Pi-(xsEta+xsOmega-oldXS3Pi);
160 else
161 newXS2Pi=oldXS2Pi;
162 }
163 else {
164 newXS2Pi=oldXS2Pi-xsEta-xsOmega;
165 if (newXS2Pi < 1.e-09)
166 newXS2Pi=0.;
167 }
168 return newXS2Pi;
169 }
170 else if (xpi == 3) {
171 if (oldXS4Pi != 0.) {
172 newXS4Pi=oldXS4Pi-xsEta-xsOmega;
173 if (newXS4Pi < 1.e-09)
174 newXS3Pi=oldXS3Pi-(xsEta+xsOmega-oldXS4Pi);
175 else
176 newXS3Pi=oldXS3Pi;
177 }
178 else {
179 newXS3Pi=oldXS3Pi-xsEta-xsOmega;
180 if (newXS3Pi < 1.e-09)
181 newXS3Pi=0.;
182 }
183 return newXS3Pi;
184 }
185 else if (xpi == 4) {
186 newXS4Pi=oldXS4Pi-xsEta-xsOmega;
187 if (newXS4Pi < 1.e-09)
188 newXS4Pi=0.;
189 return newXS4Pi;
190 }
191 else // should never reach this point
192 return 0.;
193 }
G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaN
virtual G4double piNToEtaN(Particle const *const p1, Particle const *const p2)
Cross sections for mesonic resonance production - piN Channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:195
G4INCL::CrossSectionsMultiPionsAndResonances::piNToOmegaN
virtual G4double piNToOmegaN(Particle const *const p1, Particle const *const p2)
Cross section for PiN->OmegaN.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:219
G4INCL::CrossSectionsMultiPions::piNToxPiN
virtual G4double piNToxPiN(const G4int xpi, Particle const *const p1, Particle const *const p2)
Cross section for X pion production - piN Channel.
Definition: G4INCLCrossSectionsMultiPions.cc:849

References piNToEtaN(), piNToOmegaN(), and G4INCL::CrossSectionsMultiPions::piNToxPiN().

◆ piNTwoPi()

G4double G4INCL::CrossSectionsMultiPions::piNTwoPi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedvirtualinherited

Cross section for Two (more) pion production - piN entrance channel.

Definition at line 936 of file G4INCLCrossSectionsMultiPions.cc.

936 {
937 //
938 // pion-nucleon interaction, producing 2 pions
939 // fit from Landolt-Bornstein multiplied by factor determined with evaluation of total xs
940 //
941
942 const Particle *pion;
943 const Particle *nucleon;
944 if(particle1->isNucleon()) {
945 nucleon = particle1;
946 pion = particle2;
947 } else {
948 pion = particle1;
949 nucleon = particle2;
950 }
951// assert(pion->isPion());
952
953 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
954 const G4double elas = elastic(pion, nucleon);
955
956 // this limit corresponds to sqrt(s)=1230 MeV
957 if(pLab<296.367)
958 return 0.0;
959
960 const G4int ipi = ParticleTable::getIsospin(pion->getType());
961 const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
962 const G4int cg = 4 + ind2*ipi;
963// assert(cg==2 || cg==4 || cg==6);
964
965 G4double tamp6=0.;
966 G4double tamp2=0.;
967
968 // X-SECTION PI+ P INELASTIQUE :
969 if(cg!=2) {
970 tamp6=piPluspTwoPi(particle1,particle2);
971 if(cg==6){ // CAS PI+ P ET PI- N
972 if(tamp6 >= elas && pLab < 410.) tamp6 = 0.;
973 return tamp6;}
974 }
975
976 // X-SECTION PI- P INELASTIQUE :
977 tamp2=piMinuspTwoPi(particle1,particle2);
978
979 if(cg==2) // CAS PI- P ET PI+ N
980 return tamp2;
981 else { // CAS PI0 P ET PI0 N
982 const G4double s2pin=0.5*(tamp6+tamp2);
983 return s2pin;
984 }
985 }
G4INCL::CrossSectionsMultiPions::piMinuspTwoPi
G4double piMinuspTwoPi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:1183
G4INCL::CrossSectionsMultiPions::piPluspTwoPi
G4double piPluspTwoPi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:1142

References G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4INCL::CrossSectionsMultiPions::piMinuspTwoPi(), G4InuclParticleNames::pion(), and G4INCL::CrossSectionsMultiPions::piPluspTwoPi().

Referenced by G4INCL::CrossSectionsMultiPions::piNToxPiN().

◆ piPluspIne()

G4double G4INCL::CrossSectionsMultiPions::piPluspIne ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 987 of file G4INCLCrossSectionsMultiPions.cc.

987 {
988 // piPlusP inelastic cross section (Delta excluded)
989
990 const Particle *pion;
991 const Particle *nucleon;
992 if(particle1->isNucleon()) {
993 nucleon = particle1;
994 pion = particle2;
995 } else {
996 pion = particle1;
997 nucleon = particle2;
998 }
999// assert(pion->isPion());
1000
1001 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1002
1003 // these limits correspond to sqrt(s)=1230 and 20000 MeV
1004 if(pLab>212677. || pLab<296.367)
1005 return 0.0;
1006
1007// const G4int ipit3 = ParticleTable::getIsospin(pion->getType());
1008// const G4int ind2t3 = ParticleTable::getIsospin(nucleon->getType());
1009// const G4int cg = 4 + ind2t3*ipit3;
1010// assert(cg==2 || cg==4 || cg==6);
1011
1012 const G4double p1=1e-3*pLab;
1013 const G4double p2=std::log(p1);
1014 G4double xpipp = 0.0;
1015
1016 // x-section pi+ p inelastique :
1017 if(p1<=0.75)
1018 xpipp=17.965*std::pow(p1, 5.4606);
1019 else
1020 xpipp=24.3-12.3*std::pow(p1, -1.91)+0.324*p2*p2-2.44*p2;
1021 // cas pi+ p et pi- n
1022 return xpipp;
1023
1024 }

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), and G4InuclParticleNames::pion().

Referenced by G4INCL::CrossSectionsMultiPions::piNIne(), G4INCL::CrossSectionsMultiPions::piPluspOnePi(), and G4INCL::CrossSectionsMultiPions::piPluspTwoPi().

◆ piPluspOnePi()

G4double G4INCL::CrossSectionsMultiPions::piPluspOnePi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 1068 of file G4INCLCrossSectionsMultiPions.cc.

1068 {
1069 const Particle *pion;
1070 const Particle *nucleon;
1071 if(particle1->isNucleon()) {
1072 nucleon = particle1;
1073 pion = particle2;
1074 } else {
1075 pion = particle1;
1076 nucleon = particle2;
1077 }
1078// assert(pion->isPion());
1079
1080 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1081
1082 // this limit corresponds to sqrt(s)=1230 MeV
1083 if(pLab<296.367)
1084 return 0.0;
1085
1086 // const G4int ipi = ParticleTable::getIsospin(pion->getType());
1087 // const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
1088 // const G4int cg = 4 + ind2*ipi;
1089 // assert(cg==2 || cg==4 || cg==6);
1090
1091 const G4double p1=1e-3*pLab;
1092 G4double tamp6=0.;
1093
1094 // X-SECTION PI+ P INELASTIQUE :
1095 if(pLab < 1532.52) // corresponds to sqrt(s)=1946 MeV
1096 tamp6=piPluspIne(particle1, particle2);
1097 else
1098 tamp6=0.204+18.2*std::pow(p1, -1.72)+6.33*std::pow(p1, -1.13);
1099
1100 // CAS PI+ P ET PI- N
1101 return tamp6;
1102
1103 }

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), and G4INCL::CrossSectionsMultiPions::piPluspIne().

Referenced by G4INCL::CrossSectionsMultiPions::piNOnePi(), and G4INCL::CrossSectionsMultiPions::piPluspTwoPi().

◆ piPluspTwoPi()

G4double G4INCL::CrossSectionsMultiPions::piPluspTwoPi ( Particle const *const  p1,
Particle const *const  p2 
)
protectedinherited

Definition at line 1142 of file G4INCLCrossSectionsMultiPions.cc.

1142 {
1143 //
1144 // pion-nucleon interaction, producing 2 pions
1145 // fit from Landolt-Bornstein multiplied by factor determined with evaluation of total xs
1146 //
1147
1148 const Particle *pion;
1149 const Particle *nucleon;
1150 if(particle1->isNucleon()) {
1151 nucleon = particle1;
1152 pion = particle2;
1153 } else {
1154 pion = particle1;
1155 nucleon = particle2;
1156 }
1157// assert(pion->isPion());
1158
1159 const G4double pLab = KinematicsUtils::momentumInLab(pion, nucleon);
1160
1161 // this limit corresponds to sqrt(s)=1230 MeV
1162 if(pLab<296.367)
1163 return 0.0;
1164
1165 // const G4int ipi = ParticleTable::getIsospin(pion->getType());
1166 // const G4int ind2 = ParticleTable::getIsospin(nucleon->getType());
1167 // const G4int cg = 4 + ind2*ipi;
1168 // assert(cg==2 || cg==4 || cg==6);
1169
1170 const G4double p1=1e-3*pLab;
1171 G4double tamp6=0.;
1172
1173 // X-SECTION PI+ P INELASTIQUE :
1174 if(pLab < 2444.7) // corresponds to sqrt(s)=2344 MeV
1175 tamp6=piPluspIne(particle1, particle2)-piPluspOnePi(particle1, particle2);
1176 else
1177 tamp6=1.59+25.5*std::pow(p1, -1.04); // tamp6=(0.636+10.2*std::pow(p1, -1.04))*15./6.;
1178
1179 // CAS PI+ P ET PI- N
1180 return tamp6;
1181 }

References G4INCL::Particle::isNucleon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), G4INCL::CrossSectionsMultiPions::piPluspIne(), and G4INCL::CrossSectionsMultiPions::piPluspOnePi().

Referenced by G4INCL::CrossSectionsMultiPions::piNTwoPi().

◆ spnPiMinusPHE()

G4double G4INCL::CrossSectionsMultiPions::spnPiMinusPHE ( const G4double  x)
protectedinherited

Internal function for pion cross sections.

Definition at line 582 of file G4INCLCrossSectionsMultiPions.cc.

582 {
583 // HE pi- p and pi+ n
584 G4double ramass = 0.0;
585
586 if(x <= 1275.8) {
587 G4double y = x*x;
588 G4double q2;
589 q2=(y-std::pow(1076.0, 2))*(y-std::pow(800.0, 2))/(4.0*y);
590 if (q2 > 0.) {
591 G4double q3=std::pow(q2, 3./2.);
592 G4double f3=q3/(q3+std::pow(180.0, 3));
593 G4double sdel;
594 sdel=326.5/(std::pow((x-1215.0-ramass)*2.0/110.0,2)+1.0);
595 return sdel*f3*(1.0-5.0*ramass/1215.0)/3.;
596 }
597 else {
598 return 0;
599 }
600 }
601 if(x <= 1495.0) {
602 return 0.00120683*(x-1372.52)*(x-1372.52)+26.2058;
603 } else if(x <= 1578.0) {
604 return 1.15873e-05*x*x+49965.6/((x-1519.59)*(x-1519.59)+2372.55);
605 } else if(x <= 2028.4) {
606 return 34.0248+43262.2/((x-1681.65)*(x-1681.65)+1689.35);
607 } else if(x <= 7500.0) {
608 return 3.3e-7*(x-7500.0)*(x-7500.0)+24.5;
609 } else {
610 return 24.5;
611 }
612 }

Referenced by G4INCL::CrossSectionsMultiPions::piNTot().

◆ spnPiPlusPHE()

G4double G4INCL::CrossSectionsMultiPions::spnPiPlusPHE ( const G4double  x)
protectedinherited

Internal function for pion cross sections.

Definition at line 552 of file G4INCLCrossSectionsMultiPions.cc.

552 {
553 // HE and LE pi- p and pi+ n
554 G4double ramass = 0.0;
555
556 if(x <= 1306.78) {
557 G4double y = x*x;
558 G4double q2;
559 q2=(y-std::pow(1076.0, 2))*(y-std::pow(800.0, 2))/(4.0*y);
560 if (q2 > 0.) {
561 G4double q3=std::pow(q2, 3./2.);
562 G4double f3=q3/(q3+std::pow(180.0, 3));
563 G4double sdel;
564 sdel=326.5/(std::pow((x-1215.0-ramass)*2.0/110.0,2)+1.0);
565 return sdel*f3*(1.0-5.0*ramass/1215.0);
566 }
567 else {
568 return 0;
569 }
570 }
571 if(x <= 1754.0) {
572 return -2.33730e-06*std::pow(x, 3)+1.13819e-02*std::pow(x,2)
573 -1.83993e+01*x+9893.4;
574 } else if (x <= 2150.0) {
575 return 1.13531e-06*std::pow(x, 3)-6.91694e-03*std::pow(x, 2)
576 +1.39907e+01*x-9360.76;
577 } else {
578 return -3.18087*std::log(x)+52.9784;
579 }
580 }

Referenced by G4INCL::CrossSectionsMultiPions::piNTot().

◆ total()

G4double G4INCL::CrossSectionsMultiPionsAndResonances::total ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

new total particle-particle cross section

Reimplemented from G4INCL::CrossSectionsMultiPions.

Reimplemented in G4INCL::CrossSectionsStrangeness.

Definition at line 91 of file G4INCLCrossSectionsMultiPionsAndResonances.cc.

91 {
92 G4double inelastic;
93 if(p1->isNucleon() && p2->isNucleon()) {
94 return CrossSectionsMultiPions::NNTot(p1, p2);
95 } else if((p1->isNucleon() && p2->isDelta()) ||
96 (p1->isDelta() && p2->isNucleon())) {
97 inelastic = CrossSectionsMultiPions::NDeltaToNN(p1, p2);
98 } else if((p1->isNucleon() && p2->isPion()) ||
99 (p1->isPion() && p2->isNucleon())) {
100 return CrossSectionsMultiPions::piNTot(p1,p2);
101 } else if((p1->isNucleon() && p2->isEta()) ||
102 (p1->isEta() && p2->isNucleon())) {
103 inelastic = etaNToPiN(p1,p2) + etaNToPiPiN(p1,p2);
104 } else if((p1->isNucleon() && p2->isOmega()) ||
105 (p1->isOmega() && p2->isNucleon())) {
106 inelastic = omegaNInelastic(p1,p2);
107 } else if((p1->isNucleon() && p2->isEtaPrime()) ||
108 (p1->isEtaPrime() && p2->isNucleon())) {
109 inelastic = etaPrimeNToPiN(p1,p2);
110 } else {
111 inelastic = 0.;
112 }
113
114 return inelastic + elastic(p1, p2);
115 }
G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiPiN
virtual G4double etaNToPiPiN(Particle const *const p1, Particle const *const p2)
Cross sections for mesonic resonance absorption on nucleon - pipiN Channel.
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:303
G4INCL::CrossSectionsMultiPionsAndResonances::elastic
virtual G4double elastic(Particle const *const p1, Particle const *const p2)
new elastic particle-particle cross section
Definition: G4INCLCrossSectionsMultiPionsAndResonances.cc:118
G4INCL::CrossSectionsMultiPions::piNTot
G4double piNTot(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:712

References elastic(), etaNToPiN(), etaNToPiPiN(), etaPrimeNToPiN(), G4INCL::Particle::isDelta(), G4INCL::Particle::isEta(), G4INCL::Particle::isEtaPrime(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isOmega(), G4INCL::Particle::isPion(), G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NNTot(), omegaNInelastic(), and G4INCL::CrossSectionsMultiPions::piNTot().

Field Documentation

◆ nMaxPiNN

const G4int G4INCL::CrossSectionsMultiPionsAndResonances::nMaxPiNN = 4
staticprotected

Maximum number of outgoing pions in NN collisions.

Definition at line 110 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ nMaxPiPiN

const G4int G4INCL::CrossSectionsMultiPionsAndResonances::nMaxPiPiN = 4
staticprotected

Maximum number of outgoing pions in piN collisions.

Definition at line 113 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s01ppHC

const HornerC8 G4INCL::CrossSectionsMultiPionsAndResonances::s01ppHC
protected

Horner coefficients for s01pp.

Definition at line 118 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s01ppOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s01ppOOT = 0.003421025623481919853
staticprotected

One over threshold for s01pp.

Definition at line 139 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s01pzHC

const HornerC4 G4INCL::CrossSectionsMultiPionsAndResonances::s01pzHC
protected

Horner coefficients for s01pz.

Definition at line 120 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s01pzOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s01pzOOT = 0.0035739814152966403123
staticprotected

One over threshold for s01pz.

Definition at line 141 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pmHC

const HornerC6 G4INCL::CrossSectionsMultiPionsAndResonances::s02pmHC
protected

Horner coefficients for s02pm.

Definition at line 132 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pmOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s02pmOOT = 0.0016661112962345883443
staticprotected

One over threshold for s02pm.

Definition at line 153 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pzHC

const HornerC4 G4INCL::CrossSectionsMultiPionsAndResonances::s02pzHC
protected

Horner coefficients for s02pz.

Definition at line 130 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pzOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s02pzOOT = 0.00125
staticprotected

One over threshold for s02pz.

Definition at line 151 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pmHC

const HornerC4 G4INCL::CrossSectionsMultiPionsAndResonances::s11pmHC
protected

Horner coefficients for s11pm.

Definition at line 122 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pmOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s11pmOOT = 0.0034855350296270480281
staticprotected

One over threshold for s11pm.

Definition at line 143 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pzHC

const HornerC7 G4INCL::CrossSectionsMultiPionsAndResonances::s11pzHC
protected

Horner coefficients for s11pz.

Definition at line 116 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pzOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s11pzOOT = 0.0035761542037692665889
staticprotected

One over threshold for s11pz.

Definition at line 137 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12mzHC

const HornerC4 G4INCL::CrossSectionsMultiPionsAndResonances::s12mzHC
protected

Horner coefficients for s12mz.

Definition at line 134 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12mzOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s12mzOOT = 0.0017047391749062392793
staticprotected

One over threshold for s12mz.

Definition at line 155 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12pmHC

const HornerC5 G4INCL::CrossSectionsMultiPionsAndResonances::s12pmHC
protected

Horner coefficients for s12pm.

Definition at line 124 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12pmOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s12pmOOT = 0.0016672224074691565119
staticprotected

One over threshold for s12pm.

Definition at line 145 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12ppHC

const HornerC3 G4INCL::CrossSectionsMultiPionsAndResonances::s12ppHC
protected

Horner coefficients for s12pp.

Definition at line 126 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12ppOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s12ppOOT = 0.0016507643038726931312
staticprotected

One over threshold for s12pp.

Definition at line 147 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12zzHC

const HornerC4 G4INCL::CrossSectionsMultiPionsAndResonances::s12zzHC
protected

Horner coefficients for s12zz.

Definition at line 128 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12zzOOT

const G4double G4INCL::CrossSectionsMultiPionsAndResonances::s12zzOOT = 0.0011111111111111111111
staticprotected

One over threshold for s12zz.

Definition at line 149 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.3