libMesh::ParsedFunction< Output > Class Template Reference

#include <parsed_function.h>

Inheritance diagram for libMesh::ParsedFunction< Output >:

[legend]

List of all members.

Public Member Functions
	ParsedFunction (const std::string &expression, const std::vector< std::string > *additional_vars=NULL, const std::vector< Output > *initial_vals=NULL)
virtual Output	operator() (const Point &p, const Real time=0)
virtual void	operator() (const Point &p, const Real time, DenseVector< Output > &output)
virtual Output	component (unsigned int i, const Point &p, Real time)
virtual Output &	getVarAddress (const std::string &variable_name)
virtual AutoPtr< FunctionBase < Output > >	clone () const
	ParsedFunction (std::string)
virtual Output	operator() (const Point &, const Real=0)
virtual void	operator() (const Point &, const Real, DenseVector< Output > &)
virtual void	init ()
virtual void	clear ()
virtual Output &	getVarAddress (const std::string &)
virtual AutoPtr< FunctionBase < Output > >	clone () const
void	operator() (const Point &p, DenseVector< Output > &output)
bool	initialized () const
Protected Attributes
const FunctionBase *	_master
bool	_initialized
Private Attributes
std::string	_expression
std::vector < FunctionParserBase< Output > >	parsers
std::vector< Output >	_spacetime
std::vector< std::string >	_additional_vars
std::vector< Output >	_initial_vals
Output	_dummy

---

Detailed Description

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

Definition at line 43 of file parsed_function.h.

---

Constructor & Destructor Documentation

template<typename Output = Number>

libMesh::ParsedFunction< Output >::ParsedFunction	(	const std::string &	expression,
		const std::vector< std::string > *	additional_vars = NULL,
		const std::vector< Output > *	initial_vals = NULL
	)			[inline, explicit]

Definition at line 47 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_additional_vars, libMesh::ParsedFunction< Output >::_initial_vals, libMesh::FunctionBase< Output >::_initialized, libMesh::ParsedFunction< Output >::_spacetime, end, libMesh::ParsedFunction< Output >::parsers, and libMesh::Real.

Referenced by libMesh::ParsedFunction< Output >::clone().

    : _expression(expression)
      // Size the spacetime vector to account for space, time, and any additional
      // variables passed
      //_spacetime(LIBMESH_DIM+1 + (additional_vars ? additional_vars->size() : 0)),
    {
      std::string variables = "x";
#if LIBMESH_DIM > 1
      variables += ",y";
#endif
#if LIBMESH_DIM > 2
      variables += ",z";
#endif
      variables += ",t";

      _spacetime.resize(LIBMESH_DIM+1 + (additional_vars ? additional_vars->size() : 0));

      // 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
      if (additional_vars)
      {
        if (initial_vals)
          std::copy(initial_vals->begin(), initial_vals->end(), std::back_inserter(_initial_vals));

        std::copy(additional_vars->begin(), additional_vars->end(), std::back_inserter(_additional_vars));

        for (unsigned int i=0; i < additional_vars->size(); ++i)
        {
          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[LIBMESH_DIM+1 + i] = (initial_vals && i < initial_vals->size()) ? (*initial_vals)[i] : 0;
        }
      }

      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.
        std::string subexpression =
          expression.substr(nextstart, (end == std::string::npos) ?
                                        std::string::npos : end - nextstart);

        // fparser can crash on empty expressions
        libmesh_assert(!subexpression.empty());

        // Parse (and optimize if possible) the subexpression.
        // Add some basic constants, to Real precision.
        FunctionParserBase<Output> fp;
        fp.AddConstant("pi", std::acos(Real(-1)));
        fp.AddConstant("e", std::exp(Real(1)));
        fp.Parse(subexpression, variables);
        fp.Optimize();
        parsers.push_back(fp);

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

      this->_initialized = true;
    }

template<typename Output = Number>

libMesh::ParsedFunction< Output >::ParsedFunction

(

std::string

)

[inline]

Definition at line 243 of file parsed_function.h.

                                              : _dummy(0)
    {
      libmesh_not_implemented();
    }

---

Member Function Documentation

template<typename Output = Number>

virtual void libMesh::ParsedFunction< Output >::clear

(

)

[inline, virtual]

Clears the function.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 257 of file parsed_function.h.

{}

template<typename Output = Number>

virtual AutoPtr<FunctionBase<Output> > libMesh::ParsedFunction< Output >::clone

(

)

const [inline, virtual]

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::FunctionBase< Output >.

Definition at line 259 of file parsed_function.h.

                                                       {
    return AutoPtr<FunctionBase<Output> >
      (new ParsedFunction<Output>(""));
  }

template<typename Output = Number>

virtual AutoPtr<FunctionBase<Output> > libMesh::ParsedFunction< Output >::clone

(

)

const [inline, virtual]

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::FunctionBase< Output >.

Definition at line 214 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_additional_vars, libMesh::ParsedFunction< Output >::_expression, libMesh::ParsedFunction< Output >::_initial_vals, and libMesh::ParsedFunction< Output >::ParsedFunction().

                                                       {
    return AutoPtr<FunctionBase<Output> >
      (new ParsedFunction(_expression, &_additional_vars, &_initial_vals));
  }

template<typename Output = Number>

virtual Output libMesh::ParsedFunction< Output >::component	(	unsigned int	i,
		const Point &	p,
		Real	time
	)			[inline, virtual]

Returns:

the vector component i at coordinate p and time time.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 175 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_spacetime, and libMesh::ParsedFunction< Output >::parsers.

    {
      _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;

      libmesh_assert_less (i, parsers.size());

      // The remaining locations in _spacetime are currently fixed at construction
      // but could potentially be made dynamic
      return parsers[i].Eval(&_spacetime[0]);
    }

template<typename Output = Number>

virtual Output& libMesh::ParsedFunction< Output >::getVarAddress

(

const std::string &

)

[inline, virtual]

Definition at line 258 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_dummy.

{ return _dummy; }

template<typename Output = Number>

virtual Output& libMesh::ParsedFunction< Output >::getVarAddress

(

const std::string &

variable_name

)

[inline, virtual]

Returns:

the address of a parsed variable so you can supply a parameterized value

Definition at line 198 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_additional_vars, and libMesh::ParsedFunction< Output >::_spacetime.

    {
      const std::vector<std::string>::iterator it =
          std::find(_additional_vars.begin(), _additional_vars.end(), variable_name);

      if (it == _additional_vars.end())
      {
        std::cerr << "ERROR: Requested variable not found in parsed function\n" << std::endl;
        libmesh_error();
      }

      // Iterator Arithmetic (How far from the end of the array is our target address?)
      return _spacetime[_spacetime.size() - (_additional_vars.end() - it)];
    }

template<typename Output = Number>

virtual void libMesh::ParsedFunction< Output >::init

(

)

[inline, virtual]

The actual initialization process.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 256 of file parsed_function.h.

{}

template<typename Output >

bool libMesh::FunctionBase< Output >::initialized

(

)

const [inline, inherited]

Returns:

true when this object is properly initialized and ready for use, false otherwise.

Definition at line 194 of file function_base.h.

References libMesh::FunctionBase< Output >::_initialized.

Referenced by libMesh::AnalyticFunction< Output >::operator()().

{
  return (this->_initialized);
}

template<typename Output>

void libMesh::FunctionBase< Output >::operator()	(	const Point &	p,
		DenseVector< Output > &	output
	)			[inline, inherited]

Return function for vectors. Returns in output the values of the data at the coordinate p.

Definition at line 216 of file function_base.h.

References libMesh::FunctionBase< Output >::operator()().

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

template<typename Output = Number>

virtual void libMesh::ParsedFunction< Output >::operator()	(	const Point &	p,
		const	time,
		DenseVector< Output > &	output
	)			[inline, virtual]

Return function for vectors. Returns in output the values of the data at the coordinate p and for time time. Purely virtual, so you have to overload it. Note that this cannot be a const method, check MeshFunction.

Implements libMesh::FunctionBase< Output >.

Definition at line 252 of file parsed_function.h.

                                                              {}

template<typename Output = Number>

virtual Output libMesh::ParsedFunction< Output >::operator()	(	const Point &	p,
		const	time = 0
	)			[inline, virtual]

