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

#include <G4ANuMuNucleusCcModel.hh>

Inheritance diagram for G4ANuMuNucleusCcModel:
G4NeutrinoNucleusModel G4HadronicInteraction

Public Member Functions

void ActivateFor (const G4Element *anElement)
 
void ActivateFor (const G4Material *aMaterial)
 
virtual G4HadFinalStateApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &)
 
G4double CalculateQEratioA (G4int Z, G4int A, G4double energy, G4int nepdg)
 
void ClusterDecay (G4LorentzVector &lvX, G4int qX)
 
void CoherentPion (G4LorentzVector &lvP, G4int pdgP, G4Nucleus &targetNucleus)
 
void DeActivateFor (const G4Element *anElement)
 
void DeActivateFor (const G4Material *aMaterial)
 
G4double FermiMomentum (G4Nucleus &targetNucleus)
 
void FinalBarion (G4LorentzVector &lvB, G4int qB, G4int pdgB)
 
void FinalMeson (G4LorentzVector &lvM, G4int qM, G4int pdgM)
 
G4double FinalMomentum (G4double mI, G4double mF, G4double mP, G4LorentzVector lvX)
 
 G4ANuMuNucleusCcModel (const G4String &name="ANuMuNuclCcModel")
 
G4bool GetCascade ()
 
G4double GetCosTheta ()
 
G4double GetCutEnergy ()
 
G4double GetDp ()
 
G4double GetEmu ()
 
G4int GetEnergyIndex (G4double energy)
 
virtual std::pair< G4double, G4doubleGetEnergyMomentumCheckLevels () const
 
G4double GetEx ()
 
G4double GetEx (G4int A, G4bool fP)
 
virtual const std::pair< G4double, G4doubleGetFatalEnergyCheckLevels () const
 
G4bool GetfBreak ()
 
G4bool GetfCascade ()
 
G4bool GetfString ()
 
G4LorentzVector GetLVcpi ()
 
G4LorentzVector GetLVh ()
 
G4LorentzVector GetLVl ()
 
G4LorentzVector GetLVt ()
 
G4double GetM1 ()
 
G4double GetMaxEnergy () const
 
G4double GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
G4double GetMinEnergy () const
 
G4double GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
G4double GetMinNuMuEnergy ()
 
const G4StringGetModelName () const
 
G4double GetMr ()
 
G4double GetMuMass ()
 
G4double GetNuEnergy ()
 
G4double GetNuMuOnePionProb (G4int index, G4double energy)
 
G4double GetNuMuQeTotRat (G4int index, G4double energy)
 
G4int GetOnePionIndex (G4double energy)
 
G4int GetPDGencoding ()
 
G4double GetQ2 ()
 
G4double GetQEratioA ()
 
G4double GetQkr (G4int iE, G4int jX, G4double prob)
 
G4double GetQtransfer ()
 
G4double GetRecoilEnergyThreshold () const
 
G4bool GetString ()
 
G4double GetTr ()
 
G4int GetVerboseLevel () const
 
G4double GetW2 ()
 
G4double GetXkr (G4int iEnergy, G4double prob)
 
G4double GetXsample ()
 
G4double GgSampleNM (G4Nucleus &nucl)
 
virtual void InitialiseModel ()
 
virtual G4bool IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
 
G4bool IsBlocked (const G4Element *anElement) const
 
G4bool IsBlocked (const G4Material *aMaterial) const
 
void MesonDecay (G4LorentzVector &lvX, G4int qX)
 
virtual void ModelDescription (std::ostream &) const
 
G4double NucleonMomentum (G4Nucleus &targetNucleus)
 
G4bool operator!= (const G4HadronicInteraction &right) const =delete
 
G4bool operator== (const G4HadronicInteraction &right) const =delete
 
void RecoilDeexcitation (G4Fragment &fragment)
 
virtual G4double SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
 
