diff --git a/src/lbmpy/boundaries/boundaries_in_kernel.py b/src/lbmpy/boundaries/boundaries_in_kernel.py
index 6e01987b7253e29c97e1679340f313497121d421..ed1a2c9c1326ff874d271093af97f9efbc9c530a 100644
--- a/src/lbmpy/boundaries/boundaries_in_kernel.py
+++ b/src/lbmpy/boundaries/boundaries_in_kernel.py
@@ -67,7 +67,7 @@ def boundary_conditional(boundary, direction, streaming_pattern, prev_timestep,
 
     assignments = []
     for direction_idx in dir_indices:
-        rule = boundary(f_out, f_in, direction_idx, inv_dir, lb_method, index_field=None)
+        rule = boundary(f_out, f_in, direction_idx, inv_dir, lb_method, index_field=None, force_vector=None)
 
         #   rhs: replace f_out by post collision symbols.
         rhs_substitutions = {f_out(i): sym for i, sym in enumerate(lb_method.post_collision_pdf_symbols)}
diff --git a/src/lbmpy/boundaries/boundaryconditions.py b/src/lbmpy/boundaries/boundaryconditions.py
index 3d52af041943363840a6d05954559bbb49178456..d1c67eb20f9f360d4fbaed5b2200b20a4756cf81 100644
--- a/src/lbmpy/boundaries/boundaryconditions.py
+++ b/src/lbmpy/boundaries/boundaryconditions.py
@@ -28,10 +28,11 @@ class LbBoundary(abc.ABC):
     inner_or_boundary = True
     single_link = False
 
-    def __init__(self, name=None):
+    def __init__(self, name=None, calculate_force_on_boundary=False):
         self._name = name
+        self.calculate_force_on_boundary = calculate_force_on_boundary
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         """
         This function defines the boundary behavior and must therefore be implemented by all boundaries.
         The boundary is defined through a list of sympy equations from which a boundary kernel is generated.
@@ -48,6 +49,8 @@ class LbBoundary(abc.ABC):
         lb_method:      an instance of the LB method used. Use this to adapt the boundary to the method
                         (e.g. compressibility)
         index_field:    the boundary index field that can be used to retrieve and update boundary data
+        force_vector:   vector to store the force on the boundary. Has the same size as the index field and
+                        D-entries per cell
 
         Returns:
             list of pystencils assignments, or pystencils.AssignmentCollection
@@ -109,14 +112,31 @@ class NoSlip(LbBoundary):
 
     Args:
         name: optional name of the boundary.
+        calculate_force_on_boundary: stores the force for each PDF at the boundary in a force vector
     """
 
-    def __init__(self, name=None):
+    def __init__(self, name=None, calculate_force_on_boundary=False):
         """Set an optional name here, to mark boundaries, for example for force evaluations"""
-        super(NoSlip, self).__init__(name)
+        super(NoSlip, self).__init__(name, calculate_force_on_boundary)
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
-        return Assignment(f_in(inv_dir[dir_symbol]), f_out(dir_symbol))
+    def get_additional_code_nodes(self, lb_method):
+        if self.calculate_force_on_boundary:
+            return [NeighbourOffsetArrays(lb_method.stencil)]
+        else:
+            return []
+
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
+        if self.calculate_force_on_boundary:
+            force = sp.Symbol("f")
+            subexpressions = [Assignment(force, sp.Float(2.0) * f_out(dir_symbol))]
+            offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
+            for i in range(lb_method.stencil.D):
+                subexpressions.append(Assignment(force_vector[0](f'F_{i}'), force * offset[i]))
+        else:
+            subexpressions = []
+
+        boundary_assignments = [Assignment(f_in(inv_dir[dir_symbol]), f_out(dir_symbol))]
+        return AssignmentCollection(boundary_assignments, subexpressions=subexpressions)
 
 
 class NoSlipLinearBouzidi(LbBoundary):
@@ -135,11 +155,10 @@ class NoSlipLinearBouzidi(LbBoundary):
         data_type: data type of the wall distance q
     """
 
-    def __init__(self, name=None, init_wall_distance=None, data_type='double'):
+    def __init__(self, name=None, init_wall_distance=None, data_type='double', calculate_force_on_boundary=False):
         self.data_type = data_type
         self.init_wall_distance = init_wall_distance
-
-        super(NoSlipLinearBouzidi, self).__init__(name)
+        super(NoSlipLinearBouzidi, self).__init__(name, calculate_force_on_boundary)
 
     @property
     def additional_data(self):
@@ -147,6 +166,12 @@ class NoSlipLinearBouzidi(LbBoundary):
         direction is needed. This information is stored in the index vector."""
         return [('q', create_type(self.data_type))]
 
+    def get_additional_code_nodes(self, lb_method):
+        if self.calculate_force_on_boundary:
+            return [NeighbourOffsetArrays(lb_method.stencil)]
+        else:
+            return []
+
     @property
     def additional_data_init_callback(self):
         def default_callback(boundary_data, **_):
@@ -160,7 +185,7 @@ class NoSlipLinearBouzidi(LbBoundary):
                  "(init_wall_distance=None). The boundary condition will fall back to a simple NoSlip BC")
             return default_callback
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         f_xf = sp.Symbol("f_xf")
         f_xf_inv = sp.Symbol("f_xf_inv")
         d_x2f = sp.Symbol("d_x2f")
@@ -182,6 +207,13 @@ class NoSlipLinearBouzidi(LbBoundary):
                            (case_two, sp.And(sp.Gt(q, 0), sp.Lt(q, 0.5))),
                            (case_three, True))
 
+        if self.calculate_force_on_boundary:
+            force = sp.Symbol("f")
+            subexpressions.append(Assignment(force, f_xf + rhs))
+            offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
+            for i in range(lb_method.stencil.D):
+                subexpressions.append(Assignment(force_vector[0](f'F_{i}'), force * offset[i]))
+
         boundary_assignments = [Assignment(f_in(inv_dir[dir_symbol]), rhs)]
 
         return AssignmentCollection(boundary_assignments, subexpressions=subexpressions)
@@ -201,14 +233,15 @@ class QuadraticBounceBack(LbBoundary):
         data_type: data type of the wall distance q
     """
 
-    def __init__(self, relaxation_rate, name=None, init_wall_distance=None, data_type='double'):
+    def __init__(self, relaxation_rate, name=None, init_wall_distance=None, data_type='double',
+                 calculate_force_on_boundary=False):
         self.relaxation_rate = relaxation_rate
         self.data_type = data_type
         self.init_wall_distance = init_wall_distance
         self.equilibrium_values_name = "f_eq"
         self.inv_dir_symbol = TypedSymbol("inv_dir", create_type("int32"))
 
-        super(QuadraticBounceBack, self).__init__(name)
+        super(QuadraticBounceBack, self).__init__(name, calculate_force_on_boundary)
 
     @property
     def additional_data(self):
@@ -258,7 +291,7 @@ class QuadraticBounceBack(LbBoundary):
 
         return result
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         omega = self.relaxation_rate
         inv = sp.IndexedBase(self.inv_dir_symbol, shape=(1,))[dir_symbol]
         weight_info = LbmWeightInfo(lb_method, data_type=self.data_type)
@@ -311,6 +344,13 @@ class QuadraticBounceBack(LbBoundary):
         t2 = (q * (f_xf + f_xf_inv)) / (one + q)
         result = (one - q) / (one + q) * t1 * half + t2
 
+        if self.calculate_force_on_boundary:
+            force = sp.Symbol("f")
+            subexpressions.append(Assignment(force, f_xf + result))
+            offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
+            for i in range(lb_method.stencil.D):
+                subexpressions.append(Assignment(force_vector[0](f'F_{i}'), force * offset[i]))
+
         boundary_assignments = [Assignment(f_in(inv_dir[dir_symbol]), result)]
         return AssignmentCollection(boundary_assignments, subexpressions=subexpressions)
 
@@ -355,7 +395,7 @@ class FreeSlip(LbBoundary):
         if name is None and normal_direction:
             name = f"Free Slip : {offset_to_direction_string([-x for x in normal_direction])}"
 
-        super(FreeSlip, self).__init__(name)
+        super(FreeSlip, self).__init__(name, calculate_force_on_boundary=False)
 
     def init_callback(self, boundary_data, **_):
         if len(boundary_data.index_array) > 1e6:
@@ -425,7 +465,7 @@ class FreeSlip(LbBoundary):
         else:
             return [NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         neighbor_offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
         if self.normal_direction:
             tangential_offset = tuple(offset + normal for offset, normal in zip(neighbor_offset, self.normal_direction))
@@ -559,13 +599,13 @@ class WallFunctionBounce(LbBoundary):
         if name is None:
             name = f"WFB : {offset_to_direction_string([-x for x in normal_direction])}"
 
-        super(WallFunctionBounce, self).__init__(name)
+        super(WallFunctionBounce, self).__init__(name, calculate_force_on_boundary=False)
 
     def get_additional_code_nodes(self, lb_method):
         return [MirroredStencilDirections(self.stencil, self.mirror_axis),
                 NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         # needed symbols for offsets and indices
         # neighbour offset symbols are basically the stencil directions defined in stencils.py:L130ff.
         neighbor_offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
@@ -715,7 +755,7 @@ class UBB(LbBoundary):
         self.dim = dim
         self.data_type = data_type
 
-        super(UBB, self).__init__(name)
+        super(UBB, self).__init__(name, calculate_force_on_boundary=False)
 
     @property
     def additional_data(self):
@@ -751,7 +791,7 @@ class UBB(LbBoundary):
         This is useful if the inflow velocity should have a certain profile for instance"""
         return callable(self._velocity)
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         vel_from_idx_field = callable(self._velocity)
         vel = [index_field(f'vel_{i}') for i in range(self.dim)] if vel_from_idx_field else self._velocity
 
@@ -827,7 +867,7 @@ class SimpleExtrapolationOutflow(LbBoundary):
         self.normal_direction = tuple([int(n) for n in normal_direction])
         assert all([n in [-1, 0, 1] for n in self.normal_direction]), \
             "Only -1, 0 and 1 allowed for defining the normal direction"
-        super(SimpleExtrapolationOutflow, self).__init__(name)
+        super(SimpleExtrapolationOutflow, self).__init__(name, calculate_force_on_boundary=False)
 
     def get_additional_code_nodes(self, lb_method):
         """Return a list of code nodes that will be added in the generated code before the index field loop.
@@ -841,7 +881,7 @@ class SimpleExtrapolationOutflow(LbBoundary):
         """
         return [NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         neighbor_offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
         tangential_offset = tuple(offset - normal for offset, normal in zip(neighbor_offset, self.normal_direction))
 
@@ -867,7 +907,7 @@ class ExtrapolationOutflow(LbBoundary):
 
     Args:
         normal_direction: direction vector normal to the outflow
-        lb_method: the lattice boltzman method to be used in the simulation
+        lb_method: the lattice Boltzmann method to be used in the simulation
         dt: lattice time step size
         dx: lattice spacing distance
         name: optional name of the boundary.
@@ -920,7 +960,7 @@ class ExtrapolationOutflow(LbBoundary):
 
             self.equilibrium_calculation = calc_eq_pdfs
 
-        super(ExtrapolationOutflow, self).__init__(name)
+        super(ExtrapolationOutflow, self).__init__(name, calculate_force_on_boundary=False)
 
     def init_callback(self, boundary_data, **_):
         dim = boundary_data.dim
@@ -973,7 +1013,7 @@ class ExtrapolationOutflow(LbBoundary):
         """
         return [NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         subexpressions = []
         boundary_assignments = []
         dtdx = sp.Rational(self.dt, self.dx)
@@ -1019,9 +1059,9 @@ class FixedDensity(LbBoundary):
             name = "Fixed Density " + str(density)
         self.density = density
 
-        super(FixedDensity, self).__init__(name)
+        super(FixedDensity, self).__init__(name, calculate_force_on_boundary=False)
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         def remove_asymmetric_part_of_main_assignments(assignment_collection, degrees_of_freedom):
             new_main_assignments = [Assignment(a.lhs, get_symmetric_part(a.rhs, degrees_of_freedom))
                                     for a in assignment_collection.main_assignments]
@@ -1083,7 +1123,7 @@ class DiffusionDirichlet(LbBoundary):
         self.concentration_is_callable = callable(self.concentration)
         self.velocity_field = velocity_field
 
-        super(DiffusionDirichlet, self).__init__(name)
+        super(DiffusionDirichlet, self).__init__(name, calculate_force_on_boundary=False)
 
     @property
     def additional_data(self):
@@ -1116,7 +1156,7 @@ class DiffusionDirichlet(LbBoundary):
         else:
             return [LbmWeightInfo(lb_method, self._data_type)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         assert lb_method.conserved_quantity_computation.zero_centered_pdfs is False, \
             "DiffusionDirichlet only works for methods with normal pdfs storage -> set zero_centered=False"
         weight_info = LbmWeightInfo(lb_method, self._data_type)
@@ -1159,7 +1199,7 @@ class NeumannByCopy(LbBoundary):
         """
         return [NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         neighbour_offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
         return [Assignment(f_in(inv_dir[dir_symbol]), f_out(inv_dir[dir_symbol])),
                 Assignment(f_out[neighbour_offset](dir_symbol), f_out(dir_symbol))]
@@ -1178,7 +1218,7 @@ class StreamInConstant(LbBoundary):
     """
 
     def __init__(self, constant, name=None):
-        super(StreamInConstant, self).__init__(name)
+        super(StreamInConstant, self).__init__(name, calculate_force_on_boundary=False)
         self.constant = constant
 
     def get_additional_code_nodes(self, lb_method):
@@ -1192,7 +1232,7 @@ class StreamInConstant(LbBoundary):
         """
         return [NeighbourOffsetArrays(lb_method.stencil)]
 
-    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
+    def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector):
         neighbour_offset = NeighbourOffsetArrays.neighbour_offset(dir_symbol, lb_method.stencil)
         return [Assignment(f_in(inv_dir[dir_symbol]), self.constant),
                 Assignment(f_out[neighbour_offset](dir_symbol), self.constant)]
diff --git a/src/lbmpy/boundaries/boundaryhandling.py b/src/lbmpy/boundaries/boundaryhandling.py
index ed086d1f501666232a93e3663f350fd4aecc419d..601534ee330d680f67401704d5561816afdb4a31 100644
--- a/src/lbmpy/boundaries/boundaryhandling.py
+++ b/src/lbmpy/boundaries/boundaryhandling.py
@@ -1,8 +1,10 @@
+from dataclasses import replace
 import numpy as np
 
 from pystencils import Assignment, CreateKernelConfig, create_kernel, Field, Target
 from pystencils.boundaries import BoundaryHandling
 from pystencils.boundaries.createindexlist import numpy_data_type_for_boundary_object
+from pystencils.field import FieldType
 from pystencils.simp import add_subexpressions_for_field_reads
 from pystencils.stencil import inverse_direction
 
@@ -156,22 +158,31 @@ class LatticeBoltzmannBoundaryHandling(BoundaryHandling):
 
 def create_lattice_boltzmann_boundary_kernel(pdf_field, index_field, lb_method, boundary_functor,
                                              prev_timestep=Timestep.BOTH, streaming_pattern='pull',
-                                             target=Target.CPU, **kernel_creation_args):
+                                             target=Target.CPU, force_vector=None, **kernel_creation_args):
 
     indexing = BetweenTimestepsIndexing(
         pdf_field, lb_method.stencil, prev_timestep, streaming_pattern, np.int32, np.int32)
 
