#include <G4NeutronGeneralProcess.hh>

Inheritance diagram for G4NeutronGeneralProcess:

Public Member Functions
	G4NeutronGeneralProcess (const G4String &pname="NeutronGeneralProc")

	~G4NeutronGeneralProcess () override

G4bool	IsApplicable (const G4ParticleDefinition &) override

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

void	PreparePhysicsTable (const G4ParticleDefinition &) override

void	BuildPhysicsTable (const G4ParticleDefinition &) override

G4bool	StorePhysicsTable (const G4ParticleDefinition *part, const G4String &directory, G4bool ascii) override

void	StartTracking (G4Track *) override

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

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

const G4VProcess *	GetCreatorProcess () const override

const G4String &	GetSubProcessName () const

G4int	GetSubProcessSubType () const

void	SetInelasticProcess (G4HadronicProcess *)

void	SetElasticProcess (G4HadronicProcess *)

void	SetCaptureProcess (G4HadronicProcess *)

G4VCrossSectionDataSet *	GetXSection (G4int type)

G4HadronicProcess *	GetHadronicProcess (G4int type)

const G4VProcess *	GetSelectedProcess () const

void	SetTimeLimit (G4double val)

void	SetMinEnergyLimit (G4double val)

	G4NeutronGeneralProcess (G4NeutronGeneralProcess &)=delete

G4NeutronGeneralProcess &	operator= (const G4NeutronGeneralProcess &right)=delete

Public Member Functions inherited from G4HadronicProcess
	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	DumpPhysicsTable (const G4ParticleDefinition &p)

void	AddDataSet (G4VCrossSectionDataSet *aDataSet)

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

G4HadronicInteraction *	GetHadronicModel (const G4String &)

G4HadronicInteraction *	GetHadronicInteraction () const

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	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	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 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
G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override

G4double	ComputeGeneralLambda (size_t idxe, size_t idxt)

G4double	GetProbability (size_t idxt)

void	SelectedProcess (const G4Step &step, G4HadronicProcess ptr, G4CrossSectionDataStore )

Protected Member Functions inherited from G4HadronicProcess
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 G4VDiscreteProcess
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

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

Protected Attributes inherited from G4HadronicProcess
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

Detailed Description

Definition at line 64 of file G4NeutronGeneralProcess.hh.

Constructor & Destructor Documentation

◆ G4NeutronGeneralProcess() [1/2]

G4NeutronGeneralProcess::G4NeutronGeneralProcess ( const G4String & pname = "NeutronGeneralProc" )

explicit

Definition at line 80 of file G4NeutronGeneralProcess.cc.

: G4HadronicProcess(pname),
  fMinEnergy(1*CLHEP::keV),
  fMiddleEnergy(20*CLHEP::MeV),
  fMaxEnergy(100*CLHEP::TeV),
  fTimeLimit(10*CLHEP::microsecond)
{
  SetVerboseLevel(1);
  SetProcessSubType(fNeutronGeneral);
 
  fNeutron = G4Neutron::Neutron();
 
  if(G4Threading::IsWorkerThread()) {
    isMaster = false;
  }
}

◆ ~G4NeutronGeneralProcess()

G4NeutronGeneralProcess::~G4NeutronGeneralProcess ( )

override

Definition at line 99 of file G4NeutronGeneralProcess.cc.

{
  if(isMaster) {
    delete theHandler;
    theHandler = nullptr;
  }
}

◆ G4NeutronGeneralProcess() [2/2]

G4NeutronGeneralProcess::G4NeutronGeneralProcess ( G4NeutronGeneralProcess & )

delete

Member Function Documentation

◆ BuildPhysicsTable()

