Geant4-11
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | Static Private Attributes
G4ElasticHadrNucleusHE Class Reference

#include <G4ElasticHadrNucleusHE.hh>

Inheritance diagram for G4ElasticHadrNucleusHE:
G4HadronElastic G4HadronicInteraction

Public Member Functions

void ActivateFor (const G4Element *anElement)
 
void ActivateFor (const G4Material *aMaterial)
 
G4HadFinalStateApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus) override
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &)
 
G4double ComputeMomentumCMS (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
 
void DeActivateFor (const G4Element *anElement)
 
void DeActivateFor (const G4Material *aMaterial)
 
 G4ElasticHadrNucleusHE (const G4String &name="hElasticGlauber")
 
virtual std::pair< G4double, G4doubleGetEnergyMomentumCheckLevels () const
 
virtual const std::pair< G4double, G4doubleGetFatalEnergyCheckLevels () const
 
G4double GetMaxEnergy () const
 
G4double GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
G4double GetMinEnergy () const
 
G4double GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
const G4StringGetModelName () const
 
G4double GetRecoilEnergyThreshold () const
 
G4double GetSlopeCof (const G4int pdg)
 
G4int GetVerboseLevel () const
 
void InitialiseModel () override
 
virtual G4bool IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
 
G4bool IsBlocked (const G4Element *anElement) const
 
G4bool IsBlocked (const G4Material *aMaterial) const
 
G4double LowestEnergyLimit () const
 
void ModelDescription (std::ostream &) const override
 
G4bool operator!= (const G4HadronicInteraction &right) const =delete
 
G4bool operator== (const G4HadronicInteraction &right) const =delete
 
G4double SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A) override
 
void SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
 
void SetLowestEnergyLimit (G4double value)
 
void SetMaxEnergy (const G4double anEnergy)
 
void SetMaxEnergy (G4double anEnergy, const G4Element *anElement)
 
void SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)
 
void SetMinEnergy (G4double anEnergy)
 
void SetMinEnergy (G4double anEnergy, const G4Element *anElement)
 
void SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)
 
void SetRecoilEnergyThreshold (G4double val)
 
void SetVerboseLevel (G4int value)
 
 ~G4ElasticHadrNucleusHE () override
 

Protected Member Functions

void Block ()
 
G4bool IsBlocked () const
 
void SetModelName (const G4String &nam)
 

Protected Attributes

G4bool isBlocked
 
G4double pLocalTmax
 
G4int secID
 
G4double theMaxEnergy
 
G4double theMinEnergy
 
G4HadFinalState theParticleChange
 
G4int verboseLevel
 

Private Member Functions

void Binom ()
 
void DefineHadronValues (G4int Z)
 
void FillData (const G4ParticleDefinition *p, G4int idx, G4int Z)
 
G4int FillFq2 (G4int A)
 
 G4ElasticHadrNucleusHE (const G4ElasticHadrNucleusHE &)
 
G4double GetBinomCof (G4int n, G4int m)
 
G4double GetFt (G4double Q2)
 
G4double GetLightFq2 (G4int Z, G4int A, G4double Q)
 
G4double GetQ2_2 (G4int N, G4int Nmax, const std::vector< G4double > &F, G4double rand)
 
G4double HadrNucDifferCrSec (G4int A, G4double Q2)
 
G4double HadronNucleusQ2_2 (const G4ElasticData *pElD, G4double plabGeV, G4double tmax)
 
G4double HadronProtonQ2 (G4double plab, G4double tmax)
 
void InFileName (std::ostringstream &, const G4ParticleDefinition *p, G4int Z)
 
void InterpolateHN (G4int n, const G4double EnP[], const G4double C0P[], const G4double C1P[], const G4double B0P[], const G4double B1P[])
 
G4double LineInterpol (G4double p0, G4double p2, G4double c1, G4double c2, G4double p)
 
G4ElasticHadrNucleusHEoperator= (const G4ElasticHadrNucleusHE &right)
 
void OutFileName (std::ostringstream &, const G4ParticleDefinition *p, G4int Z)
 
G4bool ReadLine (std::ifstream &, std::vector< G4double > &)
 
void WriteLine (std::ofstream &, std::vector< G4double > &)
 

Private Attributes

G4double aAIm
 
G4double aDIm
 
G4double Aeff
 
G4double BoundaryP [7]
 
G4double BoundaryTG [7]
 
G4double BoundaryTL [7]
 
G4double Coeff0
 
G4double Coeff1
 
G4double Coeff2
 
G4double ConstU
 
G4double DDSect2
 
G4double DDSect3
 
G4double dQ2
 
G4double Dtot11
 
G4double ekinLowLimit
 
std::pair< G4double, G4doubleepCheckLevels
 
char * fDirectory
 
G4double HadrEnergy
 
G4double HadrReIm
 
G4double HadrSlope
 
G4double HadrTot
 
G4double hLabMomentum
 
G4double hLabMomentum2
 
G4double hMass
 
G4double hMass2
 
G4int iHadrCode
 
G4int iHadron
 
G4int iHadron1
 
G4bool isMaster
 
G4double lowestEnergyLimit
 
G4NistManagernistManager
 
G4int nwarn
 
G4double Pnucl
 
G4double Q2max
 
G4double R1
 
G4double R2
 
G4double recoilEnergyThreshold
 
G4HadronicInteractionRegistryregistry
 
G4double Slope0
 
G4double Slope1
 
G4double Slope2
 
G4ParticleDefinitiontheAlpha
 
std::vector< const G4Material * > theBlockedList
 
std::vector< const G4Element * > theBlockedListElements
 
G4ParticleDefinitiontheDeuteron
 
std::vector< std::pair< G4double, const G4Material * > > theMaxEnergyList
 
std::vector< std::pair< G4double, const G4Element * > > theMaxEnergyListElements
 
std::vector< std::pair< G4double, const G4Material * > > theMinEnergyList
 
std::vector< std::pair< G4double, const G4Element * > > theMinEnergyListElements
 
G4String theModelName
 
G4ParticleDefinitiontheNeutron
 
G4ParticleDefinitiontheProton
 
G4double TotP
 

Static Private Attributes

static G4double fBinom [240][240] = {{0.0}}
 
static G4ElasticDatafElasticData [NHADRONS][ZMAX] = {{nullptr}}
 
static G4double fEnergy [NENERGY] = {0.0}
 
static const G4int fHadronCode [NHADRONS]
 
static const G4int fHadronType [NHADRONS]
 
static const G4int fHadronType1 [NHADRONS]
 
static G4double fLineF [ONQ2] = {0.0}
 
static G4double fLowEdgeEnergy [NENERGY] = {0.0}
 
static G4bool fRetrieveFromFile = false
 
static G4bool fStoreToFile = false
 

Detailed Description

Definition at line 94 of file G4ElasticHadrNucleusHE.hh.

Constructor & Destructor Documentation

◆ G4ElasticHadrNucleusHE() [1/2]

G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE ( const G4String name = "hElasticGlauber")
explicit

Definition at line 244 of file G4ElasticHadrNucleusHE.cc.

245 : G4HadronElastic(name), fDirectory(nullptr), isMaster(false)
246{
250 = Slope0 = Coeff0 = aAIm = aDIm = Dtot11 = Q2max = 0.0;
251 iHadrCode = iHadron = iHadron1 = 0;
252
253 verboseLevel = 0;
254 ekinLowLimit = 400.0*CLHEP::MeV;
255
256 BoundaryP[0]=9.0; BoundaryTG[0]=5.0;BoundaryTL[0]=0.;
257 BoundaryP[1]=20.0;BoundaryTG[1]=1.5;BoundaryTL[1]=0.;
258 BoundaryP[2]=5.0; BoundaryTG[2]=1.0;BoundaryTL[2]=1.5;
259 BoundaryP[3]=8.0; BoundaryTG[3]=3.0;BoundaryTL[3]=0.;
260 BoundaryP[4]=7.0; BoundaryTG[4]=3.0;BoundaryTL[4]=0.;
261 BoundaryP[5]=5.0; BoundaryTG[5]=2.0;BoundaryTL[5]=0.;
262 BoundaryP[6]=5.0; BoundaryTG[6]=1.5;BoundaryTL[6]=3.0;
263
265
266 if(fEnergy[0] == 0.0) {
267#ifdef G4MULTITHREADED
268 G4MUTEXLOCK(&elasticMutex);
269 if(fEnergy[0] == 0.0) {
270#endif
271 isMaster = true;
272 Binom();
273 // energy in GeV
274 fEnergy[0] = 0.4;
275 fEnergy[1] = 0.6;
276 fEnergy[2] = 0.8;
277 fEnergy[3] = 1.0;
278 fLowEdgeEnergy[0] = 0.0;
279 fLowEdgeEnergy[1] = 0.5;
280 fLowEdgeEnergy[2] = 0.7;
281 fLowEdgeEnergy[3] = 0.9;
282 G4double f = G4Exp(G4Log(10.)*0.1);
283 G4double e = f*f;
284 for(G4int i=4; i<NENERGY; ++i) {
285 fEnergy[i] = e;
286 fLowEdgeEnergy[i] = e/f;
287 e *= f*f;
288 }
289 if(verboseLevel > 0) {
290 G4cout << "### G4ElasticHadrNucleusHE: energy points in GeV" << G4endl;
291 for(G4int i=0; i<NENERGY; ++i) {
292 G4cout << " " << i << " " << fLowEdgeEnergy[i]
293 << " " << fEnergy[i] << G4endl;
294 }
295 }
296#ifdef G4MULTITHREADED
297 }
298 G4MUTEXUNLOCK(&elasticMutex);
299#endif
300 }
301}
static const G4int NENERGY
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:179
G4double G4Log(G4double x)
Definition: G4Log.hh:226
#define G4MUTEXLOCK(mutex)
Definition: G4Threading.hh:251
#define G4MUTEXUNLOCK(mutex)
Definition: G4Threading.hh:254
double G4double
Definition: G4Types.hh:83
int G4int
Definition: G4Types.hh:85
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
static G4double fEnergy[NENERGY]
static G4double fLowEdgeEnergy[NENERGY]
G4HadronElastic(const G4String &name="hElasticLHEP")
static G4NistManager * Instance()
static constexpr double MeV
const char * name(G4int ptype)

References aAIm, aDIm, Aeff, Binom(), BoundaryP, BoundaryTG, BoundaryTL, Coeff0, Coeff1, Coeff2, ConstU, DDSect2, DDSect3, dQ2, Dtot11, ekinLowLimit, fEnergy, fLowEdgeEnergy, G4cout, G4endl, G4Exp(), G4Log(), G4MUTEXLOCK, G4MUTEXUNLOCK, HadrEnergy, HadrReIm, HadrSlope, HadrTot, hLabMomentum, hLabMomentum2, hMass, hMass2, iHadrCode, iHadron, iHadron1, G4NistManager::Instance(), isMaster, CLHEP::MeV, NENERGY, nistManager, Pnucl, Q2max, R1, R2, Slope0, Slope1, Slope2, TotP, and G4HadronicInteraction::verboseLevel.

◆ ~G4ElasticHadrNucleusHE()

G4ElasticHadrNucleusHE::~G4ElasticHadrNucleusHE ( )
override

Definition at line 315 of file G4ElasticHadrNucleusHE.cc.

316{
317 if(isMaster) {
318 for(G4int j = 0; j < NHADRONS; ++j) {
319 for(G4int k = 0; k < ZMAX; ++k) {
320 G4ElasticData* ptr = fElasticData[j][k];
321 if(ptr) {
322 delete ptr;
323 fElasticData[j][k] = nullptr;
324 for(G4int l = j+1; l < NHADRONS; ++l) {
325 if(ptr == fElasticData[l][k]) { fElasticData[l][k] = nullptr; }
326 }
327 }
328 }
329 }
330 delete fDirectory;
331 fDirectory = nullptr;
332 }
333}
static const G4int NHADRONS
static const G4int ZMAX
static G4ElasticData * fElasticData[NHADRONS][ZMAX]

References fDirectory, fElasticData, isMaster, NHADRONS, and ZMAX.

◆ G4ElasticHadrNucleusHE() [2/2]

G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE ( const G4ElasticHadrNucleusHE )
private

Member Function Documentation

◆ ActivateFor() [1/2]

void G4HadronicInteraction::ActivateFor ( const G4Element anElement)
inlineinherited

◆ ActivateFor() [2/2]

void G4HadronicInteraction::ActivateFor ( const G4Material aMaterial)
inlineinherited

◆ ApplyYourself()

G4HadFinalState * G4HadronElastic::ApplyYourself ( const G4HadProjectile aTrack,
G4Nucleus targetNucleus 
)
overridevirtualinherited

Reimplemented from G4HadronicInteraction.

Reimplemented in G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4LEHadronProtonElastic, G4LEnp, and G4LEpp.

Definition at line 81 of file G4HadronElastic.cc.

83{
85
86 const G4HadProjectile* aParticle = &aTrack;
87 G4double ekin = aParticle->GetKineticEnergy();
88
89 // no scattering below the limit
90 if(ekin <= lowestEnergyLimit) {
93 return &theParticleChange;
94 }
95
96 G4int A = targetNucleus.GetA_asInt();
97 G4int Z = targetNucleus.GetZ_asInt();
98
99 // Scattered particle referred to axis of incident particle
100 const G4ParticleDefinition* theParticle = aParticle->GetDefinition();
101 G4double m1 = theParticle->GetPDGMass();
102 G4double plab = std::sqrt(ekin*(ekin + 2.0*m1));
103
104 if (verboseLevel>1) {
105 G4cout << "G4HadronElastic: "
106 << aParticle->GetDefinition()->GetParticleName()
107 << " Plab(GeV/c)= " << plab/GeV
108 << " Ekin(MeV) = " << ekin/MeV
109 << " scattered off Z= " << Z
110 << " A= " << A
111 << G4endl;
112 }
113
115 G4double e1 = m1 + ekin;
116 G4LorentzVector lv(0.0,0.0,plab,e1+mass2);
117 G4ThreeVector bst = lv.boostVector();
118 G4double momentumCMS = plab*mass2/std::sqrt(m1*m1 + mass2*mass2 + 2.*mass2*e1);
119
120 pLocalTmax = 4.0*momentumCMS*momentumCMS;
121
122 // Sampling in CM system
123 G4double t = SampleInvariantT(theParticle, plab, Z, A);
124
125 if(t < 0.0 || t > pLocalTmax) {
126 // For the very rare cases where cos(theta) is greater than 1 or smaller than -1,
127 // print some debugging information via a "JustWarning" exception, and resample
128 // using the default algorithm
129#ifdef G4VERBOSE
130 if(nwarn < 2) {
132 ed << GetModelName() << " wrong sampling t= " << t << " tmax= " << pLocalTmax
133 << " for " << aParticle->GetDefinition()->GetParticleName()
134 << " ekin=" << ekin << " MeV"
135 << " off (Z,A)=(" << Z << "," << A << ") - will be resampled" << G4endl;
136 G4Exception( "G4HadronElastic::ApplyYourself", "hadEla001", JustWarning, ed);
137 ++nwarn;
138 }
139#endif
140 t = G4HadronElastic::SampleInvariantT(theParticle, plab, Z, A);
141 }
142
144 G4double cost = 1. - 2.0*t/pLocalTmax;
145
146 if (cost > 1.0) { cost = 1.0; }
147 else if(cost < -1.0) { cost = -1.0; }
148
149 G4double sint = std::sqrt((1.0-cost)*(1.0+cost));
150
151 if (verboseLevel>1) {
152 G4cout << " t= " << t << " tmax(GeV^2)= " << pLocalTmax/(GeV*GeV)
153 << " Pcms(GeV)= " << momentumCMS/GeV << " cos(t)=" << cost
154 << " sin(t)=" << sint << G4endl;
155 }
156 G4LorentzVector nlv1(momentumCMS*sint*std::cos(phi),
157 momentumCMS*sint*std::sin(phi),
158 momentumCMS*cost,
159 std::sqrt(momentumCMS*momentumCMS + m1*m1));
160
161 nlv1.boost(bst);
162
163 G4double eFinal = nlv1.e() - m1;
164 if (verboseLevel > 1) {
165 G4cout <<"G4HadronElastic: m= " << m1 << " Efin(MeV)= " << eFinal
166 << " 4-M Final: " << nlv1
167 << G4endl;
168 }
169
170 if(eFinal <= 0.0) {
173 } else {
174 theParticleChange.SetMomentumChange(nlv1.vect().unit());
176 }
177 lv -= nlv1;
178 G4double erec = std::max(lv.e() - mass2, 0.0);
179 if (verboseLevel > 1) {
180 G4cout << "Recoil: " <<" m= " << mass2 << " Erec(MeV)= " << erec
181 << " 4-mom: " << lv
182 << G4endl;
183 }
184
185 // the recoil is created if kinetic energy above the threshold
186 if(erec > GetRecoilEnergyThreshold()) {
187 G4ParticleDefinition * theDef = nullptr;
188 if(Z == 1 && A == 1) { theDef = theProton; }
189 else if (Z == 1 && A == 2) { theDef = theDeuteron; }
190 else if (Z == 1 && A == 3) { theDef = G4Triton::Triton(); }
191 else if (Z == 2 && A == 3) { theDef = G4He3::He3(); }
192 else if (Z == 2 && A == 4) { theDef = theAlpha; }
193 else {
194 theDef =
196 }
197 G4DynamicParticle * aSec = new G4DynamicParticle(theDef, lv.vect().unit(), erec);
199 } else {
201 }
202
203 return &theParticleChange;
204}
static const G4double e1[44]
@ JustWarning
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
static constexpr double GeV
Definition: G4SIunits.hh:203
static constexpr double MeV
Definition: G4SIunits.hh:200
const G4int Z[17]
const G4double A[17]
#define G4UniformRand()
Definition: Randomize.hh:52
void AddSecondary(G4DynamicParticle *aP, G4int mod=-1)
void SetEnergyChange(G4double anEnergy)
void SetMomentumChange(const G4ThreeVector &aV)
void SetLocalEnergyDeposit(G4double aE)
const G4ParticleDefinition * GetDefinition() const
G4double GetKineticEnergy() const
G4double SampleInvariantT(const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A) override
G4ParticleDefinition * theAlpha
G4ParticleDefinition * theProton
G4double lowestEnergyLimit
G4ParticleDefinition * theDeuteron
G4double GetRecoilEnergyThreshold() const
const G4String & GetModelName() const
static G4He3 * He3()
Definition: G4He3.cc:93
G4ParticleDefinition * GetIon(G4int Z, G4int A, G4int lvl=0)
Definition: G4IonTable.cc:522
static G4double GetNuclearMass(const G4double A, const G4double Z)
G4int GetA_asInt() const
Definition: G4Nucleus.hh:99
G4int GetZ_asInt() const
Definition: G4Nucleus.hh:105
const G4String & GetParticleName() const
G4IonTable * GetIonTable() const
static G4ParticleTable * GetParticleTable()
static G4Triton * Triton()
Definition: G4Triton.cc:93
static constexpr double twopi
Definition: SystemOfUnits.h:56
T max(const T t1, const T t2)
brief Return the largest of the two arguments

