#include <G4BiasingProcessInterface.hh>

Inheritance diagram for G4BiasingProcessInterface:

Collaboration diagram for G4BiasingProcessInterface:

Public Member Functions
	G4BiasingProcessInterface (G4String name="biasWrapper(0)")

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

	~G4BiasingProcessInterface ()

G4VProcess *	GetWrappedProcess () const

G4VBiasingOperator *	GetCurrentBiasingOperator () const

G4VBiasingOperator *	GetPreviousBiasingOperator () const

G4VBiasingOperation *	GetCurrentNonPhysicsBiasingOperation () const

G4VBiasingOperation *	GetPreviousNonPhysicsBiasingOperation () const

G4VBiasingOperation *	GetCurrentOccurenceBiasingOperation () const

G4VBiasingOperation *	GetPreviousOccurenceBiasingOperation () const

G4VBiasingOperation *	GetCurrentFinalStateBiasingOperation () const

G4VBiasingOperation *	GetPreviousFinalStateBiasingOperation () const

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

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

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

const G4BiasingProcessSharedData *	GetSharedData () const

G4bool	GetIsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepGPILInterface (G4bool physOnly=true) const

G4bool	GetIsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepGPILInterface (G4bool physOnly=true) const

G4bool	IsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetWrappedProcessIsAtRest () const

G4bool	GetWrappedProcessIsAlong () const

G4bool	GetWrappedProcessIsPost () const

G4double	GetPreviousStepSize () const

G4double	GetCurrentMinimumStep () const

G4double	GetProposedSafety () const

void	SetProposedSafety (G4double sft)

G4double	GetPostStepGPIL () const

G4double	GetAlongStepGPIL () const

void	StartTracking (G4Track *track)

void	EndTracking ()

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

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &pd)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &pd)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &pd)

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

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

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual void	SetMasterProcess (G4VProcess *masterP)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &pd)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &pd)

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

const G4VProcess *	GetMasterProcess () const

Static Public Member Functions
static const G4BiasingProcessSharedData *	GetSharedData (const G4ProcessManager *)

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

Private Member Functions
void	SetUpFirstLastFlags ()

void	ResetForUnbiasedTracking ()

void	ReorderBiasingVectorAsGPIL ()

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

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

Private Attributes
G4Track *	fCurrentTrack

G4double	fPreviousStepSize

G4double	fCurrentMinimumStep

G4double	fProposedSafety

G4VBiasingOperation *	fOccurenceBiasingOperation

G4VBiasingOperation *	fFinalStateBiasingOperation

G4VBiasingOperation *	fNonPhysicsBiasingOperation

G4VBiasingOperation *	fPreviousOccurenceBiasingOperation

G4VBiasingOperation *	fPreviousFinalStateBiasingOperation

G4VBiasingOperation *	fPreviousNonPhysicsBiasingOperation

G4bool	fResetWrappedProcessInteractionLength

G4VProcess *	fWrappedProcess

const G4bool	fIsPhysicsBasedBiasing

const G4bool	fWrappedProcessIsAtRest

const G4bool	fWrappedProcessIsAlong

const G4bool	fWrappedProcessIsPost

G4double	fWrappedProcessPostStepGPIL

G4double	fBiasingPostStepGPIL

G4double	fWrappedProcessInteractionLength

G4ForceCondition	fWrappedProcessForceCondition

G4ForceCondition	fBiasingForceCondition

G4double	fWrappedProcessAlongStepGPIL

G4double	fBiasingAlongStepGPIL

G4GPILSelection	fWrappedProcessGPILSelection

G4GPILSelection	fBiasingGPILSelection

const G4VBiasingInteractionLaw *	fBiasingInteractionLaw

const G4VBiasingInteractionLaw *	fPreviousBiasingInteractionLaw

G4InteractionLawPhysical *	fPhysicalInteractionLaw

G4ParticleChangeForOccurenceBiasing *	fOccurenceBiasingParticleChange

G4ParticleChange *	fParticleChange

G4ParticleChangeForNothing *	fDummyParticleChange

G4bool	fFirstLastFlags [8]

G4bool	fIamFirstGPIL

const G4ProcessManager *	fProcessManager

G4BiasingProcessSharedData *	fSharedData

Static Private Attributes
static G4Cache< G4bool >	fResetInteractionLaws

static G4Cache< G4bool >	fCommonStart

static G4Cache< G4bool >	fCommonEnd

static G4Cache< G4bool >	fDoCommonConfigure

static G4MapCache< const G4ProcessManager , G4BiasingProcessSharedData >	fSharedDataMap

Additional Inherited Members
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Detailed Description

Definition at line 71 of file G4BiasingProcessInterface.hh.

Constructor & Destructor Documentation

◆ G4BiasingProcessInterface() [1/2]

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

Definition at line 44 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 ),
      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);
 }

Here is the call graph for this function:

◆ G4BiasingProcessInterface() [2/2]

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

Definition at line 81 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 ),
     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 occurence biaising:
   fOccurenceBiasingParticleChange = new G4ParticleChangeForOccurenceBiasing("biasingPCfor"+GetProcessName());
   fParticleChange                 = new                    G4ParticleChange();
   // -- instantiate a "do nothing" particle change:
   fDummyParticleChange            = new          G4ParticleChangeForNothing();
 }

Here is the call graph for this function:

◆ ~G4BiasingProcessInterface()

G4BiasingProcessInterface::~G4BiasingProcessInterface ( )

Definition at line 131 of file G4BiasingProcessInterface.cc.

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

Member Function Documentation

◆ AlongStepDoIt()

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

virtual

Implements G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AlongStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AtRestDoIt()

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

virtual

Implements G4VProcess.

Definition at line 646 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AtRestGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 641 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable()

void G4BiasingProcessInterface::BuildPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildWorkerPhysicsTable()

void G4BiasingProcessInterface::BuildWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndTracking()

void G4BiasingProcessInterface::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 186 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.
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAlongStepGPIL()

G4double G4BiasingProcessInterface::GetAlongStepGPIL ( ) const

inline

Definition at line 155 of file G4BiasingProcessInterface.hh.

155 { return fWrappedProcessAlongStepGPIL; }

G4BiasingProcessInterface::fWrappedProcessAlongStepGPIL

G4double fWrappedProcessAlongStepGPIL

Definition: G4BiasingProcessInterface.hh:239

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBiasingProcessInterfaces()

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

inline

Definition at line 108 of file G4BiasingProcessInterface.hh.

109 {return fSharedData-> fPublicBiasingProcessInterfaces;}

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

◆ GetCurrentBiasingOperator()

G4VBiasingOperator* G4BiasingProcessInterface::GetCurrentBiasingOperator ( ) const

inline

Definition at line 94 of file G4BiasingProcessInterface.hh.

94 {return fSharedData-> fCurrentBiasingOperator; }

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

◆ GetCurrentFinalStateBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentFinalStateBiasingOperation ( ) const

inline

Definition at line 101 of file G4BiasingProcessInterface.hh.

101 { return fFinalStateBiasingOperation; }

G4BiasingProcessInterface::fFinalStateBiasingOperation

G4VBiasingOperation * fFinalStateBiasingOperation

Definition: G4BiasingProcessInterface.hh:219

◆ GetCurrentMinimumStep()

G4double G4BiasingProcessInterface::GetCurrentMinimumStep ( ) const

inline

Definition at line 150 of file G4BiasingProcessInterface.hh.

150 { return fCurrentMinimumStep;}

G4BiasingProcessInterface::fCurrentMinimumStep

G4double fCurrentMinimumStep

Definition: G4BiasingProcessInterface.hh:215

◆ GetCurrentNonPhysicsBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentNonPhysicsBiasingOperation ( ) const

inline

Definition at line 97 of file G4BiasingProcessInterface.hh.

97 { return fNonPhysicsBiasingOperation; }

G4BiasingProcessInterface::fNonPhysicsBiasingOperation

G4VBiasingOperation * fNonPhysicsBiasingOperation

Definition: G4BiasingProcessInterface.hh:220

◆ GetCurrentOccurenceBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentOccurenceBiasingOperation ( ) const

inline

Definition at line 99 of file G4BiasingProcessInterface.hh.

99 { return fOccurenceBiasingOperation; }

G4BiasingProcessInterface::fOccurenceBiasingOperation

G4VBiasingOperation * fOccurenceBiasingOperation

Definition: G4BiasingProcessInterface.hh:218

Here is the caller graph for this function:

◆ GetIsFirstPostStepDoItInterface()

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

Definition at line 837 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIsFirstPostStepGPILInterface()

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

Definition at line 823 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIsLastPostStepDoItInterface()

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

Definition at line 844 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIsLastPostStepGPILInterface()

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

Definition at line 830 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNonPhysicsBiasingProcessInterfaces()

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

inline

Definition at line 112 of file G4BiasingProcessInterface.hh.

113 {return fSharedData->fPublicNonPhysicsBiasingProcessInterfaces;}

G4BiasingProcessSharedData::fPublicNonPhysicsBiasingProcessInterfaces

std::vector< const G4BiasingProcessInterface *> fPublicNonPhysicsBiasingProcessInterfaces

Definition: G4BiasingProcessSharedData.hh:108

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

◆ GetPhysicsBiasingProcessInterfaces()

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

inline

Definition at line 110 of file G4BiasingProcessInterface.hh.

111 {return fSharedData-> fPublicPhysicsBiasingProcessInterfaces;}

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

◆ GetPostStepGPIL()

G4double G4BiasingProcessInterface::GetPostStepGPIL ( ) const

inline

Definition at line 154 of file G4BiasingProcessInterface.hh.

154 { return fBiasingPostStepGPIL; }

G4BiasingProcessInterface::fBiasingPostStepGPIL

G4double fBiasingPostStepGPIL

Definition: G4BiasingProcessInterface.hh:235

Here is the caller graph for this function:

◆ GetPreviousBiasingOperator()

G4VBiasingOperator* G4BiasingProcessInterface::GetPreviousBiasingOperator ( ) const

inline

Definition at line 95 of file G4BiasingProcessInterface.hh.

95 {return fSharedData->fPreviousBiasingOperator; }

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

G4BiasingProcessSharedData::fPreviousBiasingOperator

G4VBiasingOperator * fPreviousBiasingOperator

Definition: G4BiasingProcessSharedData.hh:96

◆ GetPreviousFinalStateBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousFinalStateBiasingOperation ( ) const

inline

Definition at line 102 of file G4BiasingProcessInterface.hh.

102 { return fPreviousFinalStateBiasingOperation; }

G4BiasingProcessInterface::fPreviousFinalStateBiasingOperation

G4VBiasingOperation * fPreviousFinalStateBiasingOperation

Definition: G4BiasingProcessInterface.hh:222

◆ GetPreviousNonPhysicsBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousNonPhysicsBiasingOperation ( ) const

inline

Definition at line 98 of file G4BiasingProcessInterface.hh.

98 { return fPreviousNonPhysicsBiasingOperation; }

G4BiasingProcessInterface::fPreviousNonPhysicsBiasingOperation

G4VBiasingOperation * fPreviousNonPhysicsBiasingOperation

Definition: G4BiasingProcessInterface.hh:223

◆ GetPreviousOccurenceBiasingOperation()

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousOccurenceBiasingOperation ( ) const

inline

Definition at line 100 of file G4BiasingProcessInterface.hh.

100 { return fPreviousOccurenceBiasingOperation; }

G4BiasingProcessInterface::fPreviousOccurenceBiasingOperation

G4VBiasingOperation * fPreviousOccurenceBiasingOperation

Definition: G4BiasingProcessInterface.hh:221

Here is the caller graph for this function:

◆ GetPreviousStepSize()

G4double G4BiasingProcessInterface::GetPreviousStepSize ( ) const

inline

Definition at line 149 of file G4BiasingProcessInterface.hh.

149 { return fPreviousStepSize;}

G4BiasingProcessInterface::fPreviousStepSize

G4double fPreviousStepSize

Definition: G4BiasingProcessInterface.hh:214

Here is the caller graph for this function:

◆ GetProcessManager()

const G4ProcessManager * G4BiasingProcessInterface::GetProcessManager ( )

virtual

Reimplemented from G4VProcess.

Definition at line 766 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetProposedSafety()

G4double G4BiasingProcessInterface::GetProposedSafety ( ) const

inline

Definition at line 151 of file G4BiasingProcessInterface.hh.

151 { return fProposedSafety;}

