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, const std::string &expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
	Constructor. More...
ParsedFEMFunction &	operator= (const ParsedFEMFunction &)=delete
	This class contains a const reference so it can't be copy or move-assigned. More...
ParsedFEMFunction &	operator= (ParsedFEMFunction &&)=delete
	ParsedFEMFunction (const ParsedFEMFunction &)=default
	The remaining 5 special functions can be safely defaulted. More...
	ParsedFEMFunction (ParsedFEMFunction &&)=default
virtual	~ParsedFEMFunction ()=default
void	reparse (const 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 (const std::string &inline_var_name) const
void	set_inline_value (const std::string &inline_var_name, Output newval)
	Changes the value of an inline variable. 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 (const std::string &expression)
std::size_t	find_name (const std::string &varname, const std::string &expr) const
void	eval_args (const FEMContext &c, const Point &p, const Real time)
Output	eval (FunctionParserBase< Output > &parser, const std::string &libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
Output	eval (char &libmesh_dbg_var(parser), const std::string &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< 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, const std::string &  expression, const std::vector< std::string > *  additional_vars = nullptr, const std::vector< Output > *  initial_vals = nullptr  )

inlineexplicit

Constructor.

Definition at line 202 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(expression);
}

ParsedFEMFunction() [2/3]

template<typename Output = Number>

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

default

The remaining 5 special functions can be safely defaulted.

Note

The underlying FunctionParserBase class has a copy constructor, so this class should be default-constructible. And, although FunctionParserBase's move constructor is deleted, this class should still be move-constructible because FunctionParserBase only appears in a vector.

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 389 of file parsed_fem_function.h.

{
  return libmesh_make_unique<ParsedFEMFunction>
    (_sys, _expression, &_additional_vars, &_initial_vals);
}

Referenced by main().

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 431 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 = Number>

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

inlineprotected

eval() [2/2]

template<typename Output>

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

inlineprotected

Definition at line 803 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
                   << " of expression '"
                   << function_name
                   << "' 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_args()

template<typename Output >

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

inlineprotected

Definition at line 674 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 112 of file parsed_fem_function.h.

{ return _expression; }

find_name()

template<typename Output >

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

inlineprotected

Definition at line 648 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 ( const std::string &  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 445 of file parsed_fem_function.h.

{
  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) +
        inline_var_name;
 
#ifdef LIBMESH_HAVE_FPARSER
      // Parse and evaluate the new subexpression.
      // Add the same constants as we used originally.
      FunctionParserBase<Output> fp;
      fp.AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp.AddConstant("pi", std::acos(Real(-1)));
      fp.AddConstant("e", std::exp(Real(1)));
      if (fp.Parse(new_subexpression, variables) != -1) // -1 for success
        libmesh_error_msg
          ("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;
}

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

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 357 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);
      if (_n_requested_vars)
        elem_fe->get_phi();
      if (_n_requested_grad_components)
        elem_fe->get_dphi();
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      if (_n_requested_hess_components)
        elem_fe->get_d2phi();
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
    }
 
  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 >

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 144 of file fem_function_base.h.

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

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 412 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 >

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 398 of file parsed_fem_function.h.

{
  eval_args(c, p, time);
 
  return eval(parsers[0], "f", 0);
}

operator=() [1/2]

template<typename Output = Number>

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

delete

This class contains a const reference so it can't be copy or move-assigned.

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 ( const std::string &  expression )

inlineprotected

Definition at line 584 of file parsed_fem_function.h.

{
  _expression = 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
      if (_subexpressions.back().empty())
        libmesh_error_msg("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.
      FunctionParserBase<Output> fp;
      fp.AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp.AddConstant("pi", std::acos(Real(-1)));
      fp.AddConstant("e", std::exp(Real(1)));
      if (fp.Parse(_subexpressions.back(), variables) != -1) // -1 for success
        libmesh_error_msg
          ("ERROR: FunctionParser is unable to parse expression: "
           << _subexpressions.back() << '\n' << fp.ErrorMsg());
      fp.Optimize();
      parsers.push_back(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 ( const std::string &  expression )

inline

Re-parse with new expression.

Definition at line 228 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(expression);
}

set_inline_value()

template<typename Output>

void libMesh::ParsedFEMFunction< Output >::set_inline_value ( const std::string &  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 518 of file parsed_fem_function.h.

{
  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);
}

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

Member Data Documentation

_additional_vars

template<typename Output = Number>

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

private

Definition at line 193 of file parsed_fem_function.h.

_expression

template<typename Output = Number>

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

private

Definition at line 163 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 194 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 165 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 165 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 165 of file parsed_fem_function.h.

_n_vars

template<typename Output = Number>

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

private

Definition at line 165 of file parsed_fem_function.h.

_need_var

template<typename Output = Number>

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

private

Definition at line 180 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 183 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 188 of file parsed_fem_function.h.

_requested_normals

template<typename Output = Number>

bool libMesh::ParsedFEMFunction< Output >::_requested_normals

private

Definition at line 169 of file parsed_fem_function.h.

_spacetime

template<typename Output = Number>

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

private

Definition at line 175 of file parsed_fem_function.h.

_subexpressions

template<typename Output = Number>

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

private

Definition at line 164 of file parsed_fem_function.h.

_sys

template<typename Output = Number>

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

private

Definition at line 162 of file parsed_fem_function.h.

parsers [1/2]

template<typename Output = Number>

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

private

Definition at line 171 of file parsed_fem_function.h.

parsers [2/2]

template<typename Output = Number>

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

private

Definition at line 173 of file parsed_fem_function.h.

variables

template<typename Output = Number>

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

private

Definition at line 192 of file parsed_fem_function.h.

---

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

• include/numerics/parsed_fem_function.h