libMesh::ParsedFEMFunction< Output > Class Template Reference

ParsedFEMFunction provides support for FParser-based parsed functions in FEMSystem. More...

#include <parsed_fem_function.h>

Inheritance diagram for libMesh::ParsedFEMFunction< Output >:

Public Member Functions
	ParsedFEMFunction (const System &sys, std::string expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
	Constructor. More...
ParsedFEMFunction &	operator= (const ParsedFEMFunction &)
	Constructors. More...
ParsedFEMFunction &	operator= (ParsedFEMFunction &&)=delete
	ParsedFEMFunction (const ParsedFEMFunction &)
	ParsedFEMFunction (ParsedFEMFunction &&)=default
virtual	~ParsedFEMFunction ()=default
void	reparse (std::string expression)
	Re-parse with new expression. More...
virtual void	init_context (const FEMContext &c) override
	Prepares a context object for use. More...
virtual std::unique_ptr< FEMFunctionBase< Output > >	clone () const override
virtual Output	operator() (const FEMContext &c, const Point &p, const Real time=0.) override
void	operator() (const FEMContext &c, const Point &p, const Real time, DenseVector< Output > &output) override
	Evaluation function for time-dependent vector-valued functions. More...
virtual Output	component (const FEMContext &c, unsigned int i, const Point &p, Real time=0.) override
const std::string &	expression ()
Output	get_inline_value (std::string_view inline_var_name) const
void	set_inline_value (std::string_view inline_var_name, Output newval)
	Changes the value of an inline variable. More...
virtual void	init ()
	Any post-construction initialization. More...
void	operator() (const FEMContext &, const Point &p, DenseVector< Output > &output)
	Evaluation function for time-independent vector-valued functions. More...

Protected Member Functions
void	partial_reparse (std::string expression)
std::size_t	find_name (std::string_view varname, std::string_view expr) const
void	eval_args (const FEMContext &c, const Point &p, const Real time)
Output	eval (FunctionParserBase< Output > &parser, std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
Output	eval (char &libmesh_dbg_var(parser), std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const

Private Attributes
const System &	_sys
std::string	_expression
std::vector< std::string >	_subexpressions
unsigned int	_n_vars
unsigned int	_n_requested_vars
unsigned int	_n_requested_grad_components
unsigned int	_n_requested_hess_components
bool	_requested_normals
std::vector< std::unique_ptr< FunctionParserBase< Output > > >	parsers
std::vector< char * >	parsers
std::vector< Output >	_spacetime
std::vector< bool >	_need_var
std::vector< bool >	_need_var_grad
std::vector< bool >	_need_var_hess
std::string	variables
std::vector< std::string >	_additional_vars
std::vector< Output >	_initial_vals

Detailed Description

template<typename Output = Number>
class libMesh::ParsedFEMFunction< Output >

ParsedFEMFunction provides support for FParser-based parsed functions in FEMSystem.

All overridden virtual functions are documented in fem_function_base.h.

Author

Roy Stogner

Date

2014 Support for using parsed functions in FEMSystem.

Definition at line 57 of file parsed_fem_function.h.

Constructor & Destructor Documentation

ParsedFEMFunction() [1/3]

template<typename Output>

libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction ( const System &  sys, std::string  expression, const std::vector< std::string > *  additional_vars = nullptr, const std::vector< Output > *  initial_vals = nullptr  )

inlineexplicit

Constructor.

Definition at line 197 of file parsed_fem_function.h.

                                                                                      :
  _sys(sys),
  _expression (), // overridden by parse()
  _n_vars(sys.n_vars()),
  _n_requested_vars(0),
  _n_requested_grad_components(0),
  _n_requested_hess_components(0),
  _requested_normals(false),
  _need_var(_n_vars, false),
  _need_var_grad(_n_vars*LIBMESH_DIM, false),
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  _need_var_hess(_n_vars*LIBMESH_DIM*LIBMESH_DIM, false),
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  _additional_vars (additional_vars ? *additional_vars : std::vector<std::string>()),
  _initial_vals (initial_vals ? *initial_vals : std::vector<Output>())
{
  this->reparse(std::move(expression));
}

ParsedFEMFunction() [2/3]

template<typename Output>

libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction ( const ParsedFEMFunction< Output > &  other )

inline

Definition at line 222 of file parsed_fem_function.h.

                                                                                     :
  FEMFunctionBase<Output>(other),
  _sys(other._sys),
  _expression(other._expression),
  _subexpressions(other._subexpressions),
  _n_vars(other._n_vars),
  _n_requested_vars(other._n_requested_vars),
  _n_requested_grad_components(other._n_requested_grad_components),
  _n_requested_hess_components(other._n_requested_hess_components),
  _requested_normals(other._requested_normals),
  _spacetime(other._spacetime),
  _need_var(other._need_var),
  _need_var_grad(other._need_var_grad),
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  _need_var_hess(other._need_var_hess),
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  variables(other.variables),
  _additional_vars(other._additional_vars),
  _initial_vals(other._initial_vals)
{
  this->reparse(_expression);
}

ParsedFEMFunction() [3/3]

template<typename Output = Number>

libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction ( ParsedFEMFunction< Output > &&  )

default

~ParsedFEMFunction()

template<typename Output = Number>

virtual libMesh::ParsedFEMFunction< Output >::~ParsedFEMFunction ( )

virtualdefault

Member Function Documentation

clone()

template<typename Output >

std::unique_ptr< FEMFunctionBase< Output > > libMesh::ParsedFEMFunction< Output >::clone ( ) const

inlineoverridevirtual

Returns

A new copy of the function.

The new copy should be as "deep" as necessary to allow independent destruction and simultaneous evaluations of the copies in different threads.

Implements libMesh::FEMFunctionBase< Output >.

Definition at line 437 of file parsed_fem_function.h.

{
  return std::make_unique<ParsedFEMFunction>
    (_sys, _expression, &_additional_vars, &_initial_vals);
}

component()

template<typename Output >

Output libMesh::ParsedFEMFunction< Output >::component ( const FEMContext &  context, unsigned int  i, const Point &  p, Real  time = 0.  )

inlineoverridevirtual

Returns

The vector component i at coordinate p and time time.

Note

Subclasses aren't required to override this, since the default implementation is based on the full vector evaluation, which is often correct.

Subclasses are recommended to override this, since the default implementation is based on a vector evaluation, which is usually unnecessarily inefficient.

Reimplemented from libMesh::FEMFunctionBase< Output >.

Definition at line 479 of file parsed_fem_function.h.

{
  eval_args(c, p, time);

  libmesh_assert_less (i, parsers.size());
  return eval(*parsers[i], "f", i);
}

eval() [1/2]

template<typename Output>

Output libMesh::ParsedFEMFunction< Output >::eval ( FunctionParserBase< Output > &  parser, std::string_view   libmesh_dbg_varfunction_name, unsigned int   libmesh_dbg_varcomponent_idx  ) const

inlineprotected

Definition at line 851 of file parsed_fem_function.h.

{
#ifndef NDEBUG
  Output result = parser.Eval(_spacetime.data());
  int error_code = parser.EvalError();
  if (error_code)
    {
      libMesh::err << "ERROR: FunctionParser is unable to evaluate component "
                   << component_idx
                   << " for '"
                   << function_name;

      for (auto i : index_range(parsers))
        if (parsers[i].get() == &parser)
          libMesh::err << "' of expression '"
                       << _subexpressions[i];

      libMesh::err << "' with arguments:\n";
      for (const auto & st : _spacetime)
        libMesh::err << '\t' << st << '\n';
      libMesh::err << '\n';

      // Currently no API to report error messages, we'll do it manually
      std::string error_message = "Reason: ";

      switch (error_code)
        {
        case 1:
          error_message += "Division by zero";
          break;
        case 2:
          error_message += "Square Root error (negative value)";
          break;
        case 3:
          error_message += "Log error (negative value)";
          break;
        case 4:
          error_message += "Trigonometric error (asin or acos of illegal value)";
          break;
        case 5:
          error_message += "Maximum recursion level reached";
          break;
        default:
          error_message += "Unknown";
          break;
        }
      libmesh_error_msg(error_message);
    }

  return result;
#else
  return parser.Eval(_spacetime.data());
#endif
}

eval() [2/2]

template<typename Output = Number>

Output libMesh::ParsedFEMFunction< Output >::eval ( char &  libmesh_dbg_varparser, std::string_view   libmesh_dbg_varfunction_name, unsigned int   libmesh_dbg_varcomponent_idx  ) const

inlineprotected

eval_args()

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::eval_args ( const FEMContext &  c, const Point &  p, const Real  time  )

inlineprotected

Definition at line 722 of file parsed_fem_function.h.

{
  _spacetime[0] = p(0);
#if LIBMESH_DIM > 1
  _spacetime[1] = p(1);
#endif
#if LIBMESH_DIM > 2
  _spacetime[2] = p(2);
#endif
  _spacetime[LIBMESH_DIM] = time;

  unsigned int request_index = 0;
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      if (!_need_var[v])
        continue;

      c.point_value(v, p, _spacetime[LIBMESH_DIM+1+request_index]);
      request_index++;
    }

  if (_n_requested_grad_components)
    for (unsigned int v=0; v != _n_vars; ++v)
      {
        if (!_need_var_grad[v*LIBMESH_DIM]
#if LIBMESH_DIM > 1
            && !_need_var_grad[v*LIBMESH_DIM+1]
#if LIBMESH_DIM > 2
            && !_need_var_grad[v*LIBMESH_DIM+2]
#endif
#endif
            )
          continue;

        Gradient g;
        c.point_gradient(v, p, g);

        for (unsigned int d=0; d != LIBMESH_DIM; ++d)
          {
            if (!_need_var_grad[v*LIBMESH_DIM+d])
              continue;

            _spacetime[LIBMESH_DIM+1+request_index] = g(d);
            request_index++;
          }
      }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  if (_n_requested_hess_components)
    for (unsigned int v=0; v != _n_vars; ++v)
      {
        if (!_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM]
#if LIBMESH_DIM > 1
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+1]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+2]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+3]
#if LIBMESH_DIM > 2
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+4]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+5]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+6]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+7]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+8]
#endif
#endif
            )
          continue;

        Tensor h;
        c.point_hessian(v, p, h);

        for (unsigned int d1=0; d1 != LIBMESH_DIM; ++d1)
          for (unsigned int d2=0; d2 != LIBMESH_DIM; ++d2)
            {
              if (!_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+d1*LIBMESH_DIM+d2])
                continue;

              _spacetime[LIBMESH_DIM+1+request_index] = h(d1,d2);
              request_index++;
            }
      }
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES

  if (_requested_normals)
    {
      FEBase * side_fe;
      c.get_side_fe(0, side_fe);

      const std::vector<Point> & normals = side_fe->get_normals();

      const std::vector<Point> & xyz = side_fe->get_xyz();

      libmesh_assert_equal_to(normals.size(), xyz.size());

      // We currently only support normals at quadrature points!
#ifndef NDEBUG
      bool at_quadrature_point = false;
#endif
      for (auto qp : index_range(normals))
        {
          if (p == xyz[qp])
            {
              const Point & n = normals[qp];
              for (unsigned int d=0; d != LIBMESH_DIM; ++d)
                {
                  _spacetime[LIBMESH_DIM+1+request_index] = n(d);
                  request_index++;
                }
#ifndef NDEBUG
              at_quadrature_point = true;
#endif
              break;
            }
        }

      libmesh_assert(at_quadrature_point);
    }

  // The remaining locations in _spacetime are currently set at construction
  // but could potentially be made dynamic
}

expression()

template<typename Output = Number>

const std::string& libMesh::ParsedFEMFunction< Output >::expression ( )

inline

Definition at line 107 of file parsed_fem_function.h.

{ return _expression; }

find_name()

template<typename Output >

std::size_t libMesh::ParsedFEMFunction< Output >::find_name ( std::string_view  varname, std::string_view  expr  ) const

inlineprotected

Definition at line 696 of file parsed_fem_function.h.

{
  const std::size_t namesize = varname.size();
  std::size_t varname_i = expr.find(varname);

  while ((varname_i != std::string::npos) &&
         (((varname_i > 0) &&
           (std::isalnum(expr[varname_i-1]) ||
            (expr[varname_i-1] == '_'))) ||
          ((varname_i+namesize < expr.size()) &&
           (std::isalnum(expr[varname_i+namesize]) ||
            (expr[varname_i+namesize] == '_')))))
    {
      varname_i = expr.find(varname, varname_i+1);
    }

  return varname_i;
}

get_inline_value()

template<typename Output >

Output libMesh::ParsedFEMFunction< Output >::get_inline_value ( std::string_view  inline_var_name ) const

inline

Returns

The value of an inline variable.

Note

Will only be correct if the inline variable value is independent of input variables, if the inline variable is not redefined within any subexpression, and if the inline variable takes the same value within any subexpressions where it appears.