G4BiasingProcessInterface::fProposedSafety

G4double fProposedSafety

Definition: G4BiasingProcessInterface.hh:216

◆ GetSharedData() [1/2]

const G4BiasingProcessSharedData* G4BiasingProcessInterface::GetSharedData ( ) const

inline

Definition at line 116 of file G4BiasingProcessInterface.hh.

116 { return fSharedData; }

G4BiasingProcessInterface::fSharedData

G4BiasingProcessSharedData * fSharedData

Definition: G4BiasingProcessInterface.hh:277

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSharedData() [2/2]

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

static

Definition at line 140 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

◆ GetWrappedProcess()

G4VProcess* G4BiasingProcessInterface::GetWrappedProcess ( ) const

inline

Definition at line 86 of file G4BiasingProcessInterface.hh.

86 {return fWrappedProcess;}

G4BiasingProcessInterface::fWrappedProcess

G4VProcess * fWrappedProcess

Definition: G4BiasingProcessInterface.hh:227

Here is the caller graph for this function:

◆ GetWrappedProcessIsAlong()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAlong ( ) const

inline

Definition at line 144 of file G4BiasingProcessInterface.hh.

144 { return fWrappedProcessIsAlong; }

G4BiasingProcessInterface::fWrappedProcessIsAlong

const G4bool fWrappedProcessIsAlong

Definition: G4BiasingProcessInterface.hh:230

◆ GetWrappedProcessIsAtRest()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAtRest ( ) const

inline

Definition at line 143 of file G4BiasingProcessInterface.hh.

143 { return fWrappedProcessIsAtRest; }

G4BiasingProcessInterface::fWrappedProcessIsAtRest

const G4bool fWrappedProcessIsAtRest

Definition: G4BiasingProcessInterface.hh:229

◆ GetWrappedProcessIsPost()

G4bool G4BiasingProcessInterface::GetWrappedProcessIsPost ( ) const

inline

Definition at line 145 of file G4BiasingProcessInterface.hh.

145 { return fWrappedProcessIsPost; }

G4BiasingProcessInterface::fWrappedProcessIsPost

const G4bool fWrappedProcessIsPost

Definition: G4BiasingProcessInterface.hh:231

◆ IdxFirstLast()

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InvokeWrappedProcessPostStepGPIL()

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

private