+    dim = lb_method.stencil.D
     f_out, f_in = indexing.proxy_fields
     dir_symbol = indexing.dir_symbol
     inv_dir = indexing.inverse_dir_symbol
 
-    boundary_assignments = boundary_functor(f_out, f_in, dir_symbol, inv_dir, lb_method, index_field)
-    boundary_assignments = indexing.substitute_proxies(boundary_assignments)
-
-    config = CreateKernelConfig(index_fields=[index_field], target=target, default_number_int="int32",
+    config = CreateKernelConfig(target=target, default_number_int="int32",
                                 skip_independence_check=True, **kernel_creation_args)
 
     default_data_type = config.data_type.default_factory()
+
+    if force_vector is None:
+        force_vector_type = np.dtype([(f"F_{i}", default_data_type.c_name) for i in range(dim)], align=True)
+        force_vector = Field.create_generic('force_vector', spatial_dimensions=1,
+                                            dtype=force_vector_type, field_type=FieldType.INDEXED)
+
+    config = replace(config, index_fields=[index_field, force_vector])
+
+    boundary_assignments = boundary_functor(f_out, f_in, dir_symbol, inv_dir, lb_method, index_field, force_vector)
+    boundary_assignments = indexing.substitute_proxies(boundary_assignments)
+
     if pdf_field.dtype != default_data_type:
         boundary_assignments = add_subexpressions_for_field_reads(boundary_assignments, data_type=default_data_type)
 
diff --git a/tests/test_boundary_handling.py b/tests/test_boundary_handling.py
index e02b4a29cebf86ee5e8fa25ff01419397cf2faf4..25e14e545a82fa3581120ea0b07f6fdc64ab50e4 100644
--- a/tests/test_boundary_handling.py
+++ b/tests/test_boundary_handling.py
@@ -1,14 +1,16 @@
 import numpy as np
 import pytest
 
-from lbmpy.boundaries import NoSlip, UBB, SimpleExtrapolationOutflow, ExtrapolationOutflow, \
-    FixedDensity, DiffusionDirichlet, NeumannByCopy, StreamInConstant, FreeSlip
-from lbmpy.boundaries.boundaryhandling import LatticeBoltzmannBoundaryHandling
+from lbmpy.boundaries import (NoSlip, NoSlipLinearBouzidi, QuadraticBounceBack,
+                              UBB, SimpleExtrapolationOutflow, ExtrapolationOutflow, FixedDensity, DiffusionDirichlet,
+                              NeumannByCopy, StreamInConstant, FreeSlip)
+from lbmpy.boundaries.boundaryhandling import LatticeBoltzmannBoundaryHandling, create_lattice_boltzmann_boundary_kernel
 from lbmpy.creationfunctions import create_lb_function, create_lb_method, LBMConfig
 from lbmpy.enums import Stencil, Method
 from lbmpy.geometry import add_box_boundary
 from lbmpy.lbstep import LatticeBoltzmannStep
 from lbmpy.stencils import LBStencil
+import pystencils as ps
 from pystencils import create_data_handling, make_slice, Target, CreateKernelConfig
 from pystencils.slicing import slice_from_direction
 from pystencils.stencil import inverse_direction
@@ -435,3 +437,45 @@ def test_boundary_utility_functions():
     assert stream == StreamInConstant(constant=1.0, name="stream")
     assert not stream == StreamInConstant(constant=1.0, name="test")
     assert not stream == noslip
+
+
+@pytest.mark.parametrize("given_force_vector", [True, False])
+@pytest.mark.parametrize("dtype", ["float32", "float64"])
+def test_force_on_boundary(given_force_vector, dtype):
+    stencil = LBStencil(Stencil.D2Q9)
+    pdfs = ps.fields(f"pdfs_src({stencil.Q}): {dtype}[{stencil.D}D]", layout='fzyx')
+
+    method = create_lb_method(lbm_config=LBMConfig(stencil=stencil, method=Method.SRT, relaxation_rate=1.8))
+
+    noslip = NoSlip(name="noslip", calculate_force_on_boundary=True)
+    bouzidi = NoSlipLinearBouzidi(name="bouzidi", calculate_force_on_boundary=True)
+    qq_bounce_Back = QuadraticBounceBack(name="qqBB", relaxation_rate=1.8, calculate_force_on_boundary=True)
+
+    boundary_objects = [noslip, bouzidi, qq_bounce_Back]
+    for boundary in boundary_objects:
+        if given_force_vector:
+            force_vector_type = np.dtype([(f"F_{i}", dtype) for i in range(stencil.D)], align=True)
+            force_vector = ps.Field('forceVector', ps.FieldType.INDEXED, force_vector_type, layout=[0],
+                                    shape=(ps.TypedSymbol("forceVectorSize", "int32"), 1), strides=(1, 1))
+        else:
+            force_vector = None
+
+        index_struct_dtype = _numpy_data_type_for_boundary_object(boundary, stencil.D)
+
+        index_field = ps.Field('indexVector', ps.FieldType.INDEXED, index_struct_dtype, layout=[0],
+                               shape=(ps.TypedSymbol("indexVectorSize", "int32"), 1), strides=(1, 1))
+
+        create_lattice_boltzmann_boundary_kernel(pdfs, index_field, method, boundary, force_vector=force_vector)
+
+
+def _numpy_data_type_for_boundary_object(boundary_object, dim):
+    boundary_index_array_coordinate_names = ["x", "y", "z"]
+    direction_member_name = "dir"
+    default_index_array_dtype = np.int32
+
+    coordinate_names = boundary_index_array_coordinate_names[:dim]
+    return np.dtype(
+        [(name, default_index_array_dtype) for name in coordinate_names]
+        + [(direction_member_name, default_index_array_dtype)]
+        + [(i[0], i[1].numpy_dtype) for i in boundary_object.additional_data],
+        align=True,)
diff --git a/tests/test_compiled_in_boundaries.ipynb b/tests/test_compiled_in_boundaries.ipynb
index 69ef39d4258a448eb8b3df734ab22e69b89273dc..939e15bbf4a2755dca73d15a85e2ab906b3e6264 100644
--- a/tests/test_compiled_in_boundaries.ipynb
+++ b/tests/test_compiled_in_boundaries.ipynb
@@ -50,17 +50,7 @@
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n",
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n",
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "boundaries = OrderedDict((\n",
     "    ((0, 1, 0), UBB([lid_velocity, 0, 0])),    \n",
@@ -117,7 +107,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x13b12c820>"
+       "<matplotlib.colorbar.Colorbar at 0x11b578710>"
       ]
      },
      "execution_count": 6,