Definition at line 493 of file parsed_fem_function.h.

Referenced by libMesh::ParsedFEMFunctionParameter< T >::get(), ParsedFEMFunctionTest::testInlineGetter(), and ParsedFEMFunctionTest::testInlineSetter().

{
  libmesh_assert_greater (_subexpressions.size(), 0);

#ifndef NDEBUG
  bool found_var_name = false;
#endif
  Output old_var_value(0.);

  for (const std::string & subexpression : _subexpressions)
    {
      const std::size_t varname_i =
        find_name(inline_var_name, subexpression);
      if (varname_i == std::string::npos)
        continue;

      const std::size_t assignment_i =
        subexpression.find(":", varname_i+1);

      libmesh_assert_not_equal_to(assignment_i, std::string::npos);

      libmesh_assert_equal_to(subexpression[assignment_i+1], '=');
      for (std::size_t i = varname_i+1; i != assignment_i; ++i)
        libmesh_assert_equal_to(subexpression[i], ' ');

      std::size_t end_assignment_i =
        subexpression.find(";", assignment_i+1);

      libmesh_assert_not_equal_to(end_assignment_i, std::string::npos);

      std::string new_subexpression =
        subexpression.substr(0, end_assignment_i+1).
         append(inline_var_name);

#ifdef LIBMESH_HAVE_FPARSER
      // Parse and evaluate the new subexpression.
      // Add the same constants as we used originally.
      auto fp = std::make_unique<FunctionParserBase<Output>>();
      fp->AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp->AddConstant("pi", std::acos(Real(-1)));
      fp->AddConstant("e", std::exp(Real(1)));
      libmesh_error_msg_if
        (fp->Parse(new_subexpression, variables) != -1, // -1 for success
         "ERROR: FunctionParser is unable to parse modified expression: "
         << new_subexpression << '\n' << fp->ErrorMsg());

      Output new_var_value = this->eval(*fp, new_subexpression, 0);
#ifdef NDEBUG
      return new_var_value;
#else
      if (found_var_name)
        {
          libmesh_assert_equal_to(old_var_value, new_var_value);
        }
      else
        {
          old_var_value = new_var_value;
          found_var_name = true;
        }
#endif

#else
      libmesh_error_msg("ERROR: This functionality requires fparser!");
#endif
    }

  libmesh_assert(found_var_name);
  return old_var_value;
}

init()

template<typename Output = Number>

virtual void libMesh::FEMFunctionBase< Output >::init ( )

inlinevirtualinherited

Any post-construction initialization.

Reimplemented in libMesh::WrappedFunctor< Output >.

Definition at line 69 of file fem_function_base.h.

{}

init_context()

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::init_context ( const FEMContext &  )

inlineoverridevirtual

Prepares a context object for use.

Most problems will want to reimplement this for efficiency, in order to call FE::get_*() as their particular function requires.

Reimplemented from libMesh::FEMFunctionBase< Output >.

Definition at line 393 of file parsed_fem_function.h.

{
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      FEBase * elem_fe;
      c.get_element_fe(v, elem_fe);
      bool request_nothing = true;
      if (_n_requested_vars)
        {
          elem_fe->get_phi();
          request_nothing = false;
        }
      if (_n_requested_grad_components)
        {
          elem_fe->get_dphi();
          request_nothing = false;
        }
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      if (_n_requested_hess_components)
        {
          elem_fe->get_d2phi();
          request_nothing = false;
        }
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
      if (request_nothing)
        elem_fe->get_nothing();
    }

  if (_requested_normals)
    {
      FEBase * side_fe;
      c.get_side_fe(0, side_fe);

      side_fe->get_normals();

      // FIXME: this is a hack to support normals at quadrature
      // points; we don't support normals elsewhere.
      side_fe->get_xyz();
    }
}

operator()() [1/3]

template<typename Output >

Output libMesh::ParsedFEMFunction< Output >::operator() ( const FEMContext &  , const Point &  p, const Real  time = 0.  )

