G4UniformRandPool Class Reference

#include <G4UniformRandPool.hh>

Public Member Functions
	G4UniformRandPool ()
	G4UniformRandPool (G4int ps)
	~G4UniformRandPool ()
void	Resize (G4int newSize)
void	GetMany (G4double *rnds, G4int howMany)
G4double	GetOne ()
G4int	GetPoolSize () const

Static Public Member Functions
static G4double	flat ()
static void	flatArray (G4int howmany, G4double *rnds)

Detailed Description

Definition at line 55 of file G4UniformRandPool.hh.

Constructor & Destructor Documentation

G4UniformRandPool() [1/2]

G4UniformRandPool::G4UniformRandPool

(

)

Definition at line 77 of file G4UniformRandPool.cc.

{
  if(sizeof(G4double) * CHAR_BIT == 64)
  {
    create_pool_align(buffer, size);
  }
  else
  {
    create_pool(buffer, size);
  }
  Fill(size);
}

Referenced by flat(), and flatArray().

G4UniformRandPool() [2/2]

G4UniformRandPool::G4UniformRandPool ( G4int ps )

explicit

Definition at line 90 of file G4UniformRandPool.cc.

  : size(siz)
{
  if(sizeof(G4double) * CHAR_BIT == 64)
  {
    create_pool_align(buffer, size);
  }
  else
  {
    create_pool(buffer, size);
  }
  Fill(size);
}

~G4UniformRandPool()

G4UniformRandPool::~G4UniformRandPool

(

)

Definition at line 104 of file G4UniformRandPool.cc.

{
  if(sizeof(G4double) * CHAR_BIT == 64)
  {
    destroy_pool_align(buffer);
  }
  else
  {
    destroy_pool(buffer);
  }
}

Member Function Documentation

flat()

G4double G4UniformRandPool::flat ( )

static

Definition at line 210 of file G4UniformRandPool.cc.

{
  if(rndpool == nullptr)
  {
    rndpool = new G4UniformRandPool;
    G4AutoDelete::Register(rndpool);
  }
  return rndpool->GetOne();
}

flatArray()

void G4UniformRandPool::flatArray ( G4int howmany, G4double * rnds )

static

Definition at line 220 of file G4UniformRandPool.cc.

{
  if(rndpool == nullptr)
  {
    rndpool = new G4UniformRandPool;
    G4AutoDelete::Register(rndpool);
  }
  rndpool->GetMany(rnds, (unsigned int) howmany);
}

GetMany()

void G4UniformRandPool::GetMany	(	G4double *	rnds,
		G4int	howMany )

Definition at line 138 of file G4UniformRandPool.cc.

{
  assert(rnds != 0 && howmany > 0);
 
  // if ( howmany <= 0 ) return;
  // We generate at max "size" numbers at once, and
  // We do not want to use recursive calls (expensive).
  // We need to deal with the case  howmany>size
  // So:
  // how many times I need to get "size" numbers?
 
  const G4int maxcycles = howmany / size;
 
  // This is the rest
  //
  const G4int peel = howmany % size;
  assert(peel < size);
 
  // Ok from now on I will get random numbers in group of  "size"
  // Note that if howmany<size maxcycles == 0
  //
  G4int cycle = 0;
 
  // Consider the case howmany>size, then maxcycles>=1
  // and we will request at least "size" rng, so
  // let's start with a fresh buffer of numbers if needed
  //
  if(maxcycles > 0 && currentIdx > 0)
  {
    assert(currentIdx <= size);
    Fill(currentIdx);  //<size?currentIdx:size);
  }
  for(; cycle < maxcycles; ++cycle)
  {
    // We can use memcpy of std::copy, it turns out that the two are basically
    // performance-wise equivalent (expected), since in my tests memcpy is a
    // little bit faster, I use that
    //
    memcpy(rnds + (cycle * size), buffer, sizeof(G4double) * size);
    // std::copy(buffer,buffer+size,rnds+(cycle*size));
 
    // Get a new set of numbers
    //
    Fill(size);  // Now currentIdx is 0 again
  }
 
  // If maxcycles>0 last think we did was to call Fill(size)
  // so currentIdx == 0
  // and it is guaranteed that peel<size, we have enough fresh random numbers
  // but if maxcycles==0 currentIdx can be whatever, let's make sure we have
  // enough fresh numbers
  //
  if(currentIdx + peel >= size)
  {
    Fill(currentIdx < size ? currentIdx : size);
  }
  memcpy(rnds + (cycle * size), buffer + currentIdx, sizeof(G4double) * peel);
  // std::copy(buffer+currentIdx,buffer+(currentIdx+peel), rnds+(cycle*size));
 
  // Advance index, we are done
  //
  currentIdx += peel;
  assert(currentIdx <= size);
}

GetOne()

G4double G4UniformRandPool::GetOne ( )

inline

Definition at line 82 of file G4UniformRandPool.hh.

{
  // No more available numbers, re-fill
  //
  if(currentIdx >= /*(unsigned int)*/ size)
  {
    Fill(/*(unsigned int)*/ size);
  }
 
  return buffer[currentIdx++];
}

GetPoolSize()

G4int G4UniformRandPool::GetPoolSize ( ) const

inline

Definition at line 94 of file G4UniformRandPool.hh.

{
  return size;
}

Resize()

void G4UniformRandPool::Resize

(

G4int

newSize

)

Definition at line 116 of file G4UniformRandPool.cc.

{
  if(newSize != size)
  {
    destroy_pool(buffer);
    create_pool(buffer, newSize);
    size       = newSize;
    currentIdx = 0;
  }
  currentIdx = 0;
}

---

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

• G4UniformRandPool.hh
• G4UniformRandPool.cc