@@ -126,14 +116,12 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA00AAAFlCAYAAAA3YwNeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAArcUlEQVR4nO3df4wc533f8c9nj6RI/bAphSeFoaRIMQgjqlBTAkELdQs4tpWQalpKBVxIQWXBMUCrEQE7cFswyR+2mwYwDNsK1KoUpJowhThWhdqqCIGJwrA2VAOWTMpVZNKUoKuiWCeyJCVFvy2St/vtHztMNue73e/M7d7u3rxfwOBuZ7/zPM/uzO7dd55nnnFECAAAAAAwt8awGwAAAAAAo4ykCQAAAAC6IGkCAAAAgC5ImgAAAACgC5ImAAAAAOiCpAkAAAAAuli2mJWtWbMmrrjiisWsEhg5h44eT8Utv+BMKu6SFW+k624mz5NMqJWKO8czyfLytzbIRjbsZN25uEEYVs0eQM2R3DP9rjtb7yBka26l35v+O5VsZDNyn/3lzn32JenYmfek4t5+fVUq7upfuiRdN7AUPfnkky9HxOSw21HGb/zaefHKq83K2z/59KlHI2JzH5s0MIuaNF1xxRU6ePDgYlYJjJz3f/HOVNwv/bPpVNxnfvkv03W/2cr983Je41Qq7v3LTyTLy/8j1kz+E3heI/cv6Plenq47YyKZrElSI5mkNvr87/SE+z+IoBm5fdjvurP1SvnkJft+zyj3j8CbrdOpuOUl3ptssj91Jhf3WvKz/0vL3kzFSdJ/OrolFXfgz69OxR38/O+m6waWItt/M+w2lPXyq0098eillbdfvvb/ruljcwZqUZMmAAAAAEtFlDq5Nc5ImgAAAACUFsr38o87JoIAAAAAgC7oaQIAAABQSSs5edS4I2kCAAAAUFoo1Ix6DM8jaQIAAABQCdc0AQAAAADoaQIWW0zkzshMP74uFXfXH92crrs1kbuny7u/kLu30c9+IXfeZebcVJgkqZW8rVI67pzc+x0TufKS9wgtYpN1Z8sc4mmu6POdWZ2/c+wAysy9mEbu3s1y9r6OJU7GLnsn18blb+XKW/52rvJVJW5Seeyf5D408Z56XO8A1FFIatakp4mkCQAAAEAldRme1zNpsr1S0mOSzini/0dEfN72RZL+u6QrJL0g6V9HxN8OrqkAAAAARkVItZkIIjPY45Skj0TEByRtkLTZ9nWSdkjaHxHrJe0vHgMAAACoidYClnHSM2mKtrOjppcXS0jaKml3sX63pBsH0UAAAAAAGKbUZcW2J2w/JemEpH0R8YSkSyLimCQVPy8eWCsBAAAAjJRQqLmAZZykJoKIiKakDbZXS3rI9tXZCmxvk7RNki6//PIqbQQAAAAwakJqjlfuU1mpCWwj4jVJ35O0WdJx22slqfh5Yp5t7o2IjRGxcXJycmGtBQAAADASQlzT9HdsTxY9TLK9StLHJD0jaY+k24qw2yQ9PKA2AgAAABg5VnMByzjJDM9bK2m37Qm1k6wHI+IR2z+Q9KDtT0n6qaSPD7CdAAAAADAUPZOmiHha0jVzrH9F0kcH0ShgKfuVP5lzJOvPOfLvL0rF/fW/WJGue/2fvtU7SNLKF19Pxa1uJTvX38jVK0letTIVF8sm0mWmnJN7H1srBnBP8Inc2bZo9PmsXL/Lk6RWbnC7k3FyiTbO5I7Hxqkz/a07e4+SV17LxUnystxxFu85L1dgIzca/5l/uzpXnqRVa99Ixa372vJcgb+brhrAiAilv/bH3gD++gMAAACog3EbZlcVSRMAAACA0kL1SZpKzZ4HAAAAAHVDTxMAAACASlpRj54mkiYAAAAApdVpeB5JEwAAAIDSQlazJlf7kDQBAAAAqKQuw/PqkRoCAAAAQEX0NAEAAAAojWuaAAAAAKArqxn1GLhG0gQstohU2Jof5D6eZ87Pn+F59eoLUnHn/b9VqbgVr76bivN7z03FSVLj7VO5Mt/J1a3TZ1Jh8dobqbhGsjxJimYzGZg7JpQtr5UsbxAauePRTh63jfwfY69YngtclvtsORmnVStTYbHmwlx5kporcnW/+4u5z9brv5J7b1a8kgqTJPnF96bilr16Ml8ogLESklo1udqHpAkAAABAJXUZnleP1BAAAADA2LG92faztqds75jjedu+q3j+advXFutX2v6h7b+yfdj2Fzu2+YLtl2w/VSw39GoHPU0AAAAASosY7DVNtick3S3peknTkg7Y3hMRP+kI2yJpfbF8UNLO4ucpSR+JiLdsL5f0fdt/FhGPF9vdGRFfybaFniYAAAAAlbTkykvCJklTEfF8RJyW9ICkrbNitkq6P9oel7Ta9tri8VtFzPJiqXzRL0kTAAAAgNLaU443Ki8J6yS92PF4uliXirE9YfspSSck7YuIJzrithfD+XbZ7jlTD0kTAAAAgGFYY/tgx7Jt1vNzdUfN7i2aNyYimhGxQdKlkjbZvrp4fqek90naIOmYpK/2aijXNAEAAACoYMHXNL0cERu7PD8t6bKOx5dKOlo2JiJes/09SZslHYqI42efs32fpEd6NZSeJgAAAAClnb1PU9Ul4YCk9bavtL1C0s2S9syK2SPpE8UsetdJej0ijtmetL1akmyvkvQxSc8Uj9d2bH+TpEO9GkJPEwAAAIBKmjG4+zRFxIzt7ZIelTQhaVdEHLZ9e/H8PZL2SrpB0pSkdyR9sth8raTdxQx8DUkPRsTZHqUv296gdt73gqRP92oLSROwyFrvWZWKu+Cnp1NxMZH/snr7F5en4k5fkOuEXvbWRCrOzfxkNa2LzkvFNVauyMW9cypdd0qrlQ5tnJnJBUblyXzm1upzeZLU6PMfRefKi2W5Y0yS1Ojv4InWueek4prn5j5XpepekXvdP5vM/RlvJf/aX/hM/vhedip3nDUvWJkuE8B4CTk7oUP1OiL2qp0Yda67p+P3kHTHHNs9Lemaecq8tWw7GJ4HAAAAAF3Q0wQAAACgktYAb247SkiaAAAAAJR29j5NdUDSBAAAAKC0kAc6EcQoqUdqCAAAAAAV0dMEAAAAoJLk/ZbGHkkTAAAAgNIipCYTQQAAAADAfKyW6nFNE0kTAAAAgNJC9DQBGJCJE6+n4rx6ZSounD/Dc8H06XRsRnPlRCpu2Tsz6TIb756p2pw5xcrlqTifaSYLjHzdy5Nfscky3UrWndstAxGN5PGYPW5LHN9alnvhsTwZN5Gru3GmlYprnpv/k3vm/FzsOW/kjttz3khXndY4nTseJ159q/+VA8AiI2kCAAAAUAn3aQIAAACAeYSsVk3u00TSBAAAAKASepoAAAAAYB4hqVWTiSDq8SoBAAAAoCJ6mgAAAABUYDW5TxMAAAAAzK1Ow/NImgAAAABUUpeepnqkhgAAAABQET1NwCJrvfq3qbjlb1yYijv93hXpuifemUnFOSIV11qWO+/imVYqTpJ8ppmOTclW3UwGJt+bMtxKlpmt2wM465d+3X2uu8z7nd2H2eO2mas7Wrl6PZN/Lct+lvscZNuYdeb8/L8FK14/kws88UrF1gAYdRFmeB4AAAAAdNOsSdLU81Xavsz2d20fsX3Y9meK9V+w/ZLtp4rlhsE3FwAAAMAoCEktufIyTjI9TTOSPhcRP7J9gaQnbe8rnrszIr4yuOYBAAAAGE2uTU9Tz6QpIo5JOlb8/qbtI5LWDbphAAAAADAKSqWGtq+QdI2kJ4pV220/bXuX7dxV6wAAAADGXvs+Ta68jJN00mT7fEnflvTZiHhD0k5J75O0Qe2eqK/Os9022wdtHzx58uTCWwwAAABgJDTVqLyMk1RrbS9XO2H6ZkR8R5Ii4nhENCOiJek+SZvm2jYi7o2IjRGxcXJysl/tBgAAADBEoeq9TOPW09TzmibblvR1SUci4msd69cW1ztJ0k2SDg2miQAAAABGUWvMeoyqysye9yFJt0r6se2ninW/L+kW2xvUHs74gqRPD6B9AAAAADBUmdnzvq+5b/G+t//NAQAAADAOIqTmmA2zqyrT0wSgj7zynFzca2+n4s45dSZdd+vcFbm6Z1qpuGVvnc5VXKbn3rkvX5+eyZU30yxReUJEOtTN3PuYLjP53qiVrLeM7H7JvuakWDZRIjj3Pvrd5Gdmee5PZKzMxTWy9UpqvJOLbSXrjonc/lt1/GepOElqvPVuLjD5PgIYT+N2bVJVfJMBAAAAKK09EUQ9rmmqx6sEAAAAgIpImgAAAABU0pQrLxm2N9t+1vaU7R1zPG/bdxXPP2372mL9Sts/tP1Xtg/b/mLHNhfZ3mf7ueLnhb3aQdIEAAAAoLSQBnqfJtsTku6WtEXSVWrP3n3VrLAtktYXyzZJO4v1pyR9JCI+IGmDpM22ryue2yFpf0Ssl7S/eNwVSRMAAACACtrXNFVdEjZJmoqI5yPitKQHJG2dFbNV0v3R9rik1cX9ZCMi3ipilhdLdGyzu/h9t6QbezWEpAkAAABAJS258iJpje2DHcu2WcWvk/Rix+PpYl0qxvZEcZ/ZE5L2RcQTRcwlEXFMkoqfF/d6ncyeBwAAAGAYXo6IjV2en2sM3+z7S8wbExFNSRtsr5b0kO2rI+JQlYbS0wQAAACgtLM3t626JExLuqzj8aWSjpaNiYjXJH1P0uZi1XHbayWp+HmiV0NImgAAAABUMuBrmg5IWm/7StsrJN0sac+smD2SPlHMonedpNcj4pjtyaKHSbZXSfqYpGc6trmt+P02SQ/3agjD84DF1prdqzw3nz6TKy9y5Un9P0viZjMXmAwrZSZXqJut/tZb4v1Wa4h199uQ6vZMPjYm+nyEJ4+xxrv9rVaSwrmpeNOvOBnYeOtUtsT0d9QQj1oAA9a+uW3u+6pS+REztrdLelTShKRdEXHY9u3F8/dI2ivpBklTkt6R9Mli87WSdhcz8DUkPRgRjxTPfUnSg7Y/Jemnkj7eqy0kTQAAAAAqaSXvt1RVROxVOzHqXHdPx+8h6Y45tnta0jXzlPmKpI+WaQfD8wAAAACgC3qaAAAAAJR29ua2dUDSBAAAAKCS5IQOY4+kCQAAAEB5MdiJIEZJPVJDAAAAAKiIniYAAAAApYUGP3veqCBpAgAAAFBJXYbnkTQBAAAAKI3Z8wAMTOutt1NxE+euyhW4Ynm67sZb76biopH8ApyYyMU1m7k4SW62koHJNkbk4lrJelvJ8gYh+1qy780w684eYzMljp3sPkwet6Fc3T4zkytvWfLzIsnJWL+Tqzt9fJc5dpL7Jt5+J18mgLFTl6SJiSAAAAAAoAt6mgAAAACUFqrPlOMkTQAAAAAqYfY8AAAAAJhP1OeaJpImAAAAAKXVafY8JoIAAAAAgC7oaQIAAABQSV16mkiaAAAAAJTG7HkAAAAA0EOQNAEYpjh1KhXnRolLExu5LzY3k+XNZANLiOhvea1kef2ut4xh1p2VbWM6bgB/ZFvZwNxx61ayjU5+rsp8XrKx/d4vJcS7ue+oaKZ3DACMLJImAAAAAJVwnyYAAAAAmEdwnyYAAAAA6I5rmgAAAABgXvWZPY+b2wIAAABAF/Q0AQAAAKiE4XkAAAAAMI8QE0EAAAAAwPxiPG412A8kTQAAAAAq4T5NAAajkftyiVOn+161zzknGZj8Amw2c3ETE7m4MnW3Wvkyh6XfbWwk5+7J7pdB1D2s11zGTLKN2WNxIvvelDgdmz11m21jttp3T+WDTyVjk995ADDKSJoAAAAAlBaqz0QQPU+P2b7M9ndtH7F92PZnivUX2d5n+7ni54WDby4AAACA0dC+T1PVZZxkxhTMSPpcRPyqpOsk3WH7Kkk7JO2PiPWS9hePAQAAANRERPVlnPRMmiLiWET8qPj9TUlHJK2TtFXS7iJst6QbB9RGAAAAADVke7PtZ21P2f65Thq33VU8/7Tta4v1c46WK577gu2XbD9VLDf0akepa5psXyHpGklPSLokIo5J7cTK9sVlygIAAAAw3gZ5TZPtCUl3S7pe0rSkA7b3RMRPOsK2SFpfLB+UtLP4eXa03I9sXyDpSdv7Ora9MyK+km1Leloi2+dL+rakz0bEGyW222b7oO2DJ0+ezG4GAAAAYIS1h9m58pKwSdJURDwfEaclPaD2aLdOWyXdH22PS1pte22X0XKVpJIm28vVTpi+GRHfKVYft722eH6tpBNzbRsR90bExojYODk5WbWdAAAAAEbMgCeCWCfpxY7H0/r5xKdnzKzRcmdtL4bz7cpMaJeZPc+Svi7pSER8reOpPZJuK36/TdLDvcoCAAAAsHQscCKINWdHpBXLtlnFz5VZzZ5ComvMPKPldkp6n6QNko5J+mqv15m5pulDkm6V9GPbTxXrfl/SlyQ9aPtTkn4q6eOJsgAAAABAkl6OiI1dnp+WdFnH40slHc3GzDNaThFx/Ozvtu+T9EivhvZMmiLi+5o7g5Okj/baHgAAAMDSNOCb2x6QtN72lZJeknSzpN+aFbNH7aF2D6g9AcTrxSR1842W09lrnoqHN0k61KshpWbPA9AHzWYurtVKlpeMkxSnz+QCG7kvwPb3UUL2NQ/TONwwYpjv47DqLlNv9nhsJOdAyh4TM33+TA9AZOtu5d/vyO6bcfj8A6gklJ7QoVr5ETO2t0t6VNKEpF0Rcdj27cXz90jaK+kGSVOS3pH0yWLzOUfLRcReSV+2vUHtYXwvSPp0r7aQNAEAAACoZNCnHIskZ++sdfd0/B6S7phju3lHy0XErWXbQdIEAAAAoLwY+PC8kZG+TxMAAAAA1BE9TQAAAACqGYNLgvuBpAkAAABAJXUZnkfSBAAAAKCScZh8th+4pgkAAAAAuqCnCQAAAEBpIYbnAQAAAMD8QhJJE4BBiGYzFedknKKVr3xmJhc3kRu5GxMTufIGMODZ7u+XdNRlUPYSlj4iWiU+MxlDPHYi+5nOtrFV4rUky8x+5wEYT3X580nSBAAAAKCamiRNTAQBAAAAAF3Q0wQAAACgAjMRBAAAAAB0VZPheSRNAAAAAMqL+kw5zjVNAAAAANAFPU0AAAAAqmF4HgAAAAB0U4/heSRNAAAAAKqhpwnAMEWzlQvMxknysuRljNnbezebyYpLXD7ZyJ2ximHdgrxVot5I7psy7w/mFdm3cRxuX5/9bGVfS/K4jZmZXHmSIttGAEvbGHyl9gN/qQEAAACgC3qaAAAAAJQXkmoy5ThJEwAAAIBKxmHEcz+QNAEAAACohqQJAAAAALqoyfA8JoIAAAAAgC7oaQIAAABQiRmeBwAAAADzCHFNEwAAAADMz7W5pomkCVhs7vOlhM1mPnYiWXcrGZd+Ka1sYL7ufosSbUyXmTz9Fsl96OQfpkHM/5qte5iGdexklTnG+r0Ps3WX+T5pJdvY7+88ABgCkiYAAAAA1TA8DwAAAAC6IGkCAAAAgC5ImgAAAABgHqHaTATB1ZkAAAAARpLtzbaftT1le8ccz9v2XcXzT9u+tlh/me3v2j5i+7Dtz3Rsc5HtfbafK35e2KsdJE0AAAAAKnFUX3qWbU9IulvSFklXSbrF9lWzwrZIWl8s2yTtLNbPSPpcRPyqpOsk3dGx7Q5J+yNivaT9xeOuSJoAAAAAVBMLWHrbJGkqIp6PiNOSHpC0dVbMVkn3R9vjklbbXhsRxyLiR5IUEW9KOiJpXcc2u4vfd0u6sVdDSJoAAAAADMMa2wc7lm2znl8n6cWOx9P6+8QnHWP7CknXSHqiWHVJRByTpOLnxb0aykQQAAAAACrJDLPr4uWI2Nit+DnWza6xa4zt8yV9W9JnI+KN8k1so6cJAAAAwCialnRZx+NLJR3NxthernbC9M2I+E5HzHHba4uYtZJO9GoIPU3AqGr0fwrPaLZScZ5IFthKnncpc3ommrk49/n9iSHeaKKVrXuYN8NI1j2A4zYvd3wPzSCOsWby85I+xkrI7utkEwGMqcFOOX5A0nrbV0p6SdLNkn5rVsweSdttPyDpg5Jej4hjti3p65KORMTX5tjmNklfKn4+3KshPf+Vsb3L9gnbhzrWfcH2S7afKpYbepUDAAAAYAlZyCQQiXM5ETEjabukR9WeyOHBiDhs+3bbtxdheyU9L2lK0n2SfqdY/yFJt0r6yBw5y5ckXW/7OUnXF4+7yvQ0fUPSf5F0/6z1d0bEVxLbAwAAAFiKBjwIIiL2qp0Yda67p+P3kHTHHNt9X3Nf76SIeEXSR8u0o2dPU0Q8JunVMoUCAAAAwFKxkIkgthd33d2VuYsuAAAAgKVlkDe3HSVVk6adkt4naYOkY5K+Ol+g7W1n514/efJkxeoAAAAAjJzB3tx2ZFRKmiLieEQ0I6Kl9gVXm7rE3hsRGyNi4+TkZNV2AgAAABg1JE3zOzuveeEmSYfmiwUAAACw9CxkaN64Dc/rOXue7W9J+rCkNbanJX1e0odtb1A7R3xB0qcH10QAAAAAGJ6eSVNE3DLH6q8PoC0AAAAAxslgb247MjL3aQJQN61kn3mjlSyvxEjgRvLLN4bUr599bwYhku/3MJXZ1/02xKpTBnHsJMuMYX1eACx9Nfl6IWkCAAAAUMm4XZtUFUkTAAAAgGpqkjSN+mAGAAAAABgqepoAAAAAlDeGU4dXRdIEAAAAoBqSJgAAAADooiZJE9c0AQAAAEAX9DQBAAAAqKQu1zTR0wQAAAAAXdDTBIy7VisfOzHR57qTp5caJdrYWkLncqLE6+6n7H4po+FcXL9fs0scD4N43f00rOOhjDLfJwAg1eaaJpImAAAAAOXVaMrxJXRKFwAAAAD6j54mAAAAANXUpKeJpAkAAABANSRNAAAAADA3qz7XNJE0AQAAAKimJkkTE0EAAAAAQBf0NAEAAAAor0ZTjpM0AQAAAKiGpAnAktNqpcKi0d+Ru85V29YoE7xEtMbgL06/29hwLi5KHA/u84jzMnVnDGA/RyTLTH72AaC0MfgT1g9c0wQAAAAAXdDTBAAAAKASrmkCAAAAgG5ImgAAAABgHqHaJE1c0wQAAACgEkf1JVW+vdn2s7anbO+Y43nbvqt4/mnb13Y8t8v2CduHZm3zBdsv2X6qWG7o1Q6SJgAAAAAjx/aEpLslbZF0laRbbF81K2yLpPXFsk3Szo7nviFp8zzF3xkRG4plb6+2kDQBAAAAqCYWsPS2SdJURDwfEaclPSBp66yYrZLuj7bHJa22vVaSIuIxSa8u5OWdRdIEAAAAoJIFDs9bY/tgx7JtVvHrJL3Y8Xi6WFc2Zi7bi+F8u2xf2CuYpAkAAABANQvraXo5IjZ2LPfOKn2uO6HP7qPKxMy2U9L7JG2QdEzSV3vEM3seUCuRvOqy1crFNXLnXSJbryQnq05rzPVdOp7KvI/DYg/x/Y5+HzxJrdx+Gcj+y35Wx+DYATCGBj973rSkyzoeXyrpaIWYfyAijp/93fZ9kh7p1RB6mgAAAACMogOS1tu+0vYKSTdL2jMrZo+kTxSz6F0n6fWIONat0LPXPBVuknRovtiz6GkCAAAAUJo199i4fomIGdvbJT0qaULSrog4bPv24vl7JO2VdIOkKUnvSPrk37XP/pakD6t97dS0pM9HxNclfdn2BrX7yV6Q9OlebSFpAgAAAFDNgEf/FtOB75217p6O30PSHfNse8s8628t2w6SJgAAAACVZG9SO+64pgkAAAAAuqCnCQAAAEA1NelpImkCAAAAUA1JEwAAAADMI+pzTRNJEwAAAIBqapI0MREEAAAAAHRBTxMwqlq5UzdR4tSHW61cYCNZaLOZrDh/67tI1u1smcn3UY0B3J4vW3cdDXO/ZGU/gzGA/Zz9rGbrTpZX6rVwfANQfYbn9fzvxPYu2ydsH+pYd5HtfbafK35eONhmAgAAABg5sYBljGRO6X5D0uZZ63ZI2h8R6yXtLx4DAAAAqBFH9WWc9EyaIuIxSa/OWr1V0u7i992SbuxvswAAAABgNFS9pumSiDgmSRFxzPbFfWwTAAAAgFE3hsPsqhr47Hm2t9k+aPvgyZMnB10dAAAAgMXCNU1dHbe9VpKKnyfmC4yIeyNiY0RsnJycrFgdAAAAgFFicU1TL3sk3Vb8fpukh/vTHAAAAABjg56mNtvfkvQDSe+3PW37U5K+JOl6289Jur54DAAAAABLTs+JICLilnme+mif2wIAAABgjHgQN/geQVVnzwMwKlr5L6tIDsh1q5ULbAxgLplk3ZGs23ay3uF96Ue//+Bk918Zyfc7+1rS+2UQkvt6qPslW3f285Iurx7//ADokzEcZlcVSRMAAACASsZtQoeqSJoAAAAAVFOTpGng92kCAAAAgHFGTxMAAACAShieBwAAAADdkDQBAAAAwDyiPj1NXNMEAAAAAF3Q0wQAAACgmpr0NJE0AQAAACjNqs/wPJImYLFFKxnnXJxLjLJt5b7ZIlmkW8nX0ijRRidfN+ohecwOVfZzECVeS7LMyJY5iPcx/V2WjAMwnsp8t40xkiYAAAAAldSlp4mJIAAAAACgC3qaAAAAAJQXYiIIAAAAAOjGNblskeF5AAAAAKqJBSwJtjfbftb2lO0dczxv23cVzz9t+9qO53bZPmH70KxtLrK9z/Zzxc8Le7WDpAkAAABAJY7qS8+y7QlJd0vaIukqSbfYvmpW2BZJ64tlm6SdHc99Q9LmOYreIWl/RKyXtL943BVJEwAAAIBRtEnSVEQ8HxGnJT0gaeusmK2S7o+2xyWttr1WkiLiMUmvzlHuVkm7i993S7qxV0NImgAAAACUF2rfp6nq0ts6SS92PJ4u1pWNme2SiDgmScXPi3s1hIkgAAAAAFSywPs0rbF9sOPxvRFxb2fxc2wzu8ZMzIKRNAHjLkpMW+P+di5H8i7gbpVoYyPZxmSZkSzPnus7F0tR9rjNHmPJs6X58lSijf1W5vsEAKSFpicvR8TGLs9PS7qs4/Glko5WiJntuO21EXGsGMp3oldDGZ4HAAAAYBQdkLTe9pW2V0i6WdKeWTF7JH2imEXvOkmvnx1618UeSbcVv98m6eFeDSFpAgAAAFCaNdjZ8yJiRtJ2SY9KOiLpwYg4bPt227cXYXslPS9pStJ9kn7n79pnf0vSDyS93/a07U8VT31J0vW2n5N0ffG4K4bnAQAAACgvP6HDAqqIvWonRp3r7un4PSTdMc+2t8yz/hVJHy3TDpImAAAAAJUscCKIsUHSBAAAAKCamiRNXNMEAAAAAF3Q0wQAAACgEobnAQAAAMB8QlKrHlkTSRMAAACAauqRM5E0AaMqBnDmxo1WLrCVvNyx4eqNGTGRnDLVHoPX3OBy1drIfk9E8rNfwiC+owCMn7oMz+MvKwAAAAB0QU8TAAAAgGoGfHPbUUHSBAAAAKCSugzPI2kCAAAAUF6oNhNBcE0TAAAAAHRBTxMAAACA0izJXNMEAAAAAF30/44GI4mkCQAAAEAl9DQBAAAAwHyYCAIAAAAAINHTBGAhWrnTS1Hi9IxbycHRjWShfS4vSgxDsJ2OxdzKvN9p2WMiW3eyvFKvJfnZ6rcYUr0AxlVwc9sM2y9IelNSU9JMRGzsR6MAAAAAjD5ubpv3axHxch/KAQAAADBO6GkCAAAAgHmE5JpMOb7QiSBC0l/YftL2tn40CAAAAABGyUJ7mj4UEUdtXyxpn+1nIuKxzoAimdomSZdffvkCqwMAAAAwMmoyPG9BPU0RcbT4eULSQ5I2zRFzb0RsjIiNk5OTC6kOAAAAwCiJBSxjpHLSZPs82xec/V3Sr0s61K+GAQAAABhtjqi8jJOFDM+7RNJDxX1Ilkn604j48760CgAAAABGROWkKSKel/SBPrYFAAAAwDgZsx6jqphyHFhs6S+X5Byezo+yjVaubjf6X/fIayVfc6PE+53c10WPPVBe5I7b7Gd/EHXX5R8qoJZC6X9Xxh1JEwAAAIDSrPG7NqkqkiYAAAAA1dQkaVpCY2sAAAAAoP/oaQIAAABQTU16mkiaAAAAAJRXo4kgGJ4HAAAAoJJB39zW9mbbz9qesr1jjudt+67i+adtX9trW9tfsP2S7aeK5YZe7aCnCQAAAEA1AxyeZ3tC0t2Srpc0LemA7T0R8ZOOsC2S1hfLByXtlPTBxLZ3RsRXsm2hpwkAAADAKNokaSoino+I05IekLR1VsxWSfdH2+OSVttem9w2jaQJAAAAQAXR7mmqukhrbB/sWLbNqmCdpBc7Hk8X6zIxvbbdXgzn22X7wl6vlOF5wLiLEldgegmdJ2klX3cj+Zrt6m1BaTGI4RzZY6ImMz1VUub7BABCC/1OfTkiNnZ5fq4/zrMrnC+m27Y7Jf1h8fgPJX1V0m93ayhJEwAAAIBqBnuuZVrSZR2PL5V0NBmzYr5tI+L42ZW275P0SK+GLKHTzgAAAACWkAOS1tu+0vYKSTdL2jMrZo+kTxSz6F0n6fWIONZt2+Kap7NuknSoV0PoaQIAAABQSXbq8CoiYsb2dkmPSpqQtCsiDtu+vXj+Hkl7Jd0gaUrSO5I+2W3bougv296g9vC8FyR9uldbSJoAAAAAVDPg60QjYq/aiVHnuns6fg9Jd2S3LdbfWrYdJE0AAAAAygtJrXpMrkPSBAAAAKCCqM2MpEwEAQAAAABd0NMEAAAAoJqa9DSRNAEAAACohqQJwFBlv4Q81w2vF1h18qJON5J3tGvlRwJHnwcNu5VsYyNZcba8MmX2W6P/x8TQLvQt835nPzPJMqPf/wiUeQ8j2cZhXoBdk3+UAHTBRBAAAAAA0E2kT/KMOyaCAAAAAIAu6GkCAAAAUE1NhuqSNAEAAAAoj2uaAAAAAKCHmvQ0cU0TAAAAAHRBTxMAAACAamrS00TSBAAAAKCCIGkCAAAAgHmFyt2EfIyRNAEAAACohp4mAGOh1JdVf88GRSs7l0wzX2gy1A2n4tLvjpOvJVmvJNl9bmMj2cZkvaX0+49i8sxklKk3O+1tn+9eH8OcbrfPr6Uu//wAQFkkTQAAAACqqcnJFpImAAAAABUEN7cFAAAAgHmFFP0eJjyiuLktAAAAAHRBTxMAAACAahieBwAAAABdMBEEAAAAAMwjgpvbAgAAAEBXNelpYiIIAAAAAOiCniagTvp9Niia/S2vTNXDGg1gp0P7fu7NY3Cea5hTz9bkbCcAjJKoyfC8Bf0Ftr3Z9rO2p2zv6FejAAAAAIy6aJ+wqrqMkco9TbYnJN0t6XpJ05IO2N4TET/pV+MAAAAAjKgQU44nbJI0FRHPS5LtByRtlUTSBAAAANTBMIdlL6KFDM9bJ+nFjsfTxToAAAAAWDIW0tM019XQP9c/Z3ubpG2SdPnlly+gOgAAAACjIiRFTYbnLaSnaVrSZR2PL5V0dHZQRNwbERsjYuPk5OQCqgMAAAAwMiLaw/OqLmNkIT1NByStt32lpJck3Szpt/rSKgAAAAAjry49TZWTpoiYsb1d0qOSJiTtiojDfWsZAAAAAIyABd3cNiL2Strbp7YAAAAAGCdjNsyuKsci3ljK9klJf7NoFWIuayS9POxG4OewX0YT+2U0sV9GE/tlNLFfRtNc++WXI2KsJgCw/edqv5aqXo6Izf1qzyAtatKE4bN9MCI2Drsd+IfYL6OJ/TKa2C+jif0ymtgvo4n9Mn4WMnseAAAAACx5JE0AAAAA0AVJU/3cO+wGYE7sl9HEfhlN7JfRxH4ZTeyX0cR+GTNc0wQAAAAAXdDTBAAAAABdkDTVhO2P2z5su2V746znfs/2lO1nbf/GsNpYV7Y3F+/9lO0dw25PXdneZfuE7UMd6y6yvc/2c8XPC4fZxrqxfZnt79o+Unx/faZYz34ZItsrbf/Q9l8V++WLxXr2ywiwPWH7/9h+pHjMfhky2y/Y/rHtp2wfLNaxX8YMSVN9HJL0ryQ91rnS9lWSbpb0jyRtlvRfbU8sfvPqqXiv75a0RdJVkm4p9gkW3zfU/gx02iFpf0Ssl7S/eIzFMyPpcxHxq5Kuk3RH8flgvwzXKUkfiYgPSNogabPt68R+GRWfkXSk4zH7ZTT8WkRs6JhmnP0yZkiaaiIijkTEs3M8tVXSAxFxKiL+WtKUpE2L27pa2yRpKiKej4jTkh5Qe59gkUXEY5JenbV6q6Tdxe+7Jd24mG2qu4g4FhE/Kn5/U+1/BNeJ/TJU0fZW8XB5sYTYL0Nn+1JJ/1zSf+tYzX4ZTeyXMUPShHWSXux4PF2sw+Lg/R9tl0TEMan9D7yki4fcntqyfYWkayQ9IfbL0BVDwJ6SdELSvohgv4yGP5b0HyS1OtaxX4YvJP2F7SdtbyvWsV/GzLJhNwD9Y/svJf3iHE/9QUQ8PN9mc6xjSsXFw/sP9GD7fEnflvTZiHjDnutjg8UUEU1JG2yvlvSQ7auH3KTas/2bkk5ExJO2Pzzk5uAf+lBEHLV9saR9tp8ZdoNQHknTEhIRH6uw2bSkyzoeXyrpaH9ahATe/9F23PbaiDhme63aZ9WxiGwvVzth+mZEfKdYzX4ZERHxmu3vqX09IPtluD4k6V/avkHSSknvsf0nYr8MXUQcLX6esP2Q2kPz2S9jhuF52CPpZtvn2L5S0npJPxxym+rkgKT1tq+0vULtSTn2DLlN+Ht7JN1W/H6bpPl6bDEAbncpfV3SkYj4WsdT7Jchsj1Z9DDJ9ipJH5P0jNgvQxURvxcRl0bEFWr/LflfEfFvxH4ZKtvn2b7g7O+Sfl3tybnYL2OGm9vWhO2bJP1nSZOSXpP0VET8RvHcH0j6bbVnqvpsRPzZsNpZR8VZwT+WNCFpV0T80XBbVE+2vyXpw5LWSDou6fOS/qekByVdLumnkj4eEbMni8CA2P6nkv63pB/r76/R+H21r2tivwyJ7X+s9oXrE2qffH0wIv6j7V8Q+2UkFMPz/l1E/Cb7Zbhs/4qkh4qHyyT9aUT8Eftl/JA0AQAAAEAXDM8DAAAAgC5ImgAAAACgC5ImAAAAAOiCpAkAAAAAuiBpAgAAAIAuSJoAAAAAoAuSJgAAAADogqQJAAAAALr4/1QOCksD8jK6AAAAAElFTkSuQmCC\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
+       "<Figure size 1600x600 with 2 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -157,21 +145,10 @@
    "execution_count": 7,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n",
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n",
-      "WARNING:root:Using Nodes is experimental and not fully tested. Double check your generated code!\n",
-      "WARNING:root:Lhs\"dir of type \"int64_t\" is assigned with a different datatype rhs: \"indexField[0](dir)\" of type \"int32_t\".\n",
-      "WARNING:root:Lhs\"dir of type \"int64_t\" is assigned with a different datatype rhs: \"indexField[0](dir)\" of type \"int32_t\".\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x149a4a190>"
+       "<matplotlib.colorbar.Colorbar at 0x12e912a90>"
       ]
      },
      "execution_count": 7,
@@ -180,14 +157,12 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
+       "<Figure size 1600x600 with 2 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -226,7 +201,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.9"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,