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          15 : ConservedMaskedNoiseBase::validParams()
      16             : {
      17          15 :   InputParameters params = ElementUserObject::validParams();
      18          15 :   params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
      19          30 :   params.addParam<MaterialPropertyName>("mask",
      20             :                                         "Material property to multiply the random numbers with");
      21          15 :   return params;
      22           0 : }
      23             : 
      24           8 : ConservedMaskedNoiseBase::ConservedMaskedNoiseBase(const InputParameters & parameters)
      25          16 :   : ConservedNoiseInterface(parameters), _mask(getMaterialProperty<Real>("mask"))
      26             : {
      27           8 : }
      28             : 
      29             : void
      30          29 : ConservedMaskedNoiseBase::initialize()
      31             : {
      32             :   _random_data.clear();
      33          29 :   _integral = 0.0;
      34          29 :   _volume = 0.0;
      35          29 : }
      36             : 
      37             : void
      38        2100 : ConservedMaskedNoiseBase::execute()
      39             : {
      40             :   // reserve space for each quadrature point in the element
      41        2100 :   std::vector<std::pair<Real, Real>> & me = _random_data[_current_elem->id()] =
      42        4200 :       std::vector<std::pair<Real, Real>>(_qrule->n_points());
      43             : 
      44             :   // store a random number for each quadrature point
      45       10500 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      46             :   {
      47        8400 :     me[_qp].first = getQpRandom();
      48        8400 :     me[_qp].second = _mask[_qp];
      49        8400 :     _integral += _JxW[_qp] * _coord[_qp] * me[_qp].first * me[_qp].second;
      50        8400 :     _volume += _JxW[_qp] * _coord[_qp] * me[_qp].second;
      51             :   }
      52        2100 : }
      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          25 : ConservedMaskedNoiseBase::finalize()
      66             : {
      67          25 :   gatherSum(_integral);
      68          25 :   gatherSum(_volume);
      69             : 
      70             :   // TODO check that _volume is >0
      71          25 :   _offset = _integral / _volume;
      72          25 : }
      73             : 
      74             : Real
      75      158400 : ConservedMaskedNoiseBase::getQpValue(dof_id_type element_id, unsigned int qp) const
      76             : {
      77             :   const auto it_pair = _random_data.find(element_id);
      78             : 
      79      158400 :   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      158400 :     return (it_pair->second[qp].first - _offset) * it_pair->second[qp].second;
      85             :   }
      86             : }