void SampleLVkr (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
 
G4double SampleQkr (G4double energy, G4double xx)
 
G4double SampleXkr (G4double energy)
 
void SetCutEnergy (G4double ec)
 
void SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
 
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 SetQEratioA (G4double qea)
 
void SetRecoilEnergyThreshold (G4double val)
 
void SetVerboseLevel (G4int value)
 
G4double ThresholdEnergy (G4double mI, G4double mF, G4double mP)
 
virtual ~G4ANuMuNucleusCcModel ()
 

Protected Member Functions

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

Protected Attributes

G4bool f2p2h
 
G4bool fBreak
 
G4bool fCascade
 
G4double fCosTheta
 
G4double fCosThetaPi
 
G4double fCutEnergy
 
G4ExcitationHandlerfDeExcitation
 
G4double fDp
 
G4int fEindex
 
G4double fEmu
 
G4double fEmuPi
 
G4double fEx
 
G4int fIndex
 
G4LorentzVector fLVcpi
 
G4LorentzVector fLVh
 
G4LorentzVector fLVl
 
G4LorentzVector fLVt
 
G4double fM1
 
G4double fM2
 
G4double fMinNuEnergy
 
G4double fMpi
 
G4double fMr
 
G4double fMt
 
G4double fMu
 
G4int fNbin
 
G4double fNuEnergy
 
G4int fOnePionIndex
 
G4int fPDGencoding
 
G4GeneratorPrecompoundInterfacefPrecoInterface
 
G4PreCompoundModelfPreCompound
 
G4bool fProton
 
G4double fQ2
 
G4double fQEratioA
 
G4int fQindex
 
G4double fQtransfer
 
G4NucleusfRecoil
 
G4int fSecID
 
G4double fSin2tW
 
G4bool fString
 
G4double fTr
 
G4double fW2
 
G4double fW2pi
 
G4int fXindex
 
G4double fXsample
 
G4bool isBlocked
 
G4double theMaxEnergy
 
G4double theMinEnergy
 
G4ParticleDefinitiontheMuonMinus
 
G4ParticleDefinitiontheMuonPlus
 
G4HadFinalState theParticleChange
 
G4int verboseLevel
 

Static Protected Attributes

static const G4double fANeMuQEratio [50]
 
static const G4double fBarMass [4] = {1700., 1600., 1232., 939.57}
 
static const G4int fBarPDG [4] = {12224, 32224, 2224, 2212}
 
static const G4int fClustNumber = 4
 
static const G4double fMesMass [4] = {1260., 980., 770., 139.57}
 
static const G4int fMesPDG [4] = {20213, 9000211, 213, 211}
 
static const G4double fNeMuQEratio [50]
 
static const G4double fNuMuEnergy [50]
 
static const G4double fNuMuEnergyLogVector [50]
 
static G4double fNuMuQarrayKR [50][51][51] = {{{1.0}}}
 
static G4double fNuMuQdistrKR [50][51][50] = {{{1.0}}}
 
static const G4double fNuMuQeTotRat [50]
 
static const G4double fNuMuResQ [50][50]
 
static G4double fNuMuXarrayKR [50][51] = {{1.0}}
 
static G4double fNuMuXdistrKR [50][50] = {{1.0}}
 
static const G4double fOnePionEnergy [58]
 
static const G4double fOnePionProb [58]
 
static const G4double fQEnergy [50]
 
static const G4double fResMass [6]
 
static const G4int fResNumber = 6
 

Private Attributes

std::pair< G4double, G4doubleepCheckLevels
 
G4bool fData
 
G4bool fMaster
 
G4double recoilEnergyThreshold
 
G4HadronicInteractionRegistryregistry
 
std::vector< const G4Material * > theBlockedList
 
std::vector< const G4Element * > theBlockedListElements
 
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
 

Detailed Description

Definition at line 55 of file G4ANuMuNucleusCcModel.hh.

Constructor & Destructor Documentation

◆ G4ANuMuNucleusCcModel()

G4ANuMuNucleusCcModel::G4ANuMuNucleusCcModel ( const G4String name = "ANuMuNuclCcModel")

Definition at line 94 of file G4ANuMuNucleusCcModel.cc.

96{
97 fData = fMaster = false;
99}
G4NeutrinoNucleusModel(const G4String &name="neutrino-nucleus")
const char * name(G4int ptype)

References fData, fMaster, and InitialiseModel().

◆ ~G4ANuMuNucleusCcModel()

G4ANuMuNucleusCcModel::~G4ANuMuNucleusCcModel ( )
virtual

Definition at line 102 of file G4ANuMuNucleusCcModel.cc.

103{}

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 * G4ANuMuNucleusCcModel::ApplyYourself ( const G4HadProjectile aTrack,
G4Nucleus targetNucleus 
)
virtual

Implements G4NeutrinoNucleusModel.

Definition at line 237 of file G4ANuMuNucleusCcModel.cc.

239{
241 fProton = f2p2h = fBreak = false;
242 fCascade = fString = false;
243 fLVh = fLVl = fLVt = fLVcpi = G4LorentzVector(0.,0.,0.,0.);
244
245 const G4HadProjectile* aParticle = &aTrack;
246 G4double energy = aParticle->GetTotalEnergy();
247
248 G4String pName = aParticle->GetDefinition()->GetParticleName();
249
250 if( energy < fMinNuEnergy )
251 {
254 return &theParticleChange;
255 }
256
257 SampleLVkr( aTrack, targetNucleus);
258
259 if( fBreak == true || fEmu < fMu ) // ~5*10^-6
260 {
261 // G4cout<<"ni, ";
264 return &theParticleChange;
265 }
266
267 // LVs of initial state
268
269 G4LorentzVector lvp1 = aParticle->Get4Momentum();
270 G4LorentzVector lvt1( 0., 0., 0., fM1 );
272
273 // 1-pi by fQtransfer && nu-energy
274 G4LorentzVector lvpip1( 0., 0., 0., mPip );
275 G4LorentzVector lvsum, lv2, lvX;
276 G4ThreeVector eP;
277 G4double cost(1.), sint(0.), phi(0.), muMom(0.), massX2(0.), massX(0.), massR(0.), eCut(0.);
278 G4DynamicParticle* aLept = nullptr; // lepton lv
279
280 G4int Z = targetNucleus.GetZ_asInt();
281 G4int A = targetNucleus.GetA_asInt();
282 G4double mTarg = targetNucleus.AtomicMass(A,Z);
283 G4int pdgP(0), qB(0);
284 // G4double mSum = G4ParticleTable::GetParticleTable()->FindParticle(2212)->GetPDGMass() + mPip;
285
287 G4double p1pi = GetNuMuOnePionProb( iPi, energy);
288
289 if( p1pi > G4UniformRand() && fCosTheta > 0.9 ) // && fQtransfer < 0.95*GeV ) // mu- & coherent pion + nucleus
290 {
291 // lvsum = lvp1 + lvpip1;
292 lvsum = lvp1 + lvt1;
293 // cost = fCosThetaPi;
294 cost = fCosTheta;
295 sint = std::sqrt( (1.0 - cost)*(1.0 + cost) );
297 eP = G4ThreeVector( sint*std::cos(phi), sint*std::sin(phi), cost );
298
299 // muMom = sqrt(fEmuPi*fEmuPi-fMu*fMu);
300 muMom = sqrt(fEmu*fEmu-fMu*fMu);
301
302 eP *= muMom;
303
304 // lv2 = G4LorentzVector( eP, fEmuPi );
305 // lv2 = G4LorentzVector( eP, fEmu );
306 lv2 = fLVl;
307
308 // lvX = lvsum - lv2;
309 lvX = fLVh;
310 massX2 = lvX.m2();
311 massX = lvX.m();
312 massR = fLVt.m();
313
314 if ( massX2 <= 0. ) // vmg: very rarely ~ (1-4)e-6 due to big Q2/x, to be improved
315 {
316 fCascade = true;
319 return &theParticleChange;
320 }
321 fW2 = massX2;
322
323 if( pName == "anti_nu_mu") aLept = new G4DynamicParticle( theMuonPlus, lv2 );
324 else
325 {
328 return &theParticleChange;
329 }
330 if( pName == "anti_nu_mu" ) pdgP = -211;
331 // else pdgP = -211;
332 // eCut = fMpi + 0.5*(fMpi*fMpi-massX2)/mTarg; // massX -> fMpi
333
334 if( A > 1 )
335 {
336 eCut = (fMpi + mTarg)*(fMpi + mTarg) - (massX + massR)*(massX + massR);
337 eCut /= 2.*massR;
338 eCut += massX;
339 }
340 else eCut = fM1 + fMpi;
341
342 if ( lvX.e() > eCut ) // && sqrt( GetW2() ) < 1.4*GeV ) //
343 {
344 CoherentPion( lvX, pdgP, targetNucleus);
345 }
346 else
347 {
348 fCascade = true;
351 return &theParticleChange;
352 }
354
355 return &theParticleChange;
356 }
357 else // lepton part in lab
358 {
359 lvsum = lvp1 + lvt1;
360 cost = fCosTheta;
361 sint = std::sqrt( (1.0 - cost)*(1.0 + cost) );
363 eP = G4ThreeVector( sint*std::cos(phi), sint*std::sin(phi), cost );
364
365 muMom = sqrt(fEmu*fEmu-fMu*fMu);
366
367 eP *= muMom;
368
369 lv2 = G4LorentzVector( eP, fEmu );
370 lv2 = fLVl;
371 lvX = lvsum - lv2;
372 lvX = fLVh;
373 massX2 = lvX.m2();
374
375 if ( massX2 <= 0. ) // vmg: very rarely ~ (1-4)e-6 due to big Q2/x, to be improved
376 {
377 fCascade = true;
380 return &theParticleChange;
381 }
382 fW2 = massX2;
383
384 if( pName == "anti_nu_mu") aLept = new G4DynamicParticle( theMuonPlus, lv2 );
385 else
386 {
389 return &theParticleChange;
390 }
392 }
393
394 // hadron part
395
396 fRecoil = nullptr;
397
398 if( A == 1 )
399 {
400 if( pName == "anti_nu_mu" ) qB = 2;
401 // else qB = 0;
402
403 // if( G4UniformRand() > 0.1 ) // > 0.9999 ) // > 0.0001 ) //
404 {
405 ClusterDecay( lvX, qB );
406 }
407 return &theParticleChange;
408 }
409 /*
410 // else
411 {
412 if( pName == "nu_mu" ) pdgP = 211;
413 else pdgP = -211;
414
415
416 if ( fQtransfer < 0.95*GeV ) // < 0.35*GeV ) //
417 {
418 if( lvX.m() > mSum ) CoherentPion( lvX, pdgP, targetNucleus);
419 }
420 }
421 return &theParticleChange;
422 }
423 */
424 G4Nucleus recoil;
425 G4double rM(0.), ratio = G4double(Z)/G4double(A);
426
427 if( ratio > G4UniformRand() ) // proton is excited
428 {
429 fProton = true;
430 recoil = G4Nucleus(A-1,Z-1);
431 fRecoil = &recoil;
432 rM = recoil.AtomicMass(A-1,Z-1);
433
434 if( pName == "anti_nu_mu" ) // (0) state -> p + pi-
435 {
438 }
439 else // (0) state -> p + pi-, n + pi0
440 {
441 // fMt = G4ParticleTable::GetParticleTable()->FindParticle(2212)->GetPDGMass()
442 // + G4ParticleTable::GetParticleTable()->FindParticle(-211)->GetPDGMass();
443 }
444 }
445 else // excited neutron
446 {
447 fProton = false;
448 recoil = G4Nucleus(A-1,Z);
449 fRecoil = &recoil;
450 rM = recoil.AtomicMass(A-1,Z);
451
452 if( pName == "anti_nu_mu" ) // (+) state -> n + pi+
453 {
456 }
457 else // (-) state -> n + pi-, // n + pi0
458 {
459 // fMt = G4ParticleTable::GetParticleTable()->FindParticle(2112)->GetPDGMass()
460 // + G4ParticleTable::GetParticleTable()->FindParticle(-211)->GetPDGMass();
461 }
462 }
463 // G4int index = GetEnergyIndex(energy);
464 G4int nepdg = aParticle->GetDefinition()->GetPDGEncoding();
465
466 G4double qeTotRat; // = GetNuMuQeTotRat(index, energy);
467 qeTotRat = CalculateQEratioA( Z, A, energy, nepdg);
468
469 G4ThreeVector dX = (lvX.vect()).unit();
470 G4double eX = lvX.e(); // excited nucleon
471 G4double mX = sqrt(massX2);
472 // G4double pX = sqrt( eX*eX - mX*mX );
473 // G4double sumE = eX + rM;
474
475 if( qeTotRat > G4UniformRand() || mX <= fMt ) // || eX <= 1232.*MeV) // QE
476 {
477 fString = false;
478
479 if( fProton )
480 {
481 fPDGencoding = 2212;
483 recoil = G4Nucleus(A-1,Z-1);
484 fRecoil = &recoil;
485 rM = recoil.AtomicMass(A-1,Z-1);
486 }
487 else // if( pName == "anti_nu_mu" )
488 {
489 fPDGencoding = 2112;
491 FindParticle(fPDGencoding)->GetPDGMass(); // 939.5654133*MeV;
492 recoil = G4Nucleus(A-1,Z);
493 fRecoil = &recoil;
494 rM = recoil.AtomicMass(A-1,Z);
495 }
496 // sumE = eX + rM;
497 G4double eTh = fMr + 0.5*(fMr*fMr - mX*mX)/rM;
498
499 if( eX <= eTh ) // vmg, very rarely out of kinematics
500 {
501 fString = true;
504 return &theParticleChange;
505 }
506 // FinalBarion( fLVh, 0, fPDGencoding ); // p(n)+deexcited recoil
507 FinalBarion( lvX, 0, fPDGencoding ); // p(n)+deexcited recoil
508 }
509 else // if ( eX < 9500000.*GeV ) // < 25.*GeV) // < 95.*GeV ) // < 2.5*GeV ) //cluster decay
510 {
511 if ( fProton && pName == "anti_nu_mu" ) qB = 0;
512 else if( !fProton && pName == "anti_nu_mu" ) qB = -1;
513
514 ClusterDecay( lvX, qB );
515 }
516 return &theParticleChange;
517}
CLHEP::HepLorentzVector G4LorentzVector
CLHEP::Hep3Vector G4ThreeVector
double G4double
Definition: G4Types.hh:83
int G4int
Definition: G4Types.hh:85
const G4int Z[17]
const G4double A[17]
#define G4UniformRand()
Definition: Randomize.hh:52
Hep3Vector unit() const
Hep3Vector vect() const
void SampleLVkr(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
void AddSecondary(G4DynamicParticle *aP, G4int mod=-1)
void SetEnergyChange(G4double anEnergy)
void SetMomentumChange(const G4ThreeVector &aV)
const G4ParticleDefinition * GetDefinition() const
const G4LorentzVector & Get4Momentum() const
G4double GetTotalEnergy() const
void CoherentPion(G4LorentzVector &lvP, G4int pdgP, G4Nucleus &targetNucleus)
G4int GetOnePionIndex(G4double energy)
G4double GetNuMuOnePionProb(G4int index, G4double energy)
G4double CalculateQEratioA(G4int Z, G4int A, G4double energy, G4int nepdg)
G4ParticleDefinition * theMuonPlus
void ClusterDecay(G4LorentzVector &lvX, G4int qX)
void FinalBarion(G4LorentzVector &lvB, G4int qB, G4int pdgB)
G4int GetA_asInt() const
Definition: G4Nucleus.hh:99
G4int GetZ_asInt() const
Definition: G4Nucleus.hh:105
G4double AtomicMass(const G4double A, const G4double Z, const G4int numberOfLambdas=0) const
Definition: G4Nucleus.cc:357
const G4String & GetParticleName() const
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
static G4ParticleTable * GetParticleTable()
static constexpr double twopi
Definition: SystemOfUnits.h:56
G4double energy(const ThreeVector &p, const G4double m)
float proton_mass_c2
Definition: hepunit.py:274

References A, G4HadFinalState::AddSecondary(), G4Nucleus::AtomicMass(), G4NeutrinoNucleusModel::CalculateQEratioA(), G4HadFinalState::Clear(), G4NeutrinoNucleusModel::ClusterDecay(), G4NeutrinoNucleusModel::CoherentPion(), CLHEP::HepLorentzVector::e(), G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::f2p2h, G4NeutrinoNucleusModel::fBreak, G4NeutrinoNucleusModel::fCascade, G4NeutrinoNucleusModel::fCosTheta, G4NeutrinoNucleusModel::fEmu, G4NeutrinoNucleusModel::FinalBarion(), G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fLVcpi, G4NeutrinoNucleusModel::fLVh, G4NeutrinoNucleusModel::fLVl, G4NeutrinoNucleusModel::fLVt, G4NeutrinoNucleusModel::fM1, G4NeutrinoNucleusModel::fMinNuEnergy, G4NeutrinoNucleusModel::fMpi, G4NeutrinoNucleusModel::fMr, G4NeutrinoNucleusModel::fMt, G4NeutrinoNucleusModel::fMu, G4NeutrinoNucleusModel::fPDGencoding, G4NeutrinoNucleusModel::fProton, G4NeutrinoNucleusModel::fRecoil, G4NeutrinoNucleusModel::fSecID, G4NeutrinoNucleusModel::fString, G4NeutrinoNucleusModel::fW2, G4UniformRand, G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4HadProjectile::GetDefinition(), G4NeutrinoNucleusModel::GetNuMuOnePionProb(), G4NeutrinoNucleusModel::GetOnePionIndex(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4HadProjectile::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), CLHEP::HepLorentzVector::m(), CLHEP::HepLorentzVector::m2(), source.hepunit::proton_mass_c2, SampleLVkr(), G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetMomentumChange(), G4NeutrinoNucleusModel::theMuonPlus, G4HadronicInteraction::theParticleChange, CLHEP::twopi, CLHEP::Hep3Vector::unit(), CLHEP::HepLorentzVector::vect(), and Z.

◆ Block()

void G4HadronicInteraction::Block ( )
inlineprotectedinherited

◆ BuildPhysicsTable()

void G4HadronicInteraction::BuildPhysicsTable ( const G4ParticleDefinition )
virtualinherited

◆ CalculateQEratioA()

G4double G4NeutrinoNucleusModel::CalculateQEratioA ( G4int  Z,
G4int  A,
G4double  energy,
G4int  nepdg 
)
inherited

Definition at line 1365 of file G4NeutrinoNucleusModel.cc.

1366{
1367 energy /= GeV;
1368 G4double qerata(0.5), rr(0.), x1(0.), x2(0.), y1(0.), y2(0.), aa(0.);
1369 G4int i(0), N(0);
1370
1371 if( A > Z ) N = A-Z;
1372
1373 for( i = 0; i < 50; i++)
1374 {
1375 if( fQEnergy[i] >= energy ) break;
1376 }
1377 if(i <= 0) return 1.;
1378 else if (i >= 49) return 0.;
1379 else
1380 {
1381 x1 = fQEnergy[i-1];
1382 x2 = fQEnergy[i];
1383
1384 if( nepdg == 12 || nepdg == 14 )
1385 {
1386 if( x1 >= x2) return fNeMuQEratio[i];
1387
1388 y1 = fNeMuQEratio[i-1];
1389 y2 = fNeMuQEratio[i];
1390 }
1391 else
1392 {
1393 if( x1 >= x2) return fANeMuQEratio[i];
1394
1395 y1 = fANeMuQEratio[i-1];
1396 y2 = fANeMuQEratio[i];
1397 }
1398 aa = (y2-y1)/(x2-x1);
1399 rr = y1 + (energy-x1)*aa;
1400
1401 if( nepdg == 12 || nepdg == 14 ) qerata = N*rr/( N*rr + A*( 1 - rr ) );
1402 else qerata = Z*rr/( Z*rr + A*( 1 - rr ) );
1403 }
1404 fQEratioA = qerata;
1405
1406 return qerata;
1407}
static constexpr double GeV
Definition: G4SIunits.hh:203
static const G4double fQEnergy[50]
static const G4double fNeMuQEratio[50]
static const G4double fANeMuQEratio[50]

References A, G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fANeMuQEratio, G4NeutrinoNucleusModel::fNeMuQEratio, G4NeutrinoNucleusModel::fQEnergy, G4NeutrinoNucleusModel::fQEratioA, GeV, and Z.

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), and G4NuMuNucleusNcModel::ApplyYourself().

◆ ClusterDecay()

void G4NeutrinoNucleusModel::ClusterDecay ( G4LorentzVector lvX,
G4int  qX 
)
inherited

Definition at line 720 of file G4NeutrinoNucleusModel.cc.

721{
722 G4bool finB = false;
723 G4int pdgB(0), i(0), qM(0), qB(0); // pdgM(0),
724 G4double mM(0.), mB(0.), eM(0.), eB(0.), pM(0.), pB(0.);
725 G4double mm1(0.), mm22(0.), M1(0.), M2(0.), mX(0.);
726
727 mX = lvX.m();
728
731
732 // G4double deltaM = 1.*MeV; // 30.*MeV; // 10.*MeV; // 100.*MeV; // 20.*MeV; //
733 G4double deltaMr[4] = { 0.*MeV, 0.*MeV, 100.*MeV, 0.*MeV};
734
735 G4ThreeVector dir(0.,0.,0.);
736 G4ThreeVector bst(0.,0.,0.);
737 G4LorentzVector lvM(0.,0.,0.,0.);
738 G4LorentzVector lvB(0.,0.,0.,0.);
739
740 for( i = 0; i < fClustNumber; ++i) // check resonance
741 {
742 if( mX >= fBarMass[i] )
743 {
744 pdgB = fBarPDG[i];
745 // mB = G4ParticleTable::GetParticleTable()->FindParticle(pdgB)->GetPDGMass();
746 break;
747 }
748 }
749 if( i == fClustNumber || i == fClustNumber-1 ) // low mass, p || n
750 {
751 if ( qX == 2 || qX == 0) { pdgB = 2212; qB = 1;} // p for 2, 0
752
753 else if( qX == 1 || qX == -1) { pdgB = 2112; qB = 0;} // n for 1, -1
754
755 return FinalBarion( lvX, qB, pdgB);
756 }
757 else if( mX < fBarMass[i] + deltaMr[i] || mX < mN + mPi )
758 {
759 finB = true; // final barion -> out
760
761 if ( qX == 1 && pdgB != 2212) pdgB = pdgB - 10;
762 else if( qX == 0 && pdgB != 2212) pdgB = pdgB - 110;
763 else if( qX == 0 && pdgB == 2212) pdgB = pdgB - 100;
764
765 if( finB ) return FinalBarion( lvX, qX, pdgB ); // out
766 }
767 // no barion resonance, try 1->2 decay in COM frame
768
769 // try meson mass
770
771 mm1 = mPi + 1.*MeV; // pi+
772 mm22 = mX - mN; // mX-n
773
774 if( mm22 <= mm1 ) // out with p or n
775 {
776 if( qX == 2 || qX == 0) { pdgB = 2212; qB = 1;} // p
777 else if( qX == 1 || qX == -1) { pdgB = 2112; qB = 0;} // n
778
779 return FinalBarion(lvX, qB, pdgB);
780 }
781 else // try decay -> meson(cluster) + barion(cluster)
782 {
783 // G4double sigmaM = 50.*MeV; // 100.*MeV; // 200.*MeV; // 400.*MeV; // 800.*MeV; //
784 G4double rand = G4UniformRand();
785
786 // mM = mm1*mm22/( mm1 + rand*(mm22 - mm1) );
787 // mM = mm1*mm22/sqrt( mm1*mm1 + rand*(mm22*mm22 - mm1*mm1) );
788 // mM = -sigmaM*log( (1.- rand)*exp(-mm22/sigmaM) + rand*exp(-mm1/sigmaM) );
789 mM = mm1 + rand*(mm22-mm1);
790
791
792 for( i = 0; i < fClustNumber; ++i)
793 {
794 if( mM >= fMesMass[i] )
795 {
796 // pdgM = fMesPDG[i];
797 // mM = G4ParticleTable::GetParticleTable()->FindParticle(pdgM)->GetPDGMass();
798 break;
799 }
800 }
802 M2 = mX - mM;
803
804 if( M2 <= M1 ) //
805 {
806 if ( qX == 2 || qX == 0) { pdgB = 2212; qB = 1;} // p
807 else if( qX == 1 || qX == -1) { pdgB = 2112; qB = 0;} // n
808
809 return FinalBarion(lvX, qB, pdgB);
810 }
811 mB = M1 + G4UniformRand()*(M2-M1);
812 // mB = -sigmaM*log( (1.- rand)*exp(-M2/sigmaM) + rand*exp(-M1/sigmaM) );
813
814 bst = lvX.boostVector();
815
816 // dir = G4RandomDirection(); // ???
817 // dir = G4ThreeVector(0.,0.,1.);
818 dir = bst.orthogonal().unit(); // ??
819 // G4double cost = exp(-G4UniformRand());
820 // G4double sint = sqrt((1.-cost)*(1.+cost));
821 // G4double phi = twopi*G4UniformRand();
822 // dir = G4ThreeVector(sint*cos(phi), sint*sin(phi), cost);
823
824 eM = 0.5*(mX*mX + mM*mM - mB*mB)/mX;
825 pM = sqrt(eM*eM - mM*mM);
826 lvM = G4LorentzVector( pM*dir, eM);
827 lvM.boost(bst);
828
829 eB = 0.5*(mX*mX + mB*mB - mM*mM)/mX;
830 pB = sqrt(eB*eB - mB*mB);
831 lvB = G4LorentzVector(-pB*dir, eB);
832 lvB.boost(bst);
833
834 // G4cout<<mM<<"/"<<mB<<", ";
835
836 // charge exchange
837
838 if ( qX == 2 ) { qM = 1; qB = 1;}
839 else if( qX == 1 ) { qM = 0; qB = 1;}
840 else if( qX == 0 ) { qM = 0; qB = 0;}
841 else if( qX == -1 ) { qM = -1; qB = 0;}
842
843 // if ( qM == 0 ) pdgM = pdgM - 100;
844 // else if( qM == -1 ) pdgM = -pdgM;
845
846 MesonDecay( lvM, qM); // pdgM ); //
847
848 // else
849 ClusterDecay( lvB, qB ); // continue
850 }
851}
static constexpr double MeV
Definition: G4SIunits.hh:200
bool G4bool
Definition: G4Types.hh:86
Hep3Vector orthogonal() const
Hep3Vector boostVector() const
static const G4double fBarMass[4]
void MesonDecay(G4LorentzVector &lvX, G4int qX)
static const G4double fMesMass[4]
static const G4int fBarPDG[4]

References CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4NeutrinoNucleusModel::ClusterDecay(), G4NeutrinoNucleusModel::fBarMass, G4NeutrinoNucleusModel::fBarPDG, G4NeutrinoNucleusModel::fClustNumber, G4NeutrinoNucleusModel::FinalBarion(), G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fMesMass, G4UniformRand, G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), CLHEP::HepLorentzVector::m(), G4NeutrinoNucleusModel::MesonDecay(), MeV, CLHEP::Hep3Vector::orthogonal(), anonymous_namespace{G4ChipsKaonPlusInelasticXS.cc}::pM, and CLHEP::Hep3Vector::unit().

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), and G4NeutrinoNucleusModel::ClusterDecay().

◆ CoherentPion()

void G4NeutrinoNucleusModel::CoherentPion ( G4LorentzVector lvP,
G4int  pdgP,
G4Nucleus targetNucleus 
)
inherited

Definition at line 595 of file G4NeutrinoNucleusModel.cc.

596{
597 G4int A(0), Z(0), pdg = pdgP;
598 fLVcpi = G4LorentzVector(0.,0.,0.,0.);
599
600 G4double rM(0.), mN(938.), det(0.), det2(0.);
601 G4double mI(0.);
602 mN = G4ParticleTable::GetParticleTable()->FindParticle(2212)->GetPDGMass(); // *0.85; // *0.9; //
603
604 // mN = 1.*139.57 + G4UniformRand()*(938. - 1.*139.57);
605
606 G4ThreeVector vN = lvP.boostVector(), bst(0.,0.,0.);
607 // G4double gN = lvP.e()/lvP.m();
608 // G4LorentzVector lvNu(vN*gN*mN, mN*gN);
609 G4LorentzVector lvNu(0.,0.,0., mN); // lvNu(bst, mN);
610 lvP.boost(-vN); // 9-3-20
611 lvP = lvP - lvNu; // 9-3-20 already 1pi
612 lvP.boost(vN); // 9-3-20
613 lvNu.boost(vN); // 9-3-20
614
615 // G4cout<<vN-lvP.boostVector()<<", ";
616
617 Z = targetNucleus.GetZ_asInt();
618 A = targetNucleus.GetA_asInt();
619 rM = targetNucleus.AtomicMass(A,Z); //->AtomicMass(); //
620
621 // G4cout<<rM<<", ";
622 // G4cout<<A<<", ";
623
624 if( A == 1 )
625 {
626 bst = vN; // lvNu.boostVector(); // 9-3-20
627 // mI = 0.; // 9-3-20
628 rM = mN;
629 }
630 else
631 {
632 G4Nucleus targ(A-1,Z);
633 mI = targ.AtomicMass(A-1,Z);
634 G4LorentzVector lvTar(0.,0.,0.,mI);
635 lvNu = lvNu + lvTar;
636 bst = lvNu.boostVector();
637 // bst = fLVt.boostVector(); // to recoil rest frame
638 // G4cout<<fLVt<<" "<<bst<<G4endl;
639 }
640 lvP.boost(-bst); // 9-3-20
642 G4double eX = lvP.e();
643 G4double mX = lvP.m();
644 // G4cout<<mX-fMr<<", ";
645 G4ThreeVector dX = (lvP.vect()).unit();
646 // G4cout<<dX<<", ";
647 G4double pX = sqrt(eX*eX-mX*mX);
648 // G4cout<<pX<<", ";
649 G4double sumE = eX + rM;
650 G4double B = sumE*sumE + rM*rM - fMr*fMr - pX*pX;
651 G4double a = 4.*(sumE*sumE - pX*pX);
652 G4double b = -4.*B*pX;
653 G4double c = 4.*sumE*sumE*rM*rM - B*B;
654 det2 = b*b-4.*a*c;
655 if(det2 > 0.) det = sqrt(det2);
656 G4double dP = 0.5*(-b - det )/a;
657
658 // dP = FinalMomentum( mI, rM, fMr, lvP);
659 dP = FinalMomentum( rM, rM, fMr, lvP); // 9-3-20
660
661 // G4cout<<dP<<", ";
662 pX -= dP;
663 if( pX < 0. ) pX = 0.;
664
665 eX = sqrt( dP*dP + fMr*fMr );
666 G4LorentzVector lvN( dP*dX, eX );
667
668 if( A >= 1 ) lvN.boost(bst); // 9-3-20 back to lab
669
670 fLVcpi = lvN;
671
673 G4DynamicParticle* dp2 = new G4DynamicParticle( pd2, lvN);
674 theParticleChange.AddSecondary( dp2, fSecID ); // coherent pion
675
676 // recoil nucleus
677
678 G4double eRecoil = sqrt( rM*rM + pX*pX );
679 G4ThreeVector vRecoil(pX*dX);
680 G4LorentzVector lvTarg1( vRecoil, eRecoil);
681 lvTarg1.boost(bst);
682
683 const G4LorentzVector lvTarg = lvTarg1;
684
685 if( A > 1 ) // recoil target nucleus*
686 {
688 G4double exE = fLVt.m() - grM;
689
690 if( exE < 5.*MeV ) exE = 5.*MeV + G4UniformRand()*10.*MeV; // vmg???
691
692 const G4LorentzVector in4v( G4ThreeVector( 0., 0., 0.), grM );
693 G4Fragment fragment( A, Z, in4v); // lvTarg );
694 fragment.SetNumberOfHoles(1);
695 fragment.SetExcEnergyAndMomentum( exE, lvTarg );
696
697 RecoilDeexcitation(fragment);
698 }
699 else // recoil target proton
700 {
701 G4double eTkin = eRecoil - rM;
702 G4double eTh = 0.01*MeV; // 10.*MeV;
703
704 if( eTkin > eTh )
705 {
708 }
710 }
711 return;
712}
G4double B(G4double temperature)
HepLorentzVector & boost(double, double, double)
void SetLocalEnergyDeposit(G4double aE)
G4double FinalMomentum(G4double mI, G4double mF, G4double mP, G4LorentzVector lvX)
void RecoilDeexcitation(G4Fragment &fragment)
static G4double GetNuclearMass(const G4double A, const G4double Z)
static G4Proton * Proton()
Definition: G4Proton.cc:92

References A, G4HadFinalState::AddSecondary(), G4Nucleus::AtomicMass(), B(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), anonymous_namespace{G4ChipsKaonMinusInelasticXS.cc}::dP, CLHEP::HepLorentzVector::e(), G4NeutrinoNucleusModel::FinalMomentum(), G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fLVcpi, G4NeutrinoNucleusModel::fLVt, G4NeutrinoNucleusModel::fMr, G4NeutrinoNucleusModel::fSecID, G4UniformRand, G4Nucleus::GetA_asInt(), G4NucleiProperties::GetNuclearMass(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4Nucleus::GetZ_asInt(), CLHEP::HepLorentzVector::m(), MeV, G4Proton::Proton(), G4NeutrinoNucleusModel::RecoilDeexcitation(), G4Fragment::SetExcEnergyAndMomentum(), G4HadFinalState::SetLocalEnergyDeposit(), G4Fragment::SetNumberOfHoles(), G4HadronicInteraction::theParticleChange, CLHEP::HepLorentzVector::vect(), and Z.

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), and G4NuMuNucleusNcModel::ApplyYourself().

◆ 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().

◆ FermiMomentum()

G4double G4NeutrinoNucleusModel::FermiMomentum ( G4Nucleus targetNucleus)
inherited

Definition at line 1057 of file G4NeutrinoNucleusModel.cc.

1058{
1059 G4int Z = targetNucleus.GetZ_asInt();
1060 G4int A = targetNucleus.GetA_asInt();
1061
1062 G4double kF(250.*MeV);
1063 G4double kp = 365.*MeV;
1064 G4double kn = 231.*MeV;
1065 G4double t1 = 0.479;
1066 G4double t2 = 0.526;
1067 G4double ZpA = G4double(Z)/G4double(A);
1068 G4double NpA = 1. - ZpA;
1069
1070 if ( Z == 1 && A == 1 ) { kF = 0.; } // hydrogen ???
1071 else if ( Z == 1 && A == 2 ) { kF = 87.*MeV; }
1072 else if ( Z == 2 && A == 3 ) { kF = 134.*MeV; }
1073 else if ( Z == 6 && A == 12 ) { kF = 221.*MeV; }
1074 else if ( Z == 14 && A == 28 ) { kF = 239.*MeV; }
1075 else if ( Z == 26 && A == 56 ) { kF = 257.*MeV; }
1076 else if ( Z == 82 && A == 208 ) { kF = 265.*MeV; }
1077 else
1078 {
1079 kF = kp*ZpA*( 1 - pow( G4double(A), -t1 ) ) + kn*NpA*( 1 - pow( G4double(A), -t2 ) );
1080 }
1081 return kF;
1082}

References A, G4Nucleus::GetA_asInt(), G4Nucleus::GetZ_asInt(), MeV, and Z.

Referenced by G4NeutrinoNucleusModel::GgSampleNM(), and G4NeutrinoNucleusModel::NucleonMomentum().

◆ FinalBarion()

void G4NeutrinoNucleusModel::FinalBarion ( G4LorentzVector lvB,
G4int  qB,
G4int  pdgB 
)
inherited

Definition at line 449 of file G4NeutrinoNucleusModel.cc.

450{
451 G4int A(0), Z(0), pdg = pdgB;
452 // G4bool FiNucleon(false);
453
454 // if ( qB == 1 ) pdg = pdgB - 10;
455 // else if ( qB == 0 ) pdg = pdgB - 110;
456 // else if ( qB == -1 ) pdg = pdgB - 1110;
457
458 if( pdg == 2212 || pdg == 2112)
459 {
461 // FiNucleon = true;
462 }
463 else fMr = lvB.m();
464
466 lvB.boost(-bst); // in fLVt rest system
467
468 G4double eX = lvB.e();
469 G4double det(0.), det2(0.), rM(0.), mX = lvB.m();
470 G4ThreeVector dX = (lvB.vect()).unit();
471 G4double pX = sqrt(eX*eX-mX*mX);
472
473 if( fRecoil )
474 {
475 Z = fRecoil->GetZ_asInt();
476 A = fRecoil->GetA_asInt();
477 rM = fRecoil->AtomicMass(A,Z); //->AtomicMass(); //
478 rM = fLVt.m();
479 }
480 else // A=0 nu+p
481 {
482 A = 0;
483 Z = 1;
484 rM = electron_mass_c2;
485 }
486 // G4cout<<A<<", ";
487
488 G4double sumE = eX + rM;
489 G4double B = sumE*sumE + rM*rM - fMr*fMr - pX*pX;
490 G4double a = 4.*(sumE*sumE - pX*pX);
491 G4double b = -4.*B*pX;
492 G4double c = 4.*sumE*sumE*rM*rM - B*B;
493 det2 = b*b-4.*a*c;
494 if( det2 <= 0. ) det = 0.;
495 else det = sqrt(det2);
496 G4double dP = 0.5*(-b - det )/a;
497
498 fDp = dP;
499
500 pX -= dP;
501
502 if(pX < 0.) pX = 0.;
503
504 // if( A == 0 ) G4cout<<pX/MeV<<", ";
505
506 eX = sqrt( pX*pX + fMr*fMr );
507 G4LorentzVector lvN( pX*dX, eX );
508 lvN.boost(bst); // back to lab
509
510 if( pdg == 2212 || pdg == 2112) // nucleons mX >= fMr, dP >= 0
511 {
513 G4DynamicParticle* dp2 = new G4DynamicParticle( pd2, lvN);
515
516 }
517 else // delta resonances
518 {
520 G4KineticTrack ddkt( rePart, 0., G4ThreeVector( 0., 0., 0.), lvN);
521 G4KineticTrackVector* ddktv = ddkt.Decay();
522
524
525 for( unsigned int i = 0; i < ddktv->size(); i++ ) // add products to partchange
526 {
527 G4DynamicParticle * aNew =
528 new G4DynamicParticle( ddktv->operator[](i)->GetDefinition(),
529 ddktv->operator[](i)->Get4Momentum() );
530
531 // G4cout<<" "<<i<<", "<<aNew->GetDefinition()->GetParticleName()<<", "<<aNew->Get4Momentum()<<G4endl;
532
534 delete ddktv->operator[](i);
535 }
536 delete ddktv;
537 }
538 // recoil nucleus
539
540 G4double eRecoil = sqrt( rM*rM + dP*dP );
541 fTr = eRecoil - rM;
542 G4ThreeVector vRecoil(dP*dX);
543 // dP += G4UniformRand()*10.*MeV;
544 G4LorentzVector rec4v(vRecoil, 0.);
545 rec4v.boost(bst); // back to lab
546 fLVt += rec4v;
547 const G4LorentzVector lvTarg = fLVt; // (vRecoil, eRecoil);
548
549
550 if( fRecoil ) // proton*?
551 {
553 G4double exE = fLVt.m() - grM;
554 if( exE < 5.*MeV ) exE = 5.*MeV + G4UniformRand()*10.*MeV;
555
556 const G4LorentzVector in4v( G4ThreeVector( 0., 0., 0.), grM );
557 G4Fragment fragment( A, Z, in4v); // lvTarg );
558 fragment.SetNumberOfHoles(1);
559 fragment.SetExcEnergyAndMomentum( exE, lvTarg );
560
561 RecoilDeexcitation(fragment);
562 }
563 else // momentum?
564 {
566 }
567}
ParticleList decay(Cluster *const c)
Carries out a cluster decay.
float electron_mass_c2
Definition: hepunit.py:273

References A, G4HadFinalState::AddSecondary(), G4Nucleus::AtomicMass(), B(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4KineticTrack::Decay(), G4INCL::ClusterDecay::decay(), anonymous_namespace{G4ChipsKaonMinusInelasticXS.cc}::dP, CLHEP::HepLorentzVector::e(), source.hepunit::electron_mass_c2, G4NeutrinoNucleusModel::fDp, G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fLVt, G4NeutrinoNucleusModel::fMr, G4NeutrinoNucleusModel::fRecoil, G4NeutrinoNucleusModel::fSecID, G4NeutrinoNucleusModel::fTr, G4UniformRand, G4Nucleus::GetA_asInt(), G4NucleiProperties::GetNuclearMass(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4Nucleus::GetZ_asInt(), CLHEP::HepLorentzVector::m(), MeV, G4NeutrinoNucleusModel::RecoilDeexcitation(), G4Fragment::SetExcEnergyAndMomentum(), G4HadFinalState::SetLocalEnergyDeposit(), G4Fragment::SetNumberOfHoles(), G4HadronicInteraction::theParticleChange, CLHEP::HepLorentzVector::vect(), and Z.

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), and G4NeutrinoNucleusModel::ClusterDecay().

◆ FinalMeson()

void G4NeutrinoNucleusModel::FinalMeson ( G4LorentzVector lvM,
G4int  qM,
G4int  pdgM 
)
inherited

Definition at line 409 of file G4NeutrinoNucleusModel.cc.

410{
411 G4int pdg = pdgM;
412 // if ( qM == 0 ) pdg = pdgM - 100;
413 // else if ( qM == -1 ) pdg = -pdgM;
414
415 if( pdg == 211 || pdg == -211 || pdg == 111) // pions
416 {
418 G4DynamicParticle* dp2 = new G4DynamicParticle( pd2, lvM);
420 }
421 else // meson resonances
422 {
424 FindParticle(pdg);
425 G4KineticTrack ddkt( rePart, 0., G4ThreeVector(0.,0.,0.), lvM);
426 G4KineticTrackVector* ddktv = ddkt.Decay();
427
429
430 for( unsigned int i = 0; i < ddktv->size(); i++ ) // add products to partchange
431 {
432 G4DynamicParticle * aNew =
433 new G4DynamicParticle( ddktv->operator[](i)->GetDefinition(),
434 ddktv->operator[](i)->Get4Momentum());
435
436 // G4cout<<" "<<i<<", "<<aNew->GetDefinition()->GetParticleName()<<", "<<aNew->Get4Momentum()<<G4endl;
437
439 delete ddktv->operator[](i);
440 }
441 delete ddktv;
442 }
443}

References G4HadFinalState::AddSecondary(), G4KineticTrack::Decay(), G4INCL::ClusterDecay::decay(), G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fSecID, G4ParticleTable::GetParticleTable(), and G4HadronicInteraction::theParticleChange.

Referenced by G4NeutrinoNucleusModel::MesonDecay().

◆ FinalMomentum()

G4double G4NeutrinoNucleusModel::FinalMomentum ( G4double  mI,
G4double  mF,
G4double  mP,
G4LorentzVector  lvX 
)
inherited

Definition at line 1026 of file G4NeutrinoNucleusModel.cc.

1027{
1028 G4double result(0.), delta(0.);
1029 // G4double mI2 = mI*mI;
1030 G4double mF2 = mF*mF;
1031 G4double mP2 = mP*mP;
1032 G4double eX = lvX.e();
1033 // G4double mX = lvX.m();
1034 G4double pX = lvX.vect().mag();
1035 G4double pX2 = pX*pX;
1036 G4double sI = eX + mI;
1037 G4double sI2 = sI*sI;
1038 G4double B = sI2 - mF2 -pX2 + mP2;
1039 G4double B2 = B*B;
1040 G4double a = 4.*(sI2-pX2);
1041 G4double b = -4.*B*pX;
1042 G4double c = 4.*sI2*mP2 - B2;
1043 G4double delta2 = b*b -4.*a*c;
1044
1045 if( delta2 >= 0. ) delta = sqrt(delta2);
1046
1047 result = 0.5*(-b-delta)/a;
1048 // result = 0.5*(-b+delta)/a;
1049
1050 return result;
1051}
double mag() const

References B(), CLHEP::HepLorentzVector::e(), CLHEP::Hep3Vector::mag(), and CLHEP::HepLorentzVector::vect().

Referenced by G4NeutrinoNucleusModel::CoherentPion().

◆ GetCascade()

G4bool G4NeutrinoNucleusModel::GetCascade ( )
inlineinherited

Definition at line 107 of file G4NeutrinoNucleusModel.hh.

107{return fCascade;};

References G4NeutrinoNucleusModel::fCascade.

◆ GetCosTheta()

G4double G4NeutrinoNucleusModel::GetCosTheta ( )
inlineinherited

Definition at line 110 of file G4NeutrinoNucleusModel.hh.

110{return fCosTheta;};

References G4NeutrinoNucleusModel::fCosTheta.

◆ GetCutEnergy()

G4double G4NeutrinoNucleusModel::GetCutEnergy ( )
inlineinherited

Definition at line 99 of file G4NeutrinoNucleusModel.hh.

References G4NeutrinoNucleusModel::fCutEnergy.

◆ GetDp()

G4double G4NeutrinoNucleusModel::GetDp ( )
inlineinherited

Definition at line 118 of file G4NeutrinoNucleusModel.hh.

118{return fDp;};

References G4NeutrinoNucleusModel::fDp.

◆ GetEmu()

G4double G4NeutrinoNucleusModel::GetEmu ( )
inlineinherited

Definition at line 111 of file G4NeutrinoNucleusModel.hh.

111{return fEmu;};

References G4NeutrinoNucleusModel::fEmu.

◆ GetEnergyIndex()

G4int G4NeutrinoNucleusModel::GetEnergyIndex ( G4double  energy)
inherited

Definition at line 1213 of file G4NeutrinoNucleusModel.cc.

1214{
1215 G4int i, eIndex = 0;
1216
1217 for( i = 0; i < fIndex; i++)
1218 {
1219 if( energy <= fNuMuEnergy[i]*GeV )
1220 {
1221 eIndex = i;
1222 break;
1223 }
1224 }
1225 if( i >= fIndex ) eIndex = fIndex;
1226 // G4cout<<"eIndex = "<<eIndex<<G4endl;
1227 return eIndex;
1228}
static const G4double fNuMuEnergy[50]

References G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fIndex, G4NeutrinoNucleusModel::fNuMuEnergy, and GeV.

◆ GetEnergyMomentumCheckLevels()

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

◆ GetEx() [1/2]

G4double G4NeutrinoNucleusModel::GetEx ( )
inlineinherited

◆ GetEx() [2/2]

G4double G4NeutrinoNucleusModel::GetEx ( G4int  A,
G4bool  fP 
)
inherited

Definition at line 1115 of file G4NeutrinoNucleusModel.cc.

1116{
1117 G4double eX(10.*MeV), a1(0.), a2(0.), e1(0.), e2(0.), aa = G4double(A);
1118 G4int i(0);
1119 const G4int maxBin = 12;
1120
1121 G4double refA[maxBin] = { 2., 6., 12., 16., 27., 28., 40., 50., 56., 58., 197., 208. };
1122
1123 G4double pEx[maxBin] = { 0., 12.2, 10.1, 10.9, 21.6, 12.4, 17.8, 17., 19., 16.8, 19.5, 14.7 };
1124
1125 G4double nEx[maxBin] = { 0., 12.2, 10., 10.2, 21.6, 12.4, 21.8, 17., 19., 16.8, 19.5, 16.9 };
1126
1127 G4DataVector dE(12,0.);
1128
1129 if(fP) for( i = 0; i < maxBin; ++i ) dE[i] = pEx[i];
1130 else dE[i] = nEx[i];
1131
1132 for( i = 0; i < maxBin; ++i )
1133 {
1134 if( aa <= refA[i] ) break;
1135 }
1136 if( i >= maxBin ) eX = dE[maxBin-1];
1137 else if( i <= 0 ) eX = dE[0];
1138 else
1139 {
1140 a1 = refA[i-1];
1141 a2 = refA[i];
1142 e1 = dE[i-1];
1143 e2 = dE[i];
1144 if (a1 == a2 || e1 == e2 ) eX = dE[i];
1145 else eX = e1 + (e2-e1)*(aa-a1)/(a2-a1);
1146 }
1147 return eX;
1148}
static const G4double e1[44]
static const G4double e2[44]
static const G4double dE

References A, dE, e1, e2, and MeV.

◆ 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().

◆ GetfBreak()

G4bool G4NeutrinoNucleusModel::GetfBreak ( )
inlineinherited

Definition at line 120 of file G4NeutrinoNucleusModel.hh.

120{return fBreak;};

References G4NeutrinoNucleusModel::fBreak.

◆ GetfCascade()

G4bool G4NeutrinoNucleusModel::GetfCascade ( )
inlineinherited

Definition at line 121 of file G4NeutrinoNucleusModel.hh.

121{return fCascade;};

References G4NeutrinoNucleusModel::fCascade.

◆ GetfString()

G4bool G4NeutrinoNucleusModel::GetfString ( )
inlineinherited

Definition at line 122 of file G4NeutrinoNucleusModel.hh.

122{return fString;};

References G4NeutrinoNucleusModel::fString.

◆ GetLVcpi()

G4LorentzVector G4NeutrinoNucleusModel::GetLVcpi ( )
inlineinherited

Definition at line 127 of file G4NeutrinoNucleusModel.hh.

127{return fLVcpi;};

References G4NeutrinoNucleusModel::fLVcpi.

◆ GetLVh()

G4LorentzVector G4NeutrinoNucleusModel::GetLVh ( )
inlineinherited

Definition at line 125 of file G4NeutrinoNucleusModel.hh.

125{return fLVh;};

References G4NeutrinoNucleusModel::fLVh.

◆ GetLVl()

G4LorentzVector G4NeutrinoNucleusModel::GetLVl ( )
inlineinherited

Definition at line 124 of file G4NeutrinoNucleusModel.hh.

124{return fLVl;};

References G4NeutrinoNucleusModel::fLVl.

◆ GetLVt()

G4LorentzVector G4NeutrinoNucleusModel::GetLVt ( )
inlineinherited

Definition at line 126 of file G4NeutrinoNucleusModel.hh.

126{return fLVt;};

References G4NeutrinoNucleusModel::fLVt.

◆ GetM1()

G4double G4NeutrinoNucleusModel::GetM1 ( )
inlineinherited

Definition at line 115 of file G4NeutrinoNucleusModel.hh.

115{return fM1;};

References G4NeutrinoNucleusModel::fM1.

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

◆ GetMinNuMuEnergy()

G4double G4ANuMuNucleusCcModel::GetMinNuMuEnergy ( )
inline

Definition at line 76 of file G4ANuMuNucleusCcModel.hh.

76{ return fMu + 0.5*fMu*fMu/fM1 + 4.*CLHEP::MeV; }; // kinematics + accuracy for sqrts
static constexpr double MeV

References G4NeutrinoNucleusModel::fM1, G4NeutrinoNucleusModel::fMu, and CLHEP::MeV.

◆ 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().

◆ GetMr()

G4double G4NeutrinoNucleusModel::GetMr ( )
inlineinherited

Definition at line 116 of file G4NeutrinoNucleusModel.hh.

116{return fMr;};

References G4NeutrinoNucleusModel::fMr.

◆ GetMuMass()

G4double G4NeutrinoNucleusModel::GetMuMass ( )
inlineinherited

Definition at line 113 of file G4NeutrinoNucleusModel.hh.

113{return fMu;};

References G4NeutrinoNucleusModel::fMu.

◆ GetNuEnergy()

G4double G4NeutrinoNucleusModel::GetNuEnergy ( )
inlineinherited

Definition at line 101 of file G4NeutrinoNucleusModel.hh.

References G4NeutrinoNucleusModel::fNuEnergy.

◆ GetNuMuOnePionProb()

G4double G4NeutrinoNucleusModel::GetNuMuOnePionProb ( G4int  index,
G4double  energy 
)
inherited

Definition at line 1314 of file G4NeutrinoNucleusModel.cc.

1315{
1316 G4double ratio(0.);
1317
1318 if( index <= 0 || energy < fOnePionEnergy[0] ) ratio = 0.;
1320 else
1321 {
1322 G4double x1 = fOnePionEnergy[index-1]*GeV;
1323 G4double x2 = fOnePionEnergy[index]*GeV;
1324 G4double y1 = fOnePionProb[index-1];
1325 G4double y2 = fOnePionProb[index];
1326
1327 if( x1 >= x2) return fOnePionProb[index];
1328 else
1329 {
1330 G4double angle = (y2-y1)/(x2-x1);
1331 ratio = y1 + (energy-x1)*angle;
1332 }
1333 }
1334 return ratio;
1335}
static const G4double angle[DIMMOTT]
static const G4double fOnePionProb[58]
static const G4double fOnePionEnergy[58]

References angle, G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fOnePionEnergy, G4NeutrinoNucleusModel::fOnePionIndex, G4NeutrinoNucleusModel::fOnePionProb, and GeV.

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), and G4NuMuNucleusNcModel::ApplyYourself().

◆ GetNuMuQeTotRat()

G4double G4NeutrinoNucleusModel::GetNuMuQeTotRat ( G4int  index,
G4double  energy 
)
inherited

Definition at line 1234 of file G4NeutrinoNucleusModel.cc.

1235{
1236 G4double ratio(0.);
1237 // GetMinNuMuEnergy()
1238 if( index <= 0 || energy < fNuMuEnergy[0] ) ratio = 0.;
1239 else if (index >= fIndex) ratio = fNuMuQeTotRat[fIndex-1]*fOnePionEnergy[fIndex-1]*GeV/energy;
1240 else
1241 {
1242 G4double x1 = fNuMuEnergy[index-1]*GeV;
1243 G4double x2 = fNuMuEnergy[index]*GeV;
1244 G4double y1 = fNuMuQeTotRat[index-1];
1245 G4double y2 = fNuMuQeTotRat[index];
1246
1247 if(x1 >= x2) return fNuMuQeTotRat[index];
1248 else
1249 {
1250 G4double angle = (y2-y1)/(x2-x1);
1251 ratio = y1 + (energy-x1)*angle;
1252 }
1253 }
1254 return ratio;
1255}
static const G4double fNuMuQeTotRat[50]

References angle, G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fIndex, G4NeutrinoNucleusModel::fNuMuEnergy, G4NeutrinoNucleusModel::fNuMuQeTotRat, G4NeutrinoNucleusModel::fOnePionEnergy, and GeV.

◆ GetOnePionIndex()

G4int G4NeutrinoNucleusModel::GetOnePionIndex ( G4double  energy)
inherited

Definition at line 1293 of file G4NeutrinoNucleusModel.cc.

1294{
1295 G4int i, eIndex = 0;
1296
1297 for( i = 0; i < fOnePionIndex; i++)
1298 {
1299 if( energy <= fOnePionEnergy[i]*GeV )
1300 {
1301 eIndex = i;
1302 break;
1303 }
1304 }
1305 if( i >= fOnePionIndex ) eIndex = fOnePionIndex;
1306 // G4cout<<"eIndex = "<<eIndex<<G4endl;
1307 return eIndex;
1308}

References G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fOnePionEnergy, G4NeutrinoNucleusModel::fOnePionIndex, and GeV.

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), and G4NuMuNucleusNcModel::ApplyYourself().

◆ GetPDGencoding()

G4int G4NeutrinoNucleusModel::GetPDGencoding ( )
inlineinherited

Definition at line 106 of file G4NeutrinoNucleusModel.hh.

106{return fPDGencoding;};

References G4NeutrinoNucleusModel::fPDGencoding.

◆ GetQ2()

G4double G4NeutrinoNucleusModel::GetQ2 ( )
inlineinherited

Definition at line 103 of file G4NeutrinoNucleusModel.hh.

103{return fQ2;};

References G4NeutrinoNucleusModel::fQ2.

◆ GetQEratioA()

G4double G4NeutrinoNucleusModel::GetQEratioA ( )
inlineinherited

Definition at line 136 of file G4NeutrinoNucleusModel.hh.

136{ return fQEratioA; };

References G4NeutrinoNucleusModel::fQEratioA.

◆ GetQkr()

G4double G4NeutrinoNucleusModel::GetQkr ( G4int  iE,
G4int  jX,
G4double  prob 
)
inherited

Definition at line 366 of file G4NeutrinoNucleusModel.cc.

367{
368 G4int i(0), nBin=50;
369 G4double qq(0.);
370
371 for( i = 0; i < nBin; ++i )
372 {
373 if( prob <= fNuMuQdistrKR[iE][jX][i] )
374 break;
375 }
376 if(i <= 0 ) // Q-edge
377 {
378 fQindex = 0;
379 qq = fNuMuQarrayKR[iE][jX][0];
380 }
381 if ( i >= nBin )
382 {
383 fQindex = nBin;
384 qq = fNuMuQarrayKR[iE][jX][nBin];
385 }
386 else
387 {
388 fQindex = i;
389 G4double q1 = fNuMuQarrayKR[iE][jX][i];
390 G4double q2 = fNuMuQarrayKR[iE][jX][i+1];
391
392 G4double p1 = 0.;
393
394 if( i > 0 ) p1 = fNuMuQdistrKR[iE][jX][i-1];
395
396 G4double p2 = fNuMuQdistrKR[iE][jX][i];
397
398 if( p2 <= p1 ) qq = q1 + G4UniformRand()*(q2-q1);
399 else qq = q1 + (prob-p1)*(q2-q1)/(p2-p1);
400 }
401 return qq;
402}
static G4double fNuMuQarrayKR[50][51][51]
static G4double fNuMuQdistrKR[50][51][50]

References G4NeutrinoNucleusModel::fNuMuQarrayKR, G4NeutrinoNucleusModel::fNuMuQdistrKR, G4NeutrinoNucleusModel::fQindex, and G4UniformRand.

Referenced by G4NeutrinoNucleusModel::SampleQkr().

◆ GetQtransfer()

G4double G4NeutrinoNucleusModel::GetQtransfer ( )
inlineinherited

Definition at line 102 of file G4NeutrinoNucleusModel.hh.

References G4NeutrinoNucleusModel::fQtransfer.

◆ GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const
inlineinherited

◆ GetString()

G4bool G4NeutrinoNucleusModel::GetString ( )
inlineinherited

Definition at line 108 of file G4NeutrinoNucleusModel.hh.

108{return fString;};

References G4NeutrinoNucleusModel::fString.

◆ GetTr()

G4double G4NeutrinoNucleusModel::GetTr ( )
inlineinherited

Definition at line 117 of file G4NeutrinoNucleusModel.hh.

117{return fTr;};

References G4NeutrinoNucleusModel::fTr.

◆ GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const
inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

References G4HadronicInteraction::verboseLevel.

◆ GetW2()

G4double G4NeutrinoNucleusModel::GetW2 ( )
inlineinherited

Definition at line 114 of file G4NeutrinoNucleusModel.hh.

114{return fW2;};

References G4NeutrinoNucleusModel::fW2.

◆ GetXkr()

G4double G4NeutrinoNucleusModel::GetXkr ( G4int  iEnergy,
G4double  prob 
)
inherited

Definition at line 264 of file G4NeutrinoNucleusModel.cc.

265{
266 G4int i(0), nBin=50;
267 G4double xx(0.);
268
269 for( i = 0; i < nBin; ++i )
270 {
271 if( prob <= fNuMuXdistrKR[iEnergy][i] )
272 break;
273 }
274 if(i <= 0 ) // X-edge
275 {
276 fXindex = 0;
277 xx = fNuMuXarrayKR[iEnergy][0];
278 }
279 if ( i >= nBin )
280 {
281 fXindex = nBin;
282 xx = fNuMuXarrayKR[iEnergy][nBin];
283 }
284 else
285 {
286 fXindex = i;
287 G4double x1 = fNuMuXarrayKR[iEnergy][i];
288 G4double x2 = fNuMuXarrayKR[iEnergy][i+1];
289
290 G4double p1 = 0.;
291
292 if( i > 0 ) p1 = fNuMuXdistrKR[iEnergy][i-1];
293
294 G4double p2 = fNuMuXdistrKR[iEnergy][i];
295
296 if( p2 <= p1 ) xx = x1 + G4UniformRand()*(x2-x1);
297 else xx = x1 + (prob-p1)*(x2-x1)/(p2-p1);
298 }
299 return xx;
300}
static G4double fNuMuXarrayKR[50][51]
static G4double fNuMuXdistrKR[50][50]

References G4NeutrinoNucleusModel::fNuMuXarrayKR, G4NeutrinoNucleusModel::fNuMuXdistrKR, G4NeutrinoNucleusModel::fXindex, and G4UniformRand.

Referenced by G4NeutrinoNucleusModel::SampleXkr().

◆ GetXsample()

G4double G4NeutrinoNucleusModel::GetXsample ( )
inlineinherited

Definition at line 104 of file G4NeutrinoNucleusModel.hh.

104{return fXsample;};

References G4NeutrinoNucleusModel::fXsample.

◆ GgSampleNM()

G4double G4NeutrinoNucleusModel::GgSampleNM ( G4Nucleus nucl)
inherited

Definition at line 1156 of file G4NeutrinoNucleusModel.cc.

1157{
1158 f2p2h = false;
1159 G4double /* distr(0.), tail(0.), */ shift(1.), xx(1.), mom(0.), th(0.1);
1160 G4double kF = FermiMomentum( nucl);
1161 G4double momMax = 2.*kF; // 1.*GeV; // 1.*GeV; //
1162 G4double aa = 5.5;
1163 G4double ll = 6.0; // 6.5; //
1164
1165 G4int A = nucl.GetA_asInt();
1166
1167 if( A <= 12) th = 0.1;
1168 else
1169 {
1170 // th = 0.1/(1.+log(G4double(A)/12.));
1171 th = 1.2/( G4double(A) + 1.35*log(G4double(A)/12.) );
1172 }
1173 shift = 0.99; // 0.95; //
1174 xx = mom/shift/kF;
1175
1176 G4double rr = G4UniformRand();
1177
1178 if( rr > th )
1179 {
1180 aa = 5.5;
1181
1182 if( A <= 12 ) ll = 6.0;
1183 else
1184 {
1185 ll = 6.0 + 1.35*log(G4double(A)/12.);
1186 }
1187 xx = RandGamma::shoot(aa,ll);
1188 shift = 0.99;
1189 mom = xx*shift*kF;
1190 }
1191 else
1192 {
1193 f2p2h = true;
1194 aa = 6.5;
1195 ll = 6.5;
1196 xx = RandGamma::shoot(aa,ll);
1197 shift = 2.5;
1198 mom = xx*shift*kF;
1199 }
1200 if( mom > momMax ) mom = G4UniformRand()*momMax;
1201 if( mom > 2.*kF ) f2p2h = true;
1202
1203 // mom = 0.;
1204
1205 return mom;
1206}
G4double FermiMomentum(G4Nucleus &targetNucleus)
ThreeVector shoot(const G4int Ap, const G4int Af)

References A, G4NeutrinoNucleusModel::f2p2h, G4NeutrinoNucleusModel::FermiMomentum(), G4UniformRand, G4Nucleus::GetA_asInt(), and G4INCL::DeJongSpin::shoot().

Referenced by G4ANuElNucleusCcModel::SampleLVkr(), SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), and G4NuMuNucleusCcModel::SampleLVkr().

◆ InitialiseModel()

void G4ANuMuNucleusCcModel::InitialiseModel ( )
virtual

Reimplemented from G4HadronicInteraction.

Definition at line 119 of file G4ANuMuNucleusCcModel.cc.

120{
121 G4String pName = "anti_nu_mu";
122
123 G4int nSize(0), i(0), j(0), k(0);
124
125 if(!fData)
126 {
127#ifdef G4MULTITHREADED
128 G4MUTEXLOCK(&numuNucleusModel);
129 if(!fData)
130 {
131#endif
132 fMaster = true;
133#ifdef G4MULTITHREADED
134 }
135 G4MUTEXUNLOCK(&numuNucleusModel);
136#endif
137 }
138
139 if(fMaster)
140 {
141 char* path = getenv("G4PARTICLEXSDATA");
142 std::ostringstream ost1, ost2, ost3, ost4;
143 ost1 << path << "/" << "neutrino" << "/" << pName << "/xarraycckr";
144
145 std::ifstream filein1( ost1.str().c_str() );
146
147 // filein.open("$PARTICLEXSDATA/");
148
149 filein1>>nSize;
150
151 for( k = 0; k < fNbin; ++k )
152 {
153 for( i = 0; i <= fNbin; ++i )
154 {
155 filein1 >> fNuMuXarrayKR[k][i];
156 // G4cout<< fNuMuXarrayKR[k][i] << " ";
157 }
158 }
159 // G4cout<<G4endl<<G4endl;
160
161 ost2 << path << "/" << "neutrino" << "/" << pName << "/xdistrcckr";
162 std::ifstream filein2( ost2.str().c_str() );
163
164 filein2>>nSize;
165
166 for( k = 0; k < fNbin; ++k )
167 {
168 for( i = 0; i < fNbin; ++i )
169 {
170 filein2 >> fNuMuXdistrKR[k][i];
171 // G4cout<< fNuMuXdistrKR[k][i] << " ";
172 }
173 }
174 // G4cout<<G4endl<<G4endl;
175
176 ost3 << path << "/" << "neutrino" << "/" << pName << "/q2arraycckr";
177 std::ifstream filein3( ost3.str().c_str() );
178
179 filein3>>nSize;
180
181 for( k = 0; k < fNbin; ++k )
182 {
183 for( i = 0; i <= fNbin; ++i )
184 {
185 for( j = 0; j <= fNbin; ++j )
186 {
187 filein3 >> fNuMuQarrayKR[k][i][j];
188 // G4cout<< fNuMuQarrayKR[k][i][j] << " ";
189 }
190 }
191 }
192 // G4cout<<G4endl<<G4endl;
193
194 ost4 << path << "/" << "neutrino" << "/" << pName << "/q2distrcckr";
195 std::ifstream filein4( ost4.str().c_str() );
196
197 filein4>>nSize;
198
199 for( k = 0; k < fNbin; ++k )
200 {
201 for( i = 0; i <= fNbin; ++i )
202 {
203 for( j = 0; j < fNbin; ++j )
204 {
205 filein4 >> fNuMuQdistrKR[k][i][j];
206 // G4cout<< fNuMuQdistrKR[k][i][j] << " ";
207 }
208 }
209 }
210 fData = true;
211 }
212}
#define G4MUTEXLOCK(mutex)
Definition: G4Threading.hh:251
#define G4MUTEXUNLOCK(mutex)
Definition: G4Threading.hh:254

References fData, fMaster, G4NeutrinoNucleusModel::fNbin, G4NeutrinoNucleusModel::fNuMuQarrayKR, G4NeutrinoNucleusModel::fNuMuQdistrKR, G4NeutrinoNucleusModel::fNuMuXarrayKR, G4NeutrinoNucleusModel::fNuMuXdistrKR, G4MUTEXLOCK, and G4MUTEXUNLOCK.

Referenced by G4ANuMuNucleusCcModel().

◆ IsApplicable()

G4bool G4ANuMuNucleusCcModel::IsApplicable ( const G4HadProjectile aTrack,
G4Nucleus targetNucleus 
)
virtual

Reimplemented from G4NeutrinoNucleusModel.

Definition at line 216 of file G4ANuMuNucleusCcModel.cc.

218{
219 G4bool result = false;
220 G4String pName = aPart.GetDefinition()->GetParticleName();
221 G4double energy = aPart.GetTotalEnergy();
222
223 if( pName == "anti_nu_mu"
224 &&
226 {
227 result = true;
228 }
229
230 return result;
231}

References G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fMinNuEnergy, G4HadProjectile::GetDefinition(), G4ParticleDefinition::GetParticleName(), and G4HadProjectile::GetTotalEnergy().

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

◆ MesonDecay()

void G4NeutrinoNucleusModel::MesonDecay ( G4LorentzVector lvX,
G4int  qX 
)
inherited

Definition at line 859 of file G4NeutrinoNucleusModel.cc.

860{
861 G4bool finB = false;
862 G4int pdgM(0), pdgB(0), i(0), qM(0), qB(0);
863 G4double mM(0.), mB(0.), eM(0.), eB(0.), pM(0.), pB(0.);
864 G4double mm1(0.), mm22(0.), M1(0.), M2(0.), mX(0.), Tkin(0.);
865
866 mX = lvX.m();
867 Tkin = lvX.e() - mX;
868
869 // if( mX < 1120*MeV && mX > 1020*MeV ) // phi(1020)->K+K-
870 if( mX < 1080*MeV && mX > 990*MeV && Tkin < 600*MeV ) // phi(1020)->K+K-
871 {
872 return FinalMeson( lvX, qB, 333);
873 }
875
876 G4double deltaMr[4] = { 0.*MeV, 0.*MeV, 100.*MeV, 0.*MeV};
877
878 G4ThreeVector dir(0.,0.,0.);
879 G4ThreeVector bst(0.,0.,0.);
880 G4LorentzVector lvM(0.,0.,0.,0.);
881 G4LorentzVector lvB(0.,0.,0.,0.);
882
883 for( i = 0; i < fClustNumber; ++i) // check resonance
884 {
885 if( mX >= fMesMass[i] )
886 {
887 pdgB = fMesPDG[i];
888 // mB = G4ParticleTable::GetParticleTable()->FindParticle(pdgB)->GetPDGMass();
889 break;
890 }
891 }
892 if( i == fClustNumber ) // || i == fClustNumber-1 ) // low mass, p || n
893 {
894 if ( qX == 1) { pdgB = 211; qB = 1;} // pi+
895 else if( qX == 0 ) { pdgB = 111; qB = 0;} // pi0
896 else if( qX == -1) { pdgB = -211; qB = -1;} // pi-
897
898 return FinalMeson( lvX, qB, pdgB);
899 }
900 else if( mX < fMesMass[i] + deltaMr[i] ) // || mX < mPi + mPi ) //
901 {
902 finB = true; // final barion -> out
903 pdgB = fMesPDG[i];
904
905 // if ( qX == 1 && pdgB != 2212) pdgB = pdgB - 10;
906
907 if( qX == 0 ) pdgB = pdgB - 100;
908 else if( qX == -1 ) pdgB = -pdgB;
909
910 if( finB ) return FinalMeson( lvX, qX, pdgB ); // out
911 }
912 // no resonance, try 1->2 decay in COM frame
913
914 // try meson
915
916 mm1 = mPi + 1.*MeV; // pi+
917 mm22 = mX - mPi - 1.*MeV; // mX-n
918
919 if( mm22 <= mm1 ) // out
920 {
921 if ( qX == 1) { pdgB = 211; qB = 1;} // pi+
922 else if( qX == 0 ) { pdgB = 111; qB = 0;} // pi0
923 else if( qX == -1) { pdgB = -211; qB = -1;} // pi-
924
925 return FinalMeson(lvX, qB, pdgB);
926 }
927 else // try decay -> pion + meson(cluster)
928 {
929 // G4double sigmaM = 50.*MeV; // 100.*MeV; // 200.*MeV; // 400.*MeV; // 800.*MeV; //
930 G4double rand = G4UniformRand();
931
932 if ( qX == 1 ) { qM = 1; qB = 0;}
933 else if( qX == 0 ) { qM = -1; qB = 1;} // { qM = 0; qB = 0;} //
934 else if( qX == -1 ) { qM = -1; qB = 0;}
935 /*
936 mM = mPi;
937 if(qM == 0) mM = G4ParticleTable::GetParticleTable()->FindParticle(111)->GetPDGMass(); //pi0
938 pdgM = fMesPDG[fClustNumber-1];
939 */
940 // mm1*mm22/( mm1 + rand*(mm22 - mm1) );
941 // mM = mm1*mm22/sqrt( mm1*mm1 + rand*(mm22*mm22 - mm1*mm1) );
942 // mM = -sigmaM*log( (1.- rand)*exp(-mm22/sigmaM) + rand*exp(-mm1/sigmaM) );
943 mM = mm1 + rand*(mm22-mm1);
944 // mM = mm1 + 0.9*(mm22-mm1);
945
946
947 for( i = 0; i < fClustNumber; ++i)
948 {
949 if( mM >= fMesMass[i] )
950 {
951 pdgM = fMesPDG[i];
952 // mM = G4ParticleTable::GetParticleTable()->FindParticle(pdgM)->GetPDGMass();
953 break;
954 }
955 }
956 if( i == fClustNumber || i == fClustNumber-1 ) // low mass, p || n
957 {
958 if ( qX == 1) { pdgB = 211; qB = 1;} // pi+
959 else if( qX == 0 ) { pdgB = 111; qB = 0;} // pi0
960 else if( qX == -1) { pdgB = -211; qB = -1;} // pi-
961
962 return FinalMeson( lvX, qB, pdgB);
963 }
964 else if( mX < fMesMass[i] + deltaMr[i] ) // || mX < mPi + mPi ) //
965 {
966 finB = true; // final barion -> out
967 pdgB = fMesPDG[i];
968
969 // if ( qX == 1 && pdgB != 2212) pdgB = pdgB - 10;
970
971 if( qX == 0 ) pdgB = pdgB - 100;
972 else if( qX == -1 ) pdgB = -pdgB;
973
974 if( finB ) return FinalMeson( lvX, qX, pdgB ); // out
975 }
976
978 M2 = mX - mM;
979
980 if( M2 <= M1 ) //
981 {
982 if ( qX == 1) { pdgB = 211; qB = 1;} // pi+
983 else if( qX == 0 ) { pdgB = 111; qB = 0;} // pi0
984 else if( qX == -1) { pdgB = -211; qB = -1;} // pi-
985
986 return FinalMeson(lvX, qB, pdgB);
987 }
988 mB = M1 + G4UniformRand()*(M2-M1);
989 // mB = -sigmaM*log( (1.- rand)*exp(-M2/sigmaM) + rand*exp(-M1/sigmaM) );
990 // mB = M1 + 0.9*(M2-M1);
991
992 bst = lvX.boostVector();
993
994 // dir = G4RandomDirection();
995 dir = bst.orthogonal().unit();
996
997 eM = 0.5*(mX*mX + mM*mM - mB*mB)/mX;
998 pM = sqrt(eM*eM - mM*mM);
999 lvM = G4LorentzVector( pM*dir, eM);
1000 lvM.boost(bst);
1001
1002 eB = 0.5*(mX*mX + mB*mB - mM*mM)/mX;
1003 pB = sqrt(eB*eB - mB*mB);
1004 lvB = G4LorentzVector(-pB*dir, eB);
1005 lvB.boost(bst);
1006
1007 // G4cout<<mM<<"/"<<mB<<", ";
1008
1009 // charge exchange
1010
1011 // if ( qX == 2 ) { qM = 1; qB = 1;}
1012
1013 if ( qM == 0 ) pdgM = pdgM - 100;
1014 else if( qM == -1 ) pdgM = -pdgM;
1015
1016 MesonDecay( lvM, qM ); //
1017
1018 MesonDecay( lvB, qB ); // continue
1019 }
1020}
static const G4int fMesPDG[4]
void FinalMeson(G4LorentzVector &lvM, G4int qM, G4int pdgM)

References CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), CLHEP::HepLorentzVector::e(), G4NeutrinoNucleusModel::fClustNumber, G4NeutrinoNucleusModel::FinalMeson(), G4ParticleTable::FindParticle(), G4NeutrinoNucleusModel::fMesMass, G4NeutrinoNucleusModel::fMesPDG, G4UniformRand, G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), CLHEP::HepLorentzVector::m(), G4NeutrinoNucleusModel::MesonDecay(), MeV, CLHEP::Hep3Vector::orthogonal(), anonymous_namespace{G4ChipsKaonPlusInelasticXS.cc}::pM, and CLHEP::Hep3Vector::unit().

Referenced by G4NeutrinoNucleusModel::ClusterDecay(), and G4NeutrinoNucleusModel::MesonDecay().

◆ ModelDescription()

void G4ANuMuNucleusCcModel::ModelDescription ( std::ostream &  outFile) const
virtual

Reimplemented from G4NeutrinoNucleusModel.

Definition at line 106 of file G4ANuMuNucleusCcModel.cc.

107{
108
109 outFile << "G4ANuMuNucleusCcModel is a neutrino-nucleus (charge current) scattering\n"
110 << "model which uses the standard model \n"
111 << "transfer parameterization. The model is fully relativistic\n";
112
113}

◆ NucleonMomentum()

G4double G4NeutrinoNucleusModel::NucleonMomentum ( G4Nucleus targetNucleus)
inherited

Definition at line 1088 of file G4NeutrinoNucleusModel.cc.

1089{
1090 G4int A = targetNucleus.GetA_asInt();
1091 G4double kF = FermiMomentum( targetNucleus);
1092 G4double mom(0.), kCut = 0.5*GeV; // kCut = 1.*GeV; // kCut = 2.*GeV; // kCut = 4.*GeV; //
1093 // G4double cof = 2./GeV;
1094 // G4double ksi = kF*kF*cof*cof/pi/pi;
1095 G4double th = 1.; // 1. - 6.*ksi; //
1096
1097 if( G4UniformRand() < th || A < 3 ) // 1p1h
1098 {
1099 mom = kF*pow( G4UniformRand(), 1./3.);
1100 }
1101 else // 2p2h
1102 {
1103 mom = kF*kCut;
1104 mom /= kCut - G4UniformRand()*(kCut - kF);
1105 f2p2h = true;
1106 }
1107 return mom;
1108}

References A, G4NeutrinoNucleusModel::f2p2h, G4NeutrinoNucleusModel::FermiMomentum(), G4UniformRand, G4Nucleus::GetA_asInt(), and GeV.

Referenced by G4ANuElNucleusNcModel::SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), and G4NuMuNucleusNcModel::SampleLVkr().

◆ operator!=()

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

◆ operator==()

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

◆ RecoilDeexcitation()

void G4NeutrinoNucleusModel::RecoilDeexcitation ( G4Fragment fragment)
inherited

Definition at line 574 of file G4NeutrinoNucleusModel.cc.

575{
576 G4ReactionProductVector* products = fPreCompound->DeExcite(fragment);
577
578 if( products != nullptr )
579 {
580 for( auto & prod : *products ) // prod is the pointer to final hadronic particle
581 {
582 theParticleChange.AddSecondary(new G4DynamicParticle( prod->GetDefinition(),
583 prod->GetTotalEnergy(),
584 prod->GetMomentum() ), fSecID );
585 delete prod;
586 }
587 delete products;
588 }
589}
std::vector< G4ReactionProduct * > G4ReactionProductVector
G4PreCompoundModel * fPreCompound
virtual G4ReactionProductVector * DeExcite(G4Fragment &aFragment) final

References G4HadFinalState::AddSecondary(), G4PreCompoundModel::DeExcite(), G4NeutrinoNucleusModel::fPreCompound, G4NeutrinoNucleusModel::fSecID, and G4HadronicInteraction::theParticleChange.

Referenced by G4NeutrinoNucleusModel::CoherentPion(), and G4NeutrinoNucleusModel::FinalBarion().

◆ SampleInvariantT()

G4double G4HadronicInteraction::SampleInvariantT ( const G4ParticleDefinition p,
G4double  plab,
G4int  Z,
G4int  A 
)
virtualinherited

◆ SampleLVkr()

void G4ANuMuNucleusCcModel::SampleLVkr ( const G4HadProjectile aTrack,
G4Nucleus targetNucleus 
)

Definition at line 528 of file G4ANuMuNucleusCcModel.cc.

