G4HadronicProcess Class Reference

#include <G4HadronicProcess.hh>

Inheritance diagram for G4HadronicProcess:

Public Member Functions
	G4HadronicProcess (const G4String &processName="Hadronic", G4ProcessType procType=fHadronic)
	G4HadronicProcess (const G4String &processName, G4HadronicProcessType subType)
	~G4HadronicProcess () override
void	RegisterMe (G4HadronicInteraction *a)
G4double	GetElementCrossSection (const G4DynamicParticle *part, const G4Element *elm, const G4Material *mat=nullptr)
G4double	GetMicroscopicCrossSection (const G4DynamicParticle *part, const G4Element *elm, const G4Material *mat=nullptr)
void	StartTracking (G4Track *track) override
G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double, G4ForceCondition *) override
G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override
void	PreparePhysicsTable (const G4ParticleDefinition &) override
void	BuildPhysicsTable (const G4ParticleDefinition &) override
void	DumpPhysicsTable (const G4ParticleDefinition &p)
void	AddDataSet (G4VCrossSectionDataSet *aDataSet)
std::vector< G4HadronicInteraction * > &	GetHadronicInteractionList ()
G4HadronicInteraction *	GetHadronicModel (const G4String &)
G4HadronicInteraction *	GetHadronicInteraction () const
G4double	GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *) override
const G4Nucleus *	GetTargetNucleus () const
G4Nucleus *	GetTargetNucleusPointer ()
const G4Isotope *	GetTargetIsotope ()
G4double	ComputeCrossSection (const G4ParticleDefinition *, const G4Material *, const G4double kinEnergy)
G4HadXSType	CrossSectionType () const
void	SetCrossSectionType (G4HadXSType val)
void	ProcessDescription (std::ostream &outFile) const override
void	BiasCrossSectionByFactor (G4double aScale)
void	MultiplyCrossSectionBy (G4double factor)
G4double	CrossSectionFactor () const
void	SetIntegral (G4bool val)
void	SetEpReportLevel (G4int level)
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
G4CrossSectionDataStore *	GetCrossSectionDataStore ()
std::vector< G4TwoPeaksHadXS * > *	TwoPeaksXS () const
std::vector< G4double > *	EnergyOfCrossSectionMax () const
G4HadronicProcess &	operator= (const G4HadronicProcess &right)=delete
	G4HadronicProcess (const G4HadronicProcess &)=delete
Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &aName, G4ProcessType aType=fNotDefined)
	G4VDiscreteProcess (G4VDiscreteProcess &)
virtual	~G4VDiscreteProcess ()
G4VDiscreteProcess &	operator= (const G4VDiscreteProcess &)=delete
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
virtual G4double	GetCrossSection (const G4double, const G4MaterialCutsCouple *)
virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4VProcess &	operator= (const G4VProcess &)=delete
G4bool	operator== (const G4VProcess &right) const
G4bool	operator!= (const G4VProcess &right) const
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual const G4VProcess *	GetCreatorProcess () const
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
G4HadronicInteraction *	ChooseHadronicInteraction (const G4HadProjectile &aHadProjectile, G4Nucleus &aTargetNucleus, const G4Material *aMaterial, const G4Element *anElement)
G4double	GetLastCrossSection ()
void	FillResult (G4HadFinalState *aR, const G4Track &aT)
void	DumpState (const G4Track &, const G4String &, G4ExceptionDescription &)
G4HadFinalState *	CheckResult (const G4HadProjectile &thePro, const G4Nucleus &targetNucleus, G4HadFinalState *result)
void	CheckEnergyMomentumConservation (const G4Track &, const G4Nucleus &)
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4HadProjectile	thePro
G4ParticleChange *	theTotalResult
G4CrossSectionDataStore *	theCrossSectionDataStore
G4double	fWeight = 1.0
G4double	aScaleFactor = 1.0
G4double	theLastCrossSection = 0.0
G4double	mfpKinEnergy = DBL_MAX
G4int	epReportLevel = 0
G4HadXSType	fXSType = fHadNoIntegral
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft = -1.0
G4double	currentInteractionLength = -1.0
G4double	theInitialNumberOfInteractionLength = -1.0
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType = fNotDefined
G4int	theProcessSubType = -1
G4double	thePILfactor = 1.0
G4int	verboseLevel = 0
G4bool	enableAtRestDoIt = true
G4bool	enableAlongStepDoIt = true
G4bool	enablePostStepDoIt = true

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 73 of file G4HadronicProcess.hh.

Constructor & Destructor Documentation

G4HadronicProcess() [1/3]

G4HadronicProcess::G4HadronicProcess	(	const G4String &	processName = "Hadronic",
		G4ProcessType	procType = fHadronic )

Definition at line 87 of file G4HadronicProcess.cc.

 : G4VDiscreteProcess(processName, procType)
{
  SetProcessSubType(fHadronInelastic);  // Default unless subclass changes
  InitialiseLocal();
}