inlineoverridevirtual

Returns

The scalar function value at coordinate p and time time, which defaults to zero.

Pure virtual, so you have to override it.

Implements libMesh::FEMFunctionBase< Output >.

Definition at line 446 of file parsed_fem_function.h.

{
  eval_args(c, p, time);

  return eval(*parsers[0], "f", 0);
}

operator()() [2/3]

template<typename Output>

void libMesh::ParsedFEMFunction< Output >::operator() ( const FEMContext &  , const Point &  p, const Real  time, DenseVector< Output > &  output  )

inlineoverridevirtual

Evaluation function for time-dependent vector-valued functions.

Sets output values in the passed-in output DenseVector.

Pure virtual, so you have to override it.

Implements libMesh::FEMFunctionBase< Output >.

Definition at line 460 of file parsed_fem_function.h.

{
  eval_args(c, p, time);

  unsigned int size = output.size();

  libmesh_assert_equal_to (size, parsers.size());

  for (unsigned int i=0; i != size; ++i)
    output(i) = eval(*parsers[i], "f", i);
}

operator()() [3/3]

template<typename Output >

void libMesh::FEMFunctionBase< Output >::operator() ( const FEMContext &  context, const Point &  p, DenseVector< Output > &  output  )

inlineinherited

Evaluation function for time-independent vector-valued functions.

Sets output values in the passed-in output DenseVector.

Definition at line 149 of file fem_function_base.h.

{
  // Call the time-dependent function with t=0.
  this->operator()(context, p, 0., output);
}

operator=() [1/2]

template<typename Output >

ParsedFEMFunction< Output > & libMesh::ParsedFEMFunction< Output >::operator= ( const ParsedFEMFunction< Output > &  other )

inline

Constructors.

• This class contains a const reference so it can't be default copy or move-assigned. We manually implement the former
• This class contains unique_ptrs so it can't be default copy constructed or assigned.
• It can still be default moved and deleted.

Definition at line 249 of file parsed_fem_function.h.

{
  // We can only be assigned another ParsedFEMFunction defined on the same System
  libmesh_assert(&_sys == &other._sys);

  // Use copy-and-swap idiom
  ParsedFEMFunction<Output> tmp(other);
  std::swap(tmp, *this);
  return *this;
}

operator=() [2/2]

template<typename Output = Number>

ParsedFEMFunction& libMesh::ParsedFEMFunction< Output >::operator= ( ParsedFEMFunction< Output > &&  )

delete

partial_reparse()

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::partial_reparse ( std::string  expression )

inlineprotected

Definition at line 632 of file parsed_fem_function.h.

{
  _expression = std::move(expression);
  _subexpressions.clear();
  parsers.clear();

  size_t nextstart = 0, end = 0;

  while (end != std::string::npos)
    {
      // If we're past the end of the string, we can't make any more
      // subparsers
      if (nextstart >= _expression.size())
        break;

      // If we're at the start of a brace delimited section, then we
      // parse just that section:
      if (_expression[nextstart] == '{')
        {
          nextstart++;
          end = _expression.find('}', nextstart);
        }
      // otherwise we parse the whole thing
      else
        end = std::string::npos;

      // We either want the whole end of the string (end == npos) or
      // a substring in the middle.
      _subexpressions.push_back
        (_expression.substr(nextstart, (end == std::string::npos) ?
                           std::string::npos : end - nextstart));

      // fparser can crash on empty expressions
      libmesh_error_msg_if(_subexpressions.back().empty(),
                           "ERROR: FunctionParser is unable to parse empty expression.\n");


#ifdef LIBMESH_HAVE_FPARSER
      // Parse (and optimize if possible) the subexpression.
      // Add some basic constants, to Real precision.
      auto fp = std::make_unique<FunctionParserBase<Output>>();
      fp->AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp->AddConstant("pi", std::acos(Real(-1)));
      fp->AddConstant("e", std::exp(Real(1)));
      libmesh_error_msg_if
        (fp->Parse(_subexpressions.back(), variables) != -1, // -1 for success
         "ERROR: FunctionParser is unable to parse expression: "
         << _subexpressions.back() << '\n' << fp->ErrorMsg());
      fp->Optimize();
      parsers.push_back(std::move(fp));
#else
      libmesh_error_msg("ERROR: This functionality requires fparser!");
#endif

      // If at end, use nextstart=maxSize.  Else start at next
      // character.
      nextstart = (end == std::string::npos) ?
        std::string::npos : end + 1;
    }
}

