#include <Doxymodules_biasing.h>

Inheritance diagram for GB06BOptnSplitAndKillByImportance:

Public Member Functions
	GB06BOptnSplitAndKillByImportance (G4String name)

virtual	~GB06BOptnSplitAndKillByImportance ()

virtual const G4VBiasingInteractionLaw *	ProvideOccurenceBiasingInteractionLaw (const G4BiasingProcessInterface *, G4ForceCondition &) final

virtual G4VParticleChange *	ApplyFinalStateBiasing (const G4BiasingProcessInterface , const G4Track , const G4Step *, G4bool &) final

virtual G4double	DistanceToApplyOperation (const G4Track , G4double, G4ForceCondition condition) final

virtual G4VParticleChange *	GenerateBiasingFinalState (const G4Track , const G4Step ) final

void	SetParallelWorldIndex (G4int parallelWorldIndex)

G4int	GetParallelWorldIndex () const

void	SetBiasingSharedData (const G4BiasingProcessSharedData *sharedData)

void	SetImportanceMap (std::map< G4int, G4int > *importanceMap)

Private Attributes
G4int	fParallelWorldIndex

const G4BiasingProcessSharedData *	fBiasingSharedData

G4TouchableHandle	fPreStepTouchableHistory

G4TouchableHandle	fPostStepTouchableHistory

G4ParticleChange	fParticleChange

G4ParticleChangeForNothing	fDummyParticleChange

std::map< G4int, G4int > *	fImportanceMap

Detailed Description

Definition at line 138 of file Doxymodules_biasing.h.

Constructor & Destructor Documentation

◆ GB06BOptnSplitAndKillByImportance()

GB06BOptnSplitAndKillByImportance::GB06BOptnSplitAndKillByImportance ( G4String name )

Definition at line 42 of file GB06BOptnSplitAndKillByImportance.cc.

: G4VBiasingOperation (name),
  fParallelWorldIndex ( -1 ),
  fBiasingSharedData  ( nullptr ),
  fParticleChange(),
  fDummyParticleChange()
{}

◆ ~GB06BOptnSplitAndKillByImportance()

GB06BOptnSplitAndKillByImportance::~GB06BOptnSplitAndKillByImportance ( )

virtual

Definition at line 52 of file GB06BOptnSplitAndKillByImportance.cc.

53{}

Member Function Documentation

◆ ProvideOccurenceBiasingInteractionLaw()

virtual const G4VBiasingInteractionLaw * GB06BOptnSplitAndKillByImportance::ProvideOccurenceBiasingInteractionLaw	(	const G4BiasingProcessInterface *	,
		G4ForceCondition &
	)

inlinefinalvirtual

Definition at line 54 of file GB06BOptnSplitAndKillByImportance.hh.

56 {return 0;}

◆ ApplyFinalStateBiasing()

virtual G4VParticleChange * GB06BOptnSplitAndKillByImportance::ApplyFinalStateBiasing	(	const G4BiasingProcessInterface *	,
		const G4Track *	,
		const G4Step *	,
		G4bool &
	)

inlinefinalvirtual

Definition at line 58 of file GB06BOptnSplitAndKillByImportance.hh.

62 {return 0;}

◆ DistanceToApplyOperation()

G4double GB06BOptnSplitAndKillByImportance::DistanceToApplyOperation	(	const G4Track *	,
		G4double	,
		G4ForceCondition *	condition
	)

finalvirtual

Definition at line 57 of file GB06BOptnSplitAndKillByImportance.cc.

{
 
  // -- Remember the touchable history (ie geometry state) at the beginning of the step:
  // -- Start by getting the process handling the step limitation in parallel
  // -- geometries for the generic biasing:
  auto biasingLimiterProcess =  fBiasingSharedData->GetParallelGeometriesLimiterProcess();
  fPreStepTouchableHistory   =
    biasingLimiterProcess
    ->GetNavigator( fParallelWorldIndex )  // -- get the navigator of the geometry...
    ->CreateTouchableHistoryHandle();      // -- ...and collect the geometry state.
  
  // -- We request to be "forced" : meaning GenerateBiasingFinalState(...) will be called
  // -- anyway at the PostStepDoIt(...) stage (ie, when the track will have been moved to
  // -- its end point position) and, there, we will have to handle the decision to
  // -- split/kill if we are on a volume boundary, or do nothing, if we're not:
  *condition = Forced;
 
  // -- As we're forced, we make this returned length void:
  return DBL_MAX;
}

◆ GenerateBiasingFinalState()