Referenced by BuildPhysicsTable(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(), G4HadronElasticProcess::G4HadronElasticProcess(), G4HadronicProcess(), G4HadronInelasticProcess::G4HadronInelasticProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(), G4MuonNuclearProcess::G4MuonNuclearProcess(), G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(), G4NeutronCaptureProcess::G4NeutronCaptureProcess(), G4NeutronFissionProcess::G4NeutronFissionProcess(), G4NeutronGeneralProcess::G4NeutronGeneralProcess(), G4TauNeutrinoNucleusProcess::G4TauNeutrinoNucleusProcess(), G4NeutronGeneralProcess::GetHadronicProcess(), operator=(), G4NeutronGeneralProcess::operator=(), G4NeutronGeneralProcess::SelectedProcess(), G4NeutronGeneralProcess::SetCaptureProcess(), G4NeutronGeneralProcess::SetElasticProcess(), and G4NeutronGeneralProcess::SetInelasticProcess().

G4HadronicProcess() [2/3]

G4HadronicProcess::G4HadronicProcess	(	const G4String &	processName,
		G4HadronicProcessType	subType )

Definition at line 95 of file G4HadronicProcess.cc.

 : G4VDiscreteProcess(processName, fHadronic)
{
  SetProcessSubType(aHadSubType);
  InitialiseLocal();
}

~G4HadronicProcess()

G4HadronicProcess::~G4HadronicProcess ( )

override

Definition at line 103 of file G4HadronicProcess.cc.

{
  theProcessStore->DeRegister(this);
  delete theTotalResult;
  delete theCrossSectionDataStore;
  if(isMaster) {
    if (fXSpeaks != nullptr) {
      for (auto const& e : *fXSpeaks ) {
        delete e;
      }
    }
    delete fXSpeaks;
    delete theEnergyOfCrossSectionMax;
  }
}

G4HadronicProcess() [3/3]

G4HadronicProcess::G4HadronicProcess ( const G4HadronicProcess & )

delete

Member Function Documentation

AddDataSet()

void G4HadronicProcess::AddDataSet

(

G4VCrossSectionDataSet *

aDataSet

)

Definition at line 854 of file G4HadronicProcess.cc.

{ 
  theCrossSectionDataStore->AddDataSet(aDataSet);
}

Referenced by G4HadProcesses::AddCaptureCrossSection(), G4HadProcesses::AddElasticCrossSection(), G4HadProcesses::AddFissionCrossSection(), G4HadProcesses::AddInelasticCrossSection(), G4HadronElasticPhysics::AddXSection(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4QGSPProtonBuilder::Build(), G4TritonPHPBuilder::Build(), G4HadProcesses::BuildNeutronElastic(), G4HadProcesses::BuildNeutronInelasticAndCapture(), LBE::ConstructHad(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsHPT::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronElasticPhysicsVI::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronInelasticQBBC_ABLA::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4NeutronCrossSectionXS::ConstructProcess(), G4ThermalNeutrons::ConstructProcess(), G4URRNeutrons::ConstructProcess(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4MuonNuclearProcess::G4MuonNuclearProcess(), G4NeutronCaptureProcess::G4NeutronCaptureProcess(), G4NeutronFissionProcess::G4NeutronFissionProcess(), G4HadronPhysicsFTF_BIC::Neutron(), G4HadronPhysicsFTFP_BERT::Neutron(), G4NeutronGeneralProcess::SetCaptureProcess(), G4NeutronGeneralProcess::SetElasticProcess(), and G4NeutronGeneralProcess::SetInelasticProcess().

BiasCrossSectionByFactor()

void G4HadronicProcess::BiasCrossSectionByFactor

(

G4double

aScale

)

Definition at line 576 of file G4HadronicProcess.cc.

{
  if (aScale <= 0.0) {
    G4ExceptionDescription ed;
    ed << " Wrong biasing factor " << aScale << " for " << GetProcessName();
    G4Exception("G4HadronicProcess::BiasCrossSectionByFactor", "had010", 
                JustWarning, ed, "Cross-section bias is ignored");
  } else {
    aScaleFactor = aScale;
  }
}

Referenced by MultiplyCrossSectionBy().

BuildPhysicsTable()

void G4HadronicProcess::BuildPhysicsTable ( const G4ParticleDefinition & p )

overridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4NeutronGeneralProcess.

Definition at line 171 of file G4HadronicProcess.cc.

{
  if(firstParticle != &p) { return; }
 
  theCrossSectionDataStore->BuildPhysicsTable(p);
  theEnergyRangeManager.BuildPhysicsTable(p);
  G4HadronicParameters* param = G4HadronicParameters::Instance();
 
  G4int subtype = GetProcessSubType();
  if(useIntegralXS) {
    if(subtype == fHadronInelastic) {
      useIntegralXS = param->EnableIntegralInelasticXS();
    } else if(subtype == fHadronElastic) {
      useIntegralXS = param->EnableIntegralElasticXS();
    } 
  }
  fXSType = fHadNoIntegral;
 
  if(nullptr == masterProcess) {
    masterProcess = dynamic_cast<const G4HadronicProcess*>(GetMasterProcess());
  }
 
  // check particle for integral method
  if(isMaster || nullptr == masterProcess) {
    G4double charge = p.GetPDGCharge()/eplus;
 
    // select cross section shape
    if(charge != 0.0 && useIntegralXS) {
      G4double tmax = param->GetMaxEnergy();
      currentParticle = firstParticle;
      // initialisation in the master thread
      G4int pdg = p.GetPDGEncoding();
      if (std::abs(pdg) == 211) {
    fXSType = fHadTwoPeaks;
      } else if (pdg == 321) {
    fXSType = fHadOnePeak;
      } else if (pdg == -321) {
    fXSType = fHadDecreasing;
      } else if (pdg == 2212) {
    fXSType = fHadTwoPeaks;
      } else if (pdg == -2212 || pdg == -1000010020 || pdg == -1000010030 ||
         pdg == -1000020030 || pdg == -1000020040) {
    fXSType = fHadDecreasing;
      } else if (charge > 0.0 || pdg == 11 || pdg == 13) {
    fXSType = fHadIncreasing;
      }
        
      delete theEnergyOfCrossSectionMax;
      theEnergyOfCrossSectionMax = nullptr;
      if(fXSType == fHadTwoPeaks) {
        if (fXSpeaks != nullptr) {
          for (auto const& e : *fXSpeaks ) {
            delete e;
          }
        }
    delete fXSpeaks;
    fXSpeaks =
      G4HadXSHelper::FillPeaksStructure(this, &p, minKinEnergy, tmax);
    if(nullptr == fXSpeaks) {
      fXSType = fHadOnePeak;
    }
      }
      if(fXSType == fHadOnePeak) {
    theEnergyOfCrossSectionMax =
      G4HadXSHelper::FindCrossSectionMax(this, &p,  minKinEnergy, tmax);
    if(nullptr == theEnergyOfCrossSectionMax) {
      fXSType = fHadIncreasing;
    }
      }
    }
  } else {
    // initialisation in worker threads
    fXSType = masterProcess->CrossSectionType();
    fXSpeaks = masterProcess->TwoPeaksXS();
    theEnergyOfCrossSectionMax = masterProcess->EnergyOfCrossSectionMax();
  }
  if(isMaster && 1 < param->GetVerboseLevel()) {
    G4cout << "G4HadronicProcess::BuildPhysicsTable: for "
       << GetProcessName() << " and " << p.GetParticleName()
       << " typeXS=" << fXSType << G4endl;
  }
  G4HadronicProcessStore::Instance()->PrintInfo(&p);
}

Referenced by G4ChargeExchangeProcess::BuildPhysicsTable().

CheckEnergyMomentumConservation()

void G4HadronicProcess::CheckEnergyMomentumConservation ( const G4Track & aTrack, const G4Nucleus & aNucleus )

protected

Definition at line 679 of file G4HadronicProcess.cc.

{
  G4int target_A=aNucleus.GetA_asInt();
  G4int target_Z=aNucleus.GetZ_asInt();
  G4double targetMass = G4NucleiProperties::GetNuclearMass(target_A,target_Z);
  G4LorentzVector target4mom(0, 0, 0, targetMass 
                 + nICelectrons*CLHEP::electron_mass_c2);
 
  G4LorentzVector projectile4mom = aTrack.GetDynamicParticle()->Get4Momentum();
  G4int track_A = aTrack.GetDefinition()->GetBaryonNumber();
  G4int track_Z = G4lrint(aTrack.GetDefinition()->GetPDGCharge());
 
  G4int initial_A = target_A + track_A;
  G4int initial_Z = target_Z + track_Z - nICelectrons;
 
  G4LorentzVector initial4mom = projectile4mom + target4mom;
 
  // Compute final-state momentum for scattering and "do nothing" results
  G4LorentzVector final4mom;
  G4int final_A(0), final_Z(0);
 
  G4int nSec = theTotalResult->GetNumberOfSecondaries();
  if (theTotalResult->GetTrackStatus() != fStopAndKill) {  // If it is Alive
    // Either interaction didn't complete, returned "do nothing" state
    //  or    the primary survived the interaction (e.g. electro-nucleus )
 
    // Interaction didn't complete, returned "do nothing" state
    //   - or suppressed recoil  (e.g. Neutron elastic )
    final4mom = initial4mom;
    final_A = initial_A;
    final_Z = initial_Z;
    if (nSec > 0) {
      // The primary remains in final state (e.g. electro-nucleus )
      // Use the final energy / momentum
      const G4ThreeVector& v = *theTotalResult->GetMomentumDirection();
      G4double ekin = theTotalResult->GetEnergy();
      G4double mass = aTrack.GetDefinition()->GetPDGMass();
      G4double ptot = std::sqrt(ekin*(ekin + 2*mass));
      final4mom.set(ptot*v.x(), ptot*v.y(), ptot*v.z(), mass + ekin);
      final_A = track_A;
      final_Z = track_Z;
      // Expect that the target nucleus will have interacted,
      //  and its products, including recoil, will be included in secondaries.
    }
  }
  if( nSec > 0 ) {
    G4Track* sec;
 
    for (G4int i = 0; i < nSec; i++) {
      sec = theTotalResult->GetSecondary(i);
      final4mom += sec->GetDynamicParticle()->Get4Momentum();
      final_A += sec->GetDefinition()->GetBaryonNumber();
      final_Z += G4lrint(sec->GetDefinition()->GetPDGCharge());
    }
  }
 
  // Get level-checking information (used to cut-off relative checks)
  G4String processName = GetProcessName();
  G4HadronicInteraction* theModel = GetHadronicInteraction();
  G4String modelName("none");
  if (theModel) modelName = theModel->GetModelName();
  std::pair<G4double, G4double> checkLevels = epCheckLevels;
  if (!levelsSetByProcess) {
    if (theModel) checkLevels = theModel->GetEnergyMomentumCheckLevels();
    checkLevels.first= std::min(checkLevels.first,  epCheckLevels.first);
    checkLevels.second=std::min(checkLevels.second, epCheckLevels.second);
  }
 
  // Compute absolute total-energy difference, and relative kinetic-energy
  G4bool checkRelative = (aTrack.GetKineticEnergy() > checkLevels.second);
 
  G4LorentzVector diff = initial4mom - final4mom;
  G4double absolute = diff.e();
  G4double relative = checkRelative ? absolute/aTrack.GetKineticEnergy() : 0.;
 
  G4double absolute_mom = diff.vect().mag();
  G4double relative_mom = checkRelative ? absolute_mom/aTrack.GetMomentum().mag() : 0.;
 
  // Evaluate relative and absolute conservation
  G4bool relPass = true;
  G4String relResult = "pass";
  if (  std::abs(relative) > checkLevels.first
     || std::abs(relative_mom) > checkLevels.first) {
    relPass = false;
    relResult = checkRelative ? "fail" : "N/A";
  }
 
  G4bool absPass = true;
  G4String absResult = "pass";
  if (   std::abs(absolute) > checkLevels.second
      || std::abs(absolute_mom) > checkLevels.second ) {
    absPass = false ;
    absResult = "fail";
  }
 
  G4bool chargePass = true;
  G4String chargeResult = "pass";
  if (   (initial_A-final_A)!=0
      || (initial_Z-final_Z)!=0 ) {
    chargePass = checkLevels.second < DBL_MAX ? false : true;
    chargeResult = "fail";
   }
 
  G4bool conservationPass = (relPass || absPass) && chargePass;
 
  std::stringstream Myout;
  G4bool Myout_notempty(false);
  // Options for level of reporting detail:
  //  0. off
  //  1. report only when E/p not conserved
  //  2. report regardless of E/p conservation
  //  3. report only when E/p not conserved, with model names, process names, and limits
  //  4. report regardless of E/p conservation, with model names, process names, and limits
  //  negative -1.., as above, but send output to stderr
 
  if(   std::abs(epReportLevel) == 4
    ||  ( std::abs(epReportLevel) == 3 && ! conservationPass ) ){
      Myout << " Process: " << processName << " , Model: " <<  modelName << G4endl;
      Myout << " Primary: " << aTrack.GetParticleDefinition()->GetParticleName()
            << " (" << aTrack.GetParticleDefinition()->GetPDGEncoding() << "),"
            << " E= " <<  aTrack.GetDynamicParticle()->Get4Momentum().e()
        << ", target nucleus (" << aNucleus.GetZ_asInt() << ","
        << aNucleus.GetA_asInt() << ")" << G4endl;
      Myout_notempty=true;
  }
  if (  std::abs(epReportLevel) == 4
     || std::abs(epReportLevel) == 2
     || ! conservationPass ){
 
      Myout << "   "<< relResult  <<" relative, limit " << checkLevels.first << ", values E/T(0) = "
             << relative << " p/p(0)= " << relative_mom  << G4endl;
      Myout << "   "<< absResult << " absolute, limit (MeV) " << checkLevels.second/MeV << ", values E / p (MeV) = "
             << absolute/MeV << " / " << absolute_mom/MeV << " 3mom: " << (diff.vect())*1./MeV <<  G4endl;
      Myout << "   "<< chargeResult << " charge/baryon number balance " << (initial_Z-final_Z) << " / " << (initial_A-final_A) << " "<<  G4endl;
      Myout_notempty=true;
 
  }
  Myout.flush();
  if ( Myout_notempty ) {
     if (epReportLevel > 0)      G4cout << Myout.str()<< G4endl;
     else if (epReportLevel < 0) G4cerr << Myout.str()<< G4endl;
  }
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronElasticProcess::PostStepDoIt(), and PostStepDoIt().

CheckResult()

G4HadFinalState * G4HadronicProcess::CheckResult ( const G4HadProjectile & thePro, const G4Nucleus & targetNucleus, G4HadFinalState * result )

protected

Definition at line 588 of file G4HadronicProcess.cc.

{
  // check for catastrophic energy non-conservation
  // to re-sample the interaction
  G4HadronicInteraction * theModel = GetHadronicInteraction();
  G4double nuclearMass(0);
  if (nullptr != theModel) {
 
    // Compute final-state total energy
    G4double finalE(0.);
    G4int nSec = (G4int)result->GetNumberOfSecondaries();
 
    nuclearMass = G4NucleiProperties::GetNuclearMass(aNucleus.GetA_asInt(),
                             aNucleus.GetZ_asInt());
    if (result->GetStatusChange() != stopAndKill) {
      // Interaction didn't complete, returned "do nothing" state 
      // and reset nucleus or the primary survived the interaction 
      // (e.g. electro-nuclear ) => keep  nucleus
      finalE=result->GetLocalEnergyDeposit() +
             aPro.GetDefinition()->GetPDGMass() + result->GetEnergyChange();
      if( nSec == 0 ){
         // Since there are no secondaries, there is no recoil nucleus.
         // To check energy balance we must neglect the initial nucleus too.
        nuclearMass=0.0;
      }
    }
    for (G4int i = 0; i < nSec; ++i) {
      G4DynamicParticle *pdyn=result->GetSecondary(i)->GetParticle();
      finalE += pdyn->GetTotalEnergy();
      G4double mass_pdg=pdyn->GetDefinition()->GetPDGMass();
      G4double mass_dyn=pdyn->GetMass();
      if ( std::abs(mass_pdg - mass_dyn) > 0.1*mass_pdg + 1.*MeV ) {
        // If it is shortlived, then a difference less than 3 times the width is acceptable
        if ( pdyn->GetDefinition()->IsShortLived()  &&
             std::abs(mass_pdg - mass_dyn) < 3.0*pdyn->GetDefinition()->GetPDGWidth() ) {
          continue;
        }
    result->Clear();
    result = nullptr;
    G4ExceptionDescription desc;
    desc << "Warning: Secondary with off-shell dynamic mass detected:  " 
         << G4endl
         << " " << pdyn->GetDefinition()->GetParticleName()
         << ", PDG mass: " << mass_pdg << ", dynamic mass: "
         << mass_dyn << G4endl
         << (epReportLevel<0 ? "abort the event" 
         : "re-sample the interaction") << G4endl
         << " Process / Model: " <<  GetProcessName()<< " / "
         << theModel->GetModelName() << G4endl
         << " Primary: " << aPro.GetDefinition()->GetParticleName()
         << " (" << aPro.GetDefinition()->GetPDGEncoding() << "), "
         << " E= " <<  aPro.Get4Momentum().e()
         << ", target nucleus (" << aNucleus.GetZ_asInt() << ", "
         << aNucleus.GetA_asInt() << ")" << G4endl;
    G4Exception("G4HadronicProcess:CheckResult()", "had012",
            epReportLevel<0 ? EventMustBeAborted : JustWarning,desc);
    // must return here.....
    return result;
      }
    }
    G4double deltaE= nuclearMass +  aPro.GetTotalEnergy() -  finalE;
 
    std::pair<G4double, G4double> checkLevels = 
      theModel->GetFatalEnergyCheckLevels();    // (relative, absolute)
    if (std::abs(deltaE) > checkLevels.second && 
        std::abs(deltaE) > checkLevels.first*aPro.GetKineticEnergy()){
      // do not delete result, this is a pointer to a data member;
      result->Clear();
      result = nullptr;
      G4ExceptionDescription desc;
      desc << "Warning: Bad energy non-conservation detected, will "
       << (epReportLevel<0 ? "abort the event" 
           :  "re-sample the interaction") << G4endl
       << " Process / Model: " <<  GetProcessName()<< " / " 
       << theModel->GetModelName() << G4endl
       << " Primary: " << aPro.GetDefinition()->GetParticleName()
       << " (" << aPro.GetDefinition()->GetPDGEncoding() << "), "
       << " E= " <<  aPro.Get4Momentum().e()
       << ", target nucleus (" << aNucleus.GetZ_asInt() << ", "
       << aNucleus.GetA_asInt() << ")" << G4endl
       << " E(initial - final) = " << deltaE << " MeV." << G4endl;
      G4Exception("G4HadronicProcess:CheckResult()", "had012", 
          epReportLevel<0 ? EventMustBeAborted : JustWarning,desc);
    }
  }
  return result;
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronElasticProcess::PostStepDoIt(), and PostStepDoIt().

ChooseHadronicInteraction()

G4HadronicInteraction * G4HadronicProcess::ChooseHadronicInteraction ( const G4HadProjectile & aHadProjectile, G4Nucleus & aTargetNucleus, const G4Material * aMaterial, const G4Element * anElement )

inlineprotected

Definition at line 349 of file G4HadronicProcess.hh.

{ 
  return theEnergyRangeManager.GetHadronicInteraction(aHadProjectile, 
                                                      aTargetNucleus,
                                                      aMaterial,anElement);
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronElasticProcess::PostStepDoIt(), and PostStepDoIt().

ComputeCrossSection()

G4double G4HadronicProcess::ComputeCrossSection	(	const G4ParticleDefinition *	part,
		const G4Material *	mat,
		const G4double	kinEnergy )

Definition at line 877 of file G4HadronicProcess.cc.

{
  auto dp = new G4DynamicParticle(part, unitVector, kinEnergy);
  G4double xs = theCrossSectionDataStore->ComputeCrossSection(dp, mat);
  delete dp;
  return xs;
}

Referenced by G4HadXSHelper::FillPeaksStructure(), and G4HadXSHelper::FindCrossSectionMax().

CrossSectionFactor()

G4double G4HadronicProcess::CrossSectionFactor ( ) const

inline

Definition at line 301 of file G4HadronicProcess.hh.

{ 
  return aScaleFactor;
}

CrossSectionType()

G4HadXSType G4HadronicProcess::CrossSectionType ( ) const

inline

Definition at line 290 of file G4HadronicProcess.hh.

{ 
  return fXSType;
}

DumpPhysicsTable()

void G4HadronicProcess::DumpPhysicsTable

(

const G4ParticleDefinition &

p

)

Definition at line 849 of file G4HadronicProcess.cc.

{ 
  theCrossSectionDataStore->DumpPhysicsTable(p); 
}

DumpState()

void G4HadronicProcess::DumpState ( const G4Track & aTrack, const G4String & method, G4ExceptionDescription & ed )

protected

Definition at line 824 of file G4HadronicProcess.cc.

{
  ed << "Unrecoverable error in the method " << method << " of "
     << GetProcessName() << G4endl;
  ed << "TrackID= "<< aTrack.GetTrackID() << "  ParentID= "
     << aTrack.GetParentID()
     << "  " << aTrack.GetParticleDefinition()->GetParticleName()
     << G4endl;
  ed << "Ekin(GeV)= " << aTrack.GetKineticEnergy()/CLHEP::GeV
     << ";  direction= " << aTrack.GetMomentumDirection() << G4endl;
  ed << "Position(mm)= " << aTrack.GetPosition()/CLHEP::mm << ";";
 
  if (aTrack.GetMaterial()) {
    ed << "  material " << aTrack.GetMaterial()->GetName();
  }
  ed << G4endl;
 
  if (aTrack.GetVolume()) {
    ed << "PhysicalVolume  <" << aTrack.GetVolume()->GetName()
       << ">" << G4endl;
  }
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), and G4TauNeutrinoNucleusProcess::PostStepDoIt().

EnergyOfCrossSectionMax()

std::vector< G4double > * G4HadronicProcess::EnergyOfCrossSectionMax ( ) const

inline

Definition at line 344 of file G4HadronicProcess.hh.

{
  return theEnergyOfCrossSectionMax;
}

FillResult()

void G4HadronicProcess::FillResult ( G4HadFinalState * aR, const G4Track & aT )

protected

Definition at line 482 of file G4HadronicProcess.cc.

{
  theTotalResult->ProposeLocalEnergyDeposit(aR->GetLocalEnergyDeposit());
  const G4ThreeVector& dir = aT.GetMomentumDirection();
 
  G4double efinal = std::max(aR->GetEnergyChange(), 0.0);
 
  // check status of primary
  if(aR->GetStatusChange() == stopAndKill) {
    theTotalResult->ProposeTrackStatus(fStopAndKill);
    theTotalResult->ProposeEnergy( 0.0 );
 
    // check its final energy
  } else if(0.0 == efinal) {
    theTotalResult->ProposeEnergy( 0.0 );
    if(aT.GetParticleDefinition()->GetProcessManager()
       ->GetAtRestProcessVector()->size() > 0)
         { theTotalResult->ProposeTrackStatus(fStopButAlive); }
    else { theTotalResult->ProposeTrackStatus(fStopAndKill); }
 
    // primary is not killed apply rotation and Lorentz transformation
  } else  {
    theTotalResult->ProposeTrackStatus(fAlive);
    G4ThreeVector newDir = aR->GetMomentumChange();
    newDir.rotateUz(dir);
    theTotalResult->ProposeMomentumDirection(newDir);
    theTotalResult->ProposeEnergy(efinal);
  }
  //G4cout << "FillResult: Efinal= " << efinal << " status= " 
  //     << theTotalResult->GetTrackStatus() 
  //     << "  fKill= " << fStopAndKill << G4endl;
 
  // check secondaries 
  nICelectrons = 0;
  G4int nSec = (G4int)aR->GetNumberOfSecondaries();
  theTotalResult->SetNumberOfSecondaries(nSec);
  G4double time0 = aT.GetGlobalTime();
 
  for (G4int i = 0; i < nSec; ++i) {
    G4DynamicParticle* dynParticle = aR->GetSecondary(i)->GetParticle();
 
    // apply rotation
    G4ThreeVector newDir = dynParticle->GetMomentumDirection();
    newDir.rotateUz(dir);
    dynParticle->SetMomentumDirection(newDir);
 
    // check if secondary is on the mass shell
    const G4ParticleDefinition* part = dynParticle->GetDefinition();
    G4double mass = part->GetPDGMass();
    G4double dmass= dynParticle->GetMass();
    const G4double delta_mass_lim = 1.0*CLHEP::keV;
    const G4double delta_ekin = 0.001*CLHEP::eV;
    if(std::abs(dmass - mass) > delta_mass_lim) {
      G4double e =
        std::max(dynParticle->GetKineticEnergy() + dmass - mass, delta_ekin);
      if(verboseLevel > 1) {
    G4ExceptionDescription ed;
    ed << "TrackID= "<< aT.GetTrackID()
       << "  " << aT.GetParticleDefinition()->GetParticleName()
       << " Target Z= " << targetNucleus.GetZ_asInt() << "  A= "
       << targetNucleus.GetA_asInt() 
       << " Ekin(GeV)= " << aT.GetKineticEnergy()/CLHEP::GeV
       << "\n Secondary is out of mass shell: " << part->GetParticleName()
       << "  EkinNew(MeV)= " << e  
       << " DeltaMass(MeV)= " << dmass - mass << G4endl;
    G4Exception("G4HadronicProcess::FillResults", "had012", JustWarning, ed);
      }
      dynParticle->SetKineticEnergy(e);
      dynParticle->SetMass(mass);               
    }
    G4int idModel = aR->GetSecondary(i)->GetCreatorModelID(); 
    if(part->GetPDGEncoding() == 11) { ++nICelectrons; }
      
    // time of interaction starts from zero + global time
    G4double time = std::max(aR->GetSecondary(i)->GetTime(), 0.0) + time0;
 
    G4Track* track = new G4Track(dynParticle, time, aT.GetPosition());
    track->SetCreatorModelID(idModel);
    track->SetParentResonanceDef(aR->GetSecondary(i)->GetParentResonanceDef());
    track->SetParentResonanceID(aR->GetSecondary(i)->GetParentResonanceID());
    G4double newWeight = fWeight*aR->GetSecondary(i)->GetWeight();
    track->SetWeight(newWeight);
    track->SetTouchableHandle(aT.GetTouchableHandle());
    theTotalResult->AddSecondary(track);
  }
  aR->Clear();
  // G4cout << "FillResults done nICe= " << nICelectrons << G4endl;
}

Referenced by G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), and G4TauNeutrinoNucleusProcess::PostStepDoIt().

GetCrossSectionDataStore()

G4CrossSectionDataStore * G4HadronicProcess::GetCrossSectionDataStore ( )

inline

Definition at line 332 of file G4HadronicProcess.hh.

{
  return theCrossSectionDataStore;
}

Referenced by G4ChargeExchangeProcess::BuildPhysicsTable(), G4ElectronNuclearProcess::G4ElectronNuclearProcess(), G4PositronNuclearProcess::G4PositronNuclearProcess(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4TauNeutrinoNucleusProcess::GetMeanFreePath(), G4HadronPhysicsShielding::Neutron(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4HadronicProcessStore::PrintHtml(), G4GammaGeneralProcess::SelectHadProcess(), G4NeutronGeneralProcess::SetCaptureProcess(), G4NeutronGeneralProcess::SetElasticProcess(), and G4NeutronGeneralProcess::SetInelasticProcess().

GetElementCrossSection()

G4double G4HadronicProcess::GetElementCrossSection	(	const G4DynamicParticle *	part,
		const G4Element *	elm,
		const G4Material *	mat = nullptr )

Definition at line 144 of file G4HadronicProcess.cc.

{
  if(nullptr == mat)
  {
    static const G4int nmax = 5;
    if(nMatWarn < nmax) {
      ++nMatWarn;
      G4ExceptionDescription ed;
      ed << "Cannot compute Element x-section for " << GetProcessName()
     << " because no material defined \n"
     << " Please, specify material pointer or define simple material"
     << " for Z= " << elm->GetZasInt();
      G4Exception("G4HadronicProcess::GetElementCrossSection", "had066", 
          JustWarning, ed);
    }
  }
  return theCrossSectionDataStore->GetCrossSection(dp, elm, mat);
}

Referenced by G4HadronicProcessStore::GetCaptureCrossSectionPerAtom(), G4HadronicProcessStore::GetChargeExchangeCrossSectionPerAtom(), G4HadronicProcessStore::GetElasticCrossSectionPerAtom(), G4HadronicProcessStore::GetFissionCrossSectionPerAtom(), G4HadronicProcessStore::GetInelasticCrossSectionPerAtom(), and GetMicroscopicCrossSection().

GetEnergyMomentumCheckLevels()

std::pair< G4double, G4double > G4HadronicProcess::GetEnergyMomentumCheckLevels ( ) const

inline

Definition at line 326 of file G4HadronicProcess.hh.

{ 
  return epCheckLevels;
}

GetHadronicInteraction()

G4HadronicInteraction * G4HadronicProcess::GetHadronicInteraction ( ) const

inline

Definition at line 273 of file G4HadronicProcess.hh.

{ 
  return theInteraction;
}

Referenced by CheckEnergyMomentumConservation(), and CheckResult().

GetHadronicInteractionList()

std::vector< G4HadronicInteraction * > & G4HadronicProcess::GetHadronicInteractionList

(

)

Definition at line 860 of file G4HadronicProcess.cc.

{ 
  return theEnergyRangeManager.GetHadronicInteractionList(); 
}

Referenced by G4HadronElasticPhysicsHPT::ConstructProcess(), G4ThermalNeutrons::ConstructProcess(), G4URRNeutrons::ConstructProcess(), G4HadronElasticPhysics::GetElasticModel(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), and G4TauNeutrinoNucleusProcess::PostStepDoIt().

GetHadronicModel()

G4HadronicInteraction * G4HadronicProcess::GetHadronicModel

(

const G4String &

modelName

)

Definition at line 866 of file G4HadronicProcess.cc.

{ 
  std::vector<G4HadronicInteraction*>& list
        = theEnergyRangeManager.GetHadronicInteractionList();
  for (auto & mod : list) {
    if (mod->GetModelName() == modelName) return mod;
  }
  return nullptr;
}

GetLastCrossSection()

G4double G4HadronicProcess::GetLastCrossSection ( )

inlineprotected

Definition at line 365 of file G4HadronicProcess.hh.

{ 
  return theLastCrossSection;
}

GetMeanFreePath()

G4double G4HadronicProcess::GetMeanFreePath ( const G4Track & aTrack, G4double , G4ForceCondition *  )

overridevirtual

Implements G4VDiscreteProcess.

Reimplemented in G4MuNeutrinoNucleusProcess, G4NeutrinoElectronProcess, G4NeutronGeneralProcess, and G4TauNeutrinoNucleusProcess.

Definition at line 299 of file G4HadronicProcess.cc.

{
  G4double xs = aScaleFactor*theCrossSectionDataStore
     ->ComputeCrossSection(aTrack.GetDynamicParticle(),aTrack.GetMaterial());
  return (xs > 0.0) ? 1.0/xs : DBL_MAX;
}

GetMicroscopicCrossSection()

G4double G4HadronicProcess::GetMicroscopicCrossSection ( const G4DynamicParticle * part, const G4Element * elm, const G4Material * mat = nullptr )

inline

Definition at line 264 of file G4HadronicProcess.hh.

{ 
  return GetElementCrossSection(part, elm, mat);
}

GetTargetIsotope()

const G4Isotope * G4HadronicProcess::GetTargetIsotope ( )

inline

Definition at line 284 of file G4HadronicProcess.hh.

{ 
  return targetNucleus.GetIsotope();
}

GetTargetNucleus()

const G4Nucleus * G4HadronicProcess::GetTargetNucleus ( ) const

inline

Definition at line 279 of file G4HadronicProcess.hh.

{
  return &targetNucleus;
}

GetTargetNucleusPointer()

G4Nucleus * G4HadronicProcess::GetTargetNucleusPointer ( )

inline

Definition at line 360 of file G4HadronicProcess.hh.

{ 
  return &targetNucleus;
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), and G4TauNeutrinoNucleusProcess::PostStepDoIt().

MultiplyCrossSectionBy()

void G4HadronicProcess::MultiplyCrossSectionBy

(

G4double

factor

)

Definition at line 571 of file G4HadronicProcess.cc.

{
  BiasCrossSectionByFactor(factor);
}

Referenced by G4HadProcesses::BuildNeutronElastic(), G4HadProcesses::BuildNeutronInelasticAndCapture(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronInelasticQBBC_ABLA::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4HadronPhysicsFTF_BIC::Kaon(), G4HadronPhysicsFTFP_BERT::Kaon(), G4HadronPhysicsINCLXX::Kaon(), G4HadronPhysicsFTF_BIC::Neutron(), G4HadronPhysicsFTFP_BERT::Neutron(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsShielding::Neutron(), G4HadronPhysicsQGSP_BERT::PiK(), G4HadronPhysicsFTF_BIC::Pion(), G4HadronPhysicsFTFP_BERT::Pion(), G4HadronPhysicsINCLXX::Pion(), G4HadronPhysicsFTF_BIC::Proton(), G4HadronPhysicsFTFP_BERT::Proton(), G4HadronPhysicsINCLXX::Proton(), and G4HadronPhysicsNuBeam::Proton().

operator=()

G4HadronicProcess & G4HadronicProcess::operator= ( const G4HadronicProcess & right )

delete

PostStepDoIt()

G4VParticleChange * G4HadronicProcess::PostStepDoIt ( const G4Track & aTrack, const G4Step & aStep )

overridevirtual

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4MuNeutrinoNucleusProcess, G4NeutrinoElectronProcess, G4NeutronGeneralProcess, and G4TauNeutrinoNucleusProcess.

Definition at line 309 of file G4HadronicProcess.cc.

{
  theNumberOfInteractionLengthLeft = -1.0;
 
  //G4cout << "PostStepDoIt " << aTrack.GetDefinition()->GetParticleName()
  //     << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
  // if primary is not Alive then do nothing
  theTotalResult->Clear();
  theTotalResult->Initialize(aTrack);
  fWeight = aTrack.GetWeight();
  theTotalResult->ProposeWeight(fWeight);
  if(aTrack.GetTrackStatus() != fAlive) { return theTotalResult; }
 
  // Find cross section at end of step and check if <= 0
  //
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  const G4Material* aMaterial = aTrack.GetMaterial();
 
  // check only for charged particles
  if(fXSType != fHadNoIntegral) {
    mfpKinEnergy = DBL_MAX;
    G4double xs = aScaleFactor*
      theCrossSectionDataStore->ComputeCrossSection(aParticle,aMaterial);
    //G4cout << "xs=" << xs << " xs0=" << theLastCrossSection
    //     << "  " << aMaterial->GetName() << G4endl;
    if(xs < theLastCrossSection*G4UniformRand()) {
      // No interaction
      return theTotalResult;
    }    
  }
 
  const G4Element* anElement = 
    theCrossSectionDataStore->SampleZandA(aParticle,aMaterial,targetNucleus);
 
  // Next check for illegal track status
  //
  if (aTrack.GetTrackStatus() != fAlive && 
      aTrack.GetTrackStatus() != fSuspend) {
    if (aTrack.GetTrackStatus() == fStopAndKill ||
        aTrack.GetTrackStatus() == fKillTrackAndSecondaries ||
        aTrack.GetTrackStatus() == fPostponeToNextEvent) {
      G4ExceptionDescription ed;
      ed << "G4HadronicProcess: track in unusable state - "
     << aTrack.GetTrackStatus() << G4endl;
      ed << "G4HadronicProcess: returning unchanged track " << G4endl;
      DumpState(aTrack,"PostStepDoIt",ed);
      G4Exception("G4HadronicProcess::PostStepDoIt", "had004", JustWarning, ed);
    }
    // No warning for fStopButAlive which is a legal status here
    return theTotalResult;
  }
 
  // Initialize the hadronic projectile from the track
  thePro.Initialise(aTrack);
 
  theInteraction = ChooseHadronicInteraction(thePro, targetNucleus, 
                                             aMaterial, anElement);
  if(nullptr == theInteraction) {
    G4ExceptionDescription ed;
    ed << "Target element "<<anElement->GetName()<<"  Z= "
       << targetNucleus.GetZ_asInt() << "  A= "
       << targetNucleus.GetA_asInt() << G4endl;
    DumpState(aTrack,"ChooseHadronicInteraction",ed);
    ed << " No HadronicInteraction found out" << G4endl;
    G4Exception("G4HadronicProcess::PostStepDoIt", "had005",
                FatalException, ed);
    return theTotalResult;
  }
 
  G4HadFinalState* result = nullptr;
  G4int reentryCount = 0;
  /*
  G4cout << "### " << aParticle->GetDefinition()->GetParticleName() 
     << "  Ekin(MeV)= " << aParticle->GetKineticEnergy()
     << "  Z= " << targetNucleus.GetZ_asInt() 
     << "  A= " << targetNucleus.GetA_asInt()
     << "  by " << theInteraction->GetModelName() 
     << G4endl;
  */
  do
  {
    try
    {
      // Call the interaction
      result = theInteraction->ApplyYourself( thePro, targetNucleus);
      ++reentryCount;
    }
    catch(G4HadronicException & aR)
    {
      G4ExceptionDescription ed;
      aR.Report(ed);
      ed << "Call for " << theInteraction->GetModelName() << G4endl;
      ed << "Target element "<<anElement->GetName()<<"  Z= "
     << targetNucleus.GetZ_asInt()
     << "  A= " << targetNucleus.GetA_asInt() << G4endl;
      DumpState(aTrack,"ApplyYourself",ed);
      ed << " ApplyYourself failed" << G4endl;
      G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
          ed);
    }
 
    // Check the result for catastrophic energy non-conservation
    result = CheckResult(thePro, targetNucleus, result);
 
    if(reentryCount>100) {
      G4ExceptionDescription ed;
      ed << "Call for " << theInteraction->GetModelName() << G4endl;
      ed << "Target element "<<anElement->GetName()<<"  Z= "
     << targetNucleus.GetZ_asInt()
     << "  A= " << targetNucleus.GetA_asInt() << G4endl;
      DumpState(aTrack,"ApplyYourself",ed);
      ed << " ApplyYourself does not completed after 100 attempts" << G4endl;
      G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
          ed);
    }
  }
  while(!result);  /* Loop checking, 30-Oct-2015, G.Folger */
 
  // Check whether kaon0 or anti_kaon0 are present between the secondaries: 
  // if this is the case, transform them into either kaon0S or kaon0L,
  // with equal, 50% probability, keeping their dynamical masses (and
  // the other kinematical properties). 
  // When this happens - very rarely - a "JustWarning" exception is thrown.
  // Because Fluka-Cern produces kaon0 and anti_kaon0, we reduce the number
  // of warnings to max 1 per thread.
  G4int nSec = (G4int)result->GetNumberOfSecondaries();
  if ( nSec > 0 ) {
    for ( G4int i = 0; i < nSec; ++i ) {
      auto dynamicParticle = result->GetSecondary(i)->GetParticle();
      auto part = dynamicParticle->GetParticleDefinition();
      if ( part == G4KaonZero::Definition() || 
           part == G4AntiKaonZero::Definition() ) {
        G4ParticleDefinition* newPart;
        if ( G4UniformRand() > 0.5 ) { newPart = G4KaonZeroShort::Definition(); }
        else { newPart = G4KaonZeroLong::Definition(); }
        dynamicParticle->SetDefinition( newPart );
      }
    }
  }
 
  result->SetTrafoToLab(thePro.GetTrafoToLab());
  FillResult(result, aTrack);
 
  if (epReportLevel != 0) {
    CheckEnergyMomentumConservation(aTrack, targetNucleus);
  }
  //G4cout << "PostStepDoIt done nICelectrons= " << nICelectrons << G4endl;
  return theTotalResult;
}

PostStepGetPhysicalInteractionLength()

G4double G4HadronicProcess::PostStepGetPhysicalInteractionLength ( const G4Track & track, G4double previousStepSize, G4ForceCondition * condition )

overridevirtual

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4HadronStoppingProcess, G4MuNeutrinoNucleusProcess, G4NeutrinoElectronProcess, G4NeutronGeneralProcess, and G4TauNeutrinoNucleusProcess.

Definition at line 263 of file G4HadronicProcess.cc.

{
  *condition = NotForced;
 
  const G4Material* mat = track.GetMaterial();
  if(mat != currentMat) {
    currentMat = mat;
    mfpKinEnergy = DBL_MAX;
    matIdx = (G4int)track.GetMaterial()->GetIndex();
  }
  UpdateCrossSectionAndMFP(track.GetKineticEnergy());
 
  // zero cross section
  if(theLastCrossSection <= 0.0) { 
    theNumberOfInteractionLengthLeft = -1.0;
    currentInteractionLength = DBL_MAX;
    return DBL_MAX;
  }
 
  // non-zero cross section
  if (theNumberOfInteractionLengthLeft < 0.0) {
    theNumberOfInteractionLengthLeft = -G4Log( G4UniformRand() );
    theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
  } else {
    theNumberOfInteractionLengthLeft -= 
      previousStepSize/currentInteractionLength;
    theNumberOfInteractionLengthLeft = 
      std::max(theNumberOfInteractionLengthLeft, 0.0);
  }
  currentInteractionLength = theMFP;
  return theNumberOfInteractionLengthLeft*theMFP;
}

PreparePhysicsTable()

void G4HadronicProcess::PreparePhysicsTable ( const G4ParticleDefinition & p )

overridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4NeutronGeneralProcess.

Definition at line 165 of file G4HadronicProcess.cc.

{
  if(nullptr == firstParticle) { firstParticle = &p; }
  theProcessStore->RegisterParticle(this, &p);
}

ProcessDescription()

void G4HadronicProcess::ProcessDescription ( std::ostream & outFile ) const

overridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, G4MuNeutrinoNucleusProcess, G4MuonMinusCapture, G4MuonNuclearProcess, G4NeutrinoElectronProcess, G4NeutronCaptureProcess, G4NeutronFissionProcess, G4NeutronGeneralProcess, G4PositronNuclearProcess, and G4TauNeutrinoNucleusProcess.

Definition at line 459 of file G4HadronicProcess.cc.

{
  outFile << "The description for this process has not been written yet.\n";
}

Referenced by G4HadronicProcessStore::PrintHtml().

RegisterMe()

void G4HadronicProcess::RegisterMe

(

G4HadronicInteraction *

a

)

Definition at line 136 of file G4HadronicProcess.cc.

{
  if(nullptr == a) { return; }
  theEnergyRangeManager.RegisterMe( a );
  G4HadronicProcessStore::Instance()->RegisterInteraction(this, a);
}

Referenced by 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(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::Build(), G4NeutronPHPBuilder::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(), G4QGSPProtonBuilder::Build(), G4TritonPHPBuilder::Build(), G4HadProcesses::BuildNeutronInelasticAndCapture(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsHPT::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronElasticPhysicsVI::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronInelasticQBBC_ABLA::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4ThermalNeutrons::ConstructProcess(), G4URRNeutrons::ConstructProcess(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4HadronicAbsorptionINCLXX::G4HadronicAbsorptionINCLXX(), G4MuonMinusCapture::G4MuonMinusCapture(), G4HadronPhysicsFTF_BIC::Neutron(), G4HadronPhysicsFTFP_BERT::Neutron(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), and G4HadronPhysicsShielding::Neutron().

SetCrossSectionType()

void G4HadronicProcess::SetCrossSectionType ( G4HadXSType val )

inline

Definition at line 296 of file G4HadronicProcess.hh.

{ 
  fXSType = val;
}

SetEnergyMomentumCheckLevels()

void G4HadronicProcess::SetEnergyMomentumCheckLevels ( G4double relativeLevel, G4double absoluteLevel )

inline

Definition at line 317 of file G4HadronicProcess.hh.

{ 
  epCheckLevels.first = relativeLevel;
  epCheckLevels.second = absoluteLevel;
  levelsSetByProcess = true;
}

SetEpReportLevel()

void G4HadronicProcess::SetEpReportLevel ( G4int level )

inline

Definition at line 311 of file G4HadronicProcess.hh.

{ 
  epReportLevel = level;
}

SetIntegral()

void G4HadronicProcess::SetIntegral ( G4bool val )

inline

Definition at line 306 of file G4HadronicProcess.hh.

{ 
  useIntegralXS = val;
}

StartTracking()

void G4HadronicProcess::StartTracking ( G4Track * track )

overridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4NeutronGeneralProcess.

Definition at line 255 of file G4HadronicProcess.cc.

{
  currentMat = nullptr;
  currentParticle = track->GetDefinition();
  fDynParticle = track->GetDynamicParticle();
  theNumberOfInteractionLengthLeft = -1.0;
}

TwoPeaksXS()

std::vector< G4TwoPeaksHadXS * > * G4HadronicProcess::TwoPeaksXS ( ) const

inline

Definition at line 338 of file G4HadronicProcess.hh.

{ 
  return fXSpeaks;
}

Member Data Documentation

aScaleFactor

G4double G4HadronicProcess::aScaleFactor = 1.0

protected

Definition at line 221 of file G4HadronicProcess.hh.

Referenced by BiasCrossSectionByFactor(), CrossSectionFactor(), GetMeanFreePath(), G4HadronElasticProcess::PostStepDoIt(), and PostStepDoIt().

epReportLevel

G4int G4HadronicProcess::epReportLevel = 0

protected

Definition at line 224 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), CheckEnergyMomentumConservation(), CheckResult(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), and SetEpReportLevel().

fWeight

G4double G4HadronicProcess::fWeight = 1.0

protected

Definition at line 220 of file G4HadronicProcess.hh.

Referenced by FillResult(), and PostStepDoIt().

fXSType

G4HadXSType G4HadronicProcess::fXSType = fHadNoIntegral

protected

Definition at line 226 of file G4HadronicProcess.hh.

Referenced by BuildPhysicsTable(), CrossSectionType(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), and SetCrossSectionType().

mfpKinEnergy

G4double G4HadronicProcess::mfpKinEnergy = DBL_MAX

protected

Definition at line 223 of file G4HadronicProcess.hh.

Referenced by G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

theCrossSectionDataStore

G4CrossSectionDataStore* G4HadronicProcess::theCrossSectionDataStore

protected

Definition at line 218 of file G4HadronicProcess.hh.

Referenced by AddDataSet(), BuildPhysicsTable(), ComputeCrossSection(), DumpPhysicsTable(), GetCrossSectionDataStore(), GetElementCrossSection(), GetMeanFreePath(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), and ~G4HadronicProcess().

theLastCrossSection

G4double G4HadronicProcess::theLastCrossSection = 0.0

protected

Definition at line 222 of file G4HadronicProcess.hh.

Referenced by GetLastCrossSection(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

thePro

G4HadProjectile G4HadronicProcess::thePro

protected

Definition at line 215 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronicProcess(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), and G4TauNeutrinoNucleusProcess::PostStepDoIt().

theTotalResult

G4ParticleChange* G4HadronicProcess::theTotalResult

protected

Definition at line 217 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), CheckEnergyMomentumConservation(), FillResult(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4NeutronGeneralProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), and ~G4HadronicProcess().

---

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

• G4HadronicProcess.hh
• G4HadronicProcess.cc