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       15315 : MooseParsedVectorFunction::validParams()
      17             : {
      18       15315 :   InputParameters params = Function::validParams();
      19       15315 :   params += MooseParsedFunctionBase::validParams();
      20       30630 :   params.addClassDescription(
      21             :       "Returns a vector function based on string descriptions for each component.");
      22       91890 :   params.addDeprecatedParam<std::string>(
      23             :       "value_x", "x-component of function.", "value_x is deprecated, use expression_x");
      24       91890 :   params.addDeprecatedParam<std::string>(
      25             :       "value_y", "y-component of function.", "value_y is deprecated, use expression_y");
      26       91890 :   params.addDeprecatedParam<std::string>(
      27             :       "value_z", "z-component of function.", "value_z is deprecated, use expression_z");
      28       61260 :   params.addParam<std::string>("expression_x", "0", "x-component of function.");
      29       61260 :   params.addParam<std::string>("expression_y", "0", "y-component of function.");
      30       61260 :   params.addParam<std::string>("expression_z", "0", "z-component of function.");
      31       61260 :   params.addParam<std::string>("curl_x", "0", "x-component of curl of function.");
      32       61260 :   params.addParam<std::string>("curl_y", "0", "y-component of curl of function.");
      33       61260 :   params.addParam<std::string>("curl_z", "0", "z-component of curl of function.");
      34       45945 :   params.addParam<std::string>("div", "0", "divergence of function.");
      35       15315 :   return params;
      36           0 : }
      37             : 
      38         545 : MooseParsedVectorFunction::MooseParsedVectorFunction(const InputParameters & parameters)
      39             :   : Function(parameters),
      40             :     MooseParsedFunctionBase(parameters),
      41        3815 :     _vector_value(verifyFunction(std::string("{") +
      42        3270 :                                  getRenamedParam<std::string>("value_x", "expression_x") + "}{" +
      43        3270 :                                  getRenamedParam<std::string>("value_y", "expression_y") + "}{" +
      44        1090 :                                  getRenamedParam<std::string>("value_z", "expression_z") + "}")),
      45        3815 :     _curl_value(verifyFunction(std::string("{") + getParam<std::string>("curl_x") + "}{" +
      46        2725 :                                getParam<std::string>("curl_y") + "}{" +
      47        1090 :                                getParam<std::string>("curl_z") + "}")),
      48        2180 :     _div_value(verifyFunction(getParam<std::string>("div")))
      49             : {
      50         545 : }
      51             : 
      52             : RealVectorValue
      53    10061970 : MooseParsedVectorFunction::vectorValue(Real t, const Point & p) const
      54             : {
      55    10061970 :   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         528 : MooseParsedVectorFunction::initialSetup()
      78             : {
      79         528 :   THREAD_ID tid = 0;
      80        1584 :   if (isParamValid("_tid"))
      81        1584 :     tid = getParam<THREAD_ID>("_tid");
      82             : 
      83         528 :   if (!_function_ptr)
      84         528 :     _function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      85         528 :         _pfb_feproblem, _vector_value, _vars, _vals, tid);
      86             : 
      87         528 :   if (!_curl_function_ptr)
      88         528 :     _curl_function_ptr = std::make_unique<MooseParsedFunctionWrapper>(
      89         528 :         _pfb_feproblem, _curl_value, _vars, _vals, tid);
      90             : 
      91         528 :   if (!_div_function_ptr)
      92             :     _div_function_ptr =
      93         528 :         std::make_unique<MooseParsedFunctionWrapper>(_pfb_feproblem, _div_value, _vars, _vals, tid);
      94         528 : }