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

Multipion, mesonic Resonances and strange cross sections. More...

#include <G4INCLCrossSectionsStrangeness.hh>

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

Public Member Functions

virtual G4double calculateNNAngularSlope (G4double energyCM, G4int iso)
 Calculate the slope of the NN DDXS. More...
 
 CrossSectionsStrangeness ()
 
virtual G4double elastic (Particle const *const p1, Particle const *const p2)
 second 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 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 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 quasi-elastic 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_kmToL_pp_pm (Particle const *const p1, Particle const *const p2)
 
virtual G4double p_kmToL_pz (Particle const *const p1, Particle const *const p2)
 
G4double p_pimToLK0 (Particle const *const p1, Particle const *const p2)
 
virtual G4double p_pimToSmKp (Particle const *const p1, Particle const *const p2)
 
virtual G4double p_pimToSzKz (Particle const *const p1, Particle const *const p2)
 
G4double p_pipToSpKp (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)
 correction to old cross section More...
 
virtual G4double total (Particle const *const p1, Particle const *const p2)
 second 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, mesonic Resonances and strange cross sections.

Definition at line 55 of file G4INCLCrossSectionsStrangeness.hh.

Constructor & Destructor Documentation

◆ CrossSectionsStrangeness()

G4INCL::CrossSectionsStrangeness::CrossSectionsStrangeness ( )

Definition at line 66 of file G4INCLCrossSectionsStrangeness.cc.

66 :
67 s11pzHC(-2.228000000000294018,8.7560000000005723725,-0.61000000000023239325,-5.4139999999999780324,3.3338333333333348023,-0.75835000000000022049,0.060623611111111114688),
68 s01ppHC(2.0570000000126518344,-6.029000000012135826,36.768500000002462784,-45.275666666666553533,25.112666666666611953,-7.2174166666666639187,1.0478875000000000275,-0.060804365079365080846),
69 s01pzHC(0.18030000000000441851,7.8700999999999953598,-4.0548999999999990425,0.555199999999999959),
70 s11pmHC(0.20590000000000031866,3.3450999999999993936,-1.4401999999999997825,0.17076666666666664973),
71 s12pmHC(-0.77235999999999901328,4.2626599999999991117,-1.9008899999999997323,0.30192266666666663379,-0.012270833333333331986),
72 s12ppHC(-0.75724999999999975664,2.0934399999999998565,-0.3803099999999999814),
73 s12zzHC(-0.89599999999996965072,7.882999999999978632,-7.1049999999999961928,1.884333333333333089),
74 s02pzHC(-1.0579999999999967036,11.113999999999994089,-8.5259999999999990196,2.0051666666666666525),
75 s02pmHC(2.4009000000012553286,-7.7680000000013376183,20.619000000000433505,-16.429666666666723928,5.2525708333333363472,-0.58969166666666670206),
76 s12mzHC(-0.21858699999999976269,1.9148999999999999722,-0.31727500000000001065,-0.027695000000000000486)
77 {
78 }
G4INCL::CrossSectionsStrangeness::s02pzHC
const HornerC4 s02pzHC
Horner coefficients for s02pz.
Definition: G4INCLCrossSectionsStrangeness.hh:153
G4INCL::CrossSectionsStrangeness::s12pmHC
const HornerC5 s12pmHC
Horner coefficients for s12pm.
Definition: G4INCLCrossSectionsStrangeness.hh:147
G4INCL::CrossSectionsStrangeness::s02pmHC
const HornerC6 s02pmHC
Horner coefficients for s02pm.
Definition: G4INCLCrossSectionsStrangeness.hh:155
G4INCL::CrossSectionsStrangeness::s01ppHC
const HornerC8 s01ppHC
Horner coefficients for s01pp.
Definition: G4INCLCrossSectionsStrangeness.hh:141
G4INCL::CrossSectionsStrangeness::s11pzHC
const HornerC7 s11pzHC
Horner coefficients for s11pz.
Definition: G4INCLCrossSectionsStrangeness.hh:139
G4INCL::CrossSectionsStrangeness::s12mzHC
const HornerC4 s12mzHC
Horner coefficients for s12mz.
Definition: G4INCLCrossSectionsStrangeness.hh:157
G4INCL::CrossSectionsStrangeness::s12zzHC
const HornerC4 s12zzHC
Horner coefficients for s12zz.
Definition: G4INCLCrossSectionsStrangeness.hh:151
G4INCL::CrossSectionsStrangeness::s11pmHC
const HornerC4 s11pmHC
Horner coefficients for s11pm.
Definition: G4INCLCrossSectionsStrangeness.hh:145
G4INCL::CrossSectionsStrangeness::s12ppHC
const HornerC3 s12ppHC
Horner coefficients for s12pp.
Definition: G4INCLCrossSectionsStrangeness.hh:149
G4INCL::CrossSectionsStrangeness::s01pzHC
const HornerC4 s01pzHC
Horner coefficients for s01pz.
Definition: G4INCLCrossSectionsStrangeness.hh:143

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::CrossSectionsStrangeness::elastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

second new elastic particle-particle cross section

Reimplemented from G4INCL::CrossSectionsMultiPionsAndResonances.

Definition at line 119 of file G4INCLCrossSectionsStrangeness.cc.