void G4NeutronGeneralProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 271 of file G4NeutronGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4NeutronGeneralProcess::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
  fElasticP->BuildPhysicsTable(part);
  fInelasticP->BuildPhysicsTable(part);
  fCaptureP->BuildPhysicsTable(part);
 
  if(isMaster) {
    std::size_t nmat = G4Material::GetNumberOfMaterials();
    G4MaterialTable* matTable = G4Material::GetMaterialTable();
 
    auto tables = theHandler->GetTables();
 
    G4double sigEl(0.), sigInel(0.), sigCap(0.), val(0.), sum(0.);
 
    for(std::size_t i=0; i<nmat; ++i) {
      const G4Material* mat = (*matTable)[i];
 
      // energy interval 0
      std::size_t nn = (*(tables[0]))[i]->GetVectorLength();
      if(1 < verboseLevel) {
    G4cout << "======= Zone 0 ======= N= " << nn
           << " for " << mat->GetName() << G4endl;
      }
      for(std::size_t j=0; j<nn; ++j) {
    G4double e = (*(tables[0]))[i]->Energy(j);
    G4double loge = G4Log(e);
        sigEl = fXSFactorEl*ComputeCrossSection(fElasticXS, mat, e, loge);
        sigInel = fXSFactorInel*ComputeCrossSection(fInelasticXS, mat, e, loge);
        sigCap = ComputeCrossSection(fCaptureXS, mat, e, loge);
    sum = sigEl + sigInel + sigCap;
    if(1 < verboseLevel) {
      G4cout << j << ". E= " << e << " xs=" << sum << " sigEl=" << sigEl
         << " sigInel=" << sigInel << " sigCap=" << sigCap << G4endl;
    }
    (*(tables[0]))[i]->PutValue(j, sum);
    val = sigEl/sum;
    (*(tables[1]))[i]->PutValue(j, val);
    val = (sigEl + sigInel)/sum;
    (*(tables[2]))[i]->PutValue(j, val);
      }
 
      // energy interval 1
      nn = (*(tables[3]))[0]->GetVectorLength();
      if(1 < verboseLevel) {
    G4cout << "======= Zone 1 ======= N= " << nn << G4endl;
      }
      for(std::size_t j=0; j<nn; ++j) {
    G4double e = (*(tables[3]))[i]->Energy(j);
    G4double loge = G4Log(e);
    sigEl = fXSFactorEl*ComputeCrossSection(fElasticXS, mat, e, loge);
    sigInel = fXSFactorInel*ComputeCrossSection(fInelasticXS, mat, e, loge);
    sum = sigEl + sigInel;
    if(1 < verboseLevel) {
      G4cout << j << ". E= " << e << " xs=" << sum << " sigEl=" << sigEl
         << " sigInel=" << sigInel << " factInel=" << fXSFactorInel 
                 << G4endl;
    }
    (*(tables[3]))[i]->PutValue(j, sum);
    val = sigInel/sum;
    (*(tables[4]))[i]->PutValue(j, val);
      }
    }
  }
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
}

◆ ComputeGeneralLambda()

G4double G4NeutronGeneralProcess::ComputeGeneralLambda	(	size_t	idxe,
		size_t	idxt )

inlineprotected

Definition at line 193 of file G4NeutronGeneralProcess.hh.

{
  idxEnergy = idxe;
  return theHandler->GetVector(idxt, matIndex)
    ->LogVectorValue(fCurrE, fCurrLogE);
}

◆ GetCreatorProcess()

const G4VProcess * G4NeutronGeneralProcess::GetCreatorProcess ( ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 521 of file G4NeutronGeneralProcess.cc.

{
  return fSelectedProc;
}

◆ GetHadronicProcess()

G4HadronicProcess * G4NeutronGeneralProcess::GetHadronicProcess ( G4int type )

Definition at line 180 of file G4NeutronGeneralProcess.cc.

{
  G4HadronicProcess* ptr = nullptr;
  G4HadronicProcessType type = (G4HadronicProcessType)subtype;
  if(type == fHadronElastic) { ptr = fElasticP; }
  else if(type == fHadronInelastic) { ptr = fInelasticP; }
  else if(type == fCapture) { ptr = fCaptureP; }
  return ptr;
}  

◆ GetMeanFreePath()

G4double G4NeutronGeneralProcess::GetMeanFreePath	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition )

overrideprotectedvirtual

Reimplemented from G4HadronicProcess.

Definition at line 484 of file G4NeutronGeneralProcess.cc.

{
  *condition = NotForced;
  // recompute total cross section if needed
  CurrentCrossSection(track);
  return currentInteractionLength;
}

◆ GetProbability()

G4double G4NeutronGeneralProcess::GetProbability ( size_t idxt )

inlineprotected

Definition at line 202 of file G4NeutronGeneralProcess.hh.

{
  return theHandler->GetVector(idxt, matIndex)
    ->LogVectorValue(fCurrE, fCurrLogE);
}

Referenced by PostStepDoIt().

◆ GetSelectedProcess()

const G4VProcess * G4NeutronGeneralProcess::GetSelectedProcess ( ) const

inline

Definition at line 223 of file G4NeutronGeneralProcess.hh.

{
  return fSelectedProc;
}

◆ GetSubProcessName()

const G4String & G4NeutronGeneralProcess::GetSubProcessName ( ) const

Definition at line 505 of file G4NeutronGeneralProcess.cc.

{
  return (nullptr != fSelectedProc) ? fSelectedProc->GetProcessName()
    : G4VProcess::GetProcessName();
}

◆ GetSubProcessSubType()

G4int G4NeutronGeneralProcess::GetSubProcessSubType ( ) const

Definition at line 513 of file G4NeutronGeneralProcess.cc.

{
  return (nullptr != fSelectedProc) ? fSelectedProc->GetProcessSubType()
    : fNeutronGeneral;
}

◆ GetXSection()

G4VCrossSectionDataSet * G4NeutronGeneralProcess::GetXSection ( G4int type )

Definition at line 168 of file G4NeutronGeneralProcess.cc.

{
  G4VCrossSectionDataSet* xs = nullptr;
  G4HadronicProcessType type = (G4HadronicProcessType)subtype;
  if(type == fHadronElastic) { xs = fElasticXS; }
  else if(type == fHadronInelastic) { xs = fInelasticXS; }
  else if(type == fCapture) { xs = fCaptureXS; }
  return xs;
}

◆ IsApplicable()

G4bool G4NeutronGeneralProcess::IsApplicable ( const G4ParticleDefinition & )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 109 of file G4NeutronGeneralProcess.cc.

{
  return true;
}

◆ operator=()

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

delete

◆ PostStepDoIt()

G4VParticleChange * G4NeutronGeneralProcess::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	step )

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 416 of file G4NeutronGeneralProcess.cc.

{
  fSelectedProc = this;
  // time limit
  if(0.0 == fLambda) {
    theTotalResult->Initialize(track);
    theTotalResult->ProposeTrackStatus(fStopAndKill);
    return theTotalResult;
  }
  // In all cases clear number of interaction lengths
  theNumberOfInteractionLengthLeft = -1.0;
  G4double q = G4UniformRand();
  /*  
  G4cout << "PostStep: preStepLambda= " << fLambda << " idxE= " << idxEnergy
         << " matIndex=" << matIndex << G4endl;
  */
  if (0 == idxEnergy) {
    if(q <= GetProbability(1)) {
      SelectedProcess(step, fElasticP, fXSSElastic);
    } else if(q <= GetProbability(2)) {
      SelectedProcess(step, fInelasticP, fXSSInelastic);
    } else {
      SelectedProcess(step, fCaptureP, fXSSCapture);
    }
  } else {
    if(q <= GetProbability(4)) {
      SelectedProcess(step, fInelasticP, fXSSInelastic);
    } else {
      SelectedProcess(step, fElasticP, fXSSElastic);
    }
  }
  // total cross section is needed for selection of an element
  if(fCurrMat->GetNumberOfElements() > 1) {
    fCurrentXSS->ComputeCrossSection(track.GetDynamicParticle(), fCurrMat);
  }
  /*
    G4cout << "## neutron E(MeV)=" << fCurrE << " inside " << fCurrMat->GetName() 
     << fSelectedProc->GetProcessName()
     << " time(ns)=" << track.GetGlobalTime()/ns << G4endl; 
  */
  // sample secondaries
  return fSelectedProc->PostStepDoIt(track, step);
}

◆ PostStepGetPhysicalInteractionLength()

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

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 375 of file G4NeutronGeneralProcess.cc.

{
  *condition = NotForced;
 
  // time limit
  if(track.GetGlobalTime() >= fTimeLimit) {
    fLambda = 0.0;
    return 0.0;
  }
 
  // recompute total cross section if needed
  CurrentCrossSection(track);
 
  if (theNumberOfInteractionLengthLeft < 0.0) {
 
    // beggining of tracking (or just after DoIt of this process)
    theNumberOfInteractionLengthLeft = -G4Log( G4UniformRand() );
    theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft;
 
  } else {
 
    theNumberOfInteractionLengthLeft -=
      previousStepSize/currentInteractionLength;
    theNumberOfInteractionLengthLeft =
      std::max(theNumberOfInteractionLengthLeft, 0.0);
  }
 
  G4double x = theNumberOfInteractionLengthLeft * currentInteractionLength;
  /*
  G4cout << "PostStepGetPhysicalInteractionLength: e= " << energy
     << " idxe= " << idxEnergy << "  xs= " << fLambda
     << " x= " << x << G4endl;
  */
  return x;
}

◆ PreparePhysicsTable()

void G4NeutronGeneralProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 192 of file G4NeutronGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4NeutronGeneralProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
       << " isMaster: " << isMaster << G4endl;
  }
  G4bool noEl = (nullptr == fElasticP);
  G4bool noInel = (nullptr == fInelasticP);
  G4bool noCap = (nullptr == fCaptureP);
  if(noEl || noInel || noCap) {
    G4ExceptionDescription ed;
    ed << "Incomplete configuration of the neutron general process." << G4endl;
    if(noEl) { ed << "Neutron elastic process is not defined" << G4endl; }
    if(noInel) { ed << "Neutron inelastic process is not defined" << G4endl; }
    if(noCap) { ed << "Neutron capture process is not defined" << G4endl; }
    G4Exception ("G4NeutronGeneralProcess::PreparePhysicsTable(..)", "had001",
                 FatalException, ed, "");
    return;
  }
 
  G4HadronicParameters* param = G4HadronicParameters::Instance();
 
  SetVerboseLevel(param->GetVerboseLevel());
  fMaxEnergy = std::max(100*MeV, param->GetMaxEnergy());
  if(param->ApplyFactorXS()) {
    fXSFactorEl = param->XSFactorNucleonElastic();
    fXSFactorInel = param->XSFactorNucleonInelastic();
  }
 
  fElasticP->PreparePhysicsTable(part);
  fInelasticP->PreparePhysicsTable(part);
  fCaptureP->PreparePhysicsTable(part);
 
  std::size_t nmat = G4Material::GetNumberOfMaterials();
  G4MaterialTable* matTable = G4Material::GetMaterialTable();
 
  std::size_t nmax = 0;
  for(std::size_t i=0; i<nmat; ++i) {
    std::size_t nelm = (*matTable)[i]->GetNumberOfElements();
    nmax = std::max(nmax, nelm);
  }
  fXsec.resize(nmax);
 
  if(isMaster) {
    if(nullptr == theHandler) {
      theHandler = new G4HadDataHandler(nTables);
    }
 
    fMaxEnergy = std::max(fMaxEnergy, param->GetMaxEnergy());
    nLowE *= G4lrint(std::log10(fMiddleEnergy/fMinEnergy));
    nHighE *= G4lrint(std::log10(fMaxEnergy/fMiddleEnergy));
 
    G4PhysicsVector* vec = nullptr;
    G4PhysicsLogVector aVector(fMinEnergy, fMiddleEnergy, nLowE, false);
    G4PhysicsLogVector bVector(fMiddleEnergy, fMaxEnergy, nHighE, false);
 
    for(std::size_t i=0; i<nTables; ++i) {
      G4PhysicsTable* table = new G4PhysicsTable();
      theHandler->UpdateTable(table, i);
      table->resize(nmat);
      for(std::size_t j=0; j<nmat; ++j) {
    vec = (*table)[j];
    if (nullptr == vec) {
      if(i <= 2) {
        vec = new G4PhysicsVector(aVector);
      } else {
        vec = new G4PhysicsVector(bVector);
      }
      G4PhysicsTableHelper::SetPhysicsVector(table, j, vec);
    }
      }
    }
  }
}

◆ ProcessDescription()

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

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 496 of file G4NeutronGeneralProcess.cc.

{
  fElasticP->ProcessDescription(out);
  fInelasticP->ProcessDescription(out);
  fCaptureP->ProcessDescription(out);
}

◆ SelectedProcess()

void G4NeutronGeneralProcess::SelectedProcess	(	const G4Step &	step,
		G4HadronicProcess *	ptr,
		G4CrossSectionDataStore *	xs )

inlineprotected

Definition at line 211 of file G4NeutronGeneralProcess.hh.

