#include <G4HadronicAbsorptionFritiof.hh>

Inheritance diagram for G4HadronicAbsorptionFritiof:

Public Member Functions
void	AddDataSet (G4VCrossSectionDataSet *aDataSet)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

void	BiasCrossSectionByFactor (G4double aScale)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

G4double	CrossSectionFactor () const

virtual void	DumpInfo () const

void	DumpPhysicsTable (const G4ParticleDefinition &p)

virtual void	EndTracking ()

	G4HadronicAbsorptionFritiof (G4ParticleDefinition *pdef=0)

G4CrossSectionDataStore *	GetCrossSectionDataStore ()

G4double	GetCurrentInteractionLength () const

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

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

G4HadronicInteraction *	GetHadronicInteraction () const

std::vector< G4HadronicInteraction * > &	GetHadronicInteractionList ()

G4HadronicInteraction *	GetHadronicModel (const G4String &)

const G4VProcess *	GetMasterProcess () const

G4double	GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *) override

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

G4double	GetNumberOfInteractionLengthLeft () const

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

G4double	GetPILfactor () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

const G4Isotope *	GetTargetIsotope ()

const G4Nucleus *	GetTargetNucleus () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

void	MultiplyCrossSectionBy (G4double factor)

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

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

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

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

void	ProcessDescription (std::ostream &outFile) const

void	RegisterMe (G4HadronicInteraction *a)

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

void	SetBoundDecay (G4HadronicInteraction *ptr)

void	SetElementSelector (G4ElementSelector *ptr)

void	SetEmCascade (G4HadronicInteraction *ptr)

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

void	SetEpReportLevel (G4int level)

void	SetIntegral (G4bool val)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetVerboseLevel (G4int value)

virtual void	StartTracking (G4Track *)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual	~G4HadronicAbsorptionFritiof ()

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
void	CheckEnergyMomentumConservation (const G4Track &, const G4Nucleus &)

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

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

void	ClearNumberOfInteractionLengthLeft ()

void	DumpState (const G4Track &, const G4String &, G4ExceptionDescription &)

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

G4double	GetLastCrossSection ()

G4double	GetMeanLifeTime (const G4Track &, G4ForceCondition *)

G4Nucleus *	GetTargetNucleusPointer ()

void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

G4double	currentInteractionLength = -1.0

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4int	epReportLevel

G4double	fWeight

G4VParticleChange *	pParticleChange = nullptr

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4HadProjectile	thePro

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4ParticleChange *	theTotalResult

G4int	verboseLevel = 0

Private Member Functions
	G4HadronicAbsorptionFritiof (const G4HadronicAbsorptionFritiof &)

void	GetEnergyMomentumCheckEnvvars ()

void	InitialiseLocal ()

G4HadronicAbsorptionFritiof &	operator= (const G4HadronicAbsorptionFritiof &)

G4double	XBiasSecondaryWeight ()

G4double	XBiasSurvivalProbability ()

Private Attributes
G4double	aScaleFactor

G4int	dioID

G4int	emcID

std::pair< G4double, G4double >	epCheckLevels

G4HadronicInteraction *	fBoundDecay

G4ElementSelector *	fElementSelector

G4HadronicInteraction *	fEmCascade

G4ProcessTable *	fProcessTable = nullptr

bool	G4HadronicProcess_debug_flag

G4bool	levelsSetByProcess

G4VProcess *	masterProcessShadow = nullptr

G4int	ncID

G4int	nICelectrons

G4int	nKaonWarn

G4int	nMatWarn

G4ParticleDefinition *	pdefApplicable

G4Nucleus	targetNucleus

std::vector< G4VLeadingParticleBiasing * >	theBias

G4CrossSectionDataStore *	theCrossSectionDataStore

G4EnergyRangeManager	theEnergyRangeManager

G4double	theInitialNumberOfInteractionLength

G4HadronicInteraction *	theInteraction

G4double	theLastCrossSection

G4HadronicProcessStore *	theProcessStore

bool	useIntegralXS

Detailed Description

Definition at line 51 of file G4HadronicAbsorptionFritiof.hh.

Constructor & Destructor Documentation

◆ G4HadronicAbsorptionFritiof() [1/2]

G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof ( G4ParticleDefinition * pdef = 0 )

Definition at line 58 of file G4HadronicAbsorptionFritiof.cc.

  : G4HadronStoppingProcess( "hFritiofCaptureAtRest" ), 
    pdefApplicable( pdef ) {
  
  G4TheoFSGenerator * theModel = new G4TheoFSGenerator( "FTFP" );
  G4FTFModel * theStringModel = new G4FTFModel;
  theStringModel->SetFragmentationModel(new G4ExcitedStringDecay());
 
  // Not a cascade - goes straight to Preco
  G4HadronicInteraction* p =
    G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
  G4VPreCompoundModel * thePreEquilib = static_cast<G4VPreCompoundModel*>(p); 
  if(! thePreEquilib) { thePreEquilib = new G4PreCompoundModel; }
 
  G4GeneratorPrecompoundInterface * theCascade = 
    new G4GeneratorPrecompoundInterface( thePreEquilib ); 
 
  theModel->SetHighEnergyGenerator( theStringModel );
  theModel->SetTransport( theCascade );
 
  G4double theMin = 0.0*GeV;
  G4double theMax = G4HadronicParameters::Instance()->GetMaxEnergy();
  theModel->SetMinEnergy( theMin );
  theModel->SetMaxEnergy( theMax );
 
  RegisterMe( theModel );
}