References A, G4HadFinalState::AddSecondary(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4HadFinalState::Clear(), CLHEP::HepLorentzVector::e(), e1, G4cout, G4endl, G4Exception(), G4UniformRand, G4Nucleus::GetA_asInt(), G4HadProjectile::GetDefinition(), G4IonTable::GetIon(), G4ParticleTable::GetIonTable(), G4HadProjectile::GetKineticEnergy(), G4HadronicInteraction::GetModelName(), G4NucleiProperties::GetNuclearMass(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4HadronicInteraction::GetRecoilEnergyThreshold(), G4Nucleus::GetZ_asInt(), GeV, G4He3::He3(), JustWarning, G4HadronElastic::lowestEnergyLimit, G4INCL::Math::max(), MeV, G4HadronElastic::nwarn, G4HadronElastic::pLocalTmax, G4HadronElastic::SampleInvariantT(), G4HadronElastic::secID, G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetLocalEnergyDeposit(), G4HadFinalState::SetMomentumChange(), G4HadronElastic::theAlpha, G4HadronElastic::theDeuteron, G4HadronicInteraction::theParticleChange, G4HadronElastic::theProton, G4Triton::Triton(), CLHEP::twopi, CLHEP::Hep3Vector::unit(), CLHEP::HepLorentzVector::vect(), G4HadronicInteraction::verboseLevel, and Z.

◆ Binom()

void G4ElasticHadrNucleusHE::Binom ( )
private

Definition at line 1362 of file G4ElasticHadrNucleusHE.cc.

1363{
1364 for(G4int N = 0; N < 240; ++N) {
1365 G4double J = 1.0;
1366 for(G4int M = 0; M <= N; ++M) {
1367 G4double Fact1 = 1.0;
1368 if (N > 0 && N > M && M > 0 ) {
1369 J *= (G4double)(N-M+1)/(G4double)M;
1370 Fact1 = J;
1371 }
1372 fBinom[N][M] = Fact1;
1373 }
1374 }
1375}
#define M(row, col)
static G4double fBinom[240][240]

References fBinom, and M.

Referenced by G4ElasticHadrNucleusHE().

◆ Block()

void G4HadronicInteraction::Block ( )
inlineprotectedinherited

◆ BuildPhysicsTable()

void G4HadronicInteraction::BuildPhysicsTable ( const G4ParticleDefinition )
virtualinherited

◆ ComputeMomentumCMS()

G4double G4HadronElastic::ComputeMomentumCMS ( const G4ParticleDefinition p,
G4double  plab,
G4int  Z,
G4int  A 
)
inlineinherited

Definition at line 102 of file G4HadronElastic.hh.

104{
105 G4double m1 = p->GetPDGMass();
106 G4double m12= m1*m1;
108 return plab*mass2/std::sqrt(m12 + mass2*mass2 + 2.*mass2*std::sqrt(m12 + plab*plab));
109}

References A, G4NucleiProperties::GetNuclearMass(), G4ParticleDefinition::GetPDGMass(), and Z.

◆ DeActivateFor() [1/2]

void G4HadronicInteraction::DeActivateFor ( const G4Element anElement)
inherited

Definition at line 186 of file G4HadronicInteraction.cc.

187{
188 Block();
189 theBlockedListElements.push_back(anElement);
190}
std::vector< const G4Element * > theBlockedListElements

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedListElements.

◆ DeActivateFor() [2/2]

void G4HadronicInteraction::DeActivateFor ( const G4Material aMaterial)
inherited

Definition at line 180 of file G4HadronicInteraction.cc.

181{
182 Block();
183 theBlockedList.push_back(aMaterial);
184}
std::vector< const G4Material * > theBlockedList

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedList.

Referenced by G4HadronHElasticPhysics::ConstructProcess().

◆ DefineHadronValues()

void G4ElasticHadrNucleusHE::DefineHadronValues ( G4int  Z)
private

Definition at line 962 of file G4ElasticHadrNucleusHE.cc.

963{
965 G4double sqrS = std::sqrt(sHadr);
966
967 if(verboseLevel>2) {
968 G4cout << "GetHadrValues: Z= " << Z << " iHadr= " << iHadron
969 << " E(GeV)= " << HadrEnergy << " sqrS= " << sqrS
970 << " plab= " << hLabMomentum
971 <<" E - m "<<HadrEnergy - hMass<< G4endl;
972 }
973 G4double TotN = 0.0;
974 G4double logE = G4Log(HadrEnergy);
975 G4double logS = G4Log(sHadr);
976 TotP = 0.0;
977
978 switch (iHadron) {
979 case 0: // proton, neutron
980 case 6:
981
982 if(hLabMomentum > 10) {
983 TotP = TotN = 7.5*logE - 40.12525 + 103*G4Exp(-logS*0.165);// mb
984
985 } else {
986 // ================== neutron ================
987
988 if( hLabMomentum > 1.4 ) {
989 TotN = 33.3+15.2*(hLabMomentum2-1.35)/
990 (G4Exp(G4Log(hLabMomentum)*2.37)+0.95);
991
992 } else if(hLabMomentum > 0.8) {
993 G4double A0 = logE + 0.0513;
994 TotN = 33.0 + 25.5*A0*A0;
995 } else {
996 G4double A0 = logE - 0.2634; // log(1.3)
997 TotN = 33.0 + 30.*A0*A0*A0*A0;
998 }
999 // ================= proton ===============
1000
1001 if(hLabMomentum >= 1.05) {
1002 TotP = 39.0+75.*(hLabMomentum-1.2)/(hLabMomentum2*hLabMomentum+0.15);
1003 } else if(hLabMomentum >= 0.7) {
1004 G4double A0 = logE + 0.3147;
1005 TotP = 23.0 + 40.*A0*A0;
1006 } else {
1007 TotP = 23.+50.*G4Exp(G4Log(G4Log(0.73/hLabMomentum))*3.5);
1008 }
1009 }
1010 HadrTot = 0.5*(TotP+TotN);
1011 // ...................................................
1012 // Proton slope
1013 if(hLabMomentum >= 2.) { HadrSlope = 5.44 + 0.88*logS; }
1014 else if(hLabMomentum >= 0.5) { HadrSlope = 3.73*hLabMomentum-0.37; }
1015 else { HadrSlope = 1.5; }
1016
1017 // ...................................................
1018 if(hLabMomentum >= 1.2) {
1019 HadrReIm = 0.13*(logS - 5.8579332)*G4Exp(-logS*0.18);
1020 } else if(hLabMomentum >= 0.6) {
1021 HadrReIm = -75.5*(G4Exp(G4Log(hLabMomentum)*0.25)-0.95)/
1022 (G4Exp(G4Log(3*hLabMomentum)*2.2)+1);
1023 } else {
1025 }
1026 // ...................................................
1027 DDSect2 = 2.2; //mb*GeV-2
1028 DDSect3 = 0.6; //mb*GeV-2
1029 // ================== lambda ==================
1030 if( iHadrCode == 3122) {
1031 HadrTot *= 0.88;
1032 HadrSlope *=0.85;
1033 // ================== sigma + ==================
1034 } else if( iHadrCode == 3222) {
1035 HadrTot *=0.81;
1036 HadrSlope *=0.85;
1037 // ================== sigma 0,- ==================
1038 } else if(iHadrCode == 3112 || iHadrCode == 3212 ) {
1039 HadrTot *=0.88;
1040 HadrSlope *=0.85;
1041 // =================== xi =================
1042 } else if( iHadrCode == 3312 || iHadrCode == 3322 ) {
1043 HadrTot *=0.77;
1044 HadrSlope *=0.75;
1045 // ================= omega =================
1046 } else if( iHadrCode == 3334) {
1047 HadrTot *=0.78;
1048 HadrSlope *=0.7;
1049 }
1050 break;
1051 // ===========================================================
1052 case 1: // antiproton
1053 case 7: // antineutron
1054
1055 HadrTot = 5.2+5.2*logE + 123.2/sqrS; // mb
1056 HadrSlope = 8.32+0.57*logS; //(GeV/c)^-2
1057
1058 if( HadrEnergy < 1000 ) {
1059 HadrReIm = 0.06*(sqrS-2.236)*(sqrS-14.14)*G4Exp(-logS*0.8);
1060 } else {
1061 HadrReIm = 0.6*(logS - 5.8579332)*G4Exp(-logS*0.25);
1062 }
1063 DDSect2 = 11; //mb*(GeV/c)^-2
1064 DDSect3 = 3; //mb*(GeV/c)^-2
1065 // ================== lambda ==================
1066 if( iHadrCode == -3122) {
1067 HadrTot *= 0.88;
1068 HadrSlope *=0.85;
1069 // ================== sigma + ==================
1070 } else if( iHadrCode == -3222) {
1071 HadrTot *=0.81;
1072 HadrSlope *=0.85;
1073 // ================== sigma 0,- ==================
1074 } else if(iHadrCode == -3112 || iHadrCode == -3212 ) {
1075 HadrTot *=0.88;
1076 HadrSlope *=0.85;
1077 // =================== xi =================
1078 } else if( iHadrCode == -3312 || iHadrCode == -3322 ) {
1079 HadrTot *=0.77;
1080 HadrSlope *=0.75;
1081 // ================= omega =================
1082 } else if( iHadrCode == -3334) {
1083 HadrTot *=0.78;
1084 HadrSlope *=0.7;
1085 }
1086 break;
1087 // -------------------------------------------
1088 case 2: // pi plus, pi minus
1089 case 3:
1090
1091 if(hLabMomentum >= 3.5) {
1092 TotP = 10.6+2.*logE + 25.*G4Exp(-logE*0.43); // mb
1093 // =========================================
1094 } else if(hLabMomentum >= 1.15) {
1095 G4double x = (hLabMomentum - 2.55)/0.55;
1096 G4double y = (hLabMomentum - 1.47)/0.225;
1097 TotP = 3.2*G4Exp(-x*x) + 12.*G4Exp(-y*y) + 27.5;
1098 // =========================================
1099 } else if(hLabMomentum >= 0.4) {
1100 TotP = 88*(logE+0.2877)*(logE+0.2877)+14.0;
1101 // =========================================
1102 } else {
1103 G4double x = (hLabMomentum - 0.29)/0.085;
1104 TotP = 20. + 180.*G4Exp(-x*x);
1105 }
1106 // -------------------------------------------
1107
1108 if(hLabMomentum >= 3.0 ) {
1109 TotN = 10.6 + 2.*logE + 30.*G4Exp(-logE*0.43); // mb
1110 } else if(hLabMomentum >= 1.3) {
1111 G4double x = (hLabMomentum - 2.1)/0.4;
1112 G4double y = (hLabMomentum - 1.4)/0.12;
1113 TotN = 36.1+0.079 - 4.313*logE + 3.*G4Exp(-x*x) + 1.5*G4Exp(-y*y);
1114 } else if(hLabMomentum >= 0.65) {
1115 G4double x = (hLabMomentum - 0.72)/0.06;
1116 G4double y = (hLabMomentum - 1.015)/0.075;
1117 TotN = 36.1 + 10.*G4Exp(-x*x) + 24*G4Exp(-y*y);
1118 } else if(hLabMomentum >= 0.37) {
1119 G4double x = G4Log(hLabMomentum/0.48);
1120 TotN = 26. + 110.*x*x;
1121 } else {
1122 G4double x = (hLabMomentum - 0.29)/0.07;
1123 TotN = 28.0 + 40.*G4Exp(-x*x);
1124 }
1125 HadrTot = (TotP+TotN)*0.5;
1126 // ........................................
1127 HadrSlope = 7.28+0.245*logS; // GeV-2
1128 HadrReIm = 0.2*(logS - 4.6051702)*G4Exp(-logS*0.15);
1129
1130 DDSect2 = 0.7; //mb*GeV-2
1131 DDSect3 = 0.27; //mb*GeV-2
1132
1133 break;
1134 // ==========================================================
1135 case 4: // K plus
1136
1137 HadrTot = 10.6+1.8*logE + 9.0*G4Exp(-logE*0.55); // mb
1138 if(HadrEnergy>100) { HadrSlope = 15.0; }
1139 else { HadrSlope = 1.0+1.76*logS - 2.84/sqrS; } // GeV-2
1140
1141 HadrReIm = 0.4*(sHadr-20)*(sHadr-150)*G4Exp(-G4Log(sHadr+50)*2.1);
1142 DDSect2 = 0.7; //mb*GeV-2
1143 DDSect3 = 0.21; //mb*GeV-2
1144 break;
1145 // =========================================================
1146 case 5: // K minus
1147
1148 HadrTot = 10+1.8*logE + 25./sqrS; // mb
1149 HadrSlope = 6.98+0.127*logS; // GeV-2
1150 HadrReIm = 0.4*(sHadr-20)*(sHadr-20)*G4Exp(-G4Log(sHadr+50)*2.1);
1151 DDSect2 = 0.7; //mb*GeV-2
1152 DDSect3 = 0.27; //mb*GeV-2
1153 break;
1154 }
1155 // =========================================================
1156 if(verboseLevel>2) {
1157 G4cout << "HadrTot= " << HadrTot << " HadrSlope= " << HadrSlope
1158 << " HadrReIm= " << HadrReIm << " DDSect2= " << DDSect2
1159 << " DDSect3= " << DDSect3 << G4endl;
1160 }
1161 if(Z != 1) return;
1162
1163 // Scattering of protons
1164
1165 Coeff0 = Coeff1 = Coeff2 = 0.0;
1166 Slope0 = Slope1 = 1.0;
1167 Slope2 = 5.0;
1168
1169 // data for iHadron=0
1170 static const G4double EnP0[6]={1.5,3.0,5.0,9.0,14.0,19.0};
1171 static const G4double C0P0[6]={0.15,0.02,0.06,0.08,0.0003,0.0002};
1172 static const G4double C1P0[6]={0.05,0.02,0.03,0.025,0.0,0.0};
1173 static const G4double B0P0[6]={1.5,2.5,3.0,4.5,1.4,1.25};
1174 static const G4double B1P0[6]={5.0,1.0,3.5,4.0,4.8,4.8};
1175
1176 // data for iHadron=6,7
1177 static const G4double EnN[5]={1.5,5.0,10.0,14.0,20.0};
1178 static const G4double C0N[5]={0.0,0.0,0.02,0.02,0.01};
1179 static const G4double C1N[5]={0.06,0.008,0.0015,0.001,0.0003};
1180 static const G4double B0N[5]={1.5,2.5,3.8,3.8,3.5};
1181 static const G4double B1N[5]={1.5,2.2,3.6,4.5,4.8};
1182
1183 // data for iHadron=1
1184 static const G4double EnP[2]={1.5,4.0};
1185 static const G4double C0P[2]={0.001,0.0005};
1186 static const G4double C1P[2]={0.003,0.001};
1187 static const G4double B0P[2]={2.5,4.5};
1188 static const G4double B1P[2]={1.0,4.0};
1189
1190 // data for iHadron=2
1191 static const G4double EnPP[4]={1.0,2.0,3.0,4.0};
1192 static const G4double C0PP[4]={0.0,0.0,0.0,0.0};
1193 static const G4double C1PP[4]={0.15,0.08,0.02,0.01};
1194 static const G4double B0PP[4]={1.5,2.8,3.8,3.8};
1195 static const G4double B1PP[4]={0.8,1.6,3.6,4.6};
1196
1197 // data for iHadron=3
1198 static const G4double EnPPN[4]={1.0,2.0,3.0,4.0};
1199 static const G4double C0PPN[4]={0.0,0.0,0.0,0.0};
1200 static const G4double C1PPN[4]={0.0,0.0,0.0,0.0};
1201 static const G4double B0PPN[4]={1.5,2.8,3.8,3.8};
1202 static const G4double B1PPN[4]={0.8,1.6,3.6,4.6};
1203
1204 // data for iHadron=4
1205 static const G4double EnK[4]={1.4,2.33,3.0,5.0};
1206 static const G4double C0K[4]={0.0,0.0,0.0,0.0};
1207 static const G4double C1K[4]={0.01,0.007,0.005,0.003};
1208 static const G4double B0K[4]={1.5,2.0,3.8,3.8};
1209 static const G4double B1K[4]={1.6,1.6,1.6,1.6};
1210
1211 // data for iHadron=5
1212 static const G4double EnKM[2]={1.4,4.0};
1213 static const G4double C0KM[2]={0.006,0.002};
1214 static const G4double C1KM[2]={0.00,0.00};
1215 static const G4double B0KM[2]={2.5,3.5};
1216 static const G4double B1KM[2]={1.6,1.6};
1217
1218 switch(iHadron) {
1219 case 0:
1220
1221 if(hLabMomentum <BoundaryP[0]) {
1222 InterpolateHN(6,EnP0,C0P0,C1P0,B0P0,B1P0);
1223 }
1224 Coeff2 = 0.8/hLabMomentum2;
1225 break;
1226
1227 case 6:
1228
1229 if(hLabMomentum < BoundaryP[1]) {
1230 InterpolateHN(5,EnN,C0N,C1N,B0N,B1N);
1231 }
1232 Coeff2 = 0.8/hLabMomentum2;
1233 break;
1234
1235 case 1:
1236 case 7:
1237 if(hLabMomentum < BoundaryP[2]) {
1238 InterpolateHN(2,EnP,C0P,C1P,B0P,B1P);
1239 }
1240 break;
1241
1242 case 2:
1243
1244 if(hLabMomentum < BoundaryP[3]) {
1245 InterpolateHN(4,EnPP,C0PP,C1PP,B0PP,B1PP);
1246 }
1247 Coeff2 = 0.02/hLabMomentum;
1248 break;
1249
1250 case 3:
1251
1252 if(hLabMomentum < BoundaryP[4]) {
1253 InterpolateHN(4,EnPPN,C0PPN,C1PPN,B0PPN,B1PPN);
1254 }
1255 Coeff2 = 0.02/hLabMomentum;
1256 break;
1257
1258 case 4:
1259
1260 if(hLabMomentum < BoundaryP[5]) {
1261 InterpolateHN(4,EnK,C0K,C1K,B0K,B1K);
1262 }
1263 if(hLabMomentum < 1) { Coeff2 = 0.34; }
1264 else { Coeff2 = 0.34/(hLabMomentum2*hLabMomentum); }
1265 break;
1266
1267 case 5:
1268 if(hLabMomentum < BoundaryP[6]) {
1269 InterpolateHN(2,EnKM,C0KM,C1KM,B0KM,B1KM);
1270 }
1271 if(hLabMomentum < 1) { Coeff2 = 0.01; }
1272 else { Coeff2 = 0.01/(hLabMomentum2*hLabMomentum); }
1273 break;
1274 }
1275
1276 if(verboseLevel > 2) {
1277 G4cout<<" HadrVal : Plasb "<<hLabMomentum
1278 <<" iHadron "<<iHadron<<" HadrTot "<<HadrTot<<G4endl;
1279 }
1280}
const G4double protonM2
const G4double protonM
void InterpolateHN(G4int n, const G4double EnP[], const G4double C0P[], const G4double C1P[], const G4double B0P[], const G4double B1P[])

References BoundaryP, Coeff0, Coeff1, Coeff2, DDSect2, DDSect3, G4cout, G4endl, G4Exp(), G4Log(), HadrEnergy, HadrReIm, HadrSlope, HadrTot, hLabMomentum, hLabMomentum2, hMass, hMass2, iHadrCode, iHadron, InterpolateHN(), protonM, protonM2, Slope0, Slope1, Slope2, TotP, G4HadronicInteraction::verboseLevel, and Z.

Referenced by FillData(), and HadronProtonQ2().

◆ FillData()

void G4ElasticHadrNucleusHE::FillData ( const G4ParticleDefinition p,
G4int  idx,
G4int  Z 
)
private

Definition at line 441 of file G4ElasticHadrNucleusHE.cc.

443{
444#ifdef G4MULTITHREADED
445 G4MUTEXLOCK(&elasticMutex);
446 if(!fElasticData[idx][Z]) {
447#endif
449 G4ElasticData* pElD = new G4ElasticData(p, Z, A, fEnergy);
450 if(fRetrieveFromFile) {
451 std::ostringstream ss;
452 InFileName(ss, p, Z);
453 std::ifstream infile(ss.str(), std::ios::in);
454 for(G4int i=0; i<NENERGY; ++i) {
455 if(ReadLine(infile, pElD->fCumProb[i])) {
456 continue;
457 } else {
458 fRetrieveFromFile = false;
459 break;
460 }
461 }
462 infile.close();
463 }
464 R1 = pElD->R1;
465 R2 = pElD->R2;
466 Aeff = pElD->Aeff;
467 Pnucl = pElD->Pnucl;
468 dQ2 = pElD->dQ2;
469 if(verboseLevel > 0) {
470 G4cout<<"### FillData for " << p->GetParticleName()
471 << " Z= " << Z << " idx= " << idx << " iHadron= " << iHadron
472 <<" iHadron1= " << iHadron1 << " iHadrCode= " << iHadrCode
473 <<"\n R1= " << R1 << " R2= " << R2 << " Aeff= " << Aeff
474 <<" Pnucl= " << Pnucl << G4endl;
475 }
476
477 if(!fRetrieveFromFile) {
478 for(G4int i=0; i<NENERGY; ++i) {
479 G4double T = fEnergy[i];
480 hLabMomentum2 = T*(T + 2.*hMass);
481 hLabMomentum = std::sqrt(hLabMomentum2);
482 HadrEnergy = hMass + T;
484 Q2max = pElD->maxQ2[i];
485
486 G4int length = FillFq2(A);
487 (pElD->fCumProb[i]).reserve(length);
488 G4double norm = 1.0/fLineF[length-1];
489
490 if(verboseLevel > 0) {
491 G4cout << "### i= " << i << " Z= " << Z << " A= " << A
492 << " length= " << length << " Q2max= " << Q2max << G4endl;
493 }
494
495 (pElD->fCumProb[i]).push_back(0.0);
496 for(G4int ii=1; ii<length-1; ++ii) {
497 (pElD->fCumProb[i]).push_back(fLineF[ii]*norm);
498 if(verboseLevel > 2) {
499 G4cout << " ii= " << ii << " val= "
500 << (pElD->fCumProb[i])[ii] << G4endl;
501 }
502 }
503 (pElD->fCumProb[i]).push_back(1.0);
504 }
505 }
506
507 if(fStoreToFile) {
508 std::ostringstream ss;
509 OutFileName(ss, p, Z);
510 std::ofstream fileout(ss.str());
511 for(G4int i=0; i<NENERGY; ++i) {
512 WriteLine(fileout, pElD->fCumProb[i]);
513 }
514 fileout.close();
515 }
516
517 if(verboseLevel > 0) {
518 G4cout << " G4ElasticHadrNucleusHE::FillData done for idx= " << idx
519 << " for " << p->GetParticleName() << " Z= " << Z
520 << " A= " << A << G4endl;
521 }
522 fElasticData[idx][Z] = pElD;
523
524#ifdef G4MULTITHREADED
525 }
526 G4MUTEXUNLOCK(&elasticMutex);
527#endif
528}
G4double maxQ2[NENERGY]
std::vector< G4double > fCumProb[NENERGY]
void InFileName(std::ostringstream &, const G4ParticleDefinition *p, G4int Z)
void WriteLine(std::ofstream &, std::vector< G4double > &)
void OutFileName(std::ostringstream &, const G4ParticleDefinition *p, G4int Z)
static G4double fLineF[ONQ2]
G4bool ReadLine(std::ifstream &, std::vector< G4double > &)
G4double GetAtomicMassAmu(const G4String &symb) const
int G4lrint(double ad)
Definition: templates.hh:134

References A, G4ElasticData::Aeff, Aeff, DefineHadronValues(), G4ElasticData::dQ2, dQ2, G4ElasticData::fCumProb, fElasticData, fEnergy, FillFq2(), fLineF, fRetrieveFromFile, fStoreToFile, G4cout, G4endl, G4lrint(), G4MUTEXLOCK, G4MUTEXUNLOCK, G4NistManager::GetAtomicMassAmu(), G4ParticleDefinition::GetParticleName(), HadrEnergy, hLabMomentum, hLabMomentum2, hMass, iHadrCode, iHadron, iHadron1, InFileName(), G4ElasticData::maxQ2, NENERGY, nistManager, OutFileName(), G4ElasticData::Pnucl, Pnucl, Q2max, G4ElasticData::R1, R1, G4ElasticData::R2, R2, ReadLine(), G4HadronicInteraction::verboseLevel, WriteLine(), and Z.

Referenced by InitialiseModel(), and SampleInvariantT().

◆ FillFq2()

G4int G4ElasticHadrNucleusHE::FillFq2 ( G4int  A)
private

Definition at line 661 of file G4ElasticHadrNucleusHE.cc.

662{
663 G4double curQ2, curSec;
664 G4double curSum = 0.0;
665 G4double totSum = 0.0;
666
667 G4double ddQ2 = dQ2*0.1;
668 G4double Q2l = 0.0;
669
670 G4int ii = 0;
671 for(ii=1; ii<ONQ2-1; ++ii) {
672 curSum = curSec = 0.0;
673
674 for(G4int jj=0; jj<10; ++jj) {
675 curQ2 = Q2l+(jj + 0.5)*ddQ2;
676 if(curQ2 >= Q2max) { break; }
677 curSec = HadrNucDifferCrSec(A, curQ2);
678 curSum += curSec;
679 }
680 G4double del = (curQ2 >= Q2max) ? Q2max - Q2l : dQ2;
681 Q2l += del;
682 curSum *= del*0.1;
683 totSum += curSum;
684 fLineF[ii] = totSum;
685 if (verboseLevel>2) {
686 G4cout<<ii << ". FillFq2: A= " << A << " Q2= "<<Q2l<<" dQ2= "
687 <<dQ2<<" Tot= "<<totSum << " dTot " <<curSum
688 <<" curSec= " <<curSec<<G4endl;
689 }
690 if(totSum*1.e-4 > curSum || Q2l >= Q2max) { break; }
691 }
692 ii = std::min(ii, ONQ2-2);
693 curQ2 = Q2l;
694 G4double xx = R1*(Q2max - curQ2);
695 if(xx > 0.0) {
696 xx = (xx > 20.) ? 0.0 : G4Exp(-xx);
697 curSec = HadrNucDifferCrSec(A, curQ2);
698 totSum += curSec*(1.0 - xx)/R1;
699 }
700 fLineF[ii + 1] = totSum;
701 if (verboseLevel>1) {
702 G4cout << "### FillFq2 done curQ2= " << curQ2 << " Q2max= "<< Q2max
703 << " sumG= " << fLineF[ONQ2-2] << " totSum= " << totSum
704 << " Nbins= " << ii + 1 << G4endl;
705 }
706 return ii + 2;
707}
static const G4int ONQ2
G4double HadrNucDifferCrSec(G4int A, G4double Q2)
T min(const T t1, const T t2)
brief Return the smallest of the two arguments

References A, dQ2, fLineF, G4cout, G4endl, G4Exp(), HadrNucDifferCrSec(), G4INCL::Math::min(), ONQ2, Q2max, R1, and G4HadronicInteraction::verboseLevel.

Referenced by FillData().

◆ GetBinomCof()

G4double G4ElasticHadrNucleusHE::GetBinomCof ( G4int  n,
G4int  m 
)
inlineprivate

Definition at line 221 of file G4ElasticHadrNucleusHE.hh.

222{
223 return (numN >= numM && numN < 240) ? fBinom[numN][numM] : 0.0;
224}

References fBinom.

Referenced by GetLightFq2().

◆ GetEnergyMomentumCheckLevels()

std::pair< G4double, G4double > G4HadronicInteraction::GetEnergyMomentumCheckLevels ( ) const
virtualinherited

◆ GetFatalEnergyCheckLevels()

const std::pair< G4double, G4double > G4HadronicInteraction::GetFatalEnergyCheckLevels ( ) const
virtualinherited

Reimplemented in G4FissLib, G4LFission, G4LENDFission, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, and G4ParticleHPThermalScattering.

Definition at line 210 of file G4HadronicInteraction.cc.

211{
212 // default level of Check
213 return std::pair<G4double, G4double>(2.*perCent, 1. * GeV);
214}
static constexpr double perCent
Definition: G4SIunits.hh:325

References GeV, and perCent.

Referenced by G4HadronicProcess::CheckResult().

◆ GetFt()

G4double G4ElasticHadrNucleusHE::GetFt ( G4double  Q2)
private

Definition at line 1284 of file G4ElasticHadrNucleusHE.cc.

1285{
1286 G4double Fdistr=0;
1287 G4double SqrQ2 = std::sqrt(Q2);
1288
1289 Fdistr = (1-Coeff1-Coeff0) / HadrSlope*(1-G4Exp(-HadrSlope*Q2))
1290 + Coeff0*(1-G4Exp(-Slope0*Q2))
1292 + 2*Coeff1/Slope1*(1/Slope1-(1/Slope1+SqrQ2)*G4Exp(-Slope1*SqrQ2));
1293
1294 if (verboseLevel>1) {
1295 G4cout<<"Old: Coeff0 Coeff1 Coeff2 "<<Coeff0<<" "
1296 <<Coeff1<<" "<<Coeff2<<" Slope Slope0 Slope1 Slope2 "
1297 <<HadrSlope<<" "<<Slope0<<" "<<Slope1<<" "<<Slope2
1298 <<" Fdistr "<<Fdistr<<G4endl;
1299 }
1300 return Fdistr;
1301}

References Coeff0, Coeff1, Coeff2, ConstU, G4cout, G4endl, G4Exp(), HadrSlope, Slope0, Slope1, Slope2, and G4HadronicInteraction::verboseLevel.

Referenced by HadronProtonQ2().

◆ GetLightFq2()

G4double G4ElasticHadrNucleusHE::GetLightFq2 ( G4int  Z,
G4int  A,
G4double  Q 
)
private

Definition at line 711 of file G4ElasticHadrNucleusHE.cc.

712{
713 // Scattering off proton
714 if(Z == 1)
715 {
716 G4double SqrQ2 = std::sqrt(Q2);
717 G4double valueConstU = 2.*(hMass2 + protonM2) - Q2;
718
719 G4double y = (1.-Coeff1-Coeff0)/HadrSlope*(1.-G4Exp(-HadrSlope*Q2))
720 + Coeff0*(1.-G4Exp(-Slope0*Q2))
721 + Coeff2/Slope2*G4Exp(Slope2*valueConstU)*(G4Exp(Slope2*Q2)-1.)
722 + 2.*Coeff1/Slope1*(1./Slope1-(1./Slope1+SqrQ2)*G4Exp(-Slope1*SqrQ2));
723
724 return y;
725 }
726
727 // The preparing of probability function
728
729 G4double prec = A > 208 ? 1.0e-7 : 1.0e-6;
730
731 G4double Stot = HadrTot*MbToGeV2; // Gev^-2
732 G4double Bhad = HadrSlope; // GeV^-2
733 G4double Asq = 1+HadrReIm*HadrReIm;
734 G4double Rho2 = std::sqrt(Asq);
735
736 if(verboseLevel >1) {
737 G4cout<<" Fq2 Before for i Tot B Im "<<HadrTot<<" "<<HadrSlope<<" "
738 <<HadrReIm<<G4endl;
739 }
740 if(verboseLevel > 1) {
741 G4cout << "GetFq2: Stot= " << Stot << " Bhad= " << Bhad
742 <<" Im "<<HadrReIm
743 << " Asq= " << Asq << G4endl;
744 G4cout << "R1= " << R1 << " R2= " << R2 << " Pnucl= " << Pnucl <<G4endl;
745 }
746 G4double R12 = R1*R1;
747 G4double R22 = R2*R2;
748 G4double R12B = R12+2*Bhad;
749 G4double R22B = R22+2*Bhad;
750
751 G4double Norm = (R12*R1-Pnucl*R22*R2); // HP->Aeff;
752
753 G4double R13 = R12*R1/R12B;
754 G4double R23 = Pnucl*R22*R2/R22B;
755 G4double Unucl = Stot/twopi*R13/Norm;
756 G4double UnucRho2 = -Unucl*Rho2;
757
758 G4double FiH = std::asin(HadrReIm/Rho2);
759 G4double NN2 = R23/R13;
760
761 if(verboseLevel > 2) {
762 G4cout << "UnucRho2= " << UnucRho2 << " FiH= " << FiH << " NN2= " << NN2
763 << " Norm= " << Norm << G4endl;
764 }
765 G4double Prod0 = 0.;
766 G4double N1 = -1.0;
767
768 for(G4int i1 = 1; i1<= A; ++i1)
769 {
770 N1 *= (-Unucl*Rho2*(A-i1+1)/(G4double)i1);
771 G4double Prod1 = 0.;
772 G4double N2 = -1.;
773
774 for(G4int i2 = 1; i2<=A; ++i2)
775 {
776 N2 *= (-Unucl*Rho2*(A-i2+1)/(G4double)i2);
777 G4double Prod2 = 0;
778 G4double N5 = -1/NN2;
779 for(G4int j2=0; j2<= i2; ++j2)
780 {
781 G4double Prod3 = 0;
782 G4double exp2 = 1./((G4double)j2/R22B+(G4double)(i2-j2)/R12B);
783 N5 *= (-NN2);
784 G4double N4 = -1./NN2;
785 for(G4int j1=0; j1<=i1; ++j1)
786 {
787 G4double exp1 = 1./((G4double)j1/R22B+(G4double)(i1-j1)/R12B);
788 G4double dddd = 0.25*(exp1+exp2);
789 N4 *= (-NN2);
790 Prod3 +=
791 N4*exp1*exp2*(1.-G4Exp(-Q2*dddd))*GetBinomCof(i1,j1)/dddd;
792 } // j1
793 Prod2 += Prod3*N5*GetBinomCof(i2,j2);
794 } // j2
795 Prod1 += Prod2*N2*std::cos(FiH*(i1-i2));
796
797 if (std::abs(Prod2*N2/Prod1)<prec) break;
798 } // i2
799 Prod0 += Prod1*N1;
800 if(std::abs(N1*Prod1/Prod0) < prec) break;
801 } // i1
802
803 const G4double fact = 0.25*CLHEP::pi/MbToGeV2;
804 Prod0 *= fact; // This is in mb
805
806 if(verboseLevel>1) {
807 G4cout << "GetLightFq2 Z= " << Z << " A= " << A
808 <<" Q2= " << Q2 << " Res= " << Prod0 << G4endl;
809 }
810 return Prod0;
811}
const G4double MbToGeV2
static constexpr double twopi
Definition: G4SIunits.hh:56
G4double GetBinomCof(G4int n, G4int m)
static const double prec
Definition: RanecuEngine.cc:61
static constexpr double pi
Definition: SystemOfUnits.h:55

References A, Coeff0, Coeff1, Coeff2, G4cout, G4endl, G4Exp(), GetBinomCof(), HadrReIm, HadrSlope, HadrTot, hMass2, MbToGeV2, CLHEP::pi, Pnucl, CLHEP::prec, protonM2, R1, R2, Slope0, Slope1, Slope2, twopi, G4HadronicInteraction::verboseLevel, and Z.

◆ GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const
inlineinherited

◆ GetMaxEnergy() [2/2]

G4double G4HadronicInteraction::GetMaxEnergy ( const G4Material aMaterial,
const G4Element anElement 
) const
inherited

Definition at line 131 of file G4HadronicInteraction.cc.

133{
134 if(!IsBlocked()) { return theMaxEnergy; }
135 if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return 0.0; }
136 if(!theMaxEnergyListElements.empty()) {
137 for(auto const& elmlist : theMaxEnergyListElements) {
138 if( anElement == elmlist.second )
139 { return elmlist.first; }
140 }
141 }
142 if(!theMaxEnergyList.empty()) {
143 for(auto const& matlist : theMaxEnergyList) {
144 if( aMaterial == matlist.second )
145 { return matlist.first; }
146 }
147 }
148 return theMaxEnergy;
149}
std::vector< std::pair< G4double, const G4Material * > > theMaxEnergyList
std::vector< std::pair< G4double, const G4Element * > > theMaxEnergyListElements

References G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMaxEnergy, G4HadronicInteraction::theMaxEnergyList, and G4HadronicInteraction::theMaxEnergyListElements.

◆ GetMinEnergy() [1/2]

G4double G4HadronicInteraction::GetMinEnergy ( ) const
inlineinherited

◆ GetMinEnergy() [2/2]

G4double G4HadronicInteraction::GetMinEnergy ( const G4Material aMaterial,
const G4Element anElement 
) const
inherited

Definition at line 81 of file G4HadronicInteraction.cc.

83{
84 if(!IsBlocked()) { return theMinEnergy; }
85 if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return DBL_MAX; }
86 if(!theMinEnergyListElements.empty()) {
87 for(auto const& elmlist : theMinEnergyListElements) {
88 if( anElement == elmlist.second )
89 { return elmlist.first; }
90 }
91 }
92 if(!theMinEnergyList.empty()) {
93 for(auto const & matlist : theMinEnergyList) {
94 if( aMaterial == matlist.second )
95 { return matlist.first; }
96 }
97 }
98 return theMinEnergy;
99}
std::vector< std::pair< G4double, const G4Element * > > theMinEnergyListElements
std::vector< std::pair< G4double, const G4Material * > > theMinEnergyList
#define DBL_MAX
Definition: templates.hh:62

References DBL_MAX, G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMinEnergy, G4HadronicInteraction::theMinEnergyList, and G4HadronicInteraction::theMinEnergyListElements.

◆ GetModelName()

const G4String & G4HadronicInteraction::GetModelName ( ) const
inlineinherited

Definition at line 115 of file G4HadronicInteraction.hh.

116 { return theModelName; }

References G4HadronicInteraction::theModelName.

Referenced by G4MuMinusCapturePrecompound::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4VHadronPhysics::BuildModel(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4ChargeExchangePhysics::ConstructProcess(), G4MuonicAtomDecay::DecayIt(), G4LENDModel::DumpLENDTargetInfo(), G4AblaInterface::G4AblaInterface(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4ExcitedStringDecay::G4ExcitedStringDecay(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LENDorBERTModel::G4LENDorBERTModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4LowEIonFragmentation::G4LowEIonFragmentation(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4INCLXXInterface::GetDeExcitationModelName(), G4EnergyRangeManager::GetHadronicInteraction(), G4VHighEnergyGenerator::GetProjectileNucleus(), G4NeutronRadCapture::InitialiseModel(), G4BinaryCascade::ModelDescription(), G4LMsdGenerator::ModelDescription(), G4VPartonStringModel::ModelDescription(), G4TheoFSGenerator::ModelDescription(), G4VHadronPhysics::NewModel(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4HadronicProcessStore::PrintModelHtml(), G4BinaryCascade::PropagateModelDescription(), G4HadronicProcessStore::RegisterInteraction(), and G4LENDModel::returnUnchanged().

◆ GetQ2_2()

G4double G4ElasticHadrNucleusHE::GetQ2_2 ( G4int  N,
G4int  Nmax,
const std::vector< G4double > &  F,
G4double  rand 
)
private

Definition at line 599 of file G4ElasticHadrNucleusHE.cc.

602{
603 //G4cout << "GetQ2_2 kk= " << kk << " kmax= " << kmax << " size= "
604 // << F.size() << " rand= " << ranUni << G4endl;
605 if(kk == kmax-1) {
606 G4double X1 = dQ2*kk;
607 G4double F1 = F[kk-1];
608 G4double X2 = Q2max;
609 G4double xx = R1*(X2 - X1);
610 xx = (xx > 20.) ? 0.0 : G4Exp(-xx);
611 G4double Y = X1 - G4Log(1.0 - (ranUni - F1)*(1.0 - xx)/(1.0 - F1))/R1;
612 return Y;
613 }
614 G4double F1, F2, F3, X1, X2, X3;
615
616 if(kk == 1 || kk == 0) {
617 F1 = F[0];
618 F2 = F[1];
619 F3 = F[2];
620 X1 = 0.0;
621 X2 = dQ2;
622 X3 = dQ2*2;
623 } else {
624 F1 = F[kk-2];
625 F2 = F[kk-1];
626 F3 = F[kk];
627 X1 = dQ2*(kk-2);
628 X2 = dQ2*(kk-1);
629 X3 = dQ2*kk;
630 }
631 if(verboseLevel > 1) {
632 G4cout << "GetQ2_2 kk= " << kk << " X2= " << X2 << " X3= " << X3
633 << " F2= " << F2 << " F3= " << F3 << " Rndm= " << ranUni << G4endl;
634 }
635
636 G4double F12 = F1*F1;
637 G4double F22 = F2*F2;
638 G4double F32 = F3*F3;
639
640 G4double D0 = F12*F2+F1*F32+F3*F22-F32*F2-F22*F1-F12*F3;
641
642 if(verboseLevel > 2) {
643 G4cout << " X1= " << X1 << " F1= " << F1 << " D0= "
644 << D0 << G4endl;
645 }
646 G4double Y;
647 if(std::abs(D0) < 1.e-9) {
648 Y = X2 + (ranUni - F2)*(X3 - X2)/(F3 - F2);
649 } else {
650 G4double DA = X1*F2+X3*F1+X2*F3-X3*F2-X1*F3-X2*F1;
651 G4double DB = X2*F12+X1*F32+X3*F22-X2*F32-X3*F12-X1*F22;
652 G4double DC = X3*F2*F12+X2*F1*F32+X1*F3*F22
653 -X1*F2*F32-X2*F3*F12-X3*F1*F22;
654 Y = (DA*ranUni*ranUni + DB*ranUni + DC)/D0;
655 }
656 return Y;
657}
G4double Y(G4double density)
#define F22
#define F32
#define F12

References dQ2, F12, F22, F32, G4cout, G4endl, G4Exp(), G4Log(), Q2max, R1, G4HadronicInteraction::verboseLevel, and Y().

Referenced by HadronNucleusQ2_2().

◆ GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const
inlineinherited

◆ GetSlopeCof()

G4double G4HadronElastic::GetSlopeCof ( const G4int  pdg)
inherited

Definition at line 277 of file G4HadronElastic.cc.

278{
279 // The input parameter "pdg" should be the absolute value of the PDG code
280 // (i.e. the same value for a particle and its antiparticle).
281
282 G4double coeff = 1.0;
283
284 // heavy barions
285
286 static const G4double lBarCof1S = 0.88;
287 static const G4double lBarCof2S = 0.76;
288 static const G4double lBarCof3S = 0.64;
289 static const G4double lBarCof1C = 0.784378;
290 static const G4double lBarCofSC = 0.664378;
291 static const G4double lBarCof2SC = 0.544378;
292 static const G4double lBarCof1B = 0.740659;
293 static const G4double lBarCofSB = 0.620659;
294 static const G4double lBarCof2SB = 0.500659;
295
296 if( pdg == 3122 || pdg == 3222 || pdg == 3112 || pdg == 3212 )
297 {
298 coeff = lBarCof1S; // Lambda, Sigma+, Sigma-, Sigma0
299
300 } else if( pdg == 3322 || pdg == 3312 )
301 {
302 coeff = lBarCof2S; // Xi-, Xi0
303 }
304 else if( pdg == 3324)
305 {
306 coeff = lBarCof3S; // Omega
307 }
308 else if( pdg == 4122 || pdg == 4212 || pdg == 4222 || pdg == 4112 )
309 {
310 coeff = lBarCof1C; // LambdaC+, SigmaC+, SigmaC++, SigmaC0
311 }
312 else if( pdg == 4332 )
313 {
314 coeff = lBarCof2SC; // OmegaC
315 }
316 else if( pdg == 4232 || pdg == 4132 )
317 {
318 coeff = lBarCofSC; // XiC+, XiC0
319 }
320 else if( pdg == 5122 || pdg == 5222 || pdg == 5112 || pdg == 5212 )
321 {
322 coeff = lBarCof1B; // LambdaB, SigmaB+, SigmaB-, SigmaB0
323 }
324 else if( pdg == 5332 )
325 {
326 coeff = lBarCof2SB; // OmegaB-
327 }
328 else if( pdg == 5132 || pdg == 5232 ) // XiB-, XiB0
329 {
330 coeff = lBarCofSB;
331 }
332 // heavy mesons Kaons?
333 static const G4double lMesCof1S = 0.82; // Kp/piP kaons?
334 static const G4double llMesCof1C = 0.676568;
335 static const G4double llMesCof1B = 0.610989;
336 static const G4double llMesCof2C = 0.353135;
337 static const G4double llMesCof2B = 0.221978;
338 static const G4double llMesCofSC = 0.496568;
339 static const G4double llMesCofSB = 0.430989;
340 static const G4double llMesCofCB = 0.287557;
341 static const G4double llMesCofEtaP = 0.88;
342 static const G4double llMesCofEta = 0.76;
343
344 if( pdg == 321 || pdg == 311 || pdg == 310 )
345 {
346 coeff = lMesCof1S; //K+-0
347 }
348 else if( pdg == 511 || pdg == 521 )
349 {
350 coeff = llMesCof1B; // BMeson0, BMeson+
351 }
352 else if(pdg == 421 || pdg == 411 )
353 {
354 coeff = llMesCof1C; // DMeson+, DMeson0
355 }
356 else if( pdg == 531 )
357 {
358 coeff = llMesCofSB; // BSMeson0
359 }
360 else if( pdg == 541 )
361 {
362 coeff = llMesCofCB; // BCMeson+-
363 }
364 else if(pdg == 431 )
365 {
366 coeff = llMesCofSC; // DSMeson+-
367 }
368 else if(pdg == 441 || pdg == 443 )
369 {
370 coeff = llMesCof2C; // Etac, JPsi
371 }
372 else if(pdg == 553 )
373 {
374 coeff = llMesCof2B; // Upsilon
375 }
376 else if(pdg == 221 )
377 {
378 coeff = llMesCofEta; // Eta
379 }
380 else if(pdg == 331 )
381 {
382 coeff = llMesCofEtaP; // Eta'
383 }
384 return coeff;
385}

◆ GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const
inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

110 { return verboseLevel; }

References G4HadronicInteraction::verboseLevel.

◆ HadrNucDifferCrSec()

G4double G4ElasticHadrNucleusHE::HadrNucDifferCrSec ( G4int  A,
G4double  Q2 
)
private

Definition at line 816 of file G4ElasticHadrNucleusHE.cc.

817{
818 // ------ All external kinematical variables are in MeV -------
819 // ------ but internal in GeV !!!! ------
820
821 // Scattering of proton
822 if(A == 1)
823 {
824 G4double SqrQ2 = std::sqrt(aQ2);
825 G4double valueConstU = hMass2 + protonM2-2*protonM*HadrEnergy - aQ2;
826
827 BoundaryTL[0] = Q2max;
828 BoundaryTL[1] = Q2max;
829 BoundaryTL[3] = Q2max;
830 BoundaryTL[4] = Q2max;
831 BoundaryTL[5] = Q2max;
832
834 ( Coeff1*G4Exp(-Slope1*SqrQ2)+
835 Coeff2*G4Exp( Slope2*(valueConstU)+aQ2)+
836 (1-Coeff1-Coeff0)*G4Exp(-HadrSlope*aQ2)+
837 Coeff0*G4Exp(-Slope0*aQ2) )*2.568/(16*pi);
838
839 return dSigPodT;
840 }
841
842 G4double Stot = HadrTot*MbToGeV2;
843 G4double Bhad = HadrSlope;
844 G4double Asq = 1+HadrReIm*HadrReIm;
845 G4double Rho2 = std::sqrt(Asq);
846 G4double R12 = R1*R1;
847 G4double R22 = R2*R2;
848 G4double R12B = R12+2*Bhad;
849 G4double R22B = R22+2*Bhad;
850 G4double R12Ap = R12+20;
851 G4double R22Ap = R22+20;
852 G4double R13Ap = R12*R1/R12Ap;
853 G4double R23Ap = R22*R2*Pnucl/R22Ap;
854 G4double R23dR13 = R23Ap/R13Ap;
855 G4double R12Apd = 2/R12Ap;
856 G4double R22Apd = 2/R22Ap;
857 G4double R12ApdR22Ap = 0.5*(R12Apd+R22Apd);
858
859 G4double DDSec1p = (DDSect2+DDSect3*G4Log(0.53*HadrEnergy/R1));
860 G4double DDSec2p = (DDSect2+DDSect3*G4Log(0.53*HadrEnergy/
861 std::sqrt((R12+R22)*0.5)));
862 G4double DDSec3p = (DDSect2+DDSect3*G4Log(0.53*HadrEnergy/R2));
863
864 G4double Norm = (R12*R1-Pnucl*R22*R2)*Aeff;
865 G4double R13 = R12*R1/R12B;
866 G4double R23 = Pnucl*R22*R2/R22B;
867 G4double Unucl = Stot/(twopi*Norm)*R13;
868 G4double UnuclScr = Stot/(twopi*Norm)*R13Ap;
869 G4double SinFi = HadrReIm/Rho2;
870 G4double FiH = std::asin(SinFi);
871 G4double N = -1;
872 G4double N2 = R23/R13;
873
874 G4double ImElasticAmpl0 = 0;
875 G4double ReElasticAmpl0 = 0;
876 G4double exp1;
877
878 for(G4int i=1; i<=A; ++i) {
879 N *= (-Unucl*Rho2*(A-i+1)/(G4double)i);
880 G4double N4 = 1;
881 G4double medTot = R12B/(G4double)i;
882 G4double Prod1 = G4Exp(-aQ2*R12B/(G4double)(4*i))*medTot;
883
884 for(G4int l=1; l<=i; ++l) {
885 exp1 = l/R22B+(i-l)/R12B;
886 N4 *= (-N2*(i-l+1)/(G4double)l);
887 G4double expn4 = N4/exp1;
888 Prod1 += expn4*G4Exp(-aQ2/(exp1*4));
889 medTot += expn4;
890 } // end l
891
892 G4double dcos = N*std::cos(FiH*i);
893 ReElasticAmpl0 += Prod1*N*std::sin(FiH*i);
894 ImElasticAmpl0 += Prod1*dcos;
895 if(std::abs(Prod1*N/ImElasticAmpl0) < 0.000001) break;
896 } // i
897
898 static const G4double pi25 = CLHEP::pi/2.568;
899 ImElasticAmpl0 *= pi25; // The amplitude in mB
900 ReElasticAmpl0 *= pi25; // The amplitude in mB
901
902 G4double C1 = R13Ap*R13Ap*0.5*DDSec1p;
903 G4double C2 = 2*R23Ap*R13Ap*0.5*DDSec2p;
904 G4double C3 = R23Ap*R23Ap*0.5*DDSec3p;
905
906 G4double N1p = 1;
907 G4double Din1 = 0.5*(C1*G4Exp(-aQ2/8*R12Ap)/2*R12Ap-
908 C2/R12ApdR22Ap*G4Exp(-aQ2/(4*R12ApdR22Ap))+
909 C3*R22Ap/2*G4Exp(-aQ2/8*R22Ap));
910
911 G4double DTot1 = 0.5*(C1*0.5*R12Ap-C2/R12ApdR22Ap+C3*R22Ap*0.5);
912
913 for(G4int i=1; i<= A-2; ++i) {
914 N1p *= (-UnuclScr*Rho2*(A-i-1)/(G4double)i);
915 G4double N2p = 1;
916 G4double Din2 = 0;
917 G4double DmedTot = 0;
918 G4double BinCoeff = 1.0;
919 for(G4int l=0; l<=i; ++l) {
920 if(l > 0) { BinCoeff *= (i-l+1)/(G4double)l; }
921
922 exp1 = l/R22B+(i-l)/R12B;
923 G4double exp1p = exp1+R12Apd;
924 G4double exp2p = exp1+R12ApdR22Ap;
925 G4double exp3p = exp1+R22Apd;
926
927 Din2 += N2p*BinCoeff*(C1/exp1p*G4Exp(-aQ2/(4*exp1p))-
928 C2/exp2p*G4Exp(-aQ2/(4*exp2p))+
929 C3/exp3p*G4Exp(-aQ2/(4*exp3p)));
930
931 DmedTot += N2p*BinCoeff*(C1/exp1p-C2/exp2p+C3/exp3p);
932
933 N2p *= -R23dR13;
934 } // l
935
936 G4double dcos = N1p*std::cos(FiH*i)/(G4double)((i+2)*(i+1));
937 Din1 += Din2*dcos;
938 DTot1 += DmedTot*dcos;
939
940 if(std::abs(Din2*N1p/Din1) < 0.000001) break;
941 } // i
942 G4double gg = (G4double)(A*(A-1)*4)/(Norm*Norm);
943
944 Din1 *= (-gg);
945 DTot1 *= 5*gg;
946
947 // ---------------- dSigma/d|-t|, mb/(GeV/c)^-2 -----------------
948
949 G4double DiffCrSec2 = (ReElasticAmpl0*ReElasticAmpl0+
950 (ImElasticAmpl0+Din1)*
951 (ImElasticAmpl0+Din1))/twopi;
952
953 Dtot11 = DTot1;
954 aAIm = ImElasticAmpl0;
955 aDIm = Din1;
956
957 return DiffCrSec2; // dSig/d|-t|, mb/(GeV/c)^-2
958}
static constexpr double pi
Definition: G4SIunits.hh:55
const double C2
const double C1
#define C3

References A, aAIm, aDIm, Aeff, BoundaryTL, C1, C2, C3, Coeff0, Coeff1, Coeff2, DDSect2, DDSect3, Dtot11, G4Exp(), G4Log(), HadrEnergy, HadrReIm, HadrSlope, HadrTot, hMass2, MbToGeV2, CLHEP::pi, pi, Pnucl, protonM, protonM2, Q2max, R1, R2, Slope0, Slope1, Slope2, and twopi.

Referenced by FillFq2().

◆ HadronNucleusQ2_2()

G4double G4ElasticHadrNucleusHE::HadronNucleusQ2_2 ( const G4ElasticData pElD,
G4double  plabGeV,
G4double  tmax 
)
private

Definition at line 553 of file G4ElasticHadrNucleusHE.cc.

555{
556 G4double ekin = std::sqrt(hMass2 + plab*plab) - hMass;
557
558 if(verboseLevel > 1) {
559 G4cout<<"Q2_2: ekin(GeV)= " << ekin << " plab(GeV/c)= " << plab
560 <<" tmax(GeV2)= " << tmax <<G4endl;
561 }
562 // Find closest energy bin
563 G4int idx;
564 for(idx=0; idx<NENERGY-1; ++idx) {
565 if(ekin <= fLowEdgeEnergy[idx+1]) { break; }
566 }
567 //G4cout << " idx= " << idx << G4endl;
568
569 // Select kinematics for node energy
570 R1 = pElD->R1;
571 dQ2 = pElD->dQ2;
572 Q2max = pElD->maxQ2[idx];
573 G4int length = (pElD->fCumProb[idx]).size();
574
575 G4double Rand = G4UniformRand();
576
577 G4int iNumbQ2 = 0;
578 for(iNumbQ2=1; iNumbQ2<length; ++iNumbQ2) {
579 if(Rand <= (pElD->fCumProb[idx])[iNumbQ2]) { break; }
580 }
581 iNumbQ2 = std::min(iNumbQ2, length - 1);
582 G4double Q2 = GetQ2_2(iNumbQ2, length, pElD->fCumProb[idx], Rand);
583 Q2 = std::min(Q2, Q2max);
584 Q2 *= tmax/Q2max;
585
586 if(verboseLevel > 1) {
587 G4cout<<" HadrNucleusQ2_2(2): Q2= "<<Q2<<" iNumbQ2= " << iNumbQ2
588 << " rand= " << Rand << " Q2max= " << Q2max
589 << " tmax= " << tmax << G4endl;
590 }
591 return Q2;
592}
G4double GetQ2_2(G4int N, G4int Nmax, const std::vector< G4double > &F, G4double rand)

References G4ElasticData::dQ2, dQ2, G4ElasticData::fCumProb, fLowEdgeEnergy, G4cout, G4endl, G4UniformRand, GetQ2_2(), hMass, hMass2, G4ElasticData::maxQ2, G4INCL::Math::min(), NENERGY, Q2max, G4ElasticData::R1, R1, and G4HadronicInteraction::verboseLevel.

Referenced by SampleInvariantT().

◆ HadronProtonQ2()

G4double G4ElasticHadrNucleusHE::HadronProtonQ2 ( G4double  plab,
G4double  tmax 
)
private

Definition at line 1306 of file G4ElasticHadrNucleusHE.cc.

1307{
1308 hLabMomentum = plab;
1310 HadrEnergy = std::sqrt(hMass2 + hLabMomentum2);
1312
1313 G4double Sh = 2.0*protonM*HadrEnergy+protonM2+hMass2; // GeV
1314 ConstU = 2*protonM2+2*hMass2-Sh;
1315
1316 BoundaryTL[0] = tmax;
1317 BoundaryTL[1] = tmax;
1318 BoundaryTL[3] = tmax;
1319 BoundaryTL[4] = tmax;
1320 BoundaryTL[5] = tmax;
1321
1322 G4double MaxTR = (plab < BoundaryP[iHadron1]) ?
1324
1325 if (verboseLevel>1) {
1326 G4cout<<"3 GetKin. : iHadron1 "<<iHadron1
1327 <<" Bound.P[iHadron1] "<<BoundaryP[iHadron1]
1328 <<" Bound.TL[iHadron1] "<<BoundaryTL[iHadron1]
1329 <<" Bound.TG[iHadron1] "<<BoundaryTG[iHadron1]
1330 <<" MaxT MaxTR "<<tmax<<" "<<MaxTR<<G4endl;
1331 }
1332
1333 G4double rand = G4UniformRand();
1334
1335 G4double DDD0=MaxTR*0.5, DDD1=0.0, DDD2=MaxTR;
1336
1337 G4double norm = 1.0/GetFt(MaxTR);
1338 G4double delta = GetFt(DDD0)*norm - rand;
1339
1340 static const G4int maxNumberOfLoops = 10000;
1341 G4int loopCounter = -1;
1342 while ( (std::abs(delta) > 0.0001) &&
1343 ++loopCounter < maxNumberOfLoops ) /* Loop checking, 10.08.2015, A.Ribon */
1344 {
1345 if(delta>0)
1346 {
1347 DDD2 = DDD0;
1348 DDD0 = (DDD0+DDD1)*0.5;
1349 }
1350 else if(delta<0.0)
1351 {
1352 DDD1 = DDD0;
1353 DDD0 = (DDD0+DDD2)*0.5;
1354 }
1355 delta = GetFt(DDD0)*norm - rand;
1356 }
1357 return (loopCounter >= maxNumberOfLoops) ? 0.0 : DDD0;
1358}

References BoundaryP, BoundaryTG, BoundaryTL, ConstU, DefineHadronValues(), G4cout, G4endl, G4UniformRand, GetFt(), HadrEnergy, hLabMomentum, hLabMomentum2, hMass2, iHadron1, protonM, protonM2, and G4HadronicInteraction::verboseLevel.

Referenced by SampleInvariantT().

◆ InFileName()

void G4ElasticHadrNucleusHE::InFileName ( std::ostringstream &  ss,
const G4ParticleDefinition p,
G4int  Z 
)
private

Definition at line 1380 of file G4ElasticHadrNucleusHE.cc.

1382{
1383 if(!fDirectory) {
1384 fDirectory = std::getenv("G4LEDATA");
1385 if (fDirectory) {
1386 ss << fDirectory << "/";
1387 }
1388 }
1389 OutFileName(ss, p, Z);
1390}

References fDirectory, OutFileName(), and Z.

Referenced by FillData().

◆ InitialiseModel()

void G4ElasticHadrNucleusHE::InitialiseModel ( )
overridevirtual

Reimplemented from G4HadronicInteraction.

Definition at line 337 of file G4ElasticHadrNucleusHE.cc.

338{
339 if(!isMaster) { return; }
340 G4ProductionCutsTable* theCoupleTable=
342 size_t numOfCouples = theCoupleTable->GetTableSize();
343
344 for(G4int i=0; i<2; ++i) {
346 if(1 == i) { p = G4PionMinus::PionMinus(); }
348 iHadron = fHadronType[i];
350 hMass = p->GetPDGMass()*invGeV;
352 for(size_t j=0; j<numOfCouples; ++j) {
353 auto mat = theCoupleTable->GetMaterialCutsCouple(j)->GetMaterial();
354 auto elmVec = mat->GetElementVector();
355 size_t numOfElem = mat->GetNumberOfElements();
356 for(size_t k=0; k<numOfElem; ++k) {
357 G4int Z = std::min((*elmVec)[k]->GetZasInt(), ZMAX-1);
358 if(!fElasticData[i][Z]) {
359 if(1 == i && Z > 1) {
360 fElasticData[1][Z] = fElasticData[0][Z];
361 } else {
362 FillData(p, i, Z);
363 }
364 }
365 }
366 }
367 }
368}
const G4double invGeV
void FillData(const G4ParticleDefinition *p, G4int idx, G4int Z)
static const G4int fHadronType1[NHADRONS]
static const G4int fHadronType[NHADRONS]
static const G4int fHadronCode[NHADRONS]
const G4Material * GetMaterial() const
const G4ElementVector * GetElementVector() const
Definition: G4Material.hh:186
static G4PionMinus * PionMinus()
Definition: G4PionMinus.cc:97
static G4PionPlus * PionPlus()
Definition: G4PionPlus.cc:97
const G4MaterialCutsCouple * GetMaterialCutsCouple(G4int i) const
std::size_t GetTableSize() const
static G4ProductionCutsTable * GetProductionCutsTable()

References fElasticData, fHadronCode, fHadronType, fHadronType1, FillData(), G4Material::GetElementVector(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetPDGMass(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), hMass, hMass2, iHadrCode, iHadron, iHadron1, invGeV, isMaster, G4INCL::Math::min(), G4PionMinus::PionMinus(), G4PionPlus::PionPlus(), Z, and ZMAX.

◆ InterpolateHN()

void G4ElasticHadrNucleusHE::InterpolateHN ( G4int  n,
const G4double  EnP[],
const G4double  C0P[],
const G4double  C1P[],
const G4double  B0P[],
const G4double  B1P[] 
)
private

Definition at line 532 of file G4ElasticHadrNucleusHE.cc.

535{
536 G4int i;
537
538 for(i=1; i<n; ++i) { if(hLabMomentum <= EnP[i]) { break; } }
539 if(i == n) { i = n - 1; }
540
541 Coeff0 = LineInterpol(EnP[i], EnP[i-1], C0P[i], C0P[i-1], hLabMomentum);
542 Coeff1 = LineInterpol(EnP[i], EnP[i-1], C1P[i], C1P[i-1], hLabMomentum);
543 Slope0 = LineInterpol(EnP[i], EnP[i-1], B0P[i], B0P[i-1], hLabMomentum);
544 Slope1 = LineInterpol(EnP[i], EnP[i-1], B1P[i], B1P[i-1], hLabMomentum);
545
546// G4cout<<" InterpolHN: n i "<<n<<" "<<i<<" Mom "
547// <<hLabMomentum<<G4endl;
548}
G4double LineInterpol(G4double p0, G4double p2, G4double c1, G4double c2, G4double p)

References Coeff0, Coeff1, hLabMomentum, LineInterpol(), CLHEP::detail::n, Slope0, and Slope1.

Referenced by DefineHadronValues().

◆ IsApplicable()

G4bool G4HadronicInteraction::IsApplicable ( const G4HadProjectile aTrack,
G4Nucleus targetNucleus 
)
virtualinherited

◆ IsBlocked() [1/3]

G4bool G4HadronicInteraction::IsBlocked ( ) const
inlineprotectedinherited

◆ IsBlocked() [2/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Element anElement) const
inherited

Definition at line 202 of file G4HadronicInteraction.cc.

203{
204 for (auto const& elm : theBlockedListElements) {
205 if (anElement == elm) return true;
206 }
207 return false;
208}

References G4HadronicInteraction::theBlockedListElements.

◆ IsBlocked() [3/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Material aMaterial) const
inherited

Definition at line 193 of file G4HadronicInteraction.cc.

194{
195 for (auto const& mat : theBlockedList) {
196 if (aMaterial == mat) return true;
197 }
198 return false;
199}

References G4HadronicInteraction::theBlockedList.

◆ LineInterpol()

G4double G4ElasticHadrNucleusHE::LineInterpol ( G4double  p0,
G4double  p2,
G4double  c1,
G4double  c2,
G4double  p 
)
inlineprivate

Definition at line 211 of file G4ElasticHadrNucleusHE.hh.

214{
215 return c1+(p-p1)*(c2-c1)/(p2-p1);
216}

Referenced by InterpolateHN().

◆ LowestEnergyLimit()

G4double G4HadronElastic::LowestEnergyLimit ( ) const
inlineinherited

◆ ModelDescription()

void G4ElasticHadrNucleusHE::ModelDescription ( std::ostream &  outFile) const
overridevirtual

Reimplemented from G4HadronicInteraction.

Definition at line 305 of file G4ElasticHadrNucleusHE.cc.

306{
307 outFile << "G4ElasticHadrNucleusHE is a hadron-nucleus elastic scattering\n"
308 << "model developed by N. Starkov which uses a Glauber model\n"
309 << "parameterization to calculate the final state. It is valid\n"
310 << "for all hadrons with incident momentum above 0.4 GeV/c.\n";
311}

◆ operator!=()

G4bool G4HadronicInteraction::operator!= ( const G4HadronicInteraction right) const
deleteinherited

◆ operator=()

G4ElasticHadrNucleusHE & G4ElasticHadrNucleusHE::operator= ( const G4ElasticHadrNucleusHE right)
private

◆ operator==()

G4bool G4HadronicInteraction::operator== ( const G4HadronicInteraction right) const
deleteinherited

◆ OutFileName()

void G4ElasticHadrNucleusHE::OutFileName ( std::ostringstream &  ss,
const G4ParticleDefinition p,
G4int  Z 
)
private

Definition at line 1395 of file G4ElasticHadrNucleusHE.cc.

1397{
1398 ss << "hedata/" << p->GetParticleName() << Z << ".dat";
1399}

References G4ParticleDefinition::GetParticleName(), and Z.

Referenced by FillData(), and InFileName().

◆ ReadLine()

G4bool G4ElasticHadrNucleusHE::ReadLine ( std::ifstream &  infile,
std::vector< G4double > &  v 
)
private

Definition at line 1403 of file G4ElasticHadrNucleusHE.cc.

1405{
1406 G4int n(0);
1407 infile >> n;
1408 if (infile.fail()) { return false; }
1409 if(n > 0) {
1410 v.reserve(n);
1411 G4double x(0.0);
1412 for(G4int i=0; i<n; ++i) {
1413 infile >> x;
1414 if (infile.fail()) { return false; }
1415 v.emplace_back(x);
1416 }
1417 }
1418 return true;
1419}

References CLHEP::detail::n.

Referenced by FillData().

◆ SampleInvariantT()

G4double G4ElasticHadrNucleusHE::SampleInvariantT ( const G4ParticleDefinition p,
G4double  plab,
G4int  Z,
G4int  A 
)
overridevirtual

Reimplemented from G4HadronicInteraction.

Definition at line 373 of file G4ElasticHadrNucleusHE.cc.

376{
377 G4double mass = p->GetPDGMass();
378 G4double kine = sqrt(inLabMom*inLabMom + mass*mass) - mass;
379 if(kine <= ekinLowLimit) {
380 return G4HadronElastic::SampleInvariantT(p,inLabMom,iZ,A);
381 }
382 G4int Z = std::min(iZ,ZMAX-1);
383 G4double Q2 = 0.0;
385
386 // below computations in GeV/c
387 hMass = mass*invGeV;
389 G4double plab = inLabMom*invGeV;
391
392 if(verboseLevel > 1) {
393 G4cout<< "G4ElasticHadrNucleusHE::SampleT: "
394 << " for " << p->GetParticleName()
395 << " at Z= " << Z << " A= " << A
396 << " plab(GeV)= " << plab
397 << " hadrCode= " << iHadrCode
398 << G4endl;
399 }
400 iHadron = -1;
401 G4int idx;
402 for(idx=0; idx<NHADRONS; ++idx) {
403 if(iHadrCode == fHadronCode[idx]) {
404 iHadron = fHadronType[idx];
405 iHadron1 = fHadronType1[idx];
406 break;
407 }
408 }
409 // Hadron is not in the list
410 if(0 > iHadron) { return 0.0; }
411
412 if(Z==1) {
413 Q2 = HadronProtonQ2(plab, tmax);
414
415 if (verboseLevel>1) {
416 G4cout<<" Proton : Q2 "<<Q2<<G4endl;
417 }
418 } else {
419 const G4ElasticData* ElD1 = fElasticData[idx][Z];
420
421 // Construct elastic data
422 if(!ElD1) {
423 FillData(p, idx, Z);
424 ElD1 = fElasticData[idx][Z];
425 if(!ElD1) { return 0.0; }
426 }
427
428 // sample scattering
429 Q2 = HadronNucleusQ2_2(ElD1, plab, tmax);
430
431 if(verboseLevel > 1) {
432 G4cout<<" SampleT: Q2(GeV^2)= "<<Q2<< " t/tmax= "
433 << Q2/tmax <<G4endl;
434 }
435 }
436 return Q2*GeV2;
437}
const G4double invGeV2
const G4double GeV2
G4double HadronProtonQ2(G4double plab, G4double tmax)
G4double HadronNucleusQ2_2(const G4ElasticData *pElD, G4double plabGeV, G4double tmax)

References A, ekinLowLimit, fElasticData, fHadronCode, fHadronType, fHadronType1, FillData(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), GeV2, HadronNucleusQ2_2(), HadronProtonQ2(), hMass, hMass2, iHadrCode, iHadron, iHadron1, invGeV, invGeV2, G4INCL::Math::min(), NHADRONS, G4HadronElastic::pLocalTmax, G4HadronElastic::SampleInvariantT(), G4HadronicInteraction::verboseLevel, Z, and ZMAX.

◆ SetEnergyMomentumCheckLevels()

void G4HadronicInteraction::SetEnergyMomentumCheckLevels ( G4double  relativeLevel,
G4double  absoluteLevel 
)
inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

150 { epCheckLevels.first = relativeLevel;
151 epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

Referenced by G4BinaryCascade::G4BinaryCascade(), G4CascadeInterface::G4CascadeInterface(), and G4FTFModel::G4FTFModel().

◆ SetLowestEnergyLimit()

void G4HadronElastic::SetLowestEnergyLimit ( G4double  value)
inlineinherited

◆ SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double  anEnergy)
inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

103 { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonINCLXXPhysics::AddProcess(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

◆ SetMaxEnergy() [2/3]

void G4HadronicInteraction::SetMaxEnergy ( G4double  anEnergy,
const G4Element anElement 
)
inherited

Definition at line 151 of file G4HadronicInteraction.cc.

153{
154 Block();
155 if(!theMaxEnergyListElements.empty()) {
156 for(auto & elmlist : theMaxEnergyListElements) {
157 if( anElement == elmlist.second ) {
158 elmlist.first = anEnergy;
159 return;
160 }
161 }
162 }
163 theMaxEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
164}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyListElements.

◆ SetMaxEnergy() [3/3]

void G4HadronicInteraction::SetMaxEnergy ( G4double  anEnergy,
const G4Material aMaterial 
)
inherited

Definition at line 166 of file G4HadronicInteraction.cc.

167{
168 Block();
169 if(!theMaxEnergyList.empty()) {
170 for(auto & matlist: theMaxEnergyList) {
171 if( aMaterial == matlist.second ) {
172 matlist.first = anEnergy;
173 return;
174 }
175 }
176 }
177 theMaxEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
178}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyList.

◆ SetMinEnergy() [1/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy)
inlineinherited

Definition at line 89 of file G4HadronicInteraction.hh.

90 { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4NeutrinoElectronCcModel::IsApplicable(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

◆ SetMinEnergy() [2/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy,
const G4Element anElement 
)
inherited

Definition at line 101 of file G4HadronicInteraction.cc.

103{
104 Block();
105 if(!theMinEnergyListElements.empty()) {
106 for(auto & elmlist : theMinEnergyListElements) {
107 if( anElement == elmlist.second ) {
108 elmlist.first = anEnergy;
109 return;
110 }
111 }
112 }
113 theMinEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
114}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyListElements.

◆ SetMinEnergy() [3/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy,
const G4Material aMaterial 
)
inherited

Definition at line 116 of file G4HadronicInteraction.cc.

118{
119 Block();
120 if(!theMinEnergyList.empty()) {
121 for(auto & matlist : theMinEnergyList) {
122 if( aMaterial == matlist.second ) {
123 matlist.first = anEnergy;
124 return;
125 }
126 }
127 }
128 theMinEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
129}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyList.

◆ SetModelName()

void G4HadronicInteraction::SetModelName ( const G4String nam)
inlineprotectedinherited

◆ SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double  val)
inlineinherited

◆ SetVerboseLevel()

void G4HadronicInteraction::SetVerboseLevel ( G4int  value)
inlineinherited

◆ WriteLine()

void G4ElasticHadrNucleusHE::WriteLine ( std::ofstream &  outfile,
std::vector< G4double > &  v 
)
private

Definition at line 1423 of file G4ElasticHadrNucleusHE.cc.

1425{
1426 G4int n = v.size();
1427 outfile << n << G4endl;
1428 if(n > 0) {
1429 for(G4int i=0; i<n; ++i) {
1430 outfile << v[i] << " ";
1431 }
1432 outfile << G4endl;
1433 }
1434}

References G4endl, and CLHEP::detail::n.

Referenced by FillData().

Field Documentation

◆ aAIm

G4double G4ElasticHadrNucleusHE::aAIm
private

Definition at line 186 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and HadrNucDifferCrSec().

◆ aDIm

G4double G4ElasticHadrNucleusHE::aDIm
private

Definition at line 186 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and HadrNucDifferCrSec().

◆ Aeff

G4double G4ElasticHadrNucleusHE::Aeff
private

Definition at line 189 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData(), G4ElasticHadrNucleusHE(), and HadrNucDifferCrSec().

◆ BoundaryP

G4double G4ElasticHadrNucleusHE::BoundaryP[7]
private

◆ BoundaryTG

G4double G4ElasticHadrNucleusHE::BoundaryTG[7]
private

Definition at line 180 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and HadronProtonQ2().

◆ BoundaryTL

G4double G4ElasticHadrNucleusHE::BoundaryTL[7]
private

◆ Coeff0

G4double G4ElasticHadrNucleusHE::Coeff0
private

◆ Coeff1

G4double G4ElasticHadrNucleusHE::Coeff1
private

◆ Coeff2

G4double G4ElasticHadrNucleusHE::Coeff2
private

◆ ConstU

G4double G4ElasticHadrNucleusHE::ConstU
private

Definition at line 177 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), GetFt(), and HadronProtonQ2().

◆ DDSect2

G4double G4ElasticHadrNucleusHE::DDSect2
private

◆ DDSect3

G4double G4ElasticHadrNucleusHE::DDSect3
private

◆ dQ2

G4double G4ElasticHadrNucleusHE::dQ2
private

◆ Dtot11

G4double G4ElasticHadrNucleusHE::Dtot11
private

Definition at line 186 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and HadrNucDifferCrSec().

◆ ekinLowLimit

G4double G4ElasticHadrNucleusHE::ekinLowLimit
private

Definition at line 165 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and SampleInvariantT().

◆ epCheckLevels

std::pair<G4double, G4double> G4HadronicInteraction::epCheckLevels
privateinherited

◆ fBinom

G4double G4ElasticHadrNucleusHE::fBinom = {{0.0}}
staticprivate

Definition at line 194 of file G4ElasticHadrNucleusHE.hh.

Referenced by Binom(), and GetBinomCof().

◆ fDirectory

char* G4ElasticHadrNucleusHE::fDirectory
private

Definition at line 198 of file G4ElasticHadrNucleusHE.hh.

Referenced by InFileName(), and ~G4ElasticHadrNucleusHE().

◆ fElasticData

G4ElasticData * G4ElasticHadrNucleusHE::fElasticData = {{nullptr}}
staticprivate

◆ fEnergy

G4double G4ElasticHadrNucleusHE::fEnergy = {0.0}
staticprivate

Definition at line 192 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData(), and G4ElasticHadrNucleusHE().

◆ fHadronCode

const G4int G4ElasticHadrNucleusHE::fHadronCode
staticprivate
Initial value:
=
{211,-211,2112,2212,321,-321,130,310,311,-311,
3122,3222,3112,3212,3312,3322,3334,
-2212,-2112,-3122,-3222,-3112,-3212,-3312,-3322,-3334}

Definition at line 157 of file G4ElasticHadrNucleusHE.hh.

Referenced by InitialiseModel(), and SampleInvariantT().

◆ fHadronType

const G4int G4ElasticHadrNucleusHE::fHadronType
staticprivate
Initial value:
=
{2,3,6,0,4,5,4,4,4,5,
0,0,0,0,0,0,0,
1,7,1,1,1,1,1,1,1}

Definition at line 158 of file G4ElasticHadrNucleusHE.hh.

Referenced by InitialiseModel(), and SampleInvariantT().

◆ fHadronType1

const G4int G4ElasticHadrNucleusHE::fHadronType1
staticprivate
Initial value:
=
{3,4,1,0,5,6,5,5,5,6,
0,0,0,0,0,0,0,
2,2,2,2,2,2,2,2,2}

Definition at line 159 of file G4ElasticHadrNucleusHE.hh.

Referenced by InitialiseModel(), and SampleInvariantT().

◆ fLineF

G4double G4ElasticHadrNucleusHE::fLineF = {0.0}
staticprivate

Definition at line 191 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData(), and FillFq2().

◆ fLowEdgeEnergy

G4double G4ElasticHadrNucleusHE::fLowEdgeEnergy = {0.0}
staticprivate

Definition at line 193 of file G4ElasticHadrNucleusHE.hh.

Referenced by G4ElasticHadrNucleusHE(), and HadronNucleusQ2_2().

◆ fRetrieveFromFile

G4bool G4ElasticHadrNucleusHE::fRetrieveFromFile = false
staticprivate

Definition at line 162 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData().

◆ fStoreToFile

G4bool G4ElasticHadrNucleusHE::fStoreToFile = false
staticprivate

Definition at line 161 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData().

◆ HadrEnergy

G4double G4ElasticHadrNucleusHE::HadrEnergy
private

◆ HadrReIm

G4double G4ElasticHadrNucleusHE::HadrReIm
private

◆ HadrSlope

G4double G4ElasticHadrNucleusHE::HadrSlope
private

◆ HadrTot

G4double G4ElasticHadrNucleusHE::HadrTot
private

◆ hLabMomentum

G4double G4ElasticHadrNucleusHE::hLabMomentum
private

◆ hLabMomentum2

G4double G4ElasticHadrNucleusHE::hLabMomentum2
private

◆ hMass

G4double G4ElasticHadrNucleusHE::hMass
private

◆ hMass2

G4double G4ElasticHadrNucleusHE::hMass2
private

◆ iHadrCode

G4int G4ElasticHadrNucleusHE::iHadrCode
private

◆ iHadron

G4int G4ElasticHadrNucleusHE::iHadron
private

◆ iHadron1

G4int G4ElasticHadrNucleusHE::iHadron1
private

◆ isBlocked

G4bool G4HadronicInteraction::isBlocked
protectedinherited

◆ isMaster

G4bool G4ElasticHadrNucleusHE::isMaster
private

◆ lowestEnergyLimit

G4double G4HadronElastic::lowestEnergyLimit
privateinherited

◆ nistManager

G4NistManager* G4ElasticHadrNucleusHE::nistManager
private

Definition at line 197 of file G4ElasticHadrNucleusHE.hh.

Referenced by FillData(), and G4ElasticHadrNucleusHE().

◆ nwarn

G4int G4HadronElastic::nwarn
privateinherited

◆ pLocalTmax

G4double G4HadronElastic::pLocalTmax
protectedinherited

◆ Pnucl

G4double G4ElasticHadrNucleusHE::Pnucl
private

◆ Q2max

G4double G4ElasticHadrNucleusHE::Q2max
private

◆ R1

G4double G4ElasticHadrNucleusHE::R1
private

◆ R2

G4double G4ElasticHadrNucleusHE::R2
private

◆ recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold
privateinherited

◆ registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry
privateinherited

◆ secID

G4int G4HadronElastic::secID
protectedinherited

◆ Slope0

G4double G4ElasticHadrNucleusHE::Slope0
private

◆ Slope1

G4double G4ElasticHadrNucleusHE::Slope1
private

◆ Slope2

G4double G4ElasticHadrNucleusHE::Slope2
private

◆ theAlpha

G4ParticleDefinition* G4HadronElastic::theAlpha
privateinherited

◆ theBlockedList

std::vector<const G4Material *> G4HadronicInteraction::theBlockedList
privateinherited

◆ theBlockedListElements

std::vector<const G4Element *> G4HadronicInteraction::theBlockedListElements
privateinherited

◆ theDeuteron

G4ParticleDefinition* G4HadronElastic::theDeuteron
privateinherited

◆ theMaxEnergy

G4double G4HadronicInteraction::theMaxEnergy
protectedinherited

◆ theMaxEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMaxEnergyList
privateinherited

◆ theMaxEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMaxEnergyListElements
privateinherited

◆ theMinEnergy

G4double G4HadronicInteraction::theMinEnergy
protectedinherited

◆ theMinEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMinEnergyList
privateinherited

◆ theMinEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMinEnergyListElements
privateinherited

◆ theModelName

G4String G4HadronicInteraction::theModelName
privateinherited

◆ theNeutron

G4ParticleDefinition* G4HadronElastic::theNeutron
privateinherited

Definition at line 83 of file G4HadronElastic.hh.

Referenced by G4HadronElastic::G4HadronElastic().

◆ theParticleChange

G4HadFinalState G4HadronicInteraction::theParticleChange
protectedinherited

Definition at line 172 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4ElectroVDNuclearModel::ApplyYourself(), G4ParticleHPThermalScattering::ApplyYourself(), G4NeutrinoElectronNcModel::ApplyYourself(), G4NeutronElectronElModel::ApplyYourself(), G4LFission::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4MuonVDNuclearModel::ApplyYourself(), G4NeutrinoElectronCcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4ElectroVDNuclearModel::CalculateEMVertex(), G4MuonVDNuclearModel::CalculateEMVertex(), G4ElectroVDNuclearModel::CalculateHadronicVertex(), G4MuonVDNuclearModel::CalculateHadronicVertex(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::copyOutputToHadronicResult(), G4BinaryCascade::DebugEpConservation(), G4BinaryCascade::DebugFinalEpConservation(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), G4WilsonAbrasionModel::GetAbradedNucleons(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4NeutrinoNucleusModel::RecoilDeexcitation(), G4LEHadronProtonElastic::~G4LEHadronProtonElastic(), G4LEnp::~G4LEnp(), and G4LFission::~G4LFission().

◆ theProton

G4ParticleDefinition* G4HadronElastic::theProton
privateinherited

◆ TotP

G4double G4ElasticHadrNucleusHE::TotP
private

Definition at line 176 of file G4ElasticHadrNucleusHE.hh.

Referenced by DefineHadronValues(), and G4ElasticHadrNucleusHE().

◆ verboseLevel

G4int G4HadronicInteraction::verboseLevel
protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LFission::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4CascadeInterface::checkFinalResult(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4LENDModel::create_used_target_map(), G4CascadeInterface::createBullet(), G4CascadeInterface::createTarget(), DefineHadronValues(), FillData(), FillFq2(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElasticHadrNucleusHE(), G4EMDissociation::G4EMDissociation(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), GetFt(), GetLightFq2(), GetQ2_2(), G4HadronicInteraction::GetVerboseLevel(), HadronNucleusQ2_2(), HadronProtonQ2(), G4LFission::init(), G4DiffuseElastic::Initialise(), G4DiffuseElasticV2::Initialise(), G4NuclNuclDiffuseElastic::Initialise(), G4DiffuseElastic::InitialiseOnFly(), G4DiffuseElasticV2::InitialiseOnFly(), G4NuclNuclDiffuseElastic::InitialiseOnFly(), G4CascadeInterface::makeDynamicParticle(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), SampleInvariantT(), G4AntiNuclElastic::SampleThetaCMS(), G4DiffuseElastic::SampleThetaLab(), G4NuclNuclDiffuseElastic::SampleThetaLab(), G4AntiNuclElastic::SampleThetaLab(), G4WilsonAbrasionModel::SetUseAblation(), G4HadronicInteraction::SetVerboseLevel(), G4WilsonAbrasionModel::SetVerboseLevel(), G4DiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElasticV2::ThetaCMStoThetaLab(), G4NuclNuclDiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElastic::ThetaLabToThetaCMS(), G4DiffuseElasticV2::ThetaLabToThetaCMS(), and G4NuclNuclDiffuseElastic::ThetaLabToThetaCMS().


The documentation for this class was generated from the following files: