RandomData Class Reference

#include <RandomData.h>

Public Member Functions
	RandomData (FEProblemBase &fe_problem, const RandomInterface &random_interface)
	RandomData (FEProblemBase &fe_problem, bool is_nodal, ExecFlagType reset_on, unsigned int seed)
	~RandomData ()=default
void	updateSeeds (ExecFlagType exec_flag)
	This method is called to reset or update the seeds based on the reset_on flag and the passed execution point.
MooseRandom &	getGenerator ()
	Return the underlying MooseRandom generator object for this data instance.
unsigned int	getSeed (dof_id_type id)
	Get the seed for the passed in elem/node id.

Private Member Functions
void	updateGenerators ()

Private Attributes
FEProblemBase &	_rd_problem
MooseMesh &	_rd_mesh
MooseRandom	_generator
bool	_is_nodal
ExecFlagType	_reset_on
unsigned int	_master_seed
unsigned int	_current_master_seed
unsigned int	_new_seed
std::unordered_map< dof_id_type, unsigned int >	_seeds

Detailed Description

Definition at line 23 of file RandomData.h.

Constructor & Destructor Documentation

RandomData() [1/2]

RandomData::RandomData	(	FEProblemBase &	fe_problem,
		const RandomInterface &	random_interface
	)

Definition at line 17 of file RandomData.C.

  : RandomData(fe_problem,
               random_interface.isNodal(),
               random_interface.getResetOnTime(),
               random_interface.getMasterSeed())
{
}

RandomData() [2/2]

RandomData::RandomData	(	FEProblemBase &	fe_problem,
		bool	is_nodal,
		ExecFlagType	reset_on,
		unsigned int	seed
	)

Definition at line 25 of file RandomData.C.

  : _rd_problem(fe_problem),
    _rd_mesh(fe_problem.mesh()),
    _is_nodal(is_nodal),
    _reset_on(reset_on),
    _master_seed(seed),
    _current_master_seed(std::numeric_limits<unsigned int>::max()),
    _new_seed(0)
{
}

~RandomData()

RandomData::~RandomData ( )

default

Member Function Documentation

getGenerator()

MooseRandom & RandomData::getGenerator ( )

inline

Return the underlying MooseRandom generator object for this data instance.

Definition at line 41 of file RandomData.h.

{ return _generator; }

Referenced by RandomInterface::setRandomDataPointer().

getSeed()

unsigned int RandomData::getSeed

(

dof_id_type

id

)

Get the seed for the passed in elem/node id.

Parameters

id	- dof object id

Returns

current seed for this id

Definition at line 40 of file RandomData.C.

{
  mooseAssert(_seeds.find(id) != _seeds.end(),
              "Call to updateSeeds() is stale! Check your initialize() or timestepSetup() calls");
 
  return _seeds[id];
}

Referenced by RandomInterface::getSeed().

updateGenerators()

void RandomData::updateGenerators ( )

private

When using parallel mesh it's not worth generating parallel consistent numbers. Each processor may not be aware of which entities belong on another mesh. We do have to be careful to not generate the same patterns on different processors however. To do that, we will use the MASTER generator to generate new master seeds for each processor based on their individual processor ids before generating seeds for the mesh entities.

Definition at line 80 of file RandomData.C.

{
  //  Set the master seed and repopulate all of the child generators
  _generator.seed(MASTER, _current_master_seed);
 
  if (_rd_mesh.isDistributedMesh())
  {
    unsigned int parallel_seed = 0;
    for (processor_id_type proc_id = 0; proc_id < _rd_problem.n_processors(); ++proc_id)
      if (proc_id == _rd_problem.processor_id())
        parallel_seed = _generator.randl(MASTER);
      else
        _generator.randl(MASTER); // Generate but throw away numbers that aren't mine
 
    _generator.seed(MASTER, parallel_seed);
  }
 
  auto processor_id = _rd_problem.processor_id();
 
  if (_is_nodal)
  {
    const auto & node_to_elem = _rd_mesh.nodeToElemMap();
    auto & mesh = _rd_mesh.getMesh();
 
    for (const auto node_ptr :
         as_range(_rd_mesh.getMesh().active_nodes_begin(), _rd_mesh.getMesh().active_nodes_end()))
    {
      auto id = node_ptr->id();
      auto rand_int = _generator.randl(MASTER);
 
      // Only save states for nodes attached to active elements
      auto elem_id_it = node_to_elem.find(id);
 
      if (elem_id_it != node_to_elem.end())
      {
        for (auto elem_id : elem_id_it->second)
        {
          const auto * elem_ptr = mesh.elem_ptr(elem_id);
 
          if (elem_ptr && processor_id == elem_ptr->processor_id())
          {
            _seeds[id] = rand_int;
 
            // Update the individual dof object generators
            _generator.seed(id, rand_int);
            break;
          }
        }
      }
    }
  }
  else
  {
    for (const auto & elem_ptr : as_range(_rd_mesh.getMesh().active_elements_begin(),
                                          _rd_mesh.getMesh().active_elements_end()))
    {
      auto id = elem_ptr->id();
      auto rand_int = _generator.randl(MASTER);
 
      // Only save states for local elements
      if (processor_id == elem_ptr->processor_id())
      {
        _seeds[id] = rand_int;
 
        // Update the individual dof object generators
        _generator.seed(id, rand_int);
      }
    }
  }
}

Referenced by updateSeeds().

updateSeeds()

void RandomData::updateSeeds

(

ExecFlagType

exec_flag

)

This method is called to reset or update the seeds based on the reset_on flag and the passed execution point.

Set the seed. This part is critical! If this is done incorrectly, it may lead to difficult to detect patterns in your random numbers either within a single run or over the course of several runs. We will default to _master_seed + the current time step.

case EXEC_TIMESTEP_BEGIN: // reset and advance every timestep case EXEC_TIMESTEP_END: // reset and advance every timestep case EXEC_LINEAR: // Reset every residual, advance every timestep case EXEC_NONLINEAR: // Reset every Jacobian, advance every timestep

Definition at line 49 of file RandomData.C.

{
  if (exec_flag == EXEC_INITIAL)
    _new_seed = _master_seed;
  else
    _new_seed = _master_seed + _rd_problem.timeStep();
  // If the _new_seed has been updated, we need to update all of the generators
  if (_new_seed != _current_master_seed)
  {
    _current_master_seed = _new_seed;
    updateGenerators();
    _generator.saveState(); // Save states so that we can reset on demand
  }
 
  if (_reset_on == exec_flag)
    _generator.restoreState(); // Restore states here
}

Member Data Documentation

_current_master_seed

unsigned int RandomData::_current_master_seed

private

Definition at line 61 of file RandomData.h.

Referenced by updateGenerators(), and updateSeeds().

_generator

MooseRandom RandomData::_generator

private

Definition at line 56 of file RandomData.h.

Referenced by getGenerator(), updateGenerators(), and updateSeeds().

_is_nodal

bool RandomData::_is_nodal

private

Definition at line 57 of file RandomData.h.

Referenced by updateGenerators().

_master_seed

unsigned int RandomData::_master_seed

private

Definition at line 60 of file RandomData.h.

Referenced by updateSeeds().

_new_seed

unsigned int RandomData::_new_seed

private

Definition at line 62 of file RandomData.h.

Referenced by updateSeeds().

_rd_mesh

MooseMesh& RandomData::_rd_mesh

private

Definition at line 54 of file RandomData.h.

Referenced by updateGenerators().

_rd_problem

FEProblemBase& RandomData::_rd_problem

private

Definition at line 53 of file RandomData.h.

Referenced by updateGenerators(), and updateSeeds().

_reset_on

ExecFlagType RandomData::_reset_on

private

Definition at line 58 of file RandomData.h.

Referenced by updateSeeds().

_seeds

std::unordered_map<dof_id_type, unsigned int> RandomData::_seeds

private

Definition at line 64 of file RandomData.h.

Referenced by getSeed(), and updateGenerators().

---

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

• include/utils/RandomData.h
• src/utils/RandomData.C