#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)

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 70 of file G4BiasingProcessInterface.hh.

Constructor & Destructor Documentation

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);
 }

Here is the call graph for this function:

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

Here is the call graph for this function:

G4BiasingProcessInterface::~G4BiasingProcessInterface ( )

Definition at line 130 of file G4BiasingProcessInterface.cc.

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

Member Function Documentation

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

virtual

Implements G4VProcess.

Definition at line 651 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:

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

virtual

Implements G4VProcess.

Definition at line 572 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:

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

virtual

Implements G4VProcess.

Definition at line 714 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

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

virtual

Implements G4VProcess.

Definition at line 709 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

void G4BiasingProcessInterface::BuildPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 744 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:

void G4BiasingProcessInterface::BuildWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 841 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:

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

Here is the call graph for this function:

G4double G4BiasingProcessInterface::GetAlongStepGPIL ( ) const

inline

Definition at line 154 of file G4BiasingProcessInterface.hh.

154 { return fWrappedProcessAlongStepGPIL; }

Here is the caller graph for this function:

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

inline

Definition at line 107 of file G4BiasingProcessInterface.hh.

108 {return fSharedData-> fPublicBiasingProcessInterfaces;}

G4VBiasingOperator* G4BiasingProcessInterface::GetCurrentBiasingOperator ( ) const

inline

Definition at line 93 of file G4BiasingProcessInterface.hh.

93 {return fSharedData-> fCurrentBiasingOperator; }

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentFinalStateBiasingOperation ( ) const

inline

Definition at line 100 of file G4BiasingProcessInterface.hh.

100 { return fFinalStateBiasingOperation; }

G4double G4BiasingProcessInterface::GetCurrentMinimumStep ( ) const

inline

Definition at line 149 of file G4BiasingProcessInterface.hh.

149 { return fCurrentMinimumStep;}

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentNonPhysicsBiasingOperation ( ) const

inline

Definition at line 96 of file G4BiasingProcessInterface.hh.

96 { return fNonPhysicsBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentOccurenceBiasingOperation ( ) const

inline

Definition at line 98 of file G4BiasingProcessInterface.hh.

98 { return fOccurenceBiasingOperation; }

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

Definition at line 905 of file G4BiasingProcessInterface.cc.

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

Here is the caller graph for this function:

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

Definition at line 891 of file G4BiasingProcessInterface.cc.

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

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

Definition at line 912 of file G4BiasingProcessInterface.cc.

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

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

Definition at line 898 of file G4BiasingProcessInterface.cc.

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

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

inline

Definition at line 111 of file G4BiasingProcessInterface.hh.

112 {return fSharedData->fPublicNonPhysicsBiasingProcessInterfaces;}

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

inline

Definition at line 109 of file G4BiasingProcessInterface.hh.

110 {return fSharedData-> fPublicPhysicsBiasingProcessInterfaces;}

G4double G4BiasingProcessInterface::GetPostStepGPIL ( ) const

inline

Definition at line 153 of file G4BiasingProcessInterface.hh.

153 { return fBiasingPostStepGPIL; }

Here is the caller graph for this function:

G4VBiasingOperator* G4BiasingProcessInterface::GetPreviousBiasingOperator ( ) const

inline

Definition at line 94 of file G4BiasingProcessInterface.hh.

94 {return fSharedData->fPreviousBiasingOperator; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousFinalStateBiasingOperation ( ) const

inline

Definition at line 101 of file G4BiasingProcessInterface.hh.

101 { return fPreviousFinalStateBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousNonPhysicsBiasingOperation ( ) const

inline

Definition at line 97 of file G4BiasingProcessInterface.hh.

97 { return fPreviousNonPhysicsBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousOccurenceBiasingOperation ( ) const

inline

Definition at line 99 of file G4BiasingProcessInterface.hh.

99 { return fPreviousOccurenceBiasingOperation; }

G4double G4BiasingProcessInterface::GetPreviousStepSize ( ) const

inline

Definition at line 148 of file G4BiasingProcessInterface.hh.

148 { return fPreviousStepSize;}

const G4ProcessManager * G4BiasingProcessInterface::GetProcessManager ( )

virtual

Reimplemented from G4VProcess.

Definition at line 834 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

G4double G4BiasingProcessInterface::GetProposedSafety ( ) const

inline

Definition at line 150 of file G4BiasingProcessInterface.hh.

150 { return fProposedSafety;}

const G4BiasingProcessSharedData* G4BiasingProcessInterface::GetSharedData ( ) const

inline

Definition at line 115 of file G4BiasingProcessInterface.hh.

115 { return fSharedData; }

Here is the caller graph for this function:

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;
 }

Here is the call graph for this function:

G4VProcess* G4BiasingProcessInterface::GetWrappedProcess ( ) const

inline

Definition at line 85 of file G4BiasingProcessInterface.hh.

85 {return fWrappedProcess;}

Here is the caller graph for this function:

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAlong ( ) const

inline

Definition at line 143 of file G4BiasingProcessInterface.hh.

143 { return fWrappedProcessIsAlong; }

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAtRest ( ) const

inline

Definition at line 142 of file G4BiasingProcessInterface.hh.

142 { return fWrappedProcessIsAtRest; }

G4bool G4BiasingProcessInterface::GetWrappedProcessIsPost ( ) const

inline

Definition at line 144 of file G4BiasingProcessInterface.hh.

144 { return fWrappedProcessIsPost; }

G4bool G4BiasingProcessInterface::IsApplicable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 721 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

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

Definition at line 965 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:

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

Definition at line 919 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:

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

Definition at line 988 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:

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

Definition at line 942 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:

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

virtual

Implements G4VProcess.

Definition at line 449 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:

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 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:

void G4BiasingProcessInterface::PreparePhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 776 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:

void G4BiasingProcessInterface::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 871 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:

void G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft ( )

virtual

Reimplemented from G4VProcess.

Definition at line 885 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

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

virtual

Reimplemented from G4VProcess.

Definition at line 797 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

void G4BiasingProcessInterface::SetMasterProcess ( G4VProcess * masterP )

virtual

Reimplemented from G4VProcess.

Definition at line 728 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:

void G4BiasingProcessInterface::SetProcessManager ( const G4ProcessManager * mgr )

virtual

Reimplemented from G4VProcess.

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

Here is the call graph for this function:

void G4BiasingProcessInterface::SetProposedSafety ( G4double sft )

inline

Definition at line 151 of file G4BiasingProcessInterface.hh.

151 { fProposedSafety = sft;}

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 );
     }
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4VProcess.

Definition at line 790 of file G4BiasingProcessInterface.cc.

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

Here is the call graph for this function:

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

source/geant4.10.03.p02/source/processes/biasing/generic/include/G4BiasingProcessInterface.hh
source/geant4.10.03.p02/source/processes/biasing/generic/src/G4BiasingProcessInterface.cc

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation