#include <G4BiasingProcessInterface.hh>

Inheritance diagram for G4BiasingProcessInterface:

Public Member Functions
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &step)

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

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 &, G4ForceCondition *)

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

virtual void	BuildPhysicsTable (const G4ParticleDefinition &pd)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &pd)

virtual void	DumpInfo () const

void	EndTracking ()

	G4BiasingProcessInterface (G4String name="biasWrapper(0)")

	G4BiasingProcessInterface (G4VProcess *wrappedProcess, G4bool wrappedIsAtRest, G4bool wrappedIsAlongStep, G4bool wrappedIsPostStep, G4String useThisName="")

G4double	GetAlongStepGPIL () const

const std::vector< const G4BiasingProcessInterface * > &	GetBiasingProcessInterfaces () const

G4VBiasingOperator *	GetCurrentBiasingOperator () const

G4VBiasingOperation *	GetCurrentFinalStateBiasingOperation () const

G4double	GetCurrentInteractionLength () const

G4double	GetCurrentMinimumStep () const

G4VBiasingOperation *	GetCurrentNonPhysicsBiasingOperation () const

G4VBiasingOperation *	GetCurrentOccurenceBiasingOperation () const

G4bool	GetIsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetIsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepGPILInterface (G4bool physOnly=true) const

const G4VProcess *	GetMasterProcess () const

const std::vector< const G4BiasingProcessInterface * > &	GetNonPhysicsBiasingProcessInterfaces () const

G4double	GetNumberOfInteractionLengthLeft () const

const std::vector< const G4BiasingProcessInterface * > &	GetPhysicsBiasingProcessInterfaces () const

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

G4double	GetPILfactor () const

G4double	GetPostStepGPIL () const

G4VBiasingOperator *	GetPreviousBiasingOperator () const

G4VBiasingOperation *	GetPreviousFinalStateBiasingOperation () const

G4VBiasingOperation *	GetPreviousNonPhysicsBiasingOperation () const

G4VBiasingOperation *	GetPreviousOccurenceBiasingOperation () const

G4double	GetPreviousStepSize () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

G4double	GetProposedSafety () const

const G4BiasingProcessSharedData *	GetSharedData () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4VProcess *	GetWrappedProcess () const

G4bool	GetWrappedProcessIsAlong () const

G4bool	GetWrappedProcessIsAtRest () const

G4bool	GetWrappedProcessIsPost () const

G4bool	isAlongStepDoItIsEnabled () const

virtual G4bool	IsApplicable (const G4ParticleDefinition &pd)

G4bool	isAtRestDoItIsEnabled () const

G4bool	IsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepGPILInterface (G4bool physOnly=true) const

G4bool	isPostStepDoItIsEnabled () const

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

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

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

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &pd)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &pd)

virtual void	ProcessDescription (std::ostream &outfile) const

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *pd, const G4String &s, G4bool f)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetProposedSafety (G4double sft)

void	SetVerboseLevel (G4int value)

void	StartTracking (G4Track *track)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *pd, const G4String &s, G4bool f)

	~G4BiasingProcessInterface ()

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

static const G4BiasingProcessSharedData *	GetSharedData (const G4ProcessManager *)

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()

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

G4VParticleChange *	pParticleChange = nullptr

G4double	theInitialNumberOfInteractionLength = -1.0

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4int	verboseLevel = 0

Private Member Functions
G4int	IdxFirstLast (G4int firstLast, G4int GPILDoIt, G4int physAll) const

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

void	ReorderBiasingVectorAsGPIL ()

void	ResetForUnbiasedTracking ()

void	SetUpFirstLastFlags ()

Private Attributes
G4double	fBiasingAlongStepGPIL

G4ForceCondition	fBiasingForceCondition

G4GPILSelection	fBiasingGPILSelection

const G4VBiasingInteractionLaw *	fBiasingInteractionLaw

G4double	fBiasingPostStepGPIL

G4double	fCurrentMinimumStep

G4Track *	fCurrentTrack

G4ParticleChangeForNothing *	fDummyParticleChange

G4VBiasingOperation *	fFinalStateBiasingOperation

G4bool	fFirstLastFlags [8]

G4bool	fIamFirstGPIL

const G4bool	fIsPhysicsBasedBiasing

G4VBiasingOperation *	fNonPhysicsBiasingOperation

G4VBiasingOperation *	fOccurenceBiasingOperation

G4ParticleChangeForOccurenceBiasing *	fOccurenceBiasingParticleChange

G4InteractionLawPhysical *	fPhysicalInteractionLaw

const G4VBiasingInteractionLaw *	fPreviousBiasingInteractionLaw

G4VBiasingOperation *	fPreviousFinalStateBiasingOperation

G4VBiasingOperation *	fPreviousNonPhysicsBiasingOperation

G4VBiasingOperation *	fPreviousOccurenceBiasingOperation

G4double	fPreviousStepSize

const G4ProcessManager *	fProcessManager

G4ProcessTable *	fProcessTable = nullptr

G4double	fProposedSafety

G4bool	fResetWrappedProcessInteractionLength

G4BiasingProcessSharedData *	fSharedData

G4VProcess *	fWrappedProcess

G4double	fWrappedProcessAlongStepGPIL

G4ForceCondition	fWrappedProcessForceCondition

G4GPILSelection	fWrappedProcessGPILSelection

G4double	fWrappedProcessInteractionLength

const G4bool	fWrappedProcessIsAlong

const G4bool	fWrappedProcessIsAtRest

const G4bool	fWrappedProcessIsPost

G4double	fWrappedProcessPostStepGPIL

G4VProcess *	masterProcessShadow = nullptr

Static Private Attributes
static G4Cache< G4bool >	fCommonEnd

static G4Cache< G4bool >	fCommonStart

static G4Cache< G4bool >	fDoCommonConfigure

static G4Cache< G4bool >	fResetInteractionLaws

Detailed Description

Definition at line 69 of file G4BiasingProcessInterface.hh.

Constructor & Destructor Documentation

◆ G4BiasingProcessInterface() [1/2]

G4BiasingProcessInterface::G4BiasingProcessInterface ( G4String name = "biasWrapper(0)" )

Definition at line 42 of file G4BiasingProcessInterface.cc.

  :  G4VProcess                           ( name    ),
     fCurrentTrack                        ( nullptr ),
     fPreviousStepSize (-1.0), fCurrentMinimumStep( -1.0 ), fProposedSafety ( -1.0),
             fOccurenceBiasingOperation( nullptr ),         fFinalStateBiasingOperation( nullptr ),         fNonPhysicsBiasingOperation( nullptr ),
     fPreviousOccurenceBiasingOperation( nullptr ), fPreviousFinalStateBiasingOperation( nullptr ), fPreviousNonPhysicsBiasingOperation( nullptr ),
     fResetWrappedProcessInteractionLength( true    ),
     fWrappedProcess                      ( nullptr ),
     fIsPhysicsBasedBiasing               ( false   ),
     fWrappedProcessIsAtRest              ( false   ),
     fWrappedProcessIsAlong               ( false   ),
     fWrappedProcessIsPost                ( false   ),
     fWrappedProcessPostStepGPIL          ( -1.0    ),
     fBiasingPostStepGPIL                 ( -1.0    ),
     fWrappedProcessInteractionLength     ( -1.0    ),
     fWrappedProcessForceCondition        ( NotForced ),
     fBiasingForceCondition               ( NotForced ),
     fWrappedProcessAlongStepGPIL         ( -1.0    ),
     fBiasingAlongStepGPIL                ( -1.0    ),
     fWrappedProcessGPILSelection         ( NotCandidateForSelection ),
     fBiasingGPILSelection                ( NotCandidateForSelection ),
     fBiasingInteractionLaw               ( nullptr ),
     fPreviousBiasingInteractionLaw       ( nullptr ),
     fPhysicalInteractionLaw              ( nullptr ),
     fOccurenceBiasingParticleChange      ( nullptr ),
     fDummyParticleChange                 ( nullptr ),
     fIamFirstGPIL                        ( false   ),
     fProcessManager                      ( nullptr ),
     fSharedData                          ( nullptr )
{
  for (G4int i = 0 ; i < 8 ; i++)  fFirstLastFlags[i] = false;
  fResetInteractionLaws.Put( true );
  fCommonStart         .Put( true );
  fCommonEnd           .Put( true );
  fDoCommonConfigure   .Put( true );
}

References fCommonEnd, fCommonStart, fDoCommonConfigure, fFirstLastFlags, fResetInteractionLaws, and G4Cache< VALTYPE >::Put().

◆ G4BiasingProcessInterface() [2/2]

G4BiasingProcessInterface::G4BiasingProcessInterface	(	G4VProcess *	wrappedProcess,
		G4bool	wrappedIsAtRest,
		G4bool	wrappedIsAlongStep,
		G4bool	wrappedIsPostStep,
		G4String	useThisName = `""`
	)