Returns:

the scalar value at coordinate p and time time, which defaults to zero. Purely virtual, so you have to overload it. Note that this cannot be a const method, check MeshFunction.

Implements libMesh::FunctionBase< Output >.

Definition at line 248 of file parsed_function.h.

    { return 0.; }

template<typename Output = Number>

virtual void libMesh::ParsedFunction< Output >::operator()	(	const Point &	p,
		const Real	time,
		DenseVector< Output > &	output
	)			[inline, virtual]

Return function for vectors. Returns in output the values of the data at the coordinate p and for time time. Purely virtual, so you have to overload it. Note that this cannot be a const method, check MeshFunction.

Implements libMesh::FunctionBase< Output >.

Definition at line 148 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_spacetime, libMesh::ParsedFunction< Output >::parsers, and libMesh::DenseVector< T >::size().

    {
      _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 size = output.size();

      libmesh_assert_equal_to (size, parsers.size());

      // The remaining locations in _spacetime are currently fixed at construction
      // but could potentially be made dynamic
      for (unsigned int i=0; i != size; ++i)
        output(i) = parsers[i].Eval(&_spacetime[0]);
    }

template<typename Output = Number>

virtual Output libMesh::ParsedFunction< Output >::operator()	(	const Point &	p,
		const Real	time = 0
	)			[inline, virtual]

Returns:

the scalar value at coordinate p and time time, which defaults to zero. Purely virtual, so you have to overload it. Note that this cannot be a const method, check MeshFunction.

Implements libMesh::FunctionBase< Output >.

Definition at line 131 of file parsed_function.h.

References libMesh::ParsedFunction< Output >::_spacetime, and libMesh::ParsedFunction< Output >::parsers.

    {
      _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;

      // The remaining locations in _spacetime are currently fixed at construction
      // but could potentially be made dynamic
      return parsers[0].Eval(&_spacetime[0]);
    }

---

Member Data Documentation

template<typename Output = Number>

std::vector<std::string> libMesh::ParsedFunction< Output >::_additional_vars [private]

Definition at line 225 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::clone(), libMesh::ParsedFunction< Output >::getVarAddress(), and libMesh::ParsedFunction< Output >::ParsedFunction().

template<typename Output = Number>

Output libMesh::ParsedFunction< Output >::_dummy [private]

Definition at line 264 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::getVarAddress().

template<typename Output = Number>

std::string libMesh::ParsedFunction< Output >::_expression [private]

Definition at line 220 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::clone().

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFunction< Output >::_initial_vals [private]

Definition at line 226 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::clone(), and libMesh::ParsedFunction< Output >::ParsedFunction().

template<typename Output = Number>

bool libMesh::FunctionBase< Output >::_initialized [protected, inherited]

When init() was called so that everything is ready for calls to operator() (...), then this bool is true.

Definition at line 166 of file function_base.h.

Referenced by libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::AnalyticFunction< Output >::clear(), libMesh::ConstFunction< Output >::ConstFunction(), libMesh::AnalyticFunction< Output >::init(), libMesh::FunctionBase< Output >::initialized(), libMesh::ParsedFunction< Output >::ParsedFunction(), and libMesh::WrappedFunction< Output >::WrappedFunction().

template<typename Output = Number>

const FunctionBase* libMesh::FunctionBase< Output >::_master [protected, inherited]

Const pointer to our master, initialized to NULL. There may be cases where multiple functions are required, but to save memory, one master handles some centralized data.

Definition at line 160 of file function_base.h.

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFunction< Output >::_spacetime [private]

Definition at line 222 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::component(), libMesh::ParsedFunction< Output >::getVarAddress(), libMesh::ParsedFunction< Output >::operator()(), and libMesh::ParsedFunction< Output >::ParsedFunction().

template<typename Output = Number>

std::vector<FunctionParserBase<Output> > libMesh::ParsedFunction< Output >::parsers [private]

Definition at line 221 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< Output >::component(), libMesh::ParsedFunction< Output >::operator()(), and libMesh::ParsedFunction< Output >::ParsedFunction().

---

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

• parsed_function.h