References G4HadronicInteractionRegistry::FindModel(), G4HadronicParameters::GetMaxEnergy(), GeV, G4HadronicInteractionRegistry::Instance(), G4HadronicParameters::Instance(), G4HadronicProcess::RegisterMe(), G4VPartonStringModel::SetFragmentationModel(), G4TheoFSGenerator::SetHighEnergyGenerator(), G4HadronicInteraction::SetMaxEnergy(), G4HadronicInteraction::SetMinEnergy(), and G4TheoFSGenerator::SetTransport().

◆ ~G4HadronicAbsorptionFritiof()

G4HadronicAbsorptionFritiof::~G4HadronicAbsorptionFritiof ( )

virtual

Definition at line 87 of file G4HadronicAbsorptionFritiof.cc.

87 {

88}

◆ G4HadronicAbsorptionFritiof() [2/2]

G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof ( const G4HadronicAbsorptionFritiof & )

private

Member Function Documentation

◆ AddDataSet()

void G4HadronicProcess::AddDataSet ( G4VCrossSectionDataSet * aDataSet )

inherited

Definition at line 762 of file G4HadronicProcess.cc.

{ 
  theCrossSectionDataStore->AddDataSet(aDataSet);
}

References G4CrossSectionDataStore::AddDataSet(), and G4HadronicProcess::theCrossSectionDataStore.

◆ AlongStepDoIt()

virtual G4VParticleChange * G4VDiscreteProcess::AlongStepDoIt	(	const G4Track &	,
		const G4Step &
	)

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

93 { return 0; }

◆ AlongStepGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AlongStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	,
		G4double	,
		G4double &	,
		G4GPILSelection *
	)

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 70 of file G4VDiscreteProcess.hh.

76 { return -1.0; }

◆ AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

G4VParticleChange * G4HadronStoppingProcess::AtRestDoIt	(	const G4Track &	track,
		const G4Step &
	)

virtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 133 of file G4HadronStoppingProcess.cc.

{
  // if primary is not Alive then do nothing
  theTotalResult->Initialize(track);
 
  G4Nucleus* nucleus = GetTargetNucleusPointer();
  const G4Element* elm = fElementSelector->SelectZandA(track, nucleus);
 
  G4HadFinalState* result = 0;
  thePro.Initialise(track);
 
  // save track time an dstart capture from zero time
  thePro.SetGlobalTime(0.0);
  G4double time0 = track.GetGlobalTime();
 
  G4bool nuclearCapture = true;
 
  // Do the electromagnetic cascade in the nuclear field.
  // EM cascade should keep G4HadFinalState object,
  // because it will not be deleted at the end of this method
  //
  result = fEmCascade->ApplyYourself(thePro, *nucleus);
  G4double ebound = result->GetLocalEnergyDeposit(); 
  G4double edep = 0.0; 
  G4int nSecondaries = result->GetNumberOfSecondaries();
  G4int nEmCascadeSec = nSecondaries;
 
  // Try decay from bound level 
  // For mu- the time of projectile should be changed.
  // Decay should keep G4HadFinalState object,
  // because it will not be deleted at the end of this method.
  //
  thePro.SetBoundEnergy(ebound);
  if(fBoundDecay) {
    G4HadFinalState* resultDecay = 
      fBoundDecay->ApplyYourself(thePro, *nucleus);
    G4int n = resultDecay->GetNumberOfSecondaries();
    if(0 < n) {
      nSecondaries += n;
      result->AddSecondaries(resultDecay);
    } 
    if(resultDecay->GetStatusChange() == stopAndKill) {
      nuclearCapture = false; 
    }
    resultDecay->Clear();
  }
 
  if(nuclearCapture) {
 
    // delay of capture
    G4double capTime = thePro.GetGlobalTime();
    thePro.SetGlobalTime(0.0);
 
    // select model
    G4HadronicInteraction* model = 0;
    try {
      model = ChooseHadronicInteraction(thePro, *nucleus, 
                    track.GetMaterial(), elm);
    }
    catch(G4HadronicException & aE) {
      G4ExceptionDescription ed;
      ed << "Target element "<<elm->GetName()<<"  Z= " 
     << nucleus->GetZ_asInt() << "  A= " 
     << nucleus->GetA_asInt() << G4endl;
      DumpState(track,"ChooseHadronicInteraction",ed);
      ed << " No HadronicInteraction found out" << G4endl;
      G4Exception("G4HadronStoppingProcess::AtRestDoIt", "had005", 
          FatalException, ed);
    }
 
    G4HadFinalState* resultNuc = 0;
    G4int reentryCount = 0;
    do {
      // sample final state
      // nuclear interaction should keep G4HadFinalState object
      // model should define time of each secondary particle
      try {
    resultNuc = model->ApplyYourself(thePro, *nucleus);
    ++reentryCount;
      }
      catch(G4HadronicException & aR) {
    G4ExceptionDescription ed;
    ed << "Call for " << model->GetModelName() << G4endl;
    ed << "Target element "<<elm->GetName()<<"  Z= " 
       << nucleus->GetZ_asInt() 
       << "  A= " << nucleus->GetA_asInt() << G4endl;
    DumpState(track,"ApplyYourself",ed);
    ed << " ApplyYourself failed" << G4endl;
    G4Exception("G4HadronStoppingProcess::AtRestDoIt", "had006", 
            FatalException, ed);
      }
 
      // Check the result for catastrophic energy non-conservation
      resultNuc = CheckResult(thePro, *nucleus, resultNuc);
 
      if(reentryCount>100) {
    G4ExceptionDescription ed;
    ed << "Call for " << model->GetModelName() << G4endl;
    ed << "Target element "<<elm->GetName()<<"  Z= " 
       << nucleus->GetZ_asInt() 
       << "  A= " << nucleus->GetA_asInt() << G4endl;
    DumpState(track,"ApplyYourself",ed);
    ed << " ApplyYourself does not completed after 100 attempts" << G4endl;
    G4Exception("G4HadronStoppingProcess::AtRestDoIt", "had006", 
            FatalException, ed);  
      }
      // Loop checking, 06-Aug-2015, Vladimir Ivanchenko
    } while(!resultNuc);
 
    edep = resultNuc->GetLocalEnergyDeposit();
    size_t nnuc = resultNuc->GetNumberOfSecondaries();
 
    // add delay time of capture
    for(size_t i=0; i<nnuc; ++i) { 
      G4HadSecondary* sec = resultNuc->GetSecondary(i);
      sec->SetTime(capTime + sec->GetTime());
    }
 
    nSecondaries += nnuc;
    result->AddSecondaries(resultNuc); 
    resultNuc->Clear();
  }
 
  // Fill results
  //
  theTotalResult->ProposeTrackStatus(fStopAndKill);
  theTotalResult->ProposeLocalEnergyDeposit(edep);  
  theTotalResult->SetNumberOfSecondaries(nSecondaries);
  G4double w  = track.GetWeight();
  theTotalResult->ProposeWeight(w);
  for(G4int i=0; i<nSecondaries; ++i) {
    G4HadSecondary* sec = result->GetSecondary(i);
 
    // add track global time to the reaction time
    G4double time = sec->GetTime();
    if(time < 0.0) { time = 0.0; }
    time += time0;
 
    // create secondary track
    G4Track* t = new G4Track(sec->GetParticle(),
                 time, 
                 track.GetPosition());
    t->SetWeight(w*sec->GetWeight());
 
    // use SetCreatorModelID to "label" the track
    if (i<nEmCascadeSec) {
      t->SetCreatorModelID(emcID);
    } else if (nuclearCapture) {
      t->SetCreatorModelID(ncID);
    } else {
      t->SetCreatorModelID(dioID);
    }
 
    t->SetTouchableHandle(track.GetTouchableHandle());
    theTotalResult->AddSecondary(t);
  }
  result->Clear();
 
  if (epReportLevel != 0) { 
    CheckEnergyMomentumConservation(track, *nucleus);
  }
  return theTotalResult;
}

