Parameter from external library

[MagunRa]

Hi,
I want to use reaktoro to calculate some parameters.
e.g. I have my parameter defined as:

ocp = FunctionParameter('OCP',inputs)

in my parameter values I have some like this:

parametervalues['ocp']= _ocp_fn

def _ocp_fn(c,T): return _external_fn(c,T)
_external_fn accepts two floats and returns a float.

This does not work since c,T, are not float but some pybamm symbols, if I try .evalaute() or float the functions works if the input are scalars but not if they are broadcasts. If I wrap _external_fn with np.frompyfunc I get AttributeError: module 'pybamm' has no attribute ....
I am kind of lost how to calculate parameters from an external software.

[TomTranter]

Can you post a minimal example with the external function please

[MagunRa]

Sure a minimal exmaple would be like this, _fn being an call to the external lib.

import pybamm

def _fn(x):
    return float(x) + 1

parameter_values = pybamm.ParameterValues("Sulzer2019")
parameter_values["Negative electrode open-circuit potential [V]"] = lambda x: _fn(
    x.evaluate()
)
model_dfn = pybamm.lead_acid.Full()
sim_dfn = pybamm.Simulation(model_dfn, parameter_values=parameter_values)
sim_dfn.solve([0, 3600])

[MagunRa]

After getting a bit more under the hood of PyBamm. Would it be feasible to inherit from pybamm.Function?

[TomTranter]

I'm not sure this is possible. @valentinsulzer ??

[valentinsulzer]

You need to create a symbolic pybamm object that encapsulates your function. You can do this by subclassing SpecificFunction. Here's an example:

PyBaMM/pybamm/expression_tree/functions.py

Lines 467 to 487 in 91bfed4

	class Log(SpecificFunction):
	"""Logarithmic function."""
	def __init__(self, child):
	super().__init__(np.log, child)
	@classmethod
	def _from_json(cls, snippet: dict):
	"""See :meth:`pybamm.SpecificFunction._from_json()`."""
	snippet["function"] = np.log
	instance = super()._from_json(snippet)
	return instance
	def _function_evaluate(self, evaluated_children):
	# don't raise RuntimeWarning for NaNs
	with np.errstate(invalid="ignore"):
	return np.log(*evaluated_children)
	def _function_diff(self, children, idx):
	"""See :meth:`pybamm.Function._function_diff()`."""
	return 1 / children[0]

Then, the function you pass in to the parameter values should return that symbolic object, e.g.

def func(c, T):
    return pybamm.Log(c) * T

Then it should work. However, if you use the casadi solver (which is the default), you also need to be able to define the variable in casadi syntax, which might not be possible depending on what reaktoro does. It should still work with the IDAKLU solver.

A workaround is to pre-compute the values then use a look-up table (pybamm.Interpolant) which works with casadi

[MagunRa]

Thank you for your reply. Some parts I can pre-compute as an Interpolant, that is probably better for performance.

For the rest I will try the SpecificFunction approach. These other parameters would be changing slowly, one could assume them to be constant per time step. I there a structure where I can define parameter for each volume element of the discretization based on the state in the element? And than update these values after each solver.step(...)?