#492 added get voltage classes

Author: Scottmar93

pybamm/parameters/standard_voltage_functions/__init__.py

@@ -0,0 +1,21 @@
+#
+# Base class for setting/getting voltage
+#
+
+
+class GetVoltage(object):
+    """
+    The base class for setting the input voltage for a simulation. The parameters
+    dictionary holds the symbols of any parameters required to evaluate the voltage.
+    During processing, the evaluated parameters are stored in parameters_eval.
+    """
+
+    def __init__(self):
+        self.parameters = {}
+        self.parameters_eval = {}
+
+    def __str__(self):
+        return "Base voltage"
+
+    def __call__(self, t):
+        return 1

pybamm/parameters/standard_voltage_functions/base_current.py

@@ -0,0 +1,27 @@
+#
+# Constant voltage "function"
+#
+import pybamm
+
+
+class GetConstantVoltage(pybamm.GetVoltage):
+    """
+    Sets a constant input voltage for a simulation.
+
+    Parameters
+    ----------
+    voltage : :class:`pybamm.Symbol` or float
+        The size of the voltage in Volts.
+
+    **Extends:"": :class:`pybamm.GetVoltage`
+    """
+
+    def __init__(self, voltage=pybamm.electrical_parameters.V_typ):
+        self.parameters = {"Cell voltage [V]": voltage}
+        self.parameters_eval = {"Cell voltage [V]": voltage}
+
+    def __str__(self):
+        return "Constant voltage"
+
+    def __call__(self, t):
+        return self.parameters_eval["Cell voltage [V]"]

pybamm/parameters/standard_voltage_functions/get_constant_current.py

@@ -0,0 +1,87 @@
+#
+# Load voltage profile from a csv file
+#
+import pybamm
+import os
+import pandas as pd
+import numpy as np
+import warnings
+import scipy.interpolate as interp
+
+
+class GetVoltageData(pybamm.GetVoltage):
+    """
+    A class which loads a voltage profile from a csv file and creates an
+    interpolating function which can be called during solve.
+
+    Parameters
+    ----------
+    filename : str
+        The name of the file to load.
+    units : str, optional
+        The units of the voltage data which is to be loaded. Can be "[]" for
+        dimenionless data (default), or "[V]" for voltage in Volts.
+    voltage_scale : :class:`pybamm.Symbol` or float, optional
+        The scale the voltage in Volts if loading non-dimensional data. Default
+        is to use the typical voltage V_typ
+
+    **Extends:"": :class:`pybamm.GetVoltage`
+    """
+
+    def __init__(
+        self, filename, units="[]", voltage_scale=pybamm.electrical_parameters.V_typ
+    ):
+        self.parameters = {"Voltage [V]": voltage_scale}
+        self.parameters_eval = {"Voltage [V]": voltage_scale}
+
+        # Load data from csv
+        if filename:
+            pybamm_path = pybamm.root_dir()
+            data = pd.read_csv(
+                os.path.join(pybamm_path, "input", "drive_cycles", filename),
+                comment="#",
+                skip_blank_lines=True,
+            ).to_dict("list")
+
+            self.time = np.array(data["time [s]"])
+            self.units = units
+            self.voltage = np.array(data["voltage " + units])
+            # If voltage data is present, load it into the class
+        else:
+            raise pybamm.ModelError("No input file provided for voltage")
+
+    def __str__(self):
+        return "Voltage from data"
+
+    def interpolate(self):
+        " Creates the interpolant from the loaded data "
+        # If data is dimenionless, multiply by a typical voltage (e.g. data
+        # could be C-rate and voltage the 1C discharge voltage). Otherwise,
+        # just import the voltage data.
+        if self.units == "[]":
+            voltage = self.parameters_eval["Cell voltage [V]"] * self.voltage
+        elif self.units == "[V]":
+            voltage = self.voltage
+        else:
+            raise pybamm.ModelError(
+                "Voltage data must have units [V] or be dimensionless"
+            )
+        # Interpolate using Piecewise Cubic Hermite Interpolating Polynomial
+        # (does not overshoot non-smooth data)
+        self.voltage_interp = interp.PchipInterpolator(self.time, voltage)
+
+    def __call__(self, t):
+        """
+        Calls the interpolating function created using the data from user-supplied
+        data file at time t (seconds).
+        """
+
+        if np.min(t) < self.time[0] or np.max(t) > self.time[-1]:
+            warnings.warn(
+                "Requested time ({}) is outside of the data range [{}, {}]".format(
+                    t, self.time[0], self.time[-1]
+                ),
+                pybamm.ModelWarning,
+            )
+
+        return self.voltage_interp(t)

pybamm/parameters/standard_voltage_functions/get_current_data.py

@@ -0,0 +1,31 @@
+#
+# Allow a user-defined voltage function
+#
+import pybamm
+
+
+class GetUserVoltage(pybamm.GetVoltage):
+    """
+    Sets a user-defined function as the input voltage for a simulation.
+
+    Parameters
+    ----------
+    function : method
+        The method which returns the voltage (in Volts) as a function of time
+        (in seconds). The first argument of function must be time, followed by
+        any keyword arguments, i.e. function(t, **kwargs).
+    **kwargs : Any keyword arguments required by function.
+
+    **Extends:"": :class:`pybamm.GetVoltage`
+    """
+
+    def __init__(self, function, **kwargs):
+        self.parameters = kwargs
+        self.parameters_eval = kwargs
+        self.function = function
+
+    def __str__(self):
+        return "User defined voltage"
+
+    def __call__(self, t):
+        return self.function(t, **self.parameters_eval)