References G4HadFinalState::AddSecondaries(), G4ParticleChange::AddSecondary(), G4HadronicInteraction::ApplyYourself(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4HadronicProcess::ChooseHadronicInteraction(), G4HadFinalState::Clear(), G4HadronStoppingProcess::dioID, G4HadronicProcess::DumpState(), G4HadronStoppingProcess::emcID, G4HadronicProcess::epReportLevel, FatalException, G4HadronStoppingProcess::fBoundDecay, G4HadronStoppingProcess::fElementSelector, G4HadronStoppingProcess::fEmCascade, fStopAndKill, G4endl, G4Exception(), G4Nucleus::GetA_asInt(), G4HadProjectile::GetGlobalTime(), G4Track::GetGlobalTime(), G4HadFinalState::GetLocalEnergyDeposit(), G4Track::GetMaterial(), G4HadronicInteraction::GetModelName(), G4Element::GetName(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4Track::GetPosition(), G4HadFinalState::GetSecondary(), G4HadFinalState::GetStatusChange(), G4HadronicProcess::GetTargetNucleusPointer(), G4HadSecondary::GetTime(), G4Track::GetTouchableHandle(), G4HadSecondary::GetWeight(), G4Track::GetWeight(), G4Nucleus::GetZ_asInt(), G4HadProjectile::Initialise(), G4ParticleChange::Initialize(), CLHEP::detail::n, G4HadronStoppingProcess::ncID, G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeTrackStatus(), G4VParticleChange::ProposeWeight(), G4ElementSelector::SelectZandA(), G4HadProjectile::SetBoundEnergy(), G4Track::SetCreatorModelID(), G4HadProjectile::SetGlobalTime(), G4VParticleChange::SetNumberOfSecondaries(), G4HadSecondary::SetTime(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), stopAndKill, G4HadronicProcess::thePro, and G4HadronicProcess::theTotalResult.

◆ AtRestGetPhysicalInteractionLength()

G4double G4HadronStoppingProcess::AtRestGetPhysicalInteractionLength	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

virtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 115 of file G4HadronStoppingProcess.cc.

{
  *condition = NotForced;
  return 0.0;
}

References condition(), and NotForced.

◆ AtRestGPIL()

G4double G4VProcess::AtRestGPIL	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BiasCrossSectionByFactor()

void G4HadronicProcess::BiasCrossSectionByFactor ( G4double aScale )

inherited

Definition at line 483 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;
  }
}

References G4HadronicProcess::aScaleFactor, G4Exception(), G4VProcess::GetProcessName(), and JustWarning.

Referenced by G4HadronicProcess::MultiplyCrossSectionBy().

◆ BuildPhysicsTable()

void G4HadronStoppingProcess::BuildPhysicsTable ( const G4ParticleDefinition & p )

virtualinherited

Reimplemented from G4HadronicProcess.

Definition at line 108 of file G4HadronStoppingProcess.cc.

{
  G4HadronicProcessStore::Instance()->PrintInfo(&p);
}

