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       16001 : MooseParsedVectorFunction::validParams()
      17             : {
      18       16001 :   InputParameters params = Function::validParams();
      19       16001 :   params += MooseParsedFunctionBase::validParams();
      20       32002 :   params.addClassDescription(
      21             :       "Returns a vector function based on string descriptions for each component.");
      22       96006 :   params.addDeprecatedParam<std::string>(
      23             :       "value_x", "x-component of function.", "value_x is deprecated, use expression_x");
      24       96006 :   params.addDeprecatedParam<std::string>(
      25             :       "value_y", "y-component of function.", "value_y is deprecated, use expression_y");
      26       96006 :   params.addDeprecatedParam<std::string>(
      27             :       "value_z", "z-component of function.", "value_z is deprecated, use expression_z");
      28       64004 :   params.addParam<std::string>("expression_x", "0", "x-component of function.");
      29       64004 :   params.addParam<std::string>("expression_y", "0", "y-component of function.");
      30       64004 :   params.addParam<std::string>("expression_z", "0", "z-component of function.");
      31       64004 :   params.addParam<std::string>("curl_x", "0", "x-component of curl of function.");
      32       64004 :   params.addParam<std::string>("curl_y", "0", "y-component of curl of function.");
      33       64004 :   params.addParam<std::string>("curl_z", "0", "z-component of curl of function.");
      34       48003 :   params.addParam<std::string>("div", "0", "divergence of function.");
      35       16001 :   return params;
      36           0 : }
      37             : 
      38         584 : MooseParsedVectorFunction::MooseParsedVectorFunction(const InputParameters & parameters)
      39             :   : Function(parameters),
      40             :     MooseParsedFunctionBase(parameters),
      41        4088 :     _vector_value(verifyFunction(std::string("{") +
      42        3504 :                                  getRenamedParam<std::string>("value_x", "expression_x") + "}{" +
      43        3504 :                                  getRenamedParam<std::string>("value_y", "expression_y") + "}{" +
      44        1168 :                                  getRenamedParam<std::string>("value_z", "expression_z") + "}")),
      45        4088 :     _curl_value(verifyFunction(std::string("{") + getParam<std::string>("curl_x") + "}{" +
      46        2920 :                                getParam<std::string>("curl_y") + "}{" +
      47        1168 :                                getParam<std::string>("curl_z") + "}")),
      48        2336 :     _div_value(verifyFunction(getParam<std::string>("div")))
      49             : {
      50         584 : }
      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         565 : MooseParsedVectorFunction::initialSetup()
      78             : {
      79         565 :   THREAD_ID tid = 0;
      80        1695 :   if (isParamValid("_tid"))
      81        1695 :     tid = getParam<THREAD_ID>("_tid");
      82             : 
      83         565 :   if (!_function_ptr)
      84         565 :     _function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      85         565 :         _pfb_feproblem, _vector_value, _vars, _vals, tid);
      86             : 
      87         565 :   if (!_curl_function_ptr)
      88         565 :     _curl_function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      89         565 :         _pfb_feproblem, _curl_value, _vars, _vals, tid);
      90             : 
      91         565 :   if (!_div_function_ptr)
      92             :     _div_function_ptr =
      93         565 :         std::make_unique<MooseParsedFunctionWrapper>(_pfb_feproblem, _div_value, _vars, _vals, tid);
      94         565 : }