Definition at line 80 of file G4BiasingProcessInterface.cc.

  : G4VProcess( useThisName != "" ? useThisName : "biasWrapper("+wrappedProcess->GetProcessName()+")",
           wrappedProcess->GetProcessType()),
    fCurrentTrack                         ( nullptr            ),
    fPreviousStepSize (-1.0), fCurrentMinimumStep( -1.0 ), fProposedSafety ( -1.0),
            fOccurenceBiasingOperation( nullptr ),         fFinalStateBiasingOperation( nullptr ),         fNonPhysicsBiasingOperation( nullptr ),
    fPreviousOccurenceBiasingOperation( nullptr ), fPreviousFinalStateBiasingOperation( nullptr ), fPreviousNonPhysicsBiasingOperation( nullptr ),
    fResetWrappedProcessInteractionLength ( false              ),
    fWrappedProcess                       ( wrappedProcess     ),
    fIsPhysicsBasedBiasing                ( true               ),
    fWrappedProcessIsAtRest               ( wrappedIsAtRest    ),
    fWrappedProcessIsAlong                ( wrappedIsAlongStep ),
    fWrappedProcessIsPost                 ( wrappedIsPostStep  ),
    fWrappedProcessPostStepGPIL           ( -1.0               ),
    fBiasingPostStepGPIL                  ( -1.0               ),
    fWrappedProcessInteractionLength      ( -1.0               ),
    fWrappedProcessForceCondition         ( NotForced          ),
    fBiasingForceCondition                ( NotForced          ),
    fWrappedProcessAlongStepGPIL          ( -1.0               ),
    fBiasingAlongStepGPIL                 ( -1.0               ),
    fWrappedProcessGPILSelection          ( NotCandidateForSelection ),
    fBiasingGPILSelection                 ( NotCandidateForSelection ),
    fBiasingInteractionLaw                ( nullptr            ),
    fPreviousBiasingInteractionLaw        ( nullptr            ),
    fPhysicalInteractionLaw               ( nullptr            ),
    fOccurenceBiasingParticleChange       ( nullptr            ),
    fIamFirstGPIL                         ( false              ),
    fProcessManager                       ( nullptr            ),
    fSharedData                           ( nullptr            )
{
  for (G4int i = 0 ; i < 8 ; i++)  fFirstLastFlags[i] = false;
  fResetInteractionLaws.Put( true );
  fCommonStart.Put(true);
  fCommonEnd.Put(true);
  fDoCommonConfigure.Put(true);
  
  SetProcessSubType(fWrappedProcess->GetProcessSubType());
 
  // -- create physical interaction law:
  fPhysicalInteractionLaw         = new            G4InteractionLawPhysical("PhysicalInteractionLawFor("+GetProcessName()+")");
  // -- instantiate particle change wrapper for occurrence biaising:
  fOccurenceBiasingParticleChange = new G4ParticleChangeForOccurenceBiasing("biasingPCfor"+GetProcessName());
  // -- instantiate a "do nothing" particle change:
  fDummyParticleChange            = new          G4ParticleChangeForNothing();
}

References fCommonEnd, fCommonStart, fDoCommonConfigure, fDummyParticleChange, fFirstLastFlags, fOccurenceBiasingParticleChange, fPhysicalInteractionLaw, fResetInteractionLaws, fWrappedProcess, G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4Cache< VALTYPE >::Put(), and G4VProcess::SetProcessSubType().

◆ ~G4BiasingProcessInterface()

G4BiasingProcessInterface::~G4BiasingProcessInterface ( )

Definition at line 130 of file G4BiasingProcessInterface.cc.

{
  if ( fPhysicalInteractionLaw  != 0   ) delete fPhysicalInteractionLaw;
  if ( fOccurenceBiasingParticleChange ) delete fOccurenceBiasingParticleChange;
  if ( fDummyParticleChange            ) delete fDummyParticleChange;
}

References fDummyParticleChange, fOccurenceBiasingParticleChange, and fPhysicalInteractionLaw.

Member Function Documentation

◆ AlongStepDoIt()

G4VParticleChange * G4BiasingProcessInterface::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Implements G4VProcess.

Definition at line 648 of file G4BiasingProcessInterface.cc.

{
  
  // ---------------------------------------
  // -- case outside of volume with biasing:
  // ---------------------------------------
  if ( fSharedData->fCurrentBiasingOperator == 0 )
    {
      if ( fWrappedProcessIsAlong ) return fWrappedProcess->AlongStepDoIt(track, step);
      else
    {
      fDummyParticleChange->Initialize( track );
      return fDummyParticleChange;
    }
    }
  
  // -----------------------------------
  // -- case inside volume with biasing:
  // -----------------------------------
  if ( fWrappedProcessIsAlong ) fOccurenceBiasingParticleChange->SetWrappedParticleChange( fWrappedProcess->AlongStepDoIt(track, step) );
  else  
    {
      fOccurenceBiasingParticleChange->SetWrappedParticleChange ( 0 );
      fOccurenceBiasingParticleChange->ProposeTrackStatus( track.GetTrackStatus() );
    }
  G4double weightForNonInteraction (1.0);
  if ( fBiasingInteractionLaw != 0 ) 
    {
      weightForNonInteraction =
    fPhysicalInteractionLaw->ComputeNonInteractionProbabilityAt(step.GetStepLength()) /
    fBiasingInteractionLaw ->ComputeNonInteractionProbabilityAt(step.GetStepLength());
      
      fOccurenceBiasingOperation->AlongMoveBy( this, &step, weightForNonInteraction );
 
      if ( weightForNonInteraction <= 0. )
    {
      G4ExceptionDescription ed;
      ed << " Negative non interaction weight : w_NI = " << weightForNonInteraction <<
        " p_NI(phys) = " <<  fPhysicalInteractionLaw->ComputeNonInteractionProbabilityAt(step.GetStepLength()) <<
        " p_NI(bias) = " <<  fBiasingInteractionLaw ->ComputeNonInteractionProbabilityAt(step.GetStepLength()) <<
        " step length = "  <<  step.GetStepLength() <<
        " biasing interaction law = `" << fBiasingInteractionLaw->GetName() << "'" << G4endl;
      G4Exception(" G4BiasingProcessInterface::AlongStepDoIt(...)",
              "BIAS.GEN.04",
              JustWarning,
              ed);
    }
      
    }
  
  fOccurenceBiasingParticleChange->SetOccurenceWeightForNonInteraction( weightForNonInteraction );
  
  return fOccurenceBiasingParticleChange;
 
}

References G4VBiasingOperation::AlongMoveBy(), G4VProcess::AlongStepDoIt(), G4InteractionLawPhysical::ComputeNonInteractionProbabilityAt(), G4VBiasingInteractionLaw::ComputeNonInteractionProbabilityAt(), fBiasingInteractionLaw, G4BiasingProcessSharedData::fCurrentBiasingOperator, fDummyParticleChange, fOccurenceBiasingOperation, fOccurenceBiasingParticleChange, fPhysicalInteractionLaw, fSharedData, fWrappedProcess, fWrappedProcessIsAlong, G4endl, G4Exception(), G4VBiasingInteractionLaw::GetName(), G4Step::GetStepLength(), G4Track::GetTrackStatus(), G4ParticleChangeForNothing::Initialize(), JustWarning, G4VParticleChange::ProposeTrackStatus(), G4ParticleChangeForOccurenceBiasing::SetOccurenceWeightForNonInteraction(), and G4ParticleChangeForOccurenceBiasing::SetWrappedParticleChange().

◆ AlongStepGetPhysicalInteractionLength()

G4double G4BiasingProcessInterface::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)

virtual

Implements G4VProcess.

Definition at line 569 of file G4BiasingProcessInterface.cc.

{
  
  // -- for helper methods:
  fCurrentMinimumStep = currentMinimumStep;
  fProposedSafety     = proposedSafety;
  
 
  // -- initialization default case:
  fWrappedProcessAlongStepGPIL =                  DBL_MAX;
  *selection                   = NotCandidateForSelection;
  // ---------------------------------------
  // -- case outside of volume with biasing:
  // ---------------------------------------
  if ( fSharedData->fCurrentBiasingOperator == 0 )
    {
      if ( fWrappedProcessIsAlong ) fWrappedProcessAlongStepGPIL = 
                      fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                 previousStepSize,
                                                 currentMinimumStep, 
                                                 proposedSafety, 
                                                 selection);
      return fWrappedProcessAlongStepGPIL;
    }
  
  // --------------------------------------------------------------------
  // -- non-physics based biasing: no along operation expected (for now):
  // --------------------------------------------------------------------
  if ( !fIsPhysicsBasedBiasing ) return fWrappedProcessAlongStepGPIL;
  
  // ----------------------
  // -- physics-based case:
  // ----------------------
  if ( fOccurenceBiasingOperation == 0 )
    {
      if ( fWrappedProcessIsAlong ) fWrappedProcessAlongStepGPIL =
                      fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                 previousStepSize,
                                                 currentMinimumStep, 
                                                 proposedSafety, 
                                                 selection);
      return fWrappedProcessAlongStepGPIL;
    }
 
  
  // -----------------------------------------------------------
  // -- From here we have an valid occurrence biasing operation:
  // -----------------------------------------------------------
  // -- Give operation opportunity to shorten step proposed by physics process:
  fBiasingAlongStepGPIL =  fOccurenceBiasingOperation->ProposeAlongStepLimit( this );
  G4double minimumStep  = fBiasingAlongStepGPIL < currentMinimumStep ? fBiasingAlongStepGPIL : currentMinimumStep ;
  // -- wrapped process is called with minimum step ( <= currentMinimumStep passed ) : an along process can not
  // -- have its operation stretched over what it expects:
  if ( fWrappedProcessIsAlong )
    {
      fWrappedProcessAlongStepGPIL = fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                previousStepSize,
                                                minimumStep, 
                                                proposedSafety, 
                                                selection);
      fWrappedProcessGPILSelection = *selection;
      fBiasingGPILSelection        = fOccurenceBiasingOperation->ProposeGPILSelection( fWrappedProcessGPILSelection );
    }
  else
    {
      fBiasingGPILSelection        = fOccurenceBiasingOperation->ProposeGPILSelection( NotCandidateForSelection );
      fWrappedProcessAlongStepGPIL = fBiasingAlongStepGPIL;
    }
  
  *selection = fBiasingGPILSelection;
 
  return fWrappedProcessAlongStepGPIL;
 
}

References G4VProcess::AlongStepGetPhysicalInteractionLength(), DBL_MAX, fBiasingAlongStepGPIL, fBiasingGPILSelection, G4BiasingProcessSharedData::fCurrentBiasingOperator, fCurrentMinimumStep, fIsPhysicsBasedBiasing, fOccurenceBiasingOperation, fProposedSafety, fSharedData, fWrappedProcess, fWrappedProcessAlongStepGPIL, fWrappedProcessGPILSelection, fWrappedProcessIsAlong, NotCandidateForSelection, G4VBiasingOperation::ProposeAlongStepLimit(), and G4VBiasingOperation::ProposeGPILSelection().

◆ 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 * G4BiasingProcessInterface::AtRestDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Implements G4VProcess.

Definition at line 711 of file G4BiasingProcessInterface.cc.

{
  return  fWrappedProcess->AtRestDoIt(track, step);
}

References G4VProcess::AtRestDoIt(), and fWrappedProcess.

◆ AtRestGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 706 of file G4BiasingProcessInterface.cc.

{
  return  fWrappedProcess->AtRestGetPhysicalInteractionLength(track, condition);
}

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

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

◆ BuildPhysicsTable()

void G4BiasingProcessInterface::BuildPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 741 of file G4BiasingProcessInterface.cc.

{
  // -- Sequential mode : called second (after PreparePhysicsTable(..))
  // -- MT mode         : called second (after PreparePhysicsTable(..)) by master thread.
  // --                   Corresponding process instance not used then by tracking.
  // -- PreparePhysicsTable(...) has been called first for all processes,
  // -- so the first/last flags and G4BiasingProcessInterface vector of processes have
  // -- been properly setup, fIamFirstGPIL is valid.
  if ( fWrappedProcess != 0 )
    {
      fWrappedProcess->BuildPhysicsTable(pd);
    }
 
  if ( fIamFirstGPIL )
    {
      // -- Re-order vector of processes to match that of the GPIL
      // -- (made for fIamFirstGPIL, but important is to have it made once):
      ReorderBiasingVectorAsGPIL();
      // -- Let operators to configure themselves for the master thread or for sequential mode.
      // -- Intended here is in particular the registration to physics model catalog.
      // -- The fDoCommonConfigure is to ensure that this Configure is made by only one process (othewise each first process makes the call):
      if ( fDoCommonConfigure.Get() )
    {
      for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
        ( G4VBiasingOperator::GetBiasingOperators() )[optr]->Configure( );
      fDoCommonConfigure.Put(false);
    }
      
    }
}

References G4VProcess::BuildPhysicsTable(), demo::Configure(), fDoCommonConfigure, fIamFirstGPIL, fWrappedProcess, G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), G4Cache< VALTYPE >::Put(), and ReorderBiasingVectorAsGPIL().

◆ BuildWorkerPhysicsTable()

void G4BiasingProcessInterface::BuildWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 838 of file G4BiasingProcessInterface.cc.

{
  // -- Sequential mode : not called
  // -- MT mode         : called after PrepareWorkerPhysicsTable(..)
  // -- PrepareWorkerPhysicsTable(...) has been called first for all processes,
  // -- so the first/last flags and G4BiasingProcessInterface vector of processes have
  // -- been properly setup, fIamFirstGPIL is valid.
  if ( fWrappedProcess != 0 )
    {
      fWrappedProcess->BuildWorkerPhysicsTable(pd);
    }
 
  if ( fIamFirstGPIL )
    {
      // -- Re-order vector of processes to match that of the GPIL
      // -- (made for fIamFirstGPIL, but important is to have it made once):
      ReorderBiasingVectorAsGPIL();
      // -- Let operators to configure themselves for the worker thread, if needed.
      // -- Registration to physics model catalog **IS NOT** to be made here, but in Configure().
      // -- The fDoCommonConfigure is to ensure that this Configure is made by only one process (othewise each first process makes the call):
      if ( fDoCommonConfigure.Get() )
    {
      for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
        ( G4VBiasingOperator::GetBiasingOperators() )[optr]->ConfigureForWorker( );
      fDoCommonConfigure.Put(false);
    }
    }
}

References G4VProcess::BuildWorkerPhysicsTable(), fDoCommonConfigure, fIamFirstGPIL, fWrappedProcess, G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), G4Cache< VALTYPE >::Put(), and ReorderBiasingVectorAsGPIL().

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

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

◆ EndTracking()

void G4BiasingProcessInterface::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 184 of file G4BiasingProcessInterface.cc.

{
  if ( fIsPhysicsBasedBiasing ) fWrappedProcess->EndTracking();
  if ( fSharedData->fCurrentBiasingOperator) (fSharedData->fCurrentBiasingOperator)->ExitingBiasing( fCurrentTrack, this ); 
  fBiasingInteractionLaw = 0;
 
  // -- Inform operators of end of tracking:
  if ( fCommonEnd.Get() )
    {
      fCommonEnd  .Put( false );// = false;
      fCommonStart.Put( true  );// = true;
      
      for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
    ( G4VBiasingOperator::GetBiasingOperators() )[optr]->EndTracking( );
 
      // -- §§ for above loop, do as in StartTracking.
    }
}

References EndTracking(), G4VProcess::EndTracking(), fBiasingInteractionLaw, fCommonEnd, fCommonStart, G4BiasingProcessSharedData::fCurrentBiasingOperator, fCurrentTrack, fIsPhysicsBasedBiasing, fSharedData, fWrappedProcess, G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), and G4Cache< VALTYPE >::Put().

Referenced by EndTracking().

◆ GetAlongStepGPIL()

G4double G4BiasingProcessInterface::GetAlongStepGPIL ( ) const

inline

Definition at line 153 of file G4BiasingProcessInterface.hh.

153{ return fWrappedProcessAlongStepGPIL; }

References fWrappedProcessAlongStepGPIL.

Referenced by G4BOptnForceCommonTruncatedExp::ApplyFinalStateBiasing().

◆ GetBiasingProcessInterfaces()

const std::vector< const G4BiasingProcessInterface * > & G4BiasingProcessInterface::GetBiasingProcessInterfaces ( ) const

inline

Definition at line 106 of file G4BiasingProcessInterface.hh.

107 {return fSharedData-> fPublicBiasingProcessInterfaces;}

References fSharedData.

◆ GetCurrentBiasingOperator()

G4VBiasingOperator * G4BiasingProcessInterface::GetCurrentBiasingOperator ( ) const

inline

Definition at line 92 of file G4BiasingProcessInterface.hh.

92{return fSharedData-> fCurrentBiasingOperator; }

References fSharedData.

◆ GetCurrentFinalStateBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetCurrentFinalStateBiasingOperation ( ) const

inline

Definition at line 99 of file G4BiasingProcessInterface.hh.

99{ return fFinalStateBiasingOperation; }

References fFinalStateBiasingOperation.

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

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

◆ GetCurrentMinimumStep()

G4double G4BiasingProcessInterface::GetCurrentMinimumStep ( ) const

inline

Definition at line 148 of file G4BiasingProcessInterface.hh.

148{ return fCurrentMinimumStep;}

References fCurrentMinimumStep.

◆ GetCurrentNonPhysicsBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetCurrentNonPhysicsBiasingOperation ( ) const

inline

Definition at line 95 of file G4BiasingProcessInterface.hh.

95{ return fNonPhysicsBiasingOperation; }

References fNonPhysicsBiasingOperation.

◆ GetCurrentOccurenceBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetCurrentOccurenceBiasingOperation ( ) const

inline

Definition at line 97 of file G4BiasingProcessInterface.hh.

97{ return fOccurenceBiasingOperation; }

References fOccurenceBiasingOperation.

Referenced by G4BOptrForceCollision::ProposeFinalStateBiasingOperation().

◆ GetIsFirstPostStepDoItInterface()

G4bool G4BiasingProcessInterface::GetIsFirstPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 902 of file G4BiasingProcessInterface.cc.

{
  G4int iPhys = ( physOnly ) ? 1 : 0;
  return fFirstLastFlags[IdxFirstLast( 1, 0, iPhys)];
}

References fFirstLastFlags, and IdxFirstLast().

Referenced by G4BOptnForceFreeFlight::ApplyFinalStateBiasing().

◆ GetIsFirstPostStepGPILInterface()

G4bool G4BiasingProcessInterface::GetIsFirstPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 888 of file G4BiasingProcessInterface.cc.

{
  G4int iPhys = ( physOnly ) ? 1 : 0;
  return fFirstLastFlags[IdxFirstLast( 1, 1, iPhys)];
}

References fFirstLastFlags, and IdxFirstLast().

Referenced by SetUpFirstLastFlags().

◆ GetIsLastPostStepDoItInterface()

G4bool G4BiasingProcessInterface::GetIsLastPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 909 of file G4BiasingProcessInterface.cc.

{
  G4int iPhys = ( physOnly ) ? 1 : 0;
  return fFirstLastFlags[IdxFirstLast( 0, 0, iPhys)];
}

References fFirstLastFlags, and IdxFirstLast().

◆ GetIsLastPostStepGPILInterface()

G4bool G4BiasingProcessInterface::GetIsLastPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 895 of file G4BiasingProcessInterface.cc.

{
  G4int iPhys = ( physOnly ) ? 1 : 0;
  return fFirstLastFlags[IdxFirstLast( 0, 1, iPhys)];
}

References fFirstLastFlags, and IdxFirstLast().

◆ 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(), SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetNonPhysicsBiasingProcessInterfaces()

const std::vector< const G4BiasingProcessInterface * > & G4BiasingProcessInterface::GetNonPhysicsBiasingProcessInterfaces ( ) const

inline

Definition at line 110 of file G4BiasingProcessInterface.hh.

111 {return fSharedData->fPublicNonPhysicsBiasingProcessInterfaces;}

G4BiasingProcessSharedData::fPublicNonPhysicsBiasingProcessInterfaces

std::vector< const G4BiasingProcessInterface * > fPublicNonPhysicsBiasingProcessInterfaces

Definition: G4BiasingProcessSharedData.hh:118

References G4BiasingProcessSharedData::fPublicNonPhysicsBiasingProcessInterfaces, and fSharedData.

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsBiasingProcessInterfaces()

const std::vector< const G4BiasingProcessInterface * > & G4BiasingProcessInterface::GetPhysicsBiasingProcessInterfaces ( ) const

inline

Definition at line 108 of file G4BiasingProcessInterface.hh.

109 {return fSharedData-> fPublicPhysicsBiasingProcessInterfaces;}

References fSharedData.

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

◆ GetPostStepGPIL()

G4double G4BiasingProcessInterface::GetPostStepGPIL ( ) const

inline

Definition at line 152 of file G4BiasingProcessInterface.hh.

152{ return fBiasingPostStepGPIL; }

References fBiasingPostStepGPIL.

Referenced by G4BOptnForceCommonTruncatedExp::ApplyFinalStateBiasing().

◆ GetPreviousBiasingOperator()

G4VBiasingOperator * G4BiasingProcessInterface::GetPreviousBiasingOperator ( ) const

inline

Definition at line 93 of file G4BiasingProcessInterface.hh.

93{return fSharedData->fPreviousBiasingOperator; }

G4BiasingProcessSharedData::fPreviousBiasingOperator

G4VBiasingOperator * fPreviousBiasingOperator

Definition: G4BiasingProcessSharedData.hh:104

References G4BiasingProcessSharedData::fPreviousBiasingOperator, and fSharedData.

◆ GetPreviousFinalStateBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetPreviousFinalStateBiasingOperation ( ) const

inline

Definition at line 100 of file G4BiasingProcessInterface.hh.

100{ return fPreviousFinalStateBiasingOperation; }

References fPreviousFinalStateBiasingOperation.

◆ GetPreviousNonPhysicsBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetPreviousNonPhysicsBiasingOperation ( ) const

inline

Definition at line 96 of file G4BiasingProcessInterface.hh.

96{ return fPreviousNonPhysicsBiasingOperation; }

References fPreviousNonPhysicsBiasingOperation.

◆ GetPreviousOccurenceBiasingOperation()

G4VBiasingOperation * G4BiasingProcessInterface::GetPreviousOccurenceBiasingOperation ( ) const

inline

Definition at line 98 of file G4BiasingProcessInterface.hh.

98{ return fPreviousOccurenceBiasingOperation; }

References fPreviousOccurenceBiasingOperation.

Referenced by G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation().

◆ GetPreviousStepSize()

G4double G4BiasingProcessInterface::GetPreviousStepSize ( ) const

inline

Definition at line 147 of file G4BiasingProcessInterface.hh.

147{ return fPreviousStepSize;}

References fPreviousStepSize.

Referenced by G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation().

◆ GetProcessManager()

const G4ProcessManager * G4BiasingProcessInterface::GetProcessManager ( )

virtual

Reimplemented from G4VProcess.

Definition at line 831 of file G4BiasingProcessInterface.cc.

{
  if ( fWrappedProcess != 0 ) return fWrappedProcess->GetProcessManager();
  else                        return G4VProcess::GetProcessManager();
}

References fWrappedProcess, and G4VProcess::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(), 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().

◆ GetProposedSafety()

G4double G4BiasingProcessInterface::GetProposedSafety ( ) const

inline

Definition at line 149 of file G4BiasingProcessInterface.hh.

149{ return fProposedSafety;}

References fProposedSafety.

◆ GetSharedData() [1/2]

const G4BiasingProcessSharedData * G4BiasingProcessInterface::GetSharedData ( ) const

inline

Definition at line 114 of file G4BiasingProcessInterface.hh.

114{ return fSharedData; }

References fSharedData.

Referenced by G4BOptrForceCollision::ConfigureForWorker(), G4BOptrForceCollision::ProposeOccurenceBiasingOperation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetSharedData() [2/2]

const G4BiasingProcessSharedData * G4BiasingProcessInterface::GetSharedData ( const G4ProcessManager * mgr )

static

Definition at line 138 of file G4BiasingProcessInterface.cc.

{
  G4MapCache< const G4ProcessManager*, 
          G4BiasingProcessSharedData* >::const_iterator itr =   G4BiasingProcessSharedData::fSharedDataMap.Find( mgr );
  if ( itr !=  G4BiasingProcessSharedData::fSharedDataMap.End( ) )
    {
      return (*itr).second;
    }
  else return 0;
}

References G4MapCache< KEYTYPE, VALTYPE >::Find(), and G4BiasingProcessSharedData::fSharedDataMap.

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

◆ GetWrappedProcess()

G4VProcess * G4BiasingProcessInterface::GetWrappedProcess ( ) const

inline

Definition at line 84 of file G4BiasingProcessInterface.hh.

84{return fWrappedProcess;}

References fWrappedProcess.

Referenced by G4BOptnForceCommonTruncatedExp::ApplyFinalStateBiasing(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4BOptrForceCollision::ConfigureForWorker(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4BOptrForceCollision::ProposeOccurenceBiasingOperation(), G4BOptnForceCommonTruncatedExp::ProvideOccurenceBiasingInteractionLaw(), SetMasterProcess(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetWrappedProcessIsAlong()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAlong ( ) const

inline

Definition at line 142 of file G4BiasingProcessInterface.hh.

142{ return fWrappedProcessIsAlong; }

References fWrappedProcessIsAlong.

◆ GetWrappedProcessIsAtRest()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAtRest ( ) const

inline

Definition at line 141 of file G4BiasingProcessInterface.hh.

141{ return fWrappedProcessIsAtRest; }

References fWrappedProcessIsAtRest.

◆ GetWrappedProcessIsPost()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsPost ( ) const

inline

Definition at line 143 of file G4BiasingProcessInterface.hh.

143{ return fWrappedProcessIsPost; }

References fWrappedProcessIsPost.

◆ IdxFirstLast()

G4int G4BiasingProcessInterface::IdxFirstLast	(	G4int	firstLast,
		G4int	GPILDoIt,
		G4int	physAll
	)		const

inlineprivate

Definition at line 248 of file G4BiasingProcessInterface.hh.

  {
    // -- be careful : all arguments are *assumed* to be 0 or 1. No check
    // -- for that is provided. Should be of pure internal usage.
    return 4*firstLast + 2*GPILDoIt + physAll;
  }

Referenced by GetIsFirstPostStepDoItInterface(), GetIsFirstPostStepGPILInterface(), GetIsLastPostStepDoItInterface(), GetIsLastPostStepGPILInterface(), and SetUpFirstLastFlags().

◆ InvokeWrappedProcessPostStepGPIL()

void G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

private

Definition at line 1049 of file G4BiasingProcessInterface.cc.

{
  G4double usedPreviousStepSize = previousStepSize;
  // -- if the physics process has been under occurrence biasing in the previous step
  // -- we reset it, as we don't know if it will be biased again or not in this
  // -- step. The pity is that PostStepGPIL and interaction length (cross-section)
  // -- calculations are done both in the PostStepGPIL of the process, while here we
  // -- are just interested in the calculation of the cross-section. This is a pity
  // -- as this forces to re-generated a random number for nothing.
  if ( fResetWrappedProcessInteractionLength )
    {
      fResetWrappedProcessInteractionLength = false;
      fWrappedProcess->ResetNumberOfInteractionLengthLeft();
      // -- We set "previous step size" as 0.0, to let the process believe this is first step:
      usedPreviousStepSize = 0.0;
    }
  // -- GPIL response:
  fWrappedProcessPostStepGPIL      = fWrappedProcess->PostStepGetPhysicalInteractionLength(track, usedPreviousStepSize, condition);
  fWrappedProcessForceCondition    = *condition;
  // -- and (inverse) cross-section:
  fWrappedProcessInteractionLength = fWrappedProcess->GetCurrentInteractionLength();
}

References condition(), fResetWrappedProcessInteractionLength, fWrappedProcess, fWrappedProcessForceCondition, fWrappedProcessInteractionLength, fWrappedProcessPostStepGPIL, G4VProcess::GetCurrentInteractionLength(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::ResetNumberOfInteractionLengthLeft().

◆ 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 G4BiasingProcessInterface::IsApplicable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 718 of file G4BiasingProcessInterface.cc.

{
  if ( fWrappedProcess != 0 ) return fWrappedProcess->IsApplicable(pd);
  else                        return true;
}

References fWrappedProcess, and G4VProcess::IsApplicable().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsFirstPostStepDoItInterface()

G4bool G4BiasingProcessInterface::IsFirstPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 970 of file G4BiasingProcessInterface.cc.

{
  G4bool isFirst = true;
  const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeDoIt);
  G4int thisIdx(-1);
  for (std::size_t i = 0; i < pv->size(); ++i ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
  if ( thisIdx < 0 ) return false; // -- to ignore pure along processes
  for ( std::size_t i = 0; i < (fSharedData->fBiasingProcessInterfaces).size(); ++i )
    {
      if ( (fSharedData->fBiasingProcessInterfaces)[i]->fIsPhysicsBasedBiasing || !physOnly )
    {
      G4int thatIdx(-1);
      for (std::size_t j = 0; j < pv->size(); ++j ) if ( (*pv)(j) == (fSharedData->fBiasingProcessInterfaces)[i] ) { thatIdx = j; break; }
      if ( thatIdx >= 0 ) // -- to ignore pure along processes
        {
          if ( thisIdx >  thatIdx )
        {
          isFirst = false;
          break;
        }
        }
    }
    }
  return isFirst;
}

References G4BiasingProcessSharedData::fBiasingProcessInterfaces, fProcessManager, fSharedData, G4ProcessManager::GetPostStepProcessVector(), G4ProcessVector::size(), and typeDoIt.

Referenced by SetUpFirstLastFlags().

◆ IsFirstPostStepGPILInterface()

G4bool G4BiasingProcessInterface::IsFirstPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 916 of file G4BiasingProcessInterface.cc.

{
  G4bool isFirst = true;
  const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeGPIL);
  G4int thisIdx(-1);
  for (std::size_t i = 0; i < pv->size(); ++i ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
  if ( thisIdx < 0 ) return false; // -- to ignore pure along processes
  for ( std::size_t i = 0; i < (fSharedData->fBiasingProcessInterfaces).size(); ++i )
    {
      if ( (fSharedData->fBiasingProcessInterfaces)[i]->fIsPhysicsBasedBiasing || !physOnly )
    {
      G4int thatIdx(-1);
      for (std::size_t j = 0; j < pv->size(); ++j ) if ( (*pv)(j) == (fSharedData->fBiasingProcessInterfaces)[i] ) { thatIdx = j; break; }
      if ( thatIdx >= 0 ) // -- to ignore pure along processes
        {
          if ( thisIdx >  thatIdx )
        {
          isFirst = false;
          break;
        }
        }
    }
    }
  return isFirst;
}

References G4BiasingProcessSharedData::fBiasingProcessInterfaces, fProcessManager, fSharedData, G4ProcessManager::GetPostStepProcessVector(), G4ProcessVector::size(), and typeGPIL.

Referenced by SetUpFirstLastFlags().

◆ IsLastPostStepDoItInterface()

G4bool G4BiasingProcessInterface::IsLastPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 997 of file G4BiasingProcessInterface.cc.

{
  G4bool isLast = true;
  const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeDoIt);
  G4int thisIdx(-1);
  for (std::size_t i = 0; i < pv->size(); ++i ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
  if ( thisIdx < 0 ) return false; // -- to ignore pure along processes
  for ( std::size_t i = 0; i < (fSharedData->fBiasingProcessInterfaces).size(); ++i )
    {
      if ( (fSharedData->fBiasingProcessInterfaces)[i]->fIsPhysicsBasedBiasing || !physOnly )
    {
      G4int thatIdx(-1);
      for (std::size_t j = 0; j < pv->size(); ++j ) if ( (*pv)(j) == (fSharedData->fBiasingProcessInterfaces)[i] ) { thatIdx = j; break; }
      if ( thatIdx >= 0 ) // -- to ignore pure along processes
        {
          if ( thisIdx <  thatIdx )
        {
          isLast = false;
          break;
        }
        }
    }
    }
  return isLast;  
}

References G4BiasingProcessSharedData::fBiasingProcessInterfaces, fProcessManager, fSharedData, G4ProcessManager::GetPostStepProcessVector(), G4ProcessVector::size(), and typeDoIt.

Referenced by SetUpFirstLastFlags().

◆ IsLastPostStepGPILInterface()

G4bool G4BiasingProcessInterface::IsLastPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 943 of file G4BiasingProcessInterface.cc.

{
  G4bool isLast = true;
  const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeGPIL);
  G4int thisIdx(-1);
  for (std::size_t i = 0; i < pv->size(); ++i ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
  if ( thisIdx < 0 ) return false; // -- to ignore pure along processes
  for ( std::size_t i = 0; i < (fSharedData->fBiasingProcessInterfaces).size(); ++i )
    {
      if ( (fSharedData->fBiasingProcessInterfaces)[i]->fIsPhysicsBasedBiasing || !physOnly )
    {
      G4int thatIdx(-1);
      for (std::size_t j = 0; j < pv->size(); ++j ) if ( (*pv)(j) == (fSharedData->fBiasingProcessInterfaces)[i] ) { thatIdx = j; break; }
      if ( thatIdx >= 0 ) // -- to ignore pure along processes
        {
          if ( thisIdx <  thatIdx )
        {
          isLast = false;
          break;
        }
        }
    }
    }
  return isLast;  
}

References G4BiasingProcessSharedData::fBiasingProcessInterfaces, fProcessManager, fSharedData, G4ProcessManager::GetPostStepProcessVector(), G4ProcessVector::size(), and typeGPIL.

Referenced by SetUpFirstLastFlags().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ operator!=()

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

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator==()

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

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PostStepDoIt()

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

virtual

Implements G4VProcess.

Definition at line 447 of file G4BiasingProcessInterface.cc.

{
  // ---------------------------------------
  // -- case outside of volume with biasing:
  // ---------------------------------------
  if ( fSharedData->fCurrentBiasingOperator == 0 ) return fWrappedProcess->PostStepDoIt(track, step);
  
  // ----------------------------
  // -- non-physics biasing case:
  // ----------------------------
  if ( !fIsPhysicsBasedBiasing )
    {
      G4VParticleChange* particleChange = fNonPhysicsBiasingOperation->GenerateBiasingFinalState( &track, &step );
      (fSharedData->fCurrentBiasingOperator)->ReportOperationApplied( this, BAC_NonPhysics, fNonPhysicsBiasingOperation, particleChange );
      return particleChange;
    }
 
  // -- physics biasing case:
  // ------------------------
  // -- It proceeds with the following logic:
  // -- 1) Obtain the final state
  // --    This final state may be analog or biased.
  // --    The biased final state is obtained through a biasing operator
  // --    returned by the operator.
  // -- 2) The biased final state may be asked to be "force as it is"
  // --    in what case the particle change is returned as is to the
  // --    stepping.
  // --    In all other cases (analog final state or biased final but
  // --    not forced) the final state weight may be modified by the
  // --    occurrence biasing, if such an occurrence biasing is at play.
  
  // -- Get final state, biased or analog:
  G4VParticleChange*   finalStateParticleChange;
  G4BiasingAppliedCase BAC;
  fFinalStateBiasingOperation = (fSharedData->fCurrentBiasingOperator)->GetProposedFinalStateBiasingOperation( &track, this );
  // -- Flag below is to force the biased generated particle change to be returned "as is" to the stepping, disregarding there
  // -- was or not a occurrence biasing that would apply. Weight relevance under full responsibility of the biasing operation.
  G4bool forceBiasedFinalState = false;
  if ( fFinalStateBiasingOperation != 0 )
    {
      finalStateParticleChange = fFinalStateBiasingOperation->ApplyFinalStateBiasing( this, &track, &step, forceBiasedFinalState );
      BAC = BAC_FinalState;
    }
  else
    {
      finalStateParticleChange = fWrappedProcess->PostStepDoIt(track, step);
      BAC =  BAC_None ;
    }
  
  // -- if no occurrence biasing operation, we're done:
  if ( fOccurenceBiasingOperation == 0 )
    {
      (fSharedData->fCurrentBiasingOperator)->ReportOperationApplied( this, BAC, fFinalStateBiasingOperation, finalStateParticleChange );
      return finalStateParticleChange;
    }
  
  // -- if biased final state has been asked to be forced, we're done:
  if ( forceBiasedFinalState )
    {
      (fSharedData->fCurrentBiasingOperator)->ReportOperationApplied( this, BAC, fFinalStateBiasingOperation, finalStateParticleChange );
      return finalStateParticleChange;
    }
  
 
  // -- If occurrence biasing, applies the occurrence biasing weight correction on top of final state (biased or not):
  G4double weightForInteraction = 1.0;
  if ( !fBiasingInteractionLaw->IsSingular() ) weightForInteraction =
                         fPhysicalInteractionLaw->ComputeEffectiveCrossSectionAt(step.GetStepLength()) /
                         fBiasingInteractionLaw ->ComputeEffectiveCrossSectionAt(step.GetStepLength());
  else
    {
      // -- at this point effective XS can only be infinite, if not, there is a logic problem
      if ( !fBiasingInteractionLaw->IsEffectiveCrossSectionInfinite() )
    {
      G4ExceptionDescription ed;
      ed << "Internal inconsistency in cross-section handling. Please report !" << G4endl;
      G4Exception(" G4BiasingProcessInterface::PostStepDoIt(...)",
              "BIAS.GEN.02",
              JustWarning,
              ed);
      // -- if XS is infinite, weight is zero (and will stay zero), but we'll do differently.
      // -- Should foresee in addition something to remember that in case of singular
      // -- distribution, weight can only be partly calculated
    }
    }
  
  if ( weightForInteraction <= 0. )
    {
      G4ExceptionDescription ed;
      ed << " Negative interaction weight : w_I = "
     <<  weightForInteraction <<
    " XS_I(phys) = "       << fBiasingInteractionLaw ->ComputeEffectiveCrossSectionAt(step.GetStepLength()) <<
    " XS_I(bias) = "       << fPhysicalInteractionLaw->ComputeEffectiveCrossSectionAt(step.GetStepLength()) <<
    " step length = "      << step.GetStepLength() <<
    " Interaction law = `" << fBiasingInteractionLaw << "'" <<
    G4endl;
      G4Exception(" G4BiasingProcessInterface::PostStepDoIt(...)",
          "BIAS.GEN.03",
          JustWarning,
          ed);
      
    }
  
  (fSharedData->fCurrentBiasingOperator)->ReportOperationApplied( this,                        BAC,
                                  fOccurenceBiasingOperation,  weightForInteraction,
                                  fFinalStateBiasingOperation, finalStateParticleChange );
 
 
  fOccurenceBiasingParticleChange->SetOccurenceWeightForInteraction( weightForInteraction );
  fOccurenceBiasingParticleChange->SetSecondaryWeightByProcess( true );
  fOccurenceBiasingParticleChange->SetWrappedParticleChange( finalStateParticleChange );
  fOccurenceBiasingParticleChange->ProposeTrackStatus( finalStateParticleChange->GetTrackStatus() );
  fOccurenceBiasingParticleChange->StealSecondaries(); // -- this also makes weightForInteraction applied to secondaries stolen
 
  // -- finish:
  return fOccurenceBiasingParticleChange;
  
}

References G4VBiasingOperation::ApplyFinalStateBiasing(), BAC_FinalState, BAC_None, BAC_NonPhysics, G4InteractionLawPhysical::ComputeEffectiveCrossSectionAt(), G4VBiasingInteractionLaw::ComputeEffectiveCrossSectionAt(), fBiasingInteractionLaw, G4BiasingProcessSharedData::fCurrentBiasingOperator, fFinalStateBiasingOperation, fIsPhysicsBasedBiasing, fNonPhysicsBiasingOperation, fOccurenceBiasingOperation, fOccurenceBiasingParticleChange, fPhysicalInteractionLaw, fSharedData, fWrappedProcess, G4endl, G4Exception(), G4VBiasingOperation::GenerateBiasingFinalState(), G4Step::GetStepLength(), G4VParticleChange::GetTrackStatus(), G4VBiasingInteractionLaw::IsEffectiveCrossSectionInfinite(), G4VBiasingInteractionLaw::IsSingular(), JustWarning, G4VProcess::PostStepDoIt(), G4VParticleChange::ProposeTrackStatus(), G4ParticleChangeForOccurenceBiasing::SetOccurenceWeightForInteraction(), G4VParticleChange::SetSecondaryWeightByProcess(), G4ParticleChangeForOccurenceBiasing::SetWrappedParticleChange(), and G4ParticleChangeForOccurenceBiasing::StealSecondaries().

◆ PostStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 205 of file G4BiasingProcessInterface.cc.

{
 
  // ---------------------------------------------------------------------------------------------------
  // -- The "biasing process master" takes care of updating the biasing operator, and for all biasing
  // -- processes it invokes the PostStepGPIL of physical wrapped processes (anticipate stepping manager
  // -- call ! ) to make all cross-sections updated with current step, and hence available before the
  // -- first call to the biasing operator.
  // ---------------------------------------------------------------------------------------------------
  if ( fIamFirstGPIL )
    {
      // -- Update previous biasing operator, and assume the operator stays the same by
      // -- default and that it is not left at the beginning of this step. These
      // -- assumptions might be wrong if there is a volume change (in paralllel or
      // -- mass geometries) in what case the flags will be updated.
      fSharedData->fPreviousBiasingOperator = fSharedData->fCurrentBiasingOperator;
      fSharedData->fIsNewOperator           = false;
      fSharedData->fLeavingPreviousOperator = false;
      // -- If new volume, either in mass or parallel geometries, get possible new biasing operator:
      // -------------------------------------------------------------------------------------------
      // -- Get biasing operator in parallel geometries:
      G4bool firstStepInParallelVolume = false;
      if ( fSharedData->fParallelGeometriesLimiterProcess )
    {
      G4VBiasingOperator* newParallelOperator( nullptr );
      G4bool firstStep = ( track.GetCurrentStepNumber() == 1 );
      size_t iParallel = 0;
      for ( auto wasLimiting : fSharedData->fParallelGeometriesLimiterProcess->GetWasLimiting() )
        {
          if ( firstStep || wasLimiting )
        {
          firstStepInParallelVolume = true;
          
          auto tmpParallelOperator = G4VBiasingOperator::GetBiasingOperator( (fSharedData->fParallelGeometriesLimiterProcess->GetCurrentVolumes()[iParallel])
                                             ->GetLogicalVolume()                                                             );
          if ( newParallelOperator )
            {
              if ( tmpParallelOperator )
            {
              G4ExceptionDescription ed;
              ed << " Several biasing operators are defined at the same place in parallel geometries ! Found:\n";
              ed << "    - `" << newParallelOperator->GetName() << "' and \n";
              ed << "    - `" << tmpParallelOperator->GetName() << "'.\n";
              ed << " Keeping `" << newParallelOperator->GetName() << "'. Behavior not guaranteed ! Please consider having only one operator at a place. " << G4endl;
              G4Exception(" G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(...)",
                      "BIAS.GEN.30",
                      JustWarning,
                      ed);
            }
            }
          else newParallelOperator = tmpParallelOperator;
        }
          iParallel++;
        }
      fSharedData->fParallelGeometryOperator = newParallelOperator;
    } // -- end of " if ( fSharedData->fParallelGeometriesLimiterProcess )"
 
      // -- Get biasing operator in mass geometry:
      // -- [§§ Note : bug with this first step ? Does not work if previous step was concurrently limited with geometry. Might make use of safety at last point ?]
      G4bool  firstStepInVolume = ( (track.GetStep()->GetPreStepPoint()->GetStepStatus() == fGeomBoundary) || (track.GetCurrentStepNumber() == 1) );
      //      fSharedData->fIsNewOperator           = false;
      //      fSharedData->fLeavingPreviousOperator = false;
      if ( firstStepInVolume )
    {
      G4VBiasingOperator* newOperator = G4VBiasingOperator::GetBiasingOperator( track.GetVolume()->GetLogicalVolume() );
      fSharedData->fMassGeometryOperator = newOperator;
      if ( ( newOperator != nullptr ) && ( fSharedData->fParallelGeometryOperator != nullptr ) )
        {
          G4ExceptionDescription ed;
          ed << " Biasing operators are defined at the same place in mass and parallel geometries ! Found:\n";
          ed << "    - `" << fSharedData->fParallelGeometryOperator->GetName() << "' in parallel geometry and \n";
          ed << "    - `" << newOperator->GetName() << "' in mass geometry.\n";
          ed << " Keeping `" << fSharedData->fParallelGeometryOperator->GetName() << "'. Behavior not guaranteed ! Please consider having only one operator at a place. " << G4endl;
          G4Exception(" G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(...)",
              "BIAS.GEN.31",
              JustWarning,
              ed);
        }
    }
 
      // -- conclude the operator selection, giving priority to parallel geometry (as told in exception message BIAS.GEN.30):
      if ( firstStepInVolume || firstStepInParallelVolume )
    {
      G4VBiasingOperator*           newOperator = fSharedData->fParallelGeometryOperator;
      if ( newOperator == nullptr ) newOperator = fSharedData->fMassGeometryOperator;
      
      fSharedData->fCurrentBiasingOperator = newOperator ;
 
      if ( newOperator != fSharedData->fPreviousBiasingOperator )
        {
          fSharedData->fLeavingPreviousOperator = ( fSharedData->fPreviousBiasingOperator != nullptr ) ;
          fSharedData->fIsNewOperator           = ( newOperator != nullptr );
        }
    }
      
 
      // -- calls to wrapped process PostStepGPIL's:
      // -------------------------------------------
      // -- Each physics wrapper process has its
      // --   fWrappedProcessPostStepGPIL      ,
      // --   fWrappedProcessForceCondition    ,
      // --   fWrappedProcessInteractionLength
      // -- updated.
      if ( fSharedData->fCurrentBiasingOperator != nullptr )
    {
      for ( size_t i = 0 ; i < (fSharedData->fPhysicsBiasingProcessInterfaces).size(); i++ )
        (fSharedData->fPhysicsBiasingProcessInterfaces)[i]->InvokeWrappedProcessPostStepGPIL( track, previousStepSize, condition );
    }
    } // -- end of "if ( fIamFirstGPIL )"
 
  
 
  // -- Remember previous operator and proposed operations, if any, and reset:
  // -------------------------------------------------------------------------
  // -- remember only in case some biasing might be called
  if ( ( fSharedData->fPreviousBiasingOperator != 0 ) ||
       ( fSharedData->fCurrentBiasingOperator  != 0 )    )
    {
      fPreviousOccurenceBiasingOperation  =  fOccurenceBiasingOperation;
      fPreviousFinalStateBiasingOperation = fFinalStateBiasingOperation;
      fPreviousNonPhysicsBiasingOperation = fNonPhysicsBiasingOperation;
      fPreviousBiasingInteractionLaw      =      fBiasingInteractionLaw;
      // -- reset:
      fOccurenceBiasingOperation          =                           0;
      fFinalStateBiasingOperation         =                           0;
      fNonPhysicsBiasingOperation         =                           0;
      fBiasingInteractionLaw              =                           0;
      // -- Physics PostStep and AlongStep GPIL
      // fWrappedProcessPostStepGPIL      : updated by InvokeWrappedProcessPostStepGPIL(...) above
      fBiasingPostStepGPIL                =                     DBL_MAX;
      // fWrappedProcessInteractionLength : updated by InvokeWrappedProcessPostStepGPIL(...) above; inverse of analog cross-section.
      // fWrappedProcessForceCondition    : updated by InvokeWrappedProcessPostStepGPIL(...) above
      fBiasingForceCondition              =                   NotForced;
      fWrappedProcessAlongStepGPIL        =                     DBL_MAX;
      fBiasingAlongStepGPIL               =                     DBL_MAX;
      fWrappedProcessGPILSelection        =    NotCandidateForSelection;
      fBiasingGPILSelection               =    NotCandidateForSelection;
      // -- for helper:
      fPreviousStepSize                   =            previousStepSize;
    }
 
  
  // -- previous step size value; it is switched to zero if resetting a wrapped process:
  // -- (same trick used than in InvokedWrappedProcessPostStepGPIL )
  G4double usedPreviousStepSize = previousStepSize;
 
  // ----------------------------------------------
  // -- If leaving a biasing operator, let it know:
  // ----------------------------------------------
  if ( fSharedData->fLeavingPreviousOperator )
    {
      (fSharedData->fPreviousBiasingOperator)->ExitingBiasing( &track, this ); 
      // -- if no further biasing operator, reset process behavior to standard tracking:
      if ( fSharedData->fCurrentBiasingOperator == 0 )
    {
      ResetForUnbiasedTracking();
      if ( fIsPhysicsBasedBiasing )
        {
          // -- if the physics process has been under occurrence biasing, reset it:
          if ( fResetWrappedProcessInteractionLength )
        {
          fResetWrappedProcessInteractionLength = false;
          fWrappedProcess->ResetNumberOfInteractionLengthLeft();
          // -- We set "previous step size" as 0.0, to let the process believe this is first step:
          usedPreviousStepSize = 0.0;
        }
        }
    }
    }
  
 
  // --------------------------------------------------------------
  // -- no operator : analog tracking if physics-based, or nothing:
  // --------------------------------------------------------------
  if ( fSharedData->fCurrentBiasingOperator == 0 )
    {
      // -- take note of the "usedPreviousStepSize" value:
      if ( fIsPhysicsBasedBiasing ) return fWrappedProcess->PostStepGetPhysicalInteractionLength(track, usedPreviousStepSize, condition);
      else
    {
      *condition = NotForced;
      return DBL_MAX;
    }
    }
 
  // --------------------------------------------------
  // -- A biasing operator exists. Proceed with
  // -- treating non-physics and physics biasing cases:
  //---------------------------------------------------
  
  // -- non-physics-based biasing case:
  // ----------------------------------
  if ( !fIsPhysicsBasedBiasing )
    {  
      fNonPhysicsBiasingOperation = (fSharedData->fCurrentBiasingOperator)->GetProposedNonPhysicsBiasingOperation( &track, this );
      if ( fNonPhysicsBiasingOperation == 0 )
    {
      *condition = NotForced;
      return DBL_MAX;
    }
      return fNonPhysicsBiasingOperation->DistanceToApplyOperation(&track, previousStepSize, condition);
    }
  
 
  // -- Physics based biasing case:
  // ------------------------------
  // -- Ask for possible GPIL biasing operation:
  fOccurenceBiasingOperation = (fSharedData->fCurrentBiasingOperator)->GetProposedOccurenceBiasingOperation( &track, this );
 
 
  // -- no operation for occurrence biasing, analog GPIL returns the wrapped process GPIL and condition values
  if ( fOccurenceBiasingOperation == 0 )
    {
      *condition = fWrappedProcessForceCondition;
      return       fWrappedProcessPostStepGPIL;
    }
 
  // -- A valid GPIL biasing operation has been proposed:
  // -- 0) remember wrapped process will need to be reset on biasing exit, if particle survives:
  fResetWrappedProcessInteractionLength = true;
  // -- 1) update process interaction length for reference analog interaction law ( fWrappedProcessInteractionLength updated/collected above):
  fPhysicalInteractionLaw->SetPhysicalCrossSection( 1.0 / fWrappedProcessInteractionLength );
  // -- 2) Collect biasing interaction law:
  // --    The interaction law pointer is collected as a const pointer to the interaction law object.
  // --    This interaction law will be kept under control of the biasing operation, which is the only
  // --    entity that will change the state of the biasing interaction law.
  // --    The force condition for biasing is asked at the same time, passing the analog one as default:
  fBiasingForceCondition           = fWrappedProcessForceCondition;
  fBiasingInteractionLaw           = fOccurenceBiasingOperation->ProvideOccurenceBiasingInteractionLaw( this, fBiasingForceCondition );
  // -- 3) Ask operation to sample the biasing interaction law:
  fBiasingPostStepGPIL             = fBiasingInteractionLaw->GetSampledInteractionLength();
 
  // -- finish
  *condition = fBiasingForceCondition;
  return       fBiasingPostStepGPIL;
 
}

◆ 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 G4BiasingProcessInterface::PreparePhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 773 of file G4BiasingProcessInterface.cc.

{
  // -- Sequential mode : called first (before BuildPhysicsTable(..))
  // -- MT mode         : called first (before BuildPhysicsTable(..)) by master thread.
  // --                   Corresponding process instance not used then by tracking.
  // -- Let process finding its first/last position in the process manager:
  SetUpFirstLastFlags();
  if ( fWrappedProcess != 0 )
    {
      fWrappedProcess->PreparePhysicsTable(pd);
    }
}

References fWrappedProcess, G4VProcess::PreparePhysicsTable(), and SetUpFirstLastFlags().

◆ PrepareWorkerPhysicsTable()

void G4BiasingProcessInterface::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 868 of file G4BiasingProcessInterface.cc.

{
  // -- Sequential mode : not called
  // -- MT mode         : called first, before BuildWorkerPhysicsTable(..)
  // -- Let process finding its first/last position in the process manager:
  SetUpFirstLastFlags();
 
  if ( fWrappedProcess != 0 )
    {
      fWrappedProcess->PrepareWorkerPhysicsTable(pd);
    }
}

References fWrappedProcess, G4VProcess::PrepareWorkerPhysicsTable(), and SetUpFirstLastFlags().

◆ ProcessDescription()

void G4VProcess::ProcessDescription ( std::ostream & outfile ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4RayleighScattering, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4ComptonScattering, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4GammaConversion, G4hIonisation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4PhotoElectricEffect, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, G4XTRTransparentRegRadModel, G4Cerenkov, G4Radioactivation, G4RadioactiveDecay, G4ElectronNuclearProcess, G4MuonNuclearProcess, G4NeutrinoElectronProcess, G4NeutronFissionProcess, G4PositronNuclearProcess, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4Transportation, G4NeutronCaptureProcess, G4GammaGeneralProcess, G4Decay, G4DecayWithSpin, G4PionDecayMakeSpin, G4UnknownDecay, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4HadronElasticProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 175 of file G4VProcess.cc.

{
  outFile << "This process has not yet been described\n";
}

Referenced by G4LossTableManager::DumpHtml(), G4HadronicProcessStore::PrintHtml(), and G4GammaGeneralProcess::ProcessDescription().

◆ ReorderBiasingVectorAsGPIL()

void G4BiasingProcessInterface::ReorderBiasingVectorAsGPIL ( )

private

Definition at line 1075 of file G4BiasingProcessInterface.cc.

{
  // -- re-order vector of processes to match that of the GPIL:
  std::vector < G4BiasingProcessInterface* > tmpProcess ( fSharedData->fBiasingProcessInterfaces );
  ( fSharedData -> fBiasingProcessInterfaces                 ) . clear();
  ( fSharedData -> fPhysicsBiasingProcessInterfaces          ) . clear();
  ( fSharedData -> fNonPhysicsBiasingProcessInterfaces       ) . clear();
  ( fSharedData -> fPublicBiasingProcessInterfaces           ) . clear();
  ( fSharedData -> fPublicPhysicsBiasingProcessInterfaces    ) . clear();
  ( fSharedData -> fPublicNonPhysicsBiasingProcessInterfaces ) . clear();
  
  const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeGPIL);
  for (std::size_t i = 0; i < pv->size(); ++i ) 
    {
      for ( std::size_t j = 0; j < tmpProcess.size(); ++j )
    {
      if ( (*pv)(i) == tmpProcess[j] )
        { 
          ( fSharedData -> fBiasingProcessInterfaces                     ) . push_back( tmpProcess[j] );
          ( fSharedData -> fPublicBiasingProcessInterfaces               ) . push_back( tmpProcess[j] );
          if ( tmpProcess[j] -> fIsPhysicsBasedBiasing )
        {
          ( fSharedData -> fPhysicsBiasingProcessInterfaces          ) . push_back( tmpProcess[j] );
          ( fSharedData -> fPublicPhysicsBiasingProcessInterfaces    ) . push_back( tmpProcess[j] ); 
        }
          else
            {
              ( fSharedData -> fNonPhysicsBiasingProcessInterfaces       ) . push_back( tmpProcess[j] );
              ( fSharedData -> fPublicNonPhysicsBiasingProcessInterfaces ) . push_back( tmpProcess[j] );  
            }
          break;
        }
    }
    }
}

References G4BiasingProcessSharedData::fBiasingProcessInterfaces, fIsPhysicsBasedBiasing, fProcessManager, fSharedData, G4ProcessManager::GetPostStepProcessVector(), G4ProcessVector::size(), and typeGPIL.

Referenced by BuildPhysicsTable(), and BuildWorkerPhysicsTable().

◆ ResetForUnbiasedTracking()

void G4BiasingProcessInterface::ResetForUnbiasedTracking ( )

private

Definition at line 1040 of file G4BiasingProcessInterface.cc.

{
  fOccurenceBiasingOperation  = 0;
  fFinalStateBiasingOperation = 0;
  fNonPhysicsBiasingOperation = 0;
  fBiasingInteractionLaw      = 0;
}

References fBiasingInteractionLaw, fFinalStateBiasingOperation, fNonPhysicsBiasingOperation, and fOccurenceBiasingOperation.

Referenced by PostStepGetPhysicalInteractionLength().

◆ ResetNumberOfInteractionLengthLeft()

void G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft ( )

virtual

Reimplemented from G4VProcess.

Definition at line 882 of file G4BiasingProcessInterface.cc.

{
  if ( fWrappedProcess != 0 ) fWrappedProcess->ResetNumberOfInteractionLengthLeft();
}

References fWrappedProcess, and G4VProcess::ResetNumberOfInteractionLengthLeft().

◆ RetrievePhysicsTable()

G4bool G4BiasingProcessInterface::RetrievePhysicsTable	(	const G4ParticleDefinition *	pd,
		const G4String &	s,
		G4bool	f
	)

virtual

Reimplemented from G4VProcess.

Definition at line 794 of file G4BiasingProcessInterface.cc.

{
  if ( fWrappedProcess != 0 ) return fWrappedProcess->RetrievePhysicsTable(pd, s, f);
  else                        return false;
}

References fWrappedProcess, G4VProcess::RetrievePhysicsTable(), and s.

◆ SetMasterProcess()

void G4BiasingProcessInterface::SetMasterProcess ( G4VProcess * masterP )

virtual

Reimplemented from G4VProcess.

Definition at line 725 of file G4BiasingProcessInterface.cc.

{
  // -- Master for this process:
  G4VProcess::SetMasterProcess(masterP);
  // -- Master for wrapped process:
  if ( fWrappedProcess != 0 )
    {
      const G4BiasingProcessInterface* thisWrapperMaster = (const G4BiasingProcessInterface *)GetMasterProcess();
      // -- paranoia check: (?)
      G4VProcess* wrappedMaster = 0;
      wrappedMaster = thisWrapperMaster->GetWrappedProcess();
      fWrappedProcess->SetMasterProcess( wrappedMaster );
    }
}

References fWrappedProcess, G4VProcess::GetMasterProcess(), GetWrappedProcess(), and G4VProcess::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 G4BiasingProcessInterface::SetProcessManager ( const G4ProcessManager * mgr )

virtual

Reimplemented from G4VProcess.

Definition at line 801 of file G4BiasingProcessInterface.cc.

{ 
  if ( fWrappedProcess != 0 ) fWrappedProcess->SetProcessManager(mgr);
  else                        G4VProcess::SetProcessManager(mgr);
 
  // -- initialize fSharedData pointer:
  if (  G4BiasingProcessSharedData::fSharedDataMap.Find(mgr) == G4BiasingProcessSharedData::fSharedDataMap.End() )
    {
      fSharedData =  new G4BiasingProcessSharedData( mgr );
      G4BiasingProcessSharedData::fSharedDataMap[mgr] = fSharedData;
    }
  else fSharedData =  G4BiasingProcessSharedData::fSharedDataMap[mgr] ;
  // -- augment list of co-operating processes:
  fSharedData->       fBiasingProcessInterfaces.push_back( this );
  fSharedData-> fPublicBiasingProcessInterfaces.push_back( this );
  if ( fIsPhysicsBasedBiasing ) 
    {
      fSharedData->       fPhysicsBiasingProcessInterfaces.push_back( this );
      fSharedData-> fPublicPhysicsBiasingProcessInterfaces.push_back( this );
    }
  else
    {
      fSharedData->       fNonPhysicsBiasingProcessInterfaces.push_back( this );
      fSharedData-> fPublicNonPhysicsBiasingProcessInterfaces.push_back( this );
    }
  // -- remember process manager:
  fProcessManager = mgr;
}

References fIsPhysicsBasedBiasing, fProcessManager, fSharedData, G4BiasingProcessSharedData::fSharedDataMap, fWrappedProcess, and G4VProcess::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(), 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().

◆ SetProposedSafety()

void G4BiasingProcessInterface::SetProposedSafety ( G4double sft )

inline

Definition at line 150 of file G4BiasingProcessInterface.hh.

150{ fProposedSafety = sft;}

References fProposedSafety.

◆ SetUpFirstLastFlags()

void G4BiasingProcessInterface::SetUpFirstLastFlags ( )

private

Definition at line 1024 of file G4BiasingProcessInterface.cc.

{
  for ( G4int iPhys = 0; iPhys < 2; iPhys++ )
    {
      G4bool physOnly = ( iPhys == 1 );
      fFirstLastFlags[IdxFirstLast( 1, 1, iPhys)] = IsFirstPostStepGPILInterface(physOnly);
      fFirstLastFlags[IdxFirstLast( 0, 1, iPhys)] =  IsLastPostStepGPILInterface(physOnly);
      fFirstLastFlags[IdxFirstLast( 1, 0, iPhys)] = IsFirstPostStepDoItInterface(physOnly);
      fFirstLastFlags[IdxFirstLast( 0, 0, iPhys)] =  IsLastPostStepDoItInterface(physOnly);
    }
  
  // -- for itself, for optimization:
  fIamFirstGPIL =  GetIsFirstPostStepGPILInterface( false );
}

References fFirstLastFlags, fIamFirstGPIL, GetIsFirstPostStepGPILInterface(), IdxFirstLast(), IsFirstPostStepDoItInterface(), IsFirstPostStepGPILInterface(), IsLastPostStepDoItInterface(), and IsLastPostStepGPILInterface().

Referenced by PreparePhysicsTable(), and PrepareWorkerPhysicsTable().

◆ 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 G4BiasingProcessInterface::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 150 of file G4BiasingProcessInterface.cc.

{
  fCurrentTrack = track;
  if ( fIsPhysicsBasedBiasing ) fWrappedProcess->StartTracking(fCurrentTrack);
  fOccurenceBiasingOperation          = 0;
  fPreviousOccurenceBiasingOperation  = 0;
  fFinalStateBiasingOperation         = 0;
  fPreviousFinalStateBiasingOperation = 0;
  fNonPhysicsBiasingOperation         = 0;
  fPreviousNonPhysicsBiasingOperation = 0;
  fBiasingInteractionLaw              = 0;
  fPreviousBiasingInteractionLaw      = 0;
  
  fPreviousStepSize           = -1.0;
  
  fResetWrappedProcessInteractionLength = false;
  
  if ( fCommonStart.Get() )
    {
      fCommonStart.Put( false );// = false;
      fCommonEnd  .Put( true  );// = true;
      
      fSharedData-> fCurrentBiasingOperator = 0;
      fSharedData->fPreviousBiasingOperator = 0;
 
      // -- §§ Add a  "fSharedData->nStarting" here and outside bracket "fSharedData->nStarting++" and " if (fSharedData->nStarting) == fSharedData->(vector interface length)"
      // -- §§ call to the loop "StartTracking" of operators"
      
      for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
    ( G4VBiasingOperator::GetBiasingOperators() )[optr]->StartTracking( fCurrentTrack );
    }
}

References fBiasingInteractionLaw, fCommonEnd, fCommonStart, fCurrentTrack, fFinalStateBiasingOperation, fIsPhysicsBasedBiasing, fNonPhysicsBiasingOperation, fOccurenceBiasingOperation, fPreviousBiasingInteractionLaw, G4BiasingProcessSharedData::fPreviousBiasingOperator, fPreviousFinalStateBiasingOperation, fPreviousNonPhysicsBiasingOperation, fPreviousOccurenceBiasingOperation, fPreviousStepSize, fResetWrappedProcessInteractionLength, fSharedData, fWrappedProcess, G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), G4Cache< VALTYPE >::Put(), G4VProcess::StartTracking(), and StartTracking().

Referenced by StartTracking().

◆ StorePhysicsTable()

G4bool G4BiasingProcessInterface::StorePhysicsTable	(	const G4ParticleDefinition *	pd,
		const G4String &	s,
		G4bool	f
	)

virtual

Reimplemented from G4VProcess.

Definition at line 787 of file G4BiasingProcessInterface.cc.

{
  if ( fWrappedProcess != 0 ) return fWrappedProcess->StorePhysicsTable(pd, s, f);
  else                        return false;
}

References fWrappedProcess, s, and G4VProcess::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);
  }
}