reparse()

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::reparse ( std::string  expression )

inline

Re-parse with new expression.

Definition at line 264 of file parsed_fem_function.h.

{
  variables = "x";
#if LIBMESH_DIM > 1
  variables += ",y";
#endif
#if LIBMESH_DIM > 2
  variables += ",z";
#endif
  variables += ",t";

  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);
      std::size_t varname_i = find_name(varname, expression);

      // If we didn't find our variable name then let's go to the
      // next.
      if (varname_i == std::string::npos)
        continue;

      _need_var[v] = true;
      variables += ',';
      variables += varname;
      _n_requested_vars++;
    }

  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);

      for (unsigned int d=0; d != LIBMESH_DIM; ++d)
        {
          std::string gradname = std::string("grad_") +
            "xyz"[d] + '_' + varname;
          std::size_t gradname_i = find_name(gradname, expression);

          // If we didn't find that gradient component of our
          // variable name then let's go to the next.
          if (gradname_i == std::string::npos)
            continue;

          _need_var_grad[v*LIBMESH_DIM+d] = true;
          variables += ',';
          variables += gradname;
          _n_requested_grad_components++;
        }
    }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);

      for (unsigned int d1=0; d1 != LIBMESH_DIM; ++d1)
        for (unsigned int d2=0; d2 != LIBMESH_DIM; ++d2)
          {
            std::string hessname = std::string("hess_") +
              "xyz"[d1] + "xyz"[d2] + '_' + varname;
            std::size_t hessname_i = find_name(hessname, expression);

            // If we didn't find that hessian component of our
            // variable name then let's go to the next.
            if (hessname_i == std::string::npos)
              continue;

            _need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+d1*LIBMESH_DIM+d2]
              = true;
            variables += ',';
            variables += hessname;
            _n_requested_hess_components++;
          }
    }
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES

  {
    std::size_t nx_i = find_name("n_x", expression);
    std::size_t ny_i = find_name("n_y", expression);
    std::size_t nz_i = find_name("n_z", expression);

    // If we found any requests for normal components then we'll
    // compute normals
    if (nx_i != std::string::npos ||
        ny_i != std::string::npos ||
        nz_i != std::string::npos)
      {
        _requested_normals = true;
        variables += ',';
        variables += "n_x";
        if (LIBMESH_DIM > 1)
          {
            variables += ',';
            variables += "n_y";
          }
        if (LIBMESH_DIM > 2)
          {
            variables += ',';
            variables += "n_z";
          }
      }
  }

  _spacetime.resize
    (LIBMESH_DIM + 1 + _n_requested_vars +
     _n_requested_grad_components + _n_requested_hess_components +
     (_requested_normals ? LIBMESH_DIM : 0) +
     _additional_vars.size());

  // If additional vars were passed, append them to the string
  // that we send to the function parser. Also add them to the
  // end of our spacetime vector
  unsigned int offset = LIBMESH_DIM + 1 + _n_requested_vars +
    _n_requested_grad_components + _n_requested_hess_components;

  for (auto i : index_range(_additional_vars))
    {
      variables += "," + _additional_vars[i];
      // Initialize extra variables to the vector passed in or zero
      // Note: The initial_vals vector can be shorter than the additional_vars vector
      _spacetime[offset + i] =
        (i < _initial_vals.size()) ? _initial_vals[i] : 0;
    }

  this->partial_reparse(std::move(expression));
}

set_inline_value()

template<typename Output>

void libMesh::ParsedFEMFunction< Output >::set_inline_value ( std::string_view  inline_var_name, Output  newval  )

inline

Changes the value of an inline variable.

Note

Forever after, the variable value will take the given constant, independent of input variables, in every subexpression where it is already defined.

Currently only works if the inline variable is not redefined within any one subexpression.

Definition at line 566 of file parsed_fem_function.h.

Referenced by libMesh::ParsedFEMFunctionParameter< T >::set(), and ParsedFEMFunctionTest::testInlineSetter().

{
  libmesh_assert_greater (_subexpressions.size(), 0);

#ifndef NDEBUG
  bool found_var_name = false;
#endif
  for (auto s : index_range(_subexpressions))
    {
      const std::string & subexpression = _subexpressions[s];
      const std::size_t varname_i =
        find_name(inline_var_name, subexpression);
      if (varname_i == std::string::npos)
        continue;

#ifndef NDEBUG
      found_var_name = true;
#endif

      const std::size_t assignment_i =
        subexpression.find(":", varname_i+1);

      libmesh_assert_not_equal_to(assignment_i, std::string::npos);

      libmesh_assert_equal_to(subexpression[assignment_i+1], '=');
      for (std::size_t i = varname_i+1; i != assignment_i; ++i)
        libmesh_assert_equal_to(subexpression[i], ' ');

      std::size_t end_assignment_i =
        subexpression.find(";", assignment_i+1);

      libmesh_assert_not_equal_to(end_assignment_i, std::string::npos);

      std::ostringstream new_subexpression;
      new_subexpression << subexpression.substr(0, assignment_i+2)
                        << std::setprecision(std::numeric_limits<Output>::digits10+2)
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                        << '(' << newval.real() << '+'
                        << newval.imag() << 'i' << ')'
#else
                        << newval
#endif
                        << subexpression.substr(end_assignment_i,
                                                std::string::npos);
      _subexpressions[s] = new_subexpression.str();
    }

  libmesh_assert(found_var_name);

  std::string new_expression;

  for (const auto & subexpression : _subexpressions)
    {
      new_expression += '{';
      new_expression += subexpression;
      new_expression += '}';
    }

  this->partial_reparse(new_expression);
}

Member Data Documentation

_additional_vars

template<typename Output = Number>

std::vector<std::string> libMesh::ParsedFEMFunction< Output >::_additional_vars

private

Definition at line 188 of file parsed_fem_function.h.

_expression

template<typename Output = Number>

std::string libMesh::ParsedFEMFunction< Output >::_expression

private

Definition at line 158 of file parsed_fem_function.h.

Referenced by libMesh::ParsedFEMFunction< T >::expression().

_initial_vals

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFEMFunction< Output >::_initial_vals

private

Definition at line 189 of file parsed_fem_function.h.

_n_requested_grad_components

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_grad_components

private

Definition at line 160 of file parsed_fem_function.h.

_n_requested_hess_components

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_hess_components

private

Definition at line 160 of file parsed_fem_function.h.

_n_requested_vars

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_vars

private

Definition at line 160 of file parsed_fem_function.h.

_n_vars

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_vars

private

Definition at line 160 of file parsed_fem_function.h.

_need_var

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var

private

Definition at line 175 of file parsed_fem_function.h.

_need_var_grad

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var_grad

private

Definition at line 178 of file parsed_fem_function.h.

_need_var_hess

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var_hess

private

Definition at line 183 of file parsed_fem_function.h.

_requested_normals

template<typename Output = Number>

bool libMesh::ParsedFEMFunction< Output >::_requested_normals

private

Definition at line 164 of file parsed_fem_function.h.

_spacetime

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFEMFunction< Output >::_spacetime

private

Definition at line 170 of file parsed_fem_function.h.

_subexpressions

template<typename Output = Number>

std::vector<std::string> libMesh::ParsedFEMFunction< Output >::_subexpressions

private

Definition at line 159 of file parsed_fem_function.h.

_sys

template<typename Output = Number>

const System& libMesh::ParsedFEMFunction< Output >::_sys

private

Definition at line 157 of file parsed_fem_function.h.

Referenced by libMesh::ParsedFEMFunction< T >::operator=().

parsers [1/2]

template<typename Output = Number>

std::vector<std::unique_ptr<FunctionParserBase<Output> > > libMesh::ParsedFEMFunction< Output >::parsers

private

Definition at line 166 of file parsed_fem_function.h.

parsers [2/2]

template<typename Output = Number>

std::vector<char*> libMesh::ParsedFEMFunction< Output >::parsers

private

Definition at line 168 of file parsed_fem_function.h.

variables

template<typename Output = Number>

std::string libMesh::ParsedFEMFunction< Output >::variables

private

Definition at line 187 of file parsed_fem_function.h.

---

The documentation for this class was generated from the following file:

• include/numerics/parsed_fem_function.h