References G4HadronicProcessStore::Instance(), and G4HadronicProcessStore::PrintInfo().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ CheckEnergyMomentumConservation()

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

protectedinherited

Definition at line 587 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;
  }
}

References DBL_MAX, CLHEP::HepLorentzVector::e(), CLHEP::electron_mass_c2, G4HadronicProcess::epCheckLevels, G4HadronicProcess::epReportLevel, fStopAndKill, G4cerr, G4cout, G4endl, G4lrint(), G4DynamicParticle::Get4Momentum(), G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetBaryonNumber(), G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4ParticleChange::GetEnergy(), G4HadronicInteraction::GetEnergyMomentumCheckLevels(), G4HadronicProcess::GetHadronicInteraction(), G4Track::GetKineticEnergy(), G4HadronicInteraction::GetModelName(), G4Track::GetMomentum(), G4ParticleChange::GetMomentumDirection(), G4NucleiProperties::GetNuclearMass(), G4VParticleChange::GetNumberOfSecondaries(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4VProcess::GetProcessName(), G4VParticleChange::GetSecondary(), G4VParticleChange::GetTrackStatus(), G4Nucleus::GetZ_asInt(), G4HadronicProcess::levelsSetByProcess, CLHEP::Hep3Vector::mag(), MeV, G4INCL::Math::min(), G4HadronicProcess::nICelectrons, CLHEP::HepLorentzVector::set(), G4HadronicProcess::theTotalResult, CLHEP::HepLorentzVector::vect(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

◆ CheckResult()

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

protectedinherited

Definition at line 495 of file G4HadronicProcess.cc.

{
  // check for catastrophic energy non-conservation
  // to re-sample the interaction
 
  G4HadronicInteraction * theModel = GetHadronicInteraction();
  G4double nuclearMass(0);
  if (theModel) {
 
    // Compute final-state total energy
    G4double finalE(0.);
    G4int nSec = 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;
}

References G4HadFinalState::Clear(), CLHEP::HepLorentzVector::e(), G4HadronicProcess::epReportLevel, EventMustBeAborted, G4endl, G4Exception(), G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4DynamicParticle::GetDefinition(), G4HadProjectile::GetDefinition(), G4HadFinalState::GetEnergyChange(), G4HadronicInteraction::GetFatalEnergyCheckLevels(), G4HadronicProcess::GetHadronicInteraction(), G4HadProjectile::GetKineticEnergy(), G4HadFinalState::GetLocalEnergyDeposit(), G4DynamicParticle::GetMass(), G4HadronicInteraction::GetModelName(), G4NucleiProperties::GetNuclearMass(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), G4VProcess::GetProcessName(), G4HadFinalState::GetSecondary(), G4HadFinalState::GetStatusChange(), G4DynamicParticle::GetTotalEnergy(), G4HadProjectile::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), G4ParticleDefinition::IsShortLived(), JustWarning, MeV, and stopAndKill.

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

◆ ChooseHadronicInteraction()

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

inlineprotectedinherited

Definition at line 139 of file G4HadronicProcess.hh.

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

References G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcess::theEnergyRangeManager.

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

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ CrossSectionFactor()

G4double G4HadronicProcess::CrossSectionFactor ( ) const

inlineinherited

Definition at line 156 of file G4HadronicProcess.hh.

157 { return aScaleFactor; }

References G4HadronicProcess::aScaleFactor.

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ DumpPhysicsTable()

void G4HadronicProcess::DumpPhysicsTable ( const G4ParticleDefinition & p )

inherited

Definition at line 757 of file G4HadronicProcess.cc.

{ 
  theCrossSectionDataStore->DumpPhysicsTable(p); 
}

References G4CrossSectionDataStore::DumpPhysicsTable(), and G4HadronicProcess::theCrossSectionDataStore.

◆ DumpState()

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

protectedinherited

Definition at line 732 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;
  }
}

References G4endl, G4Track::GetKineticEnergy(), G4Track::GetMaterial(), G4Track::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4Material::GetName(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4Track::GetPosition(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), G4Track::GetVolume(), CLHEP::GeV, and CLHEP::mm.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronicProcess::FillResult(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

◆ EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

◆ FillResult()

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

protectedinherited

Definition at line 381 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 = 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(G4HadronicProcess_debug_flag) {
    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);
    G4double newWeight = fWeight*aR->GetSecondary(i)->GetWeight();
    track->SetWeight(newWeight);
    track->SetTouchableHandle(aT.GetTouchableHandle());
    theTotalResult->AddSecondary(track);
    if (G4HadronicProcess_debug_flag) {
      G4double e = dynParticle->GetKineticEnergy();
      if (e == 0.0) {
    G4ExceptionDescription ed;
    DumpState(aT,"Secondary has zero energy",ed);
    ed << "Secondary " << part->GetParticleName()
       << G4endl;
    G4Exception("G4HadronicProcess::FillResults", "had011", 
              JustWarning,ed);
      }
    }
  }
  aR->Clear();
  // G4cout << "FillResults done nICe= " << nICelectrons << G4endl;
}