119 {
120 if((p1->isNucleon()||p1->isDelta()) && (p2->isNucleon()||p2->isDelta())){ // N-N, N-Delta, Delta-Delta
121 return CrossSectionsMultiPions::elastic(p1, p2);
122 }
123 else if ((p1->isNucleon() && p2->isPion()) || (p2->isNucleon() && p1->isPion())){
124 return CrossSectionsMultiPions::elastic(p1, p2);
125 }
126 else if ((p1->isNucleon() && p2->isEta()) || (p2->isNucleon() && p1->isEta())){
127 return CrossSectionsMultiPionsAndResonances::etaNElastic(p1, p2);
128 }
129 else if ((p1->isNucleon() && p2->isHyperon()) || (p2->isNucleon() && p1->isHyperon())){
130 return NYelastic(p1, p2);
131 }
132 else if ((p1->isNucleon() && p2->isKaon()) || (p2->isNucleon() && p1->isKaon())){
133 return NKelastic(p1, p2);
134 }
135 else if ((p1->isNucleon() && p2->isAntiKaon()) || (p2->isNucleon() && p1->isAntiKaon())){
136 return NKbelastic(p1, p2);
137 }
138 else {
139 return 0.0;
140 }
141 }
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::CrossSectionsMultiPions::elastic
virtual G4double elastic(Particle const *const p1, Particle const *const p2)
Elastic particle-particle cross section.
Definition: G4INCLCrossSectionsMultiPions.cc:807
G4INCL::CrossSectionsStrangeness::NKbelastic
virtual G4double NKbelastic(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:372
G4INCL::CrossSectionsStrangeness::NKelastic
virtual G4double NKelastic(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:335
G4INCL::CrossSectionsStrangeness::NYelastic
virtual G4double NYelastic(Particle const *const p1, Particle const *const p2)
elastic scattering for Nucleon-Strange Particles cross sections
Definition: G4INCLCrossSectionsStrangeness.cc:300

References G4INCL::CrossSectionsMultiPions::elastic(), G4INCL::CrossSectionsMultiPionsAndResonances::etaNElastic(), G4INCL::Particle::isAntiKaon(), G4INCL::Particle::isDelta(), G4INCL::Particle::isEta(), G4INCL::Particle::isHyperon(), G4INCL::Particle::isKaon(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isPion(), NKbelastic(), NKelastic(), and NYelastic().

Referenced by total().

◆ etaNElastic()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::elastic(), and elastic().

◆ etaNToPiN()

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

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, G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN(), G4INCL::PiZero, G4INCL::Proton, and G4INCL::KinematicsUtils::totalEnergyInCM().

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

◆ etaNToPiPiN()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN(), G4INCL::Particle::isEta(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

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

◆ etaPrimeNToPiN()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN().

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

◆ NDeltaToDeltaLK()

G4double G4INCL::CrossSectionsStrangeness::NDeltaToDeltaLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 831 of file G4INCLCrossSectionsStrangeness.cc.

831 {
832 // Nucleon-Delta producing Delta Lambda Kaon cross section
833 //
834 // XS from K. Tsushima, A. Sibirtsev, A. W. Thomas, and G. Q. Li. Phys.Rev.C 59, 369
835 //
836 // ratio
837 // D++ p -> L K+ D++ (4)
838 //
839 // D++ n -> L K+ D+ (3)
840 // D++ n -> L K0 D++ (4)
841 //
842 // D+ p -> L K0 D++ (3)
843 // D+ p -> L K+ D+ (2)
844 //
845 // D+ n -> L K+ D0 (4)
846 // D+ n -> L K0 D+ (2)
847
848 G4double a = 2.679;
849 G4double b = 2.280;
850 G4double c = 5.086;
851 G4double n_channel = 7.;
852
853// assert((p1->isNucleon() && p2->isResonance()) || (p2->isNucleon() && p1->isResonance()));
854
855 const G4double s = KinematicsUtils::squareTotalEnergyInCM(p1 ,p2); // Mev^^2
856 const G4double s0 = 8.096E6; // Mev^2
857 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
858
859 if(s <= s0)
860 return 0.;
861
862 G4double sigma = n_channel*a*std::pow(s/s0-1,b)*std::pow(s0/s,c);
863
864 if(iso == 0)// D+ n
865 sigma *= 6./22.;
866 else if (ParticleTable::getIsospin(p1->getType()) == ParticleTable::getIsospin(p2->getType()))// D+ p
867 sigma *= 5./22.;
868 else if (std::abs(iso) == 2)// D++ n
869 sigma *= 7./22.;
870 else // D++ p
871 sigma *= 4./22.;
872
873 return sigma;
874 }
s
static constexpr double s
Definition: G4SIunits.hh:154
G4int
int G4int
Definition: G4Types.hh:85
G4INCL::KinematicsUtils::squareTotalEnergyInCM
G4double squareTotalEnergyInCM(Particle const *const p1, Particle const *const p2)
Definition: G4INCLKinematicsUtils.cc:98
G4INCL::ParticleTable::getIsospin
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
Definition: G4INCLParticleTable.cc:478

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), s, G4InuclParticleNames::s0, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by total().

◆ NDeltaToDeltaSK()

G4double G4INCL::CrossSectionsStrangeness::NDeltaToDeltaSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 875 of file G4INCLCrossSectionsStrangeness.cc.

875 {
876 // Nucleon-Delta producing Delta Sigma Kaon cross section
877 //
878 // XS from K. Tsushima, A. Sibirtsev, A. W. Thomas, and G. Q. Li. Phys.Rev.C 59, 369
879 //
880 // D++ p (9)
881 // D++ n (15)
882 // D+ p (11)
883 // D+ n (13)
884 //
885 // ratio
886 // D++ p -> S+ K+ D+ (a) (2)
887 // D++ p -> S0 K+ D++ (b) (1)
888 // D++ p -> S+ K0 D++ (c) (6)
889 //
890 // D++ n -> S+ K+ D0 *(d)* (2)
891 // D++ n -> S0 K+ D+ (e) (4)
892 // D++ n -> S- K+ D++ (f) (6)(c)*
893 // D++ n -> S+ K0 D+ (a)* (2)
894 // D++ n -> S0 K0 D++ (b)* (1)*
895 //
896 // D+ p -> S+ K+ D0 (i) (2)*
897 // D+ p -> S0 K+ D+ (j) (1)
898 // D+ p -> S- K+ D++ (k) (2)(g=a)*
899 // D+ p -> S+ K0 D+ (l) (2)
900 // D+ p -> S0 K0 D++ (m) (4)(e)*
901 //
902 // D+ n -> S+ K+ D- *(d)* (2)
903 // D+ n -> S0 K+ D0 (o) (4)
904 // D+ n -> S- K+ D+ (p) (2)*
905 // D+ n -> S+ K0 D0 (i)* (2)*
906 // D+ n -> S0 K0 D+ (j)* (1)*
907 // D+ n -> S- K0 D++ (k)* (2)*
908
909 G4double a = 8.407;
910 G4double b = 2.743;
911 G4double c = 21.18;
912 G4double n_channel = 19.;
913
914// assert((p1->isNucleon() && p2->isResonance()) || (p2->isNucleon() && p1->isResonance()));
915
916 const G4double s = KinematicsUtils::squareTotalEnergyInCM(p1 ,p2); // Mev^^2
917 const G4double s0 = 8.568E6; // Mev^2
918 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
919
920 if(s <= s0)
921 return 0.;
922
923 G4double sigma = n_channel*a*std::pow(s/s0-1,b)*std::pow(s0/s,c);
924
925 if(iso == 0)// D+ n
926 sigma *= 13./48.;
927 else if (ParticleTable::getIsospin(p1->getType()) == ParticleTable::getIsospin(p2->getType()))// D+ p
928 sigma *= 11./48.;
929 else if (std::abs(iso) == 2)// D++ n
930 sigma *= 15./48.;
931 else // D++ p
932 sigma *= 9./48.;
933
934 return sigma;
935 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), s, G4InuclParticleNames::s0, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by total().

◆ NDeltaToNLK()

G4double G4INCL::CrossSectionsStrangeness::NDeltaToNLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-Delta to Stange particles cross sections.

NDelta to strange cross sections.

No experimental data Parametrization from Phys.Rev.C 59 1 (369) (1999)

Correction are applied on the isospin symetry provided in the paper

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 732 of file G4INCLCrossSectionsStrangeness.cc.

732 {
733 // Nucleon-Delta producing Nucleon Lambda Kaon cross section
734 //
735 // XS from K. Tsushima, A. Sibirtsev, A. W. Thomas, and G. Q. Li. Phys.Rev.C 59, 369
736 //
737 // ratio
738 // D++ n -> p L K+ (3)
739 //
740 // D+ p -> p L K+ (1)
741 //
742 // D+ n -> p L K0 (1)
743 // D+ n -> n L K+ (1)
744
745 G4double a = 4.169;
746 G4double b = 2.227;
747 G4double c = 2.511;
748 G4double n_channel = 4.; // number of channel divided by 2. Here 8/2
749
750// assert((p1->isNucleon() && p2->isResonance()) || (p2->isNucleon() && p1->isResonance()));
751
752 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
753 if(std::abs(iso) == 4) return 0.;
754
755 G4double sigma = 0.;
756
757 const G4double s = KinematicsUtils::squareTotalEnergyInCM(p1 ,p2); // MeV^2
758 const G4double s0 = 6.511E6; // MeV^2
759
760 if(s <= s0) return 0.;
761
762 sigma = n_channel*a*std::pow(s/s0-1,b)*std::pow(s0/s,c);
763
764 //const G4double pLab = sdt::sqrt(s*s/(4*ParticleTable::effectiveNucleonMass2)-s)*0.001;
765 //sigma = 3*1.11875*std::pow((pLab-2.3508),1.0951)/std::pow((pLab+2.3508),2.0958); // NDelta sim to NN
766
767 if(iso == 0){ // D+ n
768 sigma *= 2./6.;
769 }
770 else if (ParticleTable::getIsospin(p1->getType()) == ParticleTable::getIsospin(p2->getType())){// D+ p
771 sigma *= 1./6.;
772 }
773 else{// D++ n
774 sigma *= 3./6.;
775 }
776 return sigma;
777 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), s, G4InuclParticleNames::s0, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by total().

◆ 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 }
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::ParticleTable::effectiveNucleonMass2
const G4double effectiveNucleonMass2
Definition: G4INCLParticleTable.hh:70
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(), G4INCL::CrossSectionsMultiPionsAndResonances::total(), and total().

◆ NDeltaToNNKKb()

G4double G4INCL::CrossSectionsStrangeness::NDeltaToNNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 937 of file G4INCLCrossSectionsStrangeness.cc.

937 {
938 // Nucleon-Delta producing Nucleon-Nucleon Kaon antiKaon cross section
939 //
940 // Total = sigma(NN->NNKKb)*10
941 //
942 // D++ p (6)
943 // D++ n (9)
944 // D+ p (7)
945 // D+ n (8)
946 //
947 // ratio
948 // D++ p -> p p K+ K0b (6)
949 //
950 // D++ n -> p p K+ K- (3)
951 // D++ n -> p p K0 K0b (3)
952 // D++ n -> p n K+ K0b (3)
953 //
954 // D+ p -> p p K+ K- (3)
955 // D+ p -> p p K0 K0b (1)
956 // D+ p -> p n K+ K0b (3)
957 //
958 // D+ n -> p p K0 K- (2)
959 // D+ n -> p n K+ K- (1)
960 // D+ n -> p n K0 K0b (3)
961 // D+ n -> n n K+ K0b (2)
962 //
963
964// assert((p1->isNucleon() && p2->isResonance()) || (p2->isNucleon() && p1->isResonance()));
965
966 G4double sigma = 0.;
967 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
968 const G4double ener = 0.001*KinematicsUtils::totalEnergyInCM(p1, p2); // GeV
969
970 if(ener <= 2.872)
971 return 0.;
972
973 if(iso == 0)// D+ n
974 sigma = 8* 22./60. * 3. *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
975 else if (ParticleTable::getIsospin(p1->getType()) == ParticleTable::getIsospin(p2->getType()))// D+ p
976 sigma = 7* 22./60. * 3. *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
977 else if (std::abs(iso) == 2)// D++ n
978 sigma = 9* 22./60. * 3. *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
979 else // D++ p
980 sigma = 6* 22./60. * 3. *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
981
982 return sigma;
983 }

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

Referenced by total().

◆ NDeltaToNSK()

G4double G4INCL::CrossSectionsStrangeness::NDeltaToNSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 778 of file G4INCLCrossSectionsStrangeness.cc.

778 {
779 // Nucleon-Delta producing Nucleon Sigma Kaon cross section
780 //
781 // XS from K. Tsushima, A. Sibirtsev, A. W. Thomas, and G. Q. Li. Phys.Rev.C 59, 369 ( X 1.25 (124/99) for isospin consideration)
782 //
783 // ratio
784 // D++ p -> p S+ K+ (6)
785 //
786 // D++ n -> p S+ K0 (3) ****
787 // D++ n -> p S0 K+ (3)
788 // D++ n -> n S+ K+ (3)
789 //
790 // D+ p -> p S+ K0 (2)
791 // D+ p -> p S0 K+ (2)
792 // D+ p -> n S+ K+ (3)
793 //
794 // D+ n -> p S0 K0 (3)
795 // D+ n -> p S- K+ (2)
796 // D+ n -> n S+ K0 (2)
797 // D+ n -> n S0 K+ (2)
798
799 G4double a = 39.54;
800 G4double b = 2.799;
801 G4double c = 6.303;
802 G4double n_channel = 11.;
803
804// assert((p1->isNucleon() && p2->isResonance()) || (p2->isNucleon() && p1->isResonance()));
805
806 G4double sigma = 0.;
807
808 const G4double s = KinematicsUtils::squareTotalEnergyInCM(p1 ,p2); // Mev^^2
809 const G4double s0 = 6.935E6; // Mev^2
810 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
811
812 if(s <= s0)
813 return 0.;
814
815 sigma = n_channel*a*std::pow(s/s0-1,b)*std::pow(s0/s,c);
816
817 //const G4double pLab = sdt::sqrt(s*s/(4*ParticleTable::effectiveNucleonMass2)-s)*0.001;
818 //sigma = 22./12./2. * 4.75*6.38*std::pow(pLab-2.593,2.1)/std::pow(pLab,4.162); // NDelta sim to NN
819
820 if(iso == 0)// D+ n
821 sigma *= 9./31.;
822 else if (ParticleTable::getIsospin(p1->getType()) == ParticleTable::getIsospin(p2->getType()))// D+ p
823 sigma *= 7./31.;
824 else if (std::abs(iso) == 2)// D++ n
825 sigma *= 9./31.;
826 else // D++ p
827 sigma *= 6./31.;
828
829 return sigma;
830 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), s, G4InuclParticleNames::s0, and G4INCL::KinematicsUtils::squareTotalEnergyInCM().

Referenced by total().

◆ NKbelastic()

G4double G4INCL::CrossSectionsStrangeness::NKbelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 372 of file G4INCLCrossSectionsStrangeness.cc.

372 {
373 //
374 // antiKaon-Nucleon elastic cross sections
375 //
376// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
377
378 G4double sigma=0.;
379
380 const Particle *antikaon;
381 const Particle *nucleon;
382
383 if (p1->isAntiKaon()) {
384 antikaon = p1;
385 nucleon = p2;
386 }
387 else {
388 antikaon = p2;
389 nucleon = p1;
390 }
391
392 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
393
394 if(pLab > 1E-6) // sigma = 287.823 [mb] -> rise very slowly, not cut needed
395 sigma = 6.132*std::pow(pLab,-0.2437)+12.98*std::exp(-std::pow(pLab-0.9902,2)/0.05558)+2.928*std::exp(-std::pow(pLab-1.649,2)/0.772)+564.3*std::exp(-std::pow(pLab+0.9901,2)/0.5995);
396
397 if (sigma < 0.) sigma = 0.; // should never happen
398 return sigma;
399 }

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

Referenced by elastic().

◆ NKbToL2pi()

G4double G4INCL::CrossSectionsStrangeness::NKbToL2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1865 of file G4INCLCrossSectionsStrangeness.cc.

1865 {
1866 //
1867 // Nucleon-antiKaon producing Lambda-2pion cross sections
1868 //
1869 // ratio
1870 // p K0b -> L pi+ pi0 (1)
1871 // p K- -> L pi+ pi- (1)
1872 // p K- -> L pi0 pi0 (1/4)
1873
1874// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1875
1876 G4double sigma = 0.;
1877 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1878
1879 const Particle *antikaon;
1880 const Particle *nucleon;
1881
1882 if (p1->isAntiKaon()) {
1883 antikaon = p1;
1884 nucleon = p2;
1885 }
1886 else {
1887 antikaon = p2;
1888 nucleon = p1;
1889 }
1890
1891 if(iso == 0)
1892 sigma = 1.25*p_kmToL_pp_pm(antikaon,nucleon);
1893 else
1894 sigma = p_kmToL_pp_pm(antikaon,nucleon);
1895
1896 return sigma;
1897 }
G4INCL::CrossSectionsStrangeness::p_kmToL_pp_pm
virtual G4double p_kmToL_pp_pm(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1898

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4InuclParticleNames::nucleon(), and p_kmToL_pp_pm().

Referenced by total().

◆ NKbToLpi()

G4double G4INCL::CrossSectionsStrangeness::NKbToLpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1764 of file G4INCLCrossSectionsStrangeness.cc.

1764 {
1765 //
1766 // Nucleon-antiKaon producing Lambda-pion cross sections
1767 //
1768 // ratio
1769 // p K0b (1) p K- (1/2)
1770 //
1771 // p K- -> L pi0 (1/2)
1772 // p K0b -> L pi+ (1)
1773// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1774
1775 G4double sigma = 0.;
1776 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1777
1778 const Particle *antikaon;
1779 const Particle *nucleon;
1780
1781 if (p1->isAntiKaon()) {
1782 antikaon = p1;
1783 nucleon = p2;
1784 }
1785 else {
1786 antikaon = p2;
1787 nucleon = p1;
1788 }
1789 if(iso == 0)
1790 sigma = p_kmToL_pz(antikaon,nucleon);
1791 else
1792 sigma = 2*p_kmToL_pz(antikaon,nucleon);
1793
1794 return sigma;
1795 }
G4INCL::CrossSectionsStrangeness::p_kmToL_pz
virtual G4double p_kmToL_pz(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1796

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4InuclParticleNames::nucleon(), and p_kmToL_pz().

Referenced by total().

◆ NKbToNKb()

G4double G4INCL::CrossSectionsStrangeness::NKbToNKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-antiKaon cross sections.

NKb cross sections.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1663 of file G4INCLCrossSectionsStrangeness.cc.

1663 {
1664 //
1665 // Nucleon-antiKaon quasi-elastic cross sections
1666 //
1667// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1668
1669 G4double sigma=0.;
1670 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1671
1672 const Particle *antikaon;
1673 const Particle *nucleon;
1674
1675 if (p1->isAntiKaon()) {
1676 antikaon = p1;
1677 nucleon = p2;
1678 }
1679 else {
1680 antikaon = p2;
1681 nucleon = p1;
1682 }
1683
1684 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
1685
1686 if(iso != 0) // K0b p and K- n -> forbidden: quasi-elastic diffusion only
1687 return 0;
1688 else if(nucleon->getType() == Proton){ // K- p -> K0b n
1689 if(pLab < 0.08921)
1690 return 0.;
1691 else if(pLab < 0.2)
1692 sigma = 0.4977*std::pow(pLab - 0.08921,0.5581)/std::pow(pLab,2.704);
1693 else if(pLab < 0.73)
1694 sigma = 2.*std::pow(pLab,-1.2) + 6.493*std::exp(-0.5*std::pow((pLab-0.3962)/0.02,2));
1695 else if(pLab < 1.38)
1696 sigma = 2.3*std::pow(pLab,-0.9) + 1.1*std::exp(-0.5*std::pow((pLab-0.82)/0.04,2)) + 5.*std::exp(-0.5*std::pow((pLab-1.04)/0.1,2));
1697 else if(pLab < 30.)
1698 sigma = 2.5*std::pow(pLab,-1.68) + 0.7*std::exp(-0.5*std::pow((pLab-1.6)/0.2,2)) + 0.2*std::exp(-0.5*std::pow((pLab-2.3)/0.2,2));
1699 else sigma = 0.;
1700 }
1701 else{ // K0b n -> K- p (same as K- p but without threshold)
1702 if(pLab < 0.1)
1703 sigma = 30.;
1704 else if(pLab < 0.73)
1705 sigma = 2.*std::pow(pLab,-1.2) + 6.493*std::exp(-0.5*std::pow((pLab-0.3962)/0.02,2));
1706 else if(pLab < 1.38)
1707 sigma = 2.3*std::pow(pLab,-0.9) + 1.1*std::exp(-0.5*std::pow((pLab-0.82)/0.04,2)) + 5.*std::exp(-0.5*std::pow((pLab-1.04)/0.1,2));
1708 else if(pLab < 30.)
1709 sigma = 2.5*std::pow(pLab,-1.68) + 0.7*std::exp(-0.5*std::pow((pLab-1.6)/0.2,2)) + 0.2*std::exp(-0.5*std::pow((pLab-2.3)/0.2,2));
1710 else sigma = 0.;
1711 }
1712 return sigma;
1713 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), and G4INCL::Proton.

Referenced by total().

◆ NKbToNKb2pi()

G4double G4INCL::CrossSectionsStrangeness::NKbToNKb2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1957 of file G4INCLCrossSectionsStrangeness.cc.

1957 {
1958 //
1959 // Nucleon-antiKaon producing Nucleon-antiKaon-2pion cross sections
1960 //
1961 // ratio
1962 // p K0b (4.25) p K- (4.75)
1963 //
1964 // p K0b -> p K0b pi+ pi- (1)
1965 // p K0b -> p K0b pi0 pi0 (1/4)
1966 // p K0b -> p K- pi+ pi0 (1)
1967 // p K0b -> n K0b pi+ pi0 (1)
1968 // p K0b -> n K- pi+ pi+ (1)
1969 // p K- -> p K0b pi0 pi- (1)
1970 // p K- -> p K- pi+ pi- (1)
1971 // p K- -> p K- pi0 pi0 (1/4)
1972 // p K- -> n K0b pi+ pi- (1)
1973 // p K- -> n K0b pi0 pi0 (1/2)
1974 // p K- -> n K- pi+ pi0 (1)
1975
1976// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1977
1978 G4double sigma=0.;
1979 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1980
1981 const Particle *antikaon;
1982 const Particle *nucleon;
1983
1984 if (p1->isAntiKaon()) {
1985 antikaon = p1;
1986 nucleon = p2;
1987 }
1988 else {
1989 antikaon = p2;
1990 nucleon = p1;
1991 }
1992
1993 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
1994
1995 if(pLab < 0.85)
1996 return 0.;
1997
1998 if(iso == 0)
1999 sigma = 4.75 * 26.8*std::pow(pLab-0.85,4.9)/std::pow(pLab,6.34);
2000 else
2001 sigma = 4.25 * 26.8*std::pow(pLab-0.85,4.9)/std::pow(pLab,6.34);
2002
2003 return sigma;
2004 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by total().

◆ NKbToNKbpi()

G4double G4INCL::CrossSectionsStrangeness::NKbToNKbpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1911 of file G4INCLCrossSectionsStrangeness.cc.

1911 {
1912 //
1913 // Nucleon-antiKaon producing Nucleon-antiKaon-pion cross sections
1914 //
1915 // ratio
1916 // p K- (28) p K0b (20)
1917 //
1918 // p K- -> p K- pi0 (6)*
1919 // p K- -> p K0b pi- (7)*
1920 // p K- -> n K- pi+ (9)*
1921 // p K- -> n K0b pi0 (6)
1922 // p K0b -> p K0b pi0 (4)
1923 // p K0b -> p K- pi+ (10)*
1924 // p K0b -> n K0b pi+ (6)*
1925 //
1926
1927// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1928
1929 G4double sigma=0.;
1930 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1931
1932 const Particle *antikaon;
1933 const Particle *nucleon;
1934
1935 if (p1->isAntiKaon()) {
1936 antikaon = p1;
1937 nucleon = p2;
1938 }
1939 else {
1940 antikaon = p2;
1941 nucleon = p1;
1942 }
1943
1944 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
1945
1946 if(pLab < 0.526)
1947 return 0.;
1948
1949 if(iso == 0)
1950 sigma = 28. * 10.13*std::pow(pLab-0.526,5.846)/std::pow(pLab,8.343);
1951 else
1952 sigma = 20. * 10.13*std::pow(pLab-0.526,5.846)/std::pow(pLab,8.343);
1953
1954 return sigma;
1955 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by total().

◆ NKbToS2pi()

G4double G4INCL::CrossSectionsStrangeness::NKbToS2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1813 of file G4INCLCrossSectionsStrangeness.cc.

1813 {
1814 //
1815 // Nucleon-antiKaon producing Sigma-2pion cross sections
1816 //
1817 // ratio
1818 // p K0b (29/12) p K- (59/24)
1819 //
1820 // p K0b -> S+ pi+ pi- (2/3)
1821 // p K0b -> S+ pi0 pi0 (1/4)
1822 // p K0b -> S0 pi+ pi0 (5/6)
1823 // p K0b -> S- pi+ pi+ (2/3)
1824 // p K- -> S+ pi0 pi- (1)
1825 // p K- -> S0 pi+ pi- (2/3)
1826 // p K- -> S0 pi0 pi0 (1/8)
1827 // p K- -> S- pi+ pi0 (2/3)
1828
1829// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1830
1831 G4double sigma=0.;
1832 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1833
1834 const Particle *antikaon;
1835 const Particle *nucleon;
1836
1837 if (p1->isAntiKaon()) {
1838 antikaon = p1;
1839 nucleon = p2;
1840 }
1841 else {
1842 antikaon = p2;
1843 nucleon = p1;
1844 }
1845
1846 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
1847
1848 if(pLab < 0.260)
1849 return 0.;
1850
1851 if(iso == 0)
1852 sigma = 29./12.*3./2.*(49.96*std::pow(pLab-0.260,6.398)/std::pow(pLab+0.260,9.732)+0.1451*std::exp(-std::pow(pLab-0.4031,2)/0.00115));
1853 else
1854 sigma = 54./24.*3./2.*(49.96*std::pow(pLab-0.260,6.398)/std::pow(pLab+0.260,9.732)+0.1451*std::exp(-std::pow(pLab-0.4031,2)/0.00115));
1855
1856 /*
1857 if(iso == 0)
1858 sigma = 29./12.*(85.46*std::pow(pLab-0.226,8.118)/std::pow(pLab+0.226,11.69)+0.1451*std::exp(-std::pow(pLab-0.4031,2)/0.00115));
1859 else
1860 sigma = 54./24.*(85.46*std::pow(pLab-0.226,8.118)/std::pow(pLab+0.226,11.69)+0.1451*std::exp(-std::pow(pLab-0.4031,2)/0.00115));*/
1861
1862 return sigma;
1863 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by total().

◆ NKbToSpi()

G4double G4INCL::CrossSectionsStrangeness::NKbToSpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1715 of file G4INCLCrossSectionsStrangeness.cc.

1715 {
1716 //
1717 // Nucleon-antiKaon producing Sigma-pion cross sections
1718 //
1719 // ratio
1720 // p K0b (4/3) p K- (13/6)
1721 //
1722 // p K0b -> S+ pi0 (2/3)
1723 // p K0b -> S0 pi+ (2/3)
1724 // p K- -> S+ pi- (1)
1725 // p K- -> S0 pi0 (1/2)
1726 // p K- -> S- pi+ (2/3)
1727
1728// assert((p1->isNucleon() && p2->isAntiKaon()) || (p1->isAntiKaon() && p2->isNucleon()));
1729
1730 G4double sigma=0.;
1731 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1732
1733 const Particle *antikaon;
1734 const Particle *nucleon;
1735
1736 if (p1->isAntiKaon()) {
1737 antikaon = p1;
1738 nucleon = p2;
1739 }
1740 else {
1741 antikaon = p2;
1742 nucleon = p1;
1743 }
1744
1745 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antikaon, nucleon); // GeV
1746
1747 if(iso == 0){
1748 if(pLab < 0.1)
1749 return 152.0; // 70.166*13/6
1750 else
1751 sigma = 13./6.*(1.4*std::pow(pLab,-1.7)+1.88*std::exp(-std::pow(pLab-0.747,2)/0.005)+8*std::exp(-std::pow(pLab-0.4,2)/0.002)+0.8*std::exp(-std::pow(pLab-1.07,2)/0.01));
1752 }
1753 else{
1754 if(pLab < 0.1)
1755 return 93.555; // 70.166*4/3
1756 else
1757 sigma = 4./3.*(1.4*std::pow(pLab,-1.7)+1.88*std::exp(-std::pow(pLab-0.747,2)/0.005)+8*std::exp(-std::pow(pLab-0.4,2)/0.002)+0.8*std::exp(-std::pow(pLab-1.07,2)/0.01));
1758 //sigma = 4./3.*(1.4*std::pow(pLab,-1.7)+1.88*std::exp(-std::pow(pLab-0.747,2)/0.005)+0.8*std::exp(-std::pow(pLab-1.07,2)/0.01));
1759 }
1760
1761 return sigma;
1762 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isAntiKaon(), G4INCL::KinematicsUtils::momentumInLab(), and G4InuclParticleNames::nucleon().

Referenced by total().

◆ NKelastic()

G4double G4INCL::CrossSectionsStrangeness::NKelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 335 of file G4INCLCrossSectionsStrangeness.cc.

335 {
336 //
337 // Kaon-Nucleon elastic cross sections
338 //
339// assert((p1->isNucleon() && p2->isKaon()) || (p1->isKaon() && p2->isNucleon()));
340
341 G4double sigma=0.;
342
343 const Particle *kaon;
344 const Particle *nucleon;
345
346 if (p1->isKaon()) {
347 kaon = p1;
348 nucleon = p2;
349 }
350 else {
351 kaon = p2;
352 nucleon = p1;
353 }
354
355 const G4double pLab = KinematicsUtils::momentumInLab(kaon, nucleon); // MeV
356
357 if (pLab < 935.)
358 sigma = 12.;
359 else if (pLab < 2080.)
360 sigma = 17.4-3.*std::exp(6.3e-4*pLab);
361 else if (pLab < 5500.)
362 sigma = 832.*std::pow(pLab,-0.64);
363 else if (pLab < 30000.)
364 sigma = 3.36;
365 else
366 sigma=0.;
367
368 if (sigma < 0.) sigma = 0.; // should never happen
369 return sigma;
370 }

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

Referenced by elastic().

◆ NKToNK()

G4double G4INCL::CrossSectionsStrangeness::NKToNK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-Kaon cross sections.

NK cross sections.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1526 of file G4INCLCrossSectionsStrangeness.cc.

1526 {
1527 //
1528 // Nucleon-Kaon quasi-elastic cross sections
1529 //
1530// assert((p1->isNucleon() && p2->isKaon()) || (p2->isNucleon() && p1->isKaon()));
1531
1532 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1533
1534 if(iso != 0)
1535 return 0.;
1536
1537 const Particle *particle1;
1538 const Particle *particle2;
1539
1540 if(p1->isKaon()){
1541 particle1 = p1;
1542 particle2 = p2;
1543 }
1544 else{
1545 particle1 = p2;
1546 particle2 = p1;
1547 }
1548
1549 G4double sigma = 0.;
1550 G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1551
1552 if(particle1->getType() == Proton)
1553 pLab += 2*0.0774;
1554
1555 if(pLab <= 0.0774)
1556 return 0.;
1557
1558 sigma = 12.84*std::pow((pLab-0.0774),18.19)/std::pow((pLab),20.41);
1559
1560 return sigma;
1561 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isKaon(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::Proton.

Referenced by total().

◆ NKToNK2pi()

G4double G4INCL::CrossSectionsStrangeness::NKToNK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1607 of file G4INCLCrossSectionsStrangeness.cc.

1607 {
1608 //
1609 // Nucleon-Kaon producing Nucleon-Kaon-2pion cross sections
1610 //
1611 // p K+ (2.875) p K0 (3.125)
1612 //
1613 // p K+ -> p K+ pi+ pi- (1)
1614 // p K+ -> p K+ pi0 pi0 (1/8)
1615 // p K+ -> p K0 pi+ pi0 (1)
1616 // p K+ -> n K+ pi+ pi0 (1/2)
1617 // p K+ -> n K0 pi+ pi+ (1/4)
1618 // p K0 -> p K+ pi0 pi- (1)
1619 // p K0 -> p K0 pi+ pi- (1)
1620 // p K0 -> p K0 pi0 pi0 (1/8)
1621 // p K0 -> n K+ pi+ pi- (1/4)
1622 // p K0 -> n K+ pi0 pi0 (1/4)
1623 // p K0 -> n K0 pi+ pi0 (1/2)
1624
1625// assert((p1->isNucleon() && p2->isKaon()) || (p2->isNucleon() && p1->isKaon()));
1626
1627 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1628
1629 const Particle *particle1;
1630 const Particle *particle2;
1631
1632 if(p1->isKaon()){
1633 particle1 = p1;
1634 particle2 = p2;
1635 }
1636 else{
1637 particle1 = p2;
1638 particle2 = p1;
1639 }
1640
1641 G4double sigma = 0.;
1642 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1643
1644 if(pLab < 0.812)
1645 sigma = 0.;
1646 else if(pLab < 1.744)
1647 sigma = 26.41*std::pow(pLab-0.812,7.138)/std::pow(pLab,5.337);
1648 else if(pLab < 3.728)
1649 sigma = 1572.*std::pow(pLab-0.812,9.069)/std::pow(pLab,12.44);
1650 else
1651 sigma = 60.23*std::pow(pLab-0.812,5.084)/std::pow(pLab,6.72);
1652
1653 if(iso == 0)
1654 sigma *= 3.125;
1655 else
1656 sigma *= 2.875;
1657
1658 return sigma;
1659 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isKaon(), and G4INCL::KinematicsUtils::momentumInLab().

Referenced by total().

◆ NKToNKpi()

G4double G4INCL::CrossSectionsStrangeness::NKToNKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1563 of file G4INCLCrossSectionsStrangeness.cc.

1563 {
1564 //
1565 // Nucleon-Kaon producing Nucleon-Kaon-pion cross sections
1566 //
1567 // Ratio determined by meson symmetry using only "resonante" diagram (with Delta or K*)
1568 //
1569 // ratio: K+ p (5) K0 p (5.545)
1570 //
1571 // K+ p -> p K+ pi0 1.2
1572 // K+ p -> p K0 pi+ 3
1573 // K+ p -> n K+ pi+ 0.8
1574 // K0 p -> p K+ pi- 1
1575 // K0 p -> p K0 pi0 0.845
1576 // K0 p -> n K+ pi0 1.47
1577 // K0 p -> n K0 pi+ 2.23
1578// assert((p1->isNucleon() && p2->isKaon()) || (p2->isNucleon() && p1->isKaon()));
1579
1580 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1581
1582 const Particle *particle1;
1583 const Particle *particle2;
1584
1585 if(p1->isKaon()){
1586 particle1 = p1;
1587 particle2 = p2;
1588 }
1589 else{
1590 particle1 = p2;
1591 particle2 = p1;
1592 }
1593
1594 G4double sigma = 0.;
1595 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1596
1597 if(pLab <= 0.53)
1598 return 0.;
1599
1600 if(iso == 0)
1601 sigma = 5.55*116.8*std::pow(pLab-0.53,6.874)/std::pow(pLab,10.11);
1602 else
1603 sigma = 5.*116.8*std::pow(pLab-0.53,6.874)/std::pow(pLab,10.11);;
1604 return sigma;
1605 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isKaon(), and G4INCL::KinematicsUtils::momentumInLab().

Referenced by total().

◆ NLToNS()

G4double G4INCL::CrossSectionsStrangeness::NLToNS ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-Hyperon quasi-elastic cross sections.

NY cross sections.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1423 of file G4INCLCrossSectionsStrangeness.cc.

1423 {
1424 //
1425 // Nucleon-Lambda producing Nucleon-Sigma cross sections
1426 //
1427 // ratio
1428 // p L -> p S0 (1/2)
1429 // p L -> n S+ (1)
1430
1431
1432// assert((p1->isLambda() && p2->isNucleon()) || (p2->isLambda() && p1->isNucleon()));
1433
1434 G4double sigma = 0.;
1435
1436 const Particle *particle1;
1437 const Particle *particle2;
1438
1439 if(p1->isLambda()){
1440 particle1 = p1;
1441 particle2 = p2;
1442 }
1443 else{
1444 particle1 = p2;
1445 particle2 = p1;
1446 }
1447
1448 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2);
1449
1450 if(pLab < 0.664)
1451 return 0.;
1452
1453 sigma = 3 * 8.74*std::pow((pLab-0.664),0.438)/std::pow(pLab,2.717); // 3 * L p -> S0 p
1454
1455 return sigma;
1456 }

References G4INCL::Particle::isLambda(), and G4INCL::KinematicsUtils::momentumInLab().

Referenced by total().

◆ 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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaOmega(), NNToNLK2pi(), NNToNLKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi(), NNToNSK2pi(), 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(), NNToNLK2pi(), NNToNLKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), NNToNSK2pi(), 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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::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::CrossSectionsStrangeness::NNToMissingStrangeness ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 700 of file G4INCLCrossSectionsStrangeness.cc.

700 {
701 //
702 // Nucleon-Nucleon missing strangeness production cross sections
703 //
704// assert(p1->isNucleon() && p2->isNucleon());
705
706 G4double sigma = 0.;
707
708 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
709 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
710
711 if(pLab < 6.) return 0.;
712
713 if(iso == 0){
714 if(pLab < 30.) sigma = 10.15*std::pow((pLab - 6.),2.157)/std::pow(pLab,2.333);
715 else return 0.;
716 }
717 else{
718 if(pLab < 30.) sigma = 8.12*std::pow((pLab - 6.),2.157)/std::pow(pLab,2.333);
719 else return 0.;
720 }
721 return sigma;
722 }

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

Referenced by NNToxPiNN().

◆ 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 
)
virtualinherited

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNDeltaOmega()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNLK()

G4double G4INCL::CrossSectionsStrangeness::NNToNLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-Nucleon to Stange particles cross sections.

NN to strange cross sections.

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 403 of file G4INCLCrossSectionsStrangeness.cc.

403 {
404 //
405 // Nucleon-Nucleon producing N-Lambda-Kaon cross sections
406 //
407 // ratio
408 // p p (1) p n (1)
409 //
410 // p p -> p L K+ (1)
411 // p n -> p L K0 (1/2)
412 // p n -> n L K+ (1/2)
413// assert(p1->isNucleon() && p2->isNucleon());
414
415 const Particle *particle1;
416 const Particle *particle2;
417
418 if(p2->getType() == Proton && p1->getType() == Neutron){
419 particle1 = p2;
420 particle2 = p1;
421 }
422 else{
423 particle1 = p1;
424 particle2 = p2;
425 }
426
427 G4double sigma = 0.;
428
429 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1, particle2); // GeV
430
431 if(particle2->getType() == Proton){
432 if(pLab < 2.3393) return 0.;
433 else if (pLab < 30.) sigma = 1.11875*std::pow((pLab-2.3393),1.0951)/std::pow((pLab+2.3393),2.0958); // pLab = 30 Gev -> exess of energie = 5 GeV
434 else return 0.;
435 }
436 else{
437 if(pLab < 2.3508) return 0.;
438 else if (pLab < 30.) sigma = 1.11875*std::pow((pLab-2.3508),1.0951)/std::pow((pLab+2.3508),2.0958);
439 else return 0.;
440 }
441
442 return sigma;
443 }

References G4INCL::Particle::getType(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::Neutron, and G4INCL::Proton.

Referenced by NNToNLKpi(), and NNToxPiNN().

◆ NNToNLK2pi()

G4double G4INCL::CrossSectionsStrangeness::NNToNLK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 597 of file G4INCLCrossSectionsStrangeness.cc.

597 {
598 //
599 // Nucleon-Nucleon producing N-Lambda-Kaon-pion cross sections
600 //
601// assert(p1->isNucleon() && p2->isNucleon());
602
603 G4double sigma = 0.;
604 G4double ratio = 0.;
605 G4double ratio1 = 0.;
606 G4double ratio2 = 0.;
607 const G4double ener = KinematicsUtils::totalEnergyInCM(p1, p2) - 675.;
608 if( ener < p1->getMass() + p2->getMass())
609 return 0;
610 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
611
612 const G4double xsiso2 = CrossSectionsMultiPions::NNInelasticIso(ener, 2);
613 if (iso != 0){
614 ratio1 = CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
615 ratio2 = CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
616 }
617 else {
618 const G4double xsiso0 = CrossSectionsMultiPions::NNInelasticIso(ener, 0);
619 ratio1 = 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
620 ratio2 = 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
621 }
622
623 if( ratio1 == 0 || ratio2 == 0)
624 return 0.;
625
626 ratio = ratio2/ratio1;
627
628 sigma = ratio * NNToNLKpi(p1,p2);
629
630 return sigma;
631 }
G4INCL::CrossSectionsStrangeness::NNToNLKpi
virtual G4double NNToNLKpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:491

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

Referenced by NNToxPiNN().

◆ NNToNLKpi()

G4double G4INCL::CrossSectionsStrangeness::NNToNLKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 491 of file G4INCLCrossSectionsStrangeness.cc.

491 {
492 //
493 // Nucleon-Nucleon producing N-Lambda-Kaon-pion cross sections
494 //
495 // ratio (pure NN -> DLK)
496 // pp (12) pn (8)
497 //
498 // pp -> p pi+ L K0 (9)(3)
499 // pp -> p pi0 L K+ (2)(1*2/3)
500 // pp -> n pi+ L K+ (1)(1*1/3)
501 //
502 // pn -> p pi- L K+ (2)(2*1/3)
503 // pn -> n pi0 L K+ (4)(2*2/3)
504 // pn -> p pi0 L K0 (4)
505 // pn -> n pi+ L K0 (2)
506
507// assert(p1->isNucleon() && p2->isNucleon());
508
509 G4double sigma = 0.;
510 G4double ratio = 0.;
511 G4double ratio1 = 0.;
512 G4double ratio2 = 0.;
513 const G4double ener = KinematicsUtils::totalEnergyInCM(p1, p2) - 540.;
514 if( ener < p1->getMass() + p2->getMass())
515 return 0;
516 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
517
518 const G4double xsiso2 = CrossSectionsMultiPions::NNInelasticIso(ener, 2);
519 if (iso != 0){
520 ratio1 = CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
521 ratio2 = CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
522 }
523 else {
524 const G4double xsiso0 = CrossSectionsMultiPions::NNInelasticIso(ener, 0);
525 ratio1 = 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
526 ratio2 = 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
527 }
528
529 if( ratio1 == 0 || ratio2 == 0)
530 return 0.;
531
532 ratio = ratio2/ratio1;
533
534 sigma = ratio * NNToNLK(p1,p2) * 3;
535
536/* const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1, p2); // GeV
537 if(pLab <= 2.77) return 0.;
538 sigma = 0.4 * std::pow(pLab-2.77,1.603)/std::pow(pLab,1.492);*/
539
540 return sigma;
541 }
G4INCL::CrossSectionsStrangeness::NNToNLK
virtual G4double NNToNLK(Particle const *const p1, Particle const *const p2)
Nucleon-Nucleon to Stange particles cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:403

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

Referenced by NNToNLK2pi(), and NNToxPiNN().

◆ NNToNNEta()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

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

◆ NNToNNEtaExclu()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

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

◆ NNToNNEtaExcluIso()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso().

◆ NNToNNEtaFourPi()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi(), s, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi().

◆ NNToNNEtaIso()

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

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, G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso(), and G4INCL::Proton.

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta().

◆ NNToNNEtaOnePi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi().

◆ NNToNNEtaOnePiOrDelta()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaEta(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi().

◆ NNToNNEtaThreePi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi().

◆ NNToNNEtaTwoPi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi().

◆ NNToNNEtaxPi()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNNKKb()

G4double G4INCL::CrossSectionsStrangeness::NNToNNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 669 of file G4INCLCrossSectionsStrangeness.cc.

669 {
670 //
671 // Nucleon-Nucleon producing Nucleon-Nucleon-Kaon-antiKaon cross sections
672 //
673 // Channel strongly resonant; fit from Sibirtesev - Z. Phys. A 358, 101-106 (1997) (eq.21)
674 // ratio
675 // pp (6) pn (13)*2
676 // pp -> pp K+ K- (1)
677 // pp -> pp K0 K0 (1)
678 // pp -> pn K+ K0 (4)
679 // pn -> pp K0 K- (4)
680 // pn -> pn K+ K- (9)
681 //
682
683// assert(p1->isNucleon() && p2->isNucleon());
684
685 G4double sigma = 0.;
686 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
687 const G4double ener = 0.001*KinematicsUtils::totalEnergyInCM(p1, p2); // GeV
688
689 if(ener < 2.872)
690 return 0.;
691
692 if(iso == 0)
693 sigma = 26 * 5./19. * 0.3 *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
694 else
695 sigma = 6 * 5./19. * 0.3 *std::pow(1.-2.872*2.872/(ener*ener),3.)*std::pow(2.872*2.872/(ener*ener),0.8);
696
697 return sigma;
698 }

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

Referenced by NNToxPiNN().

◆ NNToNNOmega()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

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

◆ NNToNNOmegaExclu()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso(), and G4INCL::KinematicsUtils::totalEnergyInCM().

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

◆ NNToNNOmegaExcluIso()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaIso().

◆ NNToNNOmegaFourPi()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi(), s, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi().

◆ NNToNNOmegaIso()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso().

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega().

◆ NNToNNOmegaOnePi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi().

◆ NNToNNOmegaOnePiOrDelta()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaOmega(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi().

◆ NNToNNOmegaThreePi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi().

◆ NNToNNOmegaTwoPi()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi(), and G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi().

◆ NNToNNOmegaxPi()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi(), and G4INCL::KinematicsUtils::totalEnergyInCM().

◆ NNToNSK()

G4double G4INCL::CrossSectionsStrangeness::NNToNSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 445 of file G4INCLCrossSectionsStrangeness.cc.

445 {
446 //
447 // Nucleon-Nucleon producing N-Sigma-Kaon cross sections
448 //
449 // Meson symmetry
450 // pp->pS+K0 (1/4)
451 // pp->pS0K+ (1/8) // HEM
452 // pp->pS0K+ (1/4) // Data
453 // pp->nS+K+ (1)
454 //
455 // pn->nS+K0 (1/4)
456 // pn->pS-K+ (1/4)
457 // pn->nS0K+ (5/8)
458 // pn->pS0K0 (5/8)
459 //
460// assert(p1->isNucleon() && p2->isNucleon());
461
462 const Particle *particle1;
463 const Particle *particle2;
464
465 if(p2->getType() == Proton && p1->getType() == Neutron){
466 particle1 = p2;
467 particle2 = p1;
468 }
469 else{
470 particle1 = p1;
471 particle2 = p2;
472 }
473
474 G4double sigma = 0.;
475
476 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1, particle2); // GeV
477
478 if(pLab < 2.593)
479 return 0.;
480
481 if(p2->getType() == p1->getType())
482// sigma = 1.375*2*6.38*std::pow(pLab-2.57,2.1)/std::pow(pLab,4.162);
483 sigma = 1.5*6.38*std::pow(pLab-2.593,2.1)/std::pow(pLab,4.162);
484 else
485 sigma = 1.75*6.38*std::pow(pLab-2.593,2.1)/std::pow(pLab,4.162);
486
487
488 return sigma;
489 }

References G4INCL::Particle::getType(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::Neutron, and G4INCL::Proton.

Referenced by NNToNSKpi(), and NNToxPiNN().

◆ NNToNSK2pi()

G4double G4INCL::CrossSectionsStrangeness::NNToNSK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 633 of file G4INCLCrossSectionsStrangeness.cc.

633 {
634 //
635 // Nucleon-Nucleon producing N-Sigma-Kaon-pion cross sections
636 //
637// assert(p1->isNucleon() && p2->isNucleon());
638
639 G4double sigma = 0.;
640 G4double ratio = 0.;
641 G4double ratio1 = 0.;
642 G4double ratio2 = 0.;
643 const G4double ener = KinematicsUtils::totalEnergyInCM(p1, p2) - 755.;
644 if( ener < p1->getMass() + p2->getMass())
645 return 0;
646 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
647
648 const G4double xsiso2 = CrossSectionsMultiPions::NNInelasticIso(ener, 2);
649 if (iso != 0){
650 ratio1 = CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
651 ratio2 = CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
652 }
653 else {
654 const G4double xsiso0 = CrossSectionsMultiPions::NNInelasticIso(ener, 0);
655 ratio1 = 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
656 ratio2 = 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
657 }
658
659 if( ratio1 == 0 || ratio2 == 0)
660 return 0.;
661
662 ratio = ratio2/ratio1;
663
664 sigma = ratio * NNToNSKpi(p1,p2);
665
666 return sigma;
667 }
G4INCL::CrossSectionsStrangeness::NNToNSKpi
virtual G4double NNToNSKpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:543

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

Referenced by NNToxPiNN().

◆ NNToNSKpi()

G4double G4INCL::CrossSectionsStrangeness::NNToNSKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 543 of file G4INCLCrossSectionsStrangeness.cc.

543 {
544 //
545 // Nucleon-Nucleon producing N-Sigma-Kaon-pion cross sections
546 //
547 // ratio (pure NN -> DSK)
548 // pp (36) pn (36)
549 //
550 // pp -> p pi+ S- K+ (9)
551 // pp -> p pi+ S0 K0 (9)
552 // pp -> p pi0 S+ K0 (4)
553 // pp -> n pi+ S+ K0 (2)
554 // pp -> p pi0 S0 K+ (4)
555 // pp -> n pi+ S0 K+ (2)
556 // pp -> p pi- S+ K+ (2)
557 // pp -> n pi0 S+ K+ (4)
558
559 // pn -> p pi0 S- K+ (4)
560 // pn -> n pi+ S- K+ (2)
561 // pn -> p pi0 S0 K0 (2)
562 // pn -> n pi+ S0 K0 (1)
563 // pn -> p pi+ S- K0 (9)
564
565// assert(p1->isNucleon() && p2->isNucleon());
566
567 G4double sigma = 0.;
568 G4double ratio = 0.;
569 G4double ratio1 = 0.;
570 G4double ratio2 = 0.;
571 const G4double ener = KinematicsUtils::totalEnergyInCM(p1, p2) - 620.;
572 if( ener < p1->getMass() + p2->getMass())
573 return 0;
574 const G4int iso = ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
575
576 const G4double xsiso2 = CrossSectionsMultiPions::NNInelasticIso(ener, 2);
577 if (iso != 0){
578 ratio1 = CrossSectionsMultiPions::NNOnePiOrDelta(ener, iso, xsiso2);
579 ratio2 = CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2);
580 }
581 else {
582 const G4double xsiso0 = CrossSectionsMultiPions::NNInelasticIso(ener, 0);
583 ratio1 = 0.5*(CrossSectionsMultiPions::NNOnePiOrDelta(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNOnePiOrDelta(ener, 2, xsiso2));
584 ratio2 = 0.5*(CrossSectionsMultiPions::NNTwoPi(ener, 0, xsiso0)+ CrossSectionsMultiPions::NNTwoPi(ener, 2, xsiso2));
585 }
586
587 if( ratio1 == 0 || ratio2 == 0)
588 return 0.;
589
590 ratio = ratio2/ratio1;
591
592 sigma = ratio * NNToNSK(p1,p2) * 3;
593
594 return sigma;
595 }
G4INCL::CrossSectionsStrangeness::NNToNSK
virtual G4double NNToNSK(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:445

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

Referenced by NNToNSK2pi(), and NNToxPiNN().

◆ 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(), G4INCL::CrossSectionsMultiPionsAndResonances::total(), and 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::CrossSectionsStrangeness::NNToxPiNN ( const G4int  xpi,
Particle const *const  p1,
Particle const *const  p2 
)
virtual

Cross section for X pion production - NN Channel.

Reimplemented from G4INCL::CrossSectionsMultiPionsAndResonances.

Definition at line 213 of file G4INCLCrossSectionsStrangeness.cc.

213 {
214 //
215 // Nucleon-Nucleon producing xpi pions cross sections corrected
216 //
217// assert(xpi>0 && xpi<=nMaxPiNN);
218// assert(particle1->isNucleon() && particle2->isNucleon());
219
220 G4double oldXS1Pi=CrossSectionsMultiPions::NNToxPiNN(1,particle1, particle2);
221 G4double oldXS2Pi=CrossSectionsMultiPions::NNToxPiNN(2,particle1, particle2);
222 G4double oldXS3Pi=CrossSectionsMultiPions::NNToxPiNN(3,particle1, particle2);
223 G4double oldXS4Pi=CrossSectionsMultiPions::NNToxPiNN(4,particle1, particle2);
224 G4double xsEta=CrossSectionsMultiPionsAndResonances::NNToNNEta(particle1, particle2)+CrossSectionsMultiPionsAndResonances::NNToNNOmega(particle1, particle2);;
225
226 const G4double xs1=NNToNLK(particle1, particle2);
227 const G4double xs2=NNToNSK(particle1, particle2);
228 const G4double xs3=NNToNLKpi(particle1, particle2);
229 const G4double xs4=NNToNSKpi(particle1, particle2);
230 const G4double xs5=NNToNLK2pi(particle1, particle2);
231 const G4double xs6=NNToNSK2pi(particle1, particle2);
232 const G4double xs7=NNToNNKKb(particle1, particle2);
233 const G4double xs8=NNToMissingStrangeness(particle1, particle2);
234 const G4double xs0 = xs1 + xs2 + xs3 + xs4 + xs5 + xs6 + xs7 + xs8;
235 G4double newXS1Pi=0.;
236 G4double newXS2Pi=0.;
237 G4double newXS3Pi=0.;
238 G4double newXS4Pi=0.;
239
240 if (xpi == 1) {
241 if (oldXS4Pi != 0. || oldXS3Pi != 0.)
242 newXS1Pi=oldXS1Pi;
243 else if (oldXS2Pi != 0.) {
244 newXS2Pi=oldXS2Pi-xsEta-xs0;
245 if (newXS2Pi < 0.)
246 newXS1Pi=oldXS1Pi-(xsEta+xs0-oldXS2Pi);
247 else
248 newXS1Pi=oldXS1Pi;
249 }
250 else
251 newXS1Pi=oldXS1Pi-xsEta-xs0;
252 return newXS1Pi;
253 }
254 else if (xpi == 2) {
255 if (oldXS4Pi != 0.){
256 newXS2Pi=oldXS2Pi;
257 }
258 else if (oldXS3Pi != 0.) {
259 newXS3Pi=oldXS3Pi-xsEta-xs0;
260 if (newXS3Pi < 0.)
261 newXS2Pi = oldXS2Pi-(xsEta+xs0-oldXS3Pi);
262 else
263 newXS2Pi = oldXS2Pi;
264 }
265 else {
266 newXS2Pi = oldXS2Pi-xsEta-xs0;
267 if (newXS2Pi < 0.)
268 newXS2Pi = 0.;
269 }
270 return newXS2Pi;
271 }
272 else if (xpi == 3) {
273 if (oldXS4Pi != 0.) {
274 newXS4Pi=oldXS4Pi-xsEta-xs0;
275 if (newXS4Pi < 0.)
276 newXS3Pi=oldXS3Pi-(xsEta+xs0-oldXS4Pi);
277 else
278 newXS3Pi=oldXS3Pi;
279 }
280 else {
281 newXS3Pi=oldXS3Pi-xsEta-xs0;
282 if (newXS3Pi < 0.)
283 newXS3Pi=0.;
284 }
285 return newXS3Pi;
286 }
287 else if (xpi == 4) {
288 newXS4Pi=oldXS4Pi-xsEta-xs0;
289 if (newXS4Pi < 0.)
290 newXS4Pi=0.;
291 return newXS4Pi;
292 }
293
294 else // should never reach this point
295 return 0.;
296 }
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
G4INCL::CrossSectionsStrangeness::NNToNLK2pi
virtual G4double NNToNLK2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:597
G4INCL::CrossSectionsStrangeness::NNToNSK2pi
virtual G4double NNToNSK2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:633
G4INCL::CrossSectionsStrangeness::NNToNNKKb
virtual G4double NNToNNKKb(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:669
G4INCL::CrossSectionsStrangeness::NNToMissingStrangeness
virtual G4double NNToMissingStrangeness(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:700

References NNToMissingStrangeness(), NNToNLK(), NNToNLK2pi(), NNToNLKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta(), NNToNNKKb(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega(), NNToNSK(), NNToNSK2pi(), NNToNSKpi(), 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(), NNToNLK2pi(), NNToNLKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi(), NNToNSK2pi(), 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::CrossSectionsStrangeness::NpiToLK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Nucleon-Pion to Stange particles cross sections.

piN to strange cross sections

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 987 of file G4INCLCrossSectionsStrangeness.cc.

987 {
988 //
989 // Pion-Nucleon producing Lambda-Kaon cross sections
990 //
991 // ratio
992 // p pi0 -> L K+ (1/2)
993 // p pi- -> L K0 (1)
994
995// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
996
997 const Particle *pion;
998 const Particle *nucleon;
999 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1000 if(iso == 3 || iso == -3)
1001 return 0.;
1002
1003 if(p1->isPion()){
1004 pion = p1;
1005 nucleon = p2;
1006 }
1007 else{
1008 nucleon = p1;
1009 pion = p2;
1010 }
1011 G4double sigma = 0.;
1012
1013 if(pion->getType() == PiZero)
1014 sigma = 0.5 * p_pimToLK0(pion,nucleon);
1015 else
1016 sigma = p_pimToLK0(pion,nucleon);
1017 return sigma;
1018 }
G4INCL::CrossSectionsStrangeness::p_pimToLK0
G4double p_pimToLK0(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1020
G4InuclParticleNames::pion
G4bool pion(G4int ityp)
Definition: G4InuclParticleNames.hh:90

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4InuclParticleNames::nucleon(), p_pimToLK0(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NpiToLK2pi()

G4double G4INCL::CrossSectionsStrangeness::NpiToLK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1225 of file G4INCLCrossSectionsStrangeness.cc.

1225 {
1226 //
1227 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
1228 //
1229 // p pi+ (2) p pi0 (1.75) p pi- (2.5)
1230 //
1231 // p pi+ -> L K+ pi+ pi0 (1)
1232 // p pi+ -> L K0 pi+ pi+ (1)
1233 // p pi0 -> L K+ pi0 pi0 (1/4)
1234 // p pi0 -> L K+ pi+ pi- (1)
1235 // p pi0 -> L K0 pi+ pi0 (1/2)
1236 // p pi- -> L K+ pi0 pi- (1)
1237 // p pi- -> L K0 pi+ pi- (1)
1238 // p pi- -> L K0 pi0 pi0 (1/2)
1239
1240// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1241
1242 G4double sigma=0.;
1243 const Particle *pion;
1244 const Particle *nucleon;
1245
1246 if(p1->isPion()){
1247 pion = p1;
1248 nucleon = p2;
1249 }
1250 else{
1251 nucleon = p1;
1252 pion = p2;
1253 }
1254 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1255 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(pion, nucleon); // GeV
1256
1257 if(pLab <= 1.4162)
1258 return 0.;
1259
1260 if(iso == 3 || iso == -3)
1261 sigma = 2*18.77*std::pow(pLab-1.4162,4.597)/std::pow(pLab,6.877);
1262 else if(pion->getType() == PiZero)
1263 sigma = 1.75*18.77*std::pow(pLab-1.4162,4.597)/std::pow(pLab,6.877);
1264 else
1265 sigma = 2.5*18.77*std::pow(pLab-1.4162,4.597)/std::pow(pLab,6.877);
1266
1267 return sigma;
1268 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NpiToLKpi()

G4double G4INCL::CrossSectionsStrangeness::NpiToLKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1134 of file G4INCLCrossSectionsStrangeness.cc.

1134 {
1135 //
1136 // Pion-Nucleon producing Lambda-Kaon-pion cross sections
1137 //
1138 // ratio
1139 // p pi+ (1) p pi0 (3/2) p pi- (2)
1140 //
1141 // p pi0 -> L K+ pi0 (1/2)
1142 // all the others (1)
1143 //
1144// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1145
1146 G4double sigma=0.;
1147 const Particle *pion;
1148 const Particle *nucleon;
1149
1150 if(p1->isPion()){
1151 pion = p1;
1152 nucleon = p2;
1153 }
1154 else{
1155 nucleon = p1;
1156 pion = p2;
1157 }
1158 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1159 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(pion, nucleon); // GeV
1160
1161 if(pLab < 1.147)
1162 return 0.;
1163
1164 if(iso == 3 || iso == -3)
1165 sigma = 146.2*std::pow(pLab-1.147,1.996)/std::pow(pLab+1.147,5.921);
1166 else if(pion->getType() == PiZero)
1167 sigma = 1.5*146.2*std::pow(pLab-1.147,1.996)/std::pow(pLab+1.147,5.921);
1168 else
1169 sigma = 2*146.2*std::pow(pLab-1.147,1.996)/std::pow(pLab+1.147,5.921);
1170
1171 return sigma;
1172 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NpiToMissingStrangeness()

G4double G4INCL::CrossSectionsStrangeness::NpiToMissingStrangeness ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1383 of file G4INCLCrossSectionsStrangeness.cc.

1383 {
1384 //
1385 // Pion-Nucleon missing strangeness production cross sections
1386 //
1387// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1388
1389 const Particle *pion;
1390 const Particle *nucleon;
1391
1392 if(p1->isPion()){
1393 pion = p1;
1394 nucleon = p2;
1395 }
1396 else{
1397 pion = p2;
1398 nucleon = p1;
1399 }
1400
1401 G4double sigma = 0.;
1402
1403 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(pion,nucleon); // GeV
1404 if(pLab < 2.2) return 0.;
1405
1406 if(pion->getType() == PiZero){
1407 if(pLab < 30.) sigma = 4.4755*std::pow((pLab - 2.2),1.927)/std::pow(pLab,1.89343);
1408 else return 0.;
1409 }
1410 else if((pion->getType() == PiPlus && nucleon->getType() == Neutron) || (pion->getType() == PiMinus && nucleon->getType() == Proton)){
1411 if(pLab < 30.) sigma = 5.1*std::pow((pLab - 2.2),1.854)/std::pow(pLab,1.904);
1412 else return 0.;
1413 }
1414 else{
1415 if(pLab < 30.) sigma = 3.851*std::pow((pLab - 2.2),2)/std::pow(pLab,1.88286);
1416 else return 0.;
1417 }
1418 return sigma;
1419 }

References G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::Neutron, G4InuclParticleNames::nucleon(), G4INCL::PiMinus, G4InuclParticleNames::pion(), G4INCL::PiPlus, G4INCL::PiZero, and G4INCL::Proton.

Referenced by piNToxPiN().

◆ NpiToNKKb()

G4double G4INCL::CrossSectionsStrangeness::NpiToNKKb ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1332 of file G4INCLCrossSectionsStrangeness.cc.

1332 {
1333 //
1334 // Pion-Nucleon producing Nucleon-Kaon-antiKaon cross sections
1335 //
1336 // ratio
1337 // p pi+ (1/2) p pi0 (3/2) p pi- (5/2)
1338 //
1339 // p pi+ -> p K+ K0b (1/2)
1340 // p pi0 -> p K0 K0b (1/4)
1341 // p pi0 -> p K+ K- (1/4)
1342 // p pi0 -> n K+ K0b (1)
1343 // p pi- -> p K0 K- (1/2)
1344 // p pi- -> n K+ K- (1)
1345 // p pi- -> n K0 K0b (1)
1346
1347// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1348
1349 const Particle *particle1;
1350 const Particle *particle2;
1351
1352 if(p1->isPion()){
1353 particle1 = p1;
1354 particle2 = p2;
1355 }
1356 else{
1357 particle1 = p2;
1358 particle2 = p1;
1359 }
1360
1361 G4double sigma = 0.;
1362
1363 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1364
1365 if(particle1->getType() == PiZero){
1366 if(pLab < 1.5066) return 0.;
1367 else if(pLab < 30.) sigma = 3./2.*2.996*std::pow((pLab - 1.5066),1.929)/std::pow(pLab,3.582);
1368 else return 0.;
1369 }
1370 else if((particle1->getType() == PiPlus && particle2->getType() == Neutron) || (particle1->getType() == PiMinus && particle2->getType() == Proton)){
1371 if(pLab < 1.5066) return 0.;
1372 else if(pLab < 30.) sigma = 5./2.*2.996*std::pow((pLab - 1.5066),1.929)/std::pow(pLab,3.582);
1373 else return 0.;
1374 }
1375 else{
1376 if(pLab < 1.5066) return 0.;
1377 else if(pLab < 30.) sigma = 1./2.*2.996*std::pow((pLab - 1.5066),1.929)/std::pow(pLab,3.582);
1378 else return 0.;
1379 }
1380 return sigma;
1381 }

References G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4INCL::Neutron, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, and G4INCL::Proton.

Referenced by piNToxPiN().

◆ NpiToSK()

G4double G4INCL::CrossSectionsStrangeness::NpiToSK ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1033 of file G4INCLCrossSectionsStrangeness.cc.

1033 {
1034 //
1035 // Pion-Nucleon producing Sigma-Kaon cross sections
1036 //
1037 // ratio
1038 // p pi+ (5/3) p pi0 (11/6) p pi- (2)
1039 //
1040 // p pi+ -> S+ K+ (10)
1041 // p pi0 -> S+ K0 (6)*
1042 // p pi0 -> S0 K+ (5)
1043 // p pi- -> S0 K0 (6)*
1044 // p pi- -> S- K+ (6)
1045
1046// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1047
1048 const Particle *pion;
1049 const Particle *nucleon;
1050 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1051
1052 if(p1->isPion()){
1053 pion = p1;
1054 nucleon = p2;
1055 }
1056 else{
1057 nucleon = p1;
1058 pion = p2;
1059 }
1060 G4double sigma = 0.;
1061
1062 if(iso == 3 || iso == -3)
1063 sigma = p_pipToSpKp(pion,nucleon);
1064 else if(pion->getType() == PiZero)
1065 sigma = p_pizToSzKp(pion,nucleon)+p_pimToSzKz(pion,nucleon);
1066 else if(iso == 1 || iso == -1)
1067 sigma = p_pimToSzKz(pion,nucleon)+p_pimToSmKp(pion,nucleon);
1068 else // should never append
1069 sigma = 0.;
1070
1071 return sigma;
1072 }
G4INCL::CrossSectionsStrangeness::p_pimToSzKz
virtual G4double p_pimToSzKz(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1118
G4INCL::CrossSectionsStrangeness::p_pizToSzKp
virtual G4double p_pizToSzKp(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1103
G4INCL::CrossSectionsStrangeness::p_pipToSpKp
G4double p_pipToSpKp(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1088
G4INCL::CrossSectionsStrangeness::p_pimToSmKp
virtual G4double p_pimToSmKp(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1073

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4InuclParticleNames::nucleon(), p_pimToSmKp(), p_pimToSzKz(), p_pipToSpKp(), p_pizToSzKp(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NpiToSK2pi()

G4double G4INCL::CrossSectionsStrangeness::NpiToSK2pi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1270 of file G4INCLCrossSectionsStrangeness.cc.

1270 {
1271 //
1272 // Pion-Nucleon producing Lambda-Kaon-2pion cross sections
1273 //
1274 // ratio
1275 // p pi+ (3.25) p pi0 (3.5) p pi- (3.75)
1276 //
1277 // p pi+ -> S+ K+ pi+ pi- (1)
1278 // p pi+ -> S+ K+ pi0 pi0 (1/4)
1279 // p pi+ -> S0 K+ pi+ pi0 (1/2)
1280 // p pi+ -> S- K+ pi+ pi+ (1/4)
1281 // p pi+ -> S+ K0 pi+ pi0 (1)
1282 // p pi+ -> S0 K0 pi+ pi+ (1/4)
1283 //
1284 // p pi0 -> S+ K+ pi0 pi- (1/2)
1285 // p pi0 -> S0 K+ pi+ pi- (1/2)
1286 // p pi0 -> S0 K+ pi0 pi0 (1/4)
1287 // p pi0 -> S- K+ pi+ pi0 (1/4)
1288 // p pi0 -> S+ K0 pi+ pi- (1)
1289 // p pi0 -> S+ K0 pi0 pi0 (1/4)
1290 // p pi0 -> S0 K0 pi+ pi0 (1/4)
1291 // p pi0 -> S- K0 pi+ pi+ (1/2)
1292 //
1293 // p pi- -> S+ K+ pi- pi- (1/4)
1294 // p pi- -> S0 K+ pi0 pi- (1/2)
1295 // p pi- -> S- K+ pi+ pi- (1/4)
1296 // p pi- -> S- K+ pi0 pi0 (1/4)
1297 // p pi- -> S+ K0 pi0 pi- (1/2)
1298 // p pi- -> S0 K0 pi+ pi- (1)
1299 // p pi- -> S0 K0 pi0 pi0 (1/2)
1300 // p pi- -> S- K0 pi+ pi0 (1/2)
1301
1302// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1303
1304 G4double sigma=0.;
1305 const Particle *pion;
1306 const Particle *nucleon;
1307
1308 if(p1->isPion()){
1309 pion = p1;
1310 nucleon = p2;
1311 }
1312 else{
1313 nucleon = p1;
1314 pion = p2;
1315 }
1316 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1317 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(pion, nucleon); // GeV
1318
1319 if(pLab <= 1.5851)
1320 return 0.;
1321
1322 if(iso == 3 || iso == -3)
1323 sigma = 3.25*137.6*std::pow(pLab-1.5851,5.856)/std::pow(pLab,9.295);
1324 else if(pion->getType() == PiZero)
1325 sigma = 3.5*137.6*std::pow(pLab-1.5851,5.856)/std::pow(pLab,9.295);
1326 else
1327 sigma = 3.75*137.6*std::pow(pLab-1.5851,5.856)/std::pow(pLab,9.295);
1328
1329 return sigma;
1330 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NpiToSKpi()

G4double G4INCL::CrossSectionsStrangeness::NpiToSKpi ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1174 of file G4INCLCrossSectionsStrangeness.cc.

1174 {
1175 //
1176 // Pion-Nucleon producing Sigma-Kaon-pion cross sections
1177 //
1178 //ratio
1179 // p pi+ (2.25) p pi0 (2.625) p pi-(3)
1180 //
1181 // p pi+ -> S+ pi+ K0 (5/4)
1182 // p pi+ -> S+ pi0 K+ (3/4)
1183 // p pi+ -> S0 pi+ K+ (1/4)
1184 // p pi0 -> S+ pi0 K0 (1/2)
1185 // p pi0 -> S+ pi- K+ (1/2)
1186 // p pi0 -> S0 pi+ K0 (3/4)
1187 // p pi0 -> S0 pi0 K+ (3/8)
1188 // p pi0 -> S- pi+ K+ (1/2)
1189 // p pi- -> S+ pi- K0 (3/8)
1190 // p pi- -> S0 pi0 K0 (5/8)
1191 // p pi- -> S0 pi- K+ (5/8)
1192 // p pi- -> S- pi+ K0 (1)
1193 // p pi- -> S- pi0 K+ (3/8)
1194
1195// assert((p1->isPion() && p2->isNucleon()) || (p2->isPion() && p1->isNucleon()));
1196
1197 G4double sigma=0.;
1198 const Particle *pion;
1199 const Particle *nucleon;
1200
1201 if(p1->isPion()){
1202 pion = p1;
1203 nucleon = p2;
1204 }
1205 else{
1206 nucleon = p1;
1207 pion = p2;
1208 }
1209 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1210 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(pion, nucleon); // GeV
1211
1212 if(pLab <= 1.3041)
1213 return 0.;
1214
1215 if(iso == 3 || iso == -3)
1216 sigma = 2.25*8.139*std::pow(pLab-1.3041,2.431)/std::pow(pLab,5.298);
1217 else if(pion->getType() == PiZero)
1218 sigma = 2.625*8.139*std::pow(pLab-1.3041,2.431)/std::pow(pLab,5.298);
1219 else
1220 sigma = 3.*8.139*std::pow(pLab-1.3041,2.431)/std::pow(pLab,5.298);
1221
1222 return sigma;
1223 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isPion(), G4INCL::KinematicsUtils::momentumInLab(), G4InuclParticleNames::nucleon(), G4InuclParticleNames::pion(), and G4INCL::PiZero.

Referenced by piNToxPiN().

◆ NSToNL()

G4double G4INCL::CrossSectionsStrangeness::NSToNL ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1458 of file G4INCLCrossSectionsStrangeness.cc.

1458 {
1459 //
1460 // Nucleon-Lambda producing Nucleon-Sigma cross sections
1461 //
1462 // ratio
1463 // p S0 -> p L (1/2)
1464 // p S- -> n L (1)
1465
1466// assert((p1->isSigma() && p2->isNucleon()) || (p2->isSigma() && p1->isNucleon()));
1467
1468 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1469 if(iso == 3 || iso == -3)
1470 return 0.;
1471
1472 G4double sigma;
1473 const Particle *particle1;
1474 const Particle *particle2;
1475
1476 if(p1->isSigma()){
1477 particle1 = p1;
1478 particle2 = p2;
1479 }
1480 else{
1481 particle1 = p2;
1482 particle2 = p1;
1483 }
1484 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1485
1486 if(particle1->getType() == SigmaZero){
1487 if(pLab < 0.1) return 100.; // cut-max
1488 sigma = 8.23*std::pow(pLab,-1.087);
1489 }
1490 else{
1491 if(pLab < 0.1) return 200.; // cut-max
1492 sigma = 16.46*std::pow(pLab,-1.087);
1493 }
1494 return sigma;
1495 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isSigma(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::SigmaZero.

Referenced by total().

◆ NSToNS()

G4double G4INCL::CrossSectionsStrangeness::NSToNS ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1497 of file G4INCLCrossSectionsStrangeness.cc.

1497 {
1498
1499// assert((p1->isSigma() && p2->isNucleon()) || (p2->isSigma() && p1->isNucleon()));
1500
1501 const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
1502 if(iso == 3 || iso == -3)
1503 return 0.; // only quasi-elastic here
1504
1505 const Particle *particle1;
1506 const Particle *particle2;
1507
1508 if(p1->isSigma()){
1509 particle1 = p1;
1510 particle2 = p2;
1511 }
1512 else{
1513 particle1 = p2;
1514 particle2 = p1;
1515 }
1516 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(particle1,particle2); // GeV
1517
1518 if(particle2->getType() == Neutron && pLab < 0.162) return 0.;
1519 else if(pLab < 0.1035) return 200.; // cut-max
1520
1521 return 13.79*std::pow(pLab,-1.181);
1522 }

References G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::isSigma(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::Neutron.

Referenced by total().

◆ NYelastic()

G4double G4INCL::CrossSectionsStrangeness::NYelastic ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

elastic scattering for Nucleon-Strange Particles cross sections

elastic cross sections

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 300 of file G4INCLCrossSectionsStrangeness.cc.

300 {
301 //
302 // Hyperon-Nucleon elastic cross sections
303 //
304// assert((p1->isNucleon() && p2->isHyperon()) || (p1->isHyperon() && p2->isNucleon()));
305
306 G4double sigma = 0.;
307
308 const Particle *hyperon;
309 const Particle *nucleon;
310
311 if (p1->isHyperon()) {
312 hyperon = p1;
313 nucleon = p2;
314 }
315 else {
316 hyperon = p2;
317 nucleon = p1;
318 }
319
320 const G4double pLab = KinematicsUtils::momentumInLab(hyperon, nucleon); // MeV
321
322 if (pLab < 145.)
323 sigma = 200.;
324 else if (pLab < 425.)
325 sigma = 869.*std::exp(-pLab/100.);
326 else if (pLab < 30000.)
327 sigma = 12.8*std::exp(-6.2e-5*pLab);
328 else
329 sigma=0.;
330
331 if (sigma < 0.) sigma = 0.; // should never happen
332 return sigma;
333 }
G4InuclParticleNames::hyperon
G4bool hyperon(G4int ityp)
Definition: G4InuclParticleNames.hh:115

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

Referenced by elastic().

◆ omegaNElastic()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::elastic().

◆ omegaNInelastic()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN(), G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiPiN(), G4INCL::CrossSectionsMultiPionsAndResonances::total(), and total().

◆ omegaNToPiN()

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

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(), G4INCL::CrossSectionsMultiPionsAndResonances::omegaNInelastic(), G4INCL::PiMinus, G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN(), G4INCL::PiZero, G4INCL::Proton, and G4INCL::KinematicsUtils::totalEnergyInCM().

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiPiN().

◆ omegaNToPiPiN()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::omegaNInelastic(), and G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN().

◆ p_kmToL_pp_pm()

G4double G4INCL::CrossSectionsStrangeness::p_kmToL_pp_pm ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Definition at line 1898 of file G4INCLCrossSectionsStrangeness.cc.

1898 {
1899 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(p1, p2); // GeV
1900 G4double sigma = 0.;
1901 if(pLab < 0.97)
1902 sigma = 6364.*std::pow(pLab,6.07)/std::pow(pLab+1.,10.58)+2.158*std::exp(-std::pow((pLab-0.395)/.01984,2)/2.);
1903 else if(pLab < 30)
1904 sigma = 46.3*std::pow(pLab,0.62)/std::pow(pLab+1.,3.565);
1905 else
1906 sigma = 0.;
1907
1908 return sigma;
1909 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NKbToL2pi().

◆ p_kmToL_pz()

G4double G4INCL::CrossSectionsStrangeness::p_kmToL_pz ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Definition at line 1796 of file G4INCLCrossSectionsStrangeness.cc.

1796 {
1797 const G4double pLab = 0.001*KinematicsUtils::momentumInLab(p1, p2); // GeV
1798 G4double sigma = 0.;
1799 if(pLab < 0.086636)
1800 sigma = 40.24;
1801 else if(pLab < 0.5)
1802 sigma = 0.97*std::pow(pLab,-1.523);
1803 else if(pLab < 2.)
1804 sigma = 1.23*std::pow(pLab,-1.467)+0.872*std::exp(-std::pow(pLab-0.749,2)/0.0045)+2.337*std::exp(-std::pow(pLab-0.957,2)/0.017)+0.476*std::exp(-std::pow(pLab-1.434,2)/0.136);
1805 else if(pLab < 30.)
1806 sigma = 3.*std::pow(pLab,-2.57);
1807 else
1808 sigma = 0.;
1809
1810 return sigma;
1811 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NKbToLpi().

◆ p_pimToLK0()

G4double G4INCL::CrossSectionsStrangeness::p_pimToLK0 ( Particle const *const  p1,
Particle const *const  p2 
)

Definition at line 1020 of file G4INCLCrossSectionsStrangeness.cc.

1020 {
1021
1022 G4double sigma = 0.;
1023 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
1024
1025 if(pLab < 0.911)
1026 return 0.;
1027
1028 sigma = 0.3936*std::pow(pLab,-1.357)-6.052*std::exp(-std::pow(pLab-0.7154,2)/0.02026)-0.16*std::exp(-std::pow(pLab-0.9684,2)/0.001432)+0.489*std::exp(-std::pow(pLab-0.8886,2)/0.08378);
1029 if(sigma < 0.) return 0;
1030 return sigma;
1031 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NpiToLK().

◆ p_pimToSmKp()

G4double G4INCL::CrossSectionsStrangeness::p_pimToSmKp ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1073 of file G4INCLCrossSectionsStrangeness.cc.

1073 {
1074
1075 G4double sigma = 0.;
1076 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
1077
1078 if(pLab < 1.0356)
1079 return 0.;
1080
1081 sigma = 4.352*std::pow(pLab-1.0356,1.006)/(std::pow(pLab+1.0356,0.0978)*std::pow(pLab,5.375));
1082
1083 if(sigma < 0.) // should never append
1084 return 0;
1085
1086 return sigma;
1087 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NpiToSK().

◆ p_pimToSzKz()

G4double G4INCL::CrossSectionsStrangeness::p_pimToSzKz ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1118 of file G4INCLCrossSectionsStrangeness.cc.

1118 {
1119
1120 G4double sigma = 0.;
1121 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
1122
1123 if((p1->getType() == PiZero && pLab < 1.0356) || (pLab < 1.034))
1124 return 0.;
1125
1126 sigma = 0.3474*std::pow(pLab-1.034,0.07678)/std::pow(pLab,1.627);
1127
1128 if(sigma < 0.) // should never append
1129 return 0;
1130
1131 return sigma;
1132 }

References G4INCL::Particle::getType(), G4INCL::KinematicsUtils::momentumInLab(), and G4INCL::PiZero.

Referenced by NpiToSK().

◆ p_pipToSpKp()

G4double G4INCL::CrossSectionsStrangeness::p_pipToSpKp ( Particle const *const  p1,
Particle const *const  p2 
)

Definition at line 1088 of file G4INCLCrossSectionsStrangeness.cc.

1088 {
1089
1090 G4double sigma = 0.;
1091 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
1092
1093 if(pLab < 1.0428)
1094 return 0.;
1095
1096 sigma = 0.001897*std::pow(pLab-1.0428,2.869)/(std::pow(pLab+1.0428,-16.68)*std::pow(pLab,19.1));
1097
1098 if(sigma < 0.) // should never append
1099 return 0;
1100
1101 return sigma;
1102 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NpiToSK().

◆ p_pizToSzKp()

G4double G4INCL::CrossSectionsStrangeness::p_pizToSzKp ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

Reimplemented from G4INCL::CrossSectionsMultiPions.

Definition at line 1103 of file G4INCLCrossSectionsStrangeness.cc.

1103 {
1104
1105 G4double sigma = 0.;
1106 const G4double pLab = 0.001 * KinematicsUtils::momentumInLab(p1,p2); // GeV
1107
1108 if(pLab < 1.0356)
1109 return 0.;
1110
1111 sigma = 3.624*std::pow(pLab-1.0356,1.4)/std::pow(pLab,5.14);
1112
1113 if(sigma < 0.) // should never append
1114 return 0;
1115
1116 return sigma;
1117 }

References G4INCL::KinematicsUtils::momentumInLab().

Referenced by NpiToSK().

◆ 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 }

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)
protectedinherited

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 
)
protectedinherited

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 G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN(), and G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaN().

◆ piMinuspToOmegaN() [1/2]

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

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 
)
protectedinherited

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 G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN(), and G4INCL::CrossSectionsMultiPionsAndResonances::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 
)
virtualinherited

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, G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN(), and G4INCL::Proton.

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

◆ piNToEtaPrimeN()

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

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 G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaPrimeN().

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaPrimeN().

◆ piNToOmegaN()

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

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, G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN(), and G4INCL::Proton.

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::piNToxPiN(), and 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(), G4INCL::CrossSectionsMultiPionsAndResonances::total(), and total().

◆ piNToxPiN()

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

correction to old cross section

Reimplemented from G4INCL::CrossSectionsMultiPionsAndResonances.

Definition at line 143 of file G4INCLCrossSectionsStrangeness.cc.

143 {
144 //
145 // pion-Nucleon producing xpi pions cross sections (corrected due to new particles)
146 //
147// assert(xpi>1 && xpi<=nMaxPiPiN);
148// assert((particle1->isNucleon() && particle2->isPion()) || (particle1->isPion() && particle2->isNucleon()));
149
150 const G4double oldXS2Pi=CrossSectionsMultiPions::piNToxPiN(2,particle1, particle2);
151 const G4double oldXS3Pi=CrossSectionsMultiPions::piNToxPiN(3,particle1, particle2);
152 const G4double oldXS4Pi=CrossSectionsMultiPions::piNToxPiN(4,particle1, particle2);
153 const G4double xsEta=CrossSectionsMultiPionsAndResonances::piNToEtaN(particle1, particle2);
154 const G4double xsOmega=CrossSectionsMultiPionsAndResonances::piNToOmegaN(particle1, particle2);
155 const G4double xs1=NpiToLK(particle2, particle1);
156 const G4double xs2=NpiToSK(particle1, particle2);
157 const G4double xs3=NpiToLKpi(particle1, particle2);
158 const G4double xs4=NpiToSKpi(particle1, particle2);
159 const G4double xs5=NpiToLK2pi(particle1, particle2);
160 const G4double xs6=NpiToSK2pi(particle1, particle2);
161 const G4double xs7=NpiToNKKb(particle1, particle2);
162 const G4double xs8=NpiToMissingStrangeness(particle1, particle2);
163 const G4double xs0 = xs1 + xs2 + xs3 + xs4 + xs5 + xs6 + xs7 +xs8;
164 G4double newXS2Pi=0.;
165 G4double newXS3Pi=0.;
166 G4double newXS4Pi=0.;
167
168 if (xpi == 2) {
169 if (oldXS4Pi != 0.)
170 newXS2Pi=oldXS2Pi;
171 else if (oldXS3Pi != 0.) {
172 newXS3Pi=oldXS3Pi-xsEta-xsOmega-xs0;
173 if (newXS3Pi < 1.e-09)
174 newXS2Pi=oldXS2Pi-(xsEta+xsOmega+xs0-oldXS3Pi);
175 else
176 newXS2Pi=oldXS2Pi;
177 }
178 else {
179 newXS2Pi=oldXS2Pi-xsEta-xsOmega-xs0;
180 if (newXS2Pi < 1.e-09 && newXS2Pi!=0.){
181 newXS2Pi=0.;
182 }
183 }
184 return newXS2Pi;
185 }
186 else if (xpi == 3) {
187 if (oldXS4Pi != 0.) {
188 newXS4Pi=oldXS4Pi-xsEta-xsOmega-xs0;
189 if (newXS4Pi < 1.e-09)
190 newXS3Pi=oldXS3Pi-(xsEta+xsOmega+xs0-oldXS4Pi);
191 else
192 newXS3Pi=oldXS3Pi;
193 }
194 else {
195 newXS3Pi=oldXS3Pi-xsEta-xsOmega-xs0;
196 if (newXS3Pi < 1.e-09){
197 newXS3Pi=0.;
198 }
199 }
200 return newXS3Pi;
201 }
202 else if (xpi == 4) {
203 newXS4Pi=oldXS4Pi-xsEta-xsOmega-xs0;
204 if (newXS4Pi < 1.e-09){
205 newXS4Pi=0.;
206 }
207 return newXS4Pi;
208 }
209 else // should never reach this point
210 return 0.;
211 }
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
G4INCL::CrossSectionsStrangeness::NpiToLKpi
virtual G4double NpiToLKpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1134
G4INCL::CrossSectionsStrangeness::NpiToNKKb
virtual G4double NpiToNKKb(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1332
G4INCL::CrossSectionsStrangeness::NpiToSK
virtual G4double NpiToSK(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1033
G4INCL::CrossSectionsStrangeness::NpiToLK2pi
virtual G4double NpiToLK2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1225
G4INCL::CrossSectionsStrangeness::NpiToMissingStrangeness
virtual G4double NpiToMissingStrangeness(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1383
G4INCL::CrossSectionsStrangeness::NpiToSKpi
virtual G4double NpiToSKpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1174
G4INCL::CrossSectionsStrangeness::NpiToLK
virtual G4double NpiToLK(Particle const *const p1, Particle const *const p2)
Nucleon-Pion to Stange particles cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:987
G4INCL::CrossSectionsStrangeness::NpiToSK2pi
virtual G4double NpiToSK2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1270

References NpiToLK(), NpiToLK2pi(), NpiToLKpi(), NpiToMissingStrangeness(), NpiToNKKb(), NpiToSK(), NpiToSK2pi(), NpiToSKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaN(), G4INCL::CrossSectionsMultiPionsAndResonances::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::CrossSectionsStrangeness::total ( Particle const *const  p1,
Particle const *const  p2 
)
virtual

second new total particle-particle cross section

redefining previous cross sections

Reimplemented from G4INCL::CrossSectionsMultiPionsAndResonances.

Definition at line 82 of file G4INCLCrossSectionsStrangeness.cc.

82 {
83 G4double inelastic;
84 if(p1->isNucleon() && p2->isNucleon()) {
85 return CrossSectionsMultiPions::NNTot(p1, p2);
86 } else if((p1->isNucleon() && p2->isDelta()) ||
87 (p1->isDelta() && p2->isNucleon())) {
88 inelastic = CrossSectionsMultiPions::NDeltaToNN(p1, p2) + NDeltaToNLK(p1, p2) + NDeltaToNSK(p1, p2) + NDeltaToDeltaLK(p1, p2) + NDeltaToDeltaSK(p1, p2) + NDeltaToNNKKb(p1, p2);
89 } else if((p1->isNucleon() && p2->isPion()) ||
90 (p1->isPion() && p2->isNucleon())) {
91 return CrossSectionsMultiPions::piNTot(p1,p2);
92 } else if((p1->isNucleon() && p2->isEta()) ||
93 (p1->isEta() && p2->isNucleon())) {
94 inelastic = CrossSectionsMultiPionsAndResonances::etaNToPiN(p1,p2) + CrossSectionsMultiPionsAndResonances::etaNToPiPiN(p1,p2);
95 } else if((p1->isNucleon() && p2->isOmega()) ||
96 (p1->isOmega() && p2->isNucleon())) {
97 inelastic = CrossSectionsMultiPionsAndResonances::omegaNInelastic(p1,p2);
98 } else if((p1->isNucleon() && p2->isEtaPrime()) ||
99 (p1->isEtaPrime() && p2->isNucleon())) {
100 inelastic = CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN(p1,p2);
101 } else if((p1->isNucleon() && p2->isLambda()) ||
102 (p1->isLambda() && p2->isNucleon())) {
103 inelastic = NLToNS(p1,p2);
104 } else if((p1->isNucleon() && p2->isSigma()) ||
105 (p1->isSigma() && p2->isNucleon())) {
106 inelastic = NSToNL(p1,p2) + NSToNS(p1,p2);
107 } else if((p1->isNucleon() && p2->isKaon()) ||
108 (p1->isKaon() && p2->isNucleon())) {
109 inelastic = NKToNK(p1,p2) + NKToNKpi(p1,p2) + NKToNK2pi(p1,p2);
110 } else if((p1->isNucleon() && p2->isAntiKaon()) ||
111 (p1->isAntiKaon() && p2->isNucleon())) {
112 inelastic = NKbToLpi(p1,p2) + NKbToSpi(p1,p2) + NKbToL2pi(p1,p2) + NKbToS2pi(p1,p2) + NKbToNKb(p1,p2) + NKbToNKbpi(p1,p2) + NKbToNKb2pi(p1,p2);
113 } else {
114 inelastic = 0.;
115 }
116 return inelastic + elastic(p1, p2);
117 }
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::CrossSectionsMultiPions::piNTot
G4double piNTot(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsMultiPions.cc:712
G4INCL::CrossSectionsStrangeness::NKbToNKb2pi
virtual G4double NKbToNKb2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1957
G4INCL::CrossSectionsStrangeness::NKbToNKbpi
virtual G4double NKbToNKbpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1911
G4INCL::CrossSectionsStrangeness::NKbToL2pi
virtual G4double NKbToL2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1865
G4INCL::CrossSectionsStrangeness::NLToNS
virtual G4double NLToNS(Particle const *const p1, Particle const *const p2)
Nucleon-Hyperon quasi-elastic cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:1423
G4INCL::CrossSectionsStrangeness::NKToNK2pi
virtual G4double NKToNK2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1607
G4INCL::CrossSectionsStrangeness::NDeltaToDeltaSK
virtual G4double NDeltaToDeltaSK(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:875
G4INCL::CrossSectionsStrangeness::NKToNKpi
virtual G4double NKToNKpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1563
G4INCL::CrossSectionsStrangeness::NDeltaToNSK
virtual G4double NDeltaToNSK(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:778
G4INCL::CrossSectionsStrangeness::NKbToLpi
virtual G4double NKbToLpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1764
G4INCL::CrossSectionsStrangeness::NSToNS
virtual G4double NSToNS(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1497
G4INCL::CrossSectionsStrangeness::NSToNL
virtual G4double NSToNL(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1458
G4INCL::CrossSectionsStrangeness::NKbToS2pi
virtual G4double NKbToS2pi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1813
G4INCL::CrossSectionsStrangeness::NKbToSpi
virtual G4double NKbToSpi(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:1715
G4INCL::CrossSectionsStrangeness::NKToNK
virtual G4double NKToNK(Particle const *const p1, Particle const *const p2)
Nucleon-Kaon cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:1526
G4INCL::CrossSectionsStrangeness::elastic
virtual G4double elastic(Particle const *const p1, Particle const *const p2)
second new elastic particle-particle cross section
Definition: G4INCLCrossSectionsStrangeness.cc:119
G4INCL::CrossSectionsStrangeness::NDeltaToNNKKb
virtual G4double NDeltaToNNKKb(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:937
G4INCL::CrossSectionsStrangeness::NDeltaToDeltaLK
virtual G4double NDeltaToDeltaLK(Particle const *const p1, Particle const *const p2)
Definition: G4INCLCrossSectionsStrangeness.cc:831
G4INCL::CrossSectionsStrangeness::NDeltaToNLK
virtual G4double NDeltaToNLK(Particle const *const p1, Particle const *const p2)
Nucleon-Delta to Stange particles cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:732
G4INCL::CrossSectionsStrangeness::NKbToNKb
virtual G4double NKbToNKb(Particle const *const p1, Particle const *const p2)
Nucleon-antiKaon cross sections.
Definition: G4INCLCrossSectionsStrangeness.cc:1663

References elastic(), G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN(), G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiPiN(), G4INCL::CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN(), G4INCL::Particle::isAntiKaon(), G4INCL::Particle::isDelta(), G4INCL::Particle::isEta(), G4INCL::Particle::isEtaPrime(), G4INCL::Particle::isKaon(), G4INCL::Particle::isLambda(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isOmega(), G4INCL::Particle::isPion(), G4INCL::Particle::isSigma(), NDeltaToDeltaLK(), NDeltaToDeltaSK(), NDeltaToNLK(), G4INCL::CrossSectionsMultiPions::NDeltaToNN(), NDeltaToNNKKb(), NDeltaToNSK(), NKbToL2pi(), NKbToLpi(), NKbToNKb(), NKbToNKb2pi(), NKbToNKbpi(), NKbToS2pi(), NKbToSpi(), NKToNK(), NKToNK2pi(), NKToNKpi(), NLToNS(), G4INCL::CrossSectionsMultiPions::NNTot(), NSToNL(), NSToNS(), G4INCL::CrossSectionsMultiPionsAndResonances::omegaNInelastic(), and G4INCL::CrossSectionsMultiPions::piNTot().

Field Documentation

◆ nMaxPiNN

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

Maximum number of outgoing pions in NN collisions.

Definition at line 133 of file G4INCLCrossSectionsStrangeness.hh.

◆ nMaxPiPiN

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

Maximum number of outgoing pions in piN collisions.

Definition at line 136 of file G4INCLCrossSectionsStrangeness.hh.

◆ s01ppHC

const HornerC8 G4INCL::CrossSectionsStrangeness::s01ppHC
protected

Horner coefficients for s01pp.

Definition at line 141 of file G4INCLCrossSectionsStrangeness.hh.

◆ s01ppOOT

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

One over threshold for s01pp.

Definition at line 139 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s01pzHC

const HornerC4 G4INCL::CrossSectionsStrangeness::s01pzHC
protected

Horner coefficients for s01pz.

Definition at line 143 of file G4INCLCrossSectionsStrangeness.hh.

◆ s01pzOOT

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

One over threshold for s01pz.

Definition at line 141 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pmHC

const HornerC6 G4INCL::CrossSectionsStrangeness::s02pmHC
protected

Horner coefficients for s02pm.

Definition at line 155 of file G4INCLCrossSectionsStrangeness.hh.

◆ s02pmOOT

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

One over threshold for s02pm.

Definition at line 153 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s02pzHC

const HornerC4 G4INCL::CrossSectionsStrangeness::s02pzHC
protected

Horner coefficients for s02pz.

Definition at line 153 of file G4INCLCrossSectionsStrangeness.hh.

◆ s02pzOOT

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

One over threshold for s02pz.

Definition at line 151 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pmHC

const HornerC4 G4INCL::CrossSectionsStrangeness::s11pmHC
protected

Horner coefficients for s11pm.

Definition at line 145 of file G4INCLCrossSectionsStrangeness.hh.

◆ s11pmOOT

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

One over threshold for s11pm.

Definition at line 143 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s11pzHC

const HornerC7 G4INCL::CrossSectionsStrangeness::s11pzHC
protected

Horner coefficients for s11pz.

Definition at line 139 of file G4INCLCrossSectionsStrangeness.hh.

◆ s11pzOOT

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

One over threshold for s11pz.

Definition at line 137 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12mzHC

const HornerC4 G4INCL::CrossSectionsStrangeness::s12mzHC
protected

Horner coefficients for s12mz.

Definition at line 157 of file G4INCLCrossSectionsStrangeness.hh.

◆ s12mzOOT

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

One over threshold for s12mz.

Definition at line 155 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12pmHC

const HornerC5 G4INCL::CrossSectionsStrangeness::s12pmHC
protected

Horner coefficients for s12pm.

Definition at line 147 of file G4INCLCrossSectionsStrangeness.hh.

◆ s12pmOOT

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

One over threshold for s12pm.

Definition at line 145 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12ppHC

const HornerC3 G4INCL::CrossSectionsStrangeness::s12ppHC
protected

Horner coefficients for s12pp.

Definition at line 149 of file G4INCLCrossSectionsStrangeness.hh.

◆ s12ppOOT

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

One over threshold for s12pp.

Definition at line 147 of file G4INCLCrossSectionsMultiPionsAndResonances.hh.

◆ s12zzHC

const HornerC4 G4INCL::CrossSectionsStrangeness::s12zzHC
protected

Horner coefficients for s12zz.

Definition at line 151 of file G4INCLCrossSectionsStrangeness.hh.

◆ s12zzOOT

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

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