G4VParticleChange * GB06BOptnSplitAndKillByImportance::GenerateBiasingFinalState	(	const G4Track *	track,
		const G4Step *
	)

finalvirtual

Definition at line 85 of file GB06BOptnSplitAndKillByImportance.cc.

{
  // -- Given we used the "Forced" condition, this method is always called.
  // -- We check the status of the step in the parallel geometry, and apply
  // -- splitting/killing if the step has been limited by the geometry.
 
  // -- We first check if we limit the step in the parallel geometry:
  G4bool isLimiting = fBiasingSharedData
    ->GetParallelGeometriesLimiterProcess()
    ->GetIsLimiting( fParallelWorldIndex );
 
  // -- if not limiting, we leave the track unchanged:
  if ( !isLimiting )
    {
      fDummyParticleChange.Initialize( *track );
      return &fDummyParticleChange;
    }
  
  // -- We collect the geometry state at the end point step:
  // -- Note this is the same call than in the DistanceToApplyOperation(...) for the
  // -- fPreStepTouchableHistory, but the navigator has pushed the track in the next
  // -- volume since then (even if the track is still on the boundary), and hence the
  // -- geometry state has changed.
  auto biasingLimiterProcess = fBiasingSharedData->GetParallelGeometriesLimiterProcess();
  fPostStepTouchableHistory  =
    biasingLimiterProcess
    ->GetNavigator( fParallelWorldIndex )
    ->CreateTouchableHistoryHandle();
 
  
  // -- We verify we are still in the "same" physical volume:
  // -- remember : using a replica, we have "one" physical volume
  // -- but representing many different placements, distinguished
  // -- by replica number. By checking we are in the same physical
  // -- volume, we verify the end step point has not reached the
  // -- world volume of the parallel geometry:
  if ( fPreStepTouchableHistory ->GetVolume() !=
       fPostStepTouchableHistory->GetVolume()    )
    {
      // -- the track is leaving the volumes in which biasing is applied,
      // -- we leave this track unchanged:
      fDummyParticleChange.Initialize( *track );
      return &fDummyParticleChange;
    }
 
  // -------------------------------------------------------------------------------------
  // -- At this stage, we know we have a particle crossing a boundary between two slices,
  // -- each of this slice has a well defined importance : we apply the biasing.
  // -- We will split if the track is entering a volume with higher importance, and
  // -- kill (applying Russian roulette) in the other case.
  // -------------------------------------------------------------------------------------
  
  // -- We start by getting the replica numbers: 
  G4int  preReplicaNumber =  fPreStepTouchableHistory->GetReplicaNumber();
  G4int postReplicaNumber = fPostStepTouchableHistory->GetReplicaNumber();
 
  // -- and get the related importance we defined in the importance map:
  G4int  preImportance = (*fImportanceMap)[ preReplicaNumber];
  G4int postImportance = (*fImportanceMap)[postReplicaNumber];
 
 
  // -- Get track weight:
  G4double initialWeight = track->GetWeight();
  
  // -- Initialize the "particle change" (it will communicate the new track state to
  // -- the tracking):
  fParticleChange.Initialize(*track);
 
  if ( postImportance > preImportance )
    {
      // -- We split :
      G4int splittingFactor = postImportance/preImportance;
      
      // Define the tracks weight:
      G4double weightOfTrack = initialWeight/splittingFactor;
      
      // Ask currect track weight to be changed to the new value:
      fParticleChange.ProposeParentWeight( weightOfTrack );
      // Now we clone this track (this is the actual splitting):
      // we will then have the primary and clone of it, hence the
      // splitting by a factor 2:
      G4Track* clone = new G4Track( *track );
      clone->SetWeight( weightOfTrack );
      fParticleChange.AddSecondary( clone );
      // -- Below's call added for safety & illustration : inform particle change to not
      // -- modify the clone (ie : daughter) weight to make it that of the primary.
      // -- Here this call is not mandatory as both tracks have same weights.
      fParticleChange.SetSecondaryWeightByProcess(true);
    }
  else
    {
      // -- We apply Russian roulette:
      G4double survivingProbability = G4double(postImportance) / G4double(preImportance);
      
      // Shoot a random number (in ]0,1[ segment):
      G4double random = G4UniformRand();
      if ( random > survivingProbability )
        {
          // We ask for the the track to be killed:
          fParticleChange.ProposeTrackStatus(fStopAndKill);
        }
      else
        {
          // In this case, the track survives. We change its weight
          // to conserve weight among killed and survival tracks:
          fParticleChange.ProposeParentWeight( initialWeight/survivingProbability );
        }
    }
 
  return &fParticleChange;
  
}