529{
530 fBreak = false;
531 G4int A = targetNucleus.GetA_asInt(), iTer(0), iTerMax(100);
532 G4int Z = targetNucleus.GetZ_asInt();
533 G4double e3(0.), pMu2(0.), pX2(0.), nMom(0.), rM(0.), hM(0.), tM = targetNucleus.AtomicMass(A,Z);
534 G4double Ex(0.), ei(0.), nm2(0.);
535 G4double cost(1.), sint(0.), phi(0.), muMom(0.);
536 G4ThreeVector eP, bst;
537 const G4HadProjectile* aParticle = &aTrack;
538 G4LorentzVector lvp1 = aParticle->Get4Momentum();
539
540 if( A == 1 ) // hydrogen, no Fermi motion ???
541 {
542 fNuEnergy = aParticle->GetTotalEnergy();
543 iTer = 0;
544
545 do
546 {
550
551 if( fXsample > 0. )
552 {
553 fW2 = fM1*fM1 - fQ2 + fQ2/fXsample; // sample excited hadron mass
555 }
556 else
557 {
558 fW2 = fM1*fM1;
559 fEmu = fNuEnergy;
560 }
561 e3 = fNuEnergy + fM1 - fEmu;
562
563 if( e3 < sqrt(fW2) ) G4cout<<"energyX = "<<e3/GeV<<", fW = "<<sqrt(fW2)/GeV<<G4endl;
564
565 pMu2 = fEmu*fEmu - fMu*fMu;
566
567 if(pMu2 < 0.) { fBreak = true; return; }
568
569 pX2 = e3*e3 - fW2;
570
571 fCosTheta = fNuEnergy*fNuEnergy + pMu2 - pX2;
572 fCosTheta /= 2.*fNuEnergy*sqrt(pMu2);
573 iTer++;
574 }
575 while( ( abs(fCosTheta) > 1. || fEmu < fMu ) && iTer < iTerMax );
576
577 if( iTer >= iTerMax ) { fBreak = true; return; }
578
579 if( abs(fCosTheta) > 1.) // vmg: due to big Q2/x values. To be improved ...
580 {
581 G4cout<<"H2: fCosTheta = "<<fCosTheta<<", fEmu = "<<fEmu<<G4endl;
582 // fCosTheta = -1. + 2.*G4UniformRand();
583 if(fCosTheta < -1.) fCosTheta = -1.;
584 if(fCosTheta > 1.) fCosTheta = 1.;
585 }
586 // LVs
587
588 G4LorentzVector lvt1 = G4LorentzVector( 0., 0., 0., fM1 );
589 G4LorentzVector lvsum = lvp1 + lvt1;
590
591 cost = fCosTheta;
592 sint = std::sqrt( (1.0 - cost)*(1.0 + cost) );
594 eP = G4ThreeVector( sint*std::cos(phi), sint*std::sin(phi), cost );
595 muMom = sqrt(fEmu*fEmu-fMu*fMu);
596 eP *= muMom;
597 fLVl = G4LorentzVector( eP, fEmu );
598
599 fLVh = lvsum - fLVl;
600 fLVt = G4LorentzVector( 0., 0., 0., 0. ); // no recoil
601 }
602 else // Fermi motion, Q2 in nucleon rest frame
603 {
604 G4Nucleus recoil1( A-1, Z );
605 rM = recoil1.AtomicMass(A-1,Z);
606 do
607 {
608 // nMom = NucleonMomentumBR( targetNucleus ); // BR
609 nMom = GgSampleNM( targetNucleus ); // Gg
610 Ex = GetEx(A-1, fProton);
611 ei = tM - sqrt( (rM + Ex)*(rM + Ex) + nMom*nMom );
612 // ei = 0.5*( tM - s2M - 2*eX );
613
614 nm2 = ei*ei - nMom*nMom;
615 iTer++;
616 }
617 while( nm2 < 0. && iTer < iTerMax );
618
619 if( iTer >= iTerMax ) { fBreak = true; return; }
620
621 G4ThreeVector nMomDir = nMom*G4RandomDirection();
622
623 if( !f2p2h || A < 3 ) // 1p1h
624 {
625 // hM = tM - rM;
626
627 fLVt = G4LorentzVector( -nMomDir, sqrt( (rM + Ex)*(rM + Ex) + nMom*nMom ) ); // rM ); //
628 fLVh = G4LorentzVector( nMomDir, ei ); // hM); //
629 }
630 else // 2p2h
631 {
632 G4Nucleus recoil(A-2,Z-1);
633 rM = recoil.AtomicMass(A-2,Z-1)+sqrt(nMom*nMom+fM1*fM1);
634 hM = tM - rM;
635
636 fLVt = G4LorentzVector( nMomDir, sqrt( rM*rM+nMom*nMom ) );
637 fLVh = G4LorentzVector(-nMomDir, sqrt( hM*hM+nMom*nMom ) );
638 }
639 // G4cout<<hM<<", ";
640 // bst = fLVh.boostVector();
641
642 // lvp1.boost(-bst); // -> nucleon rest system, where Q2 transfer is ???
643
644 fNuEnergy = lvp1.e();
645 // G4double mN = fLVh.m(); // better mN = fM1 !? vmg
646 iTer = 0;
647
648 do // no FM!?, 5.4.20 vmg
649 {
653
654 // G4double mR = mN + fM1*(A-1.)*std::exp(-2.0*fQtransfer/mN); // recoil mass in+el
655
656 if( fXsample > 0. )
657 {
658 fW2 = fM1*fM1 - fQ2 + fQ2/fXsample; // sample excited hadron mass
659
660 // fW2 = mN*mN - fQ2 + fQ2/fXsample; // sample excited hadron mass
661 // fEmu = fNuEnergy - fQ2/2./mR/fXsample; // fM1->mN
662
663 fEmu = fNuEnergy - fQ2/2./fM1/fXsample; // fM1->mN
664 }
665 else
666 {
667 // fW2 = mN*mN;
668
669 fW2 = fM1*fM1;
670 fEmu = fNuEnergy;
671 }
672 // if(fEmu < 0.) G4cout<<"fEmu = "<<fEmu<<" hM = "<<hM<<G4endl;
673 // e3 = fNuEnergy + mR - fEmu;
674
675 e3 = fNuEnergy + fM1 - fEmu;
676
677 // if( e3 < sqrt(fW2) ) G4cout<<"energyX = "<<e3/GeV<<", fW = "<<sqrt(fW2)/GeV<<G4endl;
678
679 pMu2 = fEmu*fEmu - fMu*fMu;
680 pX2 = e3*e3 - fW2;
681
682 if(pMu2 < 0.) { fBreak = true; return; }
683
684 fCosTheta = fNuEnergy*fNuEnergy + pMu2 - pX2;
685 fCosTheta /= 2.*fNuEnergy*sqrt(pMu2);
686 iTer++;
687 }
688 while( ( abs(fCosTheta) > 1. || fEmu < fMu ) && iTer < iTerMax );
689
690 if( iTer >= iTerMax ) { fBreak = true; return; }
691
692 if( abs(fCosTheta) > 1.) // vmg: due to big Q2/x values. To be improved ...
693 {
694 G4cout<<"FM: fCosTheta = "<<fCosTheta<<", fEmu = "<<fEmu<<G4endl;
695 // fCosTheta = -1. + 2.*G4UniformRand();
696 if( fCosTheta < -1.) fCosTheta = -1.;
697 if( fCosTheta > 1.) fCosTheta = 1.;
698 }
699 // LVs
700 // G4LorentzVector lvt1 = G4LorentzVector( 0., 0., 0., mN ); // fM1 );
701
702 G4LorentzVector lvt1 = G4LorentzVector( 0., 0., 0., fM1 ); // fM1 );
703 G4LorentzVector lvsum = lvp1 + lvt1;
704
705 cost = fCosTheta;
706 sint = std::sqrt( (1.0 - cost)*(1.0 + cost) );
708 eP = G4ThreeVector( sint*std::cos(phi), sint*std::sin(phi), cost );
709 muMom = sqrt(fEmu*fEmu-fMu*fMu);
710 eP *= muMom;
711 fLVl = G4LorentzVector( eP, fEmu );
712 fLVh = lvsum - fLVl;
713
714 // if( fLVh.e() < mN || fLVh.m2() < 0.) { fBreak = true; return; }
715
716 if( fLVh.e() < fM1 || fLVh.m2() < 0.) { fBreak = true; return; }
717
718 // back to lab system
719
720 // fLVl.boost(bst);
721 // fLVh.boost(bst);
722 }
723 //G4cout<<iTer<<", "<<fBreak<<"; ";
724}
static const G4double e3[45]
G4ThreeVector G4RandomDirection()
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
G4double SampleXkr(G4double energy)
G4double SampleQkr(G4double energy, G4double xx)
G4double GgSampleNM(G4Nucleus &nucl)

References A, G4Nucleus::AtomicMass(), CLHEP::HepLorentzVector::e(), e3, G4NeutrinoNucleusModel::f2p2h, G4NeutrinoNucleusModel::fBreak, G4NeutrinoNucleusModel::fCosTheta, G4NeutrinoNucleusModel::fEmu, G4NeutrinoNucleusModel::fLVh, G4NeutrinoNucleusModel::fLVl, G4NeutrinoNucleusModel::fLVt, G4NeutrinoNucleusModel::fM1, G4NeutrinoNucleusModel::fMu, G4NeutrinoNucleusModel::fNuEnergy, G4NeutrinoNucleusModel::fProton, G4NeutrinoNucleusModel::fQ2, G4NeutrinoNucleusModel::fQtransfer, G4NeutrinoNucleusModel::fW2, G4NeutrinoNucleusModel::fXsample, G4cout, G4endl, G4RandomDirection(), G4UniformRand, G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4NeutrinoNucleusModel::GetEx(), G4HadProjectile::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), GeV, G4NeutrinoNucleusModel::GgSampleNM(), CLHEP::HepLorentzVector::m2(), G4NeutrinoNucleusModel::SampleQkr(), G4NeutrinoNucleusModel::SampleXkr(), CLHEP::twopi, and Z.

Referenced by ApplyYourself().

◆ SampleQkr()

G4double G4NeutrinoNucleusModel::SampleQkr ( G4double  energy,
G4double  xx 
)
inherited

Definition at line 306 of file G4NeutrinoNucleusModel.cc.

307{
308 G4int nBin(50), iE=fEindex, jX=fXindex;
309 G4double qq(0.), qq1(0.), qq2(0.);
310 G4double prob = G4UniformRand();
311
312 // first E
313
314 if( iE <= 0 )
315 {
316 qq1 = GetQkr( 0, jX, prob);
317 }
318 else if ( iE >= nBin-1)
319 {
320 qq1 = GetQkr( nBin-1, jX, prob);
321 }
322 else
323 {
324 G4double q1 = GetQkr(iE-1,jX, prob);
325 G4double q2 = GetQkr(iE,jX, prob);
326
329 G4double e = G4Log(energy);
330
331 if( e2 <= e1) qq1 = q1 + G4UniformRand()*(q2-q1);
332 else qq1 = q1 + (e-e1)*(q2-q1)/(e2-e1); // lin in energy log-scale
333 }
334
335 // then X
336
337 if( jX <= 0 )
338 {
339 qq2 = GetQkr( iE, 0, prob);
340 }
341 else if ( jX >= nBin)
342 {
343 qq2 = GetQkr( iE, nBin, prob);
344 }
345 else
346 {
347 G4double q1 = GetQkr(iE,jX-1, prob);
348 G4double q2 = GetQkr(iE,jX, prob);
349
350 G4double e1 = G4Log(fNuMuXarrayKR[iE][jX-1]);
351 G4double e2 = G4Log(fNuMuXarrayKR[iE][jX]);
352 G4double e = G4Log(xx);
353
354 if( e2 <= e1) qq2 = q1 + G4UniformRand()*(q2-q1);
355 else qq2 = q1 + (e-e1)*(q2-q1)/(e2-e1); // lin in energy log-scale
356 }
357 qq = 0.5*(qq1+qq2);
358
359 return qq;
360}
G4double G4Log(G4double x)
Definition: G4Log.hh:226
G4double GetQkr(G4int iE, G4int jX, G4double prob)
static const G4double fNuMuEnergyLogVector[50]

References e1, e2, G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fEindex, G4NeutrinoNucleusModel::fNuMuEnergyLogVector, G4NeutrinoNucleusModel::fNuMuXarrayKR, G4NeutrinoNucleusModel::fXindex, G4Log(), G4UniformRand, and G4NeutrinoNucleusModel::GetQkr().

Referenced by G4ANuElNucleusCcModel::SampleLVkr(), G4ANuElNucleusNcModel::SampleLVkr(), SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), G4NuMuNucleusCcModel::SampleLVkr(), and G4NuMuNucleusNcModel::SampleLVkr().

◆ SampleXkr()

G4double G4NeutrinoNucleusModel::SampleXkr ( G4double  energy)
inherited

Definition at line 225 of file G4NeutrinoNucleusModel.cc.

226{
227 G4int i(0), nBin(50);
228 G4double xx(0.), prob = G4UniformRand();
229
230 for( i = 0; i < nBin; ++i )
231 {
232 if( energy <= fNuMuEnergyLogVector[i] ) break;
233 }
234 if( i <= 0) // E-edge
235 {
236 fEindex = 0;
237 xx = GetXkr( 0, prob);
238 }
239 else if ( i >= nBin)
240 {
241 fEindex = nBin-1;
242 xx = GetXkr( nBin-1, prob);
243 }
244 else
245 {
246 fEindex = i;
247 G4double x1 = GetXkr(i-1,prob);
248 G4double x2 = GetXkr(i,prob);
249
252 G4double e = G4Log(energy);
253
254 if( e2 <= e1) xx = x1 + G4UniformRand()*(x2-x1);
255 else xx = x1 + (e-e1)*(x2-x1)/(e2-e1); // lin in energy log-scale
256 }
257 return xx;
258}
G4double GetXkr(G4int iEnergy, G4double prob)

References e1, e2, G4INCL::KinematicsUtils::energy(), G4NeutrinoNucleusModel::fEindex, G4NeutrinoNucleusModel::fNuMuEnergyLogVector, G4Log(), G4UniformRand, and G4NeutrinoNucleusModel::GetXkr().

Referenced by G4ANuElNucleusCcModel::SampleLVkr(), G4ANuElNucleusNcModel::SampleLVkr(), SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), G4NuMuNucleusCcModel::SampleLVkr(), and G4NuMuNucleusNcModel::SampleLVkr().

◆ SetCutEnergy()

void G4NeutrinoNucleusModel::SetCutEnergy ( G4double  ec)
inlineinherited

Definition at line 98 of file G4NeutrinoNucleusModel.hh.

98{fCutEnergy=ec;};

References G4NeutrinoNucleusModel::fCutEnergy.

◆ 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().

◆ 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

◆ SetQEratioA()

void G4NeutrinoNucleusModel::SetQEratioA ( G4double  qea)
inlineinherited

Definition at line 137 of file G4NeutrinoNucleusModel.hh.

137{ fQEratioA = qea; };

References G4NeutrinoNucleusModel::fQEratioA.

◆ SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double  val)
inlineinherited

◆ SetVerboseLevel()

void G4HadronicInteraction::SetVerboseLevel ( G4int  value)
inlineinherited

◆ ThresholdEnergy()

G4double G4ANuMuNucleusCcModel::ThresholdEnergy ( G4double  mI,
G4double  mF,
G4double  mP 
)
inline

Definition at line 78 of file G4ANuMuNucleusCcModel.hh.

79 {
80 G4double w = std::sqrt(fW2);
81 return w + 0.5*( (mP+mF)*(mP+mF)-(w+mI)*(w+mI) )/mI;
82 };

References G4NeutrinoNucleusModel::fW2.

Field Documentation

◆ epCheckLevels

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

◆ f2p2h

G4bool G4NeutrinoNucleusModel::f2p2h
protectedinherited

◆ fANeMuQEratio

const G4double G4NeutrinoNucleusModel::fANeMuQEratio
staticprotectedinherited
Initial value:
=
{
1, 1, 1, 1, 1, 1, 1, 0.97506, 0.920938, 0.847671, 0.762973, 0.677684, 0.597685,
0.52538, 0.461466, 0.405329, 0.356154, 0.312944, 0.274984, 0.241341, 0.211654, 0.185322,
0.161991, 0.141339, 0.123078, 0.106952, 0.0927909, 0.0803262, 0.0693698, 0.0598207, 0.0514545,
0.044193, 0.0378696, 0.0324138, 0.0276955, 0.0236343, 0.0201497, 0.0171592, 0.014602, 0.0124182,
0.0105536, 0.00896322, 0.00761004, 0.00645821, 0.00547859, 0.00464595, 0.00393928,
0.00333961, 0.00283086, 0.00239927
}

Definition at line 218 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::CalculateQEratioA().

◆ fBarMass

const G4double G4NeutrinoNucleusModel::fBarMass = {1700., 1600., 1232., 939.57}
staticprotectedinherited

Definition at line 195 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::ClusterDecay().

◆ fBarPDG

const G4int G4NeutrinoNucleusModel::fBarPDG = {12224, 32224, 2224, 2212}
staticprotectedinherited

Definition at line 196 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::ClusterDecay().

◆ fBreak

G4bool G4NeutrinoNucleusModel::fBreak
protectedinherited

◆ fCascade

G4bool G4NeutrinoNucleusModel::fCascade
protectedinherited

◆ fClustNumber

const G4int G4NeutrinoNucleusModel::fClustNumber = 4
staticprotectedinherited

◆ fCosTheta

G4double G4NeutrinoNucleusModel::fCosTheta
protectedinherited

◆ fCosThetaPi

G4double G4NeutrinoNucleusModel::fCosThetaPi
protectedinherited

◆ fCutEnergy

G4double G4NeutrinoNucleusModel::fCutEnergy
protectedinherited

◆ fData

G4bool G4ANuMuNucleusCcModel::fData
private

Definition at line 88 of file G4ANuMuNucleusCcModel.hh.

Referenced by G4ANuMuNucleusCcModel(), and InitialiseModel().

◆ fDeExcitation

G4ExcitationHandler* G4NeutrinoNucleusModel::fDeExcitation
protectedinherited

◆ fDp

G4double G4NeutrinoNucleusModel::fDp
protectedinherited

◆ fEindex

G4int G4NeutrinoNucleusModel::fEindex
protectedinherited

◆ fEmu

G4double G4NeutrinoNucleusModel::fEmu
protectedinherited

◆ fEmuPi

G4double G4NeutrinoNucleusModel::fEmuPi
protectedinherited

◆ fEx

G4double G4NeutrinoNucleusModel::fEx
protectedinherited

◆ fIndex

G4int G4NeutrinoNucleusModel::fIndex
protectedinherited

◆ fLVcpi

G4LorentzVector G4NeutrinoNucleusModel::fLVcpi
protectedinherited

◆ fLVh

G4LorentzVector G4NeutrinoNucleusModel::fLVh
protectedinherited

◆ fLVl

G4LorentzVector G4NeutrinoNucleusModel::fLVl
protectedinherited

◆ fLVt

G4LorentzVector G4NeutrinoNucleusModel::fLVt
protectedinherited

◆ fM1

G4double G4NeutrinoNucleusModel::fM1
protectedinherited

◆ fM2

G4double G4NeutrinoNucleusModel::fM2
protectedinherited

◆ fMaster

G4bool G4ANuMuNucleusCcModel::fMaster
private

Definition at line 88 of file G4ANuMuNucleusCcModel.hh.

Referenced by G4ANuMuNucleusCcModel(), and InitialiseModel().

◆ fMesMass

const G4double G4NeutrinoNucleusModel::fMesMass = {1260., 980., 770., 139.57}
staticprotectedinherited

◆ fMesPDG

const G4int G4NeutrinoNucleusModel::fMesPDG = {20213, 9000211, 213, 211}
staticprotectedinherited

Definition at line 193 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::MesonDecay().

◆ fMinNuEnergy

G4double G4NeutrinoNucleusModel::fMinNuEnergy
protectedinherited

◆ fMpi

G4double G4NeutrinoNucleusModel::fMpi
protectedinherited

◆ fMr

G4double G4NeutrinoNucleusModel::fMr
protectedinherited

◆ fMt

G4double G4NeutrinoNucleusModel::fMt
protectedinherited

◆ fMu

G4double G4NeutrinoNucleusModel::fMu
protectedinherited

◆ fNbin

G4int G4NeutrinoNucleusModel::fNbin
protectedinherited

◆ fNeMuQEratio

const G4double G4NeutrinoNucleusModel::fNeMuQEratio
staticprotectedinherited
Initial value:
=
{
1, 1, 1, 1, 1, 1, 1, 0.977592, 0.926073, 0.858783, 0.783874, 0.706868, 0.63113, 0.558681,
0.490818, 0.428384, 0.371865, 0.321413, 0.276892, 0.237959, 0.204139, 0.1749, 0.149706, 0.128047,
0.109456, 0.093514, 0.0798548, 0.0681575, 0.0581455, 0.0495804, 0.0422578, 0.036002, 0.0306614,
0.0261061, 0.0222231, 0.0189152, 0.0160987, 0.0137011, 0.0116604, 0.00992366, 0.00844558, 0.00718766,
0.00611714, 0.00520618, 0.00443105, 0.00377158, 0.00321062, 0.0027335, 0.00232774, 0.00198258
}

Definition at line 219 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::CalculateQEratioA().

◆ fNuEnergy

G4double G4NeutrinoNucleusModel::fNuEnergy
protectedinherited

◆ fNuMuEnergy

const G4double G4NeutrinoNucleusModel::fNuMuEnergy
staticprotectedinherited
Initial value:
=
{
0.112103, 0.117359, 0.123119, 0.129443, 0.136404,
0.144084, 0.152576, 0.161991, 0.172458, 0.184126,
0.197171, 0.211801, 0.228261, 0.24684, 0.267887,
0.291816, 0.319125, 0.350417, 0.386422, 0.428032,
0.47634, 0.532692, 0.598756, 0.676612, 0.768868,
0.878812, 1.01062, 1.16963, 1.36271, 1.59876,
1.88943, 2.25002, 2.70086, 3.26916, 3.99166,
4.91843, 6.11836, 7.6872, 9.75942, 12.5259,
16.2605, 21.3615, 28.4141, 38.2903, 52.3062,
72.4763, 101.93, 145.6, 211.39, 312.172
}

Definition at line 201 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::GetEnergyIndex(), and G4NeutrinoNucleusModel::GetNuMuQeTotRat().

◆ fNuMuEnergyLogVector

const G4double G4NeutrinoNucleusModel::fNuMuEnergyLogVector
staticprotectedinherited
Initial value:
= {
115.603, 133.424, 153.991, 177.729, 205.126, 236.746, 273.24, 315.361, 363.973, 420.08, 484.836, 559.573, 645.832,
745.387, 860.289, 992.903, 1145.96, 1322.61, 1526.49, 1761.8, 2033.38, 2346.83, 2708.59, 3126.12, 3608.02, 4164.19,
4806.1, 5546.97, 6402.04, 7388.91, 8527.92, 9842.5, 11359.7, 13110.8, 15131.9, 17464.5, 20156.6, 23263.8, 26849.9,
30988.8, 35765.7, 41279, 47642.2, 54986.3, 63462.4, 73245.2, 84536, 97567.2, 112607, 129966 }

Definition at line 206 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::SampleQkr(), and G4NeutrinoNucleusModel::SampleXkr().

◆ fNuMuQarrayKR

G4double G4NeutrinoNucleusModel::fNuMuQarrayKR = {{{1.0}}}
staticprotectedinherited

◆ fNuMuQdistrKR

G4double G4NeutrinoNucleusModel::fNuMuQdistrKR = {{{1.0}}}
staticprotectedinherited

◆ fNuMuQeTotRat

const G4double G4NeutrinoNucleusModel::fNuMuQeTotRat
staticprotectedinherited
Initial value:
=
{
0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98,
0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98,
0.97, 0.96, 0.95, 0.93,
0.917794, 0.850239, 0.780412, 0.709339, 0.638134, 0.568165,
0.500236, 0.435528, 0.375015, 0.319157, 0.268463, 0.2232, 0.183284,
0.148627, 0.119008, 0.0940699, 0.0733255, 0.0563819, 0.0427312, 0.0319274,
0.0235026, 0.0170486, 0.0122149, 0.00857825, 0.00594018, 0.00405037
}

Definition at line 202 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::GetNuMuQeTotRat().

◆ fNuMuResQ

const G4double G4NeutrinoNucleusModel::fNuMuResQ[50][50]
staticprotectedinherited

Definition at line 198 of file G4NeutrinoNucleusModel.hh.

◆ fNuMuXarrayKR

G4double G4NeutrinoNucleusModel::fNuMuXarrayKR = {{1.0}}
staticprotectedinherited

◆ fNuMuXdistrKR

G4double G4NeutrinoNucleusModel::fNuMuXdistrKR = {{1.0}}
staticprotectedinherited

◆ fOnePionEnergy

const G4double G4NeutrinoNucleusModel::fOnePionEnergy
staticprotectedinherited
Initial value:
=
{
0.275314, 0.293652, 0.31729, 0.33409, 0.351746, 0.365629, 0.380041, 0.400165, 0.437941, 0.479237,
0.504391, 0.537803, 0.588487, 0.627532, 0.686839, 0.791905, 0.878332, 0.987405, 1.08162, 1.16971,
1.2982, 1.40393, 1.49854, 1.64168, 1.7524, 1.87058, 2.02273, 2.15894, 2.3654, 2.55792, 2.73017,
3.03005, 3.40733, 3.88128, 4.53725, 5.16786, 5.73439, 6.53106, 7.43879, 8.36214, 9.39965, 10.296,
11.5735, 13.1801, 15.2052, 17.5414, 19.7178, 22.7462, 25.9026, 29.4955, 33.5867, 39.2516, 46.4716,
53.6065, 63.4668, 73.2147, 85.5593, 99.9854
}

Definition at line 203 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::GetNuMuOnePionProb(), G4NeutrinoNucleusModel::GetNuMuQeTotRat(), and G4NeutrinoNucleusModel::GetOnePionIndex().

◆ fOnePionIndex

G4int G4NeutrinoNucleusModel::fOnePionIndex
protectedinherited

◆ fOnePionProb

const G4double G4NeutrinoNucleusModel::fOnePionProb
staticprotectedinherited
Initial value:
=
{
0.0019357, 0.0189361, 0.0378722, 0.0502758, 0.0662559, 0.0754581, 0.0865008, 0.0987275, 0.124112,
0.153787, 0.18308, 0.213996, 0.245358, 0.274425, 0.301536, 0.326612, 0.338208, 0.337806, 0.335948,
0.328092, 0.313557, 0.304965, 0.292169, 0.28481, 0.269474, 0.254138, 0.247499, 0.236249, 0.221654,
0.205492, 0.198781, 0.182216, 0.162251, 0.142878, 0.128631, 0.116001, 0.108435, 0.0974843, 0.082092,
0.0755204, 0.0703121, 0.0607066, 0.0554278, 0.0480401, 0.0427023, 0.0377123, 0.0323248, 0.0298584,
0.0244296, 0.0218526, 0.019121, 0.016477, 0.0137309, 0.0137963, 0.0110371, 0.00834028, 0.00686127, 0.00538226
}

Definition at line 204 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::GetNuMuOnePionProb().

◆ fPDGencoding

G4int G4NeutrinoNucleusModel::fPDGencoding
protectedinherited

◆ fPrecoInterface

G4GeneratorPrecompoundInterface* G4NeutrinoNucleusModel::fPrecoInterface
protectedinherited

◆ fPreCompound

G4PreCompoundModel* G4NeutrinoNucleusModel::fPreCompound
protectedinherited

◆ fProton

G4bool G4NeutrinoNucleusModel::fProton
protectedinherited

◆ fQ2

G4double G4NeutrinoNucleusModel::fQ2
protectedinherited

◆ fQEnergy

const G4double G4NeutrinoNucleusModel::fQEnergy
staticprotectedinherited
Initial value:
=
{
0.12, 0.1416, 0.167088, 0.197164, 0.232653, 0.274531, 0.323946, 0.382257, 0.451063, 0.532254,
0.62806, 0.741111, 0.874511, 1.03192, 1.21767, 1.43685, 1.69548, 2.00067, 2.36079, 2.78573,
3.28716, 3.87885, 4.57705, 5.40092, 6.37308, 7.52024, 8.87388, 10.4712, 12.356, 14.5801,
17.2045, 20.3013, 23.9555, 28.2675, 33.3557, 39.3597, 46.4444, 54.8044, 64.6692, 76.3097,
90.0454, 106.254, 125.379, 147.947, 174.578, 206.002, 243.082, 286.837, 338.468, 399.392
}

Definition at line 217 of file G4NeutrinoNucleusModel.hh.

Referenced by G4NeutrinoNucleusModel::CalculateQEratioA().

◆ fQEratioA

G4double G4NeutrinoNucleusModel::fQEratioA
protectedinherited

◆ fQindex

G4int G4NeutrinoNucleusModel::fQindex
protectedinherited

◆ fQtransfer

G4double G4NeutrinoNucleusModel::fQtransfer
protectedinherited

◆ fRecoil

G4Nucleus* G4NeutrinoNucleusModel::fRecoil
protectedinherited

◆ fResMass

const G4double G4NeutrinoNucleusModel::fResMass
staticprotectedinherited
Initial value:
=
{2190., 1920., 1700., 1600., 1440., 1232. }

Definition at line 188 of file G4NeutrinoNucleusModel.hh.

◆ fResNumber

const G4int G4NeutrinoNucleusModel::fResNumber = 6
staticprotectedinherited

Definition at line 187 of file G4NeutrinoNucleusModel.hh.

◆ fSecID

G4int G4NeutrinoNucleusModel::fSecID
protectedinherited

◆ fSin2tW

G4double G4NeutrinoNucleusModel::fSin2tW
protectedinherited

◆ fString

G4bool G4NeutrinoNucleusModel::fString
protectedinherited

◆ fTr

G4double G4NeutrinoNucleusModel::fTr
protectedinherited

◆ fW2

G4double G4NeutrinoNucleusModel::fW2
protectedinherited

◆ fW2pi

G4double G4NeutrinoNucleusModel::fW2pi
protectedinherited

◆ fXindex

G4int G4NeutrinoNucleusModel::fXindex
protectedinherited

◆ fXsample

G4double G4NeutrinoNucleusModel::fXsample
protectedinherited

◆ isBlocked

G4bool G4HadronicInteraction::isBlocked
protectedinherited

◆ recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold
privateinherited

◆ registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry
privateinherited

◆ theBlockedList

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

◆ theBlockedListElements

std::vector<const G4Element *> G4HadronicInteraction::theBlockedListElements
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

◆ theMuonMinus

G4ParticleDefinition* G4NeutrinoNucleusModel::theMuonMinus
protectedinherited

◆ theMuonPlus

G4ParticleDefinition* G4NeutrinoNucleusModel::theMuonPlus
protectedinherited

◆ 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(), 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().

◆ 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(), G4ElasticHadrNucleusHE::DefineHadronValues(), G4ElasticHadrNucleusHE::FillData(), G4ElasticHadrNucleusHE::FillFq2(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE(), G4EMDissociation::G4EMDissociation(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4ElasticHadrNucleusHE::GetFt(), G4ElasticHadrNucleusHE::GetLightFq2(), G4ElasticHadrNucleusHE::GetQ2_2(), G4HadronicInteraction::GetVerboseLevel(), G4ElasticHadrNucleusHE::HadronNucleusQ2_2(), G4ElasticHadrNucleusHE::HadronProtonQ2(), G4LFission::init(), G4DiffuseElastic::Initialise(), G4DiffuseElasticV2::Initialise(), G4NuclNuclDiffuseElastic::Initialise(), G4DiffuseElastic::InitialiseOnFly(), G4DiffuseElasticV2::InitialiseOnFly(), G4NuclNuclDiffuseElastic::InitialiseOnFly(), G4CascadeInterface::makeDynamicParticle(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4ElasticHadrNucleusHE::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: