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 "ConservedMaskedNoiseBase.h"
      11             : 
      12             : #include "libmesh/quadrature.h"
      13             : 
      14             : InputParameters
      15          23 : ConservedMaskedNoiseBase::validParams()
      16             : {
      17          23 :   InputParameters params = ElementUserObject::validParams();
      18          23 :   params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
      19          46 :   params.addParam<MaterialPropertyName>("mask",
      20             :                                         "Material property to multiply the random numbers with");
      21          23 :   return params;
      22           0 : }
      23             : 
      24          12 : ConservedMaskedNoiseBase::ConservedMaskedNoiseBase(const InputParameters & parameters)
      25          24 :   : ConservedNoiseInterface(parameters), _mask(getMaterialProperty<Real>("mask"))
      26             : {
      27          12 : }
      28             : 
      29             : void
      30          37 : ConservedMaskedNoiseBase::initialize()
      31             : {
      32             :   _random_data.clear();
      33          37 :   _integral = 0.0;
      34          37 :   _volume = 0.0;
      35          37 : }
      36             : 
      37             : void
      38        2500 : ConservedMaskedNoiseBase::execute()
      39             : {
      40             :   // reserve space for each quadrature point in the element
      41        2500 :   std::vector<std::pair<Real, Real>> & me = _random_data[_current_elem->id()] =
      42        5000 :       std::vector<std::pair<Real, Real>>(_qrule->n_points());
      43             : 
      44             :   // store a random number for each quadrature point
      45       12500 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      46             :   {
      47       10000 :     me[_qp].first = getQpRandom();
      48       10000 :     me[_qp].second = _mask[_qp];
      49       10000 :     _integral += _JxW[_qp] * _coord[_qp] * me[_qp].first * me[_qp].second;
      50       10000 :     _volume += _JxW[_qp] * _coord[_qp] * me[_qp].second;
      51             :   }
      52        2500 : }
      53             : 
      54             : void
      55           4 : ConservedMaskedNoiseBase::threadJoin(const UserObject & y)
      56             : {
      57             :   const auto & uo = static_cast<const ConservedMaskedNoiseBase &>(y);
      58             : 
      59           4 :   _random_data.insert(uo._random_data.begin(), uo._random_data.end());
      60           4 :   _integral += uo._integral;
      61           4 :   _volume += uo._volume;
      62           4 : }
      63             : 
      64             : void
      65          33 : ConservedMaskedNoiseBase::finalize()
      66             : {
      67          33 :   gatherSum(_integral);
      68          33 :   gatherSum(_volume);
      69             : 
      70             :   // TODO check that _volume is >0
      71          33 :   _offset = _integral / _volume;
      72          33 : }
      73             : 
      74             : Real
      75      193600 : ConservedMaskedNoiseBase::getQpValue(dof_id_type element_id, unsigned int qp) const
      76             : {
      77             :   const auto it_pair = _random_data.find(element_id);
      78             : 
      79      193600 :   if (it_pair == _random_data.end())
      80           0 :     mooseError("Element not found.");
      81             :   else
      82             :   {
      83             :     libmesh_assert_less(qp, it_pair->second.size());
      84      193600 :     return (it_pair->second[qp].first - _offset) * it_pair->second[qp].second;
      85             :   }
      86             : }