G4WeightWindowAlgorithm Class Reference

G4WeightWindowAlgorithm is a concrete implementation of a weight window algorithm. More...

#include <G4WeightWindowAlgorithm.hh>

Inheritance diagram for G4WeightWindowAlgorithm:

Public Member Functions
	G4WeightWindowAlgorithm (G4double upperLimitFactor=5, G4double survivalFactor=3, G4int maxNumberOfSplits=5)
	~G4WeightWindowAlgorithm () override=default
G4Nsplit_Weight	Calculate (G4double init_w, G4double lowerWeightBound) const override
Public Member Functions inherited from G4VWeightWindowAlgorithm
	G4VWeightWindowAlgorithm ()=default
virtual	~G4VWeightWindowAlgorithm ()=default

Detailed Description

G4WeightWindowAlgorithm is a concrete implementation of a weight window algorithm.

Definition at line 58 of file G4WeightWindowAlgorithm.hh.

Constructor & Destructor Documentation

G4WeightWindowAlgorithm()

G4WeightWindowAlgorithm::G4WeightWindowAlgorithm	(	G4double	upperLimitFactor = 5,
		G4double	survivalFactor = 3,
		G4int	maxNumberOfSplits = 5 )

Constructor. The arguments configure the algorithm. In case of upperLimitFactor=survivalFactor=1 the algorithm becomes the expected weight algorithm of the importance sampling technique.

Parameters

[in]	upperLimitFactor	The factor defining the upper weight limit W_u = upperLimitFactor * W_l (W_l lower weight bound).
[in]	survivalFactor	uUsed in calculating the survival weight W_s = survivalFactor * W_l.
[in]	maxNumberOfSplits	The maximal number of splits allowed to be created in one go, and the reciprocal of the minimal survival probability in case of Russian roulette.

Definition at line 33 of file G4WeightWindowAlgorithm.cc.

  : fUpperLimitFactor(upperLimitFactor),
    fSurvivalFactor(survivalFactor),
    fMaxNumberOfSplits(maxNumberOfSplits)
{
}

~G4WeightWindowAlgorithm()

G4WeightWindowAlgorithm::~G4WeightWindowAlgorithm ( )

overridedefault

Default Destructor.

Member Function Documentation

Calculate()

G4Nsplit_Weight G4WeightWindowAlgorithm::Calculate ( G4double init_w, G4double lowerWeightBound ) const

overridevirtual

Calculates the number of tracks and their weight according to the initial track weight and the lower energy bound.

Implements G4VWeightWindowAlgorithm.

Definition at line 44 of file G4WeightWindowAlgorithm.cc.

{
  G4double survivalWeight = lowerWeightBound * fSurvivalFactor;
  G4double upperWeight = lowerWeightBound * fUpperLimitFactor;
 
  // initialize return value for case weight in window
  //
  G4Nsplit_Weight nw;
  nw.fN = 1;
  nw.fW = init_w;
 
  if (init_w > upperWeight)
  {
    // splitting
    //
    G4double temp_wi_ws = init_w/upperWeight;
    auto  split_i = static_cast<G4int>(temp_wi_ws);
    if(split_i != temp_wi_ws)  { ++split_i; }
    G4double wi_ws = init_w/split_i;
 
    // values in case integer mode or in csae of double
    // mode and the lower number of splits will be diced
    //
    nw.fN = split_i;
    nw.fW = wi_ws;        
 
//TB     if (wi_ws <= fMaxNumberOfSplits) {
//TB       if (wi_ws > int_wi_ws) {
//TB         // double mode
//TB         G4double p2 =  wi_ws - int_wi_ws;
//TB         G4double r = G4UniformRand();
//TB         if (r<p2) {
//TB           nw.fN = int_wi_ws + 1;
//TB         }
//TB       }
//TB     }
//TB     else {
//TB       // fMaxNumberOfSplits < wi_ws
//TB       nw.fN = fMaxNumberOfSplits;
//TB       nw.fW = init_w/fMaxNumberOfSplits;
//TB     }
 
  }
  else if (init_w < lowerWeightBound)  // Russian roulette
  {
    G4double wi_ws = init_w/survivalWeight;
    G4double p = std::max(wi_ws,1./fMaxNumberOfSplits);
    G4double r = G4UniformRand();
    if (r<p)
    {
      nw.fW = init_w/p;
      nw.fN = 1;
    }
    else
    {
      nw.fW = 0;
      nw.fN = 0;
    }
  } 
  // else do nothing
 
  return nw;
}

---

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

• G4WeightWindowAlgorithm.hh
• G4WeightWindowAlgorithm.cc