Geometric input params

src/pybamm/__init__.py

@@ -138,6 +138,7 @@
     Chebyshev1DSubMesh,
     UserSupplied1DSubMesh,
     SpectralVolume1DSubMesh,
+    SymbolicUniform1DSubMesh,
 )
 from .meshes.scikit_fem_submeshes import (
     ScikitSubMesh2D,

src/pybamm/meshes/meshes.py

@@ -95,6 +95,8 @@
                         if isinstance(sym, pybamm.Symbol):
                             try:
                                 sym_eval = sym.evaluate()
+                            except KeyError:
+                                sym_eval = sym
                             except NotImplementedError as error:
                                 if sym.has_symbol_of_classes(pybamm.Parameter):
                                     raise pybamm.DiscretisationError(
@@ -169,7 +171,12 @@
         # Check that the final edge of each submesh is the same as the first edge of the
         # next submesh
         for i in range(len(submeshnames) - 1):
-            if self[submeshnames[i]].edges[-1] != self[submeshnames[i + 1]].edges[0]:
+            if self[submeshnames[i]].edges[-1] == self[submeshnames[i + 1]].edges[0]:
+                pass
+            elif hasattr(self[submeshnames[i + 1]], "min"):
+                # Circle back to this, but this should let the case of submesh i+1 be a symbolic submesh
+                pass
+            else:
                 raise pybamm.DomainError("submesh edges are not aligned")
 
             coord_sys = self[submeshnames[i]].coord_sys
@@ -184,10 +191,26 @@
         )
         coord_sys = self[submeshnames[0]].coord_sys
         submesh = pybamm.SubMesh1D(combined_submesh_edges, coord_sys)
+        if getattr(self[submeshnames[0]], "length", None) is not None:
+            # Assume that the ghost cells have the same length as the first submesh
+            if any("ghost" in submeshname for submeshname in submeshnames):
+                submesh_min = self[submeshnames[0]].min
+                submesh_length = self[submeshnames[0]].length
+            # If not ghost cells, then the length is the sum of the lengths of the submeshes
+            else:
+                submesh_min = self[submeshnames[0]].min
+                submesh_length = sum(
+                    [self[submeshname].length for submeshname in submeshnames]
+                )
+            submesh.length = submesh_length
+            submesh.min = submesh_min
         # add in internal boundaries
-        submesh.internal_boundaries = [
-            self[submeshname].edges[0] for submeshname in submeshnames[1:]
-        ]
+        for submeshname in submeshnames[1:]:
+            if getattr(self[submeshname], "length", None) is not None:
+                min = self[submeshname].min
+            else:
+                min = 0
+            submesh.internal_boundaries.append(self[submeshname].edges[0] + min)
         return submesh
 
     def add_ghost_meshes(self):
@@ -210,16 +233,20 @@
 
             # left ghost cell: two edges, one node, to the left of existing submesh
             lgs_edges = np.array([2 * edges[0] - edges[1], edges[0]])
-            self[domain[0] + "_left ghost cell"] = pybamm.SubMesh1D(
-                lgs_edges, submesh.coord_sys
-            )
+            lgs_submesh = pybamm.SubMesh1D(lgs_edges, submesh.coord_sys)
+            if getattr(submesh, "length", None) is not None:
+                lgs_submesh.length = submesh.length
+                lgs_submesh.min = submesh.min
+            self[domain[0] + "_left ghost cell"] = lgs_submesh
 
             # right ghost cell: two edges, one node, to the right of
             # existing submesh
             rgs_edges = np.array([edges[-1], 2 * edges[-1] - edges[-2]])
-            self[domain[0] + "_right ghost cell"] = pybamm.SubMesh1D(
-                rgs_edges, submesh.coord_sys
-            )
+            rgs_submesh = pybamm.SubMesh1D(rgs_edges, submesh.coord_sys)
+            if getattr(submesh, "length", None) is not None:
+                rgs_submesh.length = submesh.length
+                rgs_submesh.min = submesh.min
+            self[domain[0] + "_right ghost cell"] = rgs_submesh
 
     @property
     def geometry(self):

src/pybamm/meshes/one_dimensional_submeshes.py

@@ -85,6 +85,30 @@ def to_json(self):
         return json_dict
 
 
+class SymbolicUniform1DSubMesh(SubMesh1D):
+    def __init__(self, lims, npts, tabs=None):
+        spatial_var, spatial_lims, tabs = self.read_lims(lims)
+        coord_sys = spatial_var.coord_sys
+        x0 = spatial_lims["min"]
+        if tabs is not None:
+            raise NotImplementedError("Tabs not supported for symbolic uniform submesh")
+        if coord_sys != "cartesian" and spatial_lims["min"] != 0:
+            raise pybamm.GeometryError(
+                "Symbolic uniform submesh with non-cartesian coordinates and non-zero minimum not supported"
+            )
+        npts = npts[spatial_var.name]
+        length = spatial_lims["max"] - x0
+        self.edges = np.linspace(0, 1, npts + 1)
+        self.length = length
+        self.min = x0
+        self.nodes = (self.edges[1:] + self.edges[:-1]) / 2
+        self.d_edges = np.diff(self.edges)
+        self.d_nodes = np.diff(self.nodes)
+        self.npts = self.nodes.size
+        self.coord_sys = coord_sys
+        self.internal_boundaries = []
+
+
 class Uniform1DSubMesh(SubMesh1D):
     """
     A class to generate a uniform submesh on a 1D domain

src/pybamm/parameters/parameter_values.py

@@ -604,10 +604,12 @@ def process_geometry(self, geometry):
 
         def process_and_check(sym):
             new_sym = self.process_symbol(sym)
-            if not isinstance(new_sym, pybamm.Scalar):
-                raise ValueError(
-                    "Geometry parameters must be Scalars after parameter processing"
-                )
+            # if not isinstance(new_sym, pybamm.Scalar) and not isinstance(
+            #    new_sym, pybamm.InputParameter
+            # ):
+            #    raise ValueError(
+            #        "Geometry parameters must be Scalars or InputParameters after parameter processing"
+            #    )
             return new_sym
 
         for domain in geometry: