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 "ElementValueSampler.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "MooseVariableFE.h"
      14             : 
      15             : // C++ includes
      16             : #include <numeric>
      17             : 
      18             : registerMooseObject("MooseApp", ElementValueSampler);
      19             : 
      20             : InputParameters
      21        3651 : ElementValueSampler::validParams()
      22             : {
      23        3651 :   InputParameters params = ElementVariableVectorPostprocessor::validParams();
      24             : 
      25        3651 :   params.addClassDescription("Samples values of variables on elements.");
      26             : 
      27        3651 :   params += SamplerBase::validParams();
      28             : 
      29        3651 :   return params;
      30           0 : }
      31             : 
      32         307 : ElementValueSampler::ElementValueSampler(const InputParameters & parameters)
      33         307 :   : ElementVariableVectorPostprocessor(parameters), SamplerBase(parameters, this, _communicator)
      34             : {
      35             :   // ensure that variables are 'elemental'
      36         658 :   for (unsigned int i = 0; i < _coupled_moose_vars.size(); i++)
      37             :   {
      38         360 :     if (_coupled_moose_vars[i]->isNodal())
      39           6 :       paramError("variable",
      40             :                  "The variable '",
      41           3 :                  _coupled_moose_vars[i]->name(),
      42             :                  "' is a nodal variable. Nodal variables can be sampled using a "
      43             :                  "'NodalValueSampler'.");
      44        1065 :     SamplerBase::checkForStandardFieldVariableType(_coupled_moose_vars[i]);
      45             :   }
      46         298 :   std::vector<std::string> var_names(_coupled_moose_vars.size());
      47         298 :   _values.resize(_coupled_moose_vars.size());
      48             : 
      49         649 :   for (unsigned int i = 0; i < _coupled_moose_vars.size(); i++)
      50         351 :     var_names[i] = _coupled_moose_vars[i]->name();
      51             : 
      52             :   // Initialize the data structures in SamplerBase
      53         298 :   SamplerBase::setupVariables(var_names);
      54         298 : }
      55             : 
      56             : void
      57         423 : ElementValueSampler::initialize()
      58             : {
      59         423 :   SamplerBase::initialize();
      60         423 : }
      61             : 
      62             : void
      63       71258 : ElementValueSampler::execute()
      64             : {
      65       71258 :   unsigned int i_fe = 0, i_fv = 0;
      66      142724 :   for (unsigned int i = 0; i < _coupled_moose_vars.size(); i++)
      67       71466 :     if (_coupled_moose_vars[i]->isFV())
      68             :     {
      69        2401 :       const auto state = determineState();
      70        2401 :       const Moose::ElemArg elem_arg = {_current_elem, /*correct_skewness*/ false};
      71        2401 :       _values[i] = MetaPhysicL::raw_value((*_coupled_fv_moose_vars[i_fv++])(elem_arg, state));
      72             :     }
      73             :     else
      74       69065 :       _values[i] = _coupled_standard_moose_vars[i_fe++]->getElementalValue(_current_elem);
      75             : 
      76       71258 :   SamplerBase::addSample(_current_elem->vertex_average(), _current_elem->id(), _values);
      77       71258 : }
      78             : 
      79             : void
      80         387 : ElementValueSampler::finalize()
      81             : {
      82         387 :   SamplerBase::finalize();
      83         387 : }
      84             : 
      85             : void
      86          36 : ElementValueSampler::threadJoin(const UserObject & y)
      87             : {
      88          36 :   const auto & vpp = static_cast<const ElementValueSampler &>(y);
      89             : 
      90          36 :   SamplerBase::threadJoin(vpp);
      91          36 : }