Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "Moose.h"
      11             : #include "RandomInterface.h"
      12             : #include "RandomData.h"
      13             : #include "MooseRandom.h"
      14             : #include "FEProblemBase.h"
      15             : #include "Assembly.h"
      16             : 
      17             : InputParameters
      18    12980666 : RandomInterface::validParams()
      19             : {
      20             : 
      21    12980666 :   InputParameters params = emptyInputParameters();
      22    51922664 :   params.addParam<unsigned int>("seed", 0, "The seed for the master random number generator");
      23             : 
      24    38941998 :   params.addParamNamesToGroup("seed", "Advanced");
      25    12980666 :   return params;
      26           0 : }
      27             : 
      28      354990 : RandomInterface::RandomInterface(const InputParameters & parameters,
      29             :                                  FEProblemBase & problem,
      30             :                                  THREAD_ID tid,
      31      354990 :                                  bool is_nodal)
      32      354990 :   : _random_data(nullptr),
      33      354990 :     _generator(nullptr),
      34      354990 :     _ri_problem(problem),
      35      354990 :     _ri_name(parameters.getObjectName()),
      36      354990 :     _master_seed(parameters.get<unsigned int>("seed")),
      37      354990 :     _is_nodal(is_nodal),
      38      354990 :     _reset_on(EXEC_LINEAR),
      39      354990 :     _curr_node(problem.assembly(tid, 0).node()),
      40      354990 :     _curr_element(problem.assembly(tid, 0).elem())
      41             : {
      42      354990 : }
      43             : 
      44             : #ifdef MOOSE_KOKKOS_ENABLED
      45      200105 : RandomInterface::RandomInterface(const RandomInterface & object, const Moose::Kokkos::FunctorCopy &)
      46      200105 :   : _random_data(object._random_data),
      47      200105 :     _generator(object._generator),
      48      200105 :     _ri_problem(object._ri_problem),
      49      200105 :     _ri_name(object._ri_name),
      50      200105 :     _master_seed(object._master_seed),
      51      200105 :     _is_nodal(object._is_nodal),
      52      200105 :     _reset_on(object._reset_on),
      53      200105 :     _curr_node(object._curr_node),
      54      200105 :     _curr_element(object._curr_element)
      55             : {
      56      200105 : }
      57             : #endif
      58             : 
      59      539834 : RandomInterface::~RandomInterface() {}
      60             : 
      61             : void
      62         456 : RandomInterface::setRandomResetFrequency(ExecFlagType exec_flag)
      63             : {
      64         456 :   _reset_on = exec_flag;
      65         456 :   _ri_problem.registerRandomInterface(*this, _ri_name);
      66         456 : }
      67             : 
      68             : void
      69         456 : RandomInterface::setRandomDataPointer(RandomData * random_data)
      70             : {
      71         456 :   _random_data = random_data;
      72         456 :   _generator = &_random_data->getGenerator();
      73         456 : }
      74             : 
      75             : unsigned int
      76           0 : RandomInterface::getSeed(std::size_t id)
      77             : {
      78             :   mooseAssert(_random_data, "RandomData object is NULL!");
      79             : 
      80           0 :   return _random_data->getSeed(id);
      81             : }
      82             : 
      83             : unsigned long
      84     2666048 : RandomInterface::getRandomLong() const
      85             : {
      86             :   mooseAssert(_generator, "Random Generator is NULL, did you call setRandomResetFrequency()?");
      87             : 
      88             :   dof_id_type id;
      89     2666048 :   if (_is_nodal)
      90           0 :     id = _curr_node->id();
      91             :   else
      92     2666048 :     id = _curr_element->id();
      93             : 
      94     2666048 :   return _generator->randl(id);
      95             : }
      96             : 
      97             : Real
      98     2082952 : RandomInterface::getRandomReal() const
      99             : {
     100             :   mooseAssert(_generator, "Random Generator is NULL, did you call setRandomResetFrequency()?");
     101             : 
     102             :   dof_id_type id;
     103     2082952 :   if (_is_nodal)
     104      244904 :     id = _curr_node->id();
     105             :   else
     106     1838048 :     id = _curr_element->id();
     107             : 
     108     2082952 :   return _generator->rand(id);
     109             : }