Definition at line 968 of file G4BiasingProcessInterface.cc.

 {
   G4double usedPreviousStepSize = previousStepSize;
   // -- if the physics process has been under occurence 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();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsApplicable()

G4bool G4BiasingProcessInterface::IsApplicable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 653 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFirstPostStepDoItInterface()

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

Definition at line 897 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFirstPostStepGPILInterface()

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

Definition at line 851 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsLastPostStepDoItInterface()

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

Definition at line 920 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsLastPostStepGPILInterface()

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

Definition at line 874 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PostStepDoIt()

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

virtual

Implements G4VProcess.

Definition at line 384 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
   // --    occurence biasing, if such an occurence 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 retruned "as is" to the stepping, disregarding there
   // -- was or not a occurence 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 occurence 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 occurence biasing, applies the occurence 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;
   
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PostStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 207 of file G4BiasingProcessInterface.cc.

 {
   // ---------------------------------------------------------------------------------------------
   // -- The "biasing master" takes care for all biasing processes of update of biasing operators
   // -- and invokes all PostStepGPIL of physical wrapped processes (anticipate stepping manager
   // -- call ! ) so that all cross-sections are updated with current step, and available right
   // -- away to the biasing operator.
   // ---------------------------------------------------------------------------------------------
   if ( fIamFirstGPIL )
     {
       // -- Update previous biasing operator:
       fSharedData->fPreviousBiasingOperator = fSharedData->fCurrentBiasingOperator;
       // -- If new volume, get possible new biasing operator:
       // ----------------------------------------------------
       // -- [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->fCurrentBiasingOperator = newOperator ;
       if ( newOperator != fSharedData->fPreviousBiasingOperator )
         {
           fSharedData->fLeavingPreviousOperator = ( fSharedData->fPreviousBiasingOperator != 0 ) ;
           fSharedData->fIsNewOperator           = ( newOperator != 0 );
         }
     }
       
 
       // -- calls to wrapped process PostStepGPIL's:
       // -------------------------------------------
       // -- Each physics wrapper process has its
       // --   fWrappedProcessPostStepGPIL      ,
       // --   fWrappedProcessForceCondition    ,
       // --   fWrappedProcessInteractionLength
       // -- updated.
       if ( fSharedData->fCurrentBiasingOperator != 0 )
     {
       for ( size_t i = 0 ; i < (fSharedData->fPhysicsBiasingProcessInterfaces).size(); i++ )
         (fSharedData->fPhysicsBiasingProcessInterfaces)[i]->InvokeWrappedProcessPostStepGPIL( track, previousStepSize, condition );
     }
     }
 
 
   // -- 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 occurence 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 occurence 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;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreparePhysicsTable()

void G4BiasingProcessInterface::PreparePhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareWorkerPhysicsTable()

void G4BiasingProcessInterface::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReorderBiasingVectorAsGPIL()

void G4BiasingProcessInterface::ReorderBiasingVectorAsGPIL ( )

private

Definition at line 994 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 (G4int i = 0; i < pv->size(); i++ ) 
     {
       for ( 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;
         }
     }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetForUnbiasedTracking()

void G4BiasingProcessInterface::ResetForUnbiasedTracking ( )

private

Definition at line 959 of file G4BiasingProcessInterface.cc.

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

Here is the caller graph for this function:

◆ ResetNumberOfInteractionLengthLeft()

void G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft ( )

virtual

Reimplemented from G4VProcess.

Definition at line 817 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RetrievePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 729 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMasterProcess()

void G4BiasingProcessInterface::SetMasterProcess ( G4VProcess * masterP )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetProcessManager()

void G4BiasingProcessInterface::SetProcessManager ( const G4ProcessManager * mgr )

virtual

Reimplemented from G4VProcess.

Definition at line 736 of file G4BiasingProcessInterface.cc.

 { 
   if ( fWrappedProcess != 0 ) fWrappedProcess->SetProcessManager(mgr);
   else                        G4VProcess::SetProcessManager(mgr);
 
   // -- initialize fSharedData pointer:
   if ( fSharedDataMap.Find(mgr) == fSharedDataMap.End() )
     {
       fSharedData =  new G4BiasingProcessSharedData( mgr );
       fSharedDataMap[mgr] = fSharedData;
     }
   else fSharedData = 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetProposedSafety()

void G4BiasingProcessInterface::SetProposedSafety ( G4double sft )

inline

Definition at line 152 of file G4BiasingProcessInterface.hh.

152 { fProposedSafety = sft;}

G4BiasingProcessInterface::fProposedSafety

G4double fProposedSafety

Definition: G4BiasingProcessInterface.hh:216

◆ SetUpFirstLastFlags()

void G4BiasingProcessInterface::SetUpFirstLastFlags ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartTracking()

void G4BiasingProcessInterface::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StorePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 722 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fBiasingAlongStepGPIL

G4double G4BiasingProcessInterface::fBiasingAlongStepGPIL

private

Definition at line 240 of file G4BiasingProcessInterface.hh.

◆ fBiasingForceCondition

G4ForceCondition G4BiasingProcessInterface::fBiasingForceCondition

private

Definition at line 238 of file G4BiasingProcessInterface.hh.

◆ fBiasingGPILSelection

G4GPILSelection G4BiasingProcessInterface::fBiasingGPILSelection

private

Definition at line 242 of file G4BiasingProcessInterface.hh.

◆ fBiasingInteractionLaw

const G4VBiasingInteractionLaw* G4BiasingProcessInterface::fBiasingInteractionLaw

private

Definition at line 244 of file G4BiasingProcessInterface.hh.

◆ fBiasingPostStepGPIL

G4double G4BiasingProcessInterface::fBiasingPostStepGPIL

private

Definition at line 235 of file G4BiasingProcessInterface.hh.

◆ fCommonEnd

G4Cache< G4bool > G4BiasingProcessInterface::fCommonEnd

staticprivate

Definition at line 270 of file G4BiasingProcessInterface.hh.

◆ fCommonStart

G4Cache< G4bool > G4BiasingProcessInterface::fCommonStart

staticprivate

Definition at line 269 of file G4BiasingProcessInterface.hh.

◆ fCurrentMinimumStep

G4double G4BiasingProcessInterface::fCurrentMinimumStep

private

Definition at line 215 of file G4BiasingProcessInterface.hh.

◆ fCurrentTrack

G4Track* G4BiasingProcessInterface::fCurrentTrack

private

Definition at line 213 of file G4BiasingProcessInterface.hh.

◆ fDoCommonConfigure

G4Cache< G4bool > G4BiasingProcessInterface::fDoCommonConfigure

staticprivate

Definition at line 271 of file G4BiasingProcessInterface.hh.

◆ fDummyParticleChange

G4ParticleChangeForNothing* G4BiasingProcessInterface::fDummyParticleChange

private

Definition at line 249 of file G4BiasingProcessInterface.hh.

◆ fFinalStateBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fFinalStateBiasingOperation

private

Definition at line 219 of file G4BiasingProcessInterface.hh.

◆ fFirstLastFlags

G4bool G4BiasingProcessInterface::fFirstLastFlags[8]

private

Definition at line 250 of file G4BiasingProcessInterface.hh.

◆ fIamFirstGPIL

G4bool G4BiasingProcessInterface::fIamFirstGPIL

private

Definition at line 264 of file G4BiasingProcessInterface.hh.

◆ fIsPhysicsBasedBiasing

const G4bool G4BiasingProcessInterface::fIsPhysicsBasedBiasing

private

Definition at line 228 of file G4BiasingProcessInterface.hh.

◆ fNonPhysicsBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fNonPhysicsBiasingOperation

private

Definition at line 220 of file G4BiasingProcessInterface.hh.

◆ fOccurenceBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fOccurenceBiasingOperation

private

Definition at line 218 of file G4BiasingProcessInterface.hh.

◆ fOccurenceBiasingParticleChange

G4ParticleChangeForOccurenceBiasing* G4BiasingProcessInterface::fOccurenceBiasingParticleChange

private

Definition at line 247 of file G4BiasingProcessInterface.hh.

◆ fParticleChange

G4ParticleChange* G4BiasingProcessInterface::fParticleChange

private

Definition at line 248 of file G4BiasingProcessInterface.hh.

◆ fPhysicalInteractionLaw

G4InteractionLawPhysical* G4BiasingProcessInterface::fPhysicalInteractionLaw

private

Definition at line 246 of file G4BiasingProcessInterface.hh.

◆ fPreviousBiasingInteractionLaw

const G4VBiasingInteractionLaw* G4BiasingProcessInterface::fPreviousBiasingInteractionLaw

private

Definition at line 245 of file G4BiasingProcessInterface.hh.

◆ fPreviousFinalStateBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fPreviousFinalStateBiasingOperation

private

Definition at line 222 of file G4BiasingProcessInterface.hh.

◆ fPreviousNonPhysicsBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fPreviousNonPhysicsBiasingOperation

private

Definition at line 223 of file G4BiasingProcessInterface.hh.

◆ fPreviousOccurenceBiasingOperation

G4VBiasingOperation* G4BiasingProcessInterface::fPreviousOccurenceBiasingOperation

private

Definition at line 221 of file G4BiasingProcessInterface.hh.

◆ fPreviousStepSize

G4double G4BiasingProcessInterface::fPreviousStepSize

private

Definition at line 214 of file G4BiasingProcessInterface.hh.

◆ fProcessManager

const G4ProcessManager* G4BiasingProcessInterface::fProcessManager

private

Definition at line 273 of file G4BiasingProcessInterface.hh.

◆ fProposedSafety

G4double G4BiasingProcessInterface::fProposedSafety

private

Definition at line 216 of file G4BiasingProcessInterface.hh.

◆ fResetInteractionLaws

G4Cache< G4bool > G4BiasingProcessInterface::fResetInteractionLaws

staticprivate

Definition at line 268 of file G4BiasingProcessInterface.hh.

◆ fResetWrappedProcessInteractionLength

G4bool G4BiasingProcessInterface::fResetWrappedProcessInteractionLength

private

Definition at line 225 of file G4BiasingProcessInterface.hh.

◆ fSharedData

G4BiasingProcessSharedData* G4BiasingProcessInterface::fSharedData

private

Definition at line 277 of file G4BiasingProcessInterface.hh.

◆ fSharedDataMap

G4MapCache< const G4ProcessManager *, G4BiasingProcessSharedData *> G4BiasingProcessInterface::fSharedDataMap

staticprivate

Definition at line 284 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcess

G4VProcess* G4BiasingProcessInterface::fWrappedProcess

private

Definition at line 227 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessAlongStepGPIL

G4double G4BiasingProcessInterface::fWrappedProcessAlongStepGPIL

private

Definition at line 239 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessForceCondition

G4ForceCondition G4BiasingProcessInterface::fWrappedProcessForceCondition

private

Definition at line 237 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessGPILSelection

G4GPILSelection G4BiasingProcessInterface::fWrappedProcessGPILSelection

private

Definition at line 241 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessInteractionLength

G4double G4BiasingProcessInterface::fWrappedProcessInteractionLength

private

Definition at line 236 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessIsAlong

const G4bool G4BiasingProcessInterface::fWrappedProcessIsAlong

private

Definition at line 230 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessIsAtRest

const G4bool G4BiasingProcessInterface::fWrappedProcessIsAtRest

private

Definition at line 229 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessIsPost

const G4bool G4BiasingProcessInterface::fWrappedProcessIsPost

private

Definition at line 231 of file G4BiasingProcessInterface.hh.

◆ fWrappedProcessPostStepGPIL

G4double G4BiasingProcessInterface::fWrappedProcessPostStepGPIL

private

Definition at line 234 of file G4BiasingProcessInterface.hh.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4BiasingProcessInterface() [1/2]

◆ G4BiasingProcessInterface() [2/2]

◆ ~G4BiasingProcessInterface()

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ EndTracking()

◆ GetAlongStepGPIL()

◆ GetBiasingProcessInterfaces()

◆ GetCurrentBiasingOperator()

◆ GetCurrentFinalStateBiasingOperation()

◆ GetCurrentMinimumStep()

◆ GetCurrentNonPhysicsBiasingOperation()

◆ GetCurrentOccurenceBiasingOperation()

◆ GetIsFirstPostStepDoItInterface()

◆ GetIsFirstPostStepGPILInterface()

◆ GetIsLastPostStepDoItInterface()

◆ GetIsLastPostStepGPILInterface()

◆ GetNonPhysicsBiasingProcessInterfaces()

◆ GetPhysicsBiasingProcessInterfaces()

◆ GetPostStepGPIL()

◆ GetPreviousBiasingOperator()

◆ GetPreviousFinalStateBiasingOperation()

◆ GetPreviousNonPhysicsBiasingOperation()

◆ GetPreviousOccurenceBiasingOperation()

◆ GetPreviousStepSize()

◆ GetProcessManager()

◆ GetProposedSafety()

◆ GetSharedData() [1/2]

◆ GetSharedData() [2/2]

◆ GetWrappedProcess()

◆ GetWrappedProcessIsAlong()

◆ GetWrappedProcessIsAtRest()

◆ GetWrappedProcessIsPost()

◆ IdxFirstLast()

◆ InvokeWrappedProcessPostStepGPIL()

◆ IsApplicable()

◆ IsFirstPostStepDoItInterface()

◆ IsFirstPostStepGPILInterface()

◆ IsLastPostStepDoItInterface()

◆ IsLastPostStepGPILInterface()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ PrepareWorkerPhysicsTable()

◆ ReorderBiasingVectorAsGPIL()

◆ ResetForUnbiasedTracking()

◆ ResetNumberOfInteractionLengthLeft()

◆ RetrievePhysicsTable()

◆ SetMasterProcess()

◆ SetProcessManager()

◆ SetProposedSafety()

◆ SetUpFirstLastFlags()

◆ StartTracking()

◆ StorePhysicsTable()

Member Data Documentation

◆ fBiasingAlongStepGPIL

◆ fBiasingForceCondition

◆ fBiasingGPILSelection

◆ fBiasingInteractionLaw

◆ fBiasingPostStepGPIL

◆ fCommonEnd

◆ fCommonStart

◆ fCurrentMinimumStep

◆ fCurrentTrack

◆ fDoCommonConfigure

◆ fDummyParticleChange

◆ fFinalStateBiasingOperation