{
  fSelectedProc = ptr;
  fCurrentXSS = xs;
  step.GetPostStepPoint()->SetProcessDefinedStep(ptr);
}

Referenced by PostStepDoIt().

◆ SetCaptureProcess()

void G4NeutronGeneralProcess::SetCaptureProcess ( G4HadronicProcess * ptr )

Definition at line 142 of file G4NeutronGeneralProcess.cc.

{
  fCaptureP = ptr;
  fXSSCapture = ptr->GetCrossSectionDataStore();
  fCaptureXS = InitialisationXS(ptr);
  if(nullptr == fCaptureXS) {
    fCaptureXS = new G4NeutronCaptureXS();
    ptr->AddDataSet(fCaptureXS);
  }
}

◆ SetElasticProcess()

void G4NeutronGeneralProcess::SetElasticProcess ( G4HadronicProcess * ptr )

Definition at line 129 of file G4NeutronGeneralProcess.cc.

{
  fElasticP = ptr;
  fXSSElastic = ptr->GetCrossSectionDataStore();
  fElasticXS = InitialisationXS(ptr);
  if(nullptr == fElasticXS) {
    fElasticXS = new G4NeutronElasticXS();
    ptr->AddDataSet(fElasticXS);
  }
}

◆ SetInelasticProcess()

void G4NeutronGeneralProcess::SetInelasticProcess ( G4HadronicProcess * ptr )

Definition at line 116 of file G4NeutronGeneralProcess.cc.

{
  fInelasticP = ptr;
  fXSSInelastic = ptr->GetCrossSectionDataStore();
  fInelasticXS = InitialisationXS(ptr);
  if(nullptr == fInelasticXS) {
    fInelasticXS = new G4NeutronInelasticXS();
    ptr->AddDataSet(fInelasticXS);
  }
}

◆ SetMinEnergyLimit()

void G4NeutronGeneralProcess::SetMinEnergyLimit ( G4double val )

inline

Definition at line 254 of file G4NeutronGeneralProcess.hh.

{
  fMinEnergy = val;
}

◆ SetTimeLimit()

void G4NeutronGeneralProcess::SetTimeLimit ( G4double val )

inline

Definition at line 247 of file G4NeutronGeneralProcess.hh.

{
  fTimeLimit = val;
}

◆ StartTracking()

void G4NeutronGeneralProcess::StartTracking ( G4Track * )

overridevirtual

Reimplemented from G4HadronicProcess.

Definition at line 367 of file G4NeutronGeneralProcess.cc.

{
  theNumberOfInteractionLengthLeft = -1.0;
  fCurrMat = nullptr;
}

◆ StorePhysicsTable()

G4bool G4NeutronGeneralProcess::StorePhysicsTable	(	const G4ParticleDefinition *	part,
		const G4String &	directory,
		G4bool	ascii )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 464 of file G4NeutronGeneralProcess.cc.

{
  G4bool yes = true;
  if(!isMaster) { return yes; }
  for(std::size_t i=0; i<nTables; ++i) {
    G4String nam = (0==i || 3==i)
    ? "LambdaNeutronGeneral" + nameT[i] : "ProbNeutronGeneral" + nameT[i];
    G4String fnam =  GetPhysicsTableFileName(part, directory, nam, ascii);
    auto table = theHandler->Table(i);
    if(nullptr == table || !table->StorePhysicsTable(fnam, ascii)) { 
      yes = false;
    }
  }
  return yes;
}

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4NeutronGeneralProcess() [1/2]

◆ ~G4NeutronGeneralProcess()

◆ G4NeutronGeneralProcess() [2/2]

Member Function Documentation

◆ BuildPhysicsTable()

◆ ComputeGeneralLambda()

◆ GetCreatorProcess()

◆ GetHadronicProcess()

◆ GetMeanFreePath()

◆ GetProbability()

◆ GetSelectedProcess()

◆ GetSubProcessName()

◆ GetSubProcessSubType()

◆ GetXSection()

◆ IsApplicable()

◆ operator=()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ ProcessDescription()

◆ SelectedProcess()

◆ SetCaptureProcess()

◆ SetElasticProcess()

◆ SetInelasticProcess()

◆ SetMinEnergyLimit()

◆ SetTimeLimit()

◆ StartTracking()

◆ StorePhysicsTable()