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 "MooseParsedVectorFunction.h"
      11             : #include "MooseParsedFunctionWrapper.h"
      12             : 
      13             : registerMooseObjectAliased("MooseApp", MooseParsedVectorFunction, "ParsedVectorFunction");
      14             : 
      15             : InputParameters
      16       15889 : MooseParsedVectorFunction::validParams()
      17             : {
      18       15889 :   InputParameters params = Function::validParams();
      19       15889 :   params += MooseParsedFunctionBase::validParams();
      20       31778 :   params.addClassDescription(
      21             :       "Returns a vector function based on string descriptions for each component.");
      22       95334 :   params.addDeprecatedParam<std::string>(
      23             :       "value_x", "x-component of function.", "value_x is deprecated, use expression_x");
      24       95334 :   params.addDeprecatedParam<std::string>(
      25             :       "value_y", "y-component of function.", "value_y is deprecated, use expression_y");
      26       95334 :   params.addDeprecatedParam<std::string>(
      27             :       "value_z", "z-component of function.", "value_z is deprecated, use expression_z");
      28       63556 :   params.addParam<std::string>("expression_x", "0", "x-component of function.");
      29       63556 :   params.addParam<std::string>("expression_y", "0", "y-component of function.");
      30       63556 :   params.addParam<std::string>("expression_z", "0", "z-component of function.");
      31       63556 :   params.addParam<std::string>("curl_x", "0", "x-component of curl of function.");
      32       63556 :   params.addParam<std::string>("curl_y", "0", "y-component of curl of function.");
      33       63556 :   params.addParam<std::string>("curl_z", "0", "z-component of curl of function.");
      34       47667 :   params.addParam<std::string>("div", "0", "divergence of function.");
      35       15889 :   return params;
      36           0 : }
      37             : 
      38         592 : MooseParsedVectorFunction::MooseParsedVectorFunction(const InputParameters & parameters)
      39             :   : Function(parameters),
      40             :     MooseParsedFunctionBase(parameters),
      41        4144 :     _vector_value(verifyFunction(std::string("{") +
      42        3552 :                                  getRenamedParam<std::string>("value_x", "expression_x") + "}{" +
      43        3552 :                                  getRenamedParam<std::string>("value_y", "expression_y") + "}{" +
      44        1184 :                                  getRenamedParam<std::string>("value_z", "expression_z") + "}")),
      45        4144 :     _curl_value(verifyFunction(std::string("{") + getParam<std::string>("curl_x") + "}{" +
      46        2960 :                                getParam<std::string>("curl_y") + "}{" +
      47        1184 :                                getParam<std::string>("curl_z") + "}")),
      48        2368 :     _div_value(verifyFunction(getParam<std::string>("div")))
      49             : {
      50         592 : }
      51             : 
      52             : RealVectorValue
      53    10105549 : MooseParsedVectorFunction::vectorValue(Real t, const Point & p) const
      54             : {
      55    10105549 :   return _function_ptr->evaluate<RealVectorValue>(t, p);
      56             : }
      57             : 
      58             : RealVectorValue
      59       55440 : MooseParsedVectorFunction::curl(Real t, const Point & p) const
      60             : {
      61       55440 :   return _curl_function_ptr->evaluate<RealVectorValue>(t, p);
      62             : }
      63             : 
      64             : Real
      65      513216 : MooseParsedVectorFunction::div(Real t, const Point & p) const
      66             : {
      67      513216 :   return _div_function_ptr->evaluate<Real>(t, p);
      68             : }
      69             : 
      70             : RealGradient
      71           0 : MooseParsedVectorFunction::gradient(Real /*t*/, const Point & /*p*/) const
      72             : {
      73           0 :   mooseError("The gradient method is not defined in MooseParsedVectorFunction");
      74             : }
      75             : 
      76             : void
      77         573 : MooseParsedVectorFunction::initialSetup()
      78             : {
      79         573 :   THREAD_ID tid = 0;
      80        1719 :   if (isParamValid("_tid"))
      81        1719 :     tid = getParam<THREAD_ID>("_tid");
      82             : 
      83         573 :   if (!_function_ptr)
      84         573 :     _function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      85         573 :         _pfb_feproblem, _vector_value, _vars, _vals, tid);
      86             : 
      87         573 :   if (!_curl_function_ptr)
      88         573 :     _curl_function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      89         573 :         _pfb_feproblem, _curl_value, _vars, _vals, tid);
      90             : 
      91         573 :   if (!_div_function_ptr)
      92             :     _div_function_ptr =
      93         573 :         std::make_unique<MooseParsedFunctionWrapper>(_pfb_feproblem, _div_value, _vars, _vals, tid);
      94         573 : }