G4UniformRandPool Class Reference

#include <G4UniformRandPool.hh>

Collaboration diagram for G4UniformRandPool:

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)

Private Member Functions
void	Fill (G4int howmany)

Private Attributes
G4int	size
G4double *	buffer
G4int	currentIdx

Detailed Description

Definition at line 54 of file G4UniformRandPool.hh.

Constructor & Destructor Documentation

G4UniformRandPool() [1/2]

G4UniformRandPool::G4UniformRandPool

(

)

Definition at line 103 of file G4UniformRandPool.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4UniformRandPool() [2/2]

G4UniformRandPool::G4UniformRandPool

(

G4int

ps

)

Definition at line 117 of file G4UniformRandPool.cc.

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

} 

Here is the call graph for this function:

~G4UniformRandPool()

G4UniformRandPool::~G4UniformRandPool

(

)

Definition at line 132 of file G4UniformRandPool.cc.

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

Here is the call graph for this function:

Member Function Documentation

Fill()

void G4UniformRandPool::Fill ( G4int  howmany )

inlineprivate

Definition at line 101 of file G4UniformRandPool.hh.

{
  assert(howmany>0 && howmany <= size);

  // Fill buffer with random numbers
  //
  G4Random::getTheEngine()->flatArray(howmany,buffer);
  currentIdx = 0;
}

Here is the caller graph for this function:

flat()

G4double G4UniformRandPool::flat ( )

static

Definition at line 231 of file G4UniformRandPool.cc.

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

Here is the call graph for this function:

flatArray()

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

static

Definition at line 241 of file G4UniformRandPool.cc.

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

Here is the call graph for this function:

GetMany()

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

Definition at line 156 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 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
    // std::copy(buffer,buffer+size,rnds+(cycle*size));
    //
    memcpy(rnds+(cycle*size),buffer,sizeof(G4double)*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 guranteed 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);
}

Here is the call graph for this function:

GetOne()

G4double G4UniformRandPool::GetOne ( )

inline

Definition at line 84 of file G4UniformRandPool.hh.

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

  return buffer[currentIdx++];
}

Here is the call graph for this function:

GetPoolSize()

G4int G4UniformRandPool::GetPoolSize ( ) const

inline

Definition at line 96 of file G4UniformRandPool.hh.

{
  return size;
}

Resize()

void G4UniformRandPool::Resize

(

G4int

newSize

)

Definition at line 144 of file G4UniformRandPool.cc.

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

Here is the call graph for this function:

Member Data Documentation

buffer

G4double* G4UniformRandPool::buffer

private

Definition at line 80 of file G4UniformRandPool.hh.

currentIdx

G4int G4UniformRandPool::currentIdx

private

Definition at line 81 of file G4UniformRandPool.hh.

size

G4int G4UniformRandPool::size

private

Definition at line 79 of file G4UniformRandPool.hh.

---

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

• G4UniformRandPool.hh
• G4UniformRandPool.cc