Symbol

class pybamm.Symbol(name, children=None, domain=None, auxiliary_domains=None)

Base node class for the expression tree

Parameters:

• name (str) – name for the node
• children (iterable Symbol, optional) – children to attach to this node, default to an empty list
• domain (iterable of str, or str) – list of domains over which the node is valid (empty list indicates the symbol is valid over all domains)
• auxiliary_domains (dict of str) – dictionary of auxiliary domains over which the node is valid (empty dictionary indicates no auxiliary domains). Keys can be “secondary” or “tertiary”. The symbol is broadcast over its auxiliary domains. For example, a symbol might have domain “negative particle”, secondary domain “separator” and tertiary domain “current collector” (domain=”negative particle”, auxiliary_domains={“secondary”: “separator”, “tertiary”: “current collector”}).

__abs__()

return an AbsoluteValue object

__add__(other)

return an Addition object

__ge__(other)

return a EqualHeaviside object

__getitem__(key)

return a Index object

__gt__(other)

return a NotEqualHeaviside object

__init__(name, children=None, domain=None, auxiliary_domains=None)

Initialize self. See help(type(self)) for accurate signature.

__le__(other)

return a EqualHeaviside object

__lt__(other)

return a NotEqualHeaviside object

__matmul__(other)

return a MatrixMultiplication object

__mul__(other)

return a Multiplication object

__neg__()

return a Negate object

__pow__(other)

return a Power object

__radd__(other)

return an Addition object

__repr__()

returns the string __class__(id, name, children, domain)

__rmatmul__(other)

return a MatrixMultiplication object

__rmul__(other)

return a Multiplication object

__rpow__(other)

return a Power object

__rsub__(other)

return a Subtraction object

__rtruediv__(other)

return a Division object

__str__()

return a string representation of the node and its children

__sub__(other)

return a Subtraction object

__truediv__(other)

return a Division object

children

returns the cached children of this node.

Note: it is assumed that children of a node are not modified after initial creation

clear_domains()

Clear domains, bypassing checks

copy_domains(symbol)

Copy the domains from a given symbol, bypassing checks

diff(variable)

Differentiate a symbol with respect to a variable. For any symbol that can be differentiated, return 1 if differentiating with respect to yourself, self._diff(variable) if variable is in the expression tree of the symbol, and zero otherwise.

Parameters:variable (pybamm.Symbol) – The variable with respect to which to differentiate

domain

list of applicable domains

Returns: Return type:iterable of str

evaluate(t=None, y=None, y_dot=None, inputs=None, known_evals=None)

Evaluate expression tree (wrapper to allow using dict of known values). If the dict ‘known_evals’ is provided, the dict is searched for self.id; if self.id is in the keys, return that value; otherwise, evaluate using _base_evaluate() and add that value to known_evals

Parameters:

• t (float or numeric type, optional) – time at which to evaluate (default None)
• y (numpy.array, optional) – array with state values to evaluate when solving (default None)
• y_dot (numpy.array, optional) – array with time derivatives of state values to evaluate when solving (default None)
• inputs (dict, optional) – dictionary of inputs to use when solving (default None)
• known_evals (dict, optional) – dictionary containing known values (default None)

Returns:

• number or array – the node evaluated at (t,y)
• known_evals (if known_evals input is not None) (dict) – the dictionary of known values

evaluate_for_shape()

Evaluate expression tree to find its shape. For symbols that cannot be evaluated directly (e.g. Variable or Parameter), a vector of the appropriate shape is returned instead, using the symbol’s domain. See pybamm.Symbol.evaluate()

evaluate_ignoring_errors(t=0)

Evaluates the expression. If a node exists in the tree that cannot be evaluated as a scalar or vector (e.g. Time, Parameter, Variable, StateVector), then None is returned. If there is an InputParameter in the tree then a 1 is returned. Otherwise the result of the evaluation is given.

See also

evaluate()

evaluate the expression

evaluates_on_edges()

Returns True if a symbol evaluates on an edge, i.e. symbol contains a gradient operator, but not a divergence operator, and is not an IndefiniteIntegral.

evaluates_to_number()

Returns True if evaluating the expression returns a number. Returns False otherwise, including if NotImplementedError or TyperError is raised. !Not to be confused with isinstance(self, pybamm.Scalar)!

See also

evaluate()

evaluate the expression

get_children_auxiliary_domains(children)

Combine auxiliary domains from children, at all levels

has_symbol_of_classes(symbol_classes)

Returns True if equation has a term of the class(es) symbol_class.

Parameters:symbol_classes (pybamm class or iterable of classes) – The classes to test the symbol against

is_constant()

returns true if evaluating the expression is not dependent on t or y or u

See also

evaluate()

evaluate the expression

jac(variable, known_jacs=None, clear_domain=True)

Differentiate a symbol with respect to a (slice of) a State Vector. See pybamm.Jacobian.

name

name of the node

new_copy()

Make a new copy of a symbol, to avoid Tree corruption errors while bypassing copy.deepcopy(), which is slow.

orphans

Returning new copies of the children, with parents removed to avoid corrupting the expression tree internal data

pre_order()

returns an iterable that steps through the tree in pre-order fashion

Examples

>>> import pybamm
>>> a = pybamm.Symbol('a')
>>> b = pybamm.Symbol('b')
>>> for node in (a*b).pre_order():
...     print(node.name)
*
a
b

relabel_tree(symbol, counter)

Finds all children of a symbol and assigns them a new id so that they can be visualised properly using the graphviz output

render()

print out a visual representation of the tree (this node and its children)

secondary_domain

Helper function to get the secondary domain of a symbol

set_id()

Set the immutable “identity” of a variable (e.g. for identifying y_slices).

This is identical to what we’d put in a __hash__ function However, implementing __hash__ requires also implementing __eq__, which would then mess with loop-checking in the anytree module.

Hashing can be slow, so we set the id when we create the node, and hence only need to hash once.

shape

Shape of an object, found by evaluating it with appropriate t and y.

shape_for_testing

Shape of an object for cases where it cannot be evaluated directly. If a symbol cannot be evaluated directly (e.g. it is a Variable or Parameter), it is instead given an arbitrary domain-dependent shape.

simplify(simplified_symbols=None)

Simplify the expression tree. See pybamm.Simplification.

size

Size of an object, found by evaluating it with appropriate t and y

size_for_testing

Size of an object, based on shape for testing

test_shape()

Check that the discretised self has a pybamm shape, i.e. can be evaluated

Raises:pybamm.ShapeError – If the shape of the object cannot be found

to_casadi(t=None, y=None, y_dot=None, inputs=None, casadi_symbols=None)

Convert the expression tree to a CasADi expression tree. See pybamm.CasadiConverter.

visualise(filename)

Produces a .png file of the tree (this node and its children) with the name filename

Parameters:filename (str) – filename to output, must end in “.png”