References G4ParticleChange::AddSecondary(), G4HadFinalState::Clear(), G4HadronicProcess::DumpState(), CLHEP::eV, fAlive, fStopAndKill, fStopButAlive, G4HadronicProcess::fWeight, G4endl, G4Exception(), G4HadronicProcess::G4HadronicProcess_debug_flag, G4Nucleus::GetA_asInt(), G4ProcessManager::GetAtRestProcessVector(), G4HadSecondary::GetCreatorModelID(), G4DynamicParticle::GetDefinition(), G4HadFinalState::GetEnergyChange(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetKineticEnergy(), G4HadFinalState::GetLocalEnergyDeposit(), G4DynamicParticle::GetMass(), G4HadFinalState::GetMomentumChange(), G4DynamicParticle::GetMomentumDirection(), G4Track::GetMomentumDirection(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4Track::GetPosition(), G4ParticleDefinition::GetProcessManager(), G4HadFinalState::GetSecondary(), G4HadFinalState::GetStatusChange(), G4HadSecondary::GetTime(), G4Track::GetTouchableHandle(), G4Track::GetTrackID(), G4HadSecondary::GetWeight(), G4Nucleus::GetZ_asInt(), CLHEP::GeV, JustWarning, CLHEP::keV, G4INCL::Math::max(), G4HadronicProcess::nICelectrons, G4ParticleChange::ProposeEnergy(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), CLHEP::Hep3Vector::rotateUz(), G4Track::SetCreatorModelID(), G4DynamicParticle::SetKineticEnergy(), G4DynamicParticle::SetMass(), G4DynamicParticle::SetMomentumDirection(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), G4ProcessVector::size(), stopAndKill, G4HadronicProcess::targetNucleus, and G4HadronicProcess::theTotalResult.

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

◆ GetCrossSectionDataStore()

G4CrossSectionDataStore * G4HadronicProcess::GetCrossSectionDataStore ( )

inlineinherited

Definition at line 177 of file G4HadronicProcess.hh.

178 {return theCrossSectionDataStore;}

References G4HadronicProcess::theCrossSectionDataStore.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4ElectronNuclearProcess::G4ElectronNuclearProcess(), G4PositronNuclearProcess::G4PositronNuclearProcess(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4HadronPhysicsShielding::Neutron(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), and G4GammaGeneralProcess::SelectHadProcess().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

◆ GetElementCrossSection()

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

inherited

Definition at line 149 of file G4HadronicProcess.cc.

{
  if(!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
    std::max(theCrossSectionDataStore->GetCrossSection(part, elm, mat),0.0);
}

References G4Exception(), G4CrossSectionDataStore::GetCrossSection(), G4VProcess::GetProcessName(), G4Element::GetZasInt(), JustWarning, G4INCL::Math::max(), G4HadronicProcess::nMatWarn, and G4HadronicProcess::theCrossSectionDataStore.

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

◆ GetEnergyMomentumCheckEnvvars()

void G4HadronicProcess::GetEnergyMomentumCheckEnvvars ( )

privateinherited

Definition at line 129 of file G4HadronicProcess.cc.

                                                      {
  if ( std::getenv("G4Hadronic_epReportLevel") ) {
    epReportLevel = std::strtol(std::getenv("G4Hadronic_epReportLevel"),0,10);
  }
  if ( std::getenv("G4Hadronic_epCheckRelativeLevel") ) {
    epCheckLevels.first = std::strtod(std::getenv("G4Hadronic_epCheckRelativeLevel"),0);
  }
  if ( std::getenv("G4Hadronic_epCheckAbsoluteLevel") ) {
    epCheckLevels.second = std::strtod(std::getenv("G4Hadronic_epCheckAbsoluteLevel"),0);
  }
}

References G4HadronicProcess::epCheckLevels, and G4HadronicProcess::epReportLevel.

Referenced by G4HadronicProcess::InitialiseLocal().

◆ GetEnergyMomentumCheckLevels()

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

inlineinherited

Definition at line 173 of file G4HadronicProcess.hh.

174 { return epCheckLevels; }

References G4HadronicProcess::epCheckLevels.

Referenced by G4HadronicProcessStore::SetProcessAbsLevel(), and G4HadronicProcessStore::SetProcessRelLevel().

◆ GetHadronicInteraction()

G4HadronicInteraction * G4HadronicProcess::GetHadronicInteraction ( ) const

inlineinherited

Definition at line 118 of file G4HadronicProcess.hh.

119 { return theInteraction; }

G4HadronicProcess::theInteraction

G4HadronicInteraction * theInteraction

Definition: G4HadronicProcess.hh:227

References G4HadronicProcess::theInteraction.

Referenced by G4HadronicProcess::CheckEnergyMomentumConservation(), and G4HadronicProcess::CheckResult().

◆ GetHadronicInteractionList()

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

inherited

Definition at line 768 of file G4HadronicProcess.cc.

{ 
  return theEnergyRangeManager.GetHadronicInteractionList(); 
}

References G4EnergyRangeManager::GetHadronicInteractionList(), and G4HadronicProcess::theEnergyRangeManager.

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

◆ GetHadronicModel()

G4HadronicInteraction * G4HadronicProcess::GetHadronicModel ( const G4String & modelName )

inherited

Definition at line 774 of file G4HadronicProcess.cc.

{ 
  std::vector<G4HadronicInteraction*>& list
        = theEnergyRangeManager.GetHadronicInteractionList();
  for (size_t li=0; li<list.size(); li++) {
    if (list[li]->GetModelName() == modelName) return list[li];
  }
  return nullptr;
}

References G4EnergyRangeManager::GetHadronicInteractionList(), and G4HadronicProcess::theEnergyRangeManager.

◆ GetLastCrossSection()

G4double G4HadronicProcess::GetLastCrossSection ( )

inlineprotectedinherited

Definition at line 185 of file G4HadronicProcess.hh.

186 { return theLastCrossSection; }

G4HadronicProcess::theLastCrossSection

G4double theLastCrossSection

Definition: G4HadronicProcess.hh:253

References G4HadronicProcess::theLastCrossSection.

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMeanFreePath()

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

overridevirtualinherited

Implements G4VDiscreteProcess.

Reimplemented in G4NeutrinoElectronProcess, G4ElNeutrinoNucleusProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 186 of file G4HadronicProcess.cc.

{
  //G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
  //     << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
  theLastCrossSection = aScaleFactor*theCrossSectionDataStore
     ->ComputeCrossSection(aTrack.GetDynamicParticle(),aTrack.GetMaterial());
  G4double res = (theLastCrossSection>0.0) ? 1.0/theLastCrossSection : DBL_MAX;
  //G4cout << "         xsection= " << theLastCrossSection << G4endl;
  return res;
}

References G4HadronicProcess::aScaleFactor, G4CrossSectionDataStore::ComputeCrossSection(), DBL_MAX, G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4HadronicProcess::theCrossSectionDataStore, and G4HadronicProcess::theLastCrossSection.

◆ GetMeanLifeTime()

G4double G4HadronStoppingProcess::GetMeanLifeTime	(	const G4Track &	,
		G4ForceCondition *
	)

inlineprotectedinherited

Definition at line 98 of file G4HadronStoppingProcess.hh.

99 { return -1.0; }

◆ GetMicroscopicCrossSection()

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

inlineinherited

Definition at line 90 of file G4HadronicProcess.hh.

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

G4HadronicProcess::GetElementCrossSection

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

Definition: G4HadronicProcess.cc:149

References G4HadronicProcess::GetElementCrossSection().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName	(	const G4ParticleDefinition *	particle,
		const G4String &	directory,
		const G4String &	tableName,
		G4bool	ascii = `false`
	)

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetTargetIsotope()

const G4Isotope * G4HadronicProcess::GetTargetIsotope ( )

inlineinherited

Definition at line 130 of file G4HadronicProcess.hh.

131 { return targetNucleus.GetIsotope(); }

G4Nucleus::GetIsotope

const G4Isotope * GetIsotope()

Definition: G4Nucleus.hh:111

References G4Nucleus::GetIsotope(), and G4HadronicProcess::targetNucleus.

◆ GetTargetNucleus()

const G4Nucleus * G4HadronicProcess::GetTargetNucleus ( ) const

inlineinherited

Definition at line 126 of file G4HadronicProcess.hh.

127 { return &targetNucleus; }

References G4HadronicProcess::targetNucleus.

◆ GetTargetNucleusPointer()

G4Nucleus * G4HadronicProcess::GetTargetNucleusPointer ( )

inlineprotectedinherited

Definition at line 148 of file G4HadronicProcess.hh.

149 { return &targetNucleus; }

References G4HadronicProcess::targetNucleus.

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

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

◆ GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

◆ InitialiseLocal()

void G4HadronicProcess::InitialiseLocal ( )

privateinherited

Definition at line 107 of file G4HadronicProcess.cc.

                                        {  
  theTotalResult = new G4ParticleChange();
  theTotalResult->SetSecondaryWeightByProcess(true);
  theInteraction = nullptr;
  theCrossSectionDataStore = new G4CrossSectionDataStore();
  theProcessStore = G4HadronicProcessStore::Instance();
  theProcessStore->Register(this);
  theInitialNumberOfInteractionLength = 0.0;
  aScaleFactor = 1.0;
  fWeight = 1.0;
  nMatWarn = nKaonWarn = 0;
  useIntegralXS = true;
  theLastCrossSection = 0.0;
  nICelectrons = 0;
  G4HadronicProcess_debug_flag = false;
  levelsSetByProcess = false;
  epReportLevel = 0;
  epCheckLevels.first = DBL_MAX;
  epCheckLevels.second = DBL_MAX;
  GetEnergyMomentumCheckEnvvars();
}

Referenced by G4HadronicProcess::G4HadronicProcess().

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

G4bool G4HadronicAbsorptionFritiof::IsApplicable ( const G4ParticleDefinition & particle )

virtual

Reimplemented from G4HadronStoppingProcess.

Definition at line 91 of file G4HadronicAbsorptionFritiof.cc.

                                                     {
  return ( ( 0 == pdefApplicable && 
             ( &particle == G4AntiProton::Definition()     ||
               &particle == G4AntiNeutron::Definition()    ||
               &particle == G4AntiLambda::Definition()     ||
           &particle == G4AntiSigmaZero::Definition()  ||
           &particle == G4AntiSigmaPlus::Definition()  ||
               &particle == G4AntiXiZero::Definition()     ||
               particle.GetBaryonNumber() < -1 ) )     // Anti-nuclei
       || ( &particle == pdefApplicable ) );
}

References G4AntiLambda::Definition(), G4AntiNeutron::Definition(), G4AntiProton::Definition(), G4AntiSigmaPlus::Definition(), G4AntiSigmaZero::Definition(), G4AntiXiZero::Definition(), G4ParticleDefinition::GetBaryonNumber(), and pdefApplicable.

Referenced by G4StoppingPhysics::ConstructProcess(), and G4StoppingPhysicsFritiofWithBinaryCascade::ConstructProcess().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ MultiplyCrossSectionBy()

void G4HadronicProcess::MultiplyCrossSectionBy ( G4double factor )

inherited

Definition at line 478 of file G4HadronicProcess.cc.

{
  BiasCrossSectionByFactor(factor);
}

References G4HadronicProcess::BiasCrossSectionByFactor().

◆ operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess & right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

G4HadronicAbsorptionFritiof & G4HadronicAbsorptionFritiof::operator= ( const G4HadronicAbsorptionFritiof & )

private

◆ operator==()

G4bool G4VProcess::operator== ( const G4VProcess & right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PostStepDoIt()

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

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4NeutrinoElectronProcess, G4ElNeutrinoNucleusProcess, G4HadronElasticProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 199 of file G4HadronicProcess.cc.

{
  //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(aParticle->GetDefinition()->GetPDGCharge() != 0.0) {
    G4double xs = aScaleFactor*
      theCrossSectionDataStore->ComputeCrossSection(aParticle,aMaterial);
    if(xs <= 0.0 || 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(!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
    {
      // Save random engine if requested for debugging
      if (G4Hadronic_Random_File) {
         CLHEP::HepRandom::saveEngineStatus(G4Hadronic_Random_File);
      }
      // 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.
  G4int nSec = result->GetNumberOfSecondaries();
  if ( nSec > 0 ) {
    for ( G4int i = 0; i < nSec; ++i ) {
      G4DynamicParticle* dynamicParticle = result->GetSecondary(i)->GetParticle();
      const G4ParticleDefinition* particleDefinition = 
        dynamicParticle->GetParticleDefinition();
      if ( particleDefinition == G4KaonZero::Definition() || 
           particleDefinition == G4AntiKaonZero::Definition() ) {
        G4ParticleDefinition* newPart;
        if( G4UniformRand() > 0.5 ) { newPart = G4KaonZeroShort::Definition(); }
        else { newPart = G4KaonZeroLong::Definition(); }
        dynamicParticle->SetDefinition( newPart );
    if(nKaonWarn < 5) {
      ++nKaonWarn;
      G4ExceptionDescription ed;
      ed << " Hadronic model " << theInteraction->GetModelName() << G4endl;
      ed << " created " << particleDefinition->GetParticleName() << G4endl;
      ed << " -> forced to be " << newPart->GetParticleName() << G4endl;
      G4Exception( "G4HadronicProcess::PostStepDoIt", "had007", JustWarning, ed );
    }
      }
    }
  }
 
  result->SetTrafoToLab(thePro.GetTrafoToLab());
 
  ClearNumberOfInteractionLengthLeft();
 
  FillResult(result, aTrack);
 
  if (epReportLevel != 0) {
    CheckEnergyMomentumConservation(aTrack, targetNucleus);
  }
  //G4cout << "PostStepDoIt done nICelectrons= " << nICelectrons << G4endl;
  return theTotalResult;
}

References G4HadronicInteraction::ApplyYourself(), G4HadronicProcess::aScaleFactor, G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4HadronicProcess::ChooseHadronicInteraction(), G4VParticleChange::Clear(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4CrossSectionDataStore::ComputeCrossSection(), G4AntiKaonZero::Definition(), G4KaonZero::Definition(), G4KaonZeroLong::Definition(), G4KaonZeroShort::Definition(), G4HadronicProcess::DumpState(), G4HadronicProcess::epReportLevel, fAlive, FatalException, G4HadronicProcess::FillResult(), fKillTrackAndSecondaries, fPostponeToNextEvent, fStopAndKill, fSuspend, G4HadronicProcess::fWeight, G4endl, G4Exception(), G4Hadronic_Random_File, G4UniformRand, G4Nucleus::GetA_asInt(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4HadronicInteraction::GetModelName(), G4Element::GetName(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4HadFinalState::GetSecondary(), G4Track::GetTrackStatus(), G4HadProjectile::GetTrafoToLab(), G4Track::GetWeight(), G4Nucleus::GetZ_asInt(), G4HadProjectile::Initialise(), G4ParticleChange::Initialize(), JustWarning, G4HadronicProcess::nKaonWarn, G4VParticleChange::ProposeWeight(), G4HadronicException::Report(), G4CrossSectionDataStore::SampleZandA(), CLHEP::HepRandom::saveEngineStatus(), G4DynamicParticle::SetDefinition(), G4HadFinalState::SetTrafoToLab(), G4HadronicProcess::targetNucleus, G4HadronicProcess::theCrossSectionDataStore, G4HadronicProcess::theInteraction, G4HadronicProcess::theLastCrossSection, G4HadronicProcess::thePro, and G4HadronicProcess::theTotalResult.

◆ PostStepGetPhysicalInteractionLength()

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

virtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 124 of file G4HadronStoppingProcess.cc.

{
  *condition = NotForced;
  return DBL_MAX;
}

References condition(), DBL_MAX, and NotForced.

◆ PostStepGPIL()

G4double G4VProcess::PostStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

void G4HadronStoppingProcess::PreparePhysicsTable ( const G4ParticleDefinition & p )

virtualinherited

Reimplemented from G4HadronicProcess.

Definition at line 98 of file G4HadronStoppingProcess.cc.

{
  G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this,&p);
  emcID = G4PhysicsModelCatalog::GetModelID(G4String("model_" + (GetProcessName() + "_EMCascade")));
  ncID  = G4PhysicsModelCatalog::GetModelID(G4String("model_" + (GetProcessName() + "_NuclearCapture")));
  dioID = G4PhysicsModelCatalog::GetModelID(G4String("model_" + (GetProcessName() + "_DIO")));
}

References G4HadronStoppingProcess::dioID, G4HadronStoppingProcess::emcID, G4PhysicsModelCatalog::GetModelID(), G4VProcess::GetProcessName(), G4HadronicProcessStore::Instance(), G4HadronStoppingProcess::ncID, and G4HadronicProcessStore::RegisterParticleForExtraProcess().

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ ProcessDescription()

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

virtual

Reimplemented from G4HadronStoppingProcess.

Definition at line 106 of file G4HadronicAbsorptionFritiof.cc.

                                           {
  os << "Stopping and absorption of anti_proton, anti_neutron, anti_lambda, \n"
     << "anti_sigma0, anti_sigma+, anti_xi0 and all anti-nuclei \n"
     << "using  Fritiof (FTF) string model.\n"
     << "Geant4 PreCompound model is used for nuclear de-excitation."
     << std::endl;
}

◆ RegisterMe()

void G4HadronicProcess::RegisterMe ( G4HadronicInteraction * a )

inherited

Definition at line 141 of file G4HadronicProcess.cc.

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

References G4HadronicProcessStore::Instance(), G4HadronicProcessStore::RegisterInteraction(), G4EnergyRangeManager::RegisterMe(), and G4HadronicProcess::theEnergyRangeManager.

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

212 { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

◆ SetBoundDecay()

void G4HadronStoppingProcess::SetBoundDecay ( G4HadronicInteraction * ptr )

inlineinherited

Definition at line 137 of file G4HadronStoppingProcess.hh.

{
  fBoundDecay = ptr;
}

References G4HadronStoppingProcess::fBoundDecay.

Referenced by G4MuonMinusCapture::G4MuonMinusCapture().

◆ SetElementSelector()

void G4HadronStoppingProcess::SetElementSelector ( G4ElementSelector * ptr )

inlineinherited

Definition at line 122 of file G4HadronStoppingProcess.hh.

{
  if(fElementSelector != ptr) {
    delete fElementSelector;
    fElementSelector = ptr;
  }
}

References G4HadronStoppingProcess::fElementSelector.

◆ SetEmCascade()

void G4HadronStoppingProcess::SetEmCascade ( G4HadronicInteraction * ptr )

inlineinherited

Definition at line 131 of file G4HadronStoppingProcess.hh.

{
  fEmCascade = ptr;
}

References G4HadronStoppingProcess::fEmCascade.

◆ SetEnergyMomentumCheckLevels()

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

inlineinherited

Definition at line 167 of file G4HadronicProcess.hh.

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

References G4HadronicProcess::epCheckLevels, and G4HadronicProcess::levelsSetByProcess.

Referenced by G4HadronicProcessStore::SetProcessAbsLevel(), and G4HadronicProcessStore::SetProcessRelLevel().

◆ SetEpReportLevel()

void G4HadronicProcess::SetEpReportLevel ( G4int level )

inlineinherited

Definition at line 164 of file G4HadronicProcess.hh.

165 { epReportLevel = level; }

References G4HadronicProcess::epReportLevel.

◆ SetIntegral()

void G4HadronicProcess::SetIntegral ( G4bool val )

inlineinherited

Definition at line 160 of file G4HadronicProcess.hh.

161 { useIntegralXS = val; }

References G4HadronicProcess::useIntegralXS.

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess * masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

◆ StartTracking()

void G4VProcess::StartTracking ( G4Track * )

virtualinherited

Reimplemented in G4ParallelGeometriesLimiterProcess, G4ImportanceProcess, G4WeightCutOffProcess, G4WeightWindowProcess, G4VITProcess, G4DNASecondOrderReaction, G4WrapperProcess, G4FastSimulationManagerProcess, G4ParallelWorldProcess, G4ParallelWorldScoringProcess, G4ScoreSplittingProcess, G4GammaGeneralProcess, G4Decay, G4AdjointProcessEquivalentToDirectProcess, G4eAdjointMultipleScattering, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4ITTransportation, G4DNABrownianTransportation, G4CoupledTransportation, G4Transportation, G4BiasingProcessInterface, and G4VPhononProcess.

Definition at line 87 of file G4VProcess.cc.

{
  currentInteractionLength = -1.0;
  theNumberOfInteractionLengthLeft = -1.0;
  theInitialNumberOfInteractionLength = -1.0;
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::StartTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4DNASecondOrderReaction::StartTracking(), G4WrapperProcess::StartTracking(), G4AdjointProcessEquivalentToDirectProcess::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), G4Transportation::StartTracking(), G4BiasingProcessInterface::StartTracking(), and G4VPhononProcess::StartTracking().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

207 { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

◆ XBiasSecondaryWeight()

G4double G4HadronicProcess::XBiasSecondaryWeight ( )

privateinherited

Definition at line 372 of file G4HadronicProcess.cc.

{
  G4double nLTraversed = GetTotalNumberOfInteractionLengthTraversed();
  G4double result =
     1./aScaleFactor*G4Exp(-nLTraversed/aScaleFactor*(1-1./aScaleFactor));
  return result;
}

References G4HadronicProcess::aScaleFactor, G4Exp(), and G4VProcess::GetTotalNumberOfInteractionLengthTraversed().

◆ XBiasSurvivalProbability()

G4double G4HadronicProcess::XBiasSurvivalProbability ( )

privateinherited

Definition at line 363 of file G4HadronicProcess.cc.

{
  G4double nLTraversed = GetTotalNumberOfInteractionLengthTraversed();
  G4double biasedProbability = 1.-G4Exp(-nLTraversed);
  G4double realProbability = 1-G4Exp(-nLTraversed/aScaleFactor);
  G4double result = (biasedProbability-realProbability)/biasedProbability;
  return result;
}