From 3ba1fe47c72709f950510bd2af5fd073290500ba Mon Sep 17 00:00:00 2001 From: prajwal Date: Fri, 5 Jun 2026 22:41:32 +0530 Subject: [PATCH 01/16] feat: add mesh_layout='triangular' for regular triangular mesh generation Add support for triangular mesh layout based on networkx.triangular_lattice_graph. Implements flat, flat_multiscale and hierarchical triangular mesh connectivity. Closes #80 --- CHANGELOG.md | 7 + src/weather_model_graphs/create/base.py | 100 +- .../create/mesh/__init__.py | 10 + .../create/mesh/connectivity/triangular.py | 426 +++++++ tests/test_mesh_layout.py | 2 +- tests/test_triangular_mesh.py | 1048 +++++++++++++++++ 6 files changed, 1585 insertions(+), 8 deletions(-) create mode 100644 src/weather_model_graphs/create/mesh/connectivity/triangular.py create mode 100644 tests/test_triangular_mesh.py diff --git a/CHANGELOG.md b/CHANGELOG.md index ef84eba..03ad499 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Add `mesh_layout="triangular"` support to `create_all_graph_components`, using + `networkx.triangular_lattice_graph` to produce an equilateral-triangle lattice + with 6-connectivity. Supports all three `m2m_connectivity` modes: `flat`, + `hierarchical`, and `flat_multiscale`. New module + `create/mesh/connectivity/triangular.py` contains the coordinate and + connectivity creation functions for triangular meshes. + [\#80](https://github.com/mllam/weather-model-graphs/issues/80), @prajwal-tech07 - Add `mesh_layout` argument to mesh graph creation functions, with `rectilinear` as the first supported layout. Uses a two-step architecture separating coordinate creation from connectivity creation, enabling future alternative layouts (e.g. triangular). diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index d157c3b..fc1baef 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -8,6 +8,7 @@ function uses `connect_nodes_across_graphs` to connect nodes across the component graphs. """ +import warnings from typing import Dict, Iterable, List, Tuple, Union import networkx @@ -28,6 +29,11 @@ create_flat_singlescale_from_coordinates, ) from .mesh.connectivity.hierarchical import create_hierarchical_from_coordinates +from .mesh.connectivity.triangular import ( + create_flat_multiscale_from_triangular_coordinates, + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_primitive, +) from .mesh.coords import ( create_multirange_2d_mesh_primitives, create_single_level_2d_mesh_primitive, @@ -141,8 +147,12 @@ def create_all_graph_components( - "rectilinear": Uniform regular grid with ``mesh_node_spacing`` resolution. Produces an undirected mesh primitive with 4-star (cardinal) and 8-star (cardinal + diagonal) spatial adjacency edges. + - "triangular": Regular triangular lattice with ``mesh_node_spacing`` + resolution. Uses ``networkx.triangular_lattice_graph`` to produce + equilateral triangles with 6-connectivity. A CRS warning is emitted + if ``graph_crs`` is geographic (lat/lon). - mesh_layout_kwargs (for mesh_layout="rectilinear"): + mesh_layout_kwargs (for mesh_layout="rectilinear" or "triangular"): - mesh_node_spacing: float, distance between mesh nodes in coordinate units. - refinement_factor: int, refinement factor between levels (for multi-level and hierarchical mesh graphs, default: 3) @@ -255,6 +265,20 @@ def create_all_graph_components( # ----------------------------------------------------------------------- G_mesh_coords: Union[networkx.Graph, List[networkx.Graph]] + # CRS warning for triangular layout in geographic coordinates + if ( + mesh_layout == "triangular" + and graph_crs is not None + and graph_crs.is_geographic + ): + warnings.warn( + "mesh_layout='triangular' produces non-uniform physical spacing in " + "geographic coordinates. Consider mesh_layout='icosahedral' for " + "uniform coverage on a sphere.", + UserWarning, + stacklevel=2, + ) + if mesh_layout == "rectilinear": mesh_node_spacing = mesh_layout_kwargs.get( "mesh_node_spacing" @@ -283,18 +307,63 @@ def create_all_graph_components( "max_num_refinement_levels" ] G_mesh_coords = create_multirange_2d_mesh_primitives(**primitives_kwargs) + + elif mesh_layout == "triangular": + mesh_node_spacing = mesh_layout_kwargs.get( + "mesh_node_spacing" + ) or mesh_layout_kwargs.get("grid_spacing") + if mesh_node_spacing is None: + raise ValueError( + "mesh_layout='triangular' requires 'mesh_node_spacing' in " + "mesh_layout_kwargs (or 'mesh_node_distance' in " + "m2m_connectivity_kwargs for backward compatibility)." + ) + + if m2m_connectivity == "flat": + range_x, range_y = np.ptp(xy, axis=0) + nx_mesh = int(range_x / mesh_node_spacing) + ny_mesh = int(range_y / (mesh_node_spacing * np.sqrt(3) / 2)) + if nx_mesh == 0 or ny_mesh == 0: + raise ValueError( + "The given `mesh_node_spacing` is too large for the provided " + f"coordinates. Got mesh_node_spacing={mesh_node_spacing}, but the " + f"x-range is {range_x} and y-range is {range_y}. Maybe you " + "want to decrease the `mesh_node_spacing` so that the mesh nodes " + "are spaced closer together?" + ) + G_mesh_coords = create_single_level_2d_triangular_mesh_primitive( + xy, nx_mesh, ny_mesh + ) + else: + primitives_kwargs = dict( + xy=xy, + mesh_node_spacing=mesh_node_spacing, + ) + if "refinement_factor" in mesh_layout_kwargs: + primitives_kwargs["interlevel_refinement_factor"] = mesh_layout_kwargs[ + "refinement_factor" + ] + if "max_num_refinement_levels" in mesh_layout_kwargs: + primitives_kwargs["max_num_levels"] = mesh_layout_kwargs[ + "max_num_refinement_levels" + ] + G_mesh_coords = create_multirange_2d_triangular_mesh_primitives( + **primitives_kwargs + ) + else: raise NotImplementedError( f"mesh_layout='{mesh_layout}' is not yet supported. " - "Currently only 'rectilinear' is implemented." + "Currently supported: 'rectilinear', 'triangular'." ) # ----------------------------------------------------------------------- # Step 2: Connectivity creation — converts mesh primitives to directed graph # ----------------------------------------------------------------------- if m2m_connectivity == "flat": + pattern = m2m_connectivity_kwargs.get("pattern", "4-star" if mesh_layout == "triangular" else "8-star") graph_components["m2m"] = create_flat_singlescale_from_coordinates( - G_mesh_coords, **m2m_connectivity_kwargs + G_mesh_coords, pattern=pattern ) grid_connect_graph = graph_components["m2m"] @@ -302,8 +371,17 @@ def create_all_graph_components( # hierarchical mesh graph has three sub-graphs: # `m2m` (mesh-to-mesh), `mesh_up` (up edge connections) and # `mesh_down` (down edge connections) + intra_level = m2m_connectivity_kwargs.get("intra_level") + if intra_level is None and mesh_layout == "triangular": + intra_level = {"pattern": "4-star"} + hierarchical_kwargs = {} + if intra_level is not None: + hierarchical_kwargs["intra_level"] = intra_level + inter_level = m2m_connectivity_kwargs.get("inter_level") + if inter_level is not None: + hierarchical_kwargs["inter_level"] = inter_level graph_components["m2m"] = create_hierarchical_from_coordinates( - G_mesh_coords, **m2m_connectivity_kwargs + G_mesh_coords, **hierarchical_kwargs ) # Only connect grid to bottom level of hierarchy grid_connect_graph = split_graph_by_edge_attribute( @@ -311,9 +389,17 @@ def create_all_graph_components( )[0] elif m2m_connectivity == "flat_multiscale": - graph_components["m2m"] = create_flat_multiscale_from_coordinates( - G_mesh_coords, **m2m_connectivity_kwargs - ) + pattern = m2m_connectivity_kwargs.get("pattern") + if pattern is None: + pattern = "4-star" if mesh_layout == "triangular" else "8-star" + if mesh_layout == "triangular": + graph_components["m2m"] = create_flat_multiscale_from_triangular_coordinates( + G_mesh_coords, pattern=pattern + ) + else: + graph_components["m2m"] = create_flat_multiscale_from_coordinates( + G_mesh_coords, pattern=pattern + ) grid_connect_graph = graph_components["m2m"] else: diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index 2d3d7cc..e1f52e4 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -4,3 +4,13 @@ create_single_level_2d_mesh_graph, create_single_level_2d_mesh_primitive, ) + +from .connectivity.triangular import ( + create_flat_multiscale_from_triangular_coordinates, + create_flat_multiscale_triangular_mesh_graph, + create_flat_singlescale_triangular_mesh_graph, + create_hierarchical_triangular_mesh_graph, + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_graph, + create_single_level_2d_triangular_mesh_primitive, +) diff --git a/src/weather_model_graphs/create/mesh/connectivity/triangular.py b/src/weather_model_graphs/create/mesh/connectivity/triangular.py new file mode 100644 index 0000000..eb98dbe --- /dev/null +++ b/src/weather_model_graphs/create/mesh/connectivity/triangular.py @@ -0,0 +1,426 @@ +""" +Functions for creating regular triangular mesh graphs. + +Uses ``networkx.triangular_lattice_graph`` to produce an equilateral-triangle +lattice with 6-connectivity (each interior node has 6 neighbours). This +mirrors the rectilinear mesh functions (which use ``networkx.grid_2d_graph`` +with 8-connectivity) and plugs into the same two-step process: + +1. **Coordinate creation** (this module) -> ``nx.Graph`` with ``pos``, ``type``, + and ``adjacency_type`` attributes. +2. **Connectivity creation** (``create_directed_mesh_graph`` in ``general.py``) + -> ``nx.DiGraph`` with ``len`` and ``vdiff`` edge attributes. + +Supports flat, flat_multiscale, and hierarchical ``m2m_connectivity`` modes. +""" + +from typing import List + +import networkx +import numpy as np +import scipy.spatial +from loguru import logger + +from ....networkx_utils import prepend_node_index +from .general import create_directed_mesh_graph + + +def create_single_level_2d_triangular_mesh_primitive( + xy: np.ndarray, nx: int, ny: int +) -> networkx.Graph: + """ + Create an undirected triangular mesh primitive graph (``nx.Graph``) with + node positions and spatial adjacency edges. + + This is analogous to ``create_single_level_2d_mesh_primitive`` but uses + ``networkx.triangular_lattice_graph`` instead of ``grid_2d_graph``. + + In a triangular lattice, each interior node has 6 neighbours (vs. 8 for + the rectilinear lattice with diagonals), providing more isotropic message + passing. + + The nodes form a grid of ``(ny + 1)`` rows and ``(nx + 1) // 2`` columns, + with odd-row nodes shifted horizontally. Positions are scaled and offset + so that the mesh spans the coordinate domain of *xy* (with nodes inset + from the border by half a cell width in each direction). + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + nx : int + Number of triangle columns (passed as *n* to + ``triangular_lattice_graph``). + ny : int + Number of triangle rows (passed as *m* to + ``triangular_lattice_graph``). + + Returns + ------- + networkx.Graph + Undirected mesh primitive graph. Node attributes: ``pos`` + (np.ndarray[2,]), ``type`` (``"mesh"``). Edge attributes: + ``adjacency_type`` (always ``"cardinal"`` -- triangular lattices have + only one class of edge). Graph attributes: ``dx``, ``dy``. + """ + xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) + ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) + + # Create the raw triangular lattice + g_raw = networkx.triangular_lattice_graph(ny, nx, with_positions=True) + + if g_raw.number_of_nodes() == 0: + raise ValueError( + f"triangular_lattice_graph({ny}, {nx}) produced 0 nodes. " + "Increase nx/ny or decrease mesh_node_spacing." + ) + + # Gather raw positions to compute extent + raw_positions = np.array([g_raw.nodes[n]["pos"] for n in g_raw.nodes()]) + raw_xmin, raw_ymin = raw_positions.min(axis=0) + raw_xmax, raw_ymax = raw_positions.max(axis=0) + raw_extent_x = raw_xmax - raw_xmin + raw_extent_y = raw_ymax - raw_ymin + + # Domain extent with half-cell inset + domain_x = xM - xm + domain_y = yM - ym + + # Scale factors -- map raw lattice extent to domain extent (inset by half + # a cell in each direction, mirroring the rectilinear approach) + if raw_extent_x > 0: + scale_x = domain_x / (raw_extent_x + 1.0) # +1 for inset + else: + scale_x = domain_x # single column + if raw_extent_y > 0: + scale_y = domain_y / (raw_extent_y + np.sqrt(3) / 2) # +row_h for inset + else: + scale_y = domain_y # single row + + # Effective dx/dy for graph attributes + dx = scale_x + dy = scale_y * (np.sqrt(3) / 2) + + # Offset so mesh is centred within domain + offset_x = xm + (domain_x - raw_extent_x * scale_x) / 2 + offset_y = ym + (domain_y - raw_extent_y * scale_y) / 2 + + # Build output graph with scaled positions + g = networkx.Graph() + for node in g_raw.nodes(): + raw_pos = g_raw.nodes[node]["pos"] + pos = np.array([ + offset_x + (raw_pos[0] - raw_xmin) * scale_x, + offset_y + (raw_pos[1] - raw_ymin) * scale_y, + ]) + g.add_node(node, pos=pos, type="mesh") + + for u, v in g_raw.edges(): + g.add_edge(u, v, adjacency_type="cardinal") + + g.graph["dx"] = dx + g.graph["dy"] = dy + + return g + + +def create_multirange_2d_triangular_mesh_primitives( + max_num_levels, + xy: np.ndarray, + mesh_node_spacing: float = 3, + interlevel_refinement_factor: int = 3, +) -> List[networkx.Graph]: + """ + Create a list of undirected triangular mesh primitive graphs representing + different levels of mesh resolution. + + Mirrors ``create_multirange_2d_mesh_primitives`` but uses triangular + lattice topology at each level. + + Parameters + ---------- + max_num_levels : int + Maximum number of levels in the multi-scale graph. + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + mesh_node_spacing : float + Distance between mesh nodes at the finest level, in coordinate units. + interlevel_refinement_factor : int + Factor by which mesh node count decreases per level. + + Returns + ------- + list[networkx.Graph] + Triangular mesh primitive graphs, one per level. + """ + coord_extent = np.ptp(xy, axis=0) + # For triangular lattice, ny accounts for row spacing of sqrt(3)/2 + max_nx = int(coord_extent[0] / mesh_node_spacing) + max_ny = int(coord_extent[1] / (mesh_node_spacing * np.sqrt(3) / 2)) + + max_nodes_bottom = np.array([max_nx, max_ny]) + + max_mesh_levels_float = np.log(max_nodes_bottom) / np.log( + interlevel_refinement_factor + ) + max_mesh_levels = max_mesh_levels_float.astype(int) + nleaf = interlevel_refinement_factor ** max_mesh_levels + + mesh_levels_to_create = max_mesh_levels.min() + if max_num_levels: + mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) + + logger.debug( + f"triangular mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}" + ) + + G_all_levels = [] + for lev in range(mesh_levels_to_create): + nodes_x, nodes_y = ( + nleaf / (interlevel_refinement_factor ** lev) + ).astype(int) + g = create_single_level_2d_triangular_mesh_primitive( + xy, nodes_x, nodes_y + ) + for node in g.nodes: + g.nodes[node]["level"] = lev + for edge in g.edges: + g.edges[edge]["level"] = lev + g.graph["level"] = lev + g.graph["interlevel_refinement_factor"] = interlevel_refinement_factor + G_all_levels.append(g) + + return G_all_levels + + +def create_single_level_2d_triangular_mesh_graph( + xy: np.ndarray, nx: int, ny: int +) -> networkx.DiGraph: + """ + Create a directed triangular mesh graph from coordinates. + + Internally uses the two-step process: + 1. ``create_single_level_2d_triangular_mesh_primitive`` (coordinate creation) + 2. ``create_directed_mesh_graph`` (connectivity creation) + + For triangular lattices, *all* edges are ``"cardinal"`` so patterns + ``"4-star"`` and ``"8-star"`` produce the same result (6-connectivity). + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + nx : int + Number of triangle columns. + ny : int + Number of triangle rows. + + Returns + ------- + networkx.DiGraph + Directed triangular mesh graph. + """ + G_coords = create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) + return create_directed_mesh_graph(G_coords, pattern="4-star") + + +def create_flat_singlescale_triangular_mesh_graph( + xy: np.ndarray, mesh_node_distance: float +) -> networkx.DiGraph: + """ + Create a flat single-scale triangular mesh graph. + + Mirrors ``create_flat_singlescale_mesh_graph`` but with triangular + lattice topology (6-connectivity). + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + mesh_node_distance : float + Approximate side length of equilateral triangles, in coordinate units. + + Returns + ------- + networkx.DiGraph + Flat single-scale directed triangular mesh graph. + """ + range_x, range_y = np.ptp(xy, axis=0) + nx = int(range_x / mesh_node_distance) + ny = int(range_y / (mesh_node_distance * np.sqrt(3) / 2)) + + if nx == 0 or ny == 0: + raise ValueError( + "The given `mesh_node_distance` is too large for the provided " + f"coordinates. Got mesh_node_distance={mesh_node_distance}, but " + f"the x-range is {range_x} and y-range is {range_y}. Maybe you " + "want to decrease the `mesh_node_distance` so that the mesh " + "nodes are spaced closer together?" + ) + + return create_single_level_2d_triangular_mesh_graph(xy, nx, ny) + + +def create_flat_multiscale_from_triangular_coordinates( + G_coords_list: List[networkx.Graph], + pattern: str = "4-star", +) -> networkx.DiGraph: + """ + Create flat multiscale mesh graph from a list of triangular coordinate + graphs. + + Unlike the rectilinear variant (``create_flat_multiscale_from_coordinates``) + which relies on grid-index-based coincident-node detection, this function + uses position-based matching. For each coarser level, any node whose + position coincides (within floating-point tolerance) with an existing finer + level node is merged with it, so that multi-resolution edges share the + same node identity. + + Parameters + ---------- + G_coords_list : list[networkx.Graph] + One undirected triangular mesh primitive per level. + pattern : str + Connectivity pattern: ``"4-star"`` or ``"8-star"`` (default ``"4-star"``). + + Returns + ------- + networkx.DiGraph + Flat multiscale triangular mesh graph. + """ + # Convert each level to directed graph + G_directed = [ + create_directed_mesh_graph(g, pattern=pattern) + for g in G_coords_list + ] + + # Prepend level index to make node labels unique across levels + G_directed = [ + prepend_node_index(g, level_i) + for level_i, g in enumerate(G_directed) + ] + + # Build merged graph, starting from finest level + G_tot = G_directed[0] + + for lev in range(1, len(G_directed)): + G_coarse = G_directed[lev] + + # KDTree of existing (finer) nodes for position matching + fine_nodes = list(G_tot.nodes()) + fine_positions = np.array( + [G_tot.nodes[n]["pos"] for n in fine_nodes] + ) + kdt = scipy.spatial.KDTree(fine_positions) + + # Find which coarse nodes coincide with existing fine nodes + relabel_map = {} + for node in G_coarse.nodes(): + pos = G_coarse.nodes[node]["pos"] + dist, idx = kdt.query(pos) + if dist < 1e-8: + relabel_map[node] = fine_nodes[idx] + + if relabel_map: + G_coarse = networkx.relabel_nodes(G_coarse, relabel_map) + + G_tot = networkx.compose(G_tot, G_coarse) + + # Re-index to sequential (0, i) labels + G_tot = prepend_node_index(G_tot, 0) + + # Preserve dx/dy as per-level dicts + G_tot.graph["dx"] = {i: g.graph["dx"] for i, g in enumerate(G_directed)} + G_tot.graph["dy"] = {i: g.graph["dy"] for i, g in enumerate(G_directed)} + + return G_tot + + +def create_flat_multiscale_triangular_mesh_graph( + xy: np.ndarray, + mesh_node_distance: float, + level_refinement_factor: int, + max_num_levels: int, +) -> networkx.DiGraph: + """ + Create a flat multiscale triangular mesh graph. + + Mirrors ``create_flat_multiscale_mesh_graph`` but with triangular lattice + topology at each level. + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + mesh_node_distance : float + Distance between mesh nodes at the finest level. + level_refinement_factor : int + Refinement factor between levels. + max_num_levels : int + Maximum number of mesh levels. + + Returns + ------- + networkx.DiGraph + Flat multiscale triangular mesh graph. + """ + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=max_num_levels, + xy=xy, + mesh_node_spacing=mesh_node_distance, + interlevel_refinement_factor=level_refinement_factor, + ) + return create_flat_multiscale_from_triangular_coordinates(G_coords_list) + + +def create_hierarchical_triangular_mesh_graph( + xy: np.ndarray, + mesh_node_distance: float, + level_refinement_factor: int, + max_num_levels: int, + intra_level: dict = None, + inter_level: dict = None, +) -> networkx.DiGraph: + """ + Create a hierarchical triangular mesh graph. + + Mirrors ``create_hierarchical_multiscale_mesh_graph`` but with triangular + lattice topology at each level. + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + mesh_node_distance : float + Distance between mesh nodes at the finest level. + level_refinement_factor : int + Refinement factor between levels. + max_num_levels : int + Maximum number of mesh levels. + intra_level : dict, optional + Keyword arguments for intra-level connectivity (e.g. ``{"pattern": "4-star"}``). + Defaults to ``{"pattern": "4-star"}``. + inter_level : dict, optional + Keyword arguments for inter-level connectivity. If None, uses defaults + from ``create_hierarchical_from_coordinates``. + + Returns + ------- + networkx.DiGraph + Hierarchical triangular mesh graph. + """ + from .hierarchical import create_hierarchical_from_coordinates + + if intra_level is None: + intra_level = {"pattern": "4-star"} + + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=max_num_levels, + xy=xy, + mesh_node_spacing=mesh_node_distance, + interlevel_refinement_factor=level_refinement_factor, + ) + kwargs = {"intra_level": intra_level} + if inter_level is not None: + kwargs["inter_level"] = inter_level + return create_hierarchical_from_coordinates(G_coords_list, **kwargs) diff --git a/tests/test_mesh_layout.py b/tests/test_mesh_layout.py index b289fcc..594481e 100644 --- a/tests/test_mesh_layout.py +++ b/tests/test_mesh_layout.py @@ -617,7 +617,7 @@ def test_unsupported_mesh_layout_raises(self): wmg.create.create_all_graph_components( coords=xy, m2m_connectivity="flat", - mesh_layout="triangular", + mesh_layout="hexagonal", mesh_layout_kwargs=dict(mesh_node_spacing=3), g2m_connectivity="nearest_neighbour", m2g_connectivity="nearest_neighbour", diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py new file mode 100644 index 0000000..40308a3 --- /dev/null +++ b/tests/test_triangular_mesh.py @@ -0,0 +1,1048 @@ +""" +Tests for mesh_layout="triangular" support (Issue #80). + +Tests verify: +1. Primitive creation (node count, positions, adjacency_type, type attrs) +2. Single-level directed graph (bidirectional edges, len/vdiff attrs, 6-connectivity) +3. Multirange primitive creation +4. Flat single-scale mesh graph via wrapper + integration +5. Flat multiscale mesh graph (position-based merging) +6. Hierarchical mesh graph +7. Integration through create_all_graph_components for all m2m_connectivity modes +8. Edge cases (spacing too large, single-level hierarchical) +9. Numerical correctness (len symmetry, vdiff reciprocity) +10. Pattern equivalence (4-star == 8-star for triangular) +""" + +import networkx as nx +import numpy as np +import pytest + +import tests.utils as test_utils +import weather_model_graphs as wmg +from weather_model_graphs.create.mesh.connectivity.general import ( + create_directed_mesh_graph, +) +from weather_model_graphs.create.mesh.connectivity.triangular import ( + create_flat_multiscale_from_triangular_coordinates, + create_flat_multiscale_triangular_mesh_graph, + create_flat_singlescale_triangular_mesh_graph, + create_hierarchical_triangular_mesh_graph, + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_graph, + create_single_level_2d_triangular_mesh_primitive, +) + + +# =========================== +# Fixtures +# =========================== + + +@pytest.fixture +def xy_small(): + """Small 10x10 domain with 4 corner grid points.""" + return np.array([[0, 0], [10, 0], [0, 10], [10, 10]], dtype=float) + + +@pytest.fixture +def xy_medium(): + """Medium domain with many grid points.""" + return test_utils.create_fake_xy(N=20) + + +@pytest.fixture +def xy_rectangular(): + """Non-square domain.""" + return test_utils.create_rectangular_fake_xy(Nx=15, Ny=10) + + +@pytest.fixture +def xy_offset(): + """Domain not starting at origin.""" + return np.array([[5, 3], [15, 3], [5, 13], [15, 13]], dtype=float) + + +@pytest.fixture +def xy_large(): + """Larger domain with many grid points.""" + return test_utils.create_fake_xy(N=50) + + +@pytest.fixture +def xy_wide(): + """Very wide, short domain.""" + return test_utils.create_rectangular_fake_xy(Nx=30, Ny=5) + + +# =========================== +# Step 1: Triangular Primitive (Coordinate Creation) +# =========================== + + +class TestTriangularPrimitive: + """Tests for create_single_level_2d_triangular_mesh_primitive.""" + + def test_returns_undirected_graph(self, xy_small): + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + assert isinstance(G, nx.Graph) + assert not isinstance(G, nx.DiGraph) + + def test_nodes_have_pos_and_type(self, xy_small): + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=4, ny=4) + for node in G.nodes: + assert "pos" in G.nodes[node] + assert "type" in G.nodes[node] + assert G.nodes[node]["type"] == "mesh" + pos = G.nodes[node]["pos"] + assert len(pos) == 2 + assert np.isfinite(pos).all() + + def test_nonzero_node_count(self, xy_small): + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + assert G.number_of_nodes() > 0 + + def test_has_edges(self, xy_small): + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + assert G.number_of_edges() > 0 + + def test_all_edges_are_cardinal(self, xy_small): + """Triangular lattice has only cardinal edges (no diagonal distinction).""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + for u, v, d in G.edges(data=True): + assert "adjacency_type" in d, f"Edge ({u}, {v}) missing adjacency_type" + assert d["adjacency_type"] == "cardinal" + + def test_graph_has_dx_dy(self, xy_small): + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + assert "dx" in G.graph + assert "dy" in G.graph + assert G.graph["dx"] > 0 + assert G.graph["dy"] > 0 + + def test_positions_within_domain(self, xy_small): + """Mesh node positions should lie within the coordinate domain.""" + xm, xM = xy_small[:, 0].min(), xy_small[:, 0].max() + ym, yM = xy_small[:, 1].min(), xy_small[:, 1].max() + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + for node in G.nodes: + pos = G.nodes[node]["pos"] + assert xm <= pos[0] <= xM, f"x={pos[0]} out of [{xm}, {xM}]" + assert ym <= pos[1] <= yM, f"y={pos[1]} out of [{ym}, {yM}]" + + def test_raises_on_zero_nodes(self): + """nx=0 or ny=0 should produce 0 nodes and raise.""" + xy = np.array([[0, 0], [1, 0], [0, 1], [1, 1]], dtype=float) + with pytest.raises(ValueError, match="produced 0 nodes"): + create_single_level_2d_triangular_mesh_primitive(xy, nx=0, ny=0) + + def test_rectangular_domain(self, xy_rectangular): + """Works with non-square domains.""" + G = create_single_level_2d_triangular_mesh_primitive( + xy_rectangular, nx=8, ny=5 + ) + assert G.number_of_nodes() > 0 + assert G.number_of_edges() > 0 + + def test_minimal_lattice(self, xy_small): + """Smallest valid lattice (nx=1, ny=1) should produce nodes and edges.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=1, ny=1) + assert G.number_of_nodes() >= 2 + assert G.number_of_edges() >= 1 + + def test_large_lattice(self, xy_small): + """Large nx/ny values should produce many nodes.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=20, ny=20) + assert G.number_of_nodes() > 100 + + def test_asymmetric_nx_ny(self, xy_small): + """Very different nx and ny should still work.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=15, ny=3) + assert G.number_of_nodes() > 0 + assert G.number_of_edges() > 0 + + def test_offset_domain(self, xy_offset): + """Domain not starting at origin: positions should still be within bounds.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_offset, nx=5, ny=5) + xm, xM = 5.0, 15.0 + ym, yM = 3.0, 13.0 + for node in G.nodes: + pos = G.nodes[node]["pos"] + assert xm <= pos[0] <= xM + assert ym <= pos[1] <= yM + + def test_positions_are_numpy_arrays(self, xy_small): + """Node positions should be numpy arrays.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=4, ny=4) + for node in G.nodes: + assert isinstance(G.nodes[node]["pos"], np.ndarray) + + def test_no_self_loops(self, xy_small): + """Primitive graph should have no self-loops.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + for u, v in G.edges(): + assert u != v + + def test_wide_domain(self, xy_wide): + """Very wide, short domain should still produce valid mesh.""" + G = create_single_level_2d_triangular_mesh_primitive(xy_wide, nx=10, ny=3) + assert G.number_of_nodes() > 0 + for node in G.nodes: + pos = G.nodes[node]["pos"] + assert np.isfinite(pos).all() + + +# =========================== +# Step 2: Directed Mesh Graph (Connectivity Creation) +# =========================== + + +class TestTriangularDirectedGraph: + """Tests for directed graph creation from triangular primitives.""" + + def test_returns_digraph(self, xy_small): + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + assert isinstance(G, nx.DiGraph) + + def test_edges_are_bidirectional(self, xy_small): + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for u, v in G.edges(): + assert G.has_edge(v, u), f"Edge ({u}, {v}) missing reverse" + + def test_edges_have_len_and_vdiff(self, xy_small): + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for u, v, d in G.edges(data=True): + assert "len" in d, f"Edge ({u}, {v}) missing 'len'" + assert "vdiff" in d, f"Edge ({u}, {v}) missing 'vdiff'" + assert d["len"] > 0 + assert len(d["vdiff"]) == 2 + + def test_len_symmetry(self, xy_small): + """Edge length should be the same in both directions.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for u, v in G.edges(): + if G.has_edge(v, u): + np.testing.assert_allclose( + G[u][v]["len"], G[v][u]["len"], atol=1e-10 + ) + + def test_vdiff_reciprocity(self, xy_small): + """vdiff(uΓåÆv) should equal -vdiff(vΓåÆu).""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for u, v in G.edges(): + if G.has_edge(v, u): + np.testing.assert_allclose( + G[u][v]["vdiff"], -G[v][u]["vdiff"], atol=1e-10 + ) + + def test_pattern_4star_equals_8star(self, xy_small): + """For triangular lattice, 4-star and 8-star should produce identical + graphs since all edges are 'cardinal'.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G4 = create_directed_mesh_graph(G_coords, pattern="4-star") + G8 = create_directed_mesh_graph(G_coords, pattern="8-star") + assert G4.number_of_nodes() == G8.number_of_nodes() + assert G4.number_of_edges() == G8.number_of_edges() + + def test_node_count_preserved(self, xy_small): + """Directed graph should have same number of nodes as primitive.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + assert G.number_of_nodes() == G_coords.number_of_nodes() + + def test_edge_count_is_twice_undirected(self, xy_small): + """Directed graph should have exactly 2x the undirected edge count.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + assert G.number_of_edges() == 2 * G_coords.number_of_edges() + + def test_no_self_loops_directed(self, xy_small): + """Directed graph should have no self-loops.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for u, v in G.edges(): + assert u != v + + def test_pos_preserved_after_direction(self, xy_small): + """Node positions should be preserved after converting to directed.""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=5, ny=5 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + for node in G.nodes: + assert "pos" in G.nodes[node] + assert len(G.nodes[node]["pos"]) == 2 + + def test_interior_node_degree_six(self, xy_small): + """Interior nodes of a triangular lattice should have degree 6 + (6 in-edges + 6 out-edges = 12 total in directed graph).""" + G_coords = create_single_level_2d_triangular_mesh_primitive( + xy_small, nx=8, ny=8 + ) + G = create_directed_mesh_graph(G_coords, pattern="4-star") + # At least one interior node should have degree 12 (6 in + 6 out) + max_deg = max(dict(G.degree()).values()) + assert max_deg == 12 + + def test_minimal_lattice_directed(self, xy_small): + """Minimal lattice (nx=1, ny=1) should still produce a valid directed graph.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=1, ny=1) + assert isinstance(G, nx.DiGraph) + assert G.number_of_nodes() >= 2 + assert G.number_of_edges() >= 2 # at least one bidirectional edge + + +# =========================== +# Multirange primitives +# =========================== + + +class TestMultirangeTriangularPrimitives: + """Tests for create_multirange_2d_triangular_mesh_primitives.""" + + def test_returns_list(self, xy_medium): + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + assert isinstance(G_list, list) + assert len(G_list) >= 1 + + def test_each_level_is_undirected(self, xy_medium): + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + for G in G_list: + assert isinstance(G, nx.Graph) + assert not isinstance(G, nx.DiGraph) + + def test_level_attributes_set(self, xy_medium): + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + for lev, G in enumerate(G_list): + assert G.graph["level"] == lev + for node in G.nodes: + assert G.nodes[node]["level"] == lev + for u, v in G.edges(): + assert G.edges[u, v]["level"] == lev + + def test_finer_level_has_more_nodes(self, xy_medium): + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + if len(G_list) > 1: + assert G_list[0].number_of_nodes() > G_list[1].number_of_nodes() + + def test_max_num_levels_respected(self, xy_medium): + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=2, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + assert len(G_list) <= 2 + + def test_single_level(self, xy_medium): + """max_num_levels=1 should produce exactly 1 level.""" + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=1, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + assert len(G_list) == 1 + assert G_list[0].graph["level"] == 0 + + def test_refinement_factor_2(self, xy_medium): + """Different refinement factor should still produce valid graphs.""" + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=2, + ) + assert len(G_list) >= 1 + for G in G_list: + assert G.number_of_nodes() > 0 + + def test_all_levels_cover_same_domain(self, xy_medium): + """All levels should span approximately the same coordinate domain.""" + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + if len(G_list) < 2: + pytest.skip("Only one level created") + # Check centers are roughly the same across levels + centers = [] + for G in G_list: + positions = np.array([G.nodes[n]["pos"] for n in G.nodes]) + centers.append(positions.mean(axis=0)) + for c in centers[1:]: + np.testing.assert_allclose(c, centers[0], atol=2.0) + + def test_interlevel_refinement_factor_preserved(self, xy_medium): + """Each level should have the refinement factor as a graph attribute.""" + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + for G in G_list: + assert G.graph["interlevel_refinement_factor"] == 3 + + def test_all_levels_have_edges(self, xy_medium): + """Every level should have at least some edges.""" + G_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + for G in G_list: + assert G.number_of_edges() > 0 + + +# =========================== +# Convenience wrapper: single-level +# =========================== + + +class TestSingleLevelTriangularGraph: + """Tests for create_single_level_2d_triangular_mesh_graph.""" + + def test_returns_digraph(self, xy_small): + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + assert isinstance(G, nx.DiGraph) + + def test_has_bidirectional_edges(self, xy_small): + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + for u, v in G.edges(): + assert G.has_edge(v, u) + + def test_edges_have_attributes(self, xy_small): + """Directed graph edges should have len and vdiff.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + for u, v, d in G.edges(data=True): + assert "len" in d + assert "vdiff" in d + + def test_with_rectangular_domain(self, xy_rectangular): + """Should work correctly on non-square domains.""" + G = create_single_level_2d_triangular_mesh_graph(xy_rectangular, nx=8, ny=5) + assert isinstance(G, nx.DiGraph) + assert G.number_of_edges() > 0 + + def test_minimal_grid(self, xy_small): + """Minimal grid (nx=1, ny=1) should produce a valid graph.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=1, ny=1) + assert G.number_of_nodes() >= 2 + + +# =========================== +# Flat single-scale +# =========================== + + +class TestFlatSinglescaleTriangular: + """Tests for create_flat_singlescale_triangular_mesh_graph.""" + + def test_returns_digraph(self, xy_small): + G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + assert isinstance(G, nx.DiGraph) + + def test_nodes_have_pos(self, xy_small): + G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + for node in G.nodes: + assert "pos" in G.nodes[node] + + def test_raises_on_large_spacing(self, xy_small): + """Spacing larger than domain should raise.""" + with pytest.raises(ValueError, match="too large"): + create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=100.0 + ) + + def test_edges_are_bidirectional(self, xy_small): + """All edges should have a reverse.""" + G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + for u, v in G.edges(): + assert G.has_edge(v, u) + + def test_smaller_spacing_more_nodes(self, xy_small): + """Smaller mesh_node_distance should produce more nodes.""" + G_coarse = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=3.0 + ) + G_fine = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=1.5 + ) + assert G_fine.number_of_nodes() > G_coarse.number_of_nodes() + + def test_rectangular_domain(self, xy_rectangular): + """Should work with non-square domains.""" + G = create_flat_singlescale_triangular_mesh_graph( + xy_rectangular, mesh_node_distance=2.0 + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_nodes() > 0 + + def test_no_nan_positions(self, xy_small): + """No node should have NaN or Inf positions.""" + G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + for node in G.nodes: + pos = G.nodes[node]["pos"] + assert np.isfinite(pos).all() + + def test_spacing_just_fits(self): + """Spacing that just fits one cell should work.""" + xy = np.array([[0, 0], [5, 0], [0, 5], [5, 5]], dtype=float) + G = create_flat_singlescale_triangular_mesh_graph(xy, mesh_node_distance=4.0) + assert G.number_of_nodes() >= 2 + + +# =========================== +# Flat multiscale (triangular-specific merging) +# =========================== + + +class TestFlatMultiscaleTriangular: + """Tests for the triangular flat multiscale graph and position-based merging.""" + + def test_returns_digraph(self, xy_medium): + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert isinstance(G, nx.DiGraph) + + def test_has_edges(self, xy_medium): + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert G.number_of_edges() > 0 + + def test_edges_have_len_and_vdiff(self, xy_medium): + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v, d in G.edges(data=True): + assert "len" in d + assert "vdiff" in d + + def test_fewer_nodes_than_sum_of_levels(self, xy_medium): + """Position-based merging should produce fewer nodes than the raw + sum of all levels (coincident nodes get merged).""" + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + total_raw = sum(g.number_of_nodes() for g in G_coords_list) + G = create_flat_multiscale_from_triangular_coordinates(G_coords_list) + # Merged graph has at most as many nodes (usually fewer) + assert G.number_of_nodes() <= total_raw + + def test_graph_has_dx_dy_dicts(self, xy_medium): + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert isinstance(G.graph.get("dx"), dict) + assert isinstance(G.graph.get("dy"), dict) + + def test_bidirectional_edges(self, xy_medium): + """All edges should have a reverse.""" + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v in G.edges(): + assert G.has_edge(v, u), f"Edge ({u},{v}) no reverse" + + def test_nodes_have_pos(self, xy_medium): + """All nodes should have pos attribute.""" + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for node in G.nodes: + assert "pos" in G.nodes[node] + assert np.isfinite(G.nodes[node]["pos"]).all() + + def test_single_level_multiscale(self): + """When domain only supports 1 level, flat_multiscale should still work.""" + xy = np.array([[0, 0], [3, 0], [0, 3], [3, 3]], dtype=float) + G = create_flat_multiscale_triangular_mesh_graph( + xy, mesh_node_distance=1.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_nodes() > 0 + + def test_refinement_factor_2(self, xy_medium): + """Refinement factor of 2 should work.""" + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=2, max_num_levels=3, + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_edges() > 0 + + def test_no_self_loops(self, xy_medium): + """No self-loops in flat multiscale graph.""" + G = create_flat_multiscale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v in G.edges(): + assert u != v + + def test_more_nodes_than_coarsest_level(self, xy_large): + """Multiscale should have more nodes than the coarsest single level.""" + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=3, xy=xy_large, mesh_node_spacing=2, + interlevel_refinement_factor=3, + ) + if len(G_coords_list) < 2: + pytest.skip("Only one level created") + coarsest_nodes = G_coords_list[-1].number_of_nodes() + G_multi = create_flat_multiscale_from_triangular_coordinates(G_coords_list) + assert G_multi.number_of_nodes() > coarsest_nodes + + +# =========================== +# Hierarchical +# =========================== + + +class TestHierarchicalTriangular: + """Tests for create_hierarchical_triangular_mesh_graph.""" + + def test_returns_digraph(self, xy_medium): + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert isinstance(G, nx.DiGraph) + + def test_has_edges(self, xy_medium): + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + assert G.number_of_edges() > 0 + + def test_edges_have_level_attribute(self, xy_medium): + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v, d in G.edges(data=True): + # Intra-level edges have 'level', inter-level have 'levels' + assert "level" in d or "levels" in d + + def test_multiple_levels_present(self, xy_medium): + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + levels = set() + for u, v, d in G.edges(data=True): + if "level" in d: + levels.add(d["level"]) + elif "levels" in d: + # Inter-level edges like '0>1' + parts = d["levels"].split(">") + levels.update(int(p) for p in parts) + assert len(levels) >= 2, "Expected multiple levels in hierarchical graph" + + def test_single_level_raises(self, xy_small): + """Hierarchical requires ΓëÑ2 levels; too-coarse spacing should raise.""" + with pytest.raises(ValueError): + create_hierarchical_triangular_mesh_graph( + xy_small, mesh_node_distance=20.0, + level_refinement_factor=3, max_num_levels=3, + ) + + def test_nodes_have_pos(self, xy_medium): + """All nodes should have pos attribute.""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for node in G.nodes: + assert "pos" in G.nodes[node] + assert np.isfinite(G.nodes[node]["pos"]).all() + + def test_custom_intra_level(self, xy_medium): + """Custom intra_level pattern should be accepted.""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + intra_level={"pattern": "8-star"}, + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_edges() > 0 + + def test_custom_inter_level(self, xy_medium): + """Custom inter_level config should be accepted.""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + inter_level={"pattern": "nearest", "k": 3}, + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_edges() > 0 + + def test_no_self_loops(self, xy_medium): + """Hierarchical graph should have no self-loops.""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v in G.edges(): + assert u != v + + def test_has_inter_level_edges(self, xy_medium): + """Should have inter-level edges connecting different levels.""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + inter_level_count = sum( + 1 for _, _, d in G.edges(data=True) if "levels" in d + ) + assert inter_level_count > 0 + + def test_inter_level_edges_have_direction(self, xy_medium): + """Inter-level edges should have 'direction' attribute (up/down).""" + G = create_hierarchical_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0, + level_refinement_factor=3, max_num_levels=3, + ) + for u, v, d in G.edges(data=True): + if "levels" in d: + assert "direction" in d + assert d["direction"] in ("up", "down") + + +# =========================== +# Integration: create_all_graph_components +# =========================== + + +class TestIntegrationTriangular: + """Full integration tests through create_all_graph_components.""" + + COMMON_KW = dict( + m2g_connectivity="nearest_neighbours", + g2m_connectivity="nearest_neighbours", + m2g_connectivity_kwargs=dict(max_num_neighbours=4), + g2m_connectivity_kwargs=dict(max_num_neighbours=4), + return_components=True, + ) + + def test_flat_triangular(self, xy_medium): + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + **self.COMMON_KW, + ) + m2m = comps["m2m"] + assert isinstance(m2m, nx.DiGraph) + assert m2m.number_of_nodes() > 0 + assert m2m.number_of_edges() > 0 + # Should also have g2m and m2g + assert comps["g2m"].number_of_edges() > 0 + assert comps["m2g"].number_of_edges() > 0 + + def test_hierarchical_triangular(self, xy_medium): + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="hierarchical", + mesh_layout="triangular", + mesh_layout_kwargs=dict( + mesh_node_spacing=2.0, max_num_refinement_levels=3 + ), + **self.COMMON_KW, + ) + m2m = comps["m2m"] + assert isinstance(m2m, nx.DiGraph) + assert m2m.number_of_nodes() > 0 + + def test_flat_multiscale_triangular(self, xy_medium): + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat_multiscale", + mesh_layout="triangular", + mesh_layout_kwargs=dict( + mesh_node_spacing=2.0, max_num_refinement_levels=3 + ), + **self.COMMON_KW, + ) + m2m = comps["m2m"] + assert isinstance(m2m, nx.DiGraph) + assert m2m.number_of_nodes() > 0 + + def test_unsupported_layout_raises(self, xy_small): + with pytest.raises(NotImplementedError, match="not yet supported"): + wmg.create.create_all_graph_components( + coords=xy_small, + m2m_connectivity="flat", + mesh_layout="hexagonal", + mesh_layout_kwargs=dict(mesh_node_spacing=1.0), + **self.COMMON_KW, + ) + + def test_flat_triangular_return_combined(self, xy_medium): + """With return_components=False, returns a single composed graph.""" + kw = dict(self.COMMON_KW) + kw["return_components"] = False + G = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + **kw, + ) + assert isinstance(G, nx.DiGraph) + assert G.number_of_nodes() > 0 + + def test_flat_pattern_kwarg_forwarded(self, xy_medium): + """m2m_connectivity_kwargs={'pattern': ...} should be forwarded.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + m2m_connectivity_kwargs=dict(pattern="8-star"), + **self.COMMON_KW, + ) + assert comps["m2m"].number_of_edges() > 0 + + def test_rectilinear_still_works(self, xy_medium): + """Regression: rectilinear layout should not be broken.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="rectilinear", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + **self.COMMON_KW, + ) + assert comps["m2m"].number_of_nodes() > 0 + + def test_rectilinear_flat_multiscale_still_works(self, xy_medium): + """Regression: rectilinear flat_multiscale should not be broken.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat_multiscale", + mesh_layout="rectilinear", + mesh_layout_kwargs=dict( + mesh_node_spacing=2.0, max_num_refinement_levels=3 + ), + **self.COMMON_KW, + ) + assert comps["m2m"].number_of_nodes() > 0 + + def test_rectilinear_hierarchical_still_works(self, xy_medium): + """Regression: rectilinear hierarchical should not be broken.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="hierarchical", + mesh_layout="rectilinear", + mesh_layout_kwargs=dict( + mesh_node_spacing=2.0, max_num_refinement_levels=3 + ), + **self.COMMON_KW, + ) + assert comps["m2m"].number_of_nodes() > 0 + + def test_flat_triangular_with_within_radius(self, xy_medium): + """Triangular flat with within_radius g2m/m2g connectivity.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + m2g_connectivity="within_radius", + g2m_connectivity="within_radius", + m2g_connectivity_kwargs=dict(max_dist=5.0), + g2m_connectivity_kwargs=dict(max_dist=5.0), + return_components=True, + ) + assert comps["m2m"].number_of_nodes() > 0 + assert comps["g2m"].number_of_edges() > 0 + assert comps["m2g"].number_of_edges() > 0 + + def test_flat_triangular_with_nearest_neighbour(self, xy_medium): + """Triangular flat with nearest_neighbour (singular) connectivity.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + m2g_connectivity="nearest_neighbour", + g2m_connectivity="nearest_neighbour", + return_components=True, + ) + assert comps["m2m"].number_of_nodes() > 0 + assert comps["g2m"].number_of_edges() > 0 + + def test_flat_no_mesh_node_spacing_raises(self, xy_small): + """Missing mesh_node_spacing should raise ValueError.""" + with pytest.raises(ValueError, match="mesh_node_spacing"): + wmg.create.create_all_graph_components( + coords=xy_small, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(), + **self.COMMON_KW, + ) + + def test_flat_multiscale_no_mesh_node_spacing_raises(self, xy_small): + """Missing mesh_node_spacing in flat_multiscale should raise ValueError.""" + with pytest.raises(ValueError, match="mesh_node_spacing"): + wmg.create.create_all_graph_components( + coords=xy_small, + m2m_connectivity="flat_multiscale", + mesh_layout="triangular", + mesh_layout_kwargs=dict(max_num_refinement_levels=3), + **self.COMMON_KW, + ) + + def test_hierarchical_no_mesh_node_spacing_raises(self, xy_small): + """Missing mesh_node_spacing in hierarchical should raise ValueError.""" + with pytest.raises(ValueError, match="mesh_node_spacing"): + wmg.create.create_all_graph_components( + coords=xy_small, + m2m_connectivity="hierarchical", + mesh_layout="triangular", + mesh_layout_kwargs=dict(max_num_refinement_levels=3), + **self.COMMON_KW, + ) + + def test_all_components_have_nodes(self, xy_medium): + """All three components (g2m, m2m, m2g) should have nodes.""" + comps = wmg.create.create_all_graph_components( + coords=xy_medium, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=2.0), + **self.COMMON_KW, + ) + for key in ("g2m", "m2m", "m2g"): + assert comps[key].number_of_nodes() > 0 + assert comps[key].number_of_edges() > 0 + + def test_large_domain_triangular(self, xy_large): + """Large domain with small spacing should produce a big graph.""" + comps = wmg.create.create_all_graph_components( + coords=xy_large, + m2m_connectivity="flat", + mesh_layout="triangular", + mesh_layout_kwargs=dict(mesh_node_spacing=3.0), + **self.COMMON_KW, + ) + assert comps["m2m"].number_of_nodes() > 50 + + +# =========================== +# Numerical correctness +# =========================== + + +class TestNumericalCorrectness: + """Test numerical properties of the triangular mesh graph.""" + + def test_edge_lengths_positive(self, xy_medium): + G = create_flat_singlescale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0 + ) + for u, v, d in G.edges(data=True): + assert d["len"] > 0 + + def test_vdiff_consistent_with_pos(self, xy_small): + """vdiff should equal pos(u) - pos(v).""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + for u, v, d in G.edges(data=True): + pos_u = G.nodes[u]["pos"] + pos_v = G.nodes[v]["pos"] + expected_vdiff = pos_u - pos_v + np.testing.assert_allclose(d["vdiff"], expected_vdiff, atol=1e-10) + + def test_len_consistent_with_vdiff(self, xy_small): + """len should equal the L2 norm of vdiff.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + for u, v, d in G.edges(data=True): + expected_len = np.linalg.norm(d["vdiff"]) + np.testing.assert_allclose(d["len"], expected_len, atol=1e-10) + + def test_no_nan_in_edge_attrs(self, xy_small): + """Edge attributes should contain no NaN or Inf.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=6, ny=6) + for u, v, d in G.edges(data=True): + assert np.isfinite(d["len"]) + assert np.isfinite(d["vdiff"]).all() + + def test_no_zero_length_edges(self, xy_small): + """All edges should have strictly positive length.""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=6, ny=6) + for u, v, d in G.edges(data=True): + assert d["len"] > 1e-12 + + def test_edge_lengths_roughly_uniform_for_interior(self, xy_small): + """For a uniform triangular lattice, all edges should have similar + length (within a narrow tolerance, accounting for scaling).""" + G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=8, ny=8) + lengths = [d["len"] for _, _, d in G.edges(data=True)] + # In a uniformly scaled equilateral mesh, all edges should be + # within ~50% of each other (accounting for aspect ratio scaling) + max_len = max(lengths) + min_len = min(lengths) + assert min_len > 0 + ratio = max_len / min_len + # For equilateral triangles with potentially different x/y scaling, + # the ratio should still be reasonable + assert ratio < 3.0, f"Edge length ratio {ratio} too large" + + def test_scaled_domain_produces_scaled_lengths(self): + """Doubling the domain should roughly double edge lengths.""" + xy1 = np.array([[0, 0], [10, 0], [0, 10], [10, 10]], dtype=float) + xy2 = np.array([[0, 0], [20, 0], [0, 20], [20, 20]], dtype=float) + G1 = create_single_level_2d_triangular_mesh_graph(xy1, nx=5, ny=5) + G2 = create_single_level_2d_triangular_mesh_graph(xy2, nx=5, ny=5) + avg_len1 = np.mean([d["len"] for _, _, d in G1.edges(data=True)]) + avg_len2 = np.mean([d["len"] for _, _, d in G2.edges(data=True)]) + np.testing.assert_allclose(avg_len2 / avg_len1, 2.0, rtol=0.1) + + def test_no_nan_in_positions(self, xy_medium): + """No node should have NaN in positions.""" + G = create_flat_singlescale_triangular_mesh_graph( + xy_medium, mesh_node_distance=2.0 + ) + for node in G.nodes: + pos = G.nodes[node]["pos"] + assert isinstance(pos, np.ndarray) + assert np.isfinite(pos).all() From 743ec1b6e88060ed18dd806114aa1d80ebad9888 Mon Sep 17 00:00:00 2001 From: prajwal Date: Fri, 5 Jun 2026 22:50:57 +0530 Subject: [PATCH 02/16] style: apply isort and black formatting --- src/weather_model_graphs/create/base.py | 8 +- .../create/mesh/__init__.py | 13 +- .../create/mesh/connectivity/triangular.py | 36 ++- tests/test_triangular_mesh.py | 213 +++++++++++------- 4 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index fc1baef..1b9374b 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -361,7 +361,9 @@ def create_all_graph_components( # Step 2: Connectivity creation — converts mesh primitives to directed graph # ----------------------------------------------------------------------- if m2m_connectivity == "flat": - pattern = m2m_connectivity_kwargs.get("pattern", "4-star" if mesh_layout == "triangular" else "8-star") + pattern = m2m_connectivity_kwargs.get( + "pattern", "4-star" if mesh_layout == "triangular" else "8-star" + ) graph_components["m2m"] = create_flat_singlescale_from_coordinates( G_mesh_coords, pattern=pattern ) @@ -393,7 +395,9 @@ def create_all_graph_components( if pattern is None: pattern = "4-star" if mesh_layout == "triangular" else "8-star" if mesh_layout == "triangular": - graph_components["m2m"] = create_flat_multiscale_from_triangular_coordinates( + graph_components[ + "m2m" + ] = create_flat_multiscale_from_triangular_coordinates( G_mesh_coords, pattern=pattern ) else: diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index e1f52e4..b084768 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -1,10 +1,3 @@ -from .coords import ( - create_directed_mesh_graph, - create_multirange_2d_mesh_primitives, - create_single_level_2d_mesh_graph, - create_single_level_2d_mesh_primitive, -) - from .connectivity.triangular import ( create_flat_multiscale_from_triangular_coordinates, create_flat_multiscale_triangular_mesh_graph, @@ -14,3 +7,9 @@ create_single_level_2d_triangular_mesh_graph, create_single_level_2d_triangular_mesh_primitive, ) +from .coords import ( + create_directed_mesh_graph, + create_multirange_2d_mesh_primitives, + create_single_level_2d_mesh_graph, + create_single_level_2d_mesh_primitive, +) diff --git a/src/weather_model_graphs/create/mesh/connectivity/triangular.py b/src/weather_model_graphs/create/mesh/connectivity/triangular.py index eb98dbe..e90dab6 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/triangular.py +++ b/src/weather_model_graphs/create/mesh/connectivity/triangular.py @@ -109,10 +109,12 @@ def create_single_level_2d_triangular_mesh_primitive( g = networkx.Graph() for node in g_raw.nodes(): raw_pos = g_raw.nodes[node]["pos"] - pos = np.array([ - offset_x + (raw_pos[0] - raw_xmin) * scale_x, - offset_y + (raw_pos[1] - raw_ymin) * scale_y, - ]) + pos = np.array( + [ + offset_x + (raw_pos[0] - raw_xmin) * scale_x, + offset_y + (raw_pos[1] - raw_ymin) * scale_y, + ] + ) g.add_node(node, pos=pos, type="mesh") for u, v in g_raw.edges(): @@ -164,24 +166,18 @@ def create_multirange_2d_triangular_mesh_primitives( interlevel_refinement_factor ) max_mesh_levels = max_mesh_levels_float.astype(int) - nleaf = interlevel_refinement_factor ** max_mesh_levels + nleaf = interlevel_refinement_factor**max_mesh_levels mesh_levels_to_create = max_mesh_levels.min() if max_num_levels: mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) - logger.debug( - f"triangular mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}" - ) + logger.debug(f"triangular mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}") G_all_levels = [] for lev in range(mesh_levels_to_create): - nodes_x, nodes_y = ( - nleaf / (interlevel_refinement_factor ** lev) - ).astype(int) - g = create_single_level_2d_triangular_mesh_primitive( - xy, nodes_x, nodes_y - ) + nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) + g = create_single_level_2d_triangular_mesh_primitive(xy, nodes_x, nodes_y) for node in g.nodes: g.nodes[node]["level"] = lev for edge in g.edges: @@ -289,15 +285,11 @@ def create_flat_multiscale_from_triangular_coordinates( Flat multiscale triangular mesh graph. """ # Convert each level to directed graph - G_directed = [ - create_directed_mesh_graph(g, pattern=pattern) - for g in G_coords_list - ] + G_directed = [create_directed_mesh_graph(g, pattern=pattern) for g in G_coords_list] # Prepend level index to make node labels unique across levels G_directed = [ - prepend_node_index(g, level_i) - for level_i, g in enumerate(G_directed) + prepend_node_index(g, level_i) for level_i, g in enumerate(G_directed) ] # Build merged graph, starting from finest level @@ -308,9 +300,7 @@ def create_flat_multiscale_from_triangular_coordinates( # KDTree of existing (finer) nodes for position matching fine_nodes = list(G_tot.nodes()) - fine_positions = np.array( - [G_tot.nodes[n]["pos"] for n in fine_nodes] - ) + fine_positions = np.array([G_tot.nodes[n]["pos"] for n in fine_nodes]) kdt = scipy.spatial.KDTree(fine_positions) # Find which coarse nodes coincide with existing fine nodes diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py index 40308a3..1e41ada 100644 --- a/tests/test_triangular_mesh.py +++ b/tests/test_triangular_mesh.py @@ -33,7 +33,6 @@ create_single_level_2d_triangular_mesh_primitive, ) - # =========================== # Fixtures # =========================== @@ -138,9 +137,7 @@ def test_raises_on_zero_nodes(self): def test_rectangular_domain(self, xy_rectangular): """Works with non-square domains.""" - G = create_single_level_2d_triangular_mesh_primitive( - xy_rectangular, nx=8, ny=5 - ) + G = create_single_level_2d_triangular_mesh_primitive(xy_rectangular, nx=8, ny=5) assert G.number_of_nodes() > 0 assert G.number_of_edges() > 0 @@ -234,9 +231,7 @@ def test_len_symmetry(self, xy_small): G = create_directed_mesh_graph(G_coords, pattern="4-star") for u, v in G.edges(): if G.has_edge(v, u): - np.testing.assert_allclose( - G[u][v]["len"], G[v][u]["len"], atol=1e-10 - ) + np.testing.assert_allclose(G[u][v]["len"], G[v][u]["len"], atol=1e-10) def test_vdiff_reciprocity(self, xy_small): """vdiff(uΓåÆv) should equal -vdiff(vΓåÆu).""" @@ -325,7 +320,9 @@ class TestMultirangeTriangularPrimitives: def test_returns_list(self, xy_medium): G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) assert isinstance(G_list, list) @@ -333,7 +330,9 @@ def test_returns_list(self, xy_medium): def test_each_level_is_undirected(self, xy_medium): G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) for G in G_list: @@ -342,7 +341,9 @@ def test_each_level_is_undirected(self, xy_medium): def test_level_attributes_set(self, xy_medium): G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) for lev, G in enumerate(G_list): @@ -354,7 +355,9 @@ def test_level_attributes_set(self, xy_medium): def test_finer_level_has_more_nodes(self, xy_medium): G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) if len(G_list) > 1: @@ -362,7 +365,9 @@ def test_finer_level_has_more_nodes(self, xy_medium): def test_max_num_levels_respected(self, xy_medium): G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=2, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=2, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) assert len(G_list) <= 2 @@ -370,7 +375,9 @@ def test_max_num_levels_respected(self, xy_medium): def test_single_level(self, xy_medium): """max_num_levels=1 should produce exactly 1 level.""" G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=1, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=1, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) assert len(G_list) == 1 @@ -379,7 +386,9 @@ def test_single_level(self, xy_medium): def test_refinement_factor_2(self, xy_medium): """Different refinement factor should still produce valid graphs.""" G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=2, ) assert len(G_list) >= 1 @@ -389,7 +398,9 @@ def test_refinement_factor_2(self, xy_medium): def test_all_levels_cover_same_domain(self, xy_medium): """All levels should span approximately the same coordinate domain.""" G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) if len(G_list) < 2: @@ -405,7 +416,9 @@ def test_all_levels_cover_same_domain(self, xy_medium): def test_interlevel_refinement_factor_preserved(self, xy_medium): """Each level should have the refinement factor as a graph attribute.""" G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) for G in G_list: @@ -414,7 +427,9 @@ def test_interlevel_refinement_factor_preserved(self, xy_medium): def test_all_levels_have_edges(self, xy_medium): """Every level should have at least some edges.""" G_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) for G in G_list: @@ -466,11 +481,15 @@ class TestFlatSinglescaleTriangular: """Tests for create_flat_singlescale_triangular_mesh_graph.""" def test_returns_digraph(self, xy_small): - G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + G = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=2.0 + ) assert isinstance(G, nx.DiGraph) def test_nodes_have_pos(self, xy_small): - G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + G = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=2.0 + ) for node in G.nodes: assert "pos" in G.nodes[node] @@ -483,7 +502,9 @@ def test_raises_on_large_spacing(self, xy_small): def test_edges_are_bidirectional(self, xy_small): """All edges should have a reverse.""" - G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + G = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=2.0 + ) for u, v in G.edges(): assert G.has_edge(v, u) @@ -507,7 +528,9 @@ def test_rectangular_domain(self, xy_rectangular): def test_no_nan_positions(self, xy_small): """No node should have NaN or Inf positions.""" - G = create_flat_singlescale_triangular_mesh_graph(xy_small, mesh_node_distance=2.0) + G = create_flat_singlescale_triangular_mesh_graph( + xy_small, mesh_node_distance=2.0 + ) for node in G.nodes: pos = G.nodes[node]["pos"] assert np.isfinite(pos).all() @@ -529,22 +552,28 @@ class TestFlatMultiscaleTriangular: def test_returns_digraph(self, xy_medium): G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) assert isinstance(G, nx.DiGraph) def test_has_edges(self, xy_medium): G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) assert G.number_of_edges() > 0 def test_edges_have_len_and_vdiff(self, xy_medium): G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v, d in G.edges(data=True): assert "len" in d @@ -554,7 +583,9 @@ def test_fewer_nodes_than_sum_of_levels(self, xy_medium): """Position-based merging should produce fewer nodes than the raw sum of all levels (coincident nodes get merged).""" G_coords_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_medium, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_medium, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) total_raw = sum(g.number_of_nodes() for g in G_coords_list) @@ -564,8 +595,10 @@ def test_fewer_nodes_than_sum_of_levels(self, xy_medium): def test_graph_has_dx_dy_dicts(self, xy_medium): G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) assert isinstance(G.graph.get("dx"), dict) assert isinstance(G.graph.get("dy"), dict) @@ -573,8 +606,10 @@ def test_graph_has_dx_dy_dicts(self, xy_medium): def test_bidirectional_edges(self, xy_medium): """All edges should have a reverse.""" G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v in G.edges(): assert G.has_edge(v, u), f"Edge ({u},{v}) no reverse" @@ -582,8 +617,10 @@ def test_bidirectional_edges(self, xy_medium): def test_nodes_have_pos(self, xy_medium): """All nodes should have pos attribute.""" G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for node in G.nodes: assert "pos" in G.nodes[node] @@ -593,8 +630,10 @@ def test_single_level_multiscale(self): """When domain only supports 1 level, flat_multiscale should still work.""" xy = np.array([[0, 0], [3, 0], [0, 3], [3, 3]], dtype=float) G = create_flat_multiscale_triangular_mesh_graph( - xy, mesh_node_distance=1.0, - level_refinement_factor=3, max_num_levels=3, + xy, + mesh_node_distance=1.0, + level_refinement_factor=3, + max_num_levels=3, ) assert isinstance(G, nx.DiGraph) assert G.number_of_nodes() > 0 @@ -602,8 +641,10 @@ def test_single_level_multiscale(self): def test_refinement_factor_2(self, xy_medium): """Refinement factor of 2 should work.""" G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=2, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=2, + max_num_levels=3, ) assert isinstance(G, nx.DiGraph) assert G.number_of_edges() > 0 @@ -611,8 +652,10 @@ def test_refinement_factor_2(self, xy_medium): def test_no_self_loops(self, xy_medium): """No self-loops in flat multiscale graph.""" G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v in G.edges(): assert u != v @@ -620,7 +663,9 @@ def test_no_self_loops(self, xy_medium): def test_more_nodes_than_coarsest_level(self, xy_large): """Multiscale should have more nodes than the coarsest single level.""" G_coords_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=3, xy=xy_large, mesh_node_spacing=2, + max_num_levels=3, + xy=xy_large, + mesh_node_spacing=2, interlevel_refinement_factor=3, ) if len(G_coords_list) < 2: @@ -640,22 +685,28 @@ class TestHierarchicalTriangular: def test_returns_digraph(self, xy_medium): G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) assert isinstance(G, nx.DiGraph) def test_has_edges(self, xy_medium): G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) assert G.number_of_edges() > 0 def test_edges_have_level_attribute(self, xy_medium): G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v, d in G.edges(data=True): # Intra-level edges have 'level', inter-level have 'levels' @@ -663,8 +714,10 @@ def test_edges_have_level_attribute(self, xy_medium): def test_multiple_levels_present(self, xy_medium): G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) levels = set() for u, v, d in G.edges(data=True): @@ -680,15 +733,19 @@ def test_single_level_raises(self, xy_small): """Hierarchical requires ΓëÑ2 levels; too-coarse spacing should raise.""" with pytest.raises(ValueError): create_hierarchical_triangular_mesh_graph( - xy_small, mesh_node_distance=20.0, - level_refinement_factor=3, max_num_levels=3, + xy_small, + mesh_node_distance=20.0, + level_refinement_factor=3, + max_num_levels=3, ) def test_nodes_have_pos(self, xy_medium): """All nodes should have pos attribute.""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for node in G.nodes: assert "pos" in G.nodes[node] @@ -697,8 +754,10 @@ def test_nodes_have_pos(self, xy_medium): def test_custom_intra_level(self, xy_medium): """Custom intra_level pattern should be accepted.""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, intra_level={"pattern": "8-star"}, ) assert isinstance(G, nx.DiGraph) @@ -707,8 +766,10 @@ def test_custom_intra_level(self, xy_medium): def test_custom_inter_level(self, xy_medium): """Custom inter_level config should be accepted.""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, inter_level={"pattern": "nearest", "k": 3}, ) assert isinstance(G, nx.DiGraph) @@ -717,8 +778,10 @@ def test_custom_inter_level(self, xy_medium): def test_no_self_loops(self, xy_medium): """Hierarchical graph should have no self-loops.""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v in G.edges(): assert u != v @@ -726,19 +789,21 @@ def test_no_self_loops(self, xy_medium): def test_has_inter_level_edges(self, xy_medium): """Should have inter-level edges connecting different levels.""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, - ) - inter_level_count = sum( - 1 for _, _, d in G.edges(data=True) if "levels" in d + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) + inter_level_count = sum(1 for _, _, d in G.edges(data=True) if "levels" in d) assert inter_level_count > 0 def test_inter_level_edges_have_direction(self, xy_medium): """Inter-level edges should have 'direction' attribute (up/down).""" G = create_hierarchical_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0, - level_refinement_factor=3, max_num_levels=3, + xy_medium, + mesh_node_distance=2.0, + level_refinement_factor=3, + max_num_levels=3, ) for u, v, d in G.edges(data=True): if "levels" in d: @@ -783,9 +848,7 @@ def test_hierarchical_triangular(self, xy_medium): coords=xy_medium, m2m_connectivity="hierarchical", mesh_layout="triangular", - mesh_layout_kwargs=dict( - mesh_node_spacing=2.0, max_num_refinement_levels=3 - ), + mesh_layout_kwargs=dict(mesh_node_spacing=2.0, max_num_refinement_levels=3), **self.COMMON_KW, ) m2m = comps["m2m"] @@ -797,9 +860,7 @@ def test_flat_multiscale_triangular(self, xy_medium): coords=xy_medium, m2m_connectivity="flat_multiscale", mesh_layout="triangular", - mesh_layout_kwargs=dict( - mesh_node_spacing=2.0, max_num_refinement_levels=3 - ), + mesh_layout_kwargs=dict(mesh_node_spacing=2.0, max_num_refinement_levels=3), **self.COMMON_KW, ) m2m = comps["m2m"] @@ -859,9 +920,7 @@ def test_rectilinear_flat_multiscale_still_works(self, xy_medium): coords=xy_medium, m2m_connectivity="flat_multiscale", mesh_layout="rectilinear", - mesh_layout_kwargs=dict( - mesh_node_spacing=2.0, max_num_refinement_levels=3 - ), + mesh_layout_kwargs=dict(mesh_node_spacing=2.0, max_num_refinement_levels=3), **self.COMMON_KW, ) assert comps["m2m"].number_of_nodes() > 0 @@ -872,9 +931,7 @@ def test_rectilinear_hierarchical_still_works(self, xy_medium): coords=xy_medium, m2m_connectivity="hierarchical", mesh_layout="rectilinear", - mesh_layout_kwargs=dict( - mesh_node_spacing=2.0, max_num_refinement_levels=3 - ), + mesh_layout_kwargs=dict(mesh_node_spacing=2.0, max_num_refinement_levels=3), **self.COMMON_KW, ) assert comps["m2m"].number_of_nodes() > 0 From ffc60d9d557317f967915ffaffbb5127688c31ad Mon Sep 17 00:00:00 2001 From: prajwal Date: Tue, 9 Jun 2026 13:12:52 +0530 Subject: [PATCH 03/16] docs: add mesh_layout notebook demonstrating rectilinear vs triangular mesh --- docs/_toc.yml | 1 + docs/mesh_layout.ipynb | 221 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 222 insertions(+) create mode 100644 docs/mesh_layout.ipynb diff --git a/docs/_toc.yml b/docs/_toc.yml index 1943552..17d5ccc 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -7,5 +7,6 @@ chapters: - file: background - file: design - file: creating_the_graph +- file: mesh_layout - file: lat_lons - file: decoding_mask diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb new file mode 100644 index 0000000..48ef2db --- /dev/null +++ b/docs/mesh_layout.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "073d0b26", + "metadata": {}, + "source": [ + "# Changing the mesh layout\n", + "\n", + "The mesh layout controls the topology of the `m2m` (mesh-to-mesh) component of the graph.\n", + "By default, `weather-model-graphs` uses a **rectilinear** mesh, where nodes sit on a regular\n", + "rectangular grid and edges connect each node to its 8 nearest neighbours (cardinal + diagonal).\n", + "\n", + "As of v0.4.0, a **triangular** mesh layout is also supported. This places nodes on an equilateral-\n", + "triangle lattice, giving each interior node exactly 6 neighbours instead of 8. The 6-connectivity\n", + "is more isotropic and can improve message-passing in graph neural network weather models.\n", + "\n", + "In this notebook we use the [Keisler 2022](https://arxiv.org/abs/2202.07575) graph archetype to\n", + "contrast three variants:\n", + "\n", + "1. **Default rectilinear** mesh (the archetype's built-in default)\n", + "2. **Rectilinear with finer mesh spacing** (more mesh nodes, denser connectivity)\n", + "3. **Triangular mesh** at the same spacing as variant 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2595994f", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import weather_model_graphs as wmg" + ] + }, + { + "cell_type": "markdown", + "id": "d3edb0f9", + "metadata": {}, + "source": [ + "## Set up a fake grid\n", + "\n", + "We start from a regular 32 × 32 grid of Cartesian (x, y) coordinates. These represent the\n", + "locations of the input/output data (grid nodes in g2m / m2g)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7eb67af8", + "metadata": {}, + "outputs": [], + "source": [ + "xs, ys = np.meshgrid(np.linspace(0, 10, 32), np.linspace(0, 10, 32))\n", + "xy = np.stack([xs.flatten(), ys.flatten()], axis=-1)\n", + "\n", + "fig, ax = plt.subplots(figsize=(4, 4))\n", + "ax.scatter(xy[:, 0], xy[:, 1], s=2)\n", + "ax.set_aspect(1)\n", + "ax.set_title(\"Grid nodes\")" + ] + }, + { + "cell_type": "markdown", + "id": "686ee7f2", + "metadata": {}, + "source": [ + "## Example 1 — Rectilinear mesh (default spacing)\n", + "\n", + "`create_keisler_graph` uses `mesh_layout='rectilinear'` with `mesh_node_distance=3` by default.\n", + "Each interior mesh node connects to its 8 neighbours (4-star cardinal + 4 diagonals)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7661b63", + "metadata": {}, + "outputs": [], + "source": [ + "graph_rectilinear = wmg.create.archetype.create_keisler_graph(\n", + " coords=xy,\n", + " mesh_node_distance=3,\n", + ")\n", + "\n", + "m2m_rectilinear = wmg.split_graph_by_edge_attribute(graph_rectilinear, attr=\"component\")[\n", + " \"m2m\"\n", + "]\n", + "\n", + "print(f\"Mesh nodes : {m2m_rectilinear.number_of_nodes()}\")\n", + "print(f\"Mesh edges : {m2m_rectilinear.number_of_edges()}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "wmg.visualise.nx_draw_with_pos_and_attr(m2m_rectilinear, ax=ax, node_size=30)\n", + "ax.set_title(\"Rectilinear mesh — default spacing (mesh_node_distance=3)\")" + ] + }, + { + "cell_type": "markdown", + "id": "e34fb561", + "metadata": {}, + "source": [ + "## Example 2 — Rectilinear mesh with finer spacing\n", + "\n", + "Halving `mesh_node_distance` roughly quadruples the number of mesh nodes and gives a denser\n", + "rectilinear mesh over the same domain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ebc4f15", + "metadata": {}, + "outputs": [], + "source": [ + "graph_fine = wmg.create.archetype.create_keisler_graph(\n", + " coords=xy,\n", + " mesh_node_distance=1.5,\n", + ")\n", + "\n", + "m2m_fine = wmg.split_graph_by_edge_attribute(graph_fine, attr=\"component\")[\"m2m\"]\n", + "\n", + "print(f\"Mesh nodes : {m2m_fine.number_of_nodes()}\")\n", + "print(f\"Mesh edges : {m2m_fine.number_of_edges()}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "wmg.visualise.nx_draw_with_pos_and_attr(m2m_fine, ax=ax, node_size=10)\n", + "ax.set_title(\"Rectilinear mesh — finer spacing (mesh_node_distance=1.5)\")" + ] + }, + { + "cell_type": "markdown", + "id": "1acbf174", + "metadata": {}, + "source": [ + "## Example 3 — Triangular mesh\n", + "\n", + "Setting `mesh_layout='triangular'` places nodes on an equilateral-triangle lattice.\n", + "Each interior node has exactly **6 neighbours** (vs. 8 for rectilinear), which provides\n", + "more isotropic spatial connectivity.\n", + "\n", + "We keep the same g2m / m2g connectivity settings as the Keisler archetype (within-radius\n", + "encoding, 4-nearest-neighbour decoding) and use the same mesh spacing as Example 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "086f9fb1", + "metadata": {}, + "outputs": [], + "source": [ + "graph_triangular = wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"triangular\",\n", + " mesh_layout_kwargs=dict(mesh_node_spacing=3),\n", + " m2m_connectivity=\"flat\",\n", + " g2m_connectivity=\"within_radius\",\n", + " g2m_connectivity_kwargs=dict(rel_max_dist=0.51),\n", + " m2g_connectivity=\"nearest_neighbours\",\n", + " m2g_connectivity_kwargs=dict(max_num_neighbours=4),\n", + ")\n", + "\n", + "m2m_triangular = wmg.split_graph_by_edge_attribute(graph_triangular, attr=\"component\")[\n", + " \"m2m\"\n", + "]\n", + "\n", + "print(f\"Mesh nodes : {m2m_triangular.number_of_nodes()}\")\n", + "print(f\"Mesh edges : {m2m_triangular.number_of_edges()}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "wmg.visualise.nx_draw_with_pos_and_attr(m2m_triangular, ax=ax, node_size=30)\n", + "ax.set_title(\"Triangular mesh (mesh_node_spacing=3)\")" + ] + }, + { + "cell_type": "markdown", + "id": "9bd01e4c", + "metadata": {}, + "source": [ + "## Side-by-side comparison\n", + "\n", + "Plotting the `m2m` component of all three graphs side by side makes the difference in\n", + "topology clear: rectilinear nodes form a square grid with 8-connectivity, while triangular\n", + "nodes form a hexagonal-offset grid with 6-connectivity." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fdd4e7aa", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "configs = [\n", + " (m2m_rectilinear, \"Rectilinear\\n(default spacing)\", 30),\n", + " (m2m_fine, \"Rectilinear\\n(finer spacing)\", 10),\n", + " (m2m_triangular, \"Triangular\\n(same spacing as default)\", 30),\n", + "]\n", + "\n", + "for ax, (graph, title, ns) in zip(axes, configs):\n", + " wmg.visualise.nx_draw_with_pos_and_attr(graph, ax=ax, node_size=ns)\n", + " ax.set_title(title)\n", + "\n", + "fig.tight_layout()" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8593f3c2cfb5c4f16cc61d944dbb4af94a62c33e Mon Sep 17 00:00:00 2001 From: prajwal Date: Tue, 9 Jun 2026 13:21:52 +0530 Subject: [PATCH 04/16] style: apply black-jupyter formatting to mesh_layout notebook --- docs/mesh_layout.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb index 48ef2db..7ea62e5 100644 --- a/docs/mesh_layout.ipynb +++ b/docs/mesh_layout.ipynb @@ -86,9 +86,9 @@ " mesh_node_distance=3,\n", ")\n", "\n", - "m2m_rectilinear = wmg.split_graph_by_edge_attribute(graph_rectilinear, attr=\"component\")[\n", - " \"m2m\"\n", - "]\n", + "m2m_rectilinear = wmg.split_graph_by_edge_attribute(\n", + " graph_rectilinear, attr=\"component\"\n", + ")[\"m2m\"]\n", "\n", "print(f\"Mesh nodes : {m2m_rectilinear.number_of_nodes()}\")\n", "print(f\"Mesh edges : {m2m_rectilinear.number_of_edges()}\")\n", From 4c44c03aa04e92ea63fef151622854f4612ab934 Mon Sep 17 00:00:00 2001 From: prajwal Date: Tue, 9 Jun 2026 20:44:48 +0530 Subject: [PATCH 05/16] docs: update mesh_layout notebook per review feedback - Fix wording: 'can improve' -> 'is expected to improve' message-passing - Set same axis limits across all subplots in side-by-side comparison - Set aspect ratio 1.0 on all axes in side-by-side comparison --- docs/mesh_layout.ipynb | 198 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 183 insertions(+), 15 deletions(-) diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb index 7ea62e5..9096df6 100644 --- a/docs/mesh_layout.ipynb +++ b/docs/mesh_layout.ipynb @@ -13,19 +13,19 @@ "\n", "As of v0.4.0, a **triangular** mesh layout is also supported. This places nodes on an equilateral-\n", "triangle lattice, giving each interior node exactly 6 neighbours instead of 8. The 6-connectivity\n", - "is more isotropic and can improve message-passing in graph neural network weather models.\n", + "is more isotropic and is expected to improve message-passing in graph neural network weather models.\n", "\n", "In this notebook we use the [Keisler 2022](https://arxiv.org/abs/2202.07575) graph archetype to\n", "contrast three variants:\n", "\n", "1. **Default rectilinear** mesh (the archetype's built-in default)\n", "2. **Rectilinear with finer mesh spacing** (more mesh nodes, denser connectivity)\n", - "3. **Triangular mesh** at the same spacing as variant 1" + "3. **Triangular mesh** at the same spacing as variant 1\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2595994f", "metadata": {}, "outputs": [], @@ -49,10 +49,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7eb67af8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Grid nodes')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "xs, ys = np.meshgrid(np.linspace(0, 10, 32), np.linspace(0, 10, 32))\n", "xy = np.stack([xs.flatten(), ys.flatten()], axis=-1)\n", @@ -76,10 +97,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "c7661b63", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-06-09 20:43:41.254\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh nodes : 9\n", + "Mesh edges : 40\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Rectilinear mesh — default spacing (mesh_node_distance=3)')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "graph_rectilinear = wmg.create.archetype.create_keisler_graph(\n", " coords=xy,\n", @@ -111,10 +168,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "7ebc4f15", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-06-09 20:43:50.026\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh nodes : 36\n", + "Mesh edges : 220\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Rectilinear mesh — finer spacing (mesh_node_distance=1.5)')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "graph_fine = wmg.create.archetype.create_keisler_graph(\n", " coords=xy,\n", @@ -148,10 +241,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "086f9fb1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2026-06-09 20:43:59.974\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh nodes : 10\n", + "Mesh edges : 36\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Triangular mesh (mesh_node_spacing=3)')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "graph_triangular = wmg.create.create_all_graph_components(\n", " coords=xy,\n", @@ -190,10 +319,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "fdd4e7aa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", "\n", @@ -203,17 +343,45 @@ " (m2m_triangular, \"Triangular\\n(same spacing as default)\", 30),\n", "]\n", "\n", + "# Compute shared axis limits from node positions across all graphs\n", + "all_pos = np.concatenate(\n", + " [\n", + " np.array([data[\"pos\"] for _, data in graph.nodes(data=True)])\n", + " for graph, _, _ in configs\n", + " ]\n", + ")\n", + "x_min, y_min = all_pos.min(axis=0)\n", + "x_max, y_max = all_pos.max(axis=0)\n", + "pad = max(x_max - x_min, y_max - y_min) * 0.05\n", + "\n", "for ax, (graph, title, ns) in zip(axes, configs):\n", " wmg.visualise.nx_draw_with_pos_and_attr(graph, ax=ax, node_size=ns)\n", " ax.set_title(title)\n", + " ax.set_xlim(x_min - pad, x_max + pad)\n", + " ax.set_ylim(y_min - pad, y_max + pad)\n", + " ax.set_aspect(1.0)\n", "\n", - "fig.tight_layout()" + "fig.tight_layout()\n" ] } ], "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" } }, "nbformat": 4, From 36a2c0d31a5e98ec5c03d97a3836706a5334c299 Mon Sep 17 00:00:00 2001 From: prajwal Date: Tue, 9 Jun 2026 20:55:12 +0530 Subject: [PATCH 06/16] style: apply black formatting to mesh_layout notebook --- docs/mesh_layout.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb index 9096df6..c6e4a00 100644 --- a/docs/mesh_layout.ipynb +++ b/docs/mesh_layout.ipynb @@ -361,7 +361,7 @@ " ax.set_ylim(y_min - pad, y_max + pad)\n", " ax.set_aspect(1.0)\n", "\n", - "fig.tight_layout()\n" + "fig.tight_layout()" ] } ], From 899b6d0455740a2f26b1eb7d74fa1f92f2910989 Mon Sep 17 00:00:00 2001 From: prajwal Date: Wed, 10 Jun 2026 21:38:46 +0530 Subject: [PATCH 07/16] Reorganize mesh coordinate creation into layout subpackage Move coordinate-creation functions from coords.py and connectivity/triangular.py into layout/rectilinear.py and layout/triangular.py. Drop triangular-specific convenience wrappers in favour of the generic two-step API. Retain backward-compatible re-exports in coords.py and connectivity/triangular.py. Update all imports and rewrite tests to use the two-step API. --- src/weather_model_graphs/create/base.py | 16 +- .../create/mesh/__init__.py | 16 +- .../create/mesh/connectivity/flat.py | 6 +- .../create/mesh/connectivity/hierarchical.py | 4 +- .../create/mesh/connectivity/triangular.py | 353 +----------------- .../create/mesh/coords.py | 315 +--------------- .../create/mesh/layout/__init__.py | 16 + .../create/mesh/layout/rectilinear.py | 313 ++++++++++++++++ .../create/mesh/layout/triangular.py | 218 +++++++++++ tests/test_mesh_layout.py | 2 +- tests/test_triangular_mesh.py | 298 +++++---------- 11 files changed, 697 insertions(+), 860 deletions(-) create mode 100644 src/weather_model_graphs/create/mesh/layout/__init__.py create mode 100644 src/weather_model_graphs/create/mesh/layout/rectilinear.py create mode 100644 src/weather_model_graphs/create/mesh/layout/triangular.py diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index 1b9374b..28ae3a7 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -31,13 +31,15 @@ from .mesh.connectivity.hierarchical import create_hierarchical_from_coordinates from .mesh.connectivity.triangular import ( create_flat_multiscale_from_triangular_coordinates, - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_primitive, ) -from .mesh.coords import ( +from .mesh.layout.rectilinear import ( create_multirange_2d_mesh_primitives, create_single_level_2d_mesh_primitive, ) +from .mesh.layout.triangular import ( + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_primitive, +) def _migrate_deprecated_kwargs( @@ -395,10 +397,10 @@ def create_all_graph_components( if pattern is None: pattern = "4-star" if mesh_layout == "triangular" else "8-star" if mesh_layout == "triangular": - graph_components[ - "m2m" - ] = create_flat_multiscale_from_triangular_coordinates( - G_mesh_coords, pattern=pattern + graph_components["m2m"] = ( + create_flat_multiscale_from_triangular_coordinates( + G_mesh_coords, pattern=pattern + ) ) else: graph_components["m2m"] = create_flat_multiscale_from_coordinates( diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index b084768..0de2727 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -1,15 +1,15 @@ +from .connectivity.general import create_directed_mesh_graph from .connectivity.triangular import ( create_flat_multiscale_from_triangular_coordinates, - create_flat_multiscale_triangular_mesh_graph, - create_flat_singlescale_triangular_mesh_graph, - create_hierarchical_triangular_mesh_graph, - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_graph, - create_single_level_2d_triangular_mesh_primitive, ) -from .coords import ( - create_directed_mesh_graph, +from .layout.rectilinear import ( + create_multirange_2d_mesh_graphs, create_multirange_2d_mesh_primitives, create_single_level_2d_mesh_graph, create_single_level_2d_mesh_primitive, ) +from .layout.triangular import ( + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_graph, + create_single_level_2d_triangular_mesh_primitive, +) diff --git a/src/weather_model_graphs/create/mesh/connectivity/flat.py b/src/weather_model_graphs/create/mesh/connectivity/flat.py index 4abef68..6668464 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/flat.py +++ b/src/weather_model_graphs/create/mesh/connectivity/flat.py @@ -4,7 +4,7 @@ import numpy as np from ....networkx_utils import prepend_node_index -from .. import coords as mesh_coords +from ..layout import rectilinear as mesh_layout from .general import create_directed_mesh_graph @@ -213,7 +213,7 @@ def create_flat_multiscale_mesh_graph( G_tot : networkx.DiGraph The merged mesh graph """ - G_coords_list = mesh_coords.create_multirange_2d_mesh_primitives( + G_coords_list = mesh_layout.create_multirange_2d_mesh_primitives( max_num_levels=max_num_levels, xy=xy, mesh_node_spacing=mesh_node_distance, @@ -263,4 +263,4 @@ def create_flat_singlescale_mesh_graph( " so that the mesh nodes are spaced closer together?" ) - return mesh_coords.create_single_level_2d_mesh_graph(xy=xy, nx=nx, ny=ny) + return mesh_layout.create_single_level_2d_mesh_graph(xy=xy, nx=nx, ny=ny) diff --git a/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py b/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py index ae78da1..95aafee 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py +++ b/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py @@ -5,7 +5,7 @@ import scipy from ....networkx_utils import prepend_node_index -from .. import coords as mesh_coords +from ..layout import rectilinear as mesh_layout from .general import create_directed_mesh_graph @@ -207,7 +207,7 @@ def create_hierarchical_multiscale_mesh_graph( A directed graph containing the hierarchical mesh with intra-level, up, and down edges. """ - G_coords_list = mesh_coords.create_multirange_2d_mesh_primitives( + G_coords_list = mesh_layout.create_multirange_2d_mesh_primitives( max_num_levels=max_num_levels, xy=xy, mesh_node_spacing=mesh_node_distance, diff --git a/src/weather_model_graphs/create/mesh/connectivity/triangular.py b/src/weather_model_graphs/create/mesh/connectivity/triangular.py index e90dab6..7750202 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/triangular.py +++ b/src/weather_model_graphs/create/mesh/connectivity/triangular.py @@ -1,17 +1,14 @@ """ -Functions for creating regular triangular mesh graphs. +Triangular mesh connectivity functions. -Uses ``networkx.triangular_lattice_graph`` to produce an equilateral-triangle -lattice with 6-connectivity (each interior node has 6 neighbours). This -mirrors the rectilinear mesh functions (which use ``networkx.grid_2d_graph`` -with 8-connectivity) and plugs into the same two-step process: +Coordinate creation (primitives) lives in ``layout.triangular``. +This module contains only triangular-specific *connectivity* logic +that cannot be handled by the generic connectivity functions in +``flat.py`` or ``hierarchical.py``. -1. **Coordinate creation** (this module) -> ``nx.Graph`` with ``pos``, ``type``, - and ``adjacency_type`` attributes. -2. **Connectivity creation** (``create_directed_mesh_graph`` in ``general.py``) - -> ``nx.DiGraph`` with ``len`` and ``vdiff`` edge attributes. - -Supports flat, flat_multiscale, and hierarchical ``m2m_connectivity`` modes. +The generic ``create_hierarchical_from_coordinates`` already works with +triangular primitives, so no triangular-specific hierarchical function +is needed here. """ from typing import List @@ -19,242 +16,22 @@ import networkx import numpy as np import scipy.spatial -from loguru import logger from ....networkx_utils import prepend_node_index +from ..layout.triangular import ( + create_multirange_2d_triangular_mesh_primitives, + create_single_level_2d_triangular_mesh_graph, + create_single_level_2d_triangular_mesh_primitive, +) from .general import create_directed_mesh_graph - -def create_single_level_2d_triangular_mesh_primitive( - xy: np.ndarray, nx: int, ny: int -) -> networkx.Graph: - """ - Create an undirected triangular mesh primitive graph (``nx.Graph``) with - node positions and spatial adjacency edges. - - This is analogous to ``create_single_level_2d_mesh_primitive`` but uses - ``networkx.triangular_lattice_graph`` instead of ``grid_2d_graph``. - - In a triangular lattice, each interior node has 6 neighbours (vs. 8 for - the rectilinear lattice with diagonals), providing more isotropic message - passing. - - The nodes form a grid of ``(ny + 1)`` rows and ``(nx + 1) // 2`` columns, - with odd-row nodes shifted horizontally. Positions are scaled and offset - so that the mesh spans the coordinate domain of *xy* (with nodes inset - from the border by half a cell width in each direction). - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - nx : int - Number of triangle columns (passed as *n* to - ``triangular_lattice_graph``). - ny : int - Number of triangle rows (passed as *m* to - ``triangular_lattice_graph``). - - Returns - ------- - networkx.Graph - Undirected mesh primitive graph. Node attributes: ``pos`` - (np.ndarray[2,]), ``type`` (``"mesh"``). Edge attributes: - ``adjacency_type`` (always ``"cardinal"`` -- triangular lattices have - only one class of edge). Graph attributes: ``dx``, ``dy``. - """ - xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) - ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) - - # Create the raw triangular lattice - g_raw = networkx.triangular_lattice_graph(ny, nx, with_positions=True) - - if g_raw.number_of_nodes() == 0: - raise ValueError( - f"triangular_lattice_graph({ny}, {nx}) produced 0 nodes. " - "Increase nx/ny or decrease mesh_node_spacing." - ) - - # Gather raw positions to compute extent - raw_positions = np.array([g_raw.nodes[n]["pos"] for n in g_raw.nodes()]) - raw_xmin, raw_ymin = raw_positions.min(axis=0) - raw_xmax, raw_ymax = raw_positions.max(axis=0) - raw_extent_x = raw_xmax - raw_xmin - raw_extent_y = raw_ymax - raw_ymin - - # Domain extent with half-cell inset - domain_x = xM - xm - domain_y = yM - ym - - # Scale factors -- map raw lattice extent to domain extent (inset by half - # a cell in each direction, mirroring the rectilinear approach) - if raw_extent_x > 0: - scale_x = domain_x / (raw_extent_x + 1.0) # +1 for inset - else: - scale_x = domain_x # single column - if raw_extent_y > 0: - scale_y = domain_y / (raw_extent_y + np.sqrt(3) / 2) # +row_h for inset - else: - scale_y = domain_y # single row - - # Effective dx/dy for graph attributes - dx = scale_x - dy = scale_y * (np.sqrt(3) / 2) - - # Offset so mesh is centred within domain - offset_x = xm + (domain_x - raw_extent_x * scale_x) / 2 - offset_y = ym + (domain_y - raw_extent_y * scale_y) / 2 - - # Build output graph with scaled positions - g = networkx.Graph() - for node in g_raw.nodes(): - raw_pos = g_raw.nodes[node]["pos"] - pos = np.array( - [ - offset_x + (raw_pos[0] - raw_xmin) * scale_x, - offset_y + (raw_pos[1] - raw_ymin) * scale_y, - ] - ) - g.add_node(node, pos=pos, type="mesh") - - for u, v in g_raw.edges(): - g.add_edge(u, v, adjacency_type="cardinal") - - g.graph["dx"] = dx - g.graph["dy"] = dy - - return g - - -def create_multirange_2d_triangular_mesh_primitives( - max_num_levels, - xy: np.ndarray, - mesh_node_spacing: float = 3, - interlevel_refinement_factor: int = 3, -) -> List[networkx.Graph]: - """ - Create a list of undirected triangular mesh primitive graphs representing - different levels of mesh resolution. - - Mirrors ``create_multirange_2d_mesh_primitives`` but uses triangular - lattice topology at each level. - - Parameters - ---------- - max_num_levels : int - Maximum number of levels in the multi-scale graph. - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - mesh_node_spacing : float - Distance between mesh nodes at the finest level, in coordinate units. - interlevel_refinement_factor : int - Factor by which mesh node count decreases per level. - - Returns - ------- - list[networkx.Graph] - Triangular mesh primitive graphs, one per level. - """ - coord_extent = np.ptp(xy, axis=0) - # For triangular lattice, ny accounts for row spacing of sqrt(3)/2 - max_nx = int(coord_extent[0] / mesh_node_spacing) - max_ny = int(coord_extent[1] / (mesh_node_spacing * np.sqrt(3) / 2)) - - max_nodes_bottom = np.array([max_nx, max_ny]) - - max_mesh_levels_float = np.log(max_nodes_bottom) / np.log( - interlevel_refinement_factor - ) - max_mesh_levels = max_mesh_levels_float.astype(int) - nleaf = interlevel_refinement_factor**max_mesh_levels - - mesh_levels_to_create = max_mesh_levels.min() - if max_num_levels: - mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) - - logger.debug(f"triangular mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}") - - G_all_levels = [] - for lev in range(mesh_levels_to_create): - nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) - g = create_single_level_2d_triangular_mesh_primitive(xy, nodes_x, nodes_y) - for node in g.nodes: - g.nodes[node]["level"] = lev - for edge in g.edges: - g.edges[edge]["level"] = lev - g.graph["level"] = lev - g.graph["interlevel_refinement_factor"] = interlevel_refinement_factor - G_all_levels.append(g) - - return G_all_levels - - -def create_single_level_2d_triangular_mesh_graph( - xy: np.ndarray, nx: int, ny: int -) -> networkx.DiGraph: - """ - Create a directed triangular mesh graph from coordinates. - - Internally uses the two-step process: - 1. ``create_single_level_2d_triangular_mesh_primitive`` (coordinate creation) - 2. ``create_directed_mesh_graph`` (connectivity creation) - - For triangular lattices, *all* edges are ``"cardinal"`` so patterns - ``"4-star"`` and ``"8-star"`` produce the same result (6-connectivity). - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - nx : int - Number of triangle columns. - ny : int - Number of triangle rows. - - Returns - ------- - networkx.DiGraph - Directed triangular mesh graph. - """ - G_coords = create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) - return create_directed_mesh_graph(G_coords, pattern="4-star") - - -def create_flat_singlescale_triangular_mesh_graph( - xy: np.ndarray, mesh_node_distance: float -) -> networkx.DiGraph: - """ - Create a flat single-scale triangular mesh graph. - - Mirrors ``create_flat_singlescale_mesh_graph`` but with triangular - lattice topology (6-connectivity). - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - mesh_node_distance : float - Approximate side length of equilateral triangles, in coordinate units. - - Returns - ------- - networkx.DiGraph - Flat single-scale directed triangular mesh graph. - """ - range_x, range_y = np.ptp(xy, axis=0) - nx = int(range_x / mesh_node_distance) - ny = int(range_y / (mesh_node_distance * np.sqrt(3) / 2)) - - if nx == 0 or ny == 0: - raise ValueError( - "The given `mesh_node_distance` is too large for the provided " - f"coordinates. Got mesh_node_distance={mesh_node_distance}, but " - f"the x-range is {range_x} and y-range is {range_y}. Maybe you " - "want to decrease the `mesh_node_distance` so that the mesh " - "nodes are spaced closer together?" - ) - - return create_single_level_2d_triangular_mesh_graph(xy, nx, ny) +# Re-export layout functions for backward compatibility +__all__ = [ + "create_single_level_2d_triangular_mesh_primitive", + "create_multirange_2d_triangular_mesh_primitives", + "create_single_level_2d_triangular_mesh_graph", + "create_flat_multiscale_from_triangular_coordinates", +] def create_flat_multiscale_from_triangular_coordinates( @@ -324,93 +101,3 @@ def create_flat_multiscale_from_triangular_coordinates( G_tot.graph["dy"] = {i: g.graph["dy"] for i, g in enumerate(G_directed)} return G_tot - - -def create_flat_multiscale_triangular_mesh_graph( - xy: np.ndarray, - mesh_node_distance: float, - level_refinement_factor: int, - max_num_levels: int, -) -> networkx.DiGraph: - """ - Create a flat multiscale triangular mesh graph. - - Mirrors ``create_flat_multiscale_mesh_graph`` but with triangular lattice - topology at each level. - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - mesh_node_distance : float - Distance between mesh nodes at the finest level. - level_refinement_factor : int - Refinement factor between levels. - max_num_levels : int - Maximum number of mesh levels. - - Returns - ------- - networkx.DiGraph - Flat multiscale triangular mesh graph. - """ - G_coords_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=max_num_levels, - xy=xy, - mesh_node_spacing=mesh_node_distance, - interlevel_refinement_factor=level_refinement_factor, - ) - return create_flat_multiscale_from_triangular_coordinates(G_coords_list) - - -def create_hierarchical_triangular_mesh_graph( - xy: np.ndarray, - mesh_node_distance: float, - level_refinement_factor: int, - max_num_levels: int, - intra_level: dict = None, - inter_level: dict = None, -) -> networkx.DiGraph: - """ - Create a hierarchical triangular mesh graph. - - Mirrors ``create_hierarchical_multiscale_mesh_graph`` but with triangular - lattice topology at each level. - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - mesh_node_distance : float - Distance between mesh nodes at the finest level. - level_refinement_factor : int - Refinement factor between levels. - max_num_levels : int - Maximum number of mesh levels. - intra_level : dict, optional - Keyword arguments for intra-level connectivity (e.g. ``{"pattern": "4-star"}``). - Defaults to ``{"pattern": "4-star"}``. - inter_level : dict, optional - Keyword arguments for inter-level connectivity. If None, uses defaults - from ``create_hierarchical_from_coordinates``. - - Returns - ------- - networkx.DiGraph - Hierarchical triangular mesh graph. - """ - from .hierarchical import create_hierarchical_from_coordinates - - if intra_level is None: - intra_level = {"pattern": "4-star"} - - G_coords_list = create_multirange_2d_triangular_mesh_primitives( - max_num_levels=max_num_levels, - xy=xy, - mesh_node_spacing=mesh_node_distance, - interlevel_refinement_factor=level_refinement_factor, - ) - kwargs = {"intra_level": intra_level} - if inter_level is not None: - kwargs["inter_level"] = inter_level - return create_hierarchical_from_coordinates(G_coords_list, **kwargs) diff --git a/src/weather_model_graphs/create/mesh/coords.py b/src/weather_model_graphs/create/mesh/coords.py index 40cec0b..7b4ad7f 100644 --- a/src/weather_model_graphs/create/mesh/coords.py +++ b/src/weather_model_graphs/create/mesh/coords.py @@ -1,298 +1,23 @@ -from typing import List +""" +Backward-compatibility re-exports from ``layout.rectilinear``. -import networkx -import numpy as np -from loguru import logger +All coordinate creation functions have been moved to +``wmg.create.mesh.layout.rectilinear``. This module re-exports them +so that existing imports continue to work. +""" from .connectivity.general import create_directed_mesh_graph - - -def create_single_level_2d_mesh_primitive( - xy: np.ndarray, - nx: int = None, - ny: int = None, - *, - mesh_node_spacing: float = None, -) -> networkx.Graph: - """ - Create an undirected mesh primitive graph (nx.Graph) with node positions - and spatial adjacency edges, representing the coordinate creation step. - - A mesh primitive is an undirected graph that encodes all potential - neighbourhood connectivity edges. It serves as a blueprint from which - directed connectivity graphs can later be built by selecting a subset - of edges (e.g. 4-star or 8-star pattern). - - This produces a graph where: - - Nodes have a ``"pos"`` attribute (np.ndarray of shape [2,] with x and y - coordinates) and a ``"type"`` attribute (str, always ``"mesh"``). - - Edges have an ``"adjacency_type"`` attribute (str): ``"cardinal"`` for - horizontal/vertical neighbours (4-star connectivity) or ``"diagonal"`` - for diagonal neighbours (additional edges in 8-star connectivity). - - This is the first step in the two-step mesh creation process: - 1. Coordinate creation (this function) -> nx.Graph with spatial adjacency - 2. Connectivity creation (create_directed_mesh_graph) -> nx.DiGraph - - Either provide ``nx`` and ``ny`` directly, or provide - ``mesh_node_spacing`` to have them computed automatically from the - coordinate extent of ``xy``. - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped [N_grid_points, 2], with first column - representing x coordinates and second column y coordinates. - nx : int, optional - Number of nodes in x direction. If not given, computed from - ``mesh_node_spacing``. - ny : int, optional - Number of nodes in y direction. If not given, computed from - ``mesh_node_spacing``. - mesh_node_spacing : float, optional - Distance between mesh nodes (in coordinate units). When provided, - ``nx`` and ``ny`` are computed as - ``int(range / mesh_node_spacing)`` and validated to be > 0. - - Returns - ------- - networkx.Graph - Undirected mesh primitive graph with node positions and annotated - spatial adjacency edges. - """ - if mesh_node_spacing is not None: - range_x, range_y = np.ptp(xy, axis=0) - nx = int(range_x / mesh_node_spacing) - ny = int(range_y / mesh_node_spacing) - if nx == 0 or ny == 0: - raise ValueError( - "The given `mesh_node_spacing` is too large for the provided " - f"coordinates. Got mesh_node_spacing={mesh_node_spacing}, but the " - f"x-range is {range_x} and y-range is {range_y}. Maybe you " - "want to decrease the `mesh_node_spacing` so that the mesh nodes " - "are spaced closer together?" - ) - elif nx is None or ny is None: - raise ValueError( - "Either provide both `nx` and `ny`, or provide " - "`mesh_node_spacing` to compute them automatically." - ) - xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) - ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) - - # avoid nodes on border - dx = (xM - xm) / nx - dy = (yM - ym) / ny - lx = np.linspace(xm + dx / 2, xM - dx / 2, nx) - ly = np.linspace(ym + dy / 2, yM - dy / 2, ny) - - mg = np.meshgrid(lx, ly) - g = networkx.grid_2d_graph(len(lx), len(ly)) - - # Node name and `pos` attribute takes form (x, y) - for node in g.nodes: - node_xi, node_yi = node # Extract x and y index from node to index mx - g.nodes[node]["pos"] = np.array( - [mg[0][node_yi, node_xi], mg[1][node_yi, node_xi]] - ) - g.nodes[node]["type"] = "mesh" - - # Mark existing grid_2d_graph edges as cardinal (4-star adjacency) - for u, v in g.edges(): - g.edges[u, v]["adjacency_type"] = "cardinal" - - # Add diagonal edges (8-star adjacency) - diagonal_edges = [ - ((x, y), (x + 1, y + 1)) for x in range(nx - 1) for y in range(ny - 1) - ] + [((x + 1, y), (x, y + 1)) for x in range(nx - 1) for y in range(ny - 1)] - g.add_edges_from(diagonal_edges) - for u, v in diagonal_edges: - g.edges[u, v]["adjacency_type"] = "diagonal" - - g.graph["dx"] = dx - g.graph["dy"] = dy - - return g - - -def create_single_level_2d_mesh_graph( - xy: np.ndarray, nx: int, ny: int -) -> networkx.DiGraph: - """ - Create directed graph with nx * ny nodes representing a 2D grid with - positions spanning the range of xy coordinate values (first dimension - is assumed to be x and y coordinate values respectively). Each nodes is - connected to its eight nearest neighbours, both horizontally, vertically - and diagonally as directed edges (which means that the graph contains two - edges between each pair of connected nodes). - - The nodes contain a "pos" attribute with the x and y - coordinates of the node, and an "type" attribute with the - type of the node (i.e. "mesh" for mesh nodes). - - The edges contain a "len" attribute with the length of the edge - and a "vdiff" attribute with the vector difference between the - nodes. - - Internally, this uses the two-step process: - 1. create_single_level_2d_mesh_primitive (coordinate creation) - 2. create_directed_mesh_graph (connectivity creation, pattern="8-star") - - Parameters - ---------- - xy : np.ndarray [N_grid_points, 2] - Grid point coordinates, with first column representing - x coordinates and second column y coordinates. N_grid_points is the - total number of grid points. - nx : int - Number of nodes in x direction - ny : int - Number of nodes in y direction - - Returns - ------- - networkx.DiGraph - Graph representing the 2D grid - """ - G_coords = create_single_level_2d_mesh_primitive(xy, nx, ny) - return create_directed_mesh_graph(G_coords, pattern="8-star") - - -def create_multirange_2d_mesh_primitives( - max_num_levels: int, - xy: np.ndarray, - mesh_node_spacing: float = 3, - interlevel_refinement_factor: float = 3, -) -> List[networkx.Graph]: - """ - Create a list of undirected mesh primitive graphs (nx.Graph) representing - different levels of mesh resolution spanning the spatial domain of the - xy coordinates. - - This is the coordinate creation step for multi-level and hierarchical mesh - graphs. Each returned graph contains nodes with spatial positions and edges - annotated with adjacency type (``"cardinal"`` or ``"diagonal"``). - - The graphs can be consumed by connectivity creation functions to produce - directed mesh graphs for flat_multiscale or hierarchical architectures. - - Parameters - ---------- - max_num_levels : int - Number of edge-distance levels in mesh graph - xy : np.ndarray - Grid point coordinates, shaped [N_grid_points, 2] - mesh_node_spacing : float - Distance (in x- and y-direction) between created mesh nodes, - in coordinate system of xy - interlevel_refinement_factor : float - Refinement factor between grid points and bottom level of mesh hierarchy - - Returns - ------- - G_all_levels : list of networkx.Graph - List of undirected mesh primitive graphs for each level, each with - node positions and annotated spatial adjacency edges. - Each graph has ``"level"`` and ``"interlevel_refinement_factor"`` - graph attributes. - """ - # Compute the size along x and y direction of area to cover with graph - # This is measured in the Cartesian coordinates of xy - coord_extent = np.ptp(xy, axis=0) - # Number of nodes that would fit on bottom level of hierarchy, - # in both directions - max_nodes_bottom = (coord_extent / mesh_node_spacing).astype(int) - - # Find the number of mesh levels possible in x- and y-direction, - # and the number of leaf nodes that would correspond to - # max_nodes_bottom/(interlevel_refinement_factor^mesh_levels) = 1 - max_mesh_levels_float = np.log(max_nodes_bottom) / np.log( - interlevel_refinement_factor - ) - - max_mesh_levels = max_mesh_levels_float.astype(int) # (2,) - nleaf = interlevel_refinement_factor**max_mesh_levels - # leaves at the bottom in each direction, if using max_mesh_levels - - # As we can not instantiate different number of mesh levels in each - # direction, create mesh levels corresponding to the minimum of the two - mesh_levels_to_create = max_mesh_levels.min() - - if max_num_levels: - # Limit the levels in mesh graph - mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) - - logger.debug(f"mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}") - - # multi resolution tree levels - G_all_levels = [] - for lev in range(mesh_levels_to_create): # 0-index mesh levels - # Compute number of nodes on level separate for each direction - nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) - g = create_single_level_2d_mesh_primitive(xy, nodes_x, nodes_y) - # Add level information to nodes, edges and full graph - for node in g.nodes: - g.nodes[node]["level"] = lev - for edge in g.edges: - g.edges[edge]["level"] = lev - g.graph["level"] = lev - # Store refinement factor so connectivity step can use it - g.graph["interlevel_refinement_factor"] = interlevel_refinement_factor - G_all_levels.append(g) - - return G_all_levels - - -def create_multirange_2d_mesh_graphs( - max_num_levels: int, - xy: np.ndarray, - mesh_node_distance: float = 3, - level_refinement_factor: float = 3, - pattern: str = "8-star", -) -> List[networkx.DiGraph]: - """ - Create a list of 2D grid mesh graphs representing different levels of edge-length - scales spanning the spatial domain of the xy coordinates. - This list of graphs can then later be for example a) flattened into single graph - containing multiple ranges of connections or b) combined into a hierarchical graph. - - Each graph in the list contains a "level" attribute with the level index of the graph. - - Internally uses the two-step process: - 1. create_multirange_2d_mesh_primitives (coordinate creation) - 2. create_directed_mesh_graph (connectivity creation) - - Parameters - ---------- - max_num_levels : int - Number of edge-distance levels in mesh graph - xy : np.ndarray - Grid point coordinates, shaped [N_grid_points, 2] - mesh_node_distance : float - Distance (in x- and y-direction) between created mesh nodes, - in coordinate system of xy - level_refinement_factor : float - Refinement factor between grid points and bottom level of mesh hierarchy - pattern : str - Connectivity pattern for directed graph creation: ``"4-star"`` or - ``"8-star"`` (default: ``"8-star"``) - - Returns - ------- - G_all_levels : list of networkx.DiGraph - List of networkx graphs for each level representing the connectivity - of the mesh within each level - """ - G_coords_list = create_multirange_2d_mesh_primitives( - max_num_levels=max_num_levels, - xy=xy, - mesh_node_spacing=mesh_node_distance, - interlevel_refinement_factor=level_refinement_factor, - ) - - G_all_levels = [] - for g_coords in G_coords_list: - g_directed = create_directed_mesh_graph(g_coords, pattern=pattern) - G_all_levels.append(g_directed) - - return G_all_levels +from .layout.rectilinear import ( + create_multirange_2d_mesh_graphs, + create_multirange_2d_mesh_primitives, + create_single_level_2d_mesh_graph, + create_single_level_2d_mesh_primitive, +) + +__all__ = [ + "create_directed_mesh_graph", + "create_multirange_2d_mesh_graphs", + "create_multirange_2d_mesh_primitives", + "create_single_level_2d_mesh_graph", + "create_single_level_2d_mesh_primitive", +] diff --git a/src/weather_model_graphs/create/mesh/layout/__init__.py b/src/weather_model_graphs/create/mesh/layout/__init__.py new file mode 100644 index 0000000..817fd83 --- /dev/null +++ b/src/weather_model_graphs/create/mesh/layout/__init__.py @@ -0,0 +1,16 @@ +""" +Mesh layout modules. + +Each layout module defines how mesh node coordinates are placed in space +(coordinate creation step). The resulting undirected primitive graphs are +then consumed by the connectivity modules to produce directed mesh graphs. + +Available layouts: + +- ``rectilinear``: Uniform rectangular grid (``grid_2d_graph``). +- ``triangular``: Regular triangular lattice (``triangular_lattice_graph``). +""" + +from . import rectilinear, triangular + +__all__ = ["rectilinear", "triangular"] diff --git a/src/weather_model_graphs/create/mesh/layout/rectilinear.py b/src/weather_model_graphs/create/mesh/layout/rectilinear.py new file mode 100644 index 0000000..eb42755 --- /dev/null +++ b/src/weather_model_graphs/create/mesh/layout/rectilinear.py @@ -0,0 +1,313 @@ +""" +Rectilinear mesh layout: coordinate creation for uniform rectangular grids. + +Uses ``networkx.grid_2d_graph`` to produce a rectilinear lattice with +4-star (cardinal) and 8-star (cardinal + diagonal) spatial adjacency edges. + +This is the coordinate creation step in the two-step mesh creation process: + +1. **Coordinate creation** (this module) -> ``nx.Graph`` with ``pos``, ``type``, + and ``adjacency_type`` attributes. +2. **Connectivity creation** (``create_directed_mesh_graph`` in + ``connectivity.general``) -> ``nx.DiGraph`` with ``len`` and ``vdiff`` + edge attributes. +""" + +from typing import List + +import networkx +import numpy as np +from loguru import logger + +from ..connectivity.general import create_directed_mesh_graph + + +def create_single_level_2d_mesh_primitive( + xy: np.ndarray, + nx: int = None, + ny: int = None, + *, + mesh_node_spacing: float = None, +) -> networkx.Graph: + """ + Create an undirected mesh primitive graph (nx.Graph) with node positions + and spatial adjacency edges, representing the coordinate creation step. + + A mesh primitive is an undirected graph that encodes all potential + neighbourhood connectivity edges. It serves as a blueprint from which + directed connectivity graphs can later be built by selecting a subset + of edges (e.g. 4-star or 8-star pattern). + + This produces a graph where: + - Nodes have a ``"pos"`` attribute (np.ndarray of shape [2,] with x and y + coordinates) and a ``"type"`` attribute (str, always ``"mesh"``). + - Edges have an ``"adjacency_type"`` attribute (str): ``"cardinal"`` for + horizontal/vertical neighbours (4-star connectivity) or ``"diagonal"`` + for diagonal neighbours (additional edges in 8-star connectivity). + + This is the first step in the two-step mesh creation process: + 1. Coordinate creation (this function) -> nx.Graph with spatial adjacency + 2. Connectivity creation (create_directed_mesh_graph) -> nx.DiGraph + + Either provide ``nx`` and ``ny`` directly, or provide + ``mesh_node_spacing`` to have them computed automatically from the + coordinate extent of ``xy``. + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped [N_grid_points, 2], with first column + representing x coordinates and second column y coordinates. + nx : int, optional + Number of nodes in x direction. If not given, computed from + ``mesh_node_spacing``. + ny : int, optional + Number of nodes in y direction. If not given, computed from + ``mesh_node_spacing``. + mesh_node_spacing : float, optional + Distance between mesh nodes (in coordinate units). When provided, + ``nx`` and ``ny`` are computed as + ``int(range / mesh_node_spacing)`` and validated to be > 0. + + Returns + ------- + networkx.Graph + Undirected mesh primitive graph with node positions and annotated + spatial adjacency edges. + """ + if mesh_node_spacing is not None: + range_x, range_y = np.ptp(xy, axis=0) + nx = int(range_x / mesh_node_spacing) + ny = int(range_y / mesh_node_spacing) + if nx == 0 or ny == 0: + raise ValueError( + "The given `mesh_node_spacing` is too large for the provided " + f"coordinates. Got mesh_node_spacing={mesh_node_spacing}, but the " + f"x-range is {range_x} and y-range is {range_y}. Maybe you " + "want to decrease the `mesh_node_spacing` so that the mesh nodes " + "are spaced closer together?" + ) + elif nx is None or ny is None: + raise ValueError( + "Either provide both `nx` and `ny`, or provide " + "`mesh_node_spacing` to compute them automatically." + ) + xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) + ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) + + # avoid nodes on border + dx = (xM - xm) / nx + dy = (yM - ym) / ny + lx = np.linspace(xm + dx / 2, xM - dx / 2, nx) + ly = np.linspace(ym + dy / 2, yM - dy / 2, ny) + + mg = np.meshgrid(lx, ly) + g = networkx.grid_2d_graph(len(lx), len(ly)) + + # Node name and `pos` attribute takes form (x, y) + for node in g.nodes: + node_xi, node_yi = node # Extract x and y index from node to index mx + g.nodes[node]["pos"] = np.array( + [mg[0][node_yi, node_xi], mg[1][node_yi, node_xi]] + ) + g.nodes[node]["type"] = "mesh" + + # Mark existing grid_2d_graph edges as cardinal (4-star adjacency) + for u, v in g.edges(): + g.edges[u, v]["adjacency_type"] = "cardinal" + + # Add diagonal edges (8-star adjacency) + diagonal_edges = [ + ((x, y), (x + 1, y + 1)) for x in range(nx - 1) for y in range(ny - 1) + ] + [((x + 1, y), (x, y + 1)) for x in range(nx - 1) for y in range(ny - 1)] + g.add_edges_from(diagonal_edges) + for u, v in diagonal_edges: + g.edges[u, v]["adjacency_type"] = "diagonal" + + g.graph["dx"] = dx + g.graph["dy"] = dy + + return g + + +def create_single_level_2d_mesh_graph( + xy: np.ndarray, nx: int, ny: int +) -> networkx.DiGraph: + """ + Create directed graph with nx * ny nodes representing a 2D grid with + positions spanning the range of xy coordinate values (first dimension + is assumed to be x and y coordinate values respectively). Each nodes is + connected to its eight nearest neighbours, both horizontally, vertically + and diagonally as directed edges (which means that the graph contains two + edges between each pair of connected nodes). + + The nodes contain a "pos" attribute with the x and y + coordinates of the node, and an "type" attribute with the + type of the node (i.e. "mesh" for mesh nodes). + + The edges contain a "len" attribute with the length of the edge + and a "vdiff" attribute with the vector difference between the + nodes. + + Internally, this uses the two-step process: + 1. create_single_level_2d_mesh_primitive (coordinate creation) + 2. create_directed_mesh_graph (connectivity creation, pattern="8-star") + + Parameters + ---------- + xy : np.ndarray [N_grid_points, 2] + Grid point coordinates, with first column representing + x coordinates and second column y coordinates. N_grid_points is the + total number of grid points. + nx : int + Number of nodes in x direction + ny : int + Number of nodes in y direction + + Returns + ------- + networkx.DiGraph + Graph representing the 2D grid + """ + G_coords = create_single_level_2d_mesh_primitive(xy, nx, ny) + return create_directed_mesh_graph(G_coords, pattern="8-star") + + +def create_multirange_2d_mesh_primitives( + max_num_levels: int, + xy: np.ndarray, + mesh_node_spacing: float = 3, + interlevel_refinement_factor: float = 3, +) -> List[networkx.Graph]: + """ + Create a list of undirected mesh primitive graphs (nx.Graph) representing + different levels of mesh resolution spanning the spatial domain of the + xy coordinates. + + This is the coordinate creation step for multi-level and hierarchical mesh + graphs. Each returned graph contains nodes with spatial positions and edges + annotated with adjacency type (``"cardinal"`` or ``"diagonal"``). + + The graphs can be consumed by connectivity creation functions to produce + directed mesh graphs for flat_multiscale or hierarchical architectures. + + Parameters + ---------- + max_num_levels : int + Number of edge-distance levels in mesh graph + xy : np.ndarray + Grid point coordinates, shaped [N_grid_points, 2] + mesh_node_spacing : float + Distance (in x- and y-direction) between created mesh nodes, + in coordinate system of xy + interlevel_refinement_factor : float + Refinement factor between grid points and bottom level of mesh hierarchy + + Returns + ------- + G_all_levels : list of networkx.Graph + List of undirected mesh primitive graphs for each level, each with + node positions and annotated spatial adjacency edges. + Each graph has ``"level"`` and ``"interlevel_refinement_factor"`` + graph attributes. + """ + # Compute the size along x and y direction of area to cover with graph + # This is measured in the Cartesian coordinates of xy + coord_extent = np.ptp(xy, axis=0) + # Number of nodes that would fit on bottom level of hierarchy, + # in both directions + max_nodes_bottom = (coord_extent / mesh_node_spacing).astype(int) + + # Find the number of mesh levels possible in x- and y-direction, + # and the number of leaf nodes that would correspond to + # max_nodes_bottom/(interlevel_refinement_factor^mesh_levels) = 1 + max_mesh_levels_float = np.log(max_nodes_bottom) / np.log( + interlevel_refinement_factor + ) + + max_mesh_levels = max_mesh_levels_float.astype(int) # (2,) + nleaf = interlevel_refinement_factor**max_mesh_levels + # leaves at the bottom in each direction, if using max_mesh_levels + + # As we can not instantiate different number of mesh levels in each + # direction, create mesh levels corresponding to the minimum of the two + mesh_levels_to_create = max_mesh_levels.min() + + if max_num_levels: + # Limit the levels in mesh graph + mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) + + logger.debug(f"mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}") + + # multi resolution tree levels + G_all_levels = [] + for lev in range(mesh_levels_to_create): # 0-index mesh levels + # Compute number of nodes on level separate for each direction + nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) + g = create_single_level_2d_mesh_primitive(xy, nodes_x, nodes_y) + # Add level information to nodes, edges and full graph + for node in g.nodes: + g.nodes[node]["level"] = lev + for edge in g.edges: + g.edges[edge]["level"] = lev + g.graph["level"] = lev + # Store refinement factor so connectivity step can use it + g.graph["interlevel_refinement_factor"] = interlevel_refinement_factor + G_all_levels.append(g) + + return G_all_levels + + +def create_multirange_2d_mesh_graphs( + max_num_levels: int, + xy: np.ndarray, + mesh_node_distance: float = 3, + level_refinement_factor: float = 3, + pattern: str = "8-star", +) -> List[networkx.DiGraph]: + """ + Create a list of 2D grid mesh graphs representing different levels of edge-length + scales spanning the spatial domain of the xy coordinates. + This list of graphs can then later be for example a) flattened into single graph + containing multiple ranges of connections or b) combined into a hierarchical graph. + + Each graph in the list contains a "level" attribute with the level index of the graph. + + Internally uses the two-step process: + 1. create_multirange_2d_mesh_primitives (coordinate creation) + 2. create_directed_mesh_graph (connectivity creation) + + Parameters + ---------- + max_num_levels : int + Number of edge-distance levels in mesh graph + xy : np.ndarray + Grid point coordinates, shaped [N_grid_points, 2] + mesh_node_distance : float + Distance (in x- and y-direction) between created mesh nodes, + in coordinate system of xy + level_refinement_factor : float + Refinement factor between grid points and bottom level of mesh hierarchy + pattern : str + Connectivity pattern for directed graph creation: ``"4-star"`` or + ``"8-star"`` (default: ``"8-star"``) + + Returns + ------- + G_all_levels : list of networkx.DiGraph + List of networkx graphs for each level representing the connectivity + of the mesh within each level + """ + G_coords_list = create_multirange_2d_mesh_primitives( + max_num_levels=max_num_levels, + xy=xy, + mesh_node_spacing=mesh_node_distance, + interlevel_refinement_factor=level_refinement_factor, + ) + + G_all_levels = [] + for g_coords in G_coords_list: + g_directed = create_directed_mesh_graph(g_coords, pattern=pattern) + G_all_levels.append(g_directed) + + return G_all_levels diff --git a/src/weather_model_graphs/create/mesh/layout/triangular.py b/src/weather_model_graphs/create/mesh/layout/triangular.py new file mode 100644 index 0000000..6e87a0b --- /dev/null +++ b/src/weather_model_graphs/create/mesh/layout/triangular.py @@ -0,0 +1,218 @@ +""" +Triangular mesh layout: coordinate creation for regular triangular lattices. + +Uses ``networkx.triangular_lattice_graph`` to produce an equilateral-triangle +lattice with 6-connectivity (each interior node has 6 neighbours). This +mirrors the rectilinear layout (which uses ``networkx.grid_2d_graph`` +with 8-connectivity) and plugs into the same two-step process: + +1. **Coordinate creation** (this module) -> ``nx.Graph`` with ``pos``, ``type``, + and ``adjacency_type`` attributes. +2. **Connectivity creation** (``create_directed_mesh_graph`` in + ``connectivity.general``) -> ``nx.DiGraph`` with ``len`` and ``vdiff`` + edge attributes. +""" + +from typing import List + +import networkx +import numpy as np +from loguru import logger + +from ..connectivity.general import create_directed_mesh_graph + + +def create_single_level_2d_triangular_mesh_primitive( + xy: np.ndarray, nx: int, ny: int +) -> networkx.Graph: + """ + Create an undirected triangular mesh primitive graph (``nx.Graph``) with + node positions and spatial adjacency edges. + + This is analogous to ``create_single_level_2d_mesh_primitive`` in the + rectilinear layout but uses ``networkx.triangular_lattice_graph`` instead + of ``grid_2d_graph``. + + In a triangular lattice, each interior node has 6 neighbours (vs. 8 for + the rectilinear lattice with diagonals), providing more isotropic message + passing. + + The nodes form a grid of ``(ny + 1)`` rows and ``(nx + 1) // 2`` columns, + with odd-row nodes shifted horizontally. Positions are scaled and offset + so that the mesh spans the coordinate domain of *xy* (with nodes inset + from the border by half a cell width in each direction). + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + nx : int + Number of triangle columns (passed as *n* to + ``triangular_lattice_graph``). + ny : int + Number of triangle rows (passed as *m* to + ``triangular_lattice_graph``). + + Returns + ------- + networkx.Graph + Undirected mesh primitive graph. Node attributes: ``pos`` + (np.ndarray[2,]), ``type`` (``"mesh"``). Edge attributes: + ``adjacency_type`` (always ``"cardinal"`` -- triangular lattices have + only one class of edge). Graph attributes: ``dx``, ``dy``. + """ + xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) + ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) + + # Create the raw triangular lattice + g_raw = networkx.triangular_lattice_graph(ny, nx, with_positions=True) + + if g_raw.number_of_nodes() == 0: + raise ValueError( + f"triangular_lattice_graph({ny}, {nx}) produced 0 nodes. " + "Increase nx/ny or decrease mesh_node_spacing." + ) + + # Gather raw positions to compute extent + raw_positions = np.array([g_raw.nodes[n]["pos"] for n in g_raw.nodes()]) + raw_xmin, raw_ymin = raw_positions.min(axis=0) + raw_xmax, raw_ymax = raw_positions.max(axis=0) + raw_extent_x = raw_xmax - raw_xmin + raw_extent_y = raw_ymax - raw_ymin + + # Domain extent with half-cell inset + domain_x = xM - xm + domain_y = yM - ym + + # Scale factors -- map raw lattice extent to domain extent (inset by half + # a cell in each direction, mirroring the rectilinear approach) + if raw_extent_x > 0: + scale_x = domain_x / (raw_extent_x + 1.0) # +1 for inset + else: + scale_x = domain_x # single column + if raw_extent_y > 0: + scale_y = domain_y / (raw_extent_y + np.sqrt(3) / 2) # +row_h for inset + else: + scale_y = domain_y # single row + + # Effective dx/dy for graph attributes + dx = scale_x + dy = scale_y * (np.sqrt(3) / 2) + + # Offset so mesh is centred within domain + offset_x = xm + (domain_x - raw_extent_x * scale_x) / 2 + offset_y = ym + (domain_y - raw_extent_y * scale_y) / 2 + + # Build output graph with scaled positions + g = networkx.Graph() + for node in g_raw.nodes(): + raw_pos = g_raw.nodes[node]["pos"] + pos = np.array( + [ + offset_x + (raw_pos[0] - raw_xmin) * scale_x, + offset_y + (raw_pos[1] - raw_ymin) * scale_y, + ] + ) + g.add_node(node, pos=pos, type="mesh") + + for u, v in g_raw.edges(): + g.add_edge(u, v, adjacency_type="cardinal") + + g.graph["dx"] = dx + g.graph["dy"] = dy + + return g + + +def create_multirange_2d_triangular_mesh_primitives( + max_num_levels, + xy: np.ndarray, + mesh_node_spacing: float = 3, + interlevel_refinement_factor: int = 3, +) -> List[networkx.Graph]: + """ + Create a list of undirected triangular mesh primitive graphs representing + different levels of mesh resolution. + + Mirrors ``create_multirange_2d_mesh_primitives`` in the rectilinear layout + but uses triangular lattice topology at each level. + + Parameters + ---------- + max_num_levels : int + Maximum number of levels in the multi-scale graph. + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + mesh_node_spacing : float + Distance between mesh nodes at the finest level, in coordinate units. + interlevel_refinement_factor : int + Factor by which mesh node count decreases per level. + + Returns + ------- + list[networkx.Graph] + Triangular mesh primitive graphs, one per level. + """ + coord_extent = np.ptp(xy, axis=0) + # For triangular lattice, ny accounts for row spacing of sqrt(3)/2 + max_nx = int(coord_extent[0] / mesh_node_spacing) + max_ny = int(coord_extent[1] / (mesh_node_spacing * np.sqrt(3) / 2)) + + max_nodes_bottom = np.array([max_nx, max_ny]) + + max_mesh_levels_float = np.log(max_nodes_bottom) / np.log( + interlevel_refinement_factor + ) + max_mesh_levels = max_mesh_levels_float.astype(int) + nleaf = interlevel_refinement_factor**max_mesh_levels + + mesh_levels_to_create = max_mesh_levels.min() + if max_num_levels: + mesh_levels_to_create = min(mesh_levels_to_create, max_num_levels) + + logger.debug(f"triangular mesh_levels: {mesh_levels_to_create}, nleaf: {nleaf}") + + G_all_levels = [] + for lev in range(mesh_levels_to_create): + nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) + g = create_single_level_2d_triangular_mesh_primitive(xy, nodes_x, nodes_y) + for node in g.nodes: + g.nodes[node]["level"] = lev + for edge in g.edges: + g.edges[edge]["level"] = lev + g.graph["level"] = lev + g.graph["interlevel_refinement_factor"] = interlevel_refinement_factor + G_all_levels.append(g) + + return G_all_levels + + +def create_single_level_2d_triangular_mesh_graph( + xy: np.ndarray, nx: int, ny: int +) -> networkx.DiGraph: + """ + Create a directed triangular mesh graph from coordinates. + + Internally uses the two-step process: + 1. ``create_single_level_2d_triangular_mesh_primitive`` (coordinate creation) + 2. ``create_directed_mesh_graph`` (connectivity creation) + + For triangular lattices, *all* edges are ``"cardinal"`` so patterns + ``"4-star"`` and ``"8-star"`` produce the same result (6-connectivity). + + Parameters + ---------- + xy : np.ndarray + Grid point coordinates, shaped ``[N_grid_points, 2]``. + nx : int + Number of triangle columns. + ny : int + Number of triangle rows. + + Returns + ------- + networkx.DiGraph + Directed triangular mesh graph. + """ + G_coords = create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) + return create_directed_mesh_graph(G_coords, pattern="4-star") diff --git a/tests/test_mesh_layout.py b/tests/test_mesh_layout.py index 594481e..4b0e74d 100644 --- a/tests/test_mesh_layout.py +++ b/tests/test_mesh_layout.py @@ -34,7 +34,7 @@ from weather_model_graphs.create.mesh.connectivity.hierarchical import ( create_hierarchical_from_coordinates, ) -from weather_model_graphs.create.mesh.coords import ( +from weather_model_graphs.create.mesh.layout.rectilinear import ( create_multirange_2d_mesh_primitives, create_single_level_2d_mesh_primitive, ) diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py index 1e41ada..66179a0 100644 --- a/tests/test_triangular_mesh.py +++ b/tests/test_triangular_mesh.py @@ -1,17 +1,16 @@ -""" +""" Tests for mesh_layout="triangular" support (Issue #80). Tests verify: 1. Primitive creation (node count, positions, adjacency_type, type attrs) 2. Single-level directed graph (bidirectional edges, len/vdiff attrs, 6-connectivity) 3. Multirange primitive creation -4. Flat single-scale mesh graph via wrapper + integration -5. Flat multiscale mesh graph (position-based merging) -6. Hierarchical mesh graph -7. Integration through create_all_graph_components for all m2m_connectivity modes -8. Edge cases (spacing too large, single-level hierarchical) -9. Numerical correctness (len symmetry, vdiff reciprocity) -10. Pattern equivalence (4-star == 8-star for triangular) +4. Flat multiscale mesh graph (position-based merging via two-step API) +5. Hierarchical mesh graph (triangular primitives + generic hierarchical connectivity) +6. Integration through create_all_graph_components for all m2m_connectivity modes +7. Edge cases (zero nodes, single-level hierarchical) +8. Numerical correctness (len symmetry, vdiff reciprocity) +9. Pattern equivalence (4-star == 8-star for triangular) """ import networkx as nx @@ -23,11 +22,13 @@ from weather_model_graphs.create.mesh.connectivity.general import ( create_directed_mesh_graph, ) +from weather_model_graphs.create.mesh.connectivity.hierarchical import ( + create_hierarchical_from_coordinates, +) from weather_model_graphs.create.mesh.connectivity.triangular import ( create_flat_multiscale_from_triangular_coordinates, - create_flat_multiscale_triangular_mesh_graph, - create_flat_singlescale_triangular_mesh_graph, - create_hierarchical_triangular_mesh_graph, +) +from weather_model_graphs.create.mesh.layout.triangular import ( create_multirange_2d_triangular_mesh_primitives, create_single_level_2d_triangular_mesh_graph, create_single_level_2d_triangular_mesh_primitive, @@ -472,109 +473,45 @@ def test_minimal_grid(self, xy_small): assert G.number_of_nodes() >= 2 -# =========================== -# Flat single-scale -# =========================== - - -class TestFlatSinglescaleTriangular: - """Tests for create_flat_singlescale_triangular_mesh_graph.""" - - def test_returns_digraph(self, xy_small): - G = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=2.0 - ) - assert isinstance(G, nx.DiGraph) - - def test_nodes_have_pos(self, xy_small): - G = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=2.0 - ) - for node in G.nodes: - assert "pos" in G.nodes[node] - - def test_raises_on_large_spacing(self, xy_small): - """Spacing larger than domain should raise.""" - with pytest.raises(ValueError, match="too large"): - create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=100.0 - ) - - def test_edges_are_bidirectional(self, xy_small): - """All edges should have a reverse.""" - G = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=2.0 - ) - for u, v in G.edges(): - assert G.has_edge(v, u) - - def test_smaller_spacing_more_nodes(self, xy_small): - """Smaller mesh_node_distance should produce more nodes.""" - G_coarse = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=3.0 - ) - G_fine = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=1.5 - ) - assert G_fine.number_of_nodes() > G_coarse.number_of_nodes() - - def test_rectangular_domain(self, xy_rectangular): - """Should work with non-square domains.""" - G = create_flat_singlescale_triangular_mesh_graph( - xy_rectangular, mesh_node_distance=2.0 - ) - assert isinstance(G, nx.DiGraph) - assert G.number_of_nodes() > 0 - - def test_no_nan_positions(self, xy_small): - """No node should have NaN or Inf positions.""" - G = create_flat_singlescale_triangular_mesh_graph( - xy_small, mesh_node_distance=2.0 - ) - for node in G.nodes: - pos = G.nodes[node]["pos"] - assert np.isfinite(pos).all() - - def test_spacing_just_fits(self): - """Spacing that just fits one cell should work.""" - xy = np.array([[0, 0], [5, 0], [0, 5], [5, 5]], dtype=float) - G = create_flat_singlescale_triangular_mesh_graph(xy, mesh_node_distance=4.0) - assert G.number_of_nodes() >= 2 - - # =========================== # Flat multiscale (triangular-specific merging) # =========================== class TestFlatMultiscaleTriangular: - """Tests for the triangular flat multiscale graph and position-based merging.""" + """Tests for flat multiscale triangular mesh graph using two-step API. + + Uses ``create_multirange_2d_triangular_mesh_primitives`` (coordinate + creation) followed by ``create_flat_multiscale_from_triangular_coordinates`` + (connectivity creation with position-based merging). + """ + + def _create_multiscale( + self, + xy, + mesh_node_spacing=2.0, + interlevel_refinement_factor=3, + max_num_levels=3, + ): + """Helper: create primitives then apply position-based merging.""" + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=max_num_levels, + xy=xy, + mesh_node_spacing=mesh_node_spacing, + interlevel_refinement_factor=interlevel_refinement_factor, + ) + return create_flat_multiscale_from_triangular_coordinates(G_coords_list) def test_returns_digraph(self, xy_medium): - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) assert isinstance(G, nx.DiGraph) def test_has_edges(self, xy_medium): - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) assert G.number_of_edges() > 0 def test_edges_have_len_and_vdiff(self, xy_medium): - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) for u, v, d in G.edges(data=True): assert "len" in d assert "vdiff" in d @@ -594,34 +531,19 @@ def test_fewer_nodes_than_sum_of_levels(self, xy_medium): assert G.number_of_nodes() <= total_raw def test_graph_has_dx_dy_dicts(self, xy_medium): - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) assert isinstance(G.graph.get("dx"), dict) assert isinstance(G.graph.get("dy"), dict) def test_bidirectional_edges(self, xy_medium): """All edges should have a reverse.""" - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) for u, v in G.edges(): assert G.has_edge(v, u), f"Edge ({u},{v}) no reverse" def test_nodes_have_pos(self, xy_medium): """All nodes should have pos attribute.""" - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) for node in G.nodes: assert "pos" in G.nodes[node] assert np.isfinite(G.nodes[node]["pos"]).all() @@ -629,34 +551,19 @@ def test_nodes_have_pos(self, xy_medium): def test_single_level_multiscale(self): """When domain only supports 1 level, flat_multiscale should still work.""" xy = np.array([[0, 0], [3, 0], [0, 3], [3, 3]], dtype=float) - G = create_flat_multiscale_triangular_mesh_graph( - xy, - mesh_node_distance=1.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy, mesh_node_spacing=1.0) assert isinstance(G, nx.DiGraph) assert G.number_of_nodes() > 0 def test_refinement_factor_2(self, xy_medium): """Refinement factor of 2 should work.""" - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=2, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium, interlevel_refinement_factor=2) assert isinstance(G, nx.DiGraph) assert G.number_of_edges() > 0 def test_no_self_loops(self, xy_medium): """No self-loops in flat multiscale graph.""" - G = create_flat_multiscale_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_multiscale(xy_medium) for u, v in G.edges(): assert u != v @@ -681,44 +588,46 @@ def test_more_nodes_than_coarsest_level(self, xy_large): class TestHierarchicalTriangular: - """Tests for create_hierarchical_triangular_mesh_graph.""" + """Tests for hierarchical mesh graph from triangular primitives. + + Uses ``create_multirange_2d_triangular_mesh_primitives`` (coordinate + creation) followed by ``create_hierarchical_from_coordinates`` (generic + hierarchical connectivity creation). + """ + + def _create_hierarchical( + self, + xy, + mesh_node_spacing=2.0, + interlevel_refinement_factor=3, + max_num_levels=3, + **kwargs, + ): + """Helper: create primitives then apply hierarchical connectivity.""" + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=max_num_levels, + xy=xy, + mesh_node_spacing=mesh_node_spacing, + interlevel_refinement_factor=interlevel_refinement_factor, + ) + return create_hierarchical_from_coordinates(G_coords_list, **kwargs) def test_returns_digraph(self, xy_medium): - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) assert isinstance(G, nx.DiGraph) def test_has_edges(self, xy_medium): - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) assert G.number_of_edges() > 0 def test_edges_have_level_attribute(self, xy_medium): - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) for u, v, d in G.edges(data=True): # Intra-level edges have 'level', inter-level have 'levels' assert "level" in d or "levels" in d def test_multiple_levels_present(self, xy_medium): - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) levels = set() for u, v, d in G.edges(data=True): if "level" in d: @@ -730,81 +639,52 @@ def test_multiple_levels_present(self, xy_medium): assert len(levels) >= 2, "Expected multiple levels in hierarchical graph" def test_single_level_raises(self, xy_small): - """Hierarchical requires ΓëÑ2 levels; too-coarse spacing should raise.""" + """Hierarchical requires >= 2 levels; single level should raise.""" + G_coords_list = create_multirange_2d_triangular_mesh_primitives( + max_num_levels=1, + xy=xy_small, + mesh_node_spacing=2.0, + interlevel_refinement_factor=3, + ) with pytest.raises(ValueError): - create_hierarchical_triangular_mesh_graph( - xy_small, - mesh_node_distance=20.0, - level_refinement_factor=3, - max_num_levels=3, - ) + create_hierarchical_from_coordinates(G_coords_list) def test_nodes_have_pos(self, xy_medium): """All nodes should have pos attribute.""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) for node in G.nodes: assert "pos" in G.nodes[node] assert np.isfinite(G.nodes[node]["pos"]).all() def test_custom_intra_level(self, xy_medium): """Custom intra_level pattern should be accepted.""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - intra_level={"pattern": "8-star"}, - ) + G = self._create_hierarchical(xy_medium, intra_level={"pattern": "8-star"}) assert isinstance(G, nx.DiGraph) assert G.number_of_edges() > 0 def test_custom_inter_level(self, xy_medium): """Custom inter_level config should be accepted.""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - inter_level={"pattern": "nearest", "k": 3}, + G = self._create_hierarchical( + xy_medium, inter_level={"pattern": "nearest", "k": 3} ) assert isinstance(G, nx.DiGraph) assert G.number_of_edges() > 0 def test_no_self_loops(self, xy_medium): """Hierarchical graph should have no self-loops.""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) for u, v in G.edges(): assert u != v def test_has_inter_level_edges(self, xy_medium): """Should have inter-level edges connecting different levels.""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) inter_level_count = sum(1 for _, _, d in G.edges(data=True) if "levels" in d) assert inter_level_count > 0 def test_inter_level_edges_have_direction(self, xy_medium): """Inter-level edges should have 'direction' attribute (up/down).""" - G = create_hierarchical_triangular_mesh_graph( - xy_medium, - mesh_node_distance=2.0, - level_refinement_factor=3, - max_num_levels=3, - ) + G = self._create_hierarchical(xy_medium) for u, v, d in G.edges(data=True): if "levels" in d: assert "direction" in d @@ -1034,9 +914,7 @@ class TestNumericalCorrectness: """Test numerical properties of the triangular mesh graph.""" def test_edge_lengths_positive(self, xy_medium): - G = create_flat_singlescale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0 - ) + G = create_single_level_2d_triangular_mesh_graph(xy_medium, nx=5, ny=5) for u, v, d in G.edges(data=True): assert d["len"] > 0 @@ -1096,9 +974,7 @@ def test_scaled_domain_produces_scaled_lengths(self): def test_no_nan_in_positions(self, xy_medium): """No node should have NaN in positions.""" - G = create_flat_singlescale_triangular_mesh_graph( - xy_medium, mesh_node_distance=2.0 - ) + G = create_single_level_2d_triangular_mesh_graph(xy_medium, nx=5, ny=5) for node in G.nodes: pos = G.nodes[node]["pos"] assert isinstance(pos, np.ndarray) From de516b8a3d1b5288a01874c800a299a6a4040266 Mon Sep 17 00:00:00 2001 From: prajwal Date: Wed, 10 Jun 2026 21:50:36 +0530 Subject: [PATCH 08/16] Apply pre-commit formatting (isort, black pinned versions) --- src/weather_model_graphs/create/base.py | 8 ++++---- src/weather_model_graphs/create/mesh/__init__.py | 4 +--- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index 28ae3a7..cfc841e 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -397,10 +397,10 @@ def create_all_graph_components( if pattern is None: pattern = "4-star" if mesh_layout == "triangular" else "8-star" if mesh_layout == "triangular": - graph_components["m2m"] = ( - create_flat_multiscale_from_triangular_coordinates( - G_mesh_coords, pattern=pattern - ) + graph_components[ + "m2m" + ] = create_flat_multiscale_from_triangular_coordinates( + G_mesh_coords, pattern=pattern ) else: graph_components["m2m"] = create_flat_multiscale_from_coordinates( diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index 0de2727..bba1732 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -1,7 +1,5 @@ from .connectivity.general import create_directed_mesh_graph -from .connectivity.triangular import ( - create_flat_multiscale_from_triangular_coordinates, -) +from .connectivity.triangular import create_flat_multiscale_from_triangular_coordinates from .layout.rectilinear import ( create_multirange_2d_mesh_graphs, create_multirange_2d_mesh_primitives, From e053338368e22c89aeb0b79cfa2671827d288369 Mon Sep 17 00:00:00 2001 From: prajwal Date: Tue, 23 Jun 2026 22:53:14 +0530 Subject: [PATCH 09/16] Address review: mesh_layout from v0.5.0, reword layout docstring - docs/mesh_layout.ipynb: note mesh_layout is supported from v0.5.0 (was v0.4.0) - layout/__init__.py: describe layouts in plain terms instead of naming the internal networkx helpers (grid_2d_graph / triangular_lattice_graph) --- docs/mesh_layout.ipynb | 2 +- src/weather_model_graphs/create/mesh/layout/__init__.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb index c6e4a00..5b107b0 100644 --- a/docs/mesh_layout.ipynb +++ b/docs/mesh_layout.ipynb @@ -11,7 +11,7 @@ "By default, `weather-model-graphs` uses a **rectilinear** mesh, where nodes sit on a regular\n", "rectangular grid and edges connect each node to its 8 nearest neighbours (cardinal + diagonal).\n", "\n", - "As of v0.4.0, a **triangular** mesh layout is also supported. This places nodes on an equilateral-\n", + "As of v0.5.0, a **triangular** mesh layout is also supported. This places nodes on an equilateral-\n", "triangle lattice, giving each interior node exactly 6 neighbours instead of 8. The 6-connectivity\n", "is more isotropic and is expected to improve message-passing in graph neural network weather models.\n", "\n", diff --git a/src/weather_model_graphs/create/mesh/layout/__init__.py b/src/weather_model_graphs/create/mesh/layout/__init__.py index 817fd83..76d4cb3 100644 --- a/src/weather_model_graphs/create/mesh/layout/__init__.py +++ b/src/weather_model_graphs/create/mesh/layout/__init__.py @@ -7,8 +7,8 @@ Available layouts: -- ``rectilinear``: Uniform rectangular grid (``grid_2d_graph``). -- ``triangular``: Regular triangular lattice (``triangular_lattice_graph``). +- ``rectilinear``: nodes placed on a uniform rectangular grid. +- ``triangular``: nodes placed on a regular (equilateral) triangular lattice. """ from . import rectilinear, triangular From f5b2d0ed60f768639ebb53aff30804217292360e Mon Sep 17 00:00:00 2001 From: prajwal Date: Wed, 24 Jun 2026 15:30:32 +0530 Subject: [PATCH 10/16] Address review: move DiGraph building into connectivity, generalize multiscale, simplify base.py Implements the approved PR #92 review comments: - layout/ now produces only undirected coordinate primitives; all DiGraph construction lives in connectivity/. Removed create_single_level_2d_triangular_mesh_graph and the layout->connectivity import (#4). - Generalized create_flat_multiscale_from_coordinates to handle both layouts: rectilinear keeps the exact index-arithmetic merge (output unchanged), triangular falls back to position-based KD-tree matching. Per-layout selection uses the 'diagonal' adjacency signature and the odd-refinement-factor check now only guards the index path. Deleted create_flat_multiscale_from_triangular_coordinates (#5, #8). - create_single_level_2d_triangular_mesh_primitive now accepts mesh_node_spacing and computes nx/ny internally, mirroring the rectilinear primitive (#6). - base.py: swapped the mesh_layout/m2m_connectivity if-nesting so m2m_connectivity is outer and the primitive function is picked by mesh_layout, removing duplicated spacing handling (#7). - Dropped the no-op triangular 'pattern' special-casing; the lattice fully determines triangular connectivity (#2). - Renamed the unsupported-layout test placeholder 'hexagonal' -> 'nonexistent_layout' (#9). All 299 tests pass; rectilinear output is unchanged by construction. --- src/weather_model_graphs/create/base.py | 134 ++++++------------ .../create/mesh/__init__.py | 3 +- .../create/mesh/connectivity/flat.py | 133 +++++++++++++---- .../create/mesh/connectivity/triangular.py | 103 -------------- .../create/mesh/layout/triangular.py | 75 +++++----- tests/test_mesh_layout.py | 2 +- tests/test_triangular_mesh.py | 24 +++- 7 files changed, 208 insertions(+), 266 deletions(-) delete mode 100644 src/weather_model_graphs/create/mesh/connectivity/triangular.py diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index cfc841e..f5fd1cb 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -29,9 +29,6 @@ create_flat_singlescale_from_coordinates, ) from .mesh.connectivity.hierarchical import create_hierarchical_from_coordinates -from .mesh.connectivity.triangular import ( - create_flat_multiscale_from_triangular_coordinates, -) from .mesh.layout.rectilinear import ( create_multirange_2d_mesh_primitives, create_single_level_2d_mesh_primitive, @@ -281,91 +278,59 @@ def create_all_graph_components( stacklevel=2, ) - if mesh_layout == "rectilinear": - mesh_node_spacing = mesh_layout_kwargs.get( - "mesh_node_spacing" - ) or mesh_layout_kwargs.get("grid_spacing") - if mesh_node_spacing is None: - raise ValueError( - "mesh_layout='rectilinear' requires 'mesh_node_spacing' in " - "mesh_layout_kwargs (or 'mesh_node_distance' in " - "m2m_connectivity_kwargs for backward compatibility)." - ) + # Validate mesh_layout and resolve the requested mesh node spacing once + # (shared by all m2m_connectivity modes and both layouts). + if mesh_layout not in ("rectilinear", "triangular"): + raise NotImplementedError( + f"mesh_layout='{mesh_layout}' is not yet supported. " + "Currently supported: 'rectilinear', 'triangular'." + ) + + mesh_node_spacing = mesh_layout_kwargs.get( + "mesh_node_spacing" + ) or mesh_layout_kwargs.get("grid_spacing") + if mesh_node_spacing is None: + raise ValueError( + f"mesh_layout='{mesh_layout}' requires 'mesh_node_spacing' in " + "mesh_layout_kwargs (or 'mesh_node_distance' in " + "m2m_connectivity_kwargs for backward compatibility)." + ) - if m2m_connectivity == "flat": - # Single-level mesh + # Pick the coordinate-creation function based on the mesh_layout value, + # nested inside the m2m_connectivity branch (single-level vs multi-level). + if m2m_connectivity == "flat": + # Single-level mesh primitive + if mesh_layout == "rectilinear": G_mesh_coords = create_single_level_2d_mesh_primitive( xy, mesh_node_spacing=mesh_node_spacing ) - else: - # Multi-level mesh: build kwargs for create_multirange_2d_mesh_primitives - primitives_kwargs = dict(xy=xy, mesh_node_spacing=mesh_node_spacing) - if "refinement_factor" in mesh_layout_kwargs: - primitives_kwargs["interlevel_refinement_factor"] = mesh_layout_kwargs[ - "refinement_factor" - ] - if "max_num_refinement_levels" in mesh_layout_kwargs: - primitives_kwargs["max_num_levels"] = mesh_layout_kwargs[ - "max_num_refinement_levels" - ] - G_mesh_coords = create_multirange_2d_mesh_primitives(**primitives_kwargs) - - elif mesh_layout == "triangular": - mesh_node_spacing = mesh_layout_kwargs.get( - "mesh_node_spacing" - ) or mesh_layout_kwargs.get("grid_spacing") - if mesh_node_spacing is None: - raise ValueError( - "mesh_layout='triangular' requires 'mesh_node_spacing' in " - "mesh_layout_kwargs (or 'mesh_node_distance' in " - "m2m_connectivity_kwargs for backward compatibility)." - ) - - if m2m_connectivity == "flat": - range_x, range_y = np.ptp(xy, axis=0) - nx_mesh = int(range_x / mesh_node_spacing) - ny_mesh = int(range_y / (mesh_node_spacing * np.sqrt(3) / 2)) - if nx_mesh == 0 or ny_mesh == 0: - raise ValueError( - "The given `mesh_node_spacing` is too large for the provided " - f"coordinates. Got mesh_node_spacing={mesh_node_spacing}, but the " - f"x-range is {range_x} and y-range is {range_y}. Maybe you " - "want to decrease the `mesh_node_spacing` so that the mesh nodes " - "are spaced closer together?" - ) + else: # triangular G_mesh_coords = create_single_level_2d_triangular_mesh_primitive( - xy, nx_mesh, ny_mesh - ) - else: - primitives_kwargs = dict( - xy=xy, - mesh_node_spacing=mesh_node_spacing, + xy, mesh_node_spacing=mesh_node_spacing ) - if "refinement_factor" in mesh_layout_kwargs: - primitives_kwargs["interlevel_refinement_factor"] = mesh_layout_kwargs[ - "refinement_factor" - ] - if "max_num_refinement_levels" in mesh_layout_kwargs: - primitives_kwargs["max_num_levels"] = mesh_layout_kwargs[ - "max_num_refinement_levels" - ] + else: + # Multi-level mesh primitives (flat_multiscale or hierarchical) + primitives_kwargs = dict(xy=xy, mesh_node_spacing=mesh_node_spacing) + if "refinement_factor" in mesh_layout_kwargs: + primitives_kwargs["interlevel_refinement_factor"] = mesh_layout_kwargs[ + "refinement_factor" + ] + if "max_num_refinement_levels" in mesh_layout_kwargs: + primitives_kwargs["max_num_levels"] = mesh_layout_kwargs[ + "max_num_refinement_levels" + ] + if mesh_layout == "rectilinear": + G_mesh_coords = create_multirange_2d_mesh_primitives(**primitives_kwargs) + else: # triangular G_mesh_coords = create_multirange_2d_triangular_mesh_primitives( **primitives_kwargs ) - else: - raise NotImplementedError( - f"mesh_layout='{mesh_layout}' is not yet supported. " - "Currently supported: 'rectilinear', 'triangular'." - ) - # ----------------------------------------------------------------------- # Step 2: Connectivity creation — converts mesh primitives to directed graph # ----------------------------------------------------------------------- if m2m_connectivity == "flat": - pattern = m2m_connectivity_kwargs.get( - "pattern", "4-star" if mesh_layout == "triangular" else "8-star" - ) + pattern = m2m_connectivity_kwargs.get("pattern", "8-star") graph_components["m2m"] = create_flat_singlescale_from_coordinates( G_mesh_coords, pattern=pattern ) @@ -375,10 +340,8 @@ def create_all_graph_components( # hierarchical mesh graph has three sub-graphs: # `m2m` (mesh-to-mesh), `mesh_up` (up edge connections) and # `mesh_down` (down edge connections) - intra_level = m2m_connectivity_kwargs.get("intra_level") - if intra_level is None and mesh_layout == "triangular": - intra_level = {"pattern": "4-star"} hierarchical_kwargs = {} + intra_level = m2m_connectivity_kwargs.get("intra_level") if intra_level is not None: hierarchical_kwargs["intra_level"] = intra_level inter_level = m2m_connectivity_kwargs.get("inter_level") @@ -393,19 +356,10 @@ def create_all_graph_components( )[0] elif m2m_connectivity == "flat_multiscale": - pattern = m2m_connectivity_kwargs.get("pattern") - if pattern is None: - pattern = "4-star" if mesh_layout == "triangular" else "8-star" - if mesh_layout == "triangular": - graph_components[ - "m2m" - ] = create_flat_multiscale_from_triangular_coordinates( - G_mesh_coords, pattern=pattern - ) - else: - graph_components["m2m"] = create_flat_multiscale_from_coordinates( - G_mesh_coords, pattern=pattern - ) + pattern = m2m_connectivity_kwargs.get("pattern", "8-star") + graph_components["m2m"] = create_flat_multiscale_from_coordinates( + G_mesh_coords, pattern=pattern + ) grid_connect_graph = graph_components["m2m"] else: diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index bba1732..8415a7e 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -1,5 +1,5 @@ +from .connectivity.flat import create_flat_multiscale_from_coordinates from .connectivity.general import create_directed_mesh_graph -from .connectivity.triangular import create_flat_multiscale_from_triangular_coordinates from .layout.rectilinear import ( create_multirange_2d_mesh_graphs, create_multirange_2d_mesh_primitives, @@ -8,6 +8,5 @@ ) from .layout.triangular import ( create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_graph, create_single_level_2d_triangular_mesh_primitive, ) diff --git a/src/weather_model_graphs/create/mesh/connectivity/flat.py b/src/weather_model_graphs/create/mesh/connectivity/flat.py index 6668464..3b8a5dc 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/flat.py +++ b/src/weather_model_graphs/create/mesh/connectivity/flat.py @@ -2,6 +2,7 @@ import networkx import numpy as np +import scipy.spatial from ....networkx_utils import prepend_node_index from ..layout import rectilinear as mesh_layout @@ -59,6 +60,12 @@ def create_flat_multiscale_from_coordinates( In a flat multiscale graph, coarser levels are merged into the finer level by coincident node positions (no separate inter-level connectivity needed). + This works for any mesh layout. When the mesh primitives carry the integer + ``(i, j)`` grid-index node labels of a complete rectangular lattice (the + rectilinear layout) the merge uses fast index arithmetic. Otherwise (e.g. a + triangular lattice, whose nodes do not form a full rectangle) it falls back + to layout-agnostic position-based matching with a KD-tree. + Parameters ---------- G_coords_list : list of networkx.Graph @@ -67,7 +74,8 @@ def create_flat_multiscale_from_coordinates( - Node attributes: ``"pos"`` (np.ndarray of shape [2,]), ``"type"`` (str) - Edge attributes: ``"adjacency_type"`` (str, ``"cardinal"`` or ``"diagonal"``) - Graph attribute: ``"interlevel_refinement_factor"`` (int) - Created by ``create_multirange_2d_mesh_primitives``. + Created by ``create_multirange_2d_mesh_primitives`` (rectilinear) or + ``create_multirange_2d_triangular_mesh_primitives`` (triangular). **kwargs Additional keyword arguments passed to ``create_directed_mesh_graph`` (e.g. ``pattern="8-star"``). @@ -82,32 +90,69 @@ def create_flat_multiscale_from_coordinates( G_coords_list[0], "create_flat_multiscale_from_coordinates" ) - # Assert interlevel_refinement_factor is set (no silent default) - if "interlevel_refinement_factor" not in G_coords_list[0].graph: - raise ValueError( - "The coordinate graphs must have an 'interlevel_refinement_factor' " - "graph attribute. This is set by create_multirange_2d_mesh_primitives." - ) - interlevel_refinement_factor = G_coords_list[0].graph[ - "interlevel_refinement_factor" - ] - - # Check that interlevel_refinement_factor is an odd integer - if ( - int(interlevel_refinement_factor) != interlevel_refinement_factor - or interlevel_refinement_factor % 2 != 1 - ): - raise ValueError( - "The `interlevel_refinement_factor` must be an odd integer. " - f"Given value: {interlevel_refinement_factor}." - ) - # Convert each level's coordinate graph to directed graph with chosen pattern G_all_levels = [ create_directed_mesh_graph(g_coords, **kwargs) for g_coords in G_coords_list ] - # combine all levels to one graph + # Decide how to merge coincident nodes across levels. The fast index path is + # only valid for the rectilinear ``grid_2d`` layout, where coarse-level grid + # indices coincide in *position* with finer nodes. Its structural signature + # is the presence of ``"diagonal"`` adjacency edges (8-star lattice). Other + # layouts -- e.g. the triangular lattice, which has only ``"cardinal"`` edges + # and offset rows -- fall back to layout-agnostic position matching (KD-tree). + # The check is done on the undirected coordinate graph so it is independent + # of the connectivity ``pattern`` (which may filter diagonals out later). + grid_indexed = any( + d.get("adjacency_type") == "diagonal" + for _, _, d in G_coords_list[0].edges(data=True) + ) + + if grid_indexed: + # The index-arithmetic merge relies on a known, odd refinement factor + # between levels; this requirement is specific to the grid-index path. + # The position-based fallback below works for any refinement factor. + if "interlevel_refinement_factor" not in G_coords_list[0].graph: + raise ValueError( + "The coordinate graphs must have an 'interlevel_refinement_factor' " + "graph attribute. This is set by create_multirange_2d_mesh_primitives." + ) + interlevel_refinement_factor = G_coords_list[0].graph[ + "interlevel_refinement_factor" + ] + # Check that interlevel_refinement_factor is an odd integer + if ( + int(interlevel_refinement_factor) != interlevel_refinement_factor + or interlevel_refinement_factor % 2 != 1 + ): + raise ValueError( + "The `interlevel_refinement_factor` must be an odd integer. " + f"Given value: {interlevel_refinement_factor}." + ) + G_tot = _merge_levels_by_grid_index(G_all_levels, interlevel_refinement_factor) + else: + G_tot = _merge_levels_by_position(G_all_levels) + + # Relabel mesh nodes to start with 0 + G_tot = prepend_node_index(G_tot, 0) + + # add dx and dy to graph + G_tot.graph["dx"] = {i: g.graph["dx"] for i, g in enumerate(G_all_levels)} + G_tot.graph["dy"] = {i: g.graph["dy"] for i, g in enumerate(G_all_levels)} + + return G_tot + + +def _merge_levels_by_grid_index( + G_all_levels: List[networkx.DiGraph], interlevel_refinement_factor: int +) -> networkx.DiGraph: + """Merge multiscale levels using integer ``(i, j)`` grid-index arithmetic. + + This is the original rectilinear merge: coarser-level nodes are matched to + their coincident finer-level nodes purely from the grid indices, so the + result is unchanged for the rectilinear layout. + """ + G_all_levels = list(G_all_levels) G_tot = G_all_levels[0] # First node at level l+1 share position with node (offset, offset) at level l level_offset = interlevel_refinement_factor // 2 @@ -141,12 +186,46 @@ def create_flat_multiscale_from_coordinates( num_nodes_x //= interlevel_refinement_factor num_nodes_y //= interlevel_refinement_factor - # Relabel mesh nodes to start with 0 - G_tot = prepend_node_index(G_tot, 0) + return G_tot - # add dx and dy to graph - G_tot.graph["dx"] = {i: g.graph["dx"] for i, g in enumerate(G_all_levels)} - G_tot.graph["dy"] = {i: g.graph["dy"] for i, g in enumerate(G_all_levels)} + +def _merge_levels_by_position( + G_all_levels: List[networkx.DiGraph], +) -> networkx.DiGraph: + """Merge multiscale levels by coincident node positions (KD-tree). + + Layout-agnostic fallback used when node labels do not form a complete + ``(i, j)`` grid (e.g. the triangular layout). For each coarser level, any + node whose position coincides (within floating-point tolerance) with an + existing finer-level node is merged with it, so multi-resolution edges + share the same node identity. + """ + # Prepend level index so labels are unique across levels before merging + G_levels = [ + prepend_node_index(g, level_i) for level_i, g in enumerate(G_all_levels) + ] + + G_tot = G_levels[0] + for lev in range(1, len(G_levels)): + G_coarse = G_levels[lev] + + # KDTree of existing (finer) nodes for position matching + fine_nodes = list(G_tot.nodes()) + fine_positions = np.array([G_tot.nodes[n]["pos"] for n in fine_nodes]) + kdt = scipy.spatial.KDTree(fine_positions) + + # Find which coarse nodes coincide with existing fine nodes + relabel_map = {} + for node in G_coarse.nodes(): + pos = G_coarse.nodes[node]["pos"] + dist, idx = kdt.query(pos) + if dist < 1e-8: + relabel_map[node] = fine_nodes[idx] + + if relabel_map: + G_coarse = networkx.relabel_nodes(G_coarse, relabel_map) + + G_tot = networkx.compose(G_tot, G_coarse) return G_tot diff --git a/src/weather_model_graphs/create/mesh/connectivity/triangular.py b/src/weather_model_graphs/create/mesh/connectivity/triangular.py deleted file mode 100644 index 7750202..0000000 --- a/src/weather_model_graphs/create/mesh/connectivity/triangular.py +++ /dev/null @@ -1,103 +0,0 @@ -""" -Triangular mesh connectivity functions. - -Coordinate creation (primitives) lives in ``layout.triangular``. -This module contains only triangular-specific *connectivity* logic -that cannot be handled by the generic connectivity functions in -``flat.py`` or ``hierarchical.py``. - -The generic ``create_hierarchical_from_coordinates`` already works with -triangular primitives, so no triangular-specific hierarchical function -is needed here. -""" - -from typing import List - -import networkx -import numpy as np -import scipy.spatial - -from ....networkx_utils import prepend_node_index -from ..layout.triangular import ( - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_graph, - create_single_level_2d_triangular_mesh_primitive, -) -from .general import create_directed_mesh_graph - -# Re-export layout functions for backward compatibility -__all__ = [ - "create_single_level_2d_triangular_mesh_primitive", - "create_multirange_2d_triangular_mesh_primitives", - "create_single_level_2d_triangular_mesh_graph", - "create_flat_multiscale_from_triangular_coordinates", -] - - -def create_flat_multiscale_from_triangular_coordinates( - G_coords_list: List[networkx.Graph], - pattern: str = "4-star", -) -> networkx.DiGraph: - """ - Create flat multiscale mesh graph from a list of triangular coordinate - graphs. - - Unlike the rectilinear variant (``create_flat_multiscale_from_coordinates``) - which relies on grid-index-based coincident-node detection, this function - uses position-based matching. For each coarser level, any node whose - position coincides (within floating-point tolerance) with an existing finer - level node is merged with it, so that multi-resolution edges share the - same node identity. - - Parameters - ---------- - G_coords_list : list[networkx.Graph] - One undirected triangular mesh primitive per level. - pattern : str - Connectivity pattern: ``"4-star"`` or ``"8-star"`` (default ``"4-star"``). - - Returns - ------- - networkx.DiGraph - Flat multiscale triangular mesh graph. - """ - # Convert each level to directed graph - G_directed = [create_directed_mesh_graph(g, pattern=pattern) for g in G_coords_list] - - # Prepend level index to make node labels unique across levels - G_directed = [ - prepend_node_index(g, level_i) for level_i, g in enumerate(G_directed) - ] - - # Build merged graph, starting from finest level - G_tot = G_directed[0] - - for lev in range(1, len(G_directed)): - G_coarse = G_directed[lev] - - # KDTree of existing (finer) nodes for position matching - fine_nodes = list(G_tot.nodes()) - fine_positions = np.array([G_tot.nodes[n]["pos"] for n in fine_nodes]) - kdt = scipy.spatial.KDTree(fine_positions) - - # Find which coarse nodes coincide with existing fine nodes - relabel_map = {} - for node in G_coarse.nodes(): - pos = G_coarse.nodes[node]["pos"] - dist, idx = kdt.query(pos) - if dist < 1e-8: - relabel_map[node] = fine_nodes[idx] - - if relabel_map: - G_coarse = networkx.relabel_nodes(G_coarse, relabel_map) - - G_tot = networkx.compose(G_tot, G_coarse) - - # Re-index to sequential (0, i) labels - G_tot = prepend_node_index(G_tot, 0) - - # Preserve dx/dy as per-level dicts - G_tot.graph["dx"] = {i: g.graph["dx"] for i, g in enumerate(G_directed)} - G_tot.graph["dy"] = {i: g.graph["dy"] for i, g in enumerate(G_directed)} - - return G_tot diff --git a/src/weather_model_graphs/create/mesh/layout/triangular.py b/src/weather_model_graphs/create/mesh/layout/triangular.py index 6e87a0b..0d4e8f0 100644 --- a/src/weather_model_graphs/create/mesh/layout/triangular.py +++ b/src/weather_model_graphs/create/mesh/layout/triangular.py @@ -19,11 +19,13 @@ import numpy as np from loguru import logger -from ..connectivity.general import create_directed_mesh_graph - def create_single_level_2d_triangular_mesh_primitive( - xy: np.ndarray, nx: int, ny: int + xy: np.ndarray, + nx: int = None, + ny: int = None, + *, + mesh_node_spacing: float = None, ) -> networkx.Graph: """ Create an undirected triangular mesh primitive graph (``nx.Graph``) with @@ -42,16 +44,27 @@ def create_single_level_2d_triangular_mesh_primitive( so that the mesh spans the coordinate domain of *xy* (with nodes inset from the border by half a cell width in each direction). + Either provide ``nx`` and ``ny`` directly, or provide ``mesh_node_spacing`` + to have them computed automatically from the coordinate extent of ``xy`` + (mirroring ``create_single_level_2d_mesh_primitive``). + Parameters ---------- xy : np.ndarray Grid point coordinates, shaped ``[N_grid_points, 2]``. - nx : int + nx : int, optional Number of triangle columns (passed as *n* to - ``triangular_lattice_graph``). - ny : int + ``triangular_lattice_graph``). If not given, computed from + ``mesh_node_spacing``. + ny : int, optional Number of triangle rows (passed as *m* to - ``triangular_lattice_graph``). + ``triangular_lattice_graph``). If not given, computed from + ``mesh_node_spacing``. + mesh_node_spacing : float, optional + Distance between mesh nodes (in coordinate units). When provided, + ``nx`` and ``ny`` are computed from the coordinate extent of ``xy`` + (``ny`` accounts for the ``sqrt(3)/2`` triangular row spacing) and + validated to be > 0. Returns ------- @@ -61,6 +74,23 @@ def create_single_level_2d_triangular_mesh_primitive( ``adjacency_type`` (always ``"cardinal"`` -- triangular lattices have only one class of edge). Graph attributes: ``dx``, ``dy``. """ + if mesh_node_spacing is not None: + range_x, range_y = np.ptp(xy, axis=0) + nx = int(range_x / mesh_node_spacing) + ny = int(range_y / (mesh_node_spacing * np.sqrt(3) / 2)) + if nx == 0 or ny == 0: + raise ValueError( + "The given `mesh_node_spacing` is too large for the provided " + f"coordinates. Got mesh_node_spacing={mesh_node_spacing}, but the " + f"x-range is {range_x} and y-range is {range_y}. Maybe you " + "want to decrease the `mesh_node_spacing` so that the mesh nodes " + "are spaced closer together?" + ) + elif nx is None or ny is None: + raise ValueError( + "Either provide both `nx` and `ny`, or provide " + "`mesh_node_spacing` to compute them automatically." + ) xm, xM = np.amin(xy[:, 0]), np.amax(xy[:, 0]) ym, yM = np.amin(xy[:, 1]), np.amax(xy[:, 1]) @@ -185,34 +215,3 @@ def create_multirange_2d_triangular_mesh_primitives( G_all_levels.append(g) return G_all_levels - - -def create_single_level_2d_triangular_mesh_graph( - xy: np.ndarray, nx: int, ny: int -) -> networkx.DiGraph: - """ - Create a directed triangular mesh graph from coordinates. - - Internally uses the two-step process: - 1. ``create_single_level_2d_triangular_mesh_primitive`` (coordinate creation) - 2. ``create_directed_mesh_graph`` (connectivity creation) - - For triangular lattices, *all* edges are ``"cardinal"`` so patterns - ``"4-star"`` and ``"8-star"`` produce the same result (6-connectivity). - - Parameters - ---------- - xy : np.ndarray - Grid point coordinates, shaped ``[N_grid_points, 2]``. - nx : int - Number of triangle columns. - ny : int - Number of triangle rows. - - Returns - ------- - networkx.DiGraph - Directed triangular mesh graph. - """ - G_coords = create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) - return create_directed_mesh_graph(G_coords, pattern="4-star") diff --git a/tests/test_mesh_layout.py b/tests/test_mesh_layout.py index 4b0e74d..fbeb805 100644 --- a/tests/test_mesh_layout.py +++ b/tests/test_mesh_layout.py @@ -617,7 +617,7 @@ def test_unsupported_mesh_layout_raises(self): wmg.create.create_all_graph_components( coords=xy, m2m_connectivity="flat", - mesh_layout="hexagonal", + mesh_layout="nonexistent_layout", mesh_layout_kwargs=dict(mesh_node_spacing=3), g2m_connectivity="nearest_neighbour", m2g_connectivity="nearest_neighbour", diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py index 66179a0..a4c0b71 100644 --- a/tests/test_triangular_mesh.py +++ b/tests/test_triangular_mesh.py @@ -19,21 +19,35 @@ import tests.utils as test_utils import weather_model_graphs as wmg +from weather_model_graphs.create.mesh.connectivity.flat import ( + create_flat_multiscale_from_coordinates, +) from weather_model_graphs.create.mesh.connectivity.general import ( create_directed_mesh_graph, ) from weather_model_graphs.create.mesh.connectivity.hierarchical import ( create_hierarchical_from_coordinates, ) -from weather_model_graphs.create.mesh.connectivity.triangular import ( - create_flat_multiscale_from_triangular_coordinates, -) from weather_model_graphs.create.mesh.layout.triangular import ( create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_graph, create_single_level_2d_triangular_mesh_primitive, ) + +# Test helpers exercising the equivalent generic two-step API after the +# triangular-specific convenience functions were removed (PR #92 review). +def create_single_level_2d_triangular_mesh_graph(xy, nx, ny): + """Directed triangular mesh graph via primitive + generic connectivity.""" + return create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) + ) + + +def create_flat_multiscale_from_triangular_coordinates(G_coords_list, **kwargs): + """Triangular flat-multiscale graph via the generalized generic function.""" + return create_flat_multiscale_from_coordinates(G_coords_list, **kwargs) + + # =========================== # Fixtures # =========================== @@ -752,7 +766,7 @@ def test_unsupported_layout_raises(self, xy_small): wmg.create.create_all_graph_components( coords=xy_small, m2m_connectivity="flat", - mesh_layout="hexagonal", + mesh_layout="nonexistent_layout", mesh_layout_kwargs=dict(mesh_node_spacing=1.0), **self.COMMON_KW, ) From fc01d665525ef4a945bfd298ccd3d694f5f78d3c Mon Sep 17 00:00:00 2001 From: prajwal Date: Thu, 9 Jul 2026 12:53:31 +0530 Subject: [PATCH 11/16] Address PR #92 review: rename layout primitives, elif dispatch, tidy tests - Rename triangular layout primitives to drop the _triangular suffix and alias them on import in base.py (same for rectilinear) for symmetry. - Use elif mesh_layout == 'triangular' in both coordinate-creation branches and raise NotImplementedError for unsupported layouts. - Inline the triangular test helpers to use the generic two-step API and drop the redundant flat-multiscale passthrough. - Clarify the 4-star/8-star pattern-equivalence test docstring. - Fix mangled UTF arrows in the vdiff reciprocity docstring. --- src/weather_model_graphs/create/base.py | 32 ++++-- .../create/mesh/__init__.py | 6 +- .../create/mesh/connectivity/flat.py | 2 +- .../create/mesh/layout/triangular.py | 6 +- tests/test_triangular_mesh.py | 102 +++++++++++------- 5 files changed, 94 insertions(+), 54 deletions(-) diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index f5fd1cb..94493b8 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -30,12 +30,16 @@ ) from .mesh.connectivity.hierarchical import create_hierarchical_from_coordinates from .mesh.layout.rectilinear import ( - create_multirange_2d_mesh_primitives, - create_single_level_2d_mesh_primitive, + create_multirange_2d_mesh_primitives as create_multirange_2d_rectilinear_mesh_primitives, +) +from .mesh.layout.rectilinear import ( + create_single_level_2d_mesh_primitive as create_single_level_2d_rectilinear_mesh_primitive, ) from .mesh.layout.triangular import ( - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_primitive, + create_multirange_2d_mesh_primitives as create_multirange_2d_triangular_mesh_primitives, +) +from .mesh.layout.triangular import ( + create_single_level_2d_mesh_primitive as create_single_level_2d_triangular_mesh_primitive, ) @@ -301,13 +305,18 @@ def create_all_graph_components( if m2m_connectivity == "flat": # Single-level mesh primitive if mesh_layout == "rectilinear": - G_mesh_coords = create_single_level_2d_mesh_primitive( + G_mesh_coords = create_single_level_2d_rectilinear_mesh_primitive( xy, mesh_node_spacing=mesh_node_spacing ) - else: # triangular + elif mesh_layout == "triangular": G_mesh_coords = create_single_level_2d_triangular_mesh_primitive( xy, mesh_node_spacing=mesh_node_spacing ) + else: + raise NotImplementedError( + f"mesh_layout='{mesh_layout}' is not implemented. " + "Supported layouts: 'rectilinear', 'triangular'." + ) else: # Multi-level mesh primitives (flat_multiscale or hierarchical) primitives_kwargs = dict(xy=xy, mesh_node_spacing=mesh_node_spacing) @@ -320,11 +329,18 @@ def create_all_graph_components( "max_num_refinement_levels" ] if mesh_layout == "rectilinear": - G_mesh_coords = create_multirange_2d_mesh_primitives(**primitives_kwargs) - else: # triangular + G_mesh_coords = create_multirange_2d_rectilinear_mesh_primitives( + **primitives_kwargs + ) + elif mesh_layout == "triangular": G_mesh_coords = create_multirange_2d_triangular_mesh_primitives( **primitives_kwargs ) + else: + raise NotImplementedError( + f"mesh_layout='{mesh_layout}' is not implemented. " + "Supported layouts: 'rectilinear', 'triangular'." + ) # ----------------------------------------------------------------------- # Step 2: Connectivity creation — converts mesh primitives to directed graph diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index 8415a7e..07dbd38 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -7,6 +7,8 @@ create_single_level_2d_mesh_primitive, ) from .layout.triangular import ( - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_primitive, + create_multirange_2d_mesh_primitives as create_multirange_2d_triangular_mesh_primitives, +) +from .layout.triangular import ( + create_single_level_2d_mesh_primitive as create_single_level_2d_triangular_mesh_primitive, ) diff --git a/src/weather_model_graphs/create/mesh/connectivity/flat.py b/src/weather_model_graphs/create/mesh/connectivity/flat.py index 3b8a5dc..da57b06 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/flat.py +++ b/src/weather_model_graphs/create/mesh/connectivity/flat.py @@ -75,7 +75,7 @@ def create_flat_multiscale_from_coordinates( - Edge attributes: ``"adjacency_type"`` (str, ``"cardinal"`` or ``"diagonal"``) - Graph attribute: ``"interlevel_refinement_factor"`` (int) Created by ``create_multirange_2d_mesh_primitives`` (rectilinear) or - ``create_multirange_2d_triangular_mesh_primitives`` (triangular). + ``create_multirange_2d_mesh_primitives`` (triangular). **kwargs Additional keyword arguments passed to ``create_directed_mesh_graph`` (e.g. ``pattern="8-star"``). diff --git a/src/weather_model_graphs/create/mesh/layout/triangular.py b/src/weather_model_graphs/create/mesh/layout/triangular.py index 0d4e8f0..9042cae 100644 --- a/src/weather_model_graphs/create/mesh/layout/triangular.py +++ b/src/weather_model_graphs/create/mesh/layout/triangular.py @@ -20,7 +20,7 @@ from loguru import logger -def create_single_level_2d_triangular_mesh_primitive( +def create_single_level_2d_mesh_primitive( xy: np.ndarray, nx: int = None, ny: int = None, @@ -154,7 +154,7 @@ def create_single_level_2d_triangular_mesh_primitive( return g -def create_multirange_2d_triangular_mesh_primitives( +def create_multirange_2d_mesh_primitives( max_num_levels, xy: np.ndarray, mesh_node_spacing: float = 3, @@ -205,7 +205,7 @@ def create_multirange_2d_triangular_mesh_primitives( G_all_levels = [] for lev in range(mesh_levels_to_create): nodes_x, nodes_y = (nleaf / (interlevel_refinement_factor**lev)).astype(int) - g = create_single_level_2d_triangular_mesh_primitive(xy, nodes_x, nodes_y) + g = create_single_level_2d_mesh_primitive(xy, nodes_x, nodes_y) for node in g.nodes: g.nodes[node]["level"] = lev for edge in g.edges: diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py index a4c0b71..3771542 100644 --- a/tests/test_triangular_mesh.py +++ b/tests/test_triangular_mesh.py @@ -29,24 +29,11 @@ create_hierarchical_from_coordinates, ) from weather_model_graphs.create.mesh.layout.triangular import ( - create_multirange_2d_triangular_mesh_primitives, - create_single_level_2d_triangular_mesh_primitive, + create_multirange_2d_mesh_primitives as create_multirange_2d_triangular_mesh_primitives, +) +from weather_model_graphs.create.mesh.layout.triangular import ( + create_single_level_2d_mesh_primitive as create_single_level_2d_triangular_mesh_primitive, ) - - -# Test helpers exercising the equivalent generic two-step API after the -# triangular-specific convenience functions were removed (PR #92 review). -def create_single_level_2d_triangular_mesh_graph(xy, nx, ny): - """Directed triangular mesh graph via primitive + generic connectivity.""" - return create_directed_mesh_graph( - create_single_level_2d_triangular_mesh_primitive(xy, nx, ny) - ) - - -def create_flat_multiscale_from_triangular_coordinates(G_coords_list, **kwargs): - """Triangular flat-multiscale graph via the generalized generic function.""" - return create_flat_multiscale_from_coordinates(G_coords_list, **kwargs) - # =========================== # Fixtures @@ -249,7 +236,7 @@ def test_len_symmetry(self, xy_small): np.testing.assert_allclose(G[u][v]["len"], G[v][u]["len"], atol=1e-10) def test_vdiff_reciprocity(self, xy_small): - """vdiff(uΓåÆv) should equal -vdiff(vΓåÆu).""" + """vdiff(u->v) should equal -vdiff(v->u).""" G_coords = create_single_level_2d_triangular_mesh_primitive( xy_small, nx=5, ny=5 ) @@ -261,8 +248,13 @@ def test_vdiff_reciprocity(self, xy_small): ) def test_pattern_4star_equals_8star(self, xy_small): - """For triangular lattice, 4-star and 8-star should produce identical - graphs since all edges are 'cardinal'.""" + """The ``pattern`` argument selects edges by ``adjacency_type``: + ``4-star`` keeps cardinal edges, ``8-star`` keeps cardinal + diagonal. + A triangular lattice has only a single edge class (all ``cardinal``), + so ``4-star`` and ``8-star`` yield identical graphs here. (The "6" of a + triangular mesh refers to the node degree -- 6 neighbours per interior + node -- not to the ``pattern`` name, which describes rectilinear edge + classes.)""" G_coords = create_single_level_2d_triangular_mesh_primitive( xy_small, nx=5, ny=5 ) @@ -319,7 +311,9 @@ def test_interior_node_degree_six(self, xy_small): def test_minimal_lattice_directed(self, xy_small): """Minimal lattice (nx=1, ny=1) should still produce a valid directed graph.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=1, ny=1) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=1, ny=1) + ) assert isinstance(G, nx.DiGraph) assert G.number_of_nodes() >= 2 assert G.number_of_edges() >= 2 # at least one bidirectional edge @@ -457,33 +451,43 @@ def test_all_levels_have_edges(self, xy_medium): class TestSingleLevelTriangularGraph: - """Tests for create_single_level_2d_triangular_mesh_graph.""" + """Tests for the triangular single-level directed mesh graph.""" def test_returns_digraph(self, xy_small): - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + ) assert isinstance(G, nx.DiGraph) def test_has_bidirectional_edges(self, xy_small): - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + ) for u, v in G.edges(): assert G.has_edge(v, u) def test_edges_have_attributes(self, xy_small): """Directed graph edges should have len and vdiff.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + ) for u, v, d in G.edges(data=True): assert "len" in d assert "vdiff" in d def test_with_rectangular_domain(self, xy_rectangular): """Should work correctly on non-square domains.""" - G = create_single_level_2d_triangular_mesh_graph(xy_rectangular, nx=8, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_rectangular, nx=8, ny=5) + ) assert isinstance(G, nx.DiGraph) assert G.number_of_edges() > 0 def test_minimal_grid(self, xy_small): """Minimal grid (nx=1, ny=1) should produce a valid graph.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=1, ny=1) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=1, ny=1) + ) assert G.number_of_nodes() >= 2 @@ -496,7 +500,7 @@ class TestFlatMultiscaleTriangular: """Tests for flat multiscale triangular mesh graph using two-step API. Uses ``create_multirange_2d_triangular_mesh_primitives`` (coordinate - creation) followed by ``create_flat_multiscale_from_triangular_coordinates`` + creation) followed by ``create_flat_multiscale_from_coordinates`` (connectivity creation with position-based merging). """ @@ -514,7 +518,7 @@ def _create_multiscale( mesh_node_spacing=mesh_node_spacing, interlevel_refinement_factor=interlevel_refinement_factor, ) - return create_flat_multiscale_from_triangular_coordinates(G_coords_list) + return create_flat_multiscale_from_coordinates(G_coords_list) def test_returns_digraph(self, xy_medium): G = self._create_multiscale(xy_medium) @@ -540,7 +544,7 @@ def test_fewer_nodes_than_sum_of_levels(self, xy_medium): interlevel_refinement_factor=3, ) total_raw = sum(g.number_of_nodes() for g in G_coords_list) - G = create_flat_multiscale_from_triangular_coordinates(G_coords_list) + G = create_flat_multiscale_from_coordinates(G_coords_list) # Merged graph has at most as many nodes (usually fewer) assert G.number_of_nodes() <= total_raw @@ -592,7 +596,7 @@ def test_more_nodes_than_coarsest_level(self, xy_large): if len(G_coords_list) < 2: pytest.skip("Only one level created") coarsest_nodes = G_coords_list[-1].number_of_nodes() - G_multi = create_flat_multiscale_from_triangular_coordinates(G_coords_list) + G_multi = create_flat_multiscale_from_coordinates(G_coords_list) assert G_multi.number_of_nodes() > coarsest_nodes @@ -928,13 +932,17 @@ class TestNumericalCorrectness: """Test numerical properties of the triangular mesh graph.""" def test_edge_lengths_positive(self, xy_medium): - G = create_single_level_2d_triangular_mesh_graph(xy_medium, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_medium, nx=5, ny=5) + ) for u, v, d in G.edges(data=True): assert d["len"] > 0 def test_vdiff_consistent_with_pos(self, xy_small): """vdiff should equal pos(u) - pos(v).""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + ) for u, v, d in G.edges(data=True): pos_u = G.nodes[u]["pos"] pos_v = G.nodes[v]["pos"] @@ -943,28 +951,36 @@ def test_vdiff_consistent_with_pos(self, xy_small): def test_len_consistent_with_vdiff(self, xy_small): """len should equal the L2 norm of vdiff.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=5, ny=5) + ) for u, v, d in G.edges(data=True): expected_len = np.linalg.norm(d["vdiff"]) np.testing.assert_allclose(d["len"], expected_len, atol=1e-10) def test_no_nan_in_edge_attrs(self, xy_small): """Edge attributes should contain no NaN or Inf.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=6, ny=6) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + ) for u, v, d in G.edges(data=True): assert np.isfinite(d["len"]) assert np.isfinite(d["vdiff"]).all() def test_no_zero_length_edges(self, xy_small): """All edges should have strictly positive length.""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=6, ny=6) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=6, ny=6) + ) for u, v, d in G.edges(data=True): assert d["len"] > 1e-12 def test_edge_lengths_roughly_uniform_for_interior(self, xy_small): """For a uniform triangular lattice, all edges should have similar length (within a narrow tolerance, accounting for scaling).""" - G = create_single_level_2d_triangular_mesh_graph(xy_small, nx=8, ny=8) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_small, nx=8, ny=8) + ) lengths = [d["len"] for _, _, d in G.edges(data=True)] # In a uniformly scaled equilateral mesh, all edges should be # within ~50% of each other (accounting for aspect ratio scaling) @@ -980,15 +996,21 @@ def test_scaled_domain_produces_scaled_lengths(self): """Doubling the domain should roughly double edge lengths.""" xy1 = np.array([[0, 0], [10, 0], [0, 10], [10, 10]], dtype=float) xy2 = np.array([[0, 0], [20, 0], [0, 20], [20, 20]], dtype=float) - G1 = create_single_level_2d_triangular_mesh_graph(xy1, nx=5, ny=5) - G2 = create_single_level_2d_triangular_mesh_graph(xy2, nx=5, ny=5) + G1 = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy1, nx=5, ny=5) + ) + G2 = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy2, nx=5, ny=5) + ) avg_len1 = np.mean([d["len"] for _, _, d in G1.edges(data=True)]) avg_len2 = np.mean([d["len"] for _, _, d in G2.edges(data=True)]) np.testing.assert_allclose(avg_len2 / avg_len1, 2.0, rtol=0.1) def test_no_nan_in_positions(self, xy_medium): """No node should have NaN in positions.""" - G = create_single_level_2d_triangular_mesh_graph(xy_medium, nx=5, ny=5) + G = create_directed_mesh_graph( + create_single_level_2d_triangular_mesh_primitive(xy_medium, nx=5, ny=5) + ) for node in G.nodes: pos = G.nodes[node]["pos"] assert isinstance(pos, np.ndarray) From daa841c8315adbcb5ee78c39331c9673e54b5aa6 Mon Sep 17 00:00:00 2001 From: prajwal Date: Thu, 9 Jul 2026 15:41:55 +0530 Subject: [PATCH 12/16] Remove no-op 4-star/8-star pattern-equivalence test for triangular The pattern argument only filters cardinal vs diagonal edges, which is a rectilinear distinction. Triangular primitives have only cardinal edges, so 4-star and 8-star produce identical graphs -- the test verified a no-op. --- tests/test_triangular_mesh.py | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/tests/test_triangular_mesh.py b/tests/test_triangular_mesh.py index 3771542..c0587f3 100644 --- a/tests/test_triangular_mesh.py +++ b/tests/test_triangular_mesh.py @@ -10,7 +10,6 @@ 6. Integration through create_all_graph_components for all m2m_connectivity modes 7. Edge cases (zero nodes, single-level hierarchical) 8. Numerical correctness (len symmetry, vdiff reciprocity) -9. Pattern equivalence (4-star == 8-star for triangular) """ import networkx as nx @@ -247,22 +246,6 @@ def test_vdiff_reciprocity(self, xy_small): G[u][v]["vdiff"], -G[v][u]["vdiff"], atol=1e-10 ) - def test_pattern_4star_equals_8star(self, xy_small): - """The ``pattern`` argument selects edges by ``adjacency_type``: - ``4-star`` keeps cardinal edges, ``8-star`` keeps cardinal + diagonal. - A triangular lattice has only a single edge class (all ``cardinal``), - so ``4-star`` and ``8-star`` yield identical graphs here. (The "6" of a - triangular mesh refers to the node degree -- 6 neighbours per interior - node -- not to the ``pattern`` name, which describes rectilinear edge - classes.)""" - G_coords = create_single_level_2d_triangular_mesh_primitive( - xy_small, nx=5, ny=5 - ) - G4 = create_directed_mesh_graph(G_coords, pattern="4-star") - G8 = create_directed_mesh_graph(G_coords, pattern="8-star") - assert G4.number_of_nodes() == G8.number_of_nodes() - assert G4.number_of_edges() == G8.number_of_edges() - def test_node_count_preserved(self, xy_small): """Directed graph should have same number of nodes as primitive.""" G_coords = create_single_level_2d_triangular_mesh_primitive( From eb215fca57259d393498db3fa1bc5727b13a1504 Mon Sep 17 00:00:00 2001 From: prajwal Date: Sat, 18 Jul 2026 11:24:23 +0530 Subject: [PATCH 13/16] Add prebuilt mesh layout: node clouds from user-provided nodes (issue #79) The prebuilt layout takes user-supplied mesh node positions (nx.Graph with pos/type/level node attributes, or a bare [N, 2] array) and passes them through as edge-less node-cloud primitives after validation. Following the design agreed in #79, no adjacency is invented in the layout step: the connectivity step builds directed mesh edges straight from the node positions (method='delaunay', the default), skipping the undirected adjacency graph entirely. The connectivity step now also validates an explicit 'pattern' against the adjacency types present in the primitive and raises with the available options instead of silently producing an empty mesh; when no pattern is given, every edge the layout produced is used (behaviour-identical for the generated layouts). intra_level for hierarchical connectivity accepts method= for edge-less primitives alongside the existing pattern=. --- .../create/mesh/__init__.py | 5 + .../create/mesh/connectivity/general.py | 156 ++++++++- .../create/mesh/connectivity/hierarchical.py | 47 ++- .../create/mesh/layout/__init__.py | 6 +- .../create/mesh/layout/prebuilt.py | 308 ++++++++++++++++++ 5 files changed, 490 insertions(+), 32 deletions(-) create mode 100644 src/weather_model_graphs/create/mesh/layout/prebuilt.py diff --git a/src/weather_model_graphs/create/mesh/__init__.py b/src/weather_model_graphs/create/mesh/__init__.py index 07dbd38..56aa1dd 100644 --- a/src/weather_model_graphs/create/mesh/__init__.py +++ b/src/weather_model_graphs/create/mesh/__init__.py @@ -1,5 +1,10 @@ from .connectivity.flat import create_flat_multiscale_from_coordinates from .connectivity.general import create_directed_mesh_graph +from .layout.prebuilt import ( + create_multi_level_prebuilt_mesh_primitives, + create_single_level_prebuilt_mesh_primitive, + validate_prebuilt_mesh_nodes, +) from .layout.rectilinear import ( create_multirange_2d_mesh_graphs, create_multirange_2d_mesh_primitives, diff --git a/src/weather_model_graphs/create/mesh/connectivity/general.py b/src/weather_model_graphs/create/mesh/connectivity/general.py index 9a3914c..be879e8 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/general.py +++ b/src/weather_model_graphs/create/mesh/connectivity/general.py @@ -1,57 +1,116 @@ import networkx import numpy as np +import scipy.spatial def create_directed_mesh_graph( - G_undirected: networkx.Graph, pattern: str = "8-star" + G_undirected: networkx.Graph, pattern: str = None, method: str = None ) -> networkx.DiGraph: """ - Convert an undirected mesh primitive graph with spatial adjacency edges to a - directed mesh graph (nx.DiGraph) based on the specified connectivity pattern. + Convert an undirected mesh primitive graph to a directed mesh graph + (nx.DiGraph). This is the second step in the two-step mesh creation process: - 1. Coordinate creation (create_single_level_2d_mesh_primitive) -> nx.Graph + 1. Coordinate creation (mesh layout module) -> nx.Graph 2. Connectivity creation (this function) -> nx.DiGraph - The ``pattern`` argument defines the spatial neighbourhood connectivity: - - ``"4-star"``: only cardinal directions (horizontal and vertical neighbours) - - ``"8-star"``: cardinal directions plus diagonals (all 8 surrounding neighbours) + Two kinds of mesh primitive are supported: + + - **Primitives with adjacency edges** (the generated layouts, + ``rectilinear``/``triangular``): the edges carry an ``adjacency_type`` + attribute and the optional ``pattern`` argument selects a subset of + them. When no ``pattern`` is given, every edge the layout produced is + used. When a ``pattern`` is given it must match the adjacency types + present in the primitive, otherwise a ``ValueError`` is raised listing + what is available (rather than silently producing an empty mesh). + - **Edge-less primitives** (the ``prebuilt`` layout's node clouds): there + is no adjacency to select from, so the directed edges are built + directly from the node positions using ``method`` (currently only + ``"delaunay"``, the default: Delaunay triangulation of the node + positions). ``pattern`` does not apply to node clouds. Parameters ---------- G_undirected : networkx.Graph Undirected mesh primitive graph. Expected node attributes: - ``"pos"``: np.ndarray of shape [2,], spatial coordinates. - Expected edge attributes: - - ``"adjacency_type"``: str, either ``"cardinal"`` or ``"diagonal"``. + Expected edge attributes (only when the primitive has edges): + - ``"adjacency_type"``: str, e.g. ``"cardinal"`` or ``"diagonal"``. Additional edge attributes (e.g. ``"level"``) are preserved in the output directed graph. - pattern : str - Connectivity pattern. Options: + pattern : str, optional + Connectivity pattern for primitives with adjacency edges. Options: + - ``None`` (default): use every edge the layout produced - ``"4-star"``: only cardinal edges (horizontal/vertical neighbours) - ``"8-star"``: all edges (cardinal + diagonal neighbours) + method : str, optional + Edge construction method for edge-less primitives (node clouds). + Options: + - ``None`` (default): resolves to ``"delaunay"`` for node clouds + - ``"delaunay"``: Delaunay triangulation of the node positions Returns ------- networkx.DiGraph Directed graph with bidirectional edges, each having ``"len"`` and - ``"vdiff"`` attributes. All original edge attributes from the - primitive graph are preserved. + ``"vdiff"`` attributes. All original node, edge and graph attributes + from the primitive graph are preserved. + + Raises + ------ + ValueError + If ``pattern`` does not match the adjacency types present in the + primitive, if ``pattern`` is given for an edge-less primitive, if + ``method`` is given for a primitive that already has adjacency + edges, or if the node positions are degenerate (e.g. all collinear) + so that no triangulation exists. + NotImplementedError + If an unknown ``method`` is requested. """ - if pattern == "4-star": + if G_undirected.number_of_edges() == 0 and G_undirected.number_of_nodes() > 0: + return _create_directed_mesh_graph_from_node_cloud( + G_undirected, pattern=pattern, method=method + ) + + if method is not None: + raise ValueError( + f"method='{method}' was given, but the mesh primitive already " + "has adjacency edges (created by the mesh layout). The 'method' " + "argument only applies to edge-less primitives (node clouds " + "from mesh_layout='prebuilt')." + ) + + if pattern is None: + # Use every edge the layout produced + edges_to_use = list(G_undirected.edges(data=True)) + elif pattern == "4-star": # Filter to only cardinal edges, preserving edge data edges_to_use = [ (u, v, d) for u, v, d in G_undirected.edges(data=True) if d.get("adjacency_type") == "cardinal" ] + if len(edges_to_use) == 0: + available = sorted( + { + str(d.get("adjacency_type")) + for _, _, d in G_undirected.edges(data=True) + } + ) + raise ValueError( + "pattern='4-star' selects edges with " + "adjacency_type='cardinal', but the mesh primitive has no " + f"such edges (available adjacency types: {available}). " + "Omit 'pattern' to use every edge the layout produced." + ) elif pattern == "8-star": # Use all edges with their data edges_to_use = list(G_undirected.edges(data=True)) else: raise ValueError( f"Unknown connectivity pattern: '{pattern}'. " - "Choose '4-star' or '8-star'." + "Choose '4-star', '8-star', or omit 'pattern' to use every " + "edge the layout produced." ) # Create filtered undirected graph with only selected edges (preserving attrs) @@ -79,3 +138,70 @@ def create_directed_mesh_graph( dg.graph.update(G_undirected.graph) return dg + + +def _create_directed_mesh_graph_from_node_cloud( + G_nodes: networkx.Graph, pattern: str = None, method: str = None +) -> networkx.DiGraph: + """Build a directed mesh graph directly from an edge-less node cloud. + + The directed edges are constructed straight from the node positions + (no intermediate undirected adjacency graph is built). + """ + # A single-node primitive has no edges under any semantics; don't reject + # a 'pattern' that a generated-layout code path may have passed along. + if pattern is not None and G_nodes.number_of_nodes() > 1: + raise ValueError( + f"pattern='{pattern}' was given, but the mesh primitive has no " + "adjacency edges to select from (it is a node cloud from " + "mesh_layout='prebuilt'). Use method='delaunay' (the default) " + "to control how edges are constructed from the node positions." + ) + if method is None: + method = "delaunay" + if method != "delaunay": + raise NotImplementedError( + f"method='{method}' is not implemented for building mesh edges " + "from node positions. Currently supported: 'delaunay'." + ) + + dg = networkx.DiGraph() + dg.add_nodes_from(G_nodes.nodes(data=True)) + dg.graph.update(G_nodes.graph) + + nodes = list(G_nodes.nodes) + positions = np.array( + [np.asarray(G_nodes.nodes[n]["pos"], dtype=float) for n in nodes] + ) + n_nodes = len(nodes) + + # Delaunay triangulation needs >= 3 non-collinear points; smaller node + # clouds get the only sensible connectivity directly. + if n_nodes == 1: + return dg + if n_nodes == 2: + undirected_pairs = {(0, 1)} + else: + try: + triangulation = scipy.spatial.Delaunay(positions) + except scipy.spatial.QhullError as exc: + raise ValueError( + "Delaunay triangulation of the prebuilt mesh nodes failed " + f"({n_nodes} nodes). This typically means the node positions " + "are degenerate (e.g. all collinear). Provide at least 3 " + "non-collinear mesh node positions." + ) from exc + undirected_pairs = set() + for simplex in triangulation.simplices: + for i in range(3): + a, b = int(simplex[i]), int(simplex[(i + 1) % 3]) + undirected_pairs.add((min(a, b), max(a, b))) + + for ia, ib in sorted(undirected_pairs): + u, v = nodes[ia], nodes[ib] + vdiff = positions[ia] - positions[ib] + d = float(np.sqrt(np.sum(vdiff**2))) + dg.add_edge(u, v, len=d, vdiff=vdiff) + dg.add_edge(v, u, len=d, vdiff=-vdiff) + + return dg diff --git a/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py b/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py index 95aafee..bdb0571 100644 --- a/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py +++ b/src/weather_model_graphs/create/mesh/connectivity/hierarchical.py @@ -11,8 +11,8 @@ def create_hierarchical_from_coordinates( G_coords_list: List[networkx.Graph], - intra_level: Dict[str, object] = {"pattern": "8-star"}, - inter_level: Dict[str, object] = {"pattern": "nearest", "k": 1}, + intra_level: Optional[Dict[str, object]] = None, + inter_level: Optional[Dict[str, object]] = None, ) -> networkx.DiGraph: """ Create a hierarchical multiscale mesh graph from a list of mesh primitive @@ -23,10 +23,14 @@ def create_hierarchical_from_coordinates( directed mesh graph with intra-level connectivity and inter-level up/down connections. - The ``intra_level["pattern"]`` defines the spatial neighbourhood connectivity - within each mesh level: - - ``"4-star"``: only cardinal directions (horizontal and vertical neighbours) - - ``"8-star"``: cardinal directions plus diagonals (all 8 surrounding neighbours) + Intra-level connectivity is controlled by ``intra_level``: + - For primitives with adjacency edges (generated layouts), the optional + ``intra_level["pattern"]`` selects a subset of them (``"4-star"``: + only cardinal neighbours; ``"8-star"``: cardinal plus diagonal). When + no pattern is given, every edge the layout produced is used. + - For edge-less primitives (``mesh_layout="prebuilt"`` node clouds), + ``intra_level["method"]`` selects how edges are built from the node + positions per level (currently only ``"delaunay"``, the default). Parameters ---------- @@ -34,13 +38,18 @@ def create_hierarchical_from_coordinates( List of undirected mesh primitive graphs, one per level. Each graph must have: - Node attributes: ``"pos"`` (np.ndarray of shape [2,]), ``"type"`` (str) - - Edge attributes: ``"adjacency_type"`` (str, ``"cardinal"`` or ``"diagonal"``) - Created by ``create_multirange_2d_mesh_primitives``. - intra_level : dict + - Edge attributes (when the primitive has edges): ``"adjacency_type"`` + (str, ``"cardinal"`` or ``"diagonal"``) + Created by ``create_multirange_2d_mesh_primitives`` (generated + layouts) or ``create_multi_level_prebuilt_mesh_primitives`` + (prebuilt). + intra_level : dict, optional Configuration for intra-level connectivity. Keys: - - ``"pattern"`` (str): ``"4-star"`` or ``"8-star"``. - Default: ``{"pattern": "8-star"}`` - inter_level : dict + - ``"pattern"`` (str): ``"4-star"`` or ``"8-star"`` (primitives with + adjacency edges only; default: use every edge). + - ``"method"`` (str): edge construction method for edge-less + primitives (default: ``"delaunay"``). + inter_level : dict, optional Configuration for inter-level connectivity. Keys: - ``"pattern"`` (str): Currently only ``"nearest"`` is supported. - ``"k"`` (int): Number of nearest neighbours for inter-level connections. @@ -53,7 +62,12 @@ def create_hierarchical_from_coordinates( edges (direction="same"), inter-level down edges (direction="down"), and inter-level up edges (direction="up"). """ - intra_level_pattern = intra_level.get("pattern", "8-star") + if intra_level is None: + intra_level = {} + if inter_level is None: + inter_level = {} + intra_level_pattern = intra_level.get("pattern") + intra_level_method = intra_level.get("method") inter_level_pattern = inter_level.get("pattern", "nearest") inter_level_k = inter_level.get("k", 1) @@ -63,9 +77,12 @@ def create_hierarchical_from_coordinates( "for hierarchical graphs. Only 'nearest' is currently implemented." ) - # Convert each level's coordinate graph to directed graph with chosen pattern + # Convert each level's coordinate graph to directed graph with chosen + # pattern (adjacency-edge primitives) or method (edge-less primitives) Gs_all_levels = [ - create_directed_mesh_graph(g_coords, pattern=intra_level_pattern) + create_directed_mesh_graph( + g_coords, pattern=intra_level_pattern, method=intra_level_method + ) for g_coords in G_coords_list ] diff --git a/src/weather_model_graphs/create/mesh/layout/__init__.py b/src/weather_model_graphs/create/mesh/layout/__init__.py index 76d4cb3..4f07a55 100644 --- a/src/weather_model_graphs/create/mesh/layout/__init__.py +++ b/src/weather_model_graphs/create/mesh/layout/__init__.py @@ -9,8 +9,10 @@ - ``rectilinear``: nodes placed on a uniform rectangular grid. - ``triangular``: nodes placed on a regular (equilateral) triangular lattice. +- ``prebuilt``: nodes taken from a user-provided mesh graph (edge-less node + clouds; mesh edges are built in the connectivity step). """ -from . import rectilinear, triangular +from . import prebuilt, rectilinear, triangular -__all__ = ["rectilinear", "triangular"] +__all__ = ["prebuilt", "rectilinear", "triangular"] diff --git a/src/weather_model_graphs/create/mesh/layout/prebuilt.py b/src/weather_model_graphs/create/mesh/layout/prebuilt.py new file mode 100644 index 0000000..e6aba36 --- /dev/null +++ b/src/weather_model_graphs/create/mesh/layout/prebuilt.py @@ -0,0 +1,308 @@ +""" +Prebuilt mesh layout: coordinate creation from user-provided mesh nodes. + +Unlike the generated layouts (``rectilinear``, ``triangular``), the prebuilt +layout does not place mesh nodes itself -- the user supplies their own node +positions (e.g. ICON grid vertices, an observation-station network, or any +custom point set) and the library builds the graph around them. + +This is the coordinate creation step in the two-step mesh creation process: + +1. **Coordinate creation** (this module) -> edge-less ``nx.Graph`` (a "node + cloud") with ``pos`` and ``type`` node attributes. No adjacency edges are + created here: how a point cloud gets connected is a *connectivity* + decision, so edge construction happens in the connectivity step (see + ``create_directed_mesh_graph`` in ``connectivity.general``, which builds + directed edges directly from the node positions with + ``method="delaunay"``). +2. **Connectivity creation** -> ``nx.DiGraph`` with ``len`` and ``vdiff`` + edge attributes. + +Currently only *nodes-only* input is supported: the input graph must not +contain any edges. Support for user-provided edges (using them as the mesh +adjacency) is planned as a follow-up -- see the design discussion in +https://github.com/mllam/weather-model-graphs/issues/79. + +The user input contract: + +- an ``nx.Graph`` (or edge-less ``nx.DiGraph``) whose nodes carry: + + - ``pos``: ``np.ndarray`` of shape ``(2,)`` -- the node position, **in the + same coordinate system as the grid coordinates** passed to + ``create_all_graph_components`` + - ``type``: ``str``, must be ``"mesh"`` + - ``level``: ``int``, only for hierarchical meshes (lowest value = finest + level); must be present on either all nodes or none + +- or, for convenience, a bare ``np.ndarray`` of shape ``[N, 2]`` with node + positions (a nodes-only, single-level mesh). +""" + +from typing import List, Union + +import networkx +import numpy as np +import scipy.spatial +from loguru import logger + + +def validate_prebuilt_mesh_nodes( + mesh_graph: networkx.Graph, require_levels: bool = False +) -> None: + """ + Validate that a user-provided mesh graph satisfies the prebuilt nodes-only + input contract. + + Every node must have a ``pos`` attribute (``np.ndarray`` of shape ``(2,)`` + with finite values) and a ``type`` attribute equal to ``"mesh"``. Node + positions must be unique. The graph must not contain any edges + (user-provided edges are not yet supported, see issue #79). + + Parameters + ---------- + mesh_graph : networkx.Graph + User-provided graph to validate. + require_levels : bool + If True, additionally require an integer ``level`` attribute on every + node, with at least two distinct level values (needed for hierarchical + meshes). + + Raises + ------ + ValueError + If the graph is empty, a node attribute is missing or malformed, + positions are duplicated, or level attributes are inconsistent. + NotImplementedError + If the graph contains edges (nodes+edges input is not yet supported). + """ + if mesh_graph.number_of_nodes() == 0: + raise ValueError( + "mesh_layout='prebuilt' requires a mesh_graph with at least one node." + ) + + if mesh_graph.number_of_edges() > 0: + raise NotImplementedError( + "mesh_layout='prebuilt' currently only supports nodes-only input, " + f"but the given mesh_graph has {mesh_graph.number_of_edges()} " + "edge(s). Mesh connectivity is built in the connectivity step " + "(method='delaunay' by default). Support for user-provided edges " + "is planned -- see " + "https://github.com/mllam/weather-model-graphs/issues/79." + ) + + n_with_level = 0 + positions = [] + for node, data in mesh_graph.nodes(data=True): + if "pos" not in data: + raise ValueError( + f"Node {node!r} is missing the required 'pos' attribute. All " + "nodes in a prebuilt mesh must have 'pos' as an np.ndarray of " + "shape (2,)." + ) + pos = np.asarray(data["pos"]) + if pos.shape != (2,): + raise ValueError( + f"Node {node!r} has 'pos' with shape {pos.shape}, expected " + "(2,). All nodes in a prebuilt mesh must have 'pos' as an " + "np.ndarray of shape (2,)." + ) + if not np.all(np.isfinite(pos.astype(float))): + raise ValueError( + f"Node {node!r} has a non-finite 'pos' value ({pos}). Node " + "positions must be finite numbers." + ) + if data.get("type") != "mesh": + raise ValueError( + f"Node {node!r} has type={data.get('type')!r}, expected " + "'mesh'. All nodes in a prebuilt mesh must have the 'type' " + "attribute set to 'mesh' (the 'grid' node type is reserved " + "for the grid nodes created from the `coords` argument)." + ) + if "level" in data: + n_with_level += 1 + if not isinstance(data["level"], (int, np.integer)): + raise ValueError( + f"Node {node!r} has a non-integer 'level' attribute " + f"({data['level']!r}). Mesh levels must be integers " + "(lowest value = finest level)." + ) + positions.append(pos.astype(float)) + + n_nodes = mesh_graph.number_of_nodes() + if 0 < n_with_level < n_nodes: + raise ValueError( + f"Only {n_with_level} of {n_nodes} nodes have a 'level' " + "attribute. For a hierarchical prebuilt mesh every node must " + "have a 'level'; for a flat mesh no node should have one." + ) + + positions_arr = np.stack(positions) + n_unique = np.unique(positions_arr, axis=0).shape[0] + if n_unique < n_nodes: + raise ValueError( + f"The mesh_graph contains duplicate node positions ({n_nodes} " + f"nodes but only {n_unique} unique positions). Duplicate " + "positions would produce zero-length mesh edges." + ) + + if require_levels: + if n_with_level == 0: + raise ValueError( + "Hierarchical prebuilt meshes require an integer 'level' " + "attribute on every node (lowest value = finest level), but " + "no node has one." + ) + levels = {int(data["level"]) for _, data in mesh_graph.nodes(data=True)} + if len(levels) < 2: + raise ValueError( + "At least two distinct mesh levels are required for a " + f"hierarchical prebuilt mesh, but only level(s) " + f"{sorted(levels)} were found." + ) + + +def _as_node_cloud_graph( + mesh_graph: Union[networkx.Graph, np.ndarray] +) -> networkx.Graph: + """Normalize prebuilt-mesh input to an undirected node-cloud graph. + + Accepts either a graph (undirected or directed -- direction is the + library's to assign, so an edge-less DiGraph is treated as its + undirected node set) or a bare ``[N, 2]`` coordinate array. + """ + if isinstance(mesh_graph, np.ndarray): + xy = np.asarray(mesh_graph, dtype=float) + if xy.ndim != 2 or xy.shape[1] != 2: + raise ValueError( + "A prebuilt mesh given as an array must have shape " + f"[N_mesh_nodes, 2], got {xy.shape}." + ) + g = networkx.Graph() + for i, pos in enumerate(xy): + g.add_node(i, pos=pos, type="mesh") + return g + if isinstance(mesh_graph, networkx.Graph): # includes DiGraph + return networkx.Graph(mesh_graph) + raise TypeError( + "mesh_graph must be a networkx.Graph (or edge-less DiGraph) or an " + f"np.ndarray of shape [N, 2], got {type(mesh_graph).__name__}." + ) + + +def _estimate_node_spacing(positions: np.ndarray) -> float: + """Median nearest-neighbour distance -- the characteristic node spacing. + + Used to fill the ``dx``/``dy`` graph attributes that generated layouts + derive from their lattice spacing (needed e.g. by the hierarchical + connectivity step and relative-distance grid connection methods). + """ + if positions.shape[0] < 2: + return 0.0 + kdt = scipy.spatial.KDTree(positions) + # k=2: the nearest neighbour that isn't the node itself + dists, _ = kdt.query(positions, k=2) + return float(np.median(dists[:, 1])) + + +def _node_cloud_primitive(g_cloud: networkx.Graph) -> networkx.Graph: + """Build one edge-less mesh primitive from a validated node cloud. + + Node labels are replaced by ``(i,)`` integer tuples (insertion order) so + they sort against the grid node labels and support the level-index + prepending used by hierarchical connectivity. Only the contract + attributes (``pos``, ``type``) are carried over. + """ + g = networkx.Graph() + positions = [] + for i, (_, data) in enumerate(g_cloud.nodes(data=True)): + pos = np.asarray(data["pos"], dtype=float) + g.add_node((i,), pos=pos, type="mesh") + positions.append(pos) + spacing = _estimate_node_spacing(np.stack(positions)) + g.graph["dx"] = spacing + g.graph["dy"] = spacing + return g + + +def create_single_level_prebuilt_mesh_primitive( + mesh_graph: Union[networkx.Graph, np.ndarray] +) -> networkx.Graph: + """ + Create a single-level mesh primitive from user-provided mesh nodes. + + This is the coordinate creation step for ``mesh_layout="prebuilt"`` with + flat connectivity. The result is an *edge-less* undirected graph (a node + cloud): mesh adjacency for a point cloud is built in the connectivity + step (``method="delaunay"`` by default). + + Parameters + ---------- + mesh_graph : networkx.Graph or np.ndarray + User-provided mesh nodes (see the module docstring for the input + contract). If nodes carry a ``level`` attribute it is ignored (with + a warning) -- use ``m2m_connectivity="hierarchical"`` to build a + hierarchical mesh from the levels. + + Returns + ------- + networkx.Graph + Edge-less mesh primitive. Node attributes: ``pos`` + (np.ndarray of shape ``(2,)``), ``type`` (``"mesh"``). Graph + attributes: ``dx``, ``dy`` (median nearest-neighbour node spacing). + """ + g_cloud = _as_node_cloud_graph(mesh_graph) + validate_prebuilt_mesh_nodes(g_cloud) + if any("level" in d for _, d in g_cloud.nodes(data=True)): + logger.warning( + "The prebuilt mesh_graph nodes carry 'level' attributes but a " + "single-level (flat) mesh was requested; the levels are ignored. " + "Use m2m_connectivity='hierarchical' to build a hierarchical " + "mesh from them." + ) + return _node_cloud_primitive(g_cloud) + + +def create_multi_level_prebuilt_mesh_primitives( + mesh_graph: Union[networkx.Graph, np.ndarray] +) -> List[networkx.Graph]: + """ + Create per-level mesh primitives from user-provided mesh nodes with + ``level`` attributes. + + This is the coordinate creation step for ``mesh_layout="prebuilt"`` with + hierarchical connectivity. Nodes are split by their integer ``level`` + attribute (lowest value = finest level) into one *edge-less* primitive + per level; intra-level adjacency is built per level in the connectivity + step (``intra_level=dict(method="delaunay")`` by default) and inter-level + up/down edges by nearest-neighbour search (``inter_level``). + + Parameters + ---------- + mesh_graph : networkx.Graph + User-provided mesh nodes with ``pos``, ``type`` and ``level`` + attributes on every node (see the module docstring). + + Returns + ------- + list[networkx.Graph] + Edge-less mesh primitives, one per level, ordered finest first. + Each carries the graph attributes ``level`` (0-based level index), + ``dx`` and ``dy`` (median nearest-neighbour spacing of that level). + """ + g_cloud = _as_node_cloud_graph(mesh_graph) + validate_prebuilt_mesh_nodes(g_cloud, require_levels=True) + + user_levels = sorted({int(d["level"]) for _, d in g_cloud.nodes(data=True)}) + + primitives = [] + for level_index, user_level in enumerate(user_levels): + level_nodes = [ + n for n, d in g_cloud.nodes(data=True) if int(d["level"]) == user_level + ] + g_level = _node_cloud_primitive(g_cloud.subgraph(level_nodes)) + for node in g_level.nodes: + g_level.nodes[node]["level"] = level_index + g_level.graph["level"] = level_index + primitives.append(g_level) + + return primitives From 554943819160440178d097cacae8e6803571fb21 Mon Sep 17 00:00:00 2001 From: prajwal Date: Sat, 18 Jul 2026 11:24:40 +0530 Subject: [PATCH 14/16] Wire mesh_layout='prebuilt' into create_all_graph_components + tests - accept mesh_layout_kwargs=dict(mesh_graph=...) (nx.Graph or [N, 2] ndarray); no mesh_node_spacing needed since spacing is implied by the node positions - flat: forward optional pattern/method to the connectivity step (no more hardcoded 8-star default; omitting pattern uses every layout edge, which is behaviour-identical for the generated layouts) - hierarchical: multi-level primitives split by the nodes' integer 'level' attribute (lowest = finest); grid connects to the finest level as usual - flat_multiscale with prebuilt raises NotImplementedError for now - tests: input validation, primitive creation, Delaunay connectivity (incl. 1/2-node clouds, collinear degeneracy, pattern-vs-method errors), flat + hierarchical end-to-end, and a pattern-default equivalence guard for the generated layouts --- src/weather_model_graphs/create/base.py | 106 ++++-- tests/test_prebuilt_mesh.py | 464 ++++++++++++++++++++++++ 2 files changed, 547 insertions(+), 23 deletions(-) create mode 100644 tests/test_prebuilt_mesh.py diff --git a/src/weather_model_graphs/create/base.py b/src/weather_model_graphs/create/base.py index 94493b8..9f70c86 100644 --- a/src/weather_model_graphs/create/base.py +++ b/src/weather_model_graphs/create/base.py @@ -29,6 +29,10 @@ create_flat_singlescale_from_coordinates, ) from .mesh.connectivity.hierarchical import create_hierarchical_from_coordinates +from .mesh.layout.prebuilt import ( + create_multi_level_prebuilt_mesh_primitives, + create_single_level_prebuilt_mesh_primitive, +) from .mesh.layout.rectilinear import ( create_multirange_2d_mesh_primitives as create_multirange_2d_rectilinear_mesh_primitives, ) @@ -154,6 +158,14 @@ def create_all_graph_components( resolution. Uses ``networkx.triangular_lattice_graph`` to produce equilateral triangles with 6-connectivity. A CRS warning is emitted if ``graph_crs`` is geographic (lat/lon). + - "prebuilt": User-provided mesh node positions (e.g. ICON grid vertices + or an observation-station network). The mesh nodes are taken from + ``mesh_layout_kwargs["mesh_graph"]`` and mesh edges are built in the + connectivity step (``method``, Delaunay triangulation by default). + Currently nodes-only input is supported (the given graph must not + contain edges) and ``m2m_connectivity`` must be "flat" or + "hierarchical". See ``create.mesh.layout.prebuilt`` for the input + contract. mesh_layout_kwargs (for mesh_layout="rectilinear" or "triangular"): - mesh_node_spacing: float, distance between mesh nodes in coordinate units. @@ -162,18 +174,33 @@ def create_all_graph_components( - max_num_refinement_levels: int, maximum number of mesh levels (for multi-level and hierarchical mesh graphs) - Wherever the ``pattern`` argument appears below it defines the spatial - neighbourhood connectivity: + mesh_layout_kwargs (for mesh_layout="prebuilt"): + - mesh_graph: networkx.Graph with node attributes ``pos`` (np.ndarray of + shape (2,), same coordinate system as ``coords``), ``type`` ("mesh"), + and -- for hierarchical meshes -- integer ``level`` (lowest value = + finest level); or an np.ndarray of shape [N_mesh_nodes, 2] with node + positions. No ``mesh_node_spacing`` is needed (spacing is implied by + the node positions). + + Wherever the ``pattern`` argument appears below it selects a subset of + the spatial adjacency edges created by the (generated) mesh layout: + - not given (default): use every edge the layout produced - ``"4-star"``: only cardinal directions (horizontal and vertical neighbours) - ``"8-star"``: cardinal plus diagonal neighbours (all 8 surrounding nodes) + For mesh_layout="prebuilt" the primitives are edge-less node clouds, so + ``pattern`` does not apply; the ``method`` argument (default: + ``"delaunay"``) selects how mesh edges are built from the node positions. m2m_connectivity: - "flat": Create a single-level directed mesh graph. - m2m_connectivity_kwargs: pattern (default: "8-star") + m2m_connectivity_kwargs: pattern (generated layouts) or + method (mesh_layout="prebuilt", default: "delaunay") - "flat_multiscale": Create a flat multiscale mesh graph. - m2m_connectivity_kwargs: pattern (default: "8-star") + m2m_connectivity_kwargs: pattern + (not yet supported for mesh_layout="prebuilt") - "hierarchical": Create a hierarchical mesh graph with up/down connections. - m2m_connectivity_kwargs: intra_level=dict(pattern=...), inter_level=dict(pattern=..., k=...) + m2m_connectivity_kwargs: intra_level=dict(pattern=... or method=...), + inter_level=dict(pattern=..., k=...) m2g_connectivity: - "nearest_neighbour": Find the nearest neighbour in mesh for each node in grid @@ -283,22 +310,33 @@ def create_all_graph_components( ) # Validate mesh_layout and resolve the requested mesh node spacing once - # (shared by all m2m_connectivity modes and both layouts). - if mesh_layout not in ("rectilinear", "triangular"): + # (shared by all m2m_connectivity modes and layouts). + if mesh_layout not in ("rectilinear", "triangular", "prebuilt"): raise NotImplementedError( f"mesh_layout='{mesh_layout}' is not yet supported. " - "Currently supported: 'rectilinear', 'triangular'." + "Currently supported: 'rectilinear', 'triangular', 'prebuilt'." ) - mesh_node_spacing = mesh_layout_kwargs.get( - "mesh_node_spacing" - ) or mesh_layout_kwargs.get("grid_spacing") - if mesh_node_spacing is None: - raise ValueError( - f"mesh_layout='{mesh_layout}' requires 'mesh_node_spacing' in " - "mesh_layout_kwargs (or 'mesh_node_distance' in " - "m2m_connectivity_kwargs for backward compatibility)." - ) + if mesh_layout == "prebuilt": + # Prebuilt meshes carry their own node positions, so no + # mesh_node_spacing is needed (spacing is implied by the positions) + mesh_graph = mesh_layout_kwargs.get("mesh_graph") + if mesh_graph is None: + raise ValueError( + "mesh_layout='prebuilt' requires 'mesh_graph' in " + "mesh_layout_kwargs: a networkx.Graph of mesh nodes (or an " + "np.ndarray of node positions with shape [N_mesh_nodes, 2])." + ) + else: + mesh_node_spacing = mesh_layout_kwargs.get( + "mesh_node_spacing" + ) or mesh_layout_kwargs.get("grid_spacing") + if mesh_node_spacing is None: + raise ValueError( + f"mesh_layout='{mesh_layout}' requires 'mesh_node_spacing' in " + "mesh_layout_kwargs (or 'mesh_node_distance' in " + "m2m_connectivity_kwargs for backward compatibility)." + ) # Pick the coordinate-creation function based on the mesh_layout value, # nested inside the m2m_connectivity branch (single-level vs multi-level). @@ -312,11 +350,21 @@ def create_all_graph_components( G_mesh_coords = create_single_level_2d_triangular_mesh_primitive( xy, mesh_node_spacing=mesh_node_spacing ) + elif mesh_layout == "prebuilt": + G_mesh_coords = create_single_level_prebuilt_mesh_primitive(mesh_graph) else: raise NotImplementedError( f"mesh_layout='{mesh_layout}' is not implemented. " - "Supported layouts: 'rectilinear', 'triangular'." + "Supported layouts: 'rectilinear', 'triangular', 'prebuilt'." ) + elif mesh_layout == "prebuilt": + # Multi-level prebuilt primitives, split by the nodes' `level` attribute + if m2m_connectivity == "flat_multiscale": + raise NotImplementedError( + "m2m_connectivity='flat_multiscale' is not yet supported for " + "mesh_layout='prebuilt'. Use 'flat' or 'hierarchical'." + ) + G_mesh_coords = create_multi_level_prebuilt_mesh_primitives(mesh_graph) else: # Multi-level mesh primitives (flat_multiscale or hierarchical) primitives_kwargs = dict(xy=xy, mesh_node_spacing=mesh_node_spacing) @@ -339,16 +387,24 @@ def create_all_graph_components( else: raise NotImplementedError( f"mesh_layout='{mesh_layout}' is not implemented. " - "Supported layouts: 'rectilinear', 'triangular'." + "Supported layouts: 'rectilinear', 'triangular', 'prebuilt'." ) # ----------------------------------------------------------------------- # Step 2: Connectivity creation — converts mesh primitives to directed graph # ----------------------------------------------------------------------- if m2m_connectivity == "flat": - pattern = m2m_connectivity_kwargs.get("pattern", "8-star") + # `pattern` selects adjacency edges of generated layouts; `method` + # builds edges from node positions for edge-less (prebuilt) + # primitives. Both default to "use what the layout implies" when not + # given (all layout edges, and Delaunay triangulation respectively). + conn_kwargs = { + key: m2m_connectivity_kwargs[key] + for key in ("pattern", "method") + if key in m2m_connectivity_kwargs + } graph_components["m2m"] = create_flat_singlescale_from_coordinates( - G_mesh_coords, pattern=pattern + G_mesh_coords, **conn_kwargs ) grid_connect_graph = graph_components["m2m"] @@ -372,9 +428,13 @@ def create_all_graph_components( )[0] elif m2m_connectivity == "flat_multiscale": - pattern = m2m_connectivity_kwargs.get("pattern", "8-star") + conn_kwargs = { + key: m2m_connectivity_kwargs[key] + for key in ("pattern",) + if key in m2m_connectivity_kwargs + } graph_components["m2m"] = create_flat_multiscale_from_coordinates( - G_mesh_coords, pattern=pattern + G_mesh_coords, **conn_kwargs ) grid_connect_graph = graph_components["m2m"] diff --git a/tests/test_prebuilt_mesh.py b/tests/test_prebuilt_mesh.py new file mode 100644 index 0000000..9de3bf7 --- /dev/null +++ b/tests/test_prebuilt_mesh.py @@ -0,0 +1,464 @@ +""" +Tests for mesh_layout="prebuilt" support (Issue #79). + +Tests verify: +1. Input validation (nodes-only contract: pos/type/level attributes, + duplicate positions, edges rejected) +2. Single- and multi-level primitive creation (edge-less node clouds, + tuple relabelling, dx/dy spacing estimate, level splitting) +3. Directed mesh graph construction from node clouds + (method="delaunay": Delaunay edges, bidirectional len/vdiff, + small/degenerate node clouds, pattern-vs-method argument validation) +4. Integration through create_all_graph_components for flat and + hierarchical connectivity (including the np.ndarray convenience input) +5. Generated-layout behaviour is unchanged (pattern default equivalence) +""" + +import networkx as nx +import numpy as np +import pytest + +import tests.utils as test_utils +import weather_model_graphs as wmg +from weather_model_graphs.create.mesh.connectivity.general import ( + create_directed_mesh_graph, +) +from weather_model_graphs.create.mesh.connectivity.hierarchical import ( + create_hierarchical_from_coordinates, +) +from weather_model_graphs.create.mesh.layout.prebuilt import ( + create_multi_level_prebuilt_mesh_primitives, + create_single_level_prebuilt_mesh_primitive, + validate_prebuilt_mesh_nodes, +) + +# =========================== +# Fixtures +# =========================== + + +@pytest.fixture +def xy_grid(): + """Grid point coordinates covering [0, 10]^2.""" + return test_utils.create_fake_xy(N=10) * 10 / 10 + + +@pytest.fixture +def mesh_xy(): + """Irregular mesh node positions inside the grid domain.""" + rng = np.random.default_rng(seed=7) + return rng.random((25, 2)) * 10 + + +def _nodes_only_graph(positions, level=None, label=lambda i: i): + """Build a nodes-only mesh graph from an [N, 2] position array.""" + g = nx.Graph() + for i, pos in enumerate(positions): + attrs = dict(pos=np.asarray(pos, dtype=float), type="mesh") + if level is not None: + attrs["level"] = level + g.add_node(label(i), **attrs) + return g + + +@pytest.fixture +def mesh_graph(mesh_xy): + """Nodes-only mesh graph with string labels.""" + return _nodes_only_graph(mesh_xy, label=lambda i: f"station_{i}") + + +@pytest.fixture +def mesh_graph_two_levels(mesh_xy): + """Nodes-only mesh graph with two levels (1 = fine, 2 = coarse).""" + rng = np.random.default_rng(seed=11) + g = _nodes_only_graph(mesh_xy, level=1, label=lambda i: ("f", i)) + for i, pos in enumerate(rng.random((6, 2)) * 10): + g.add_node(("c", i), pos=pos, type="mesh", level=2) + return g + + +# =========================== +# 1. Input validation +# =========================== + + +class TestValidatePrebuiltMeshNodes: + def test_valid_nodes_pass(self, mesh_graph): + validate_prebuilt_mesh_nodes(mesh_graph) + + def test_empty_graph_raises(self): + with pytest.raises(ValueError, match="at least one node"): + validate_prebuilt_mesh_nodes(nx.Graph()) + + def test_missing_pos_raises(self): + g = nx.Graph() + g.add_node(0, type="mesh") + with pytest.raises(ValueError, match="missing the required 'pos'"): + validate_prebuilt_mesh_nodes(g) + + def test_wrong_pos_shape_raises(self): + g = nx.Graph() + g.add_node(0, pos=np.array([1.0, 2.0, 3.0]), type="mesh") + with pytest.raises(ValueError, match="shape"): + validate_prebuilt_mesh_nodes(g) + + def test_non_finite_pos_raises(self): + g = nx.Graph() + g.add_node(0, pos=np.array([np.nan, 0.0]), type="mesh") + with pytest.raises(ValueError, match="non-finite"): + validate_prebuilt_mesh_nodes(g) + + def test_missing_type_raises(self): + g = nx.Graph() + g.add_node(0, pos=np.array([0.0, 0.0])) + with pytest.raises(ValueError, match="type"): + validate_prebuilt_mesh_nodes(g) + + def test_wrong_type_value_raises(self): + g = nx.Graph() + g.add_node(0, pos=np.array([0.0, 0.0]), type="grid") + with pytest.raises(ValueError, match="expected 'mesh'"): + validate_prebuilt_mesh_nodes(g) + + def test_duplicate_positions_raise(self): + g = _nodes_only_graph([[0.0, 0.0], [1.0, 1.0], [0.0, 0.0]]) + with pytest.raises(ValueError, match="duplicate node positions"): + validate_prebuilt_mesh_nodes(g) + + def test_edges_not_yet_supported(self, mesh_graph): + mesh_graph.add_edge("station_0", "station_1") + with pytest.raises(NotImplementedError, match="nodes-only"): + validate_prebuilt_mesh_nodes(mesh_graph) + + def test_mixed_level_presence_raises(self, mesh_xy): + g = _nodes_only_graph(mesh_xy) + g.nodes[0]["level"] = 1 + with pytest.raises(ValueError, match="'level'"): + validate_prebuilt_mesh_nodes(g) + + def test_non_integer_level_raises(self, mesh_xy): + g = _nodes_only_graph(mesh_xy, level=1) + g.nodes[0]["level"] = "fine" + with pytest.raises(ValueError, match="non-integer 'level'"): + validate_prebuilt_mesh_nodes(g) + + def test_require_levels_missing_raises(self, mesh_graph): + with pytest.raises(ValueError, match="no node has one"): + validate_prebuilt_mesh_nodes(mesh_graph, require_levels=True) + + def test_require_levels_single_level_raises(self, mesh_xy): + g = _nodes_only_graph(mesh_xy, level=1) + with pytest.raises(ValueError, match="two distinct mesh levels"): + validate_prebuilt_mesh_nodes(g, require_levels=True) + + +# =========================== +# 2. Primitive creation (coordinate creation step) +# =========================== + + +class TestSingleLevelPrimitive: + def test_is_edge_less_node_cloud(self, mesh_graph, mesh_xy): + g = create_single_level_prebuilt_mesh_primitive(mesh_graph) + assert g.number_of_nodes() == len(mesh_xy) + assert g.number_of_edges() == 0 + + def test_nodes_relabelled_to_tuples(self, mesh_graph): + g = create_single_level_prebuilt_mesh_primitive(mesh_graph) + assert all(isinstance(n, tuple) for n in g.nodes) + # tuple labels must sort against the (level_id, i) grid node labels + assert sorted(g.nodes) == list(g.nodes) + + def test_positions_preserved(self, mesh_graph, mesh_xy): + g = create_single_level_prebuilt_mesh_primitive(mesh_graph) + positions = np.stack([g.nodes[n]["pos"] for n in g.nodes]) + assert np.allclose(np.sort(positions, axis=0), np.sort(mesh_xy, axis=0)) + + def test_spacing_estimate_set(self, mesh_graph): + g = create_single_level_prebuilt_mesh_primitive(mesh_graph) + assert g.graph["dx"] > 0 + assert g.graph["dx"] == g.graph["dy"] + + def test_ndarray_input(self, mesh_xy): + g = create_single_level_prebuilt_mesh_primitive(mesh_xy) + assert g.number_of_nodes() == len(mesh_xy) + assert g.number_of_edges() == 0 + + def test_bad_ndarray_shape_raises(self): + with pytest.raises(ValueError, match=r"\[N_mesh_nodes, 2\]"): + create_single_level_prebuilt_mesh_primitive(np.zeros((3, 4))) + + def test_bad_input_type_raises(self): + with pytest.raises(TypeError, match="mesh_graph must be"): + create_single_level_prebuilt_mesh_primitive([[0, 0], [1, 1]]) + + def test_edge_less_digraph_accepted(self, mesh_xy): + dg = nx.DiGraph() + for i, pos in enumerate(mesh_xy): + dg.add_node(i, pos=pos, type="mesh") + g = create_single_level_prebuilt_mesh_primitive(dg) + assert g.number_of_nodes() == len(mesh_xy) + + +class TestMultiLevelPrimitives: + def test_split_by_level_finest_first(self, mesh_graph_two_levels, mesh_xy): + primitives = create_multi_level_prebuilt_mesh_primitives(mesh_graph_two_levels) + assert len(primitives) == 2 + # level 1 (finest, 25 nodes) must come first as level index 0 + assert primitives[0].number_of_nodes() == len(mesh_xy) + assert primitives[0].graph["level"] == 0 + assert primitives[1].number_of_nodes() == 6 + assert primitives[1].graph["level"] == 1 + + def test_primitives_are_edge_less(self, mesh_graph_two_levels): + primitives = create_multi_level_prebuilt_mesh_primitives(mesh_graph_two_levels) + assert all(g.number_of_edges() == 0 for g in primitives) + + def test_level_values_need_not_be_contiguous(self, mesh_xy): + g = _nodes_only_graph(mesh_xy[:10], level=3) + for i, pos in enumerate(mesh_xy[10:15]): + g.add_node(("coarse", i), pos=pos, type="mesh", level=7) + primitives = create_multi_level_prebuilt_mesh_primitives(g) + assert [p.graph["level"] for p in primitives] == [0, 1] + assert primitives[0].number_of_nodes() == 10 + + def test_per_level_spacing_estimates(self, mesh_graph_two_levels): + primitives = create_multi_level_prebuilt_mesh_primitives(mesh_graph_two_levels) + assert all(g.graph["dx"] > 0 for g in primitives) + + +# =========================== +# 3. Directed mesh graph from node clouds (connectivity step) +# =========================== + + +class TestNodeCloudDirectedGraph: + def test_delaunay_bidirectional_len_vdiff(self, mesh_graph): + g_prim = create_single_level_prebuilt_mesh_primitive(mesh_graph) + dg = create_directed_mesh_graph(g_prim) + assert isinstance(dg, nx.DiGraph) + assert dg.number_of_edges() > 0 + for u, v, d in dg.edges(data=True): + assert dg.has_edge(v, u) + assert d["len"] > 0 + assert np.allclose(d["vdiff"], -dg.edges[v, u]["vdiff"]) + assert np.isclose(d["len"], np.linalg.norm(d["vdiff"])) + + def test_delaunay_edges_match_scipy(self, mesh_xy): + import scipy.spatial + + g_prim = create_single_level_prebuilt_mesh_primitive(mesh_xy) + dg = create_directed_mesh_graph(g_prim) + tri = scipy.spatial.Delaunay(mesh_xy) + expected_pairs = set() + for simplex in tri.simplices: + for i in range(3): + a, b = sorted((simplex[i], simplex[(i + 1) % 3])) + expected_pairs.add((a, b)) + assert dg.number_of_edges() == 2 * len(expected_pairs) + + def test_single_node_no_edges(self): + g_prim = create_single_level_prebuilt_mesh_primitive(np.array([[1.0, 2.0]])) + dg = create_directed_mesh_graph(g_prim) + assert dg.number_of_nodes() == 1 + assert dg.number_of_edges() == 0 + + def test_two_nodes_bidirectional_pair(self): + g_prim = create_single_level_prebuilt_mesh_primitive( + np.array([[0.0, 0.0], [3.0, 4.0]]) + ) + dg = create_directed_mesh_graph(g_prim) + assert dg.number_of_edges() == 2 + (d,) = [d for _, _, d in dg.edges(data=True) if d["vdiff"][0] < 0] + assert np.isclose(d["len"], 5.0) + + def test_three_nodes_triangle(self): + g_prim = create_single_level_prebuilt_mesh_primitive( + np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + ) + dg = create_directed_mesh_graph(g_prim) + assert dg.number_of_edges() == 6 + + def test_collinear_nodes_raise(self): + g_prim = create_single_level_prebuilt_mesh_primitive( + np.array([[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]]) + ) + with pytest.raises(ValueError, match="collinear"): + create_directed_mesh_graph(g_prim) + + def test_pattern_on_node_cloud_raises(self, mesh_graph): + g_prim = create_single_level_prebuilt_mesh_primitive(mesh_graph) + with pytest.raises(ValueError, match="method='delaunay'"): + create_directed_mesh_graph(g_prim, pattern="8-star") + + def test_unknown_method_raises(self, mesh_graph): + g_prim = create_single_level_prebuilt_mesh_primitive(mesh_graph) + with pytest.raises(NotImplementedError, match="'delaunay'"): + create_directed_mesh_graph(g_prim, method="knn") + + def test_method_on_lattice_primitive_raises(self, xy_grid): + from weather_model_graphs.create.mesh.layout.rectilinear import ( + create_single_level_2d_mesh_primitive, + ) + + g_prim = create_single_level_2d_mesh_primitive(xy_grid, nx=4, ny=4) + with pytest.raises(ValueError, match="already"): + create_directed_mesh_graph(g_prim, method="delaunay") + + +# =========================== +# 4. Integration through create_all_graph_components +# =========================== + + +class TestFlatEndToEnd: + def test_flat_components(self, xy_grid, mesh_graph, mesh_xy): + components = wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph), + m2m_connectivity="flat", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + return_components=True, + ) + assert set(components.keys()) == {"m2m", "g2m", "m2g"} + m2m = components["m2m"] + mesh_nodes = [n for n, d in m2m.nodes(data=True) if d.get("type") == "mesh"] + assert len(mesh_nodes) == len(mesh_xy) + assert m2m.number_of_edges() > 0 + assert components["g2m"].number_of_edges() == len(mesh_xy) + + def test_explicit_delaunay_method_matches_default(self, xy_grid, mesh_graph): + kwargs = dict( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph), + m2m_connectivity="flat", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + return_components=True, + ) + default = wmg.create.create_all_graph_components(**kwargs) + explicit = wmg.create.create_all_graph_components( + m2m_connectivity_kwargs=dict(method="delaunay"), **kwargs + ) + assert default["m2m"].number_of_edges() == explicit["m2m"].number_of_edges() + + def test_merged_single_graph(self, xy_grid, mesh_xy): + graph = wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_xy), + m2m_connectivity="flat", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + ) + assert graph.number_of_nodes() == len(xy_grid) + len(mesh_xy) + + def test_missing_mesh_graph_raises(self, xy_grid): + with pytest.raises(ValueError, match="mesh_graph"): + wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + m2m_connectivity="flat", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + ) + + def test_flat_multiscale_not_supported(self, xy_grid, mesh_graph): + with pytest.raises(NotImplementedError, match="flat_multiscale"): + wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph), + m2m_connectivity="flat_multiscale", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + ) + + +class TestHierarchicalEndToEnd: + def test_hierarchical_components(self, xy_grid, mesh_graph_two_levels, mesh_xy): + components = wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph_two_levels), + m2m_connectivity="hierarchical", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + return_components=True, + ) + m2m = components["m2m"] + directions = { + d["direction"] for _, _, d in m2m.edges(data=True) if "direction" in d + } + assert directions == {"same", "up", "down"} + n_up = sum(1 for _, _, d in m2m.edges(data=True) if d.get("direction") == "up") + # nearest with k=1: one up edge per fine node + assert n_up == len(mesh_xy) + # the grid connects only to the finest level + assert components["g2m"].number_of_edges() == len(mesh_xy) + + def test_intra_level_method_kwarg(self, xy_grid, mesh_graph_two_levels): + components = wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph_two_levels), + m2m_connectivity="hierarchical", + m2m_connectivity_kwargs=dict( + intra_level=dict(method="delaunay"), + inter_level=dict(pattern="nearest", k=2), + ), + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + return_components=True, + ) + n_up = sum( + 1 + for _, _, d in components["m2m"].edges(data=True) + if d.get("direction") == "up" + ) + # k=2: two up edges per fine node + assert n_up == 2 * mesh_graph_two_levels.number_of_nodes() - 2 * 6 + + def test_hierarchical_without_levels_raises(self, xy_grid, mesh_graph): + with pytest.raises(ValueError, match="level"): + wmg.create.create_all_graph_components( + coords=xy_grid, + mesh_layout="prebuilt", + mesh_layout_kwargs=dict(mesh_graph=mesh_graph), + m2m_connectivity="hierarchical", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + ) + + def test_direct_hierarchical_from_prebuilt_primitives(self, mesh_graph_two_levels): + primitives = create_multi_level_prebuilt_mesh_primitives(mesh_graph_two_levels) + m2m = create_hierarchical_from_coordinates(primitives) + assert m2m.number_of_edges() > 0 + assert set(m2m.graph["dx"].keys()) == {0, 1} + + +# =========================== +# 5. Generated layouts unchanged (pattern default equivalence) +# =========================== + + +class TestGeneratedLayoutsUnchanged: + @pytest.mark.parametrize("mesh_layout", ["rectilinear", "triangular"]) + def test_no_pattern_equals_8_star(self, xy_grid, mesh_layout): + kwargs = dict( + coords=xy_grid, + mesh_layout=mesh_layout, + mesh_layout_kwargs=dict(mesh_node_spacing=2), + m2m_connectivity="flat", + g2m_connectivity="nearest_neighbour", + m2g_connectivity="nearest_neighbour", + return_components=True, + ) + default = wmg.create.create_all_graph_components(**kwargs) + explicit = wmg.create.create_all_graph_components( + m2m_connectivity_kwargs=dict(pattern="8-star"), **kwargs + ) + assert default["m2m"].number_of_edges() == explicit["m2m"].number_of_edges() From 2b13e5a8c67c90e894d853939a68a059af455609 Mon Sep 17 00:00:00 2001 From: prajwal Date: Sat, 18 Jul 2026 11:24:55 +0530 Subject: [PATCH 15/16] Add prebuilt mesh jupyter-book chapter + CHANGELOG entry New docs chapter walks through the input contract, the flat (Delaunay) and hierarchical (level-attribute) nodes-only cases with plots, the validation errors, and how to load real mesh sources (station CSV, ICON vertices) into the node-cloud graph. --- CHANGELOG.md | 11 ++ docs/_toc.yml | 1 + docs/prebuilt_mesh.ipynb | 312 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 324 insertions(+) create mode 100644 docs/prebuilt_mesh.ipynb diff --git a/CHANGELOG.md b/CHANGELOG.md index 03ad499..89fa7fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Add `mesh_layout="prebuilt"` support to `create_all_graph_components` for + user-provided mesh node positions (e.g. ICON grid vertices or an + observation-station network), given as a nodes-only `networkx.Graph` (or a + bare `[N, 2]` coordinate array) via `mesh_layout_kwargs=dict(mesh_graph=...)`. + Mesh edges are built in the connectivity step directly from the node + positions (`method="delaunay"`); hierarchical meshes are declared with an + integer `level` node attribute. New module `create/mesh/layout/prebuilt.py` + contains the input validation and primitive creation; the connectivity step + now also validates that an explicit `pattern` matches the adjacency types + present in the mesh primitive instead of silently producing an empty mesh. + [\#79](https://github.com/mllam/weather-model-graphs/issues/79), @prajwal-tech07 - Add `mesh_layout="triangular"` support to `create_all_graph_components`, using `networkx.triangular_lattice_graph` to produce an equilateral-triangle lattice with 6-connectivity. Supports all three `m2m_connectivity` modes: `flat`, diff --git a/docs/_toc.yml b/docs/_toc.yml index 17d5ccc..9dc4146 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -8,5 +8,6 @@ chapters: - file: design - file: creating_the_graph - file: mesh_layout +- file: prebuilt_mesh - file: lat_lons - file: decoding_mask diff --git a/docs/prebuilt_mesh.ipynb b/docs/prebuilt_mesh.ipynb new file mode 100644 index 0000000..d423925 --- /dev/null +++ b/docs/prebuilt_mesh.ipynb @@ -0,0 +1,312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bring your own mesh: the prebuilt mesh layout\n", + "\n", + "The generated mesh layouts (`rectilinear`, `triangular`) place mesh nodes for you.\n", + "With `mesh_layout=\"prebuilt\"` you instead supply **your own mesh node positions** --\n", + "for example ICON grid vertices, MPAS cell centres, or an observation-station network --\n", + "and `weather-model-graphs` builds the encode-process-decode graph around them.\n", + "\n", + "The two-step mesh creation process still applies, with a twist:\n", + "\n", + "1. **Coordinate creation** (`mesh_layout=\"prebuilt\"`): your nodes are validated and\n", + " passed through as an *edge-less node cloud* -- no adjacency is invented here.\n", + "2. **Connectivity creation** (`m2m_connectivity`): mesh edges are built directly from\n", + " the node positions (`method=\"delaunay\"`, the default) and directed with\n", + " `len`/`vdiff` edge features.\n", + "\n", + "```{note}\n", + "Currently the prebuilt layout supports **nodes-only** input: the mesh graph you\n", + "provide must not contain any edges. Support for user-provided edges is planned --\n", + "see the design discussion in\n", + "[issue #79](https://github.com/mllam/weather-model-graphs/issues/79).\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "\n", + "import weather_model_graphs as wmg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The input contract\n", + "\n", + "Provide a `networkx.Graph` where **every node** has:\n", + "\n", + "- `pos`: `np.ndarray` of shape `(2,)` -- the node position. **These must be in the\n", + " same coordinate system as the grid `coords`** you pass to\n", + " `create_all_graph_components` (the library cannot check this for you!).\n", + "- `type`: the string `\"mesh\"`.\n", + "- `level`: an integer, **only** for hierarchical meshes (lowest value = finest\n", + " level); either all nodes have one or none do.\n", + "\n", + "Node positions must be unique. For the simplest case you can also pass a bare\n", + "`np.ndarray` of shape `[N, 2]` instead of a graph.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up a fake grid and some mesh nodes\n", + "\n", + "We create a regular grid of (x, y) coordinates (the locations of the input/output\n", + "data) and a set of irregular \"station-like\" mesh node positions inside the same\n", + "domain.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "xs, ys = np.meshgrid(np.linspace(0, 10, 32), np.linspace(0, 10, 32))\n", + "xy = np.stack([xs.flatten(), ys.flatten()], axis=-1)\n", + "\n", + "rng = np.random.default_rng(seed=42)\n", + "mesh_xy = rng.random((40, 2)) * 10\n", + "\n", + "my_mesh = nx.Graph()\n", + "for i, pos in enumerate(mesh_xy):\n", + " my_mesh.add_node(i, pos=pos, type=\"mesh\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "ax.scatter(xy[:, 0], xy[:, 1], s=2, alpha=0.3, label=\"grid points\")\n", + "ax.scatter(mesh_xy[:, 0], mesh_xy[:, 1], s=40, marker=\"^\", label=\"my mesh nodes\")\n", + "ax.legend()\n", + "ax.set_title(\"User-provided mesh nodes over the data grid\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1 -- flat mesh from nodes only\n", + "\n", + "With nodes-only input the connectivity step builds the mesh edges by Delaunay\n", + "triangulation of the node positions (`method=\"delaunay\"` is the default, shown\n", + "here explicitly).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "graph_flat = wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"prebuilt\",\n", + " mesh_layout_kwargs=dict(mesh_graph=my_mesh),\n", + " m2m_connectivity=\"flat\",\n", + " m2m_connectivity_kwargs=dict(method=\"delaunay\"),\n", + " g2m_connectivity=\"nearest_neighbour\",\n", + " m2g_connectivity=\"nearest_neighbour\",\n", + ")\n", + "\n", + "m2m_flat = wmg.split_graph_by_edge_attribute(graph_flat, attr=\"component\")[\"m2m\"]\n", + "\n", + "print(f\"Mesh nodes : {m2m_flat.number_of_nodes()}\")\n", + "print(f\"Mesh edges : {m2m_flat.number_of_edges()}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "wmg.visualise.nx_draw_with_pos_and_attr(m2m_flat, ax=ax, node_size=30)\n", + "ax.set_title(\"Flat prebuilt mesh (Delaunay connectivity)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The convenience form skips building the graph yourself -- pass the coordinate\n", + "array directly:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "graph_from_array = wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"prebuilt\",\n", + " mesh_layout_kwargs=dict(mesh_graph=mesh_xy),\n", + " m2m_connectivity=\"flat\",\n", + " g2m_connectivity=\"nearest_neighbour\",\n", + " m2g_connectivity=\"nearest_neighbour\",\n", + ")\n", + "graph_from_array.number_of_nodes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2 -- hierarchical mesh from `level` attributes\n", + "\n", + "For a hierarchical mesh, give every node an integer `level` attribute (lowest\n", + "value = finest). Within each level the mesh edges are built per level\n", + "(`intra_level=dict(method=\"delaunay\")`); between levels, `mesh_up`/`mesh_down`\n", + "edges are created by nearest-neighbour search (`inter_level`), exactly as for the\n", + "generated layouts.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_mesh_hier = nx.Graph()\n", + "for i, pos in enumerate(mesh_xy):\n", + " my_mesh_hier.add_node((\"fine\", i), pos=pos, type=\"mesh\", level=1)\n", + "coarse_xy = rng.random((8, 2)) * 10\n", + "for i, pos in enumerate(coarse_xy):\n", + " my_mesh_hier.add_node((\"coarse\", i), pos=pos, type=\"mesh\", level=2)\n", + "\n", + "components = wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"prebuilt\",\n", + " mesh_layout_kwargs=dict(mesh_graph=my_mesh_hier),\n", + " m2m_connectivity=\"hierarchical\",\n", + " m2m_connectivity_kwargs=dict(\n", + " intra_level=dict(method=\"delaunay\"),\n", + " inter_level=dict(pattern=\"nearest\", k=1),\n", + " ),\n", + " g2m_connectivity=\"nearest_neighbour\",\n", + " m2g_connectivity=\"nearest_neighbour\",\n", + " return_components=True,\n", + ")\n", + "\n", + "m2m_hier = components[\"m2m\"]\n", + "for direction in (\"same\", \"up\", \"down\"):\n", + " n = sum(\n", + " 1 for _, _, d in m2m_hier.edges(data=True) if d.get(\"direction\") == direction\n", + " )\n", + " print(f\"{direction:>5} edges: {n}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "wmg.visualise.nx_draw_with_pos_and_attr(m2m_hier, ax=ax, node_size=30)\n", + "ax.set_title(\"Hierarchical prebuilt mesh (2 levels)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helpful validation errors\n", + "\n", + "The input contract is checked up front, with errors that say what to fix:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bad_mesh = nx.Graph()\n", + "bad_mesh.add_node(0, pos=np.array([1.0, 1.0]), type=\"mesh\")\n", + "bad_mesh.add_node(1, pos=np.array([1.0, 1.0]), type=\"mesh\") # duplicate!\n", + "\n", + "try:\n", + " wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"prebuilt\",\n", + " mesh_layout_kwargs=dict(mesh_graph=bad_mesh),\n", + " m2m_connectivity=\"flat\",\n", + " g2m_connectivity=\"nearest_neighbour\",\n", + " m2g_connectivity=\"nearest_neighbour\",\n", + " )\n", + "except ValueError as e:\n", + " print(f\"ValueError: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with_edges = nx.Graph()\n", + "with_edges.add_node(0, pos=np.array([0.0, 0.0]), type=\"mesh\")\n", + "with_edges.add_node(1, pos=np.array([5.0, 5.0]), type=\"mesh\")\n", + "with_edges.add_edge(0, 1) # user-provided edges: not yet supported\n", + "\n", + "try:\n", + " wmg.create.create_all_graph_components(\n", + " coords=xy,\n", + " mesh_layout=\"prebuilt\",\n", + " mesh_layout_kwargs=dict(mesh_graph=with_edges),\n", + " m2m_connectivity=\"flat\",\n", + " g2m_connectivity=\"nearest_neighbour\",\n", + " m2g_connectivity=\"nearest_neighbour\",\n", + " )\n", + "except NotImplementedError as e:\n", + " print(f\"NotImplementedError: {e}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading real mesh sources\n", + "\n", + "The library deliberately has no file-format support here -- whatever the source,\n", + "you load it into the node-cloud graph in a few lines. For example, station\n", + "locations from a CSV with columns `x`, `y` (already in the grid's coordinate\n", + "system):\n", + "\n", + "```python\n", + "import pandas as pd\n", + "\n", + "df = pd.read_csv(\"stations.csv\")\n", + "my_mesh = nx.Graph()\n", + "for i, row in df.iterrows():\n", + " my_mesh.add_node(i, pos=np.array([row.x, row.y]), type=\"mesh\")\n", + "```\n", + "\n", + "or ICON grid vertices from its NetCDF grid file (remember to transform lon/lat to\n", + "the grid's projected coordinate system first, e.g. with `pyproj`).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d8db437d2a1c6c281573ba4affef3c1076f66d30 Mon Sep 17 00:00:00 2001 From: prajwal Date: Sat, 18 Jul 2026 11:52:05 +0530 Subject: [PATCH 16/16] Clean notebooks for the nb-clean pre-commit hook Upstream main added nb-clean (v4.0.1) to the pre-commit config after this branch's fork point; CI lints the merge with main, so the two notebooks this branch touches need to be clean: strip execution counts/outputs from mesh_layout.ipynb and the kernel version metadata from prebuilt_mesh.ipynb. --- docs/mesh_layout.ipynb | 165 +++------------------------------------ docs/prebuilt_mesh.ipynb | 3 +- 2 files changed, 13 insertions(+), 155 deletions(-) diff --git a/docs/mesh_layout.ipynb b/docs/mesh_layout.ipynb index 5b107b0..be78843 100644 --- a/docs/mesh_layout.ipynb +++ b/docs/mesh_layout.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "2595994f", "metadata": {}, "outputs": [], @@ -49,31 +49,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7eb67af8", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Grid nodes')" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAF2CAYAAAC72fnJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIllJREFUeJzt3Q1wlNUV8PEDCSQshQgqKOUrgpUvkSridPGjLQzUIqIdrTpqo0618oZCpFXAFpUqIliREUHEqdhWLdoZgi2tthQRRUFAQbHIp1YZFIMtxMBKwHDfufd9k0nYpCTPs2nOvfx/M2vYzUn25OY+J49373m2mTHGCACgSTVv2qcHAFgUYwBQgGIMAApQjAFAAYoxAChAMQYABSjGAKAAxRgAFKAYA4ACFGOodcMNN0j37t2PGfevf/1LmjVrJk899ZRo8e1vf9vdgPqiGCPjPvzwQxkzZox84xvfkEQi4W59+vSRwsJCeffddxlxoBbZtT0IRLVkyRK56qqrJDs7W6699lo566yzpHnz5rJ582ZZtGiRPPbYY65Yd+vW7Zjf64knnpAjR47wy8BxgWKMjNmxY4dcffXVrtAuW7ZMTj311Bqfnz59usydO9cV5//mwIED0rp1a2nRogW/HRw3WKZAxsyYMcMV0gULFqQVYsueLY8dO1a6dOlSY134a1/7mivk3//+96VNmzbujLquNeN9+/a5x/Py8uSEE06QgoIC91h92DVlu7b8+uuvy/jx4+Xkk092Rf/yyy+XPXv2pMXbPxx9+/aVnJwc6dSpk1tmqe255s+fLz169JBWrVrJoEGD5LXXXqv1+cvLy+Xuu++Wnj17uu9px+GOO+5wj1e3dOlSOf/8893PZ8fmjDPOkDvvvLNePyP8xZkxMrpEYQvNeeed16Cv++qrr2T48OGuAP361792a8y1sVd7HTVqlKxcuVJuvfVW6d27txQXF7uC3BA//elPpV27dq4w2hf/Zs2a5da4n3vuuaqYe+65R6ZMmSJDhw6V0aNHy5YtW9wSy9q1a10xrzxr/81vfiM/+clPJJlMSlFRkXzwwQdy6aWXSvv27Wv80bHLLfZxm/stt9zict+4caM8/PDDsnXrVlm8eLGL++c//ymXXHKJ9O/fX371q1+5or19+3b3nAicvZ4xEFdpaam9Lra57LLL0j63d+9es2fPnqpbKpWq+lxBQYH7uokTJ6Z9nf1ct27dqu4vXrzYxc6YMaPqsa+++spccMEF7vEFCxb81xzt523c0KFDzZEjR6oev+2220xWVpbZt2+fu19SUmJatmxphg0bZioqKqriHn30Uff1Tz75pLt/6NAh06FDBzNgwABTXl5eFTd//nwXd9FFF1U99vvf/940b97cvPbaazVymjdvnot9/fXX3f2HH37Y3bfjhOMLyxTIiC+++MJ9tP9bfTS7xcsuCVTe5syZkxZjzz6P5a9//atb6qgem5WV5c50G8KemdrlikoXXHCBVFRUyEcffeTu/+Mf/5BDhw65M93q69s333yztG3bVv7yl7+4++vWrZOSkhJ3lt6yZcuquMpllOr++Mc/urPhXr16yeeff151++53v+s+v3z5cvfRLk1YL7zwAi9eHmcoxsgIu9Zr7d+/P+1zjz/+uFsHffrpp2v9WltgO3fufMznsMXSrkUfXfDtmmpDdO3atcZ9u2Rh7d27t+p5avu+tuCedtppVZ+v/Hj66afXiLNLGDauum3btrkliOp/lOzNbv+zbFG37E6UwYMHy49//GPp2LGje0H0+eefpzAfB1gzRkbYM0FbKN977720z1WuIdv12drYddFj7bDIJHs2XZvGfAcyu2Z85plnysyZM2v9fOX6sn0R8NVXX3VnyvYM/KWXXnJr2fYM+u9//3uducN/nBkjY0aMGOFebFqzZk2jjKrdMvfpp5+mnX3bF9cy/Ty1fV+7dFF9j3TlR3vWW93hw4ddXHV2t8V//vMfGTJkiHtR8Ohb9bNw+4fJxtnCvWnTJpk6daq8/PLLVUsZCBPFGBljt2nZnRA33XSTfPbZZxk/87Rb3+zOC7uroZJd6509e7Zkki2OdknikUceqZGz3TlRWlrq/uhYAwcOdEsN8+bNc4W6+ha6o7fA/fCHP5Rdu3a5Rpajffnll25LoGUL9tEGDBjgPh69BQ5hYZkCGWPXTp999lm55ppr3JleZQeeLWj2TNF+zp711Wd9uDYjR45066kTJ050Sx62xdp29dkCmUm2wE6aNMltbfve977ntqTZs2S77/jcc8+V6667rmpt+L777nNb2+wygl3vtT+n3Wd99Jrx9ddf79Z+7Yt99gzX/hz2D4ntTLSP/+1vf3PF3W5ns8sUtuDbM2+7lmyf146Z3fqHgDX1dg6EZ/v27Wb06NGmZ8+eJjc317Rq1cr06tXL3HrrrWbDhg1p29dat25d6/c5emub9e9//9tcf/31pm3btiYvL8/9e/369Q3a2rZ27doajy9fvtw9bj9WZ7ey2bxbtGhhOnbs6H4mu03vaHPnzjX5+fkmJyfHDBw40Lz66qtuW1v1rW2VW+GmT59u+vbt62LbtWtnzjnnHDNlyhS3NdBatmyZGTVqlOnUqZPbXmc/XnPNNWbr1q3/9WeD/5rZ/zT1HwQAON6xZgwAClCMAUABijEAKEAxBgAFKMYAoADFGAAUUNf0YXv4P/nkE3fhmepX1gIA39idw2VlZe7NCY51/RV1xdgW4uoX5QYA3+3cufOYnafZWi/FaJO3144FAJ+v821PLivrmlfFuHJpwhZiijGAENRnyZUX8ABAAYoxAChAMQYABSjGAKAAxRgAFKAYA4ACFGMA8LEY2/fnsu9FZtv77N65xYsXp7X/3XXXXe5t2+3bjts3dzz63XMBADGLsX0XW/smk3PmzKn18zNmzHDvqmvfMffNN9+U1q1by/Dhw+XgwYMNfSoAOG40uBhffPHF7h1xL7/88rTP2bPiWbNmyS9/+UsZNWqU9O/fX373u9+5600cfQadaV9VHJEP9ux3H32J0ZgTMYwPcyP68RxHRtuh7duU79692y1NVMrLy5PzzjtPVq1aJVdffXXa15SXl7tb9V7uhrID9IO5b8i7u0ql/9fzZNH/SUp2VnPVMRpzIobxYW4kIx/PcWX0O9pCbHXs2LHG4/Z+5eeONm3aNFewK29Rrtj28X9SbqAs+9He1x6jMSdiGB/mRiry8ez9bopJkyZJaWlp1c1era2hurZPuL9YVv/Oee6+9hiNORHD+DA3EpGP59hMDPbLi4uLq+7v2LHDPbZ+/foacRdeeKEZO3Zsvb5naWmp+x72Y0Mc/qrC7Cgpcx99idGYEzGMD3Mj+vEcp541s/+JWsjt1rbi4mK57LLLKgu72/L285//XH72s59VrQF36NBBnnrqqVrXjI9m4+1yhT1L5hKaAHzWkHrW4Bfw9u/fL9u3b6/xot2GDRukffv20rVrVykqKnK7LU4//XTJz8+XyZMnuwJdWbABABkoxuvWrZPvfOc7VffHjx/vPhYUFLiz3zvuuMPtRb7llltk3759cv7558tLL70kubm5DX0qADhuxFqmaAwsUwAIRUPqWZPvpsgUH5sVNOZEDOPD3Aig6aOp+NisoDEnYhgf5kYyjKaPpuJjs4LGnIhhfJgbqcjHc1xBFGMfmxU05kQM48PcSEQ+nmMzytD0kY5GDBox6sLcKFPTxNSkTR+Ngd0UAEJxXO6mAACfUYwBQAGKMQAoEEwx9rFZQWNOxDA+zI10NH3Uk4/NChpzIobxYW4kafqIw8dmBY05EcP4MDdSkY/nuIJYpvCxWUFjTsQwPsyNROTjOTajDE0f6djYr2djPzGMT0PQ9AEACtD0AQCeCWLNGAB8RzEGAAWCKcY+NitozIkYxoe5kY6mj3rysVlBY07EMD7MjSRNH3H42KygMSdiGB/mRiry8RxXEMsUPjYraMyJGMaHuZGIfDzHZpSh6SMdjQY0GtSFuVGmpkmnNjR9AIACNH0AgGeCWDMGAN9RjAFAgWCKsY/NChpzIobxYW6ko+mjnnxsVtCYEzGMD3MjSdNHHD42K2jMiRjGh7mRinw8xxXEMoWPzQoacyKG8WFuJCIfz7EZZWj6SMfGfj0b+4lhfBqCpg8AUICmDwDwTBBrxgDgO4oxACgQTDH2sVlBY07EMD7MjXQ0fdSTj80KGnMihvFhbiRp+ojDx2YFjTkRw/gwN1KRj+e4glim8LFZQWNOxDA+zI1E5OM5NqMMTR/paDSg0aAuzI0yNU06taHpAwAUoOkDADwTxJoxAPiOYgwAIRbjiooKmTx5suTn50urVq2kR48ecu+999oXCqUx+disoDEnYhgf5kYgTR/Tp0+Xxx57TH77299K3759Zd26dXLjjTdKXl6ejB07VhqDj80KGnMihvFhbiTDafp44403ZNSoUTJixAjp3r27XHHFFTJs2DBZs2aNNBYfmxU05kQM48PcSEU+ntUV42QyKcuWLZOtW7e6+++8846sXLlSLr744lrjy8vL3faP6reG8rFZQWNOxDA+zI1E5OM5NpNhFRUVZsKECaZZs2YmOzvbfbz//vvrjL/77rvtYnLazW6WbggfN79rzIkYxoe5EUjTx8KFC+X222+XBx980K0Zb9iwQYqKimTmzJlSUFBQ65mxvVWyZ8ZdunSR0tJSadu2bSZTAwC1TR8ZL8a2kE6cOFEKCwurHrvvvvvk6aefls2bN2c0eQDQrEk78FKplDRvXvPbZmVlyZEjjbclBAB8l/GtbSNHjpSpU6dK165d3TLF+vXr3RLFTTfdlOmnAoBgZHyZoqyszDV9FBcXS0lJiXTq1EmuueYaueuuu6Rly5bH/HqWKQCEokmXKdq0aSOzZs2Sjz76SL788kvZsWOHWzOuTyGOw8fOMY05EcP4MDcC6cBrCj52jmnMiRjGh7mRDKcDryn42DmmMSdiGB/mRiry8RxXEMXYx84xjTkRw/gwNxKRj+fYjDK87VI6uuLoiqsLc6NMTUdpbXjbJQBQgLddAgDPBLFmDAC+oxgDgALBFGMfmxU05kQM48PcSEfTRz352KygMSdiGB/mRpKmjzh8bFbQmBMxjA9zIxX5eI4riGUKH5sVNOZEDOPD3EhEPp5jM8rQ9JGOjf16NvYTw/g0BE0fAKAATR8A4Jkg1owBwHcUYwBQIJhi7GOzgsaciGF8mBvpaPqoJx+bFTTmRAzjw9xI0vQRh4/NChpzIobxYW6kIh/PcQWxTOFjs4LGnIhhfJgbicjHc2xGGZo+0tFoQKNBXZgbZWqadGpD0wcAKEDTBwB4Jog1YwDwHcUYABQIphj72KygMSdiGB/mRjqaPurJx2YFjTkRw/gwN5I0fcThY7OCxpyIYXyYG6nIx3NcQSxT+NisoDEnYhgf5kYi8vEcm1GGpo90bOzXs7GfGManIWj6AAAFaPoAAM8EsWYMAL6jGAOAAsEUYx+bFTTmRAzjw9xIR9NHPfnYrKAxJ2IYH+ZGkqaPOHxsVtCYEzGMD3MjFfl4jiuIZQofmxU05kQM48PcSEQ+nmMzytD0kY5GAxoN6sLcKFPTpFMbmj4AQAGaPgDAM0GsGQOA7yjGAKBAMMXYx2YFjTkRw/gwNwJq+ti1a5dMmDBBXnzxRUmlUtKzZ09ZsGCBDBw4sDGezstmBY05EcP4MDeS4TR97N27VwYPHiwtWrRwxXjTpk3y0EMPSbt27aSx+NisoDEnYhgf5kYq8vGsrhhPnz5dunTp4s6EBw0aJPn5+TJs2DDp0aOHNBYfmxU05kQM48PcSEQ+nmMzGda7d29TVFRkrrjiCnPyySebAQMGmPnz59cZf/DgQbcxuvK2c+dOY9Oy/24IHze/a8yJGMaHuRFI00dubq77OH78eLnyyitl7dq1Mm7cOJk3b54UFBSkxd9zzz0yZcqUtMdLS0ulbdu2mUwNANQ2fWS8GLds2dK9UPfGG29UPTZ27FhXlFetWpUWX15e7m7Vk7fLHBRjAL5r0g68U089Vfr06VPjsd69e8vHH39ca3xOTo5LsvoNAI43GS/GdifFli1bajy2detW6datW6afCgCCkfFifNttt8nq1avl/vvvl+3bt8uzzz4r8+fPl8LCQmlMPjYraMyJGMaHudE0TR8ZXzO2lixZIpMmTZJt27a5rW32xbybb74542ssPjcraMyJGMaHuZHMaNNHk1+17ZJLLpGNGzfKwYMH5f333693IY7Kx2YFjTkRw/gwN1KRj+e4grg2hY/NChpzIobxYW4kIh/PsRlleKePdDRi0IhRF+ZGmZomptrwTh8AoECTrxkDABqGYgwAClCMAUCBYIqxj80KGnMihvFhbgT0Th//az42K2jMiRjGh7mRDOedPpqCj80KGnMihvFhbqQiH89xBVGMfWxW0JgTMYwPcyMR+XiOzShD00c6Nvbr2dhPDOPTEDR9AIACNH0AgGeCWDMGAN9RjAFAgWCKsY/NChpzIobxYW6ko+mjnnxsVtCYEzGMD3MjSdNHHD42K2jMiRjGh7mRinw8xxXEMoWPzQoacyKG8WFuJCIfz7EZZWj6SEejAY0GdWFulKlp0qkNTR8AoABNHwDgmSDWjAHAdxRjAFAgmGLsY7OCxpyIYXyYG+lo+qgnH5sVNOZEDOPD3EjS9BGHj80KGnMihvFhbqQiH89xBbFM4WOzgsaciGF8mBuJyMdzbEYZmj7SsbFfz8Z+YhifhqDpAwAUoOkDADwTxJoxAPiOYgwACgRTjH1sVtCYEzGMD3MjHU0f9eRjs4LGnIhhfJgbSZo+4vCxWUFjTsQwPsyNVOTjOa4glil8bFbQmBMxjA9zIxH5eI7NKEPTRzoaDWg0qAtzo0xNk05taPoAAAVo+gAAzwSxZgwAvqMYA4ACwRRjH5sVNOZEDOPD3EhH00c9+disoDEnYhgf5kaSpo84fGxW0JgTMYwPcyMV+XhWv0zxwAMPSLNmzaSoqKjRnsPHZgWNORHD+DA3EpGP59hMI1qzZo3p3r276d+/vxk3blzGN0n7vvldY07EMD7MjcCaPvbv3y9nn322zJ07V+677z4ZMGCAzJo1K6ObpAFAMxVNH4WFhTJixAgZOnTof40rLy93CVe/AcDxJrsxvunChQvl7bfflrVr1x4zdtq0aTJlypTGSAMAvJHxM+OdO3fKuHHj5JlnnpHc3Nxjxk+aNMmdwlfe7NcDwPEm48X4rbfekpKSErdenJ2d7W4rVqyQRx55xP27oqKiRnxOTo5bS6l+i8LHZgWNORHD+DA3Amn6GDJkiGzcuLHGYzfeeKP06tVLJkyYIFlZWZl+Si+bFTTmRAzjw9xIhtP00aZNG+nXr1+NW+vWreXEE090/24MPjYraMyJGMaHuZGKfDzHFcS1KXxsVtCYEzGMD3MjEfl4js0oQ9NHOhoxaMSoC3OjTE0Tk9qmj6ho+gAQChVNHwCA+qMYA4ACFGMAUCCYYuxjs4LGnIhhfJgbgTR9NAUfmxU05kQM48PcSIbT9NEUfGxW0JgTMYwPcyMV+XiOK4hi7GOzgsaciGF8mBuJyMdzbEYZmj7SsbFfz8Z+YhifhqDpAwAUoOkDADwTxJoxAPiOYgwACgRTjH1sVtCYEzGMD3MjHU0f9eRjs4LGnIhhfJgbSZo+4vCxWUFjTsQwPsyNVOTjOa4glil8bFbQmBMxjA9zIxH5eI7NKEPTRzoaDWg0qAtzo0xNk05taPoAAAVo+gAAzwSxZgwAvqMYA4ACwRRjH5sVNOZEDOPD3EhH00c9+disoDEnYhgf5kaSpo84fGxW0JgTMYwPcyMV+XiOK4hlCh+bFTTmRAzjw9xIRD6eYzPK0PSRjo39ejb2E8P4NARNHwCgAE0fAOCZINaMAcB3FGMAUCCYYuxjs4LGnIhhfJgb6Wj6qCcfmxU05kQM48PcSNL0EYePzQoacyKG8WFupCIfz3EFsUzhY7OCxpyIYXyYG4nIx3NsRhmaPtLRaECjQV2YG2VqmnRqQ9MHAChA0wcAeCaINWMA8B3FGAAUCKYY+9isoDEnYhgf5kY6mj7qycdmBY05EcP4MDeSNH3E4WOzgsaciGF8mBupyMdzXEEsU/jYrKAxJ2IYH+ZGIvLxHJtRhqaPdGzs17OxnxjGx5umj2nTpsmiRYtk8+bN0qpVK0kmkzJ9+nQ544wzMr5JGgA0a9KmjxUrVkhhYaGsXr1ali5dKocPH5Zhw4bJgQMHMv1UABCMjJ8ZH23Pnj3SoUMHV6QvvPDCY8ZzZgwgFA2pZ9mNnYxNwmrfvn2tny8vL3e36skDwPGmUXdTHDlyRIqKimTw4MHSr1+/OteY7V+OyluXLl0iPZePzQoacyKG8WFuNE3TR6MuU4wePVpefPFFWblypXTu3LneZ8a2IDfkBTwfmxU05kQM48PcSGa06UPFVdvGjBkjS5YskeXLl9dZiK2cnByXZPVbQ/nYrKAxJ2IYH+ZGKvLxHFfGi7E90baFuLi4WF5++WXJz8+XxuZjs4LGnIhhfJgbicjHc2wmw0aPHm3y8vLMK6+8Yj799NOqWyqVqtfX0/SRjkYDGg3qwtwoU9Oko67po1mzZrU+vmDBArnhhhuO+fVsbQMQiibd2tbI25YBIEhBXCgIAHxHMQYABYIpxj42K2jMiRjGh7mRjnf6qCcfmxU05kQM48PcSPJOH3H42KygMSdiGB/mRiry8RxXEMsUPjYraMyJGMaHuZGIfDzHZpSh6SMdG/v1bOwnhvHxpukjLpo+AIRCxYWCAAD1RzEGAAUoxgCgQDDF2MdmBY05EcP4MDfS0fRRTz42K2jMiRjGh7mRpOkjDh+bFTTmRAzjw9xIRT6e4wpimcLHZgWNORHD+DA3EpGP59iMMjR9pKPRgEaDujA3ytQ06dSGpg8AUICmDwDwTBBrxgDgO4oxACgQTDH2sVlBY07EMD7MjXQ0fdSTj80KGnMihvFhbiRp+ojDx2YFjTkRw/gwN1KRj+e4glim8LFZQWNOxDA+zI1E5OM5NqMMTR/p2NivZ2M/MYxPQ9D0AQAK0PQBAJ4JYs0YAHxHMQYABYIpxj42K2jMiRjGh7mRjqaPevKxWUFjTsQwPsyNJE0fcfjYrKAxJ2IYH+ZGKvLxHFcQyxQ+NitozIkYxoe5kYh8PMdmlKHpIx2NBjQa1IW5UaamSac2NH0AgAI0fQCAZ4JYMwYA31GMAUCBYIqxj80KGnMihvFhbqSj6aOefGxW0JgTMYwPcyNJ00ccPjYraMyJGMaHuZGKfDzHFcQyhY/NChpzIobxYW4kIh/PsRllaPpIx8Z+PRv7iWF8GoKmDwBQgKYPAPBMo60Zz5kzR7p37y65ubly3nnnyZo1axrrqQDAe41SjJ977jkZP3683H333fL222/LWWedJcOHD5eSkpLGeDoA8F6jFOOZM2fKzTffLDfeeKP06dNH5s2bJ4lEQp588klpLD42K2jMiRjGh7kRSNPHoUOH5K233pJJkyZVPda8eXMZOnSorFq1Ki2+vLzc3aoveDeUj80KGnMihvFhbiTDafr4/PPPpaKiQjp27FjjcXt/9+7dafHTpk2TvLy8qluXLl0a/Jw+NitozIkYxoe5kYp8PHvf9GHPoEtLS6tuO3fubPD38LFZQWNOxDA+zI1E5OM5NpNh5eXlJisryxQXF9d4/Ec/+pG59NJLM7pJ2vfN+BpzIobxYW4E9E4fdivboEGDZPbs2e7+kSNHpGvXrjJmzBiZOHFixjZJA4BmDalnGX8Bz7Lb2goKCmTgwIGuKM+aNUsOHDjgdlcAAP5Hxfiqq66SPXv2yF133eVetBswYIC89NJLaS/qAQD+n0ZZpoiDZQoAoeDaFADgmSbf2gYAoBgDgAqcGQOAAhRjAFCAYgwAoe4zjqNyp12Uq7cBgCaVdaw+O4jVFeOysjL3McrV2wBAI1vXbFu0V00f9joWn3zyibRp00aaNWvWoL9AtoDbq76FeE0Lfj6/8fs7Pn9/xhhXiDt16uSu6+7VmbFNuHPnzpG/3g5UiMW4Ej+f3/j9HX+/v7xjnBFX4gU8AFCAYgwACgRTjHNycty7UduPIeLn8xu/P7/l/A/qi7oX8ADgeBTMmTEA+IxiDAAKUIwBQAGKMQAoEEwxnjNnjnTv3l1yc3Pdu1OvWbNGQjBt2jQ599xzXUdihw4d5LLLLpMtW7ZIqB544AHXeVlUVCSh2LVrl1x33XVy4oknSqtWreTMM8+UdevWSQgqKipk8uTJkp+f7362Hj16yL333luvazFo9Oqrr8rIkSNdx5ydh4sXL67xeftz2ff2PPXUU93PO3ToUNm2bVtGnjuIYvzcc8+5d6S2W0/efvttOeuss2T48OFSUlIivluxYoUUFhbK6tWrZenSpXL48GEZNmyYe7ft0Kxdu1Yef/xx6d+/v4Ri7969MnjwYGnRooW8+OKLsmnTJnnooYekXbt2EoLp06fLY489Jo8++qi8//777v6MGTNk9uzZ4qMDBw64+mFP7mpjf7ZHHnlE5s2bJ2+++aa0bt3a1ZqDBw/Gf3ITgEGDBpnCwsKq+xUVFaZTp05m2rRpJjQlJSX2lMOsWLHChKSsrMycfvrpZunSpeaiiy4y48aNMyGYMGGCOf/8802oRowYYW666aYaj/3gBz8w1157rfGdiJji4uKq+0eOHDGnnHKKefDBB6se27dvn8nJyTF/+MMfYj+f92fGhw4dkrfeesv970L161vY+6tWrZLQlJaWuo/t27eXkNiz/xEjRtT4PYbgT3/6kwwcOFCuvPJKt8z0zW9+U5544gkJRTKZlGXLlsnWrVvd/XfeeUdWrlwpF198sYTmww8/lN27d9eYo/a6E3ZZNBO1Rt2Fghrq888/d+tWHTt2rPG4vb9582YJib2inV1Ltf/b269fPwnFwoUL3fKSXaYIzQcffOD+N94uo915553uZxw7dqy0bNlSCgoKxHcTJ050VzTr1auXZGVluWNx6tSpcu2110podu/e7T7WVmsqP3dcF+PjiT17fO+999yZRyjsJQnHjRvn1sPti6+hsX9A7Znx/fff7+7bM2P7O7RrjiEU4+eff16eeeYZefbZZ6Vv376yYcMGd8JgXwAL4ef7X/J+meKkk05yf5E/++yzGo/b+6eccoqEYsyYMbJkyRJZvnx5rEuMamOXmOwLrWeffbZkZ2e7m33R0r5IYv9tz7R8Zl9179OnT43HevfuLR9//LGE4Pbbb3dnx1dffbXbJXL99dfLbbfd5nYBheaU/19PGqvWeF+M7f/unXPOOW7dqvrZiL3/rW99S3xnX0ewhbi4uFhefvllt4UoJEOGDJGNGze6M6rKmz2TtP+ba/9t/9D6zC4pHb0V0a6vduvWTUKQSqXSLppuf2f2GAxNfn6+K7rVa41dorG7KjJSa0wAFi5c6F7RfOqpp8ymTZvMLbfcYk444QSze/du47vRo0ebvLw888orr5hPP/206pZKpUyoQtpNsWbNGpOdnW2mTp1qtm3bZp555hmTSCTM008/bUJQUFBgvv71r5slS5aYDz/80CxatMicdNJJ5o477jC+7upZv369u9nyOHPmTPfvjz76yH3+gQcecLXlhRdeMO+++64ZNWqUyc/PN19++WXs5w6iGFuzZ882Xbt2NS1btnRb3VavXm1CYCdEbbcFCxaYUIVUjK0///nPpl+/fu6EoVevXmb+/PkmFF988YX7XdljLzc315x22mnmF7/4hSkvLzc+Wr58ea3Hm/2jU7m9bfLkyaZjx47u9zlkyBCzZcuWjDw3l9AEAAW8XzMGgBBQjAFAAYoxAChAMQYABSjGAKAAxRgAFKAYA4ACFGMAUIBiDAAKUIwBQAGKMQAoQDEGAGl6/xfXLQC0IbVD7wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "xs, ys = np.meshgrid(np.linspace(0, 10, 32), np.linspace(0, 10, 32))\n", "xy = np.stack([xs.flatten(), ys.flatten()], axis=-1)\n", @@ -97,46 +76,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "c7661b63", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m2026-06-09 20:43:41.254\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mesh nodes : 9\n", - "Mesh edges : 40\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Rectilinear mesh — default spacing (mesh_node_distance=3)')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "graph_rectilinear = wmg.create.archetype.create_keisler_graph(\n", " coords=xy,\n", @@ -168,46 +111,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "7ebc4f15", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m2026-06-09 20:43:50.026\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mesh nodes : 36\n", - "Mesh edges : 220\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Rectilinear mesh — finer spacing (mesh_node_distance=1.5)')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg4AAAHDCAYAAABMJZLOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYFMX29gtEBQERQRBUEMxiDpgTGFAxYBZzzjnnnK45XHPOGVEMKIoRBRUQQZIkEQQERJAc5nt+db8z/9ra6u7qmdmdXqn3eQZ2Znq6+3RX13lPrFq5XC6nAgICAgICAgI8UNtno4CAgICAgICAQBwCAgICAgICUiF4HAICAgICAgK8EYhDQEBAQEBAgDcCcQgICAgICAjwRiAOAQEBAQEBAd4IxCEgICAgICDAG4E4BAQEBAQEBHgjEIeAgICAgICApYc4HH/88WrNNdes8FmtWrXU9ddfn3//7LPP6s/Gjh1bhjP8d4Hr3aBBA5U1LFq0SF166aVqjTXWULVr11YHHnigcywExKPc16tfv35queWWU+PGjVNZRFbHfxyY97ivzIPViTAPZxsfffSRHst//vln1RIHUcDyqlOnjlpttdX0wzRhwgRVVZg4caKezAYOHFhlxwio2Xj66afVnXfeqQ455BD13HPPqQsuuKDcpxRQAK666ip15JFHqtatW4frF6DmzJmj5/7PP/98qbkaw4cP1/PX9ttvr+rWrZva6EUfm3paXuuvv36F7Tp16qTWXnttddttt6U+xzqpf6GUuvHGG1WbNm3UvHnz1HfffacJxddff60GDx6sBa0K4nDDDTdoz8Jmm21W4bsnnnhCLVmyJPb3xxxzjDriiCPU8ssvX/JzC8gGPvvsM01i77333gqfz507VxPcAD+U83phGPTq1Uv16dOnLMcPqFoUMg9DHJj7wa677qqWBnz77bfqgQceUBtuuKHaYIMNCjKYucZPPvlkhc8aNWpUabvTTjtNXXzxxfoaN2zY0Hv/Bc0Qe++9t9pqq6303yeffLJq2rSpuuOOO9S7776rDjvsMFWdWHbZZRO3WWaZZfQrq4D4LFiwoEpI19KCKVOmqJVWWqnS5+W6pkx4K6ywgqppKOcYfOaZZ1SrVq3UtttuW7ZzCKg6ZH0ezgr2339/NWPGDK3I77rrroKIA+T/6KOPTtzu4IMPVuecc45644031Iknnli9OQ477bST/n/UqFEVPh82bJh2Ha+88sp6QoJsQC5scJFwzeBRgCmtvvrq6thjj1VTp07VLqqtt95ab3fCCSfk3S4Sr3PlONhw5Tjwm86dO2tPSfv27fX5tW3bVj3//PPO8zv//PN1/Jzzw70DUbI9Hdxk3EtNmjRR9erVU1tuuaV68803K+2Pczn77LPVSy+9pNq1a6f3SbwpCnKuXAuuIfveeOON8+67t99+W79HBo45YMCASvvwuRcLFy7UzHOdddbR2yDHjjvuqD755JNK+yM0RR4BMbJVVllFs9bFixercsVve/furYYMGZIfH3Jt7Dgrf/PZr7/+qscOZAMmzthC2dt48cUX9TXlmnPtsJjGjx9fYRssoY022kj9+OOPauedd9aE4corr4w850mTJunjMc659y1atFAHHHCAc3x+/PHH2svG/cAC4V6bmD59ur723H/uxYorrqiJ/U8//VTpuHgIkX/dddfV++O4Bx10UIXntpjrhbfi3HPP1YYEkx4TIOPEN2/inXfeUR06dNDbLw3jX8bNL7/8onbbbTc9bvCa/ec//3ES45NOOkk1b95cn9umm26qQ3KuuYr7xD3iXh133HH6Mxd85+ckzJ8/X8/fXAe577///rvXPPzDDz+ovfbaS48Z7iuebFFgbMc+AfdFnm0ZS4MGDdKyMm9z/quuuqr+7bRp0yoct5BnHp3A/WjcuLF+pnkOTXz44Yda79WvX1/LvO++++r5pxTgfqSx/qPAeJw5c2bsNs2aNVObbLKJ6t69e6p9l4Q4yEDgIgu4iFgOQ4cOVZdffrm6++679UXmYevWrVt+u3/++UffgAcffFDtueee6v7771enn366HtQMPlw1hEbAqaeeql544QX94mYWCwYSD84ee+yhz4/zZ2CZA4CBtcsuu+jBBJnBhbTDDjuoK664Ql144YUV9se5b7755vp8b731Vs36Dj30UPX+++87Xes8bIcffrj+XRL54Vy7du2q9ttvPx2T+uuvv/TfkA/2A7vk4UIJ4PUxSY3vveABYx9MYg899JCON2MB9u/fv9KA5GFnYoUscX3Y5+OPP66qG0wsjAfidyhiGR+MmzhwjWbNmqWvJX8zqYlLVHDLLbfoe44iueeeezR5/PTTT/XYsydjJisUNkr+vvvu09cwjuVz3Zm4Hn74Ya1sOZfffvutwnYjR47U44P9cp4ynkxFNnr0aK1wUayc4yWXXKJ+/vlnfU8I8Zn3jG2QEeXK/TrvvPPU33//rUOMSfC5Xjw7PMf77LOPJtYoAiZUH6CIkX+LLbZYqsY/chBrhgiwD8bxZZddphWTScggGYzro446SufyoPi43swdglwupwko23E9br75Zj2HQh5s+F4TH+B1Zswzf99+++3aC+xz3yFD/Ab9wTkwdpCP8Lc824888oj+u0uXLvlnG7ILeA4Y/zxH/BZS/+qrr+rxx7UoZAzznpAKMjCP8x6Dkfla8MILL2j5II2M82uuuUaTP0imSYogVBi/Pq9SA72FEcE4gYicddZZWte6wHyQOjyYS4FnnnmGu5Hr1atX7s8//8yNHz8+9+abb+ZWWWWV3PLLL6/fCzp27JjbeOONc/Pmzct/tmTJktz222+fW2eddfKfXXvttXqfb7/9dqXjsT34/vvv9TYc38Zxxx2Xa926dYXP2Pa6666rdN5jxozJf8Zv+OzLL7/MfzZlyhQtx0UXXZT/7KabbsrVr18/N2LEiArHuPzyy3PLLLNM7rfffst/NmfOnArbLFiwILfRRhvlOnToUOn8ateunRsyZEjOB3Kuffr0yX/Ws2dP/Vm9evVy48aNy3/+2GOP6c979+6d+l5suummuX333Tf2XLje7P/GG2+s8Pnmm2+e23LLLXPlwi677JJr165dpc/tscDffHbiiSdW2K5Lly65Jk2a5N+PHTtW399bbrmlwnY///xzrk6dOhU+59js89FHH008z7/++ktve+edd3rd87feeiv/2d9//51r0aKFvtYC7unixYsr/JZxzjg279HTTz+t93fPPfdEPmfFXK8ff/xRb3f++edX2O7444+vtE8XmFPY7r333ltqxr+Mm+effz7/2fz583Orrrpq7uCDD85/dt999+ntXnzxxQpzy3bbbZdr0KBBbubMmfqzd955R2/3n//8J7/dokWLcjvttFOl+dP3miRh4MCBet9nnnlmhc+7du2aOA9369ZNv2d+jwJ6Jmr82PMteOWVVyrN675jeOTIkXpe5nP7mZJnZNasWbmVVlopd8opp1T4ftKkSblGjRpV+Fzk9XlFgXnC1l1JQDdddtlluddee01fDxmzO+ywQ27hwoWVtr/11lv195MnT/Y+RkEeh913312zQZgYFjtMFRcXFp+4T2FowvCEVWGVwdSxpKQK46233tJsG0Zpw3ZZlhq4fiXMApBpvfXW0yxWQOyHbfBGmAyRa4Dl8eWXX+a3xcIyLQmsOX5rWywAK4XjpznX7bbbLv9+m2220f/j2sUqsj8XGdLcC1x4WCJ8lgS8QiaQ07xuWYfr/Lkm4trD/Y3VynUz7zvuUDwQhEZMEHLA8kkCY4RyQ9zsjJE4tGzZssJzgQWBBwRXPOEOOS7lp4DxiAxYQoxjc9zxnOEOJp5ZyHOWdL0k1HbmmWdW2M51PBfEvWx6LZeG8c+9MmPRjA3c5Oa+PvjgAz3uqDYRYBHjqcKK/OKLL/Lb4ZU644wz8tuRU2DfgzTXJAkcE3AuJvDOJUFyknr06KHDRGlhzreE4ZBB8mNcc27SGMZzxzN/7bXX5p8p+xnByzFjxgx9L8x5gevM2DPnBa4l2/u8Sgk8Knh+uL94YfCs4D395ptvnKFzeebSeD4KSo7873//q+OkKEbK4FCeZqYsbkWMF1w4vKLcVMTzcC3iui0HzAnHvIjmhM5DRCxNYm0uOQQ8ALgHSWbBTRU3MRPLK+ZcJUMW8ub6XGRIcy9wzeHq5N4Se8WFituOGJgJ4on29bCvmwuMF9yuhQC5zImiWNjXUx4eZEBBc9+5bpAEn6Rcrh+TfhJ4TnBvXnTRRTpezURHCAFCgHIwQS6NPXa4NwCXKNsz0eGuJuQxZsyYCnF2XOkCnjPIRKEVE0nXi74LTLb2uEaGNHC5mP8t498FjC37HrMv5hwB15ZxaCszCcdJzwv+J2/F7jPBfTeR5pokQe77WmutFXtMFzCemPsJB1ANRTiGUAkhKZ/KCwgQvyU8Yc7DMtekHcM8I8gSZ9AJqezQoYPze/Yj4F7wygII53GvqVqCTLieuTSGekGzCIxYqiq40cR2uNnUnzJoJb5IwhCsy4W0E0pVICrD15y8kIUcCJoLuSAT+VdffaWTgoh/M4kzYFAuZIq//PLLlX6XVglGnWuSDGnuBefOw0OiDMlAlPPwQD/66KM6jpl0zCQQU3cldPmA60hMt1TwuW48SMSaXdvak3Oa+4k1RnweC6dnz576gcZKwAokRyYNyKXh9ySF3XTTTTqeyeTHMZLKlEv9rBQDITlRyvffMP4LOf+qQFbmZ54vLGByGt577z39LDCOybfgs6RGW1jUxObJ6yG3SHQPhM819ktxrWW/L7zwQiWiD0xijpHkIjAuuPZVSjA/8YxBtmzIM4dH0hdFF2xzM5j0JKGIJBeyXAGKE5d+HGCqSclZVR2ySDo/3IFJcuAKxhJh8JtsGYVXTqS5FwDFg8udF3IzmZI0Zk6chQLy5VMi5ALVJ9V935lQsKCFHJZ6/3gdeGHFMPExYZKEa1uG5vgfMWKE/l+SaZl4efaeeuqpCvvHnWpOBByvb9++2iXsU8KcFjRsYlLF62F6aZDBB9Kcht//W8d/MdcWDwTX1/Q6kEAu38v/JO9y3qbSxaAr5poknRvnJR6tqGPGAa8bL9zpGFkkSOJF4JpHzf0oO2TF40BoQeATZooCzwiykOho9wsyt5FqhKRr99prr3mFL6uaKAIJSbk85zxzzBVRXvUqq6rAxYQXgsxaYk1cVD577LHH1B9//FFpe7PFJa4qSsdcmbxyMcmhAFFlRVUJWC0NOSAENjgfWh0LgWKQm65i3MlYleVEmnthlzEx+WB5mGGXYoALkIetkFd1u/zI3OaeMjHZDzXv7WuVJtuZZ8SejCi/sq8zVRHmc0EslnJhJjWxUDhH+/zIy7Fj1DxnTByQ+6qYtMRyxdtmgmx3H+AWJ+xAed6/dfwXCqoEyGlBEQmYd7i2nCMuf9mOz6USATAf2fcgzTVJAhU/gGozE+iCJKD87bEnCluuufRCsed+8R7Yv/c5bhTwnkPMCFnZHgs5DuN8xRVX1J4+V16Gee2qI8cBwmaWUzO3QBJs4I1EBrwxNigjN/OHfFCyFnG4iygVIxGDJBTyIAhhUF99yimnaJY7efJkrYQpEZI6c36H1cRvcVNRGoI7hWRLXIQkTjKxkkjDeyZYiASJKGnzBAqVi3MhDo2rnPObPXu2LnnjvCEHsDXKcyiH48YQtiHmxjVg4jHjleWA771AsTOhICOWF5M4MtJzYmkDY458FcpuucdMKow92DnKnNJgXL1pgcegY8eOmpByvXFtsj/uhx17xNNB7f7333+v8yHIJ2I704vFuGSiw7KhhwjjkhJFsSoF5FBAOighZj0IEsMYx8Q8SWgktl8MGDOQEyZuFDAWJEl74iHx8RpyDlwL28uytI9/xhpKnvmHSR5vE+dFshvXW2r+CX9RKo7XlzErfT9c7nLfa5IEFD2JghBGjsMYxBPg42kibMnvSADmeUPh0QkYxQwJEhc7ckCaeB64L+Sf8MIbRM8LFDjEk/BSMR4r5mpKcFGyPB8YD3iPef5IVMazzrk98sgjOveF0mGeWSx1Sokpu+f6CzkvNMeB6yhkj3sM2Cc6kJc5HplLgJSBQjAJd3JPxIuH0UsSK7rJfs7RU+gnyjVTwbv+wigvcZXPUL6y1lpr6RclQGDUqFG5Y489VpcXLbvssrnVVlst17lzZ13CaWLatGm5s88+W3+/3HLL5VZffXVdQjJ16tT8Nt27d89tuOGGuhTOLC0qphzTVXpFiRQvE5TgXHHFFbm1115bn1/Tpk112dJdd92ly6IETz31lC5lohRu/fXX18eVUiD7/M466yyPKx5/rq79IKOr3M/nXtx888259u3b63IjytyQgbJDU0auN+WpNlxyZrkckzIvE64xAiiH3HHHHbXMvLgmXPPhw4cnHtsFxjS/Zz/sjxKubbbZJvf666877zllh5tsskl+TL3xxhsVtqOcjvJhyjS5Z5Rcffvtt85xTPnaVVddlWvTpo0eA4yFQw45RI+NUlyv2bNna9lWXnllXSZ44IEH6uvEdrfffnvitenfv7/e9quvvnJei3/b+I8aN645jVK5E044Qc89zEGUUrrK05lLjznmmNyKK66oxxZ/DxgwwFnO7js/J2Hu3Lm5c889V5c2cm32228/XZqfNA9zv4888shcq1at9Phu1qyZPv4PP/xQYf+U4VLqitzmPn///XddOsn9QtZDDz00N3HixKKfeUqXKa/lnBo3bqzv0yeffFJhm969e+f22msvfdy6detqvUfpsX3uhUDGsOtljwvem59R7n300UdrXbXCCitoGRhjlFya41jwyCOP6O2kpNcXtfgnNSUKCAioUmBVYlVRqVOTQYURFhC5G8Suk4AFhXVH8llAQEDVgmcTL5u9xs+/flntgICAbMBVaosrnbixb6dXYse4pbO6rHZAwL8F9F4hmZRwbFqEZQMDAgJKAuLNxOCp8iB3g1JWXsTo7X4LUSB3iQXfajLI0YqTgcS+NBns5YI0GYsC+QeuFRcDagbIeYhqQ52EQBwCAgJKAhLjyBAnuYwJiYY7lDKScLY0gaQ66eYYVcJormmQVSQl9rEGhiw2GLB0IeQ4BAQEBJQQeF3iukhiqZN9n3VQcRMHclHStM0P+PegxhEH2luzOhwPJzXIlG9RKidAnOuuu06X9VD7ywNK+UxU6+CAgICAgICAf3FyJLXn9HagDjkqzkozEno+0CmPng804rCb7gQEBAQEBAQsBR4HEzSJMT0OiIL7jDa+0pyHZho0zyEWZzfYiQJdw+jaR2OVcra7DggICAgoH9ApNKZCr9iLjC3N+FclR9I1jExgs4c4Wb9katMRzZc4QBp8s8ADAgICAv7dGD9+vF7JNOBfSBykfAgPgwnex5UW0Rfd7EcvThgGi7lMakBAQEDA0gPWh8GIlLbeAf9C4lAo6EHOYkY2IA2BOAQEBAQs3Qgh64r4VwVtZMVAFmsxwfu49c7pnEUuhLzwNAQEBAQEBAT8y4kDq2VCEFidzXQ1UV0Rt2woK6CJdyF4GQICAgICAv5FoQo60plLtpIQyUI6LLdKp7rzzz9fL4dM3waIxDXXXKMzYs1eDwEBAQEBAQFLCXH44YcfdC98wYUXXlih/emll16qez3QH58GUKw5z2IedevWLeNZBwQEBAQE/DtQo/s4VBUIb1DGSb5DSI4MCAgIWDoRdMFSkOMQEBAQEBAQULUIxCEgICAgICDAG4E4BAQEBAQEBHgjEIeAgICAgIAAbwTiEBAQEBAQEOCNQBwCAgICAgICvBGIQ0BAQEBAQIA3AnEICAgICAgI8EYgDgEBAQEBAQHeCMQhICAgICAgwBuBOAQEBAQEBAR4IxCHgICAgICAAG8E4hAQEBAQEBDgjUAcAgICAgICArwRiENAQEBAQECANwJxCAgICAgICPBGIA4BAQEBAQEB3gjEISAgICAgIMAbgTgEBAQEBAQEeCMQh4CAgICAgABvBOJQQ5HL5dRHH32kJk6cqJZWfPrpp2rcuHFqacWXX36pfv31V7W04ttvv1VDhw5VSyu+//57NWjQoHKfRsBSiDrlPoGA9Pjnn3/Uaaedpl5++WV11llnqYceeij1PpYsWaKmT5+u/vrrL/2+Vq1a+lW7du383/Z7+++GDRuq5Zdfvtpv4dy5c9W5556rnnzySXXcccepZ599tiDihfy8CpW/QYMGqm7duqq6sWDBAnXJJZeoBx54QHXp0kW9/fbbBcnPvZ82bZp+7yuz+Xf9+vVVvXr1VHVj0aJF6pprrlG333676tixo+rVq1dB8s+YMUPLz7PgK7N5nZB/hRVWUNUNzveWW25R1113ndpyyy01gShE/pkzZ6qpU6eqxYsXe8tsvkd2rkHA0odAHGoYhgwZopXFqFGj9Psffvgh/x0TwJ9//qkmT55c4TVlypRKn7EdE3CxaNy4sWrRokWl16qrrlrhPSSDyaZYjBw5UssvlqY5aSI/E2Gc3OZ3pZB/pZVWSpSd14orrlgS+fGwHHTQQWrAgAGV7j8KBUUYJbMt/8KFC4s+n0aNGsXKLS+2K4X8eNgOO+ww1adPH/2+f//+WgmybyHDvvJDwIoF9zVObvmO56QU8vPcHnnkkdrbBgYPHqzH/TLLLKPlhwz6yj9//vyizwfy7PP8r7zyyiWRPyAbqJXjqQuoAJg4E93ff/+tJ4ZyYMBvf6kxU2erNk3rq81bNdafPf/88+rUU0/VCo/JAjBhbLbZZuq3337TStO+nSjsZs2aqebNmztf8kAz6fBb82V/Zr7nbyy2SZMmqT/++KPSa86cORXOA+vEnEjWXXddteGGG+rXeuutV8lydcn/xhtvqOOPP15PeCI/547VJfJzXiawiKJk59WkSRO9jyR5XfIzPmz55T1eIRPIJ5Npy5Yt1TrrrJOXf/31169kubrk79GjhzrqqKPU7Nmz8/KDrbbaSo0fP14rFVt+9pskP1ZkIfLPmjXLKTsvvjOBZ8ZUJrb8KKAk+fEsQBp4Pm35J0yYoJWh+blc9yT5eYbSys/LlN8eB5yjCTxzpvxrr712Xv4NNthAP6dJ8n/99dfqkEMOyXsJBFtssYU+vosMc92jZGdeWGWVVSLlT7oGjHGX7Lx4Nkwst9xyefn5f6211lLt2rXLy898myT/0qoLsojgccggbv9wqHr0y9H596fv3FZ98cCFOqfBBhNImzZt1IEHHuicGMrhSgVRSuX3339Xb775pp54xOJFcbdt2zY/kc5fv5PqNnx2Bfn7P3OdJg422A+T0f777++Uv1yuVJlU7YkVi/n111/XE7Ap/5prrpmXf956e6l3f51XQf4Rb9ypnnnmGeexUH6dO3fWE7LILdfAVsjVBciNS6nwHvnfe++9Ch6P1q1bV5C/x+gFFeSf/PHj6r777nMeCxkh1C7lyHflsHQhzlGk8q233tIk0JR/jTXWyMs/d9091YfjFleQf863r6ibbrrJeSzI0UknnZS//+arVJ6+QsKJpvzm3926dVPvv/9+BZKz2mqr5eWfs+4e6uPxqoL8l++9QbXLEBCN4HHIGMuEaXd55H9uWBONv39SDf36Q21ti4Uo3gUU8cEHH6xqAiA6KHORAwXKxIfyx/KZV39VVbvTZZV+t8qAZ9XPn7+nfycTochPjgO5DjUBnDNua8aWyI9ViBcC+Rc0bKnUnpdU+l2LwS+qgb3eUfPmzask/4MPPqjOPvtsVVOw+uqraw8B8jIesMaRv06dOmrhiqup3B4XV/pN6+Gvq+8/ekMrJImxc+34n3j/FVdcoWoKsLCHDRuWl3/ZZZfVihP5l6zcWi3ucEGl37T99S3V94PX8p48GTv8f9lll6lbb71V1RS0b99ehxhN+bn//J9bubVa5JC/2xnbl8XzEDwOboSqiowB95wLo/78Jx+TRNGYlsS7776r+vXrp93VpYhbVwUk/k6OBpOEfAZQBqNHj9b5C3sdcozz9yP+mFFBfjNnAOutb9++OlxRirh1VUCSMZEfJWHKDxkQ+Xfd7zDn74eOn6a3Ayha5EdpADxR3333nc5/KEXcuiogyZi//PKLJoncO3G3c85jxozR8m+35wHO3w8aM0mPE3F7M/6FQBPCoMJi7Nix+WuUNUgyJrk5eAJM+XlmOXcqZDbbcQ/n7weOmpgnDdx/5Je8ht69e+ucD8aQXKMsyg9ZHj58eD48ZsrP2EX+DbbZNdW8GFAeBI9DDfE4TH35MtW8zlytdHjomCCIaUIW7Lhu06ZNE5P1eBXrxreTEeMSseKSEZEHZbDddtupb4ZNUC2Ou8cpf9Na/6hWrVrp7VEQIr+9XyampGQ9vrPjyoXIn5SMKAmaccmIyIO1ueOOO6qvh/4eKf/KuZnapc+23H+uPWTJ3m9Uwqp9TYp1Y8clY9qJqXHJiMjPa5dddtHyr3rs3ZW2mfbK5arRor90SAfLlPuP/CgcW35XwqprPBSbsGonYyYl40aROvGg7LbbbqrP8Imq2dF3Vpb/1StUw/lTdUgP+dmX3H97v2bCatxzUGzCqpDhJNnlFSc/++rQoYP6buQktcpR/6m0TfA4ZAuBOGTQPXVj95/U09/9nn8/f8B7OsYr2eNYGqIsUbhYseQUuJKUzM9sa4z8ByYhu+QqqQyLlyguOxmPmHJUIhb/M2F988032r2KPOyXRDkmf+L/kJ562x2pFqy1S36fc/t3V1N7PZV3TWuX9v9XFvxNhQFKPE52XrY1JvL7yGu/51q6khHNZExXUiqT+E8//ZQPLbBflCFyYHXy/TJbHqyWrNcxv8/Z33dTf33+bJ4gcs4iP2MBbwPjIE52V8IqISJ+V4j8KAHkt0mrJGNGJeQiHxVBJ5xwQv788UDxnGGNEsZYsvF+qla7vfL7nNX3LfXPNy/liQfXSsY/5/LFF19oshAle1TCKp4rrPdC5OdcXJVJccmIIj/nc/jhh+fl51rx+vnnn/VYmL/B3qrOxnvn9znzuzfV3O9ezT+/3H+OK6Gqnj176muY9PzbCavIzvm65Eu6Bow/lzHAPuPk58V5kJMk8pOgjUHw448/6qTRf9beXS2/Wef8Ps/Ypa26rNMGS6UuyCoCccjgYCH+t+MBR6t6zVqr2rOnqjp//66tQ9y5ZtUED/J+++2nk42SLAdxFZqTiTz4Phnk9mdRE4RPMiZu1R122EH/jZcBeZk8hIiQKDZ5UT1Vf9U2avGMP1TDBdP0ZIl1acuPlfbJJ594yc99NSdSrKAo+ZOuCQrXJb+PFwcFsckmm+i/t9lmGzVw4EB9f3Hlo4jJdP+7TmPVsOVaat6fv6lmy8zR54l3xQTyEy8m254JOG3CKvKjAHyrCMz33I+oZMQkQJBI6AVbb721Lilk3DA+kZNnjlyXlVqtq2ZNGKVaN/hfBQN5Ebb8JNOhcLgfaRNWeUEACpXfJke89/HiMM65x2DzzTfXIRr2R0Ip56OVedM2aqVW66npY4eq9Zour59VzteWn+vIePLpp2EnrPI/BND3mTffQ96E8JjXwMeLA4HlOrEvngNp4sa5QI4Yyw1ab6TH/5+jh6iBn76jK2+WRl2QWVCOGVARf//9N9pJ/18OPPvss/r48tp99931/yussEKFz+vVq5ebNGlSjbt9c+bMye2xxx65DTbYIFerVq3ccsstp/8XufjOlHPnnXfW/zds2LDCdssuu2xu7NixuZqGhQsX5vbdd9/cRhttpOWw5d9ll10qyL/NNtvklllmmdxKK62Uq127dv5zPvvll19yNQ1LlizJdenSJbfJJptoOerWrVtB/m233Vb/L59tvvnm+hqtvPLKWmbZju9//PHHXE1E165dtVzyHJv3e7PNNtP/16lTR/+/4YYb5urXr59bZZVVKsjP64svvsjVRJx88sm5Lbfc0in/uuuuq/9ffvnl8+9nz569VOqCrCIkR2YQJJCZDVNI/tp9990rxYhxvVOGJt0Pawq6d++ukzlxWWO9iNVnxrtNy53Wynvuuae2GE2PA9Yy8mON1SRQikYy54gRI/R7U34sOSxOLFAB23L/Sa4zQyP8TQdR2xLPOj7++GOdzEhlAcDKNOU3Ex8BHpldd91Vj3MzNMLzccYZZ2gPRk0CoZWvvvpKe1qAGUIU1z2QMAAJldtuu22F0JCEDuigKuOopoDQGgmd0i7bDCEiF+EcIDkRJE2eeeaZZTrbABcCccgocbCB8iT+KS5ZGuFQC4+bGncnD2PWgeI/9thjdee7Tp06qcsvvzxPFExliCuTUIj5OZ3yKGMT+ffZZx+tgFAqNMD6/PPPVdaBgkDR03ODUM0NN9ygFaUpJ8qCCROXvxl+II6NnCL/zjvvrGUmk57PXT0+sgYI0gUXXKDv/aabbqpbRiOPKT+KkZdUDQAIBPeasIwQKpoeMfYhjYz/d955R2Ud3Nsrr7xSh9dIcrz33ns1STTlB9LO2pSf8b/99tvn5adpGoQSpUsDtFdeeUVlHTzb9KIgCZhQDWXEppyA5wEZzXHB75577rnIPiYBZUC5XR5ZRLndU23atKnguuWFi3qNNdbQLtvVVlstN3XqVL3tuHHjctttt512a9555525xYsX57KIMWPGaNc0Ltfnn39eu6vBW2+9VUlWXJO2Sxb5V111Ve3WbN68eW7ChAn69xMnTszttttu+vsbb7wxt2jRolwW8fvvv+e23npr7ZZ/7LHH8vJ/9NFHlWTlOnGfzc+4RrjqV1xxxVzTpk1zo0eP1r//888/c3vvvbfe5vLLL9dhkCxi8uTJuZ122kmHl+677778OP3qq6/yLnl54cLmOtnyE6riGjRu3Dg3ZMgQ/fu//vord9BBB+ltzjvvvNz8+fNzWcT06dN1CI57feutt+bHKaEWccnLi+fZDkuKS5+xzxj4/vvv9e9nzpyZO+qoo/T3p5xyig4DZhHMpfvvv7++j9dee21+nBJqs2XdcccdnfJznQYNGlTt5x1CFZURiEPGBguxPFuRynsmnauuukr//e677+Z/s2DBgtyll16qP+/cuXOeVGQFn3/+uVZ2EKKff/45//ncuXN1PLdt27a5008/vULugkt+yAGTDn+//PLL+f0wCV933XV6u44dO2Yu7+O7777LtWjRIrf66qvnfvjhhwr3bfvtt9efn3vuuXk5GzRo4JSf1/XXX6//h3wIUMK33367Hh9MuuPHj89lCQMGDMi1atVKK71vvvmmwn0jf4fY/cUXX5wnUM2aNYuU/4YbbtD/33333fn9QMIeeOABTba22mqr3KhRo3JZAspx7bXX1qSnV69eFc77gAMOyDVq1Ch32WWX5QlU69atI+Vn/PMcMA7M/Tz55JOabG288ca5oUOH5rKEX3/9VedpQHh69OhR4bwhPZAE5jUhUOutt16k/I888ki1nnsgDm4E4pCxwTJ48OC88mQSICFuhx120ElQWFc8bDB3FDHWton3338/16RJE+2ZMCfocuLhhx/WE2KHDh0qEZrTTjtNTxYDBw7U73v37q0JgMjfrl07LScWKN9NmzZNy3/kkUfqSUisbsGnn36qlRMv/s4CSHRFoUEQbEKDsuTa9OnTR7/nngkxQH6SR/GykESJwsG7AE499VRtfdqJkV9//bUmIYwBxkIW8Prrr2vFwD387bffKnyHrCgFUaaQKpGf64LnibGM0v3444+11wJcdNFF+vr079+/wv74PSQURYwnKwt47733tKeEsWwTGsgPsnbv3l2/x5pm/DNekA+511xzTX1P8Uz98ccfeju2gTxwv03w+/XXX1979V544YVcFvDJJ59oD9E666xTidA8/vjjWv6XXnpJvx8+fHjummuu0dsjP4bGWmutpYkk4xkvo3jqqguBOLgRiEPGBgsPGseGpYODDz5YW9EmUCAtW7bULs158+ZV+A5rE6KB9UboorofNAEuY4gBspxzzjnaujbx4osv6u+eeOKJCp9/++23+nOsVHD88cfn2rdvX2GbGTNm6EkFb8U///xT4TsmV64XCgnrtFyhG1yxF154oZblpJNOqnSf3nnnHf3dPffc4ySOX375pX5/9tlna2vNBDJDKlASXAsTkDMqNtgHVmy5Qjdc96uvvlqfB0TPzopnnMs9MkHojd988MEH+v0VV1yhyYMJruUWW2yhleqUKVMqfMf1OOSQQyLHXXWB546QBDLiVSCkYAKSCDm65JJLKoU0OPfXXntNv2cfGA/22OIZx4tFCMzErFmzcsccc0zkuKtO+e+//349D+21115aLhM83xgNeBrteYNzx4MC8CRBIsr1HAfi4EYgDhkbLMT/ObbEKpn8sDht9O3bVz94xx13XCVywMSC0mA/TCKEBMoVz5YJwASWMlYR52afe7du3fR5i3V55ZVXatetjZ9++knvA2JlTyooS7Fc+d4mF1UNJsk999xTT5pMfLaMeEpQBgceeGCl77C+TeKI4sCDYAPrjH106tSpEjngevznP//RVuk+++xTiVxUNVCSKEuUJiEUW0YsR8ITxPztcyesg/zihXrwwQe1BW7vgzJcLFFKde28BrZ96KGHtGIm/6W6Q3eQpCOOOCIfWrDHJ8QfLwLK3yY25G7wO3I/zNJsmwBAkNkHoRk7rwH5n3rqKT0/YFyIp6K6wLmeeOKJ+rzxDtn3mPGIN4VyVHtuwitlEsc333xTvy9X+DUQBzcCccjYYLnjjju0q1Vw00036UnWBVx8nOddd93l/J48AOKe9AGwwxpVHc9mUrddqQAljtsWi9ml0CW0IZMtiXTI4PKcYLWjnHDdugAJgVzgmcCSLWc825xUmezxmBB6soGLmXsqFjoKgPcuyxn3PeQEz4YLuLcZS1zrkSNH5qoDEB7urx3PNkktpBKPmZDDOOKI5c1717VifEFOSQp0jQ/Ce4S6CF9IMmVVA8WHN4TwzBtvvFHpe8Y1ZI/zcuWi2MQRBcp7O8wjiZWErPDouOSHhBHqgmDYYZ2qAiQFsgJpee655yp9z3niEWJ8iIy2QWR6HCFQvK+u+2cjEAc3AnHI2GA5//zztQvajAOiHKOy5XHl8n1UTLtfv356kqYSw0zMq8p4NhOna6IDeEjYJmoiIMbJuQpeeeWV2Htxyy23VHDtujwTeCyiiEx1xbMFhB6woCUr3gaeAiZVAcoX+aSKxAYeDb6HYLgwbNgwnStA3NhFZEoJ9g9hgjhFNaai8gOyI6EYF3HkeyGOJNYiH3K48Mwzz+jvuQ4u4N0hV4j74iIypQTji3HGeBPF5xqvPK8ffvih83ubOEIOeB81Xnjm+J79ugA5Ib8EgsG2VQnOEZJCCAUCEDde8SS4ICE8yQcaMWKEfk+OUzkQiIMbgThkbLDg4sS9KiBxinOJcjcyweIWZmKMUsYoHfIEmDxeffXVKo1nc/5RXd6efvppvQ3hmLiOcljkgs8++0z/hgnEBUmWRLaoLoLEwSV0wjlUdzxbINbzf//738h9XXDBBTqr3CR+/CbKYuTYJEsim7i340InuPBLnfdixrM5jh3PFkBukQWvWhRw7UN0BSTUJXVIxB1OWKZnz56JoROOXRV5P+TqcA8Indh5FwJIEOfJsxIF8pJM4kgOA/LHkR5JKH777bed3xPKkNAJ21ZFvgDeTzyDzDNRJJexzDWibDYKVE0wjiS8QViD866KecsHgTi4EYhDxgYL7YZRhFEx36iJEasKl2xULJDJQ+q9mbhKNXmYk/Jtt90WOSljgTCxkLAVBxL7KCmNivlGyUaPBKydqJAMcXBICftCOZeq34EZz8ZbEnVd8XxQZnn44YfHKi72xRiwkwWjLFSRjd8Q0opqwY28eLPYF0mrpep3YMezo64rORl4Pbi3cWOPsAMWsp0sGGcto2ToZUFYJsozwTHJlyl13g8hJLxI7JdEv6jrKjkZGAVxCauEnfAQmfuP8yiJbLj/CctFzROMuZtvvrnkeT/IIqXgxx57bOR1xfAhyRViETf2II54LMzzJuwBMS0HAnFwIxCHjA0WJg0zZk3jJM4lypoytyNuuuuuu0ZmkvMQkqyGkmetADKwqzKeLSBsQayV2GfShI3SQHkIIEJxrk0BVg6WKvkcUceQen/J9HbFzQuNZ8cpNtyu5H2Qa5F0zbl/kAcBsiA/SXJxIOGOvAmaR8Udg2RVrD6IhpR3FgqUAWWmUfFsU/kzrgnBJV1ziIVJHLlnhHZIkowDlim5HBwnyuNR6rwfxiZEgJycuP4CQuxdVSA2MBpM4ggI/+DRigNEgGRDxpkrd6Qq8n645iTf4kWhtDSKEEPsud6uKhAbeM94pkwgE6SvHAjEwY1AHDI2WAg54K40H7ok974Ady5K4YwzzojdjuZRWL+bbrppwZMn8WwsyLh4tkxoTFI8/D6NmVD+WB2mNcXEHOfeN2OsKIWjjz461qonqZCKBBRZoZOnxLORKyqeLYof5Upviai8DxOEKfCImMCSjnPvm6Wc3FeqNeKserw3eCfwUEWFgJJAvozEs/GKRQESS3ksys8nQRPiiGfIBMeJc+8L2D9jknBJnEfJzPvhmhUCeiZA1CDrcWEULHL6rvBcm83PfIkjgBDFufcFjC/GGU3A4sowzbyfQhcJw4PEWOU5Igk3ChJK5LmMytMwsd9++2mvowm8iUmeyqpCIA5uBOKQocGCkuW49DiIIxNxwKJMiqPLxMfEyeSXRnn4xrMBygvPBhYOk1USmGTZr2292WQiDsRCkR/PStLEhwVYiPLwiWfLtcItjkUep1xN4L0hQTLOC5WUoIlHiU58SR4qJn4IRNqkWbHa4+LZgjPPPFMTP9/kNu4HIZ84L1QcaPzFGEpStJw3xBnFlzZpllwCxjS/5zrGATc+FrlvQy7IrE0cXWQiCvRBwUNzwgknxJJnxi33D6KZNmmWsBlklnPlOYoDVWFxycs2yG+yiaPthapOBOLgRiAOGRosuP45rt31EKueLoO+IJbN5Jk0IWBtp1EevvFsAe5FlJh0xksCHgn2TWa1CVywxOV9gXXKcc223C7gbcG1j5Xq02kT65m+GknxbAE5H3Z77KR8Cba3u/6R2El+ii/wTvgcl1BFGuUBsUvTH4RETFeTryiId4nKChO4w7HafcHvOS4VSUmudsgfJAjC5XN+0vKanIKkPAGp+LCbfMUBhWwTR/JizITpJBA28jkuIS1CdhANn4oLiAil3xAhvAJJ/UEoR5U24b5wEUe8DXgdyoFAHNwIxCFDgyWqZplGMSQe+QKFzoSAQkzyJvgqD+K0xF6T4tl2WZk9CcYBlz+/sa1z6t7xXPhCPB3IlOQeFuVBVUac8kCpcx5J8WzTKpWEybTEka6KJlBSNEvyhXg6UIi45eOA8hPlEWcVQhpZTCopni0gJwfyalvPcSA2j/zE4U1gPW+77ba5NCBcx72ikiEOkB/GCueKoo97piS5mMXUkuTnWcYrhfXsW8URFZZkHRNyidJAPB3SSCkKkN+uXbtqoh3npeSZIv+A86OkNqkjKYYIzxSeEl/5o8KSGCCEBMuBQBzcCMQhQ4NFarJt9z8TG5N7GpCEJglpSZZBkvLgfEhuwhryscxZe4F90S46TembNLux8w4gTeQJpAHWFK5kn4S0JOUBacJdjHvaxzKndJKESRR+muoVIY526OSss87SnpE0QCaUrU9CGsoDpYjywEvgUmhULUAafSxzSigZK3gK0rS8piIA+XG3m8DLQUgtDfAOYaXTddNe08QG50goREpF7THL9YE0odR8XO4cj9wHiHaa6hV6f7iII9UQ7C8NkAn3PqGvuBwkwBiVihuIrqsTLUQUIhJHruxEZbwEaVbrFOJol5USGmXslaN9fiAObgTikKHBQsa/6wHBLU6CYVrEtSX2VR4oXY5NcptPIpWUnSUlaMX1ebAnW/r5s9hNWnAuhGFcbYltcH3EojKVBwSMahAmYJ9YuLQCJi4f1c8iybXLYl4msHBJekuLuLbELuWBd8BWHhAwFDBEyIc0UWnAvWJ9jbTPD0l2HN8uKcXlzvHTQs6Flu1RvTUEyIvcHJ98EiF8EDAIEEQ4KfQFkBnvAMdN2yYZUu4ijoR64prAJZ0LoU57TEVVXHF8ngOZL3huIMC+pIkxz3gj5JA28Zo8KBdxlLyl6m6dDgJxcCMQhwwNFrpAYiHboGmLWducBkltieOUBw8+CgAiQDJlEpic2N7Hynchal0G4qqEHQpBUlviOOWBDJSGEfLxyQhnvEAYfKx8F2RpaPs8WUIba6+QBauS2hKb4HvJj0B5cD8Jk5GcG9Xp0VYaEEbuYSFLW0tOgE04pbV6IeXDhP04f7L1fa4fZZ8oaSpzII1UhHD9eI6SwHkTUvKx8l2QdRlsJQ9h4fNCKqC4D9wP5PBZ8AvyznyBhwX5uW6MSTvvyAWIDT1dIHmFtLiOIo4k1vJ5UiJmVSAQBzcCccjQYCET3BXLJObHw1yoqy6pLXGU5YG7GcshqqmOHe7ANc4kZS+fmyap0RXLtBf+SouktsQu5cH2EAY8FnHNtwRYpljmXDOf7V3gunPMqPUbCiFjPm2JXcoDosK54LHyqQhBKZEwh9KwLUZfMM6xbKNWjC2EjAAqGiADxOZ9gIXLeeBlg7Am5UkASMmhhx6qlSzdTguBjHObOPk0gYsDihd5CHn5AKKC55P7T55MXPMxc94gNMlxCl3SXfKC7P4iPk3gqgqBOLgRiEOGBgtJUK6VMGXd+kLh05bYjtFCADimT54C7kxyJJhkk5Lx4kAJoWslTFmvIsndHIektsQm8BbgNZAue0l5Clha5EgwyfpY5nFVGCgrG7JeRTENi2S10Ki2xHasGa8R23Nfkyx1rg8WOuMrrqY/CYTI2IcNWa+iGIsTr5WrYsUFcnqoNmJ7PChJYS6eD6p+GF8+1zepGsI+nqxXUcxaM3it2IddseICzxnhSbbH4+bTZZOqL1cpeRq89dZbeh92iEfWq/AhcKVGIA5uBOKQocFCqR8d5qIe+mJgtiWO8yAwOeNlIC4qLWrJMYgiDygVysWwtIpdRInsaVeohrJCzqOYNrlmW+K4nhK4SWmMhOeDihAsVTL0o+Tnc8rF8Aj5JA4WEqphv3HrlfgA5Y5FTIJn1AJEkthGwyE6fd57771aLhLjosgD8uMp4zoVu54Anh4sXRviqi60WZWcJySY/ccpIMnp4T5I6AjyGJdfIOu0+Hj04iBLaNshBQhD3HolaeYX7mdcpQXhCTyHhFu4H4RpeG7i8pUkvFVsW+ioUA1zUtJ6JVWFQBzcCMQhQ4OFnvdUAth49NFHtTVTLHABkoNAxrOrix+liyThsY1YtyxrLetbuCZjGvxwblgLxQJXMkrbhsS40yYb2iC5CguKDHVX0yeuCf30SWyTOKs01EI5usiD9DXwKVFNAqEE1xLqstBZXCthH3D9yFmAPLkSXalmgTCSUClKGm8P9xdy5PK8CLn0sWSTgKLGa2NDFjpzLcOcBig/Yv2QJ1eiq+T08AxIGS/XHvc7ZYUu8iTPR5qy46TkYPs45NfweVyHUh9AfshZgDzZlRsAS9/O6WE7tud3Ls8LiZtpy46TkoPttuQYOiFUkS0E4pAh4oASdlVPyFLDpQBWK2WaKEiz6x3WDFYWxMWOpdO1UurXXavyJTXa8QVK2FU9IT0hCs1xsCdHShtRDqbnhTgq4QnKV+3ERvo2cHzcsSZ5QFnwOZZ5KUCXPRJRo5YaLjTHwQRjmtJaQiJmzBylTJiIske7fJHYOx4FqntM+eW62OOiUKCEsXBt4MkqJsfBJk943kiYNHM3aNe8zjrrOHN6sIRdnhcZl3jkSgE8FuzPJmh4iIrJcbDJE1VWXGfT80LzNcKkEFfbI0eOA54XEiZNbwjGAqQyziOXBrJ6rF09QaIpn6ft8FkKBI+DG4E4ZGiw8ADSJdE3aaxQoBhR0IQFmDCZQLFCqbuOKtvCGuaaEIc3Ey7lfSlA0xos3qiksVKtaIgCNj0vTMh4ISAUUVY9bljOgXAKk6RM8qVcfCeq7FKSI4tdlEqARWd6Xkhm5VpAKMePH+/8jchLHg7yM8lDJuR9KQABwxsQlRyZ1I/BF1RnmJ4X9suzwCuKnNieF/JOIBN0Ui2V/OLdsvcnyZE+bdt9AAHffffd854X5gNyOhgDUYnNJEyK5wXPBd1tIROEKQup9nFByi7teVeSI316yJQagTi4EYhDhgYLFp29Mlxc0lgxwC3NRMlkwQRCEliSvOJhoNMc/5NwWMqmLFj0WH2+SWPFel6YLLHwUSDUnifVukuCHZMnSoSE01LKT2tecguiss3T9gWIA7LiXcLzgKcJazNpETJCZpIwihKh70eplmeXfg2usltKITlu0roQhXheuPeMAQhr0iJk4nmh5BD3PYuJlWp59rgkaKpU+Nxnkaw0nhdpaoaXhZyepFAQHgbIEn0t+B1r1ZTymYxKgobc8jmN5aobgTi4EYhDhgYLmdkoMN+ksWIhViMldD5uYJQksU6uDZNuqTu5QURQ5r5JY8UCFywEgGvrOykLaULRlsrSMisfIHJRSWNxC4oVAipAUASQ0riESZvcci54rEqpNACtrAkh2KAShmMWuwy0DbwNECCuge8iXIQlOBfyQEoROrOToHkebaAwXY2higXeBcY+zwAeFB/IolWENEo9P0YlQfNs8rnvQnGlRCAObtRWAZnBkiVLVK1atbw/LwaDBg1Sp556qmrfvr1q1KiR2m+//dSff/4Z+5snn3xSvffee2qjjTZSffv2VY8//nhJzwkiGyU/KOU1GD58uDrmmGPUZpttplZddVV14IEHqgkTJsT+5qWXXlKvvfaaln/w4MHqvvvuU6VE1H3mupRa/rFjx6ojjjhCrb/++qp169bqkEMOUWPGjIn9Tbdu3dRTTz2l2rVrp0aNGqVuv/12VWr5a9euXS33f+LEierggw9Wa665plpvvfX0tRg2bFjsb3r27KkefPBBfc1+//13dc011+TvTU0b/1OnTlVdunRRzZs3V5tuuql+Fn766afY33z55ZfqjjvuUOuss47+/aWXXlpS+aPkrAr5A4pDIA4ZQtTEEfV5oRg9erTaa6+91FprraU+/vhj1bt3bzVt2jS1++676/9dYMKEaJx11llq4MCB6pxzzlGnn366evrpp6tNcbqUSiFg0t9zzz1Vs2bN1CeffKI+//xztWDBAtWhQwc1adIk529QmEyuvAYMGKCuvPJKdfHFF+vrUh33H5RqDEyZMkXLX69ePdWrVy/1xRdfqOWXX17L/9tvvzl/8+qrr6pDDz1UEyzkv+2229R1112n/69p8v/11196/C9atEh9+umn+v43bdpUyz9y5Ejnb9599121//77q44dO2r5H3jgAXX33Xerq666qmTKs7rG/6xZs9Q+++yjpk+fruX/7LPPVNu2bfXzDyF2geekU6dO2tDo37+/fh4ee+wxdd5555VM/qj7XBXEOaBIRHgilmqUyz1F4hUhAFfSWCG9+qNi+5Q8kktgJgKSgIT7keRM2yUuddpmVQH/47bGterTVMcHlDyStOibNFYIyBOgTwEVBGb1BPFdwgQc306QlOWhSV6VmD7nIk1vfFbL9AElr1S7+CaNFQL2wT0ml8IMTxHfp6KCEIRdVULnTdzZLDZmxvRliWlyP0oBxpmrcyadCDlOIW28XbF9Fkwjr8NsC01+BxU1hCDsJEw6bxLSILfDDM8QWuG8CDGVAlFJ0ISUOI5PB1ffklT6NJh9ISTnhXwPO0GSPiKENOjnYIZnpL8M7dlL8WxGJUHLqrk+bd9LjRCqcCMQhwwNFjK0WVDJN2mskGx6KgdIhrL7wQOytkmWo7qCkigmA0mIvPbaaytNDihRzhml4rMATqGdM6VWvBTZ9CwhDkFydSFkYkah0oRLEhGlFJU1PGz5ec858z01+MUiqXNmIWs1mGBCphSRNtKuDH2SDyEuVFdIsylKgTk2+Td2IiTyU1XC9+ThFAtabldV50xAjgzKL6oJFs2vSJLkHkg+BcqM8U0iqCsRkqqiUlUXQVCpVLBB46NiO2cCcnIgP1FNsKja4fmjLFn6eJBfA5mhM6qrCZS0Zy9FdVFUEjQEh899FtkrNQJxcCMQhwwNFjrbuZaPxqJzJY2lgSxAxMSMdyEKPJwoFs4DD0DSpMhkRMIgk1GhaxT4dM50JY2lgSxAxHWMa91rel5YdAz5UehxnSOpriDBjhK1qljkrBSdM1F6VAFQvx9XD296XsSjENX8CvA5Fif3xzfBLq5zpmv5aFnkqdjOmYxTEkFdzY9szwteOYgMcp188smxibBCrqu6c6araZsvzHFKU6somJ4XDBa2p4ooLjFZyDWewWIga8pUVefMQhCIgxuBOGRosBx33HG6vtz1YOJaLBQ8iJ07d/ZegIjsZSwfrgGTp49ShmjQgyCppC0OLMKDR6TUnTOZ9A877DA9Kftkz2ONo2CFNPgoZeriIWXFdDekcyZKywb9/4vpnInSOOGEE7wXIMLzgofL7NuQpJQpUYSUFZP5n9Q5M6lcNAqcP6QUEkB3wiTgeSFkwjEh80klp+wfjwRdL4txp9MrpKo6Z4pniAqlJODZ4VmW0tuk6iFZq8N3LZykzpm2Z6dUnTMLQSAOboTkyAyhTp06auHChSVNjiTh6sQTT9QZ4W+//bbadtttY7dfvHixrp4gWbBu3brqzTffTKy2ILGOfS+33HI6eW7OnDmZkZ/fktCJHCT47brrronbP/PMM2ru3LlqhRVWUN27d9cZ+Enn/frrr6smTZro6pSZM2eWXH5Q6DW47LLLtEzPPvusToqLA8d64YUX1D///KMaNGigPvroIzVu3LjY35C09+KLL+oKBRIIoxJsyyX/zTffrJNYH3nkEV09kgQqZ0igbNiwoU4c/vXXX2O357x4ZjbZZBM9/v/444+C5Sdh0042LFb+e+65R916663qrrvuUscdd1zi9jzLkydPViuuuKLq06eP+uWXX2K357y4vttvv7066KCDdMVOofIDewyE5MgMIoJQLNUoF8vE4nS5qnGFuhoD+QCL2XcBIpg+qxxi3RNvxDWI5UHM26f5DhYBXg0WUyokWQqL07XIE6GaQnM8JAbtswARliWWE9sT2yd5DpctMW+f+DJJZTQUokFOIT0eZFEl+9qJx6WQfUpip88CRBJ2YHu8XFi4uOwJXQwaNCjx94wRQg00Fiqk54a4qu0Yt6xVUsjqqNIDhDU1kmDm9PA/eQ4k0iKTz6qvWOrkD5FHU0iPB1mrwW5EJqEacjAK3Sft3H0gYQfGAaEhWuAzpn1WfSVHAo8Z4cZC8nFYWZVj2/lXEqopNsejEASPgxv/OuLA5Ep2OgoYtx8TH6180yiycg0WqidwkdvnSmzS1Yo6CeLi9lmAh8n6kEMO0e5sM9FRlAcJUz4tb2VpXOLjaSFJkLarksZQro6SSZCOiz4L8DBuCBVBssxER0IvaZQHkx9KnoqLtJDqCbtXP1n7hRBHGicRoyax04c0sVaKneiYVnmwDS5rCFha8ijVE3bba4ijqxV1EnCbcy7kKCSdC9/T8tzO6SFJltUiOT4dLJNAPJ5nmNBFWvklCdKuapAcn7RdKuVcyFHwkZ950s7pYQ7cbbfd9FwalxshIFQFySd0lbarqCRB2s+Z5PgUQhyLRSAOSwlxEKuVRC0sIBg3AznNkq/lGixRD8j++++vrdg0oNscMX1i20mTBtYRHSGxdllQyQaxZYiLr/KQ7nI+8WSXZWVnzzMJ77zzzqknIbwfkKGkCQzSRM99lCz3wEZa5SErJmJBp0GUZYUSTksc03g/UEiME5STK8HNVB6u8RFVPou3Iw0kCc5OXoWEudYw8fF+UEWS1OGS8cHKtFGeGZJSuY6QENf4iFqsKW2lhawCaVc8QMJda5jEAe8EniIf7wfzA97OKM8M1TjkOkCIfRIgKd9kLKWttOCcOQd7eXqSNAshjqVAIA5LCXHYd999dYmgCVZ1Q/lkfbDIKoB29jTlkfR48AWuPuqxd9ppJ2cJlQmsO9pcY5lgLUdBlAdkJEl5MBFh5bDPNJnQsgqgnQTVoUMHrdh9gZVMiGHLLbdMTCiEFJGQCmnCQxGFNMoD+bFy2WeahXlkFUCbnKUljhAd+jFQGZE0htmWun48TXioopBWeZx//vmaiMVVMLjGIvLbCZw8u4xlXyAzZYVcg6T1PdiWxGEUHZZ9FAi90MfCN+yDl4t9+hAts1ya/dulzfRLca2aGwXGPM80z0BSCSvjmtAix0VBRwHyKe3GqX5JMkZk5VjCTL7gGruqM2jznZY4lgqBOCxFHgczJs3KhyjRuEkR5coAkZdMYNVNHKQnu61smAAIv/iA2CKVCcQak5ZhxiuBJUPtvo+CR3lgwaM8CCskTV4obs7dt4wOwoP8NoEhVEBJoA+wrmiihbWV1DCI0lNkJwzgs4BOGuWBlYuyY+z5rrFAbNvlqYE42mQ47rjkGGBtJ60/gluZMBQeOp9qkzTKAy/GXnvtpUt7pSeAz7m7PDUQR6pifMA5YjxQhWQ2eHKB82Js4Zlh3ZIk4JmQpl+ySmrcthgsWMq+q1qyP8gmuS4mcPvTf8IHHBcigLct6ZnmeYOQcI6EGH3Oj7CZlOjGefLYlmXIMTR810EBjEXmcBPkXVFKXg4E4rCUEAcGM4lAsH2sKP5nkouDJETZr+omDih6jmtavsiDHHSVSwLbYp36lMURx2eS4oGMWko6amKmg6K4NeMmTxQ3uRG4+X2WxGYb9ktipgmUj09ZKOdy5JFHak9HUlkc+QRsh2WWpiOhqTzouxA3eXI/IbF05PNJFuP88WjYLn7IjU9ZKL8/5ZRT9D6SQkpYwoTwSGRLs1y1qTwo1YwLg2BBs2gZL/72AWWQ9r1OQxzJh4HYxnnPJP+DccW5pe3IKAmEeAHjkkCx5rn3jIEkEh93rwk3+BJHmcvivGeA8UHpK7lgPomvJkgcZl7lWYvzaPI88+wzB/g+Y3jJGFcm8IhBhsqBQByWEuJAlz2sXP7ngaDzG/X1cfXLWfE4oIRw75otjIVM+FgEJHcxaX7wwQexlqA0diLpspAVDlEe0hwIqyKOFGBtYHVgqfski2EpmsmceBBcZCIut4IWwXHXWBo74QIvdIVDUR54YOIaMzEGUdBYnz7JYmTlm8mcUWSi0NwK9gfhYzvOqdBulIxRxhrWfdxzglUPGcD74JPcR/MhO5kTBe+TLyC5FbbFbsuPS55zx4r3JTQ2GI8QerwhceEQvE0SNvR51iCyhLlsMuGTLyAdRpMMJap0OHc8U1RCFAK8YjzX9G+J668hYUPk8ulDQjjUDku6yER1IRCHpYQ4MEjtSRaF4lquOYuDBbe52fseNyfnkuRKl1I2KjPiXOE0KoKc4MEotr888UsS5ggNxMVSpZzOp7qD6gmsRgHWML9NSkqUsjMyw33i2ZxLsfJj1eHmxd0bF44gG51j+lR3bLHFFprQCZjYfYgjZBFlSDzYJ57NGEub9W4Dqx43Px6BuK6G5Dn4VneQzEiHR5s4JjUuItSCMiSUEnVfIbhUzrA/SHaxy6KTxIhrnVyKuG6shB7x7uGhSBpzEDESlW3imNTSG4LOs4hbP+oYeEfEW0iztWKXqadRHPNVUqhTEpV9qjvYBkJjAuJZipbehSAQh6WEOOBdwJVmAgaeppyvnIMF1yYPt+lS5Vzi+ijglmdiiis7I3TBBOcbz/YFpVO4IrGU41o5YzGhPO2MaRuETpj8BBAm5Cf/IwrIljQxmfHsOI9MWkDscEVjVcYlQko/iaR+GljBxLRNj0UScaRkFk8NpChKGaaNZ/sCNz/PFs9dXMttWdMgKbGSXAZc0wLGPb/jOYgCHkJyOrD+o5QhxBaCi3KNy3dKC4gtiZiEB+O6cgqxxysUB0IShCYEeDP4HWtGRAGvJDk9rHMT5f1jG0gZJOTxxx/PlQpce8guz1/cOQqxT+qngTeU59T0Bvt2vKwKBOKwlBAHLAqUmJRjYhUyqWBh1ITBsueee2oXst3AJmpCYCVL4pRMNlGuUCzeQuLZacqoSOAjZyBKMUpbYs4jjgSQuc+aEnZfiCiXKq52Jhom7yhXqMSzaWRVihUGbZAjgisa8hYVJvBtS0yLY+LCAjwtyB913xgXlGqSdW73fyhFPNsHjEHTk5XUljgu/4LW0OZCZ0Ico84bokBVDJ7GqDECuUWx8vLpxZEWlE/jJUjyZJEbk5R/QRjNXOgsKmFaAFFkzoC4RjWIIkGcfTIGimkJHQWeO8ILSZ4sCW/G5V9g5JkLnUUlTFcXAnFYSogDDzGstVWrVvkGUCQbpYnll3OwkDNgrleBpepaahgwQaGM+d7lkZB4NhMaq9sVu7piHHAp42KWhkuuyYPjQ16o+Iia5GlChNdFQNgJZeOajEUZQ0ZchMCMZ3fq1KngeLYPGF94fJCfUIvL8kfJQ/BQYFGTPIm9jFl7xcAo4ohrnlhzVB//UsSzfUD+gqwUyjm5LH8+k4qPKA8a49VcryKJOBKaQb4oxcqS71wfyFixq2vGwcydicr7YUxQVovXy27yJMAjYTaBSyKOhOZ4vinldgEvAN4AyKVvdU8h4Hwlxygq74dtpOIjarzS4ZV9yPhhbR3e+1amlBqBOCwlxKGmDxa72Q2TMclBLtx9993OhimABxe3b6ni2T5gYoDoxBGVpMY8dpdESB8xVBdwuSKfq6+CGc9GuRQbz/aVnzJNSbxzeQCkLTEeGldiJvfUbHZDhQHekrjcEZfrudTxbF9QpgvRgyC4kgbNtsSuToDIYnZJFOLoGr+y+BXXzAb3W6pf8OIk9TMpFbgnQlRcZcjMKXjIeMbt1tKuJnBCHF1jBbLAtXJ1aeV6XXvttfq3zAOFLpBWaN4PRMW14B3nQWiDZ9qVVMlcxjkLsZbur75VKaVGIA5uBOKQscFCtr65hDYMnditDSwsLC1XCAbLQuLZcXHHqoKERugn4arhl7bEJAHangSy9XF5i6KwY74CLBYmaDMfxI5n8z0WZ3UDKxFlT4WAK2lOWgHjobHllzbhYrHZMV8BFiv315UMV1Xx7DStkyGHEARX0lxcW2IhA6J0IY6EIVwElGvMPmz58SzhYYLAkSxcbBJsWpCoSN4P5+1ajZZEUtzxhHfsShPyRMwmcBBHPBSuMU54grCeTYoh7BB3SAU9Eapbfsn7oUeMK5+KvAiMAyoybEJHKAn5ZdwQ+mKeqw7Dx4VAHNwIxCFjgwVFx7F5+HngSRa0u15itTEp8Z1tSZrx7HK59wAxaZLmIEGUiUWVztmKrVu3bhUUB5Y7vSlMYMljsWG52C7hqo5n+4IGZO3atdMEwZX3IG2J7W590j1UCBfWIiVqttXGviEUtldHJu2qimf7AsWO1Uneh6uCR9oS29aydA+lOZcQR7wzJlA2fAYxIb/CBCErclkI3/m0B68q0LeAZEWUHsaArfhYKpvv7DVNIJrID/kS4ggBNQHZgBgyxu0eLDT9IkcEYkYL93KB82LcQt4Ip9jkhooMiD1hLRN4KZCfHDVA4zs8dOVCIA5uBOKQkcHCZMCkIQvNMDFilaB4iJmiYJgwmYCwprDo7KYqtMwVN3FVxrN9gbuVJjHIQ2Kc7W6lWRHyYT0zsfC/9EdAfipA+B6vyx133KF/jwIihooVZndGrK54ti9Q8Cg+5KGPha3kWYGQ+4V1xX2FLFARxPZ03UT5Ew+mWgLLUX6P653PbW9GdcWzfQGpI0wicW87dIMrHcXy9ddfa/mpDpFkYGTAKiVPiSoLngvJUSGBEkJiJ5lS1UB1SVJ5aHUBUk+YDHm4h3boRsY6BIdxTR6DLHRGng/EgPEMAaGxkzzTVCjhlbOTTPFWMGdQPZXUAK46wDPNeUMQuYd2aIL8G2TFWEB+xix/Q6ggP4QzuM+FLPBXKgTi4EYgDhkZLChKV/dKXrj0+J9cBxbj4UE0y9OYoGRlw+qMZ/uACQGvAhMgoQsziRF3PP01CKtgnbhkR7HgWeFvJkQSD+3MbDue7dOlsjoBoSGsgOVoVpRABJGdz1EsLvmZREV+En5lMSKzIRZKVzoGkt1eXfFsX1CKh0In6dMs2YUsoxTxkEhWvv2CWIn8EAksUP42qzcYYxBLnguqG8rhKYwD1jMKHUVoJnFy3whXIJcQTNf9l+cfIi332eyuifyUu0Im2J8rd6KcwItG2AI5zZJdzvvAAw/U10YIpv1CJt9241WBQBzcCMQhI4MFKyKKOOCWFiXK/yhZiY3C0ikFZIKJW6Sn3MCFjgsZF6q58A3JnyY5sEmDWN/me7P0FM8Ccd5yxbN9gTeFhEAsaMI0cp5UoDA5UknjmjT5Hw8KSlHkZz9CjshnkFLAcsSzfYE3gfsoazHIeVK+CDngnrqUJv8zNrgWIj9hKskBIVQhScDkQ5QrFp4EXPDcY+SA5Mh5ktPDNSHs5pIfmVkZVtrn8zlhSvG+4NWTJGAWFku79HZ1gdAjXgdkgPxI6EK8hIxpkc+Un2sT19StqhGIgxuBOGQoVCETpD2BYGmY73nA8FDg6sNljyVTzni2L5jkyNdABkoXJStc5KItrUt+5LPlZ6Ihg59rgyWTZhXGcoFQC+EZZOA64Go25YUguOSHcNny46khdwLZCVtJTDjLwMMiJZv0KiGfAdIgckGAhRyYL9z2NqEkvwGvC2ODJMm0S7iXA3gCxWNE7g55HITiRC5CjLby5EWir/k58hP3J6yDFwcyTmv9rAOyAAng/DF+SHDGEyVjms9c8pcjwVsQiIMbgThkaLBgPeO2k4cHpUic22WJyzZ0S6zK/gSlBpYmFjdWBkoDWXgx+SErLk2RDVKEhS6Wp+2J4EVWfRbyOdIAjwuhC5EfeclNIKEPa1Lk5zP+5tpEyc8aEL6rj2YFhJlQGFiTECVk5D5zTQhHiXx8z/9UD7g8MbxIEnSV/WUZrMTJsy3yIwfPAy/yM0R++Z9EZ9f957pBNvHm1CRQacFzjvwiC88C14LQnU0ek1Y5rUoE4uBGbRWQGbRo0UK9/vrrkDn9vkmTJmrNNdfMf1+79v9u1/LLL6/q1auntt12W3X00UerlVZaSdUU1KpVS5100kmqS5cuauHChWrJkiX69c8//6h58+aptdZaS28DmjVrptZZZx21aNGi/G9B3bp19TXYZptttPxNmzZVNQldu3ZVRx11VF5+7vecOXP034wBuc/83bZtW31tbPnr1Kmj5T/yyCPVqquuqmoSuPennnqqWrBggVq8eLGWn3u/3HLLqRVWWEEtu+yyefl5/fnnnxV+z71fZplltPyHH364WmONNVRNQqdOndT555+flx/wd8OGDfV77i9A9gYNGqgJEyZU+L183759e3XwwQfrZ6YmYdddd1VXXnmllpkxD5Cb+W7GjBn6OoBVVllFj/O11167zGccYKMW7KHSp0s5Zs6cqRo1aqT+/vtvteKKK1b78U855RT15JNPqtVXX10rzt69e+vPmzdvrqZMmaI23HBDNXHiRPXXX39pxfHyyy8n7pMHdNq0aWry5MkVXuxDlJL5QnklvefayOTOC0XPhJ6Ezz77THXs2LHS50ySKEm++/TTT1WbNm1Uq1at1BdffJGfSJBh3XXXVVOnTtWvfffdV/Xo0cNL/unTp1eSn894BHzktd8zwdnyM9EloW/fvmq77bbLE0RTIcyfP1/tscce6uOPP9YKAVLwzTff6O8hSEysrVu3VrNnz1aTJk1SO+20k/ryyy8Tj8mxXPJzPQuVn/tlyy9KPw4///yz2mKLLfKEUMBvuU+777676tmzp1YYK6+8surXr5/+nr8ZHxyL7caPH6822WQT9dNPP3nJz1h3yc++kuR1fSbyc4/kfx/5f/31V7XxxhtrsmSC/TN+OnTooD766CN9/zmGyIeBMHfuXD0OOM7YsWP1MzJ69Ggv+Rk7puzMJTxDKG0fee339evXz8su8kP+ksB922CDDfQYNsE+eQYY04x/SDPvhwwZopZWXZBVJM9yAdWOxx57TLXduoO6/b9Pq4ZtNlQr9O2rJ+Vx48ap3XbbTRMJsT6///57NWzYMP2dPSnK5MD/WG1i3Qiw7piM2ZdYvubL/sx8L14CE0wsnKc5mdovPjeJjhANzo39oSy++uordcHN96vnun2kVlprXVWvXz/9WyZISMXnn3+eV7o//vijGjFihJ5EXXKb72358dpg5SB/krwu+Zn4TOXPfpA/Tnb+f+WVV/K/k8mYcxOPC6TpnOvvVm9/8rVqsu4aql7//qply5Zq1KhRWqlAFOT3AwcOVCNHjtTy2zLb8tuKmkkZ+TmHQuQXL4kpP0otTnZer732Wv5cODYv3uOBwcOG0jjzmv+onn0GqOZrNFX1fv5ZrbbaalrhYq326dMnfy+HDh2q7z/KKEp2kZ/9254LzrcQ+Xlx/035gS2/ayy8+eabedJgys++GD+QhlMuv0V9M2ikatG4rpYPI4L7vPPOO+tnHmsdcN9/+eUXTSKT5JffCFDynC/PoEu+pGvA/befKcZT3PPPC/mENJjys0+UNPf/hItvUANHTVSr1g9O8SwieBwyyDJv/3CoevTL/7Mi5vz4jqo/spdm+Ensm/PFM2G/mJDsz7BmigETMRPSH3/8UeHFJGa/tydtJiwmQ6x2Jg6u+fDhw7XinLd+J7VgrV3y287r/66qM+R9/Zsk65L9Jcltyi8ErBAw2dny27LLZ/akzQSL/NwvJm7kR0EwsdbZ6hA1p/UO+W3nD+yhlvR/W7vkIUpxQKYkueXFtSpWfghpkuz8jyfFROPGjbU8PGfcfxQJ9x+ruvFuJ6i/W7bPb7tw0Adqft/XtPftu+++iz0nyHCS3PLi2hcjP0pT5I+TnZftXUBOkR8vA0oYAwAy02r/c9XUVTbPb7tk8Efq7y+f114K8T5FATLsKz/HLlZ+PBZJsvPCU2KCa483keuA/HzP+IeYbNj1SjWxUbv8tqfv3FZdvvcGamnUBVlFIA4ZGywDfvtLdXmkT6XPF31wm5owyD1pPPLII2rvvffWyoKJI2sQNzkTyJgxY9T+++9fIVeB6y0W9Gqb7KDq7HNFpX3U7nW3GvPD/0I2Nu666y4d60V+FEfWIG5y5P/999/VPvvsoydIZOcazJo1K2+5tthoO7Vc56sq7aPeVw+pYd985Nz/DTfcoHM9UAaQy6xB3OSiUJAfIuGSv3m7bVXd/a6utI/G3z+pBn76jnP/l156qc6ZKAUZrir5mUtEmZLjwXvJ6UB+sdybbdBe1Tvg2kr7WHXQC6rvB68593/22Werc889V1v5xZLhqpIfGYVEkJcC4Sbcwng15W+63laqfpfrK+2j2xnbq81bNa72cw/EwY3gB8oYxkytGPcT1GveWrvxUY62m5//iXtnkTQAJjIs7I022kjtt99++m+AFUZ4golFttm6477OfSzTuIX2RqAcbPmxWHFxZ5E0AGQjJNSuXTu111575ZP5UJ7Ij9JkG6zwKPkXrbCylh+PhMDMpyAenEXSAEQ2cnMIteA5sOUHWJ9b77aPcx//1F5By0/IRhSjyM/vJR8gi+B8kW399dfXoUaeA4AXylSaGCtbRcg/beEyWkZCNrb8eH64psV6kKoKnBMG2HrrradDTeS3ALyQpvxss+Wue6eaFwPKg5DjkDG0aeqe/Bsvs1DNrVu3UoY1ypOciEGDBjnjiRLDrW5IMqYdd+f8zclNJg3IA0pkxm8jlFpnk0r7W7nOIjV3hRW0xWLL/+yzz+r4vyuuTkKlT8JmVcjvSsYjqdUMW9jyz540Rqk2m1XaX9Pll6jZK6yg92EeA9nIGeBzV1zdN2G11IhKRuT+YcUJzBg5SmTBtN+VavA/xWJileVzak6DBjo0IN4pkf/dd9/VoQ5XbN03YbXUcCUjivx4HqLkXzzjD6UcTs7m9Wqp2Q0b6tCAyM9vkZ9E0jPOOMOZVwDRLpf8eFVs+ZGdvIwo+XMzJyvV2H9eDCgPAnHIGHDHnbZzW/WYkePQaEJf9f1Hb+i/IQFMBihELGzeY2mSMMlDibI2wcTC9i5SIVnwhWRUE5OMS8ZyJWPiEeG4WBaELszEMkpLSfAc0Kub2m2jXdWA+U0ryN/vw9crJCBKWEay+0kYZFJmYrXll4RNm1RIFrxvFYH5Hm9JkvyuZESOyf2ShEzBlltuqX/zXY9X1a7nb6sGL/4/z8KKE77Tn4v83Hte4pbmen799ddafrt00UxYtRWrZMEXIj/egrhEvKhkRI5pe8bYH9URKI6v3nlB7XLe5mqo+r8Sy4a/f6u+7fFK/j1k2JQfS52ESZHflbDqIhW855wKkR/yF5WIHJeMKPfflh9vBM9D7zefUTuds5H6ddk2+e8b/NZHffPuS/n3eK/MsAzeDHI/eP45bpqEVcakbxWJ+Z57G5WILJ/ZeS08a5JbYY9RqaD47I2n1Q5nbaDG1vufVwqcsUvbsoQpAqIRchwyGNfCKm2z1W5q0x33UCssma2+eOtZ7YZkYrXBwwZZEDe9TOhJCWu8bMVeCOxkxKgXk7dM9K+++qouI5VsdjLFUfyEG7BGmAhn111FbbbTnqre4n+0/Li6pXRUwL4gBsjLZApkQo9K0jT/thV7IZBkxDi57WREykcJ2Qh52GWXXXQlCSEMqgO4p7mVW6tNdthd1V04U33x9nNaUdqkQCZxCBeJlsUmrBYClKBvMq4kI1Jei8valJ+kP5QZ58bnK6yxoVp/653VcvNnaDJBiILnwpaf35NUiBu82ITVQmAnY8YlpUoyYv/+/TVRFDD+KdFFwYviJ9dhjQ231PJ/3f1FnUj422+/OeX/4Ycf8vsrJmG1EDBWfZMxea45Z5Ig5X6BHXfcUV8TxgfPOPeFqrKV19xANVl2kfrwxUfU0qoLsopAHDI4WHr16qVr+cWlT6MXHjZbcYL77rtPnXfeeQW70qUMKqn0zP4MS43JoJC8CiZ66riZKCEElFlKkhjYdNNNdfUELlbOj4l1wIABlYgT1+emm25SV111VcnlT7omWI/IX0heBQmSkAQmUqw+7i0ERFz4TKpUGHAMJlH6GmBRk3lvy3/JJZeoO+64o+BQAuTBt/zQfC/WYyF5Fbjwue8QKXJzqBTieeNzIEqSa4vMJP7S+8NWdBDP0047TT388MMFyc/xuL6Fyi9kOC2Qg9+xD3ITCDOaxFhIosxBnTt31iWM0ixNAGmGgL/wwgsFyc++ORffZ958z7NpGgNpwD6k2RV5P5AGiD9eSMB3hJ74DA/i008/rU444QS1NOqCzCKio+RSjXK3Gb3//vsr9PBn9UDaEdOO2my3Sytie2npmgAW+GHNBlrO0mbXbqdLG2WzZz3rMfCy5afPfznb0RbTdpuloWmzLPKLvMjPol3mNZGVFW35uX6sd1ATcdlll+kW0yK/2UaZNRtM+Rs2bKhbUfMMmPLTitxeWrqmgIWepO223UZcVsM0xzkr47Imh7kdf9O+uiaChb4YzzLPmfdVFvwy21GzSN7SqAuyilBVkUHQ0AVrVJIacV/DzGHkEl7A4ocJ46J85x13mVoWQRiBcswnnnhCy2BbkVgzyGjKj/WFZWrmRYjFgzeGhko1Bchw6KGHqgcffFB7a0R+icuL9SZ5EABrR9rxmo2j8Frg5n3qqacqxPWzDCy4Y489VntJTPnlvmJFY4mbHQjxOuASNxuOcW2oMsAb89BDD9UY+bGkKR2lhBaZJFwi8iM7nhbTimcbXlwrM9GVvAi8EXfeeWelRlRZBblBeEgvu+wyLauEy2Re47mWHAizHTUlrK5QbUCZUG7mkkWUm2WySqa9sBEvltcVFs5yvCxuxSqDvD/vvPPyS01nFV988YVesIjFrN57773czz//nNtoo40qycnKn7JqnvliQSOxzFmOedasWbmjjz5avz/11FP16pNZBqtBsqohljOrOQ4fPjy/ZLj5wuJkgS/T68LfyC/vWY7bXG2T68D1yDIGDhyoV7XEg8ByynjLXMuJM86R37SubflZQtpcbfPggw/O/GJveMdY1ZTFyx5//HG9OFeHDh0qyC6rRHKNTCvcXnr+pJNOqrDa5j777JP5xd6436xqi5cJryqL+nXu3LnSAmZcE66Rubgdn7N8enUvG19uXZBVBOKQscHCg8GkaU+m8vCwjC5u67lz5+a3f/DBB7XLk2Wpsxq6gOgwETApTpo0Kf85SwPLhCmKskWLFk75ZTlpVtaTe4P8Tz31lHb7b7LJJrlhw4blsgiWgGbC3G677XLjx4/Pf/7WW2/lFYMoSu6xa3lhXky8uHgnT55cYbVNiCbXplwu3SRAlFAGuKFHjx6d//yjjz6qJD9uedfy2rwY45DKsWPHVlhtEzc+pOT777/PZREQZchAu3btKozRr7/+Wt9rnm0hCptvvnmFUKX5YjVMruPQoUPz+yBcwdLqkNKvvvoql0X06tVLj9u11147N2jQoPznhNqYF3iJ/O3bt8+HcOzXyy+/XK3nHYiDG4E4ZGywoFRNRSl/t2zZMtelS5fcp59+qh+qCy64oMLvfvjhB61wIB0oo6wAL8jpp5+uZTj77LO1lWRaYMS5jznmmNy3336rz59J0SU/ZAHr5LPPPtPbnHzyyRWOg/di/fXX1/vDms0KFi5cmLvwwgu1DCeeeKK2kgWQPO7XgQcemOvfv78+f+6tWFqm/Hhp9t57b+214Te29YX3YtNNN9UE6rHHHqt2yywunwXviCwBP3v27Px3EyZM0HKR04Ey4fxRHjIGTPlZhnrPPffMff755/o3WNimjGPGjNEKB4V73333ZUZ+zuO2227TsrAE/MyZM/Pf4SFgGXW8LjwL22yzjSZMyGrLj5cK0s3zz2/IA1m0aFF+X7///ntup5120teP43HdsyI/3gXOi/s3ffr0/HczZszQRAKiBJnC04SsyGfLz5hHZohWdSIQBzcCccjYYOnXr58+NiSBCRBX/iGHHFJhGz5nmx49elT4nAfx0EMPzStpU0mVA1OmTNGTAZP5E088UeG7f/75R1tfWJf8DXC9Y5lw/pCEu+++W4ctSJY08eSTT+ptXn311Qqf46o/9thj865cU0mVA0ySTJZMmg888EAFZca9IUyBlSwudj7r06ePPn9+d+edd2plgGIx8dprr+lt7GvK9ROSduSRR1ZQUuUAx4cUoQBQZqb8ECpkw0pmnABI5YABA/T5466+/fbb9XWAUJh4//339Tb33ntvJZIKoeY7jmsqqXKA8cd94HyuvvrqCsqcvzt16qQ9BeKBgghAILhePDe33nprbv/999eJoea16927t97mxhtvrHA8rulVV12lv2Pfcl3LBcYzzyHyX3TRRfr8BMjDvIb36Ndff81fEwgExBHP3M0336znMxKjy0UEA3FwIxCHjA2Wd999Vx+b+B9AERLzNsFDxITCQ2dXFfDdww8/rC1XlC6WSLni2VSDkNNgu085R+RighgyZEiF7/AoID8WNDjrrLO0e97+PRMy2eZY6jaeeeYZ/R2/wxItB7gv66yzjrYUIUM2kIt7hKfIBK525JfPqT6AXNggp4Pff/PNN5W+g1DhFid0IdexuoE3BWLIeeCmt0FsHkJljw0UB/LjWQAoD5SrDRQRv3dd2+7du+vrznUz3eLVCfIXCMswxl9//fVK399yyy1awffs2bPC53hhkF+uGdY6IS5bcVKVwe+R1Qb7xCsDKStX6OaPP/7Q8xbnTpjOBkQaOW3vqMy9EpIgDMl701NZnQjEwY1AHDI2WHAz464UN+Qll1yiLQ6XNYc3AlfftGnTKn1P7JBcCPIFSMorVzx73Lhxlb6XycAVUmDC4DuxlrGqIB82sK6JdyMjk5QNQheEPlA6uPerE3iCIHUoTrGmbMWOjBA8GygMvkOBgHvuuUdfSxtY11jsXBvXNR4xYkRugw020LF/WzlVNXCnSzzbVS7L9ZEEVxtY0yZxxKuCgjStVcB7rGoIArLaIAcCTwW5Hy7lWpXAnU5orVWrVtqD4pKRZ5wQjg0Io0kcZazgTTSBdU5iNPK5yBHjh9ANoSvbM1fV4NwJNzD3fPfdd5W+Zz7CC0mCqw3uO/JyjcyxUi4DKBAHNwJxyNhguf7667VrTnDXXXfpycEFksyIh3bs2NHJyFGouPxg/STQlTOeLSB5j8mMagAXCE+QpxBFpEwwmTA5kTAmyaImpk6dquOirlBJVQCrEPe6K55tTozcT66Py/1Ktr2pKLlvXE9XxQSu6DXXXFMrSNf3KBvyIrh+1RH3Z/9Ykq54tqnQUfb77befMw5vE0fbA2eCEA9eFV6uigpCYFRbcD1x+1eHu5swGuMNUmcmsJrPJM83+QquMW0TR5tI2fJx7xkDrrAEz4RUHdmhkqoC94/nG9IiMpjAyMETST6HqwoMTxPnKwmk4oErV7+SQBzcCMQhY4PltNNO08lCAqxyziUqXs+DRjIdru+oOONxxx2n94F7uKomDzOeHTVJcz1x3zPZRZVOXnzxxdpSFbzzzjv63M1KDNt6gRgR+nAdE0J1xhln6H1QumdbrtURzxYgM+GTddddNzL/4IYbbtDWqkByPlyeC4C1CRHB+nQdE+XENZW8j6oq2TXj2SSDuq4zx0ZhoDhcXjIhjnhY5F5yf9mny3IHeBsgIuTBuI7JNbn22mv1Prp27VplJbuMM5p6cRyeYdd15l5AGCAOLi+ZizjisWGfUY2u8DbhdYKouI5pklnypqqqZBfZpDSUZGcXkedekLuEN8rlJQOvvPJKhbmXkA/vP/jgg1w5EIiDG4E4ZGywYKmSMS74+OOP9bnExeqZbKJc3zJ54Llg8sDSK3XSHEotLp4t50AlANu4XMuCo446Sk+CAqotkC0uVi1Wucv1Lfjvf/+rLWEy+EudNJcUzxb5qarAGouTheTGzTbbrELIBdlImowCrnjurcv1bZa9khNBLwCXJVwMIHXEs9k/x4kCvUawxuNCZ3ZoDg8F8seFWz755BN9b+1KIxPcF/JeqiLvB88WyZwQ+KhnEEAo8f6IG94FQnMmcYRgIf+bb74Z+RvyXLj2ELcorwqeGwgmJculzvvBs7Xvvvtq2Zhnos6BbpGupG4TEpqTfUBI+Q15S+VAIA5uBOKQscGCiw8FYyYZci6uWKEJrGkmT+LLUSAbXWLvper3YNZn24mOdjIYcpD/EAcmYDKpBZwnv0M5xOHKK6/UyjNuUuLaYJ3i9ShVvwcm7bh4toAkN58JEOJI7F6AC5rfdevWLfZ3VC24Kk3sc8U6xeIvVb8HiWdjRUPyoiB5LfQciQOudciNAA8Bv3v++edjf/fQQw/p7QgVRAF3t8TeS5X3A7EjCZNcGknodEEqYfDGxQHvmFlFgpUOIYH4xoFxxf4JSfmca6ladRNCoYyYckl6ckSB5xJiccUVV8TuD+JIbpIJ8nTwmpQDgTi4EYhDxgYLyX6UVAlwaXIuSQleuDaxplHiUW5tcX1i0ZEbEWf5lCKebTc5In8jCST0QYLMOC6/ffHFF2N/xwSL0sWjMXjw4MjtuDYcI2miK0U822zQw6RJJYAPcTzhhBMqyMU1fvTRRxPvB94aPBpxmfS4iPFokEeSREZ849lJVjzJqVwnXPhJeQbk65jEEXBPKU2NA/vFW8Nx4pog8TyRE1OKvB+un48VT4k114lQSZL8hPtM4gjo4UK4JQmEpBhnceOa3hGlyvvhOCj1pOodCAv3kOczKVQKcbTLj9l/nDepKhGIgxuBOGRosDCp8EBjPZmEAEuacEQSUN7Ez1GMceeO+xPLnmNhCVVFPNu08nA9Hn744V7JaXgEsJ5NoOSIfSeB+C2TOBZLXPtdrg2uVRRyIS5Q5E2KZwvwwuDl4XiuZDgbeC7wnpjAmif3IQnElSEeKBpXYppJxqihZ1yZY62QeDYTfVzeAB4jSCrjzaekjr4eXFsTeLNQiklg/yhFShHjFDnXSfp94D5PmzTJ9oQU+D3Jl9KHxAVJ4CW3wxX3t8F2JnEE5DwxznzuC2FOSHGcR43rJP0+ICSFyM/zCEnheHbFR5oEXhu77757pb419LSAdJUDgTi4EYhDhgYLsVJXbTMT4U033eS1DyYMJg4e6DhFhbLDQk2rPHzj2YBMeGrJKZv0SUpjYkV+e78QgUsvvdTr/IiJc71QIHGKimsj6zykUR6+8WwAeeHcKZv1GUucA9fVducz6Z555ple5yfXHAIRd82x/KRZErkRvvKb8Wy8AHG/Y1uIQFTJsAt4zGx3PhYoCXe+94drThJqnKLivKUCCPLrmzQspIvfQR7ifkfCLLkvUSXDLhBGsokjHgg8ET5gnHHNCcfFeQElaVLIrw+ptUkXPUbifoeBQdgpqmTYBcKoNnHEA4UnqhwIxMGNQBwyNFiiEuFQPHSC9AWJZEzsSVZaWuUhMeKkeDZAaeHCTrJ+TWAluhLhKCmlMsQXuKp9XONplQchEJQSFnRcPFuIGZZSkvXrIo52IhyhICzbNHkHJAJCDJPkF+VBQ6kk5TFy5Mh8PDtpOWfps8C25roKcYhKhKNihGvgC+6Tr2sckgZ5xnOS5BGR3hB4wFgfIw4cl3uGty0u98WHODL2eQZ8QTgOAob1nlRF9PTTT2vPG9c4ySMCKZXeEElhHmThvAkJxSX2+hBH5j7mwHIgEAc3AnHI0GCRCgpzEaCouG8SfJPxeMAl2zlOeRCnJp7rk5UuFRQoL7szYhyk3bKduOeK+yZBkvF8vCk+yoM4NWEUn26UUkGBEkiz6JAQR7sfP9a2mTDoA0nGs8M+ccqDcr0o5UElCJYjoTCfxFKa+7BPxrQvpILCjtHbCYM+IBmPe2pb71HXCqLJGIsKOxDDx5Pj242SCgqfpFYTUkFhJxDjbbMTBpNAB1a8Yrb1HlVxARlg9dGosANjnnPw7UYpc0pSbpKLODIeTeBthYCXA4E4uBGIQ4YGC61ZOa49eRPfw3pNA5QXC0FFtSVOozyoaIAE4KKPi+cKSIL0qaCISqK0m9nYvS18gTcFmZIqMpKUB4ocCxarLy6eKyD+6wq5+BJHu+IFzxGu57Qgfo3ypBdGMcoD8oclyD3wWbqZpl2+pM2ElN5SSRTXFM0XlOeyP58kSMYIxJgcAzw/NqGjcoYQgKsRVVR5sA9psz0lLuJoN0VLsyIt++N+JIFjkugIQbNlpHyacAtJ1eaqpFFgvDHuzCTvNMTR9mbZvS2qE4E4uBGIQ4YGCyydh9elAMksTouktsQ+ygPLDXcjHQh98hSkRa5vToYJSs6wkmz3MgqQkEdaiLucaxrXO8JWHrhjRUFSwom7mZwJn+Qu+lgwyRH/TQtKDrl29nUml4AEy7QQdzlKx8dKdikPvECEG1CoPv0vxNL1zckwgXWO/HaFCgoQApi2eZmsicL49Sm/hCBh2RKOkeeFtVAITXFNfBaNgvxwPLxEaZMOpdmXTRyx2vnch7TboDEc9yMptCYEiecMrwphKUnuJbmTa+LT/4KwDOMtqiFZHCg5dxFHKsr43DdPpJQIxMGNQBwyNFgo18MVbIM4tItQ+CBtVrOpPCjXwgrHC+Gz0iYTHx6OpNh6FLAsmaR8CYUPIEBMelFtiaOUB9vjMYBI0ZXQZ6VNPDt4ZgitFHKuUe3FozxRPkDZUH4Z1ZbYZfWKS56upSgBvF0+TcNQsnhmKAsuZFEiLGNIl33tyCdweaJ8wDXDU8S48lF8EEyuFdcAzwGkCSLpQ5pQsnhmSOYsZGVaabdtP6cQWheh8AH3gVAn5Mfn91j9jH2eAeSn5wOVSj5Nw8itwDNEQmghJCeqvbh4okrVeyQNAnFwIxCHDA0WOuuRVRzVGbLQXvtJbYldyoN4PsdECfooAXIAOAZKttC2xsSFKUeMakNbaMfLpLbEru3x0nBMkvJ8lADXGMKFki20rTEEkfO0IQv9+LjJXcB6xtUe1ZbYtT1JsBwTJehDmrhmKBtyYAq9T0IQo9YvKHSlTyxVXO1U9/jIwnUmng+JQQn6zAMoXMgGSXyFdiYVj5M93khK5vM0+UJ27gSVLcwtPrLgbSMswzEp7fapiJFrRkit0M6kQhDtcBhji899vCalRiAObtRWAZkBRK527ehbUqtWrYL2u/HGG6uXXnpJdevWTV1//fWJ2/ft21fNmDFD1atXTw0fPlz99ddfsdsPGzZM7b333mqjjTZSb731llpuueUyJf8666yj3njjDdWrVy916aWXJm7fv39/NW3aNFW/fn01cuRINXXq1Njtx4wZo/baay+15pprqnfffVdftyzJ36pVK33vua9nnnmmPk4cfvrpJzVlyhQt/9ixY9WkSZNit58wYYLaY489VJMmTdQHH3ygGjZsWNB5VpX8q666qurevbv65Zdf1Iknnpgo/5AhQ9Qff/yh5R8/fryaOHFi7PZ//vmn2nPPPfW479mzp2rcuHFB5ynnFXUNCpV/5ZVXVu+99576/fff1VFHHaUWL16c+Dwjd4MGDfR1+O2332K3Z67o1KmTmjdvnvrkk09Us2bNMiV/QOkRiEOGsGTJEufDEfV5Guy///7qtttuUzfddJN6+OGHI7f773//q0466SR1+umnqx9//FGTht13310rUheYYFAaTM7vv/++nmyrQn5QzDXo2LGjeuCBB9S9996r/vOf/0Ru9+yzz6quXbvqCXbgwIF6ku3QoYOeQF2YPHmylh+5P/roI9WoUaNMyr/ddtupJ554Qj311FPquuuui9wOgnXQQQep/fbbTyvQFVZYQcs/btw45/bTp0/XpIlz/Pjjj1XTpk0zKf/mm2+unn/+efXaa6+pCy+8MJI89OjRQ3Xu3Fnttttummg0b95cyw+BdGHWrFmaNP/9999a/pYtWxZ8jlFylkL+9ddfX7366qua2PFsyz5tfPbZZ/p+brnllmro0KFq7bXX1s//4MGDndvPmTNHjxXmAeRv3bp1JuUPKDEiPBFLNcrlniKRyVV2RnIYfRmKBaEO6dvgajdLEp70NJCwCHFbXNBk1NsuWFyK5A/QtKYUCwfRjdBVdibJYT5u5iTISon33ntvpe9o6CQNcSSkQ9wWFzQuW9sFS84E94v4uV1CWwhuvvlmZ9mZJIeVYnEquceu5FVc5YwzclQkpDN+/Hh9T3jxtwni2LRvJn7u26shqYSYnBIbJKhyznGt1H0h95gSRzv0RxUQoRJyeiSkQ8MzxjihGztHgPwJKo1IXPXt1ZBU2cS52SXRhAH5vBTHIF+GEAzJq7b8rGVDYicJxRJuI0xBjgyhO9rVmyCESTMwkoeT+rr4gIXIkNPORWJs8Xma0uZSIYQq3AjEIUODhYfZXBnRnOzIKi8FmCwgKEweUi5ottClhMqeUIjfoxyIX0u1BXFs3qPofCoWfEAlgrkyor20eCHJgTaQTdolmwsHsSofn5FnYstPbJ2kL3o4SPyViZWcAfIayEYvBVDmTNA2ZGnxQpID4xYco4rHTkykhNdWXMTvyT0hfi15FihWckbIa0GxlQIs0IQS8q02KOY40vTMJKeQJpZGt3N6kBnZIchSjgixgmBAdOhxUgpI7xE7D0mWFi9VciBrrNhjnfwCEqFpmmXnWDDmyd3gGZA8E86Rvif8ptg1X+zeI3Y5sCwtbpepVgcCcXAjEIcMDRYa3ZCMZQMFxwNaKvDQ0+wJRcGEyYp1yIvFG5cxj5IkQ52JhExtLC0+LxVYGc/VryAqaaxQMFniVRHPiyhSrkNUAiqTFyQJYoflz/LkVFD49MjwBeTN1a9Aksbs/gKl8rxIszA69EUlz6K0xfNCsuERRxyhK2hQ6qUC5+LqVyBVBaVcDlo8L1xzFCnPAmtERDVAMz0vLKPOWi2QeSoBSgXGoisJWsoUfUpq0/Z44JmjmgNZWE8mKhGaMc+9ZwxQqgnp4JqRuFwqSCm3nVyL19PVUbc6EIiDG4E4ZGiw4CLfcsstnZ0NmaRLCRQELWF5+JEVizsJWJaQBbwPnE+ps5xpdOQqR8UzwjkWWq0R53lhv6JAkqpWxPNCyR0T7QcffJArJaLKUaUxlu96D2k9L6JAkuTHs8T5IT/jxl5TpVjQ6MhVjkoLcs7Rp/lQGkCURX5Ie1LFkXhepOIIt38pIdVTUR1VS+XZEghh5MVckNRyXDwvlKjym6S1WkpVjiodVUsRDkmLQBzcCMmRGQJEzpUAFPV5MSBzmcQvyWRv06aNV3UGLxIl11tvPbX11ltXm/xyzqUCx2nRokX+/VprrZV4jUkw22KLLXRCYNu2bdWOO+6oqlP+Uo4B9kVCq4AkuKT9I/O2226r5V9jjTXUrrvuqkqJqKqKqpAf2PInjS9k3mWXXXTCMM8OSYQ1dfwDZJDj8fwvs8wyideLRGASQakcISmylIi6z1V1/wMKRyAOSylxuPvuu3V1wZ133qkOPvhgddhhh+mqiCiQPU1lBpUW/GbUqFGqS5cuugSrVIjKqq+KieOxxx5TV199tbrhhhvU8ccfr4499lhdURCF+fPnq0MPPVR9/vnn6o477tDVFPvss4+aPXt2yc4p6j5XRVY55bnnn3++uvjii9XZZ5+tM+2pKInCwoUL1dFHH63LTanOQW4UJ0qkJhInylNPPfVUddppp6nLLrtMXXTRRbqiKApU17Dtiy++qG688UatxKk2SCrVzer4p2z0mGOO0feUSivKtG+//fbI7TkHxgsVWVdddZVaccUVdbVJUqlqGgTiUIMQ4YlYqlEu9xSJabT29U0aKxQsfIV8sgAQcU0aPRF+cCU6EXOksRHxZ1oKS6Y7iWEs312q3AMWRqLxjG/SWDHZ27jazz33XO2ex0VLJQEZ9a5FiajmIBGQjHMyzwFuU9zqu+22W0mqPQDJejQqikoaK9V4RAZkZSEu5Odl5rzY4P6SCMhvZOVOMvxx2VNVUWjDJ9faEq4OqYSEkL8UlTuAMcy9ZCE27r2Z8+Ja14FESMYHyZMSniDnhURWcl5KFULC9e9qgEU1AedWisoVGbvMJ507d87nNFx33XX6GISLonKizPAEOS9UmlBxQuVJKRCVBE0Laj73WVyr1AihCjcCccjQYGEiZyK2Qf5BIYvcuECGPvF5JgIzpk3+AKVVkAFIgYDSKM6J3AY7EZDYM2SDTOxCWgz7ds6MShorBCwkRaIpisAkIigHFAnf0alRQLyVdSqYaO1EwC+//FJ/TovlUlR8UNHi6pwZlTRWCMhMl7bYZhdNrsXxxx+vlSPESkD1COSQ+8w6HCaYyBkXrNxZSIthV+dM8ieiOmf6Ls8eB7ov0habjqBmzgxji+RQe3VGtmG9DxQ6BM6OvZPzQl6STzvzJEQlQVO1UUznTLsrLNeYe2Z2OEV+SZI2l/VmjLDuBqTSXrVScl54ZktR8SOt1W1DhATsYjpnFoNAHNwIxCFDg4WsbqoWfJPG0oJkRiytQw45xJkIhfLDskYZMllRPUH/BizLKLbPpM5kRxlbsYqdJYAp+/JNGksLytogYCzY5SI6fIZlLZ4XysK4HygaSEKU9QrZ2n///ROTy5KAB4iSP9+ksbSgnA+LHiLkIjrieYFYUskBGaBPAUQjanls8bzsvvvuRZNHVpNEEduAsBTTcluA4qUyBq+e61oyfklQRkli/XKNsMoZD1ErjIrnZfvtty+aPEYlQUvL7WLLnqlKYREr1p5wER3kZ70cjvXoo4/q+3nooYfq8cAYdEE8L8wTxY7PqCRoabnN/9WNQBzcCMQhQ4MFi48JyLX4EcqrGMDasQ6Z4ONCC1ghKAsULKVnTLRJ9ePSuKWQFTFNYPHRK8GG9BgoBkxwsgBRXGiBSQtlARkggxxFm7SyIq5/LHWaChUDLD4WWIpaprkYqx7XsixAFDeuTc8L5XeQgqQ+Bb179y54RUwTt956q15UKWrxo2JWR6ScEm8OMsWVteJ5gcBzPxmLjIOkPgWMD7YrZEVMEw888IAm9q7ri/yyYmUhoJyS8UyflLjryPlD4DkeYRjGASQyDswPjBNIdzHhRAmh2gQUTwOfl7L02xeBOLgRiEOGBgslUSg2V805JVCFQhZt8l2ACMsMKxNlTQ8FH9xwww36mhVTokd5JNaQDayfYjpnygJEKAKfBYio02ciTFNyJg2kiinRozySVSmjOmcWungWiiLNAkTErCFMHJO8Ax+IV8hsqpUW9NOois6ZEAVyZyAOdvdLF7DGZZEzs0lUHMQrZDbVKlXnTLxaxXTOZB7DIwBx9GmiBUGVRc7IA/IB94j5goXqiu2caS9Eh7fTtdx2dSAQBzcCcchYAyhXy2kmo0KX1ca9ixVLEpO96lyUOxPlxcRBbgMTWZSb1rZUcGsS5ii0NS4Wu6vldFTSmA+Qmd4QyOQTIycBj2slq0licUW5aW35sVRxNRdab47HxqU4pQFWIa5wwi2QMYiTTx8EYtWMQbwzNPmCsNEgyQcoGdzaZo5MGpAEDGG1rXYSVgvtnIl3idAE19UnRwDSwPZ4+Gi9zHFR6L45KijPQptCSUdH2+IupnMm3kVCUxgePp0nJaeH+0CTM46LJ8jHk0Koie3JySkEkgRsh1FK3TkzDQJxcCMQhwwNFhoAuToHolBdlmgSsFDxMqA0sKJ9PBMQBtyZKBkUFfkQvsqDSRpXOJUBhWRak8vhSgKNUqhJIOxANQjubx83LzIjO+fPtWACP/bYY72VB5M0HiNIh8/1dlntKB7b4qKjIgQurRuc/aD8UBokxfmQTFz5nD+Jf+Q8nH766d7Kg+ORKErMvxC3etTy6aJQ0zYAw23O+GVM+STWSU4PpInt+T1NyaQCKUl+tifpFG9VIc2aJJfDJriiUNMu1835Mn4Jf/is82Dm9LA9v2dOEs9DUhiC7cmRYawWUgEhuRzDhg1zVtUU8kwVi0Ac3AjEIUODhTawWGz2A0rs1JX7kPQQ00IWy8EnqQjFAmnB2jYnLpQHnhBf5YErmP1wvmnLNMUlb8fyiZ27Qhhx4DypUsED4DNpouhwZUPQzNbG7Ieuir7KA3c6+0EBpc1JEJe8HYNmDY9CiCPlrYynqMRGE+PGjcutvfbamjialrmpPKh6SVIeKDc8PBAQe82BJIhL3iYdEEdX7kMSCDNAxFwltja45lQHEKKwLVtpT02baZvUuSx2xir3y8fD51rMyo7l44lB+acljngq2Z+rxNYVzqE6BNJnrz3CvMR1JAE6ibxhbLRv314nYaatgpHFrOycGinHLmXnWF8E4uBGIA4ZGiyyJoHtksWKoyQsDSTnQOru40BLWyZmJjxXHDmt5UFvfSY6kj3TTHayJoHtkj3ooIN0tUda7wX7koW84sBETVkZCi+qV0Aa5UEsFiuXe5YmWUzWJLBjuViNaYkjCaW+OQeQRqo5CGlFrfJJuMhXeWAx4uWgeiVNpYmsSWAvZkTuiytpNg6SUEqJZxLwLpH/gbKL6pVA7gokjNLjpFwTPFd4yHbZZZdUyg7yxjl/+OGHlXJfXEmzcSC8yP0ifOJzXKqZmAOi8ghYORQSThlrUvUEniu8nHg70+TlQDqR3ywHltyXQohjKRCIgxuBOGRosNAnwdWTnoeaigNfiGszbtEqMyGJCQEXe1IjG7E8WOAoaUKUZi5UhPiCtSBci9ngPoWEpHH5cp5Y6kkgHotXBmsrKWs/jfKQuDyNdXyBp4Pf0B+jGOKI5U5OCArXR8HgWkcxJ7mCRXlwPklJtshAiIvyPl9g9boSbCGOKCxfCHGFcCURV86T/CFIY1LyIdUzjBV6ICSFDfBykR9zyimneJNnrHUX2SVp2lWmnURcuW5JxJUyY0gOxATiFgdyVwhjQAiS8k0I9XCt0pRpsx3jy+wjEVdtVR0IxMGNQBwyNFiYuDiu3WiI2nZYtw9wMxJj7Nq1a+wDi9WM65nj0bHS1zLCg+GrPFDcKHDptpgEvB2cj52MyaSG1eUDSBeKEOUeN2nyHaEHjse18rWMRHmQOJnU9EcWUbItqLgcEbaHdNnE0YcEANz8uJspu43zjDA25Pwoo/OtwYeUoDy22mqrROUhiyjZjYPi7gmEx65kQWmiPH0A+SFHAyIcFypDfiphIDfkgfg2cILUcn25J0mueHGxU2bpCzw1diULpAkS4ANyi8jR8QmV4ZXieuMZ8Q2r4J0jnAPRSlqtVAwYQpy+IFRmV7JAmplvyoFAHNwIxCFDg4XJm+PiZhWg0H0nX9zsuNzJCo/LwMezgGLBen7ooYdSx05FeWClx02euKnJzGbbJGtGtmciN9v+cm5Yjz7JiSgySAZVAXGKkPvKeUFqiAOnld9UHnGVCuwX74xvngmA9NheGty0Pt4jlB85Kuutt16sRYxCoQJGPCJpa+9RHihn3PtxTYmQH4sby9sOP0SB8Wt7aXyJI/ece0/YJa50k2cDIoL85K+kbdzFWEbBcZykJEhaWTOmffJMANfU9tJgbfsQR+SCZJFjFFd2StIveUPIz/9pG3dBTql+IrSTlHQqy7f7VGYBkqvpamuCMB3eo3IgEAc3AnHI2GChnNFc4lrinklLOJsVDXEud+LZVA7gxZB1JwoBJZfEMZk87GQqE3glULAcM67xjgBrhiWuk+KeNrAucSGj0LhmcZMeiXs0w/L1hEQpDxLgcPPGJV/iycA6R9H4dD7kOqHMbOKI9RoHvAtYphCaOGUO0aGxD65sn/yXOO8YBAU3f5xSlMoW7qtPOSjnRiWHTRxJEPStaCDkFQXuAcSafdqenTTAs0FOEMcjqTUKkBI8Glwnn3JQxvDRRx9diTgmNVfjOvE7vI1xzyOeBcot8TS41uXwBXMMIQtIsd2K274veAwYbz7llOTF4C00wXPmE3asCgTi4EYgDhkbLPZDIglzcb0RmDSk7CyuSQoTHBMdijwqCS4NZBJmsjK9JDY4FkSFBaGSrBvbupKEuTjljPzkQKAM4noooOBQrLhZS7FgEJMwbl4s6rhyVbwyEKwkT5DLukJB+RBHuv2hDOLIoBnPLkVNPB4OlCKeKzxCUZ4bX08QIAmW0IlNHOOUk3TdxINkr6dhAoXKfUgiu75AFs6V49LDIEp+qkvwBDHuknIjbLe8EMekcmjCAUnXiXvOfWAMRLVQTwNIMWE+aZQV5bnCwwUhTPIEAZ5jc70erinzSxJxrCoE4uBGIA4ZGyw8NGYiIC4+ziWuLwKubbaJKjuTeDYTXJp4tg9QhJSLcnwm76jJgxIrFBulnXEghAIJMhOyktrtSgVBlAWJ/PRCSBvP9gETO+sbSLliVF6B5J4ktSXm/pgVJNL8Jq7drlQQxHW5lHg21mbaMsE4YFHLypKEJaJyZfAC+LQltitIaBXOvuMUnTwjcV0bGRsQS56vYte8MIEsKM2kXBm8QJBWvEJxuSd26TEhB/Yd5x0jJ4pnO67LJQmnGBYocB/Pjy8Yy5CmpLkFLyDeQDwqcflUdukxpKuYplLFIhAHNwJxyNhgwU2Huy6pt4OA2DHfR62TQAiDfg6FxrN9Jw8Supg8OP+opElZ5TKuRJAGMiQeJvV2EKBQUQhRhIQQBkSMfdDMp9iFqKLkJ1eE+4BiiCIm0uAoTsHhpmdyT+rtIMBzgkLATe0iJMXGs31BDg6eF8ISUUmTPm2JCdMQrvEljnizCAMQpnDJz/2WPhyMg1KsYuoCig1iiPs+Ku8HBc8YgWDGlVGjYJN6Owg4FmEgvBSusc3zLktmk9dSilVM47yZkJ4oYkJuEInVspy7C4RpCdcm9XaoLgTi4EYgDhkbLCQGkatgJhfhWnWBCZo8A1i8SyHA8smu5kEsJp7tC9zEJELGhUKkLbFdOSLAesWla/ZPiFrgC2sEJcP1cikELEssTIiF75obxQCZJBRid7/zbUvMJE+CoL1Oh0spQAppWkTOhsvSK1U82xeQWJRYXChE2hJHtfHGe2auBBtHHCGF5I9gobrIGp9Bwrl+eJxKsSx7HEgUTMr7gWAiD11CXbDvdxxxxHMBUeN4rhCAhFKkNLuq5SdRVEIhUaFFWTqb+xHnPZPxLE3Bil0ZtFAE4uBGIA4ZGyy4G0mkE+D+pXrBZUng0iZxytW0iAeXB5i4YnUuDkPyJRnX5DTQQjauLbFrMsAaNxf0somEgEmQeDDbunr4m/HspNUtSwksY+LZnJfdj8GnLTHhBtPDZBMJE1jQkEJXxUqp49m+gKySy4AXxJVJb7YldilX6f8hK5jGEUfq+7FgXZn9EDfGDd4I132oKph5Py5yhPx4lSBzLita+n8IEYgjjoQGGSuu+wtxJ18oKXmz1PDJ+8EDhEx2oytzXQ7pqWETiepGIA5uBOKQscGCRcJkKNYBSzzvu+++lbaTnAXXpIg1w4PLA1zIwkDFguoJEiGZHJn47fCItCVGwdptiWl+w7WXGnwayCBHVI8A15K/Es9mAk/b9rYUQKZ99tlHT45UiNiTvrQlRrHb+QbEopFLKlBsD5S9kqDLk1JV8Wxf4B2A1HF+lFHaMf24tsQksPI76REAcaREMapHgCuvg0RSiBuemHJYqmbeD2EJO6aPdxBPEKTf9szhzjebwEEcXevXkPMQFfbCSoe4443zWaOk1DDzfhi/dt4HzwNzGpVNdpIycptN4GwPVHUjEIeliDhggWPVsFgNzB/XeZpFV8o5WMTiIJkMUsDkR4Mme2JAKRHGsCckKhKqOp7tA44tsWXIj12KSWkak/thhx1WwYUqbaepJuFvlCY5GibwIECMLrjggsh4NnX6VRXP9gHnwqQPuSPh005uRaGjOJhATfmliobYPi8aGUFCbG8C49oeF9UVz/YB50K7ZyxiQml2XwEsc4gDCtQkVlJF06NHD+2x6tChg3bHm4AM4IWgR4Z57cxcG8ZcOZ5f81wgt4xTwim2V4zngRALORHmcyrl1xAjPAnce8KNJtiGuQ0ZTVJu5tqwsmlSJ9iqBOdCThPjFJJsh+64N8xtzM0msZAqGogxnXRpfMUaKuVCIA5LCXFg4OGex42LgoHRo4DTrGVfjsFCaAHrDEXBseWF1Y5y4eGj1JBYJxYIE6o54WK5ipWPezMrQAEwydFfgonAlSz4zDPPaIVJJ0cUiS0/lRBMMr1799aTIfeX3AXTkjPj2SRYVXU81xe4Xkl2457Zy01zbZCRFrskvxGmIvxkyw/xwOr+6KOPdOIp3hrGgznh4sVgkq2ueHaavAdCb1jAdmUABBglTykhliakB2Voys/9ZEwQ/iL0gcyEQrgGZhIun5MgKtU9VZEEWwgwWCAIkGS7lTbzE/eX80WxkhhJGItrYl4DmjrhneJ5Ycwz9llIzSQGfE5YM6m6p7qBAYRnEQ+YvdgW3+EZpJQYYsW4xVPFPTflZ04sFwJxWEqIA+U8WDg1bbCgGDmmOWnIA4RbV75jwkARmRYsDyATCxZsubKP40AvAh5+LCFcq6aVxGTPpIIijJKf8jz5jEmY/AizyVO54tm+gOxhASIbytFUaniGJKzikp8X41k+w/2M69ZsJlSueLYvILWQX+nUaFrYVANJ22Nbfv7GYqfKRj6DQHG9zCZPeBix6mlGhHLNGiC1ErohL8NshS0hR/J+bPl5Eba05ed6QbQFzAWMEa5VUqOwcgBSK6EbFomT/BVAO24+l/FhkwbuNWGPciEQh6WEOKCAWU6YXgAkhhHnjcpgztJgwRq1Jw154aoz30vWOlYlpY24A7HCyhHP9gXKAo8K549nAGWCVUQogomQLoQQC5f8KEXzPcmCWHLIz0QJ8ShXPNsXkAXyHZgY8QxBJiBQKAXkx6JGSbjkRyma7yGI0sKZBDys2XLFs32BrOS7ICsWNMSP+4fC4L5TjYDit70NQhxNhYK84r0htIc3A6+Gb1vvckDCCNxjkp3FA0oYDtmYqwi/mHOAPA+Earhu8jnjXbw3JBhiSPCyPXpZk5/wA/eY8AT9OQA5EMiPMcDLvM/ILM3FyoVAHJYS4gBD5YX7D/cvZWgo1rjllbEAGCDykqYr1R0jRbGYE6dMHGTO2xMq34klTl6DyeKzDBLXUHwoCiwJmSiRCavclFO+Y3tbftMSP+GEExIX3MoKCLcQtqBsEevTvNeEn1zEgTCPfV14iZVOAmkpm1pVJUh6Qx7CVxB8kUl6QLjkh1S6xoVcL9z7pWxqVZWA3EDySAxkTQrTswChcsmP8RMnP+GtUja1qkpAbiH5zGn0VRGZmKMhyC7jKap0uzoQiMNSQhyYgOwlaImhmW1MbUhCmf2qbuKAVSYubY5PWAJL1GWFwcaZfH0Xj8kScC3jaTDl4r6JdSnyQy5Qsq5Jk+2ZfLPomk4CrmVXLgv/E88XGbFCsS5Na9OUn+98V57MEmSRNdd95XP5G88ChIoQjP1sIj8GQiGLtJUbzCv777+/c84xc1zEYIBkuuRnXJAMWhVN3aoSJO1Cdl3y4400yRT/l5MUBeLgRm31L0OLFi3UhhtuWOGzDTbYQP3222+Rv7niiivU33//nX+NHz9elQO1a9dWr7zyilpxxRX1++WWW06tvvrqFbapX7++/h8Z58yZo37++WdV09CsWTO1cOFCVatWrfxnixcvVi1btlSjR49WK6+8sv5shRVWUK1bt85vw/Yi/7rrrqsWLVqkBg4cqGoamjZtquXlfguWLFmi5ed+MobBSiutpNZee20tp8hfr149/T+f8//333+vahoaN26s/zflRxbk79u3r1pzzTXz1wk5//nnnwry8zu2qVu3rvruu+8qjKOagIYNG6o6depUkH+ZZZbR9/2LL77Q85U8Jzz/U6ZM0e/ZHpnZdo011lCNGjVSX331VYX91ATwDDO3mefN38j7ySefqM0331x/xnuegVVXXbWMZxvgQh31L8MOO+yghg8fXuGzESNGVFBANpZffnn9ygJWWWUV9fTTT6uuXbuqmTNn6skUcH5MFDNmzFDbbbed+vbbb/XnTBwuoJimTp2qJ53JkydHvv766y+9PZOv+eJBTnoPwWGyc7142CEArkn93nvvrUR4UJwTJ07UMrZr1079+OOPav78+XqiBMsuu6xq0qSJlol7/M033+jPmWhdYH/Tpk2LlZ3X9OnT8bp5yWu/RwG45Ja/OV+X/I899phWeC75+c1qq62mzx1wPQDKgn2zDfJ//fXXifIjW5L8HKdQ+Rs0aBApu8jvUmovvvii6tWrl1P+5s2b63HFfWfMsw+eZ/bDdYHU77TTTlp+zjtOfsa2j/xsmySv6zOR35ZbXhAfl/zdu3dXb7/9dqXn9Y8//tAyCkFifKFkf//9d/0ZJAIDCPkZ/5y3XAd7nPFZkvzMDTxPQmLTzgGcW5TsfM5cxri1wb1/7rnnKt0vzqdVq1Z63mPf3Hve1zRiuDTgX0ccLrjgArX99turW2+9VR122GGqX79+6vHHH9evmoKDDjpIfTF4nOp44JFq8933116QwYMH6weJyQSrTNCnTx911VVXqXHjxlWYFJgQeBhN8DAyMcurffv2eeXOtv8/dJV/2Z+Z7/kbEsNk99NPP+n/OU8TWBWuieXXX3/VEyQTBZ4HE3gZkOn6B59V9z75ktp41730fn/55Rc9UWOB8L2gf//+6uqrr64k/59//llJfvZtyr/VVlvllXuSvC75Oa9JkyZpEoT8XA8TkB1Tfvkb5YcS4BwhRzbwIlx+56Pq6Td7qA477qBmz56t5Wd/kCohTWDYsGFafhSKSRL5G4VgAmVkyr/FFlvklXsh8s+aNUvLPWTIEP2/kFABVrXIbF4Hzg+LmXO05Z87d66+nmdfd5fq/tm3arttNtGfDR06VB8Xa9Qky1xLPIYc31aK4qkRQEZM+TfbbLO8ck8rPy+Rn3NjHAjZE6A0OY49/rlOKETOcd68eRV+w3d8ftyF16kvBw5TG6/7P8XJNeZa8cya8rP9ZZddpseSLb/9bEHETPk33nhjLT/n6ZIv6RrgCUL+kSNH6v+Zc2z58RrY8nPdMOQ4R+6tCa4jv+ty8gVq8G9/qtVarFTp+QgoP2oRr1D/MvTo0UNPJgzoNm3aqAsvvFCdcsop3r+H8WLpoRgkbFCduP3DoerRL0fn3//93ZtqMzVWWxcoA/uW8TDi0jUnBfPFw8v/4uavKhA64cHnxURivszPmNgEYlVAYJhQ1l9/fTV1tR3VkFzL/5P/2zfUpmqsJgwoA1t+5CN0ESW3vCAeVQkmQWSLk13kFxlw2zOJIj/Xj2sxd7291KCFzSvJj5diwYIFleTnGq633npaObvkNuWvSusNxWbLGvVeZOA5Q34UGEoUK7X25gep/vOaVJB/4yWj1Q8//KC3seVnH4Tuosa/vCDdVS2/ef+jZMezIjIwv4j83FvOseGOx6h+/zSqIP+GC0eqQYMGaRJpy89vkF/uf9SLY1Wl/Jy/yB83DpBfSD1jkrCThO8gx832OFV9+/f/Paun79xWXb73/8I31Y1y64Ks4l9JHGryYBnw21+qyyP/Z1ELave6W435obfzNz179lR77rmnqglAuUJgZNjhlWBS472O5TZZU7U47p5Kv6v31UNq2Dcf6b/FQyB46623tJemJoDJEc8Hk6wpP0D+3MqtnfKv1O8J9dNn3Z3yP/vss+q4445TNQU8Wzxj4pVAfqz+OPlb/Pyi+u79VyvJz98PPPCAOvvss1VNAd42lKcpP1Y2XoPFK63hlH/NEW+oL95+rpL8XLebb75ZG0o1BZBcwsemV4brgMdiUaPVnfJ3O2N7tXmr/+XGVCcCcXCjZmXVLAUYM3W28/Mpc/+nZMh5wKI0Y6dYYjUFuMsl+Q2gQInh8uLvUy68yvm78TPma2sE70pNlp+JEq+KAJlxt/PCYj3+nEudv/t18sy8618UTU2UH2yyySb5v/EgTZgwIS//kaee5/zNz2Mn5/M8RNEAFGhNk58QiVj+Ij+hJkj1Qcef4fzND8N/02Me2bkGPAsAy518oJoEwk0yfiHSkCjkx+PW+cgTU82LAeVB8DjUEI9Dnc/uVa0b/C/GSCyVmL5YbYDzjUvUk/fkCFSFu5IJwJWMaCdnMkmaoQoTm266qZowb1lVv8v1Tvlb1f+fe1PkN3Mq7ERNl+z8T2igKuR3JWO6ElOZJHHXurDRRhupP3MNVN39rq703bK971Or11ukz524NhMtyY8CSdR05ZSYn0UlrJZCfknGjEvIRXbGgAsQqlnLNVF19qlsPS/3+f2q5fILtMIR+c2cgqhERVfCZlXI75OMKPJDkl0g3LigYUtVa6/K5HH5Lx5QzevM1YSBXBqIFh4KgStR0TUWohJWSyE/55UkPyGLqAo3QjbLNFtLLe54YaXvgschWwjEIYPuqVveH6Ke+Hps/n3tYb3UmHfuq7Qdkwg5HBdffLGetF25BVLKZiaIyYSC5c4+zGzpqL/t9xLPj0tGtJMxJVEKN+Vrr72mt0cR4EnZdtttVe/evf+Xq7DXaeq3+uv9346GfqLGdb+/kvxYnUw2yC+JanZc1SRXkiAm8nNOcfLHXQ9i7bb8djKimYwpeQccm4nz+eef15Mt8iPHjjvuqD799FOtPFbZ4xQ1sVG7/H5yQz5Sv733UCX5+S1Jlpdeeqm21lwx5aiEVXlJWZyPzObfEs835beTEc1kTFN+tqWyRGQAHTp00Nn2bdu2VSt3OFFNabJpfj+LBn2gJnzwsFN+7iP3n2O74umuhFVJWORcGA++Mpt/SzzfJxnTzDnhmIzJBx98UG8jSnz33XfX8jOeV9r1eDW9+Zb5/SwY2ENN6vlYpdwGfsv+LrroIv3elVvgSlg15eccC5GfxEtTdl4SfjPHmivXgu3uvvvuvAzMA4RaP/vsMx3GWXHnY9XM1bbJ7+eMXdqqyzqFHIcsIRCHDBIHsrQ363igWmmNdVWj2vPV6O8/00lzY8eOrTR5rLPOOjrjXly3NiAOUYlKMtn5ZJDbn9kZ6q6ExKhkTHIyOnXqpCcgwhYoXM6Fa83/WEVYnk3W3EAtN3+G+mPwt1r+UaNGVZKfzynXk7JNGySTibyuJMUo+ZOuiZ2hniYZkyRPSiqRn+oC7h1WKN4QzgnvwfwGLVSztTZSS/6epGaMGqgnVKpRXImhfM5v0iasciwUgG8VgfneVgquhMyoZEyqJghX8B3Ki/vOvWUfeGS0Mm/aRjVfZ2M1d/I4teCPETpp0iU/zym/ZcykTVjlJcmmaeUXAhKXjBqVjMlzDOHnO5ICkY0xjDJnHECI6rdqp5q22VDNGD9CLTNjvJYT+W1ATkkCl7LtNAmr/M/3vs+8+V4nMTZrFil7XDImxJHfAcY8zwBjgv8h1fym2YbbqIYt2qqpY39R4378omyJieXWBZlFRGOopRrl7hb2xhtvVOimRpc5uunZaznQRTLNcuFZAe2B6QZI90hkogOkKZfdeli67El3SfOVxUW9fBb9oSsiyyXT/Y81CkyZZMEr6RIqK0bSKdGWnxbeNQ2sW0JXTBY2QyaRXzpGyoJn0jGTpaXNTormi+WnaxrodEnb7Xbt2um1G6QzpsjPQlbShpn/ZQEs+znh9eSTT+ZqIlgxk9bTyE4HVFN+Osbyv4wL1h0qV3fQcuuCrCIkR2YQeBBMC/L999/XCUXSNc8EJXo1rTCGsAIW54ABA7S3wQynYG0hJxat4L333tOhDAkrCLBM6Glhh0iyDqyXLbfcUsuPxwOvgCk/Fo64cKW8mKY/4ia2ez7YIZKsg7Da1ltvrcsLsfjxCgEJ3WCBA3H9f/DBB6pjx44VQgFyHejjYfcrqCny05uBkJfcf2nkhHcJSI8HuiniyjfHichP51RXL5Csj396iOBZRSbp5SDzmDTrY54Ab775pnr00UfLeMYBlVBu5pJFlJtlsmIeFplYnFjlLVu21BaHWGEbbrihXtyKv1myt6YscvTCCy9oS4IVPrfeemtnv3rWa2DFQ/GwcB1Y6IrPpH89v5dFglhhsaYscvTmm2/qVQCxqszlks01G1ivhCXCRX4+496zKqh4HRgPLOTGtWGxI1bbrAlgVUfWXuBlr1chYx35sURNDxtWaevWrfNWOOu0XH/99fp5YH0Tlm6vCWDBJu4dY0A8KfaaJVwXxrm54BP3HU+EyM8zxJLc9mqbWQerunIfGc8HHHBABU+DeBUZz/by2lyXH374YanTBVlFIA4ZHCwsO2u75ZlERdHy3cCBA/W2b7/9tnZ7t2nTJtNhC9zTZ5xxhj7/o48+Ojdjxoz8UtOuZbRlgjTll1UC+ZtVFs3VNllW+auvvsplFcgqqwFC9FjoicWJ7r777korArJKoO2WR2Zc2xKykhUDP/vsM70QGMsql3MVwSQg67XXXpsPPbDQF+7nRx55pJKSYEE6e2ErZGZ5ef5ne1nczVxt87333stlFch6++236/uHYmQFXj5j1V47BMmqr64ltln0DqKA/C+++GKl1TYJcWYVyPrggw9qOVjgbcyYMfrz119/vcJcJ6u+QhTNccHvuM/VbSCVWxdkFYE4ZGywLFy40BnLl4eIeD9KZfjw4fnfjB49WpMKfnffffdlbrXAKVOm6LwFzu/xxx/Pf855HnPMMZokoBREVtdqiDK5HnTQQXo/P/30U4XVNrHe2ea2227L3GqB06dP16secn72/cFrhDzEfEVW12qIIv+hhx6qx8K3336b3wdKmDg4ky7KGZKSJbDkeZcuXfT53XrrrRXkv+yyy7Q8kGWRFYs0Sn68cfz/6aef5vcBCdtvv/3055AzSGqWwJL3shrkVVddVWF84jXg80033bTCMuI2mbTlf/fdd/P7YJ467LDD9Odnnnlmbu7cubksYd68ebmTTjpJn98FF1yg5zjB/fffrz83V8vlWrg8Dvx/xx13VOu5B+LgRiAOGRssuBztCQNvwtVXX62tLCbhddddV7sn58+fn/8df/NQ8psDDzxQK6ssAM8IioDQi+0RILGL8yV8wflfeeWVud12262S/FgauOWxqFiSl+Q5QjVMyAImI37PhNupUydNVrKAoUOHahczrulPPvmkwnevvvqqlhGrm/O/6aabKiWGMmHiUUDBsj0yY5EzJszxiTJCCTHhEuqZMGFCLgsYNWqUJgVY0KayA3gIkJGloSE7d955p7ZGTQsc+fEoXXLJJbmXXnopN2fOHG2x4+6fOnVqfl+QkXvuuUdvz/UZO3ZsLgvAs8CzShKknciJt4j7Bdnj/rFEOOcuyYIiP2GrCy+8MPfcc8/p8Q9JImxn3mPx3hDSIOl25MiRuSwAUksoCU8J3hUT3333nSbNzFuc/1NPPaUNIOYKU34MifPPP1//nvmvOhGIgxuBOGRssFAlwLGff/55PTHi1iWr3gSxPh64s88+u9Lvu3fvrpUUOQB9+/bNlTuej3eEiWzcuHGVCAWehlNPPbXC5/3799fyP/roo7nJkydrCwvXpYkhQ4bo3x533HGVvCs9e/bUEw+K5csvv8yVO56PCxmSY0/keIyYELFETRnYDvnvvfdenbeApYbisZUxipiQh+1dYfwgO9fg448/zpUTeAUIIeBK556ZQLEzTlGCpgzIjPx4JlCM5513nibKJvAwoTghiLZ3BWUEUWXfNlGpbnzzzTc6hATxZVybQE6+gwSZMkAMkP+aa67RpAODgdwWE+Tz8Bkk0zQewIABAzRRZXyUu+KEeYoQIsTX9JCJl4jQC0TJlIFrAXHEc8ScQXgHWcqFQBzcCMQhY4OFh51jSywPxYobzwaKVRSsDSZlHkisDwhIOePZKH7TMwC4rkxu5CzYblWULb+TZDcSINnWBjFetrvrrrsqfYfCgWxgrWCFlTOeTWjJHkdYzeRx4JK2LSjIDnKJor3uuusqKQ7QrVs3vR3f28DbQmgEa5YciuoOXZnxbEIoKAkTKIr27dtrBW9/h+JDLiG93F8Ilg1IEftnfNjA24bXjf3gxSlH6A7rGXJPvgIE2ATKEa8QChWL3OVxlHyVxx57TN9HmyDhvWP/p5xySiX5GFNHHHGE3s/ll19eltDdK6+8osk9HgSIngnOB2MIUmkbFFwPzpvxDfAy8Z4S5nIgEAc3AnHI2GAhBs4DJ5MBlgcZ+C7gcUA59u7d2xlXPPHEE7UcuHmrK+5txrNvueWWSpMa74nTY0W43KlMuJyzWCG4sbHaXWBSZFKFbNggzn3OOefk477VFfeGFHTt2lUfF2vRNWnjRcB1PWjQoErfkSzGbyXU9PDDD2sF6doP15dt+Y0N7jfhDb4//vjj9XioDnDfTj75ZGc8W4AXAaXn8oiR7GoSR8JYvLfJJ3jggQf0d88880yl7xhnknjrIq9VBeQ999xz9XEh/bZHADAuGLeff/55pe8gBCZxJDzJe5tgmM8K18ElP6SL4+DVqS4XP+OO51KSoHkebJCnwPeu5xZPJN/hOQIQKN6Xq2okEAc3AnHI2GBhsid+LSDuySTrspqYpChdw22L+9oGv4GIMHlQsljV8sTFs015opQdIE5PTFtAXJftXQlfKFMmRYiF7QoXYLFBrnAJ29ZtdcazBcRpkefpp592fk+yGJ4iud9vvfWW3t5Vbso2hDo4Htn1LqB42R9xZpfyKSXYPzkKxLNdylzCV1HKzkUc8SzwngRgl/xY3ByPMj8XuH6Ey7gv3J+qBKFFnkfG23//+1/nM/vRRx/lSbULNnHExc97MxnYBLkPEMuosBREjOeDihzXHFFKML8wzzDfkK/ikh9ixPlCLlz48MMPtbziifj555/1e8I+5UAgDm4E4pCxwXLsscfqSd7uIhml9PicigQmhqjzZbKiZJNObVWVNBUXzxZQLsokjycgClQZ4MY3zx35o5LdsKQgKxzXTJYzgWUHuWKbX375JVfd8WwBkyBKHg9AFJhQyU8RoBCRf/Dgwc7tsehwBxNLnjhxonMbrDfc4nHnViwgLuzfFc8WYDWixOI6AUIcuVcCFCbyR+0TgkGsn0qUqDFC+IN4ety5FQvuT9u2bfW5uzyAAOICKSY3Iyp8YBNHCBPyRxEDLHz2RwKlWWllgjHP2OfcXF6OUmDEiBF6fmGeQfm7QAiN/BsqoFyeKAChNokjv+E9ZeflQCAObgTikLHBsueee+qkNzvmHafwyNzngSVuGBWSGDZsmE4yQ7mbpWyljGfTuCaK4DABSNOnOLc55ZZcg6iYtwtMrkyKVGREhSTYRrwhLhdpMcBKhhC54tkCclbIaeAc4tzmJHxut912lZIl4+4ZOR1MyLSqjirFE28I1jdWfylBtQeEyBXPNpP+KLOD5NLDIwqE37hGdsxb+ja4gDeGscX+o2Lh3Be8IVWR98O5kYcB4XV5RgD3hfsKwYtrVkb1kEkcGStSeRQFriflvDzfUdVUPJfiDXHlRRUDEpIhLoxv5hkXeC45Pkm7cRU/eGJM4gjBYm4pR64SCMTBjUAcMjZYmHywugVYEZxLlBUjgOXjIrz00ksjt2FSQSnzIOJKLWU8m3KpKCsCooBSjbMKBUyueF0EWNF23boLVBMwKdJkKgp4J2TdjyhXahogL/H6uHi2bMd1j7MKBWxHjoh5zuz/5Zdfjv1dv379dG4MceUoufBOSNIcXReLTZrj9yi6uHi2bIdMlBlGudwFkGYSKgUQYcY1Iac44M1BeXOcKLlKnffDdSb5kv1BeKNIi/QrgbRI7D4KeKNIbDaBXK4kYNvip5KE8RP1HKK8IWacL3NMsXk/UgLL/dl7771jCSF5RlH5WCY4P7ynJvAUMV7LgUAc3AjEIWODBVcm7loBDyPnglWXBEr42Ja8gCgwqaDk2Q4lW+jk6RPPlsnlhBNO0Nv5xCmxtsjzMM8XRf/EE08k/pZtkCuOFJnKDuu+0MnTJ54tIDQDWbP7OEQRRyZZAfvFmufe+mSyJzXJYX/SdIgk1UKbBfFs4OGKi2cLpL8GpcJJIExnEkcA4STRMQmQS45D8mEUOE+upeT94AkpBPyO68d1vOGGG2JJGE3JfMgfoBrGJI6AMANEJwkkEjLOILNxwOPAuGX8xin7ODBueH6QC2Mlbh6RvCaz+VscccRzaQJPUpxBUJUIxMGNQBwyNFiwWDkurm9zosNSiUomM8G2WFQoaWnJHKdkmWSYpNIqD+LZUfXZNlAq0pfC5/yxmknotMlUVDKZDSZN5EoKx1DmRdIp8eG0ysMnni2gKkKaPPkAVy5WrE2mIDs+QGmiPJM8NMSMISSUraZVHmY8O2l1TqmKoDrGByQG214zyJSrZ4kLlMH6KGlyZ7DkKQtNu84JXjOUGR6UpNg730tfBh/Q3MwkjkKmUNI+gMT6KGlyHfCAIUdUbkwUCDUQFuNZldbXcWEMnkcqbHyAMYJ3xgReFDw65UAgDm4E4pChwUIJGse1J2OSzmhV6wMJC5Col7TwD5370ioPrNqkeLZtAfoqPfIAkN+uSKCBEiVuPpCwAG7bpERQLLS0ysMnni3Aw8CkGZcMagLvh2upZCZpCKEPJCzAOeK+jwMeIK5TGuUh8Wzi6VHxbAHkFRKL+90nLCTE0fauYBlj3fuAfRA2YT+Eb5IaFEHUiM3b/QTiQmL8BoLjKqc1QSIqOSUkg/qGhVzEkZ4UEFxfYJ3jUUhach4CTKk3svgmTZNrRD4Nv0taG0dyr2hi5+vZhJDbxBEiAaEoBwJxcCMQhwwNFiY6jktCoAkWPSKXwBckgtFch46NSda0r/JgQpamTnHxbAGxbJQXk57vpEkCKPu3Oz6S9Egtvi8gICg2EsaSCJGpPJLyL7Cak+LZAnIZULBxMWdXAqOrvp28DNzqvuDcsFzxVCS13jaVB56EJGsWFz9KLGmxIa4lIQZIrG8PiaiwHH0xqJzwBR40yBYKLqn1NjIjO9cgqnJFQEgOhcx4TCKadIbEK0dCqm8PCYgjRNsmjqeddpp+ln3BfjhHPHVJ5BbCxNjnGUhafRJCj/eTHIwkokkojxALpN93Ho0Ky9FFkqTaciAQBzcCccjQYCEGzHHtJZJRGvQrSAMUN65UV1vitMqDB1ryIojXJlmP5D9Q/kZnyDQd3wgvcAz7HEjoo9NeGojidrUlTqs8kJcQgGuRoqgkVLpdQlzSrOYnxNHuyUCvAshjGqC4UQautsSFKA9p2sM4SLqeJHTikfEhLraFyjFsSxk3N+eXBqK48YwlkVyUIMSZ8RLVD0Li9NyLpLwYjgdxoeNnklfOBNtyjB49elT4HMIOCUoDFDfWOxUqSc2fIEF43SD6USusQpogjUcddVQiEWS88bxCXNL0jhDiiFfTDneWq+10IA5uBOKQocFC0pKrvSxuah7stIhrS+yrPFCSWDzsh3i9j7VHTNYnVBLVRtomG+QtEFNPi7i2xL7KA9LA733j9FJ2Rtlr2p4ZQhxtaw7SQrgqLZAjqi2xS3mg7FAeZhInv2P8cF4osKT9MF7wkDDRJ4VKbLDoE8exK0/IW+C+pAUEDAvWXg8kSmkRsiPEYS/PLXk6NFtK2o805WI/aZe5Z3sXccTTg6cjbRUM/VS4DxgdSWQPzyQkm9CSHSqUPB3mgaRzkKZcjLu0a8UIcbR7TZAfxedJBLAqEIiDG4E4ZGiwRK1LQI4AoYdCIG2JfRa8sZUHLnYy3HGfRnU6NMGkwqTpU3bmAhO0a10CFjxCERcCaUvsc/6m8iA/A3lIVOP39KpIgkyaPmVnaYgjx2ZCL6R8FEsxrlOjS3kw6TNeOB7xZvE0JYHtUa5RbcCTIOsS2BayyFBI22zpxOiTXAvpJQwF2eSYyEPFhLQP97n+Es4rZIEpxpyLOEq3zagGZ3HgPvD8RnVqtEkvHgW2x8MCKLfk2JB3H/mFZMVVWqUljuTV8PmYMWNy1Y1AHNwIxCFDgwU3MDHBpPUr0sBsS5wUwzSVB8qPngpMoj5lZByHJEAmnah20kkg89xlWdttiNOA86LHAsowyg3tUh4oPzrcuWLOUSCMUeikKeEAl2Utyi9N2MMEHhPkYQL2UR7ksHA8SBT/21UuSRUNPiTLBVmXI2n9irQQj4lP90FIG+OF7WWJd7M8Og7IzfYQ3UIgFSh2lZO9fkVa0AMiqYmUALJMaMiUH8PFZ+4Rgkf5bSEQD6kd3rLXr6hOBOLgRiAOGRosVA6YXfMElFZxPoVC2hITw/fJnidUwLZSo+0DWVComA5vKF6XZ0X6ExS6UA+EAyVIGCYpARIwcZPYxTFPP/10r2OIZYbFVSiw6l2eFWLeLkvUFyhDGvSQ4Z5UCSHkgSY8HJPERB/IGPUJi0VB1mWxgevaZYn6AmVIZQM5Pyghn+15XjgmYZc03hKfcEYUZF0WmyATuuBzH+LvAudDZQueQJ+W28gvpIH/feSh2gjSB+kqVH5Zl8X2rJCD5AphVAcCcXAjEIcMDRYsdnOdBgFd84ohDmZbYnIl4iotyACnCQ2TDBY3E3lSTwCJgdplZGmBpWK22xXg8XDlPqQBYRgSIKk2iLuvTNqUM8rCWFjqSc23ZMI3G1cVAixVs92ugJi7K2k2DQjDkCdCtUmcy5vwFB4H5KaDo91XxAVc6WxPN8JiunFKSMYGYR9X0mwaMOapTCBpN46AoTTF48Bz4BPmwSPCeCGsV0w3TlkAzU6+hDC4ch/SgDCP5B7FkWcJN3E8yKZPmAeFznxBInYx3TglJGO3rZfuuUnlpVWBQBzcCMQhQ4OFJjcoNlfsG5d5sSD5CquL5D1XohGKmWxoas/JrmYCw23PZB61cA1KlXPzjYHGAZeouTKobc0V2uVPQMUEoQAmUBcJwdNAzTmTIFY+kyA15FhSWEMuQKr4nqWyi5WfCdpcGdQ8BvIXu7olyZp4XVCgrjUNIE1Y5ihBwiPIQ08A7m9UAy/GCeODypdiW1ijoAnJRcW+i12gjVAHnjTCga41RSSnBxIkOQ6UAsZ50ihnJgxIAmKxLZzF1W+X70rSZLELlDF+eL6otnBVe3D/uN8cS3IcJMcjypPGOZGAyZxS7NLtsqCfPTbxkrnKtKsDgTi4EYhDhgYLFhsljDaYtFyx30IAa2eiw5oyY6lYpChUJgFiqqYyYVJEmdqlWnTfwyOBhVqs0gBY7IQIoqotSpFVTckjKzRSpmgSEf5m8uPamFUFTOL0kECZ2p4XriWKDg+Fb6+GOBBLp/dBVLVFmtLGKNC0CK8GrnizxwVjgfsMCTBbQ3NfIUUuzwsKjWRWxlIh+SeulSG5/lFluqVYFholRMdTPHum5wWlf9hhh+nnzCwHhDwQQnR5XriWEFE8c6UYm5LLYz9LUqbrE2ZJAgmGeF3wPJmeF0gyreEhiXbnWjyBHJ/7YwIPEESUsVRoGNGVy2P3XpFqC58cpVIjEAc3AnHI0GCB7bsavUg5VqkAAUDhsdYAEz4TKI1qmARdq1BiSZAwyaQucUZipXgm6DFRrKUlIJ/C1ehFyrEKXVfBZSWi8MTzwn2mURGfudyhLs8LTbogIMSAS3Ve5IngSo5KGkvbGjkKWInieWHCJzxFWIIxARm04fK8MJnjHaEZULGeIAGNfxhTNiByyJ/UzMgXJBmanhfGN7kMkGBXAqXpeZEEQ86FCihKeAtd78EGSbjIaXuuSArk86QFwnzB8uZ4Xghd4XlhfOMx4v7i3bPh8rzgsSAfiRLuUo1LiKlr3uV+8bnPWjelRiAObgTikKHBQiLeFlts4Z00VgxQEChCXPMkZKIE7I6VJlCwKFpCHShykvhQtr5d8XzAQj40TorKISjWFWoCgoCSIo+B5koo0risbdPzQiwaBQ/ZKuUYwS2MNRy13kEh5XhJnhfIA+18ua9xJaSQB5QLBBaLlOoXEiijllEvBCSYuspx6cdR6nI8lDBjmOeNcQ1pilt3w/S8EDqE4PIqNnzkWqTNBiSdz5NaXKcBeQOMNe4h5J/5JW65ddPzQkiJ3zEGCq10cSEqCZoQI58nrb9TFQjEwY1AHDI0WGiwgjLyTRorFmLJM2n6WDOQBNySWF5MmoWWB8aVDeJC9U0aKxYoZGRh0nR5WmxAXAhx8Bu6EpYidGCCpYNdfTwk27yUSloUMooQS9On7wTXXxLmCKmk6Yrog7vvvtvZIVDq+H0qYtIA1zdEiGtgN32Kq87gXCCapfKAJCVBozD5PKkldlpgKDCvMJ59Vt+VlW45FwgeXqdSIioJmkZifO5TEVJqBOLgRm0VkBlA5GrXru39eTH4+++/1T333KMaN26sFixYoO688061ePHi2N+MGDFCjR49WtWrV09NmTJF/11d8oNatWqV7FizZ8/WMjds2FDv//bbb1cLFy6M/Q3ycg2Qf/r06frv6pB/yZIl+v9SjoH58+drmZGlTp06+u958+bF/mb8+PFqyJAh+jczZsxQQ4cOVaWW33WP5f6XUn7uNTIje926dfVYYEzEYeLEieqnn37S8v/zzz9q8ODBqqaOf5515GffDRo0UHfffbeeE+LAM//999+r5ZdfXs2ZM0cNHDhQlRJR97kq7n9AcQh3IkNAQbgmh6jPC8XcuXPV/vvvr8aOHau++OIL9corr6iXX35ZnXLKKXklZaNfv35qt912U23atNHKY4MNNlB77LGHnkirWnHIOZXqGkCUDjnkEPXzzz+rXr16qW7duqkePXqoo48+Wi1atMj5G+TcZZddVNOmTbXCaN++vdp7771V3759VakQdZ9LrThQGl27dlV9+vRRH3zwgX4xDg499FB9bVwYPny42nnnnbXSGDRokOrYsaMeQ/yuOsZ/KeVnfyeddJLq2bOneuedd9Qnn3yi+vfvr+Xh2XCBZwX5IVxse8ABB+gx9OGHH6qaNv45ztlnn63eeOMN9dprr+l7OHLkSD2eZ82a5fzNhAkT1K677qqmTp2qfvjhB/2s8HrrrbdUqRAlZ6nlDygBIjwRSzXK5Z4ihkrLZ9+ksUJA9j+JYCQ6mslGVC7gsnQ1cKHKAhcy8XBJBCNMQXyY3IhSuVCjOmdGJY0VAtzNxOpx0ZpVIiQg4ram5a5di071ACuIkkwniWC4U8kNoKlSoY15bEStSUH74lKNR64hK60SnjCrRCTnhQoROyREbJ3QBPdGMvFJCN199911bkSpst3pnMl1drVNRv5ShEZkwTbGulk9ITkvrGZqJ7tSPUBoioofWX6bnBeeI3JezCqcYkA/FFcSNGWIyO/TvMu3Qyv7MzuiSs4LFSJ2sishIko4GZvSS8PMeTGrcIpBVBI0IRU+T7v2RykQQhVuBOKQocHCYlZkqbuSxpigS6E0jzvuOP2wuxLBpI6cfhKipFGuTKj0d7BjjyTr0XeCRMFSxDtJviLpyjdpLC2QiZJXYtquRDDKwfiOOK6UxKEUmVC5L3ZOB+MDooeyK0WpHJ0zKZUrdedME6xZwL5IOLVBnJ98D8oSpbyUpkMkEVImbOd0kPPCuIBUlqIdMC2r4zpnJi2RnWbtFiqVXGWf5PuQLCjlpZBikghZ6dQ+Pjkv5HxAwgtZm8Q3CRpSU0znTBOUVLIvSJorl4LcBSqFJOmZ3hkQBvo/2MmpEEyaPnHOhaxN4psETRVQMZ0zi0EgDm4E4pChwYLCwqp3JY25ss3TwOwI5yq5shO02JYJG4uKUsyoOnWUCZYopVmupjql6JxZbMttM/mQ/bC/KHBtxPOCIoGwkRAZpbQhEyS0olzGjx+f2c6Z5poFENEomJ4XPE14VOg26moYZXpeUPjF9lmg5XZc58xCW24LqIZgP1SvREE8LwceeKC2wvGoQY6jxjbWMaWskKdC15Iwk6B53qJabhfTOdPsh0L1UhTwbojnBUufZF1KLqO8PeJ58V0LJw5RSdDScruYzpmFIhAHNwJxyNBgwRvAJGyDrm1YvcVOyj7tc83FerC+mRSSyiBx3+J1oDyzmJLJuM6ZnEsxSLMAkXhecOfjjk8qOaUkD6uM0E0x5al4A+I6Zxaz7zQLEInnBQLBeEx6DiAVlNFCIIt5ZvAG0F8hqgFWMaWPyAQhhJwmhbwgKsiOJQ0pTKpmgVRCeHHnF1Mym9Q5k/4LhQIjAJkwTpLkhzBDYCBQ3NOk6552LZwosIJtXOfMuHLxqkIgDm6E5MgMgeQfSYTzSZryxRNPPKGuuOIKdd1116lzzjkncfsmTZro45GU1KpVK7XsssvGbs82JBiSQHnGGWc4ZfBFVchP4idyX3jhheryyy9P3J5Kk2WWWUYnEa6++upqueWWi92+efPm6t1331XDhg1TJ5xwQsHyR93/YpPDunfvrk4++WR16qmnqptvvjlx+0aNGmn5SRRt2bKlrjpIul7ITwIdSZdJ1TmFjH/5vhCQ/HjUUUepI488Ut13332J+0F+qi2Qn3tLFUUcqMxB/pkzZ+qEyaTqnDhUhfxff/21Pq99991XPf7444n7QR6eeeRo1qyZql+/fuz2XB+STDnPAw88MLE6JwpyXvY1qIqqkoAiEUEolmqUi2WynC1uQZcl5nLh+oAEuDQLENHcB8sM7wdxYP5mWW6flsISo4xzhcfh2muv1QtxuSwxlwvXB+RoYGkhj09bbOrZ2Z56fa4FXocDDjjAq6Ww9FugA2QhwLPk6mMgllghfSyIW3PtkMdnASLGC5YmcX48HfyN29onTEJXTcZanCs8DniWuN72fZI1DArpY4GVSriJXASf60eiI6564vzkweCCJ2HQp2cJuQh4KXxXVI0KJdjJiYRP+FwSM9Pgl19+0eEmVof16XBq5vQwFhiPeBN8epbgGcBjQgv6QhKZxbNkL+ZGEndV9LHwQfA4uBGIQ4YGC8lhNJaxgXvVVW2QBJo6kRtBpryP0oQoIDeNqGR7Jm2UB3Fcn+Q8lAbKI2pRrKTjo7Ttc8W97koaTALJZFxPFJ/PWhLEWDl3Jj7ZnqSvNMpDlheP68KXlFVukxTCK65qgySQDU81BOfuE0LCnc/1p722EEXc1mmUBxVAUcmXSZDW2vZxCDOhkNMqIxQQ1RCEG3zaYrtyeiBeXHtCET7JmVIB5Eq+TIK01rZzRST2n7a1OWETKkGYO3zaYnOvIU1mTg+JiYQhaczm07lTEnmZy9JCWmvbicZCyEvV2joNAnFwIxCHDA0WiUPbkzzWIm1x04C4JMqWbHifSZMETI7tWuWSGCvKg9bMScoDqxZrFaslbaWFLKtrx4mJy7rKVH3i7mTD+yh8SZyjVNG2zNMoD64di2IxAaddzVA6JNoTNNUmaYmjxN3JmfBR+KzBAGnq2rVrJZKVRnkgP2XFkM20LYKlQyKdAm3i6CpTjQOKnzGDB8unjBPlBDnBu2Q/fyQ9QkBIAPapbKDcE8+JvShcEih7dbVWJj/JZVDEAeKHl4HkTp+kVYg+3gIMBDuXhtwK8je4lj5trykrxlOZtkyTsYX8PAeuapNSlGOnRSAObgTikKHBQokkx7X7v5N0iBXsCywTqjPI9E/qJY+SYKLjuCxrHfVwplEeXDcUHW2p07iXyeLnPOzsdNzMZLn7Apc0RItM/6SlmPFuUAbJcfHsRHlm0igPJl6sXJRdmoQ+LC3Owy5tPPTQQ1MRR4gPSa2QvST3LvebUBgTPeXAUeGMNMoDpcWYxduRxr2OgkN+W+FyXlR2+AKZCK/hKUqq/WdbvCSQJghfVDiD54hFoVDEVFskPVOsGArZTFMJQeUG8uN5MQGZ59i+QKZTTjlFK1ufpaipMmJb1mKJ8mrgvcEIgcCYq+e6wDOElxNvZ5r1NSB7yG8v4R7V36Q6EIiDG4E4ZGiwSNmRPdnhbvSNGzNpsJIh1kPS+gsodSwMrCPyCJIYvSgPSrSS1rZACZCXgcLzjc0zySI/Hg4TTFisTugDZCDGjMs9qbae+8tkidLEtZokfxrlgZXLddpuu+28K02YnJHfttTSEkdWGUURxi3aBPBE0bOBY5JfkhTOEuVBzDxJIaEEIVm+Hi85H1e5MMQRT4AvbrrpJr0fQi9x4L4cf/zxeltWf0zKAcETRuyfnAnW+YgDXi5INjlLvmu6cHxZRMsE94jF2Hwh4SI8mHHguST3iW15vpKeU8Id9O1gbknyJpATw8qhlBenWdMFskuujwk8WGmIYykRiIMbgThkaLCgbDgusVYBygy3t2/CoZRdml3xoixoCAlWObFNX2BB00HRR3mguFHgTE5prrt97ng6fBMOpeySplFxwBOBV4SQinm9k5BGeUDciJkfe+yxXm5WLFVIjN1nIg1xlHAXyiMOeAJQ6oytNPkY3CMSB1Ee77zzTuy2kEuuE02CfHJsANvbY53z9E04lETKpPFC2SD3kftjW7hJ5IYVZbHQ6a/hk2OD98Enx0bGut1nghwV+mr4ALLok6BKvgAkgOfTJipxwCPB/eQYZufJqBwbymvJmfBJrgZ4KSFxJrjeaYhjKRGIgxuBOGRosMD4OS7Z/Pa5JBEBc/llrMc4SLY0XRoLadojysNn0pXcgUceeSRxvyhXFNJ9992XqExdIDaK94TqlKQkNNzI5ECQdZ4WKA+sYCZdGmb5ZMrbVlQUmGixmG3iSA5KEnAho9DI04gjKhA+joNHoJCOl6byQMnHHQtywf1LGpMCPFqXXXZZojJ1gQZEhCdohRx3TniL6DmAR8hnVVTXcwoZ5L5yr+KOBbn0GZMC+piceeaZicrUBcJSPNd40eK8JxA6PAF4zqgESQv2DZGT8GYcKaRKw2dMCugbgsfUBIYKCdvlQCAObgTikLHBggfAbFJEf3rOJcntTg4CCoZ4eNSDbMazyRkopoUxbl5ZYhfXeNxERWMnlKwdgnABZWY2KSIZkWMkLXtMIiZeEKyTqHMx49lYgVHdEH1gunmRL86iZHLlmvt4NjbaaCOdayHgHnGMJOuWvBMUAQlxcdadxLPZrphlwbnGWLWcG+MgLhwjbZ5ZcyMJhHYIH9jEMYmgMU7Iv6D6I650FiIH4cX1XUwLa54x6UQKUYlrzkUY0DYIokDokGRo2wtD188kDwKJsCTExj3XJIGyP8IIxSxTzrP0n//8R98bvAFxxxQvGO2uk0BFD8+mCXK1uNblQCAObgTikLHBQgydZCgBhCFpgRsUAMlDJORFTWB8TvKXbzzbd/LAEkYRU0kRdb2Y/OnACClK6n7HxE9M07Qik/rUE3vFKovrXGjGsy+66CJv13ES8KRAisjliEoE5VozufokKxLLJqZturuTiCMeEBQGIY2ozoVp49m+oOySCgosxai2zGayYlJbYq4T3hybOJoLcrnubVLnQpPo4C1IW9oYFxpBLp69qOoN5KeFOYQtKbGQkAShCZs4xrWJZyxDBElGjSIDjMHrrrtO7wvjwjfvJAmQYcY1hHf06NGR2/HMMU/YFRM28GQQmrLzPpKIY1UhEAc3AnHI2GAh7ogFY9dFR50LEwIMHddz1MRFPBt3Hx4JJrpSg7gquQIo7ihiIOWREKO469q5c2f98l3giEkZtznehqhjm/HsQvoLJAGlDimCvESFPnzbEqNgUQL2OgVRxBH5UYTc2yhSUmg82xfffvutDidQ/hvVFti3LTEKltbdSQnDJvD4QF6itiE5ETLiE1opBHj7IO5YxlGLfUl5JM9pXFUSa8SQVJmUMGx7tAiHROUckaiIJe8TWikEki+Fx4vx6gIEgHvAcxpnBEFuCCHZCcNxxLEqEYiDG4E4ZGyw4BUgf0DARIdSiHrYb775Zu0ujErUw8LBEik0nu0LQgUoThRo1CTnE07A24CCEZDkiHxRHgJZ7c8uYStVPNsX5IqQMwKBiqpmkHACSjzK4qc0lt4TNnGMauCD+5vv6cPgAuVwxcSzfUHFCQqfsYo7PC6cQJggKpzAks/cL5s4RpFiWXKcJaldQElR2UCSYpK1WwxIGibMAjmNuhdmOCGqEyerVvKM2CtjRvVEkSXHCRu4gBeA41EamZTMWgwgw8xbcXk/jGEMB4hRVJiQ+2h2D5WVMZOqmKoKgTi4EYhDxgaL3ewH9yps3gUUNFYULL0q49m+wFVPSILJI2oil7bEUcledpdIsuMhPi5g3SEfVlpVxrN9IeWdyEdM2kX2pC0xyV6u76mKMbtEkpOBK9y1LUluJJNSs1+V8WxfEA6T8k7um+ucpS0xLnnX93aznzjiSBgHN3lUMiQEDiWMsip2ZUkfmOEwEjxd5BivEEqckIwrXGh3iaQFehRxxJMIUWfMufbF/EBJNF4uu6lWVQAyTGKn9ERx3TOqmRjf5HK4vre7RAoxKnbl2UIRiIMbgThkbLDY61JQv08dvw1ceLiHia3bE1RVxbN9wGTApCHHdiXqSZ05k6TLg4CyF0XAPlB8LpICwcDKs+Wrqni2Dzg2q1xybNbHcFnW0pYYJRm1LoVcNxJPmfhtMDYJ/XBt7GNUVTzbB9w3abvNsV2WtXhRIEk27HUpoogjMlOBgPVqJ+aZiXtxuTdVAY4NaYQ8EnJz9XDA7c65uVYqhVib61JEEUfGB+E3PIl2bg3bMraw3MmZKWbFzmLyfjAiXG2iKf/m3DCSXFUY5roUPCtcq+qcw0wE4uBGIA4ZGyyiVORBgRjYWdYoJ9zduN/tzoQ8qOIy9CmBrCrgrsRypE21XfJptiW2Y8JiYcmES/UHawfYipFJGYJld8Y049kkbpajTa14O7CsUW6umK60JbaTHsXCErkoTbOXWpe21ljbtiVd1fFsX4i3gzCBq3ugtCW2K02I05vdQyGOrqXWKe/j+tr7hlBAtqVU0Gdhr6qAeDsITbhyLwhJcI6MdxPimpewGsTRtdQ65Z08X3b4DUKBB4p9oJhLlQScFuLtoNsqZMAGHklXpQkeCbN7KGPYtdR6dSEQBzcCccjYYJFeDFjMTIDEppkkzQmSSRfFaMesqyue7Qvikkx6TKB23JsJjrUE+N68zuRqID8TI94CyBHrJ5hJdzLp2rkEZjybFQXLDUIJnA8KFCJhggkdgkfM37QIZaEfPEa4vZl4cWubykcWI7M7I1ZXPNsXxOU5HxQ8YTOTxED+8AagXMwwEoQB2UiShFxiUWO5cl3k97IKK94ZE+RBQFQ5XlL5anUAwky+Dgqe3iSm/EL+yIkxqxEgjFLiCgHg+eA5YYVI+b3MEZR5mqCqBe8kx/Mp/axqEF7gfCDIeJfscArzGt4UM38D7wmEkmeeCgvypqjYKBcCcXAjEIeMDBasA1yyHJcXDw//QxAoz5J+AbKCoNnrQSYTiWf7rGJXXcADQNWDnL9Z78/EitUMQcI6JCvdlp9JR+RnooEQ8Bnbuyw8Egt9FiKqLuABEAsYRWiWy6LoiFHjVcGyIinQlh/PEZMvfzOZYsnhqeFaljOe7Qs8AJAAzp+KETOsQN4N9xxiQIMsKhNM+Xlxr/G48BnrH+CRIAHT7PUglR3sC6KVVPJZnYAgy1ow3GczKZC8BYg+4TbIICRJ7rtcA55/iAPv8aSxABbjHC+kSUSksoPwJSQjK4Ag86xy/ngOzVwrQmg8r5RfQnQYu7b8vMzy3OpGIA5uBOKQkcFCgpM8MPJi0uB/SinlPS8mGmHvPJj0ZeB7JpPqjGf7QmKuKDzq3c2ySVlgikW5bPlRGvwvE6fIj+taXLBcB6wZiWf7LB9cDvmZGLGusJ7Mkk3xntCW15Yf0sD/KE5RoshPboMQMPaNNVuueLYv8ADgCeHczeoewmnISOjNJT/ycm34X+Qnt0UIGPLjzWBsMYbSLCpWnYDw4wmDKJjhBTxR3FuX/Mgryc2m/JADc5yzD+klkbSoXbkA4ccTiofNLBvFM8Z9dsmPrHiP7E6i1YlAHNwIxCEjgwUmzoQgZMF8mZaoMHFYPJY1kyW/KWc82xfU5FMhgnsWNzsWN8oEefCWMKkIWTBfuCtt+QllEN/H3V/ueLYvSPgiwx+LGXc7+Sh4HDh/EkJRKi75cffbn+HGxWODNcZ7rNpyxbN9wXjFI4asEAa8UYSiREmS6ChkyXzh7rc/I/EUz5rkc+DV8F1MrFzgfCHByEiZNSSfUISMaUil6/5DHO15geoV9ocXivd4teK6V2YBPO9CAikjJ2mZCjKRiXJeU37xPlRF7xVfBOLgRiAOGRosJBGZEwTKFCXjmkx4YWWgbFzJR1kFlpKU7OFWRjZeyImCxMIS+VAwTB5855KfzyFV9jLMWQbKAqXH+eOaFitSEgmR2fY4YKm55Id0Ed4iobKmAGVBwiPnz9gVLxLyo0T531YceBhc8kNAKe1Ls0hXFkIXdFHk/JEX2WWMQ5zxSpjuel64813yE7LgGtj5M1kG5FYSY7n/IitzGUmQvGz5k5ZGr0oE4uBGIA4ZGyyUkZmWtm1tMtHgluVvQhZY8TUNeEao43e5ZmkOJe+JedreBuQXckEiXJbiuWkgytN2zRMHlvcQC7HIbfc1f2O91yTSZAL3sy0/pIl8B3mPIkUxmsRZiCZ/Y6GXq6NgsSBHyWUIEJaQ9xBG7rVJpkz5IRQ+639kEbKKrU2EmdPEeIIY8X9Us6zqQCAObtTiHxVQATNnzlSNGjVSf//9t1pxxRWr9eosWbJEbbvttur7779XrVu3Vmuvvbb69NNP9XfLLrusqlu3LmRPtWnTRv3888/q1FNPVY899ljqY0yfPl1NnjxZ/fXXX/qzWrVqVXjVrl078T3XZtVVV1XLLbdcquOPGzdObbjhhmrOnDn5z9gn+5o0aZLafPPNVf/+/VXbtm3V6quvrr788ku9zTLLLKMaNGigFi5cqNZZZx31008/qa5du6qXXnop1fG5fiI///PeR177fcOGDfU5L7/88qmOj4zrr7++Hmfy+LHPpk2bqj///FNtv/32qk+fPmqttdZSq6yyivruu+/0NnLN586dq9q1a6ev0b777qt69OiRWn7uO/JPmzatYPm5F8jPmEwDjr3eeuupqVOn5uUHjRs31t/ttttuqnfv3lp+5B0wYED+GrEN140xwjOy00475cdHGvlnzJiRl5/nIUle12cif7169VId/59//tHjf8KECfrYAsbTrFmz1F577aV69uypxz/P/PDhw/PbNGnSRI/ZrbfeWvXr109tsskm+jlIKz9z25QpU/Q9WLx4sZe89vv69etr+VdYYYVUx583b54+79GjR+tjC7iOjO3OnTvrMc38B8aOHauWRl2QZdQp9wkEVAQPZ/fu3dWJJ56oJ8R1111Xfw6B+PXXX7XC+P3339Uvv/yiP//xxx/1/zyAKB0mQ/vFBGG/Nx/YYsFk1qJFC/1iIpG/7c+YGMEtt9yiSUOdOnXUokWL8pPZH3/8oSdLFOvuu++uBg0alJ+U+ZwJZI011tCT3eDBg/XnP/zwQ15+Po+S2ZZfjlsKrLzyyomyi/xMuHfddZeeiCBCch+Qn/vHfR45cqTq2LGjnlhXWmkl/f2aa66p7zv7Q/GIsoA8ABQQSjBKZlt+yFepgDJPkp0XEy/yP/DAA1pWU34AaYAQIhP3n/HQvHlz/R0EknPnWEzkMu4HDhyor51JBn3kX7BgQcnk53zi5JbPuJfI//jjj6vx48dr+U1AGnjeee732GMPfT95tiAO7IPrA1lhvMm4Hzp0qB7LzBtCBn3knz9/fsnk5776PP/cO+R//vnn9Ri35Yc0cP8//vhj1alTp7zSDsgeAnHIIHjIrn/wWbX34cepDocery0TJo+9995bWyJALBUmWSbViRMnVrDeAIqKibdZs2b6fzwZ/G++mIR4mNmfTMDysj8z3/M3VhtKngleXqNGjVLffPON/puJwAQWiiiQrbbaShMHtmEiYz/sl8mCiXCNzXZSP/29vNrxgCP09ygIJpNPPvlEH1vkHzFihGrVqlUl602OZ8ravn37SvIzMSN/krwu+VH+tvyQm2+//Vb/bXpUAJaZKJAtt9xSW5NYXyI/++RvPBirrL+1GrFgJbX13vtqhdC3b18tP94nlK3IynGwzCAVtvwcz5SVa+6SH6VTiPwoOlN2ZPjtt9/0ufJ+9uzZFc4HEoj8KBCRHwUm8iMXcnBOK6yxoVpQq7natMOOej9fffWVtsS/+OILTXpEVs4BUsX9t8kwxzNl3WKLLZzyo8DSys/LlF/GAeePJ4S/IXgm8MwgP88c54KnDvkhvDy/nP+YMWP0/cyt3FotqNtKtWu/sT5Wr169NJnAE8WYEfm5Fnhm+L1NhjmeKetmm21W4T3zAh6tKPmTrgHymbLLCw8R//Msm2BcIz/XHI8R7yFwkEi25/wxjjbaaCM1c9mV1cLV1lJrt2vrmCEDyo0Qqsige+r2D4eqR78cnX9fZ2RvVW94z7yVbYNwha0UmBTSuhBLCSEB9sSKpYXFKZOVTHZYUngVcGEvs8VB6tu//+edALWHf6qajP8qb2XZOPbYY9UOO+xQSX6IQ7lgKhZzYkXB3X///fntRH7OFfmxuJbd6hD13Uxj3P3ysVp92o+akLlw+OGHq1133VVPyiZR5JqWE8hvKxXeIz9yQ9jE84GSRwHicVl260NVv1n/Z2kuGfyRWnfu0HzIzsYBBxygSYVNCpCfY5QLKFZTfvn7oYce0oQZwibyo+S5/1yD5dsfrr6f/T9PE1g06AO1SW6M+vDDD53HwaAgZCX3X17i4SoXIHwis3kdHn30UT03mPJDIpCfEGzdbY9QP85ZOb+f03duqy7fe4OlUhdkFcHjkDEM+O2vCqQBLFpnN7XczDGq0fjxegAD081LTPiII45QWQITFg8cL+L5AiwWcjKYOMVVKbF7LKkR0xaoGQZp0L9Zr6OqNfd3tdJKv2ovBzDDHMS5Tz75ZJU1+ZGJF2TIxLPPPqvd0C75x8zMqekmaQAb7qkWD56iLXXkh5SY8m+zzTbq9NNPV1kDiosXZMjEq6++qvNcRH6uFV4Y5B83u5aabpAGUHujTmr+0BlO+fkt1vsZZ5yhsgaIC0SIlwni97YRwHOC92HCvGXVNIM0gDqb7KPmjHhDeyqQn2dI5GfsYKGfddZZKmuADEOEeJn4/PPPtVfO9JCK/JMW1lXTDNIAmA/3areq2rxV42o794B4BOKQMYyZWtG9K/jjn8V50sBkiTcB5cvk8cYbb+TDALywNphYsgImOom/YnFjEaM4hPjwPa5WcOTBZ6g+jnTdCTMX5kkD8mOhoWiQv1u3bnqfpvy4wbMCMxkROXEPQxxM+bHEwOEHn67+lwpZEeNnLMgnsgLkZ6LFYkMRYa1JPLmQhNWqhJmMiJwoQEIaZn6HyH/wgaeq6Y59jJs+t4L8WKgoTVzdhO9ItpNYeiEJq1UJSUYU+cUTYIZWJP/ggM4nqmkR8wI5HC758cS8/fbbFXIK0iasVof3EfnwPOBd4tzN0BrhKl77dDo2Uv5AHLKDEKrImHsKj0OXR/pU+nzS8xep+vP+1PFcSAKTDueJIjYnVMCkhHKyE5Xs9yhbFKyZLW3+HQc7GTHuRQzTjL/akwbvsTjJNO83aopqcdw9TvnrzZmsXZlYcvwe+VHEUhlhggqFpIQ1IRiFyu+TjCgTopmM6JIfmbCc+wyfGCn/8v/8L3kUxSM5BsgvlRG+CaumgoVgFCJ/UjKmmZxqJyO65EeZ4Dn5eujvkfIvN2uivv88kxJjZ/xz/+38jqiEVfO9EAxbbvk7SX47GTMqIddORpScGlN+7sOOO+6ovhzyW6T8df7+PV9pAsz7b8vvk7AqBKMQ+e1k1LhkZF5J8uN9wnP6+c9jnfJ3O2P7shCHEKpYSonD7bffrq644gp13nnnqfvuu69GDJbr3xmonu07If9+7o/vqKmfPp2fHPAmcNukjAoFjvfBjie7EpfSZJPHlWexH3uyQqFJfN31Eq8ACY6ma5lEKRQAkwuyNdjxaKU22CP//ezv31Yzvng+Tz5M+QG/5dySZOeVJps8rfx2MqYtO/8zWVNeSV6GHANXM5Mw4w1P0nJbH6qW2Xjv/H5n9X1T/fPNy/l7J94kuR4kzjJe4+SWz+yE1SREkQqIkJ2MaCdjRslPRVCXLl3y8hPKIpEU5QOBzG16gFp+s875/f797Rtqfr/X8+eOkuF3Ij8Jwquttlqk/OZ7O2G1lPLbyZim3PJCfrwte+65Z37/kEHGM4mVEN6FG+6j6m15QAX5F/d/WxMFl/xUYXANfZ5/O2G1UPk5dlIyZtRcgKFDTpLsn0opfksVEfPDnHX2UPW3/t/4AGfs0lZd1inkOGQJ2fFnVwHIbiaejhuzJmGv5nPVbc9dqJZfpZVSMyerRov+0pUTJBaaCYU8dCggrAteLVu29HKZy2QiZYk+GeT2Z65JwjcZEwtJID0LmFAlFLPioHfVhH4fqnrN11SLpk9Qqy47T9VddVU9sQKRnwn0wAMPzMvNPiAhcfJzDJlEsYSi5E+6JliqhSZjmhPudtttp+O9/B4LmleL/m+rKf0/UQ1atFVzp4xTbVaspf5q0iTvzjflp2yTHAImc8mc901YRX4UoG8VgfkeC9mW3zcZ0xwnVPrQjwAPCaEnzqvxvNfU9J8+Uyuuvo6aNeFXtWHzFdSEhg3zxEEUNvLjpdh00031s8A58LdvwiovyFgh8uOpshWkbzKmlJgC+jFAfCB+3AtIcP0ZL6u/h3ypGrdaT00fN0xb2iON0JspP6STa8j54GXceOONvRNW+R8i7fvMm+85HnKb5MA3GZP7LF4nvGzke/Ds8B5Stewfz6t5o/qpFVuupaaO+UV1OOjFxH0GVDNy/1LQbYwFdT755BPdje28886rMd3CnnzyyQptV2WRI1aSND+noxzrHdQ00HaXBbnMlsvSLQ759thjjwod5egQSVdFOsmZLbnpNEj/+5oG1tRgjQHW7TAXLxK5ZP0NecnS1KxrYXZRpKvgyJEjczWxcyjLRtNim/sti1mJXPaCZ2xHV0E6KZry8xtzwayahDPPPDO/TgP30ZSfxaqkS6R0EOXe047ZXsuhpnZOvfjii/NdcemEa85rrOci14X/aStvripanSi3Lsgqaqt/KcgypkSJRjJJgHVjiZmvcgJXrjRLAZThUcONNWpGlrDAKEWDpdcUYFU88sgj6r333svX7pt9GcQValovlGF26NBBewvM8AC/RX56R9QUcP+eeuop9c477+R7T5h9GbAisebM5D4sMipHCGfY7nFc/jQBqknyv/jii+rNN9/UCbLiQTPDcFifWKQCmgXRg0O6HAq4TocddljqzonlBrK/8sor2jUPzL4UyC9Nv0RWPI00fiNXyBz/jJGjjjpKe2xqEkjmfe655/R9BeL1AeI5ApIXhHfkuOOOq5THE1BG5P6FeOWVV3QfexbUAUkeh+uuu865iEy5WCbrFbB4j71GAzLJOhWnnXZark+fPrk11lhDWyPvvfdeLuvAO7LXXnvp8+d+PProo9prYK/8h4cF+e3PWV5c5D/yyCMrrLb5xhtv5LIOVoM88MAD86s5PvPMM3pxI1tOxivy24ubsbKiWGEswz5o0KAKq23WBC8g943zP+aYY3IvvfSSvnem/FieeFzwLtny77jjjvmFv1iGeejQofnVNhlLWV8dds6cObkTTzxRn//BBx+sx6w9zvm7Y8eO2ptorxTKuJBrwoqhLE9vrraZdfnxNJ511ln6/Pfdd1+91DheFFN+ZEF+17xw9913V/s5B4+DG/864sB69KwY+NNPP+U/SyIOLMfLAJHX+PHjy0ocWDXSJjFMqDxkKAlWlZOFX6ZNm6aVCNvg/luwYEEui+B+cN7I8NFHH+U/7969e6XV8Fjcyp402IaVA1EouC6nTp2qf889ktU2cf8KWcwahg0bppeNRlEwYQpYpMqWtV27ds7lpXHXN2nSRI/vCRMmVFptE/c/77OI0aNHa9c0MkDsBd99910lWSGI5iqhZmiKRb+4BihNe7XNww8/PLMuZeYUQm4sZPXUU0/llfzPP/+cJ8MmQSQ0ZcvPdSJswTPA7+zVNvfff389H2QRkyZN0gYBsv73v//Ny899lNVvZR5gO9eKuJAmxkt1IhCHpYQ4MCnLIDNXkmNQ8jfx5SwPlpkzZzq9H7zIcbjrrrv03y+88EL+NzyEWBxMLNtuu21u7NixuSzhrbfe0hbUZpttVuHcuL7koWA13njjjXkF4lKavJh0kZO/H3744QryP/LII1qxoHSyFvf/4IMPtGWNd8A8t9mzZ2tlCqG47bbb8gokahlx5Lv33nv1WL7jjjsqHOPZZ5/VvyNuPmTIkFyW8Nlnn2llj3do8ODB+c9Reu3bt9fLZmNNirLEg+aSH2/Lfffdp5/ja665psIxWCWS54PVVPv375/LEvAMNm/eXHsHzdVsmYvwnPDdAw88kF8F0zQcTFKN3Fwnxsn5559f4RisEgop5Vp+++23uSwBmZF91VVX1ddCsHjx4lznzp31/YZMyGqY5oq4pvwQ7Oeff75azz0Qh6WEOKB4YePmC6Z/9NFH51l6lgcLljnHJhGMkAXWZYcOHXLDhw/Pk55jjz1WW25idQlg41gkTCBY8uUGE4OEgfAKmNYwyv7QQw/Vk70oU2S///779fYoGpIkmURZahe3tMiPZwElY9/PAQMGaCLCPl999dVcuYGMLJPO5IdXyB5PuK0hQ4QcwC+//JJ76KGH8sqT+96mTRtNuFC4CxcuzC9JDbnq169fhf1BGPBWsE/CIFmQH3lQeCyXbVvDeAEhA3379tXvGc8QQORnDOMphFSxfDTXSLxpN998s1YiX3zxRYX9MY622GILTbAglllw3T/99NNa0RNmweo2cfXVV2s5Pv/8c/1+3LhxWn7uLd61nXbaSd9PnmnGNp5RAHniGkFITfB7DAd+j4GRBfl5DhmPzMF2IjPkFznef/99/X7ixIl6vEAgkB/PA0YFxAryUQ5vYiAOSwlxcKEmVVXgxufYYpmjcIn52uQIVk7OA3+bIPtY4uiELnw8LFUBQildunTR53HLLbdUmsREQdq5CWSJ87mQgpNOOklPOnasGNm5BrYy4npIHB2CUa7QDed41FFH6fO48sorNYkygWLnO1vBoyD5XCwzxi2K0wSWOjFurLg//vijwnd4MSSOfvzxx5ctdMM5nnLKKfo8sI6F9AjefPNN/R2Wth3S4POePXvmlSuhKRNiqUOqUZYmUK5nn312PnRRrtAN8nLvOA+uA9fDxIcffqi/u/XWWyvlAfE5XjpRrnirTPAs7bPPPppcjRgxosJ3jPdLLrlE78NFVqsLjPcrrrhCnwfPAc+DiS+//FITSrYxwXjlN3jQAJ4ItrOfn+pCIA5uBOKQscHCA8OxZcJn8sHFbQPrlAmFuKb9UDGx4NLmgcNrQVJeueLZLs8HljKW5rnnnlvpO1EoUmaK4sDrYGPUqFHaK0EilU0OkJ9kOY4BaazuklUznu3yfECK+I6cBBsoTOTnGoLbb79dW182sN6I9+ONEUvUBC5dvDLEy7HkqhOTJ0/WFjaWNha3DTwDjF08TjahhDAhv3hhUBxY0PYYnzJlirbE8ca4yAGEVMJjNrmoakBm8bDw/EGQbRnJw2Ls7r333pXkYmwgv5RZch95bytenmnxxsyYMaPSOfTo0UNb7nZ4rDrAvEkIAk8bHjdbfsZHy5YtczvvvHMlQjlmzBgtr+RBvf322/o997scCMRhKSYONWmwEOvGkhBgkTDJuICrElenzdoF9LBA6VAHb1sm1R3PNj0iJEkS27atMMBEi8KXyebBBx/UCsjldu3du7dWKliYLnz11Vc6GRN3v2+Yqlig+Ijl2vFs0xPD/cBjgnfABtURJnEUz4TrWuHixy1P6Mp1fSBoTNBY7D/88EOuOkB+AbLjXjbj2QLkQpnjLXI9X1jaJnEUIulK+oNcQE6pUHBZpHzPWMMzUV39DhjzjH2eAZ4FG5Bc+lRwjSTB18THH39cgTgKkXTlLRG+5PnGOHB5FknIJXTHfPLpp5/mqgPMM5AVSIsdSgGcJ6TKTPA1QX4G8kpyu+2BrG4E4uBGIA4ZGyxY4SS4mc2gOJcol7skS7744ouRDzJWCRMMk1K54tmyDR4SJjIsCxeuuuoqPamaSW/IF+U1eeyxx/T3xIZdYMLdZJNNIr0f1RXPFvlp/MS5MKm7YHsYmHyRDy+GC5Q08v2dd97p/J7JGZIW5f2oqnh21PlSRgzZiWrcJMRRiAAubeTDw+bCO++8oy1bcmlcwFLFsuW+VHXeB+OLe4u3TRS/DcKHkF0XqXIRR3IbeC95IDZ4pnnmLrzwQuf3EHVyhdgG701VgnNh7OIJiRrfN9xwg75fVBO5YHsYyHvhfdT2VY1AHNwIxCFjgwX3Le53Af0ZOBcXOxdlRCybyTiqVAlXJlYJkwfJh6VOmkqKZ9skJ67nBPF5FJ2AxDF+EzURATwOTMYuC8/Mt2DCwqNTavmT4tkCwids8/LLL0fuyw5N4bXgN3EeAzxOyIZ7OinfgmqEUseL2R95HFHxbJvkPPHEE5H7gjiaoSmsan6DdykKeOXYBpKZND5RsKXO+2E8kbDJPWCcSam0i1hwDlQGRcEmjoSZ+A1VE1EgT4RtKPOMGp88l2xz+umnlzzvR6q68H7GhUZR/lwjyEMU7NAU15LzZuyUA4E4uBGIQ8YGC5nUVICY7mbOJa7EjBg37k9c5FGWHpOl1HvHKbdSx7Nty4jErTgQ9z3ggAPy76mm4JztDHp7YsTLQSWCXWkiYCJCaYpyK1XSYFI82wybYEkzcceBZFiqKcxcBjPzPEo2rhnVJK7wEOC8IE1Jyi0teEZIwouKZ5sECG8EjZ/iiBvJsCR+mqQX+eO8JeLJYf9RBIttULCS9+PKCygE5FdIH5Hrr78+kpRR8UJeB4nLcfKj4E3iyNjm2saRLfZHQzHGF+MsCngv2YbEUleYpBAw92C4ID/PdhQpk5wkvB9xxM2V00SZcRzZqkoE4uBGIA4ZGyzEfnFnCkjs4lzIwo4DrnFquClHc8XOBbhrUfIQlGITjpLi2abyJ+bJhB3ljRAQ/8adbbpakf/111+P/R3bEc9l0o27b+JOx6sR5cUpVTxbQFiG8lpc5kmEjfuCEhSwPfLHkTKpJsFFTvOsOKWA5Yo7nfBNsf0+SLojrIZCjCM2XGfyLCAEUd4IAdUChLNMpYg3DU9ZHNgv95TjxCWDljLvh2eT8UoSJrkYUSBfg/tCXkvSnEIliF1FxdjBoxEHxgmJwOT0RIUBJfQjeT9RJNMXXGfKP7k/Zl8ZG5A0xglzWxJhcVVRkady+eWX58qBQBzcCMQhY4OFSchsrWqXJ8WBeCjs3JWtboKEI5KTmDwKnTxFAbMgT5SXQyxyJgwUuo+VBwnBchMgB0SHJMkkCEGhnW2cVYNVioLhVejkKQo4Lp4tCh2FwbX2qe7gWuEZMkFOCN6CJAhBwaKMc0eTaMb5MAYKTZpEAXNexLO57nEKHcLAtfYhajTwMokjgBATCvFRZCSDQiDiCApjHuLA+X/99de5QiAKGKVmdql1KXQIY5JCF7CtSRwBvRzOOeecxN8yvrivjMk4j5Lk/eChKjR3QBJvedn9RExgKGAw8FzGjROTOOLBMkFlkKsCqToQiIMbgThkaLBI10g7Bs5DZ3cKjIJkpcfFEWXyIGmSCS2N8jDj2UxwcRM0ygvryWwRHAeUPXFSEh5N4LrEhekDyrjYR1JIBCVDcxmUR5qMe4gMfSl8XP7IQ1kaFrlvN0fICLkgJrhPdqfAOIWGOxrlG0ceUTJMyBwvjfKQUt+keLZsiwUNwXRVmLhAuM0kjgDigSXqg++//16XoRKOipOf88ZC59zSrvPC+BSXfxwZ5Pjk7EB840IIJvCa2cSR0BXhEB9AhLmnhK7iclkYt6wbw7klefNs4F3Ay4C3IanUl3FLeMg3MRuPKWEXE3igIBTlQCAObgTikKHBEpUIhlUXlTXtwk033aT3E+c+tZUHFmSp4tl23DUuP8FEVCIYXg3yMv5fe+cBZkWRteECVFBURFCCiigGQBQRBUWMoMJiQFRkxRzXsOuPrlnUZU0YEddV0NVdV8WAougafzFLEF0jKmbMiGJWVJj/eWv/M1tTU9Vd3ffO3B6nvue5z8zcuaFPd3Wdr875zqlQSGe9tCgNEZAszsPMZ6PiTxMZknLCwbrK0lzwCcE4RppahUIqcdBcpNmD88d5+ISFefLZAshryDi0iSMiUhOQLx5ZomF8b1qUhmjesGHDtGMLqbiACNNUjM9ms6Y0kSGRw9BoYRJx5NozBkLBWOYeTYvSEA2BYPHakIoLrg9jOrS5mFQ8pY1DE/QmsStkuPeZAyqBSBzciMShQIMFB+uqICDvzQ0eCpz2iBEjdNoirW+/OA8cfJLzQARJeDMtny2Q1tE4sVBIBQGrxqS8d4j9rFBxiGnRhFDngYaCEDjnNMQRonDHFkhMKAih8x5bL2ELJkMgK700QojzQ4yL80ia4ImG4bzS8tl2GW1abt4EXTB5j102awsmQ4AQFpvSSnBxhhBcvpeono8MoxviPkHxb0fEkpw37cFD4SOOXEu7e2gapJ1zWjUC5HfUqFHVFTc++yEZ3CcQOyJOaZVJjGHOFUQrFD7i6GsCVx+IxMGNSBwKNFhkpWR/75577qnVyFlACgGRkastcVbnQW6aiYswcogmACEnE4Adck0D5YTYb/e0J79JWDQLmOggXK62xEnOg3I4e1JERIoIjpRLSFoHAhiSLnC9j2Owc8Hkt9FJZAG5ZULRCAHTdCw4DyJafDeTtH3MhPU5/5DGEE0AOW/SBaSystgPyeUY7Jw5K2e6RGYBNuHoWMFLF0ofOEapuOE82JEkHDppCUhjSFoHDUlIusAlNnURRyInVAxlATZRwQLR8/WAMF8rRIP7wI4kMZdA3vmskMgc440UINVGaWLoEOKY1ASurhGJgxuROBRosMDkCZvbNwisndV+VkhbYib9tLCiz3mghaByAAISIqSUsrM0gaILlJxBXuwQMKs2RF9ZkdaW2Oc8WIHJhE/6BEU4os2Q7nVSdkaEIGu9vBBHWzfAqh0tSlbwOYgAeaS1Hfc5D1Tw5J1xBHYkKGnMkQLLWvJKJMvV7IqoDUQkq+PgmqNjQcAYUkEEaWb8Ed2T6hfSWbT1RkgYQpqIzPF9fG/WkldfsyuJXmUdT5x/7n2uh03GXaByhygV2h25dpxDxjLzUkg60xxzROmyQIijTXTQYPB81s8rByJxcCMShwINFp+DJFeM48qDtLbESc4DzQWKdo4pRBHOhM/rUYHnOXdoM6gKsEENN6u9PEhrS5zkPBB0IlajIiCpAZXpNNCjuDbfCoHPQQqhyrJ6s1d/RB9C3k+6RpwHpJFIB6QlqXJAwMSOoj8kyuWCOEi7ZHXSpEm570dsIOpE9CmkdwkpFqJFnC8iVeTWOX9JlQNmOoeUSkiUywWfg/RF4kLAdSDMT/QxqUxbQEQBkkBaij016NHC/ROiUyIyQVWIa/OtEEiXVPvc+SJx9YFIHNyIxKFAg4WugThdG7RTJvSfN1QnHfsQNIYA58H34cRYOYRMWKxMWZnjNJhw8oBIB8TDBu20Of6Qic8FQp843jPOOCPo9TgP8rNMoEQsiCKkgbHCyhyCF1JB4gJpEnOfEvP4sR9ikgesFCEDRFJCgPPg2mM/q9WQCZtrwzbIhNRDK0h8XQNtsM8C9uc9r+hcCHWjlQi5h0hHQFR5ED3ytce2haOE5olMhFaQ2JANrexNy6QJHOXWecBKHluocAmxn/NF1JD3UNHl60hrAlKKDokxk3dfEGk3bVeqSBM4IjL1jUgc3GiqIgoDiFyTJk1qPd+sWTO1ZMkS5/9CsM8++6hTTz1VnXTSSeqee+5JfX2vXr3U8ssvr3788UfVvXt31b59+8TXf/vtt2rIkCFq/vz56sEHH1RrrLFG2e0HixcvzvW5u+66qzr33HPVmDFj1C233JL6+p49e6qVVlpJ27/++uun2sPrdtttN/XWW2+pBx54QHXp0qVQ9g8cOFBddtll6tJLL1V/+9vfUl/fo0cP1bp1a23X2muvrTp37pz4+p9//lnttdde6vnnn1f33nuvHjNFsr9fv35qwoQJ2vbx48envr5r165q1VVXVT/88INac8011TrrrJP4eo5r3333VU888YSaOnWq2mSTTXLbD+xzUKr93M//+Mc/9Ng/55xzUl+/7rrrqg4dOmj7O3bsqO+BJDA3HXroofraT548WZ/vurCf74koCDyEolGjUiwTERyhXl9ZUymQtsSEHZPCruSxWfWyeiZ0zEr1gAMO8Ib5Cf/uuOOO+nNDcuBJQARHftgGfS2wP02nkARWWqQfWEknrVzQMRA1IHpC9QBha8SpvjA/z9NGmM8NrdX3wbcTquxXkif8b9qPWBN7ZMtiFwgxE9pG1yJNvhDGubbuBowLziufy06OpQARHGk1G5QnY3+pnR4R6xJJY2WblNqgyyORM1IHjGt6kfiiXXJe+dwpU6aUdHyUbbq0DAhy09rOh4D+GHxOUlUMmh6atXEPUD3EXIBOwjcXYr+0si91PwnfTqhSph5a1l1OxIiDG5E4FGiwUBuOqMoG5UlMTKUCsRZCL5T2rklIQpRMFCKmYzIgzE8ttU0eENAR/iQMXI5te2kry6TtS7XkTVUIEHwh9MIZuFpkE2LGcSOmFDEduy8SPqeW3hZ7SoMfyJVvg6ks8IkgS01VCHBI9EOA5LiuFykGKmeooJEujzTuwZlDOm2Hhv3s5sr4COkDEVLCy7HZoMqglFSFgOtHaSskx1UdQFUDqTLGoGh6IIOE7Klqcok92ZQrpCV4CPgMPsseZxDyUlIV5vWiQom5xHW90Bagz4E44qzlu5kT0Dq4xJ6k1zg29gEpFaLxsIW86It4vlRingeROLgRiUOBBgvVEzgtG3/961+1cyoHUIkj4CIXbQremJxpd424CZGXvRLCOUBsJEfKzyOPPFJPQnSrLJc4lJWuDVZIXI+0fQ5CQNQCoRyToRl5mT59us7n0qvBFqfddtttzsjLiSeeqI+L3HQ5gDgUYZ0NyAvfU+reIoDIAcI/nKG5gsMpIUylescmKFQ7uCIv0mjMt6V5HnEoEQ6X5oDvCdGapAHyg/ATsmtGXqhkQM/h0vQQ8XBFXqiCStrSPK841CboCJx5PkRrkQZICaXXjGcz8sK5Rc9DxM9uoc694Yq8TJw4UR9XqHYotPeH3Zqea8PzeduDl4JIHNyIxKFAgwVHTK/+UNFYXuAYISisblll0neBlR6rKt+qXiYJmtFAGpgs+Dtp176swBGz4gkVjeUFxMiMvOBAmRghFL5rTtQDknTooYfqiV2qT7I0eErDmDFjnNUzhMBdorG8gICZkRccE+cC5b2vGsSOvEBmOSbIQ7mAI4a8usSdfFfSniBZQHqNcmHGPKQEh8y9QJqQzeJcsCMvMiYZs+WCdPy0BYyIE3k+rR9FKCB/ZuSFFT17TlAR5Nt3xo68kFbgfmCxU67+Cr4+NsxRPJ9XdFkKInFwIxKHAg0WtlxGW+AqEeQmLydwQkyUOAw+m1bSaXX3EBjOC05HmiWVE7SzpfzRxj/+8Q9nmV45Ii+o4HEgKOLTNBQSeWHlxfEQpi4nKLslVeDbf6RcWyEDbCW6hDPAWVMRkbYJGc6ClSrv43ioAipnUx7KbiEzLqfN94WUBIeCsU7kBTLAGOC+Szu/EnlhC3ucZmiVRiiEnNtgxc/zIX1EskZeIIPMAVRzpWloJPJCVI7zQJoyS4OrNEjZrR3xpOkczyftwFtXiMTBjVhVUSBA5Jo2bRr8fClo27atOvHEE9WXX36pVctjx45VLVq0SHzPUUcdpasHpk2bprbYYgv9/vqyH+StKnGhVatW6rTTTtMVIai1L7jgAtWyZcvE9xxwwAFq5MiR6pFHHlEbbrihrtKoT/vLOQawdfTo0bpyYtGiRfr6c06SsMcee6gjjjhCPf7447rS4KKLLirrNfFVVdSF/Yz1s846S/3yyy/qu+++01U3bdq0SXzPb37zG3X88cerp59+WlcbXHHFFfVqfzm/a+mll1Znnnmm/syvvvpKj+W06qltt91WnX766WrWrFm66uaaa64p6zXxXee6uP4RpSFeiQLBV3JZSimmD5SOHXbYYWrw4MG63HDQoEHq3XffTXwPpVx33XWX2m677dT06dPV2WefXdZj8k2cUoZVzolj9uzZuoQOWyg/wynMnTs38T3jxo1TN9xwg9pmm23USy+9pE4++eTqSa0c8F3nunAcr7zyiho+fLjq27evLj+lZPXFF19MfA+O4sorr1RbbbWVLj099thjy26/6xrL9S+n/W+88YYmwdi++eab63OBQ0zCpEmT1IUXXqjLDT/++GN1+OGHl7VEsD7H/7x589TOO++s1ltvPX0PcC889thjie+58847Ndnq06ePWrhwoTrwwAM18SoXfNe5Lq5/RInwRCIaNSoVniJ/ThgwVDSWF+R0EQIScidkixgMUSIdIl3NmwjHylba5OH5W4Rxodt9hwD9BKVgoaKxvCCnixCQ6hFC9ogBKb+kQ6RPuU+ppOwKKVtLS3vucoGW167NfHyisbwg5E9OmwoePhPNC9oa0by4gGqeYyCnzXVA21LudAUNygib+zoK+vLvWUHFCCJAhJCk7AiNk37gu33NmxiDpKkQyKLxoETY1LyUAz4RNPqCcnZORGSL7ZwDzgWalwEDBuiUlU+AiP6AY0MgS8pQNC9sppe1tbwPPhE085VrD5P6QExVuBGJQ4EGCzlTevzbwEnlbblsA8eIAI+crmkfpVhMJIgTpRQP4BRk9zxbPS57O3B85QBOCAceKhrLA4gRNfrkdE0hIPldxGGU45m5dHMPC7b7NY8BRydkqhyAhHBsoaKxPED8xzWGKJpCQPL7aF4YG3Z7bRGCUq9v2i8CSQSC5bg2fI+rc6bsYZGn5bINrjlttCFoZmtjCBSk3a42MrU9aJBMkoD2BjJRLoGgTwQte1iEtD1PAyQJESzVO5SfChBF02YavYe9VwTaHkgS1RhmVY1oXmhnXw7yJIJTW2tFxQ/Pl9onJg8icXAjEocCDRZ6AqD2DxWNZQXNXYgq4CBdPQFQrTOhUsePU2EyoNKDc+HaNZPJkhLKcpXk0RPAtQukrG5LBatLbKPszOWE7MgL9iHYTBKC0nuhXCV5iC1du0CKaCzrpkk2cI5EFig7dFUoSOSFaAQEE/ulaZBvy2WiYUKqSgXn2NUAS/ZqYPyWAqJL3F98h72RFJDIC9EoibxcfPHFNaqJfKSWDeJKBfcYZaI2ZK8G6a2QF1QlIWymFNnVE4LxReSFaKREXriv+W5XHxcgkRf+Xyp58omgZfOrvK28S0EkDm5E4lCgwXLggQfqG9fGRRddpFcCpUA2ICIcT3c8H+jOh2NhRU4YkhUVYVofmCzoeMnkUWrnwGOOOcbbOZPjKAWyARHh+KQOhGbkhesR0txG0jhJHQlDcMoppzg7Z0oDrFI6Z8oGRITjk8r6zMgLK2y+lzRNEtj2Oa0jYQj4HtcmZ1OnTi25cybOaNCgQTocnxTyNiMvEFm+l+ub5BRx+LyOCEwpYJwldc40IwRZQTqBbcapIErqwGhGXkjL8b2chyT72dsmy144aZ9TV50z8yASBzcicSjQYCF/SlmcDVazrBLyIusGRDgWJrDQSAKT0uDBg/VKpZRwKg2mXNuHl9o5M+sGREzQOJjQyZCV2F577aXTSaU06aFzpmt31FI3+cq6ARHRFq6lRBpCOxIyZigdzItzzjknsXOmr8dCyPWh/wSr+ZCtofkeCIxoOEKAcyVsX0oH1brqnMn1QYvB8XEuQxYZRJ34TqKgIZEEyBXk3tWRM2vnTLu9e7k6Z+ZBJA5uxKqKAoESKUrjQtXWIci6ARHff8YZZ+gNddjoiY2R0qotKOdEcU6J2i677KIV13mwzDLLlN3+rBsQoRKnTO37779XK6+8si65S6u2QO3+97//XW+ORHUCm32V236Q5xzwXtmA6Pbbb0/dgAgF+5///GddokfJLhtDUUGSBI6LaovevXuroUOHqg8++EAVyX6qP26++WZ144036g2/0l5//vnnqwULFuiNrnjPM888k/o9F198sdp+++31vUbFSV77uV/tSo1Sq2rY4I6KmGuvvVaPzyTwXZdccon66KOPdHkmY+bJJ59M/Q7GDJ/NhnpU7OS1H9hjoC6qiiJKhIdQNGpUimXC2l3bSrPqI8WQFawUDj/88OANiAhnEzlg5UhemRUOfftJXYR0rWOljriN7nK+TaHSQt4ucRyr/rwRF9nYKGQDIsLZhHMRqNE3n5U3VR6sPkMU3byeEDfRnTxdLqXRl73CE7V9HgGaaBSIWqSBa7bffvvp84UgjtQAHUZJb4TsE8BKnfGL8DZPdERy3LY4TtT2eVI1olEg3ZUGzq+kZxAqkrag8oboE02oQlbqNDBjzOSZO6TRl90hVFqO54m4EK3jvZyHNJgbViFUxQYqr4iChEQq0EiQ5mHOyNPlVBp92fob2Va9lFRNXsSIgxuROBRosBCqxGnbjoMwI0roPJ+HHUkaBfOmZ5Ig3E4bXgGTFc6D0HXSrpLmTY6TI3SbN1Rpi6Oo6qB8LCtEuMZ5SAPOijbEhLPJqQuyOg9C9VxDQvdZxWLsicHx2m2fIY6EjrNCqjFIAaSBc06pHaTJ3ACJnPe2224b7DxI1TCGSN1ktZ+9Izhes9qhFOJI2JzwOSmgkHQbqUJeb25YBVmBTEPoEKmmgVQd9wr7WmQtU6QUEvvplGiCdCH3VNbP417kepICDCFNVIfw/ThU3NMAAGEOSURBVOxSat4Xe+yxhyaT3E9poCIJok2FRtZOr1Sz8P12uktSdaVofPIiEgc3InEo0GCRid6u18ehsathFrD/BDc7VQEhKyVWyWgAXOTAXHmw+kmDlOmFrPJc6nm74gGRJs4rCx599FE92bPlcZoDQziJBgINgIscMGHhCPg8VOShZWUhqzyXet6u10ex3rt370yfRYSE68WW12n2Ex2g5TikyXV9szoPRKLYQQvtLBD1vB3dgTgi2MwC2jNTicTeEmmRGqJDtE/GObuuL2I9IjGhJJToXui9ZwLRLt+BpsEE+8IQ9cv6WUTvGNdp0T/sg+hCmlx7z0BYTKFs2nhiDuFeIdqZhTwS4eI7bIKKxqtUcXheROLgRiQOBRosop62y64I/eI8QoEAkhUaZCNtlUJZGhUECCft+m3bebAiDXUerF5Y7eDAQyEiKFvAyOoFcVsoSLFQckfpma3Qdr2WEkQmpqRj5XOoVw91HpSpcq5oXhQK2T7YPg6uYxbiSKMkHA09QdL2H2F1TwkiUQLIpg9ZnYeUqRJFCQX9Q3iPLbCDODIGQkFZKdUpNLhKK2HFWVGiSZQoqSoG8iGluWlVFma0j0qBrPOOHdng3nftYZO0EIBoEaWzd3q1QUqBRQH3alJVjFmai2A0jYxJtM+MXqQBggN5Yc8OE5S6ZiWO5UIkDm5E4lCgwSLbx9qrfsLUoVvXMhGQY6Qfgr1ZjA0maBwmpZchWxbjPKSvQ5rzwNHiuHHgodshoxHgs21nywQYWidPtIYcM2TIt9OjAIU9qzLy0q66/lKcB+eKVTwELuSzwcKFC/Vnm6kCQLQhlDgSHcHJ0EgqrXwR3QKNgOgdEVINksV58FocPlGc0DI6xgyfbRNTok18VgiIHhA9wy475eEiqmiHIFlJpNle/XKMNGtLWslLJQNRnNDtoHkPUSJ7x1XGEVHH0HNIlIFxnVR2DNAtUcVDaiGpRNOOJuLcIfJpqQgiRURxQipZBFTV2Duu7rPPPpmIYzkRiYMbkTgUaLDg6OxVGg6Imy+kLJIbmVp9br6knQSZoHD8TABDhw5NJRg+50H/hqSIBvbQUAliEnIumfRdqzScb0hZJBM5Ox6mlYViAytCziuvT1uVJTmPpIgG5xUCxzkI2dmS48LR2H0jII4hZZE4clIK6DHSiACrOsLJTMi0IM4C03kkRTQQ26LNoalYaA8GiKatyYA44oRCzh9RIaIHaTsp0hsDJ03PArNTaqiIk7FDGiQp7879yFbtkJik3ikmIHH08zDBOYSEhAA9A9EDO91hg+gK44SoTOixCZifGKc77rhj4n3N/UjvDMS1aSRGwP1CPxcTRERIJVUCkTi4EYlDgQYLEz83vdmlEXEix5KmLZBa+rQVDvlsVm98JlGMvK1iITKE4pkYkvZQYLUdmjYBTDJml0aON7S5EKtgJvQkESPkhNp0aaGcp/pDnAeOl0ktiRSgEA9NmwAiBeZ23UIcQ5oL0bIah55UQcIx4Fywn+hRyDH5nAcOGuFoEilAr8KKntelpU0AaSNbWBtKHBk3aRUknE9aZPM6SEbIMblAG2wcL2mepMgGpCw0bQIgMoxPE0RFQoijNKKiksIH7ne0J7wOAWtewSHCS64L1yupvwRzA91aIX9E1NLAnhkclwneT+fOSiASBzcicSjYYLHTEtKnfcaMGYnvo7skr8OhJaUCCGOTz86Se/YBB42j58ZOWlGQeoBkkPdPg726ZFLCLrPSI6nsjDK6kHx20nkKBeFdwrykhmwlvAk0CxBCdB9psFeX5OuxK62cVLpL+lpj2/nsJOcSCsL7kAIiCkmNtXgdq3scdZo2gOMz0xJCHBGcJoHzA2kySZfLiSFyZSzSxr3UFslUARAhIKKQ1FiLlABCTUp904i6nZaQxUTSuJZ7EYKZ1LAK4kJEivNJOqBU+xHxij4qKcIhQk2ie2lEnbQEUVMTRBDLuZleFkTi4EYkDgUbLKxgqASwdwZMWtXA/tMcM1GILPnsUCDkRLjExJCUy5R6+jQHwKTB5GHvDJjU8ZLyrTTHnCefHQJSQtSuoxVJ6ppHaiCkLTFOA+dh7wyYRBx5TZpjzpPPDgERBcgOWgZ6X/hAtUJIJ05IA+TBJo5JY4u0VJpjZpxCSiG6pbZGNwGx69+/v4700fvCByoFIDZpkQO79FqIY5Jwk1RDmmNmnNKVlfMUUhkVCtJ8aCq4/5LGNtcPYpMWObBLr0l3hcwbdYVIHNyIxKFgg4XQP7qDtN4GAjb+gRAQ4vOlAiixypvPDgEhSCYtJgby8y7nZaZSktoSE6bEFru3gU+HQJqA8D6RBF/YvZR8dghYyZHvxjGw4vc575C2xISpza3VqXRIIo6MUcSdhMLt7YjLkc8OAd+L3iEt/RXSltjeIdXX28CMSEDccDY+rQ7nkFUrotnQXHsWcG+id5H0l+8+lD09KLv2gYiJuUOqr7eB+d2MFxYEPjEw1Vqky4iMUaZabkBWZF+PpPSXpFKSqrK4f8yt1Un1pRHHukQkDm5E4lCwwUITGnOHTIRirh0D5YaFDLCKdnWV4wZGaFRqPjsEHItsv00FgIvoiOKd7oqkTVzgeM0dMmXjH5czxkEReub8uD6vXPnsEHAsTPp8F9sPu76Lc0RXTVaHvi54COPMHTKFOLo6UXJOIFpEO1wOsVz57BCI4JbvYuXv+i6OB4LFqtfnwPgMc7z7mmIJcNhEO1ydTTkmhKxE44jk1OX9LIJbvouGUS7dD6+hrwYk1rdFNOMdci3jXZpi+QgfK3gWBa4oGp8hW3WjsQkR6JYCEdz6dD8cDyW9vMbXTE42upLxTgqIv+uC8IQgEgc3InEo2GDB0bEy8DlSEzgqJipX6JkbV/LZ5djyOhR0qWRiIOXgajtL6JW2xKRkXM5lzJgxOoLic6QuMZyrV4KZzyZNUmo+NxSsJnEM9FBwbQMtNfasfl3O5dJLL9WOUI4XR0oOOWkF50oRlDufHQrC4BADX3SD4yJkTtrENT6k/l9IbhJxJDXg65UAcYPA8X/GUNaui3lBGiRJ98NxESFAy+SKftlN4GxH6mpR7dq9FeJOAyb+TzQgrwg4KyAEovtxpRe5rpTX8hpX5ReiU46ZXiRg8uTJ+u+6Jj0+ROLgRiQOBRssODnCygImf1apNkT7QPizvvLZoRA9BWpy18qKnDw20lDKDmvTbRJnLxM9W1ujyLeBXYT9CX8n5bNZsdU32AYYPQUPV4ULx8exsTK1HZpoASTsTskr5aw2OK+sTPl/feWzQ8H449pTFuwStUIo+J+rLTFpDOwXp+ojjqxAIVikv1y6C7ZQh8CFdPosN0zdjystA6FkbHCMdnrJbgLnI45oP6hq4B6ySRXknDJQCHxIu/lyw9T9uETYkACIBa+x00uyhTY/AQ2kzAhMfSMSBzcicSjYYBHHwYqDSRWnSbtbE4TlCeeyorYdr5nPTurlUNfAOTAxMnkRwrVvfFTwspmOCfaJkLbT0sxm9913rzUxkp7B8dgrKclns+KzO3DWJ3AOTN6QG8idfZ1EBW+L5cRxoFjHNmznHNhRCxwz59deidZ1PjsURBM4bjQN6B5sgoTolbFhi+XEcdB2mvcQNSB6Y0ctuL5E4uzNtNACSKWHOJ9KAN0PIldsOeGEE2qlCTk2iA+pFlf3UKoUpFunqfmQqAUROyoa7KgVVVhE9EgHhmyhXlfgGg0fPlzbQvmvnbojGgGxoD+DOTdI91DEpNJwzbXxX30hEgc3InEoyGDhu5gsRCeAYyDNANtGac7kwyTBBIQGAgGVGb4z89msQiqxIYwNiA+OgWPCAdoCR6pAsJHVMxMNZYtEEHg9ERP+R5ianDmfQ56byRSHRETDTAXY+eyk3hL1BRy/2IPo1RamkkLgeAnv4gBxptKqmeuPY+X6Yw8pK3Qs2IlOgIiFTQxRtddXPjsEXCuxkfC0nbqhQyK2QvZwLDg6KSsmysC1F3vQ6EAmRSdANMVu8kXqgvPVr1+/XDtJlhscKxFEbOCetQWuRAOk4RsEENJD+gmyhbMkYgK55L2kHeR6QyY4N5AEE3QchYzQadSnIapv+0mTcqwQHVvXQ4pNUk3Ma5BFIo6Me+Y3bOFcZN2npZyIxMGNSBwKMlgI2/GdTLL85MFNw08mDn6SF4XFMxGZKmszn41GoFJhPR8Il+PocIamiAtiwaRAVQCrStt++ZtyN34nvM0KlPNiViYQ7pV8Njsh1lc+OxSkSzh2rp8pCuM4iUowSeIczWsuD6612E/oG/GsrMjM80gJb33ns0MBISQKANkzm3MxTiFUPE+DMJf9OBHOEb+zQpXqBTMFYQpz+X+eLc3rEpTSQoS4fubOq9gPyefekNW5y34ExfxO/xWEx/xu7udgCnOpbsmzpXldAoLDPc71s9upk2oiQirj2j4HjH+IYqUQiYMbkTgUZLBIG2PXg1Cl6VSZSGVyIJ9MDrxS+exQsFqCHDARms13mDhkVWXbLRMITavsvyU3SkifvyuVzw4FIVhSK1xDogqSuiCSwuQoxMkmTfzkf9gu9jMepAsf+4Bw7iqVzw4F6SVaFEuTJiE3pDE4dlaktv2MC35CnPhd7DeFlaysiWbwf/LhRSPNAqJtRIo4fvZdEW0HERaiJKRdXKSRMcC44Xd5HgIq0RuamkG+0kqBKw3mUulYS8REUhdEGIhIoAmR623az9hA59EY09ZFRiQOBRks3PCEpO2bR1aatkNh/wMmXSYdohVJnQuLAiZL6tyxYdddd61WkMuDELPLfoRktv2s0knNEM5ECBm6kVIlgbOUttA4UYie6SyEWNj2k8u2HWr79u11qS6rOBxpUm+MogCyhBPARsgvCnrTXqqAbOfJQ6Jxpv3oOKTmHz0D2o6ig3uc9AzOkMoKoi9CCLAb+10LB7Qstv3oeLAfATR6hqSdTYtkvxAFNFgIZyH8ck9L1M1+VHJBFImDG5E4FGiwsCphEpTJkxAuDsK1EpMJlxBtXfYnqAsQZmfiwwZZSROuRCVOSFfsR01OJMUmE6b9rF6KoOfIAhwGEz42yDmAABGKJqQrtkEK+J3nbfvlHBHibWirIdI1rJrN64gzwaGy8pbnxKlwrnz2058i6yZllQa5fMa5XH9JSfA7qTt5TkgFegdXJIYHAkyiOQ0JVFXJOBdbxSaiZ/KcXOO6aNoVikgc3GiqIgqD1q1bqzvuuEM1adJE/73SSiupNddcs/r/TZs21f9baqml9Gs32mgj1bdvX9WiRQvVkLDrrruq7bbbTi1ZsgTiqh/fffedatasmWrTpo3+Cdq2bau6dOmiFi9eXG0/WHrppdUKK6ygevbsqTbbbDPVsmVL1ZCwww47qCFDhmj75Rz88MMPatlll1XLLLOMtg+suuqqap111lHff/99Dft5DTZvvPHGqnfv3mrFFVdUDQlbbbWVGjZsmL6u2A9++uknPd4XLVqkzwNo3769Wn311dWCBQv033JfNG/eXD822WQT/eBeaEhgzO67777V1x9wLlZZZRX12WefVV/PDh066HPy4Ycf1rKfMYDtzAGMk4YE7ttDDjmkhv3cA+3atVPvvPOOvu8BdmHrWmutVeEjjrDRBPZQ69lGjq+//lq1atVKffXVVxWZlE866SR1wQUXqNVWW02tu+666tFHH9XPM4l+8MEHeuJ5+eWXtbPZc8891W233Zb4eUxKn3/+ufr000/V/Pnz9U95LFy4sHpSMh9CUpL+5twwuZkPbnpx/D7cddddaujQobWehwDhQAYMGKAeeugh1blzZ02cHnvsMf1/zgeTaK9evdQbb7yhvv32W7XTTjup+++/P/H7mJyw37adxxdffKEnrRB77b8hL6btODomuzT7H374YTVw4MBazwthgFQ9+OCDmjQwmT711FP6+Y4dO6qPPvpIO4v33ntPj8/NN99cTZ8+PdV+rrNtOw/OS177l19++Rq28xP7IbZJmDFjhurXr5/+XhN8Judgm2220fYz9iGSvB7wHVzDrl27Vh979+7d1SuvvJL4fXxPkv2cnzR7Xc9hv9gtD65Xmv0vvviiJny//PJLrf9BCLmmjJH11ltPf8dzzz2n/8dnQ6Ig01x7jn+NNdZQ8+bNS7X/yy+/dNrP57nsDxkDHKvLfhnHPsydO1ePYUiiDeZdCDH3PNcfEvnCCy+oxuoLiorkER5REYwdO1Z16z9Y/eG0s1W77puqNi+9pFcYTHLbbrutJhKy+pg5c6b+G0cik4HtIFnFCLMXLLfccvomX3nllfVnmat/edjPmX/zO5MRx2QCp4nzsB2K+Zg6dWqt90BufvzxRz0pTps2TZ05/jo1/u83q3bde6o2L7+sJxBs2X777fX/xf7Zs2erxx9/XL377rtOYiD2S9RCwOdhP46Jz0qz12U/k4mshgVMrkn28zfEyWX/zz//rIkSpOm0S65W1952j+rQY1218quvagcCaYJUmfYzqWI/zsNlu9hvOylImtjPMeex/5tvvtGfbRIAjgv7Xdddnrv77rtrvEfs5zMhnpCGP573FzX5wSdUh3VWUyvPnasnba4xhAv7Ba+//rp2MhBqn/2MC9t+VrLYz/flsZ8H9vPZtv18ps92Ho888kiN4xH7AdcZ0vD7sy5WD814Qa3eYSV9bbH/7bff1tdfFhLg/fff169Psp0HhNwE84nYz/e77Es7BxB3PtueW2z77bHAnGWSBr5fPpffuZ6/O+18NeOVt9XqrZap8dkRxUCMOBSQZZ5/36vqqsffrv77m5m3q3afzNA3KhOkL0jEMTMZ8GDylt/tB/9jgioHmJCYoD7++OPqxyeffFLjbx68xpwsmbg6deqkw7M4cf732muv6VXWV2ttp75erW/1a7+ddYdq88GT2rESyvSBaxViOz+xX5xvKeCYTPtdtvMcD14rYFXGapHjwX4mTuwnqqI2Hqo+X3WT6td+N/tOtcJbD+v3sFrzgQhIiO08eG257Md5JNkuP03nhYPg+nNMkFjsxzbSDitstZ/6pPWG1a/94dm7VPPX7tfHPGfOHO+xsAIOsZ0HY6Uc9jNusT/JdnnY9sv157i5p998801NaDr+5ig1r+X61a/98d93q6YvTtX3CtEKH2QxkGY7D+aKctgP4YE8ptnOwyQLkDUiqJAKSTW+9dZbehysP/xE9eYya1e/9ndbr61OHtxNNUZfUFRE4lCwwfLveQvV7lc+Xev5n+45R338sjskfdNNN6ndd9+90FoHSRewaiIUCwjpcp6JNKBxAC07baDa7jO29gc8eKF677n/pCxsXH311WrkyJHVufGi2k9aBOJHmJq/XfYvu3o3teq+F9Z6f/PHx6u5Tz/o/OxLL71UHX744dpxFBU4RuzHoWy66abaZpwn9uNQIcVJ9reaOVG9+EjNSJVgzJgxatSoUWUjw3UBSRfgQLfcckv9O84TDQPkgzkHtFitq2q330W13t/+xX+qmffeUut5nP8JJ5ygTj/9dE2simw/8yn2EzXhp9gP+eB/SfZPObKf6tWp/rUskTi4EcWRBcM7C/7jQGw0W6mDzvkRypYcuvxkEioyaQBMEqyYEHOy4gFMmOSeq0lDy5Zqt30Pc77/l+Xa6Jw/ugfJIctPPqPIpEHsJ4RL/lbEXrb9OH6f/d81aanTOLxXcshiPw65yKRBHBxpkQ022EB16/af1SMOg7FbTRqWXVYNGXGQ8/2fLWpabT/RKtv+IpMGsZ9oCpoMxIFA0n2kPADRhkHD93e+f97CH9Xaa6+tH7wOSIoB+4tMGsR+SALXHuIo6VHGv5AmruvAYSMzzYsRlUHUOBQMa7V1Vwh0XGEp1WxxW53TlHwoP5k8x48fr/Omvryq5LHrO7pg51r5SZ6e1ab5WgET4dxnn1Sq1zq1PnO1FZZSSy1ZVb9fUh78xP6JEyeqWbNmefOqkseu7+iCy37EjSJIldcKmEzfeXGmUhutV+sz11ipuWqm2mv7JeWB/ZyzG264QYfwfZqSEMFqOSHOzKW3YaUpVQLAzo9/9PrzSm3QvdZnrrlyC9WsSXv9ftt+KpHQAfh0FSGC1XJCxJguzQ3Hj7DXZ/+Ct+co1W0j57zQtFnHGikv7n/suu+++3TE0Xf/hwhW6yK64rKf40eXI+lWM+3K719/8IZS6/dy2h9RHETiUDAQjjti67XVBEPj0HLeU2rWfbfWEjYhbGSVThSCmxJ1OROT6ZgAkwaTiD2xMqGwes2jqKaiwyXE8okRJf/KMXC8VIWYkyaVBKjH33/+CbX55kPU84tW+e9736ttP8eO/aw0+Ty+89VXX9X247RMMLny3fbEKgrw0CoC82/Ij8v2NDEi9hM14RqZkyYlijj/N2f+r9p844Hq5SUd/mv/u0+qGf+6ufpvjhn7IYScV1bhiDQRCmJ/mmBVnAoPzmUe+8lX+8S4SWJEuf68xgRVFuS45zxxr+rbvb96rUmn/567d55QM+65ucZ4Nu1nFY7NTzzxhHZMnH+fYNW8B/id48pjv2h7XM6R50w9i4xZ034IpAlW4Vy7F6bdpfp06VMjx9/8rcfU03ffVMN+EbYSpSESw3ii+kbsdwlWXfYzLkOrSMy/Rdvjs98WYzJmRV+BtsWsBOHziMJANmY/MFltusbG6r3l/kuej9xm7YqkKSL8iBqHAua1uKnW3XwHtV7v/qpV00Xqqak3aidpO0RAiJIb1UxV4NRMUZpPuMT7bAefBSJGTBNiiRhRMHnyZLXXXntph8YkyKTJpEcqAoEY5/6H5dqprn22US0Xf6um3zNJfwaTkg3sxh7eI8CpiSAxSbDF55ViP+c+xHZbjPnAAw+oQYMG6YmYxxZbbKGdHg4A56nFgq07qa6bba2a//SVzm1LKaoNJmRZbZcqWM0KbAqx3RZjPv300zrPL1Gg/v3768oQCAAaGGxqvlpXtW6vfqrZ95+rZx+8XTtbqips8Bms4HlvqYLVrBAxZprt/N8UI7700ku6HFGqeSg/xX5spDoKm9qs11ut1rWXqvr6U/XSo3drssnYcIHP69GjR8mC1ayQyqQ02/lJmkLsR+DM9RL7t956a33/yxjnnuzce1vVutP6aqkfvtDjvxxCzoboCwoLT2OoRo1KdwujfazZKY5WxHQRdLVjZUfAcrSCZcMlWiKzSx2toelGyeZR7IlBZ0Y20uJ8sOsk+ySU0q2S/RU4drpk0kGQroE8xKZNN920ug0tP3fYYQfdWdFlP7sJ1oX9bJSUZD//ywt2bqQrHhs/0RWQroHSJZEH3ROlmyA/2T6d1uIu+9myuxz20w46i/2lbKTEPiN0CmTjL7b/pkOi2R2T5/gp15zuiGaXSXlwDk855ZSK2F9Kt1K+g+tNu2w6KGIbHVLFLsYFP+mkyk/Z48Lcr0LuD3ZNrS/7uW7lsJ/vwzbmNPZd4Tqa8xst9nmOzrH8zT4+jdUXFBWROBRwsLAVr+lIaT3NZMKNZE4eTLb21roNAUxOtEpmcrAdIpPhTjvtVMNJMJHI7oJmu13OUUPYo8EGJIVW2djish+iZD6HU2ETIByNaT/Egq3YGxpwUmzuJduG22TA3rOB68x+FbQpN+3n93vuuaeqoQHHCeHBLrHf3KNDdkOVB/c8G7lJC3JzrNi7TTYU+9lunfnLZb+9Nwd2Pvnkk43SFxQVsaqigCDXTVhMQrnkbwnjkaowG8UQvqS0ccKECd7eDkUDqQhC0wj6UJnboVJ0D9hIaFPsl3AhP8VOUhQotAlzUo7YUOwnFE0TK64ZokVfqJjQvtiPnoRQrbSeBoTzyQvTEOmcc86pJbIrKsjtk6YZN26cDmPb9kv6SioHAOkUKi8Iwcs54XV0UN1ll110KWIpKZf6BPqD3XbbTZ133nk6hC/2y/jlujK2TTEn15bUi7SbB/xOimvvvfdWxx9/fEkph/oEWowRI0ao0aNH17j+Yj/2uSpE9thjj1ralYgKotLMpYioNMtkoxd7YyNJWQgznzRpkk4XHHnkkfrvvffeu/Cs+Pbbb9ebWRGKJlLw3nvv6S2RbTtJVdipGezeeuutq/+eOHFird02P//886oi495779WrZnb2fPTRR/XWyIMHD65lP9dfwtTmqosdJeVvtia3d9ss+mZHREfYsIqN2+6//369NfawYcNq2Y+dsgmaaf+WW25Z/Tc7oxK5YIdQ/sfY+OCDD6qKjKefflrbzs6e7PjI5lz77LNPrXHOPcH1t6Mr7KgpfzPuWblfeuml1bttsnV9kcEOtqTmiJyxMy6pj0MPPbTWOGeXTOYJM7qK/QMHDqzejr6x+IKiIhKHgg0WJgOfnoFJZYMNNtBpC/PYCFfyHrZfLuL20tzsZ555prZhzz331BOG4LLLLqsOx5q7grrs59GrVy898S5YsKD6M6ZOnarTGExKRUxdcE0vuOACbd/OO++sc8SCa6+9VttFyFbs79y5s9d+HAROxXSS7LaJXoBxUcTtpbEfLQqT/4ABA6rmz59f/b9bb721Oh0hRKFr167O7cWFVECq33zzzRq7bbL1OqQEQlJEcJ25xpAfCKNJJrELzYPYvPHGGzu3l+cBqeBcvfjii9WfMXPmTD1mcMhTpkypKiIgCmhW2P2TBYPgscceq94BVuwnVSH6HvtxzTXX1OtxR+LgRiQOBRssH374Ya2bhUmEHOdRRx1V9cwzz+icNxoBE2+88YZ+DZPTFVdcoSfrIgBR1e67767tIK9pHhfbCzNBHHvssVWvv/66njAgALb9TCgbbbRR1WGHHVb17LPP6tewUjU/i8lo88031wQEMVV9r0x8QGA2cuRIbQd5bfQNgpdeeklPpgcffHDV22+/rXPbrLRspwGhQDB50EEHaU1Lu3btdITBtBFnhFPhXLEaN7+nkiAqxHXDDq4zURJzzEJ4hw8fXvX+++/rFSVO0RSKiv2I6BjzbMkMQeRcmZ8FGRk0aJB+/cknn1zjf5UEx4HdHBera0SHgnnz5mkSjPiV64cIlPvBdQ+sv/76ehzNnj1b61241zm3Asio3Gd8n/m/SoIxyrjnuIiumKJiImSQXSKp/M44YPwimLbtR0TK+7n+9YlIHNyIxKFgg2XGjBn6u5lsSUcQtmeVbuIf//iHfs31119f43kmJVTWsrJHAV1J4AwRtUF0CM2aIEyL4JEVtExyODuxf//996+64YYb9KSCWNLE5MmT9Wv++te/1hJdnnDCCfp/rOzNqEQlgDPk+kEOuJY2ocIZcH6kQoFJFjLB8Y8YMUJfX5whq1QTrKp5zdixY2s8z/kjsoOjZWVP9UYlgTPAweMM//a3v9X4Hw6ElTUOQe4ziCDhdmzbY489qq677jpNECGNJp544gntYEaPHl3jec7f+eefr4kX38v5ryRInUGGOJ7LL7+8BtFlrJKSIm0l45T/c82wHxLBOYMsrLXWWjU+F/LAOUVgaoL3E8Hjf4w7qpcqCa4r9yHjkbFq2s9Y5dwQXTQjMJwziCP3/NVXX111yCGH6NdUCpE4uBGJQ8EGC6FGvlvy1QceeKBeSZvgBmT1xeqMMKUNHCvhbCblV199tapS+WxWU+gZcIb28TMxsrJ69913a/zvf//3f7X9Eor+/e9/r9MzNo4++mgdXUArYAOlPRUoEJP6XqHY+WxKTomS2PazeoJQvfbaazX+x/XEfqmWYbWGHTZYVeM8//Wvf9X6H+eQqASrOdf4qA+QMsMpchxPPfVUrf8ffvjhevza1+eVV17R9pN+AOeee66+ljbQNvA6Uh02UOBz3kldEAqvBF5++eWqLl266GN/+OGHa/0fjQLj106tEYXALlIYAMJBFNGOIEqKD3Jlg6gkZIPUxQMPPFBVCcydO7eqW7dueh5yjdGzzjpLEwr73BA5wS6pFsE+/jYjNfWJSBzciMShYIPlyiuv1CsUCUOfdNJJtVYcAGEkKxacg0sUhuMlvIvIjL4Qlcpnu1b9pBI4v3fffXet//3zn//U/5M68bPPPls7ABus2BBRQU5cKytSF+ghCP3fcccdVZXKZ7tW/VdddZW2kbyvDSIz/O/jjz/Wf48bN06vwGzHwYoN8sXEjLO1wfshnDjnG2+8sapS+WzXql+uMStKGzgS/kcaA7Dq5m+utwnOB1EZvsel60F4SeqG1bfre+oSd911lyaFpJdcY1OuMcJGG6Tv+J/YJBoQInS2/aQ+GGeuUkUcMNEqyCVjqD5Tl2huIC2kVFwLl4ceekiThjFjxtT635w5c7S9QvhEAwKhqgQicXAjEoeCDZYzzjhD5/gEqOcRDrmAc2BlRVjS1ZBHQoVMHvSGqOvJw8xn/+EPf3DmmZnkIBUQIhcgFeS9BUz6TDKuzyKsyaqOiITrWkE+SNm49BX1nc8WEH1gskev4gKkguslGgVSHL6xiMgU58Q5cBE0yCUpH8n717Xug88/9dRTnfls0zEwnvfbbz/n9SA9ZRJHokf87SLHfD5jn3tAiJYJyIZUHfnGYzmBPRBdxuvQoUNriIDN9B1kHj2Cy35Ih0kccaD87XLA3G+IRQnl25E7wBiSqiPGY13rHrCH+YrxC2kxRcCmhgshr63RMSOVHC8RC7lf+JsoSiUQiYMbkTgUbLDgeFmpCVgtcizkxF1gZcJETDmmayJi8jjxxBP1Z5D2qKuQX1I+2xSwoX63hW0mjjvuOL1SMSsmOHYzD2o7IlbdECSXIJDJibAon8E5KqXjYd58tgDNCakbhG2+64BGgSiSbyJ1OSKiLjRNslflgOOAjOHMiFC4nFk5wL3C57vy2QLIACSPSJiv86BNHHEY2G+newQQCs4X0RVfN1O0MFwXGmvZK/dyAXsQ93GskH+XU+SaQ3SIILqcqos4ksriM10pObmnqKjo2bOnd44g3A9ZhWSYFS3lBLYxv3Csf/zjH533Ivc8ZbMsjHzHYc93XF/+rlSjr0gcGglxICfKzUmoEGZLu1Y7j1zkwYID5OHL+btw2223Va+qfSA8TNi6X79+ZRfNpeWzARMJgifSDkn19r/97W+1INKX83eBcCaTrS+KIboPCJYvfF6X+WyAI2GVyWozSbRG7h9iYef8EQT6gFMhX+6LYgDyzBAsHHe5RXOkFSADfL5vgodIEGXgGrhSKyZxRJvjy/m7wBghneOLYggB4/rUhe6HtBhCT2xjnPnA9cGBI270wSaOds7fBUozme8YX76oEvclkQn0Mi+88EJVOQGpl7SYLdg2wf0JgRP9igsXXXSRtkUAGcZ+32KkrhGJQyMhDjgnGDaTOcIrSp0o38rSW72SgwXSQ9RBICp7xHZJoASP19FkyQcqFhDs4eTL1e8hLZ8tGDVqlHbu5D+TQF6a3LWAECx2pYm8SMW4Kk1MQD6wnXPAuSgHiIgk5bMFrEI5Pru6xAar9iFDhlT/TQoi7boCGmLxOkpxfcBhQ3CIUPhWsFlBvhqRa5pDFl1Lmt6CFAerUnMlG7Iny0033eSsNDEB+UawV07dD06QBUqaEBftEsdHRCEJRxxxRA3iCBGCbBDFSgIpDqI9NARLIzjofsrV7wFNBhEEHklCXNG1pO07QWrFJI4AwseCsBKIxKGREAcbhMRMsU3RBwuhfLPMjBQAx5J2ozPBECpN278C546TT1sdlSOfbTu1tMkPUKJolpnxuWmEQOynzwGTbFITKKItRF1YHTGZ5QXfh7I/KZ9tO7WQyQ/iSAmaeZ6JJtilpy6Qx2dF54t6CBFBVMpnTpgwoSovpGuh7C2SlAKAXHGeGC9pIOVCSskEjj6JEAhOO+00/T0u0a2AexpixnGTjy9F98L5IzVHhCwpBQC54rpQIZQGOqCy2DGBhiOJEAjY8MwnunXpftBjlGK/RDH79u2rtQs+sOjhviSVkfZ9zCWkVExA9tAOVQKRODRS4kAYlZvELgk0waqGASIPnGsliIPLSRDiZ5JLW6kA8vesVlhVJ6UjeB2TM5NsiDPPk88W0MkQmxCphUxShLttJ0HOO2SHPK4jlQykTJJU2GY+lrr/rJNnSD5bQGSDyXXfffcN+h6Io+0kWM0Rwk4DOWTy+EQApCrBBcK/hM05fr4rq/0h+WwBYfG0MLoJukba/QnQvJDCSAOfD4nj+5Lud1P3QyQsq2jUPH/8dGlLBDQ2o8IAMWCIOJMmaCZxBBB9MwrpA9eRvg+kbZLEhKbuh9RY1mZhvJ7rzvspC0/aKZeIISkSdE0h+iqII/dWUhSyPhGJQyMkDtwgrC7sBjo2pB2y/ahv4uCLLuAISUWEANJDKJ5VddKNyrlhMs7qPHBIUp+dJljitYQZKctMmlxNQuOKLtBKm4kq9BySmqIUMyk9hb1EdrI6j9B8NoC8cC0omw3ZhlyIo51uwBZ20wwBK38cLQ44qQEY9kPQsjqP0Hw2gLxyLThfoalCoguQOROsQHGIIUBUR8MoBIiUZCaBsmHIL58dWnEgZZ5cpzQyz7Ug7M618IkhbbiiC0QgiESEgHFGUzXIZlIUQMqGiYRA6kLGp13mmRaxIQpHgzPEm6GiTFd0gUUOhKISiMShERIHJltyj2liuKJEHMiR8r12/p2JMEn45lvlpoUGTefBiiZtRYRQk9Wsrz7bnmCYMHltqJIdjQDHQmjXBMQP4VuW80gel5BsGiHI4jwoJQ3JZwMcJQ4TxxkqRpW0mt13gomayT0UssplA600QoAeKNR5IOojIhLSWIrPgrxCnEJr8CUtRWdUE1xHKlZCwSqX60QKIe2aIjok3UC6xVeVICCKgRPks5MEfgCiDGGGOCdFf0KIIyk40gGhgNxxnYheJKUQJY1EhIJzldZplnEl27unaY4Yd5AdooVJ0R8bfLZNHEnBIb6tBCJxaGTEgc6CsHfK1RrKYJFWwuYmMIDwMy14s0DESKiU0yDOgzCvz3kQBWGCJeSatnqCgPA6JgEmm1DgmDlmhK0maDvM52UBzpfPIiSbhhDnwUSJCDSkpE0qKCAvWRTsvJZjtjUahINxwlnA8bIqRGyWBjQB2IYo0XdtcZQ4AZxR2kpWKihwSFk6V3KvYr8toOVeZuWaBVShcE2JpqRF0yDEpDdYqfuiFIgAIc2QeFfPBBN8H4sWSECWTcf4bhdxpAcHhCULIHlcU6qU0uznvuNepaTTV/ZM5QYpBzRIvtJgE6SCfJ1NsxJHtEQIeiuBSBwaCXHgJmGiIVQXMsCLNFh87VXJj5MjzIqktsRZnAdiK4gFK7+QkC4iMF7PhJwFUlZqb4+NPoJJLSsQf/naEmdxHqzKEHcRMk5bwQFEgEQxULrnIY62Y2ISphoiK6QtMSHpNFCuJ47Rdh6cG1IzhOjTVuWmSM/enyPkGFx6JDoM5tmvQLpOhuh4cLREEnCM9vnHsUKaSNGEpBz4Pl9nzCTgnF3EEREq92ZWLQqEOFSUC1knSkGKx543OTdEToighaQcZB4jlZEFPuLIjpiu7qH1gUgcGglxwMmQJ6XcjO5r8giZ8Cs9WHx9+V0lSiFg5ZvUljjEeVAGB/mAvISIuwizcu5CqgBsjB8/3tmXn6gBIe+sMNsS+xoIpTkPSAcrR6IeIaSJvD/2s412VsiEa0d9KDU1a9uz2E8KipW3qy1xiPOAdJL2Il0Scg9RNooN9gZUIZDNy+wumFQvmE2RsgD9CiQ2rQwYYDO2cw4k6kWFCqSJUH5I8yzKPDlWW+AZGiXCfjb6clXl5GneFVoGDIh0Mva5B6TXBBURzKcQ6pCUI9VrjDc6VWYlOkIczS3DZVHD82mRrrpAJA6NhDi4RI6+zWCKNlgQK3Lj2sAJ4fzzIK0tcZLzkN4QTAIh4kEiBqy0yUnmASJVs922b/+OLEhrS5zkPCByOAFKxEJIE04WksE22XnK3OyuiXYb5jxdLyE7RJF8bYmTnAfjDidAE7UQRTxheUgGqvg81wqxIePHPneyt0OexmVcN0hPaNoMwkx0i9dzPUi3kCYLOfdECiAZCLLztLeWrom2kNTevyMLuA6kOUPTZkTbIAkQVdKcvI/0XMhciO4HkoGQMU97a7vdtm//jvpEJA6NhDg05MGCmti1E6T0Qchbc53WltjlPHAcfCe56hAngKARJ0NONe+eCKjJERPakP0a8rZLZqUCIUlqS2w7D4gG34lWIWSly4qeyAaCsLx7IiAKI+JjQ/ZryLviwhmktSW2Xw/R5DvR14SMGSI6kB5EjHnbmhOtYgzZIHrIsWTtACtA9JdFqMvrEePxnQhzQ8YMET2ihbw+b1tziVbZ50/2a0jqOBki1EXUK7vupr0ess13Ut4dUhFDcy2qv3h93nlTdEl2qhAyz/NZ9CLlQiQObjRVEYUBRK5pU/8ladKkSa7PXWuttdQdd9yhnnjiCfWHP/xBf08SbrzxRvXZZ5+plVdeWT3yyCNq3rx5ia+fNWuWGjp0qBowYID6+9//nmhDEpYsWVIn9nfs2FHdeeed6vnnn1eHH354qv2TJ09WH3zwgWrTpo166qmn1Jtvvpn4+pdeekntvPPOqk+fPurmm29WSy21VJ1c/7zntW3bturuu+9Wb731ltp///31eU7C1KlT1dtvv63f98wzz6g5c+Ykvn7u3Llq0KBBqlu3bmrKlCmqefPmue1PusZ57W/VqpW2iTE9YsQI9csvvyS+/v7771evv/66WmWVVdQLL7ygH0l477331I477qhWW201fZ6XW265XMcp18VnZ97x37JlS3XXXXepH3/8Ue2xxx5q0aJFia+fNm2aevHFF7X9XPvZs2cnvv7jjz9WO+ywgz7P9913n1pxxRVzHafclz77817/iPIjXokCgYnDNTn4ns+CrbfeWl155ZXqqquuUn/605+8N+7o0aPVqaeeqs466yw9YeIEtttuO/X+++873/Pqq6+q3/zmN2qjjTbSDneZZZbJfYw+xyETainnYLPNNlPXXXed+uc//6n++Mc/esnDBRdcoMnV8ccfrydNJs/tt9/eSx5wsDvttJMmZ0zOyy67bJ1c/1Lt79Gjh7rppps0gTryyCO99l9xxRXqkEMOUUcccYR2nl26dFEDBw5Ur7zyivP1H374oXaakIx//etfavnlly+k/euuu6667bbbtFM88MAD1eLFi52vg/jus88++gEh6tmzp76+zz33nPP18+fP1/Yz7h944AHVunXr3Mco18S2sxz2d+rUSZM6iCDk6eeff3a+jnM0bNgwtcsuu+gx379/fzVkyBBNoF1YuHChPj8//fSTevDBB9Wqq66a+xh9dpbD/ogywxOJaNSoVHiKahBX9QA5fnLt5YAo3qk4MEEaRLbgNeuoSVsQ5iZ0bW9Oxf8I6aOhsCsh8oAqEHaPLGeO39W3gc/iu8zUD79LNz2EffI/8q3k/OnGaZf28j/OCw2qyrFxGNeEFJEv9xsSZg4VYB5zzDG1Ul/ktPkfwj75H9eVMUkY2u7dwf8I6ZNeKsfGYVSBkO6xITn+pI3eQoHYlXuJHid2Sk32k0BQKv9jDqCHAmkIu3cH/yM0z7kpx7FR/cL326kxyfEntZIPBWkv0kF77bVXrZQaqRJb08M9RzUNaSi7vwz/IzXDuQkRX4dcG+y0K1cYd2kbvdUVYqrCjUgcCjRYaPJELtK3LXC5IKJHaePMJCktdKlssIHDxHHiQEW4RFkWf0MqyqV29pUdSk+K0O52aaBMjM+TNs44SXbu85WuYR/kAFulxwaTGw4V7YStgs8Ldjd1lR2KOLBcWyJTpcDnIcYVgsB38xylpDah4HvR3tD4Saot0ErgUNntNK/2wMa4ceO0uNCG7BBbrl09IaKIMM0eD5Q88h0Ie237udYQBGyVagvGIpohxIBpzcBCIWWHNqGRHWLLtaslPVkQ8UIQhKSgo+Kc0O7aJi5cawgCtorOAt0L5cmIJ8u1YZyUj9qNqObMmaOfD6kMKjcicXAjEocCDRZKSc2d8dJEY3nBxMiGQNjIhEkVAJMGk4cPKLpxkqwwIRKIp3ByeZTePpxwwgnOslOfaKwUEFXhM+kRQN8JORc+0P2QaguIDTajNEfImKUrXho4FlfZqYjGQqpiskZeIEynnHJK6rbsRFQQGBJhgihQaYDyPq9gzwXOP47IJbx1lSmWK/Ii/T44Fz4Bshl54ZojmqXiopyrYPo+uETQOGZXmWK5Ii8QNj6fiKdP2CyRF8Y81Q10WmVOSusgmQX0i3GJoGVr+bQdgusCkTi4EYlDgQYLW+qyoY2roQz9DcoJMzUBaUjbdwDgMCALTO44jXKETk2wHwXKdxv0kuA485R4JUFSEzxCNhHDceE4sZ+QerknMo6HVb2vN0I50kGurchDO4xK5IWoAE5j2rRpZT8eV78K6W8QUk6aBVxzsZ/oU1rVkkReuPY43bS9WrJCqqdsMM5cjbFKhZR/8mAuSLOfyAvzE4SJ9xAhKCekX4Vd+YPdrsZY9YFIHNyI4sgCwScOTFOb58UXX3yhP5fPR9yUhg4dOmjl+Hfffad/X3PNNevN/nKrqvlM7BekKc0BQklEZtiPCAzhYH3aX+4xgLBNgOI+DVTZdO7cWX3//fe64mS99dYr6/H4qkrqyv4vv/wyk/0rrbSSWmedddQPP/ygf+/evXuDHf/29cemNKywwgqqa9eu+lzxO4LocsJ3nevq+kfkRyQOjZQ4nHzyybrKABU5KvvDDjtMXX/99d7X42RR17/zzju6MuHzzz/XJXhff/112Y7Jp6qvi4njnHPOUePHj1d//etf1YknnqiOPfZYXXXiA3YOHjxYV5pwnpg8OR+ch3KhLqtKbIwbN06dffbZuopkzJgx6vTTT1cXXnih9/WQhd122009+eSTeswsvfTSutrkk08+aZDE6eqrr9b3AFVEl1xyiRo7dqyuJPIBYjl8+HB177336vdCoqg2SitVLur4nzRpkvr973+vRo0apSZMmKDvg+OOO85bbUMJK6W8vI/KGwg01/+NN94o2zFF4tCA4IlENGpUKjxFh0bXLng+0Vhe0BHQzOmT1+S7Cb+69hcgREt+F3GYpCdoSkN3PTZfCmkqFALU/K5d8GTPgbyNpVxiUzOnT4iW5ls8h0DNBk2DuC6IwyQ9Qd6VCgi2vA7d/TMNVHMgQvWJxso1HkUzghjVbL7Fc4w1G+ScUdaTopH0BFUEonkpl2iTccmYsnHvvffqY7OrevKC1A9jHU2RhOdF82JXG0n3UXYapSum7Ptial7KdVyMS0SLNtBRcGxpO9KGgrbYfM/+++9ffU+Zmhc7ZUGKkJbrvIfusLbmJc9Ggi74RNCya/AzzzxTVd+IqQo3InEo0GBBpEh3Q1cVgEs0lgfihBFHmmACYSKheoM9A8wuit26ddOiPXvXStTelGnR0jiku1zezpk+0Vge4ITRdPBddjkmjoT/mbvz4RSpdKHkzN7vApU7z7NjZNqWxCHgmrg6Z/pEY3lA33+uMep5236IhL3PCHntLbbYQrc8Zy8BW/PCuGBvk3IIN3Herr1aSu2caZd2ohfae++9a1UPIE619xmBFFM9AXG3N21D88L1QpcT0s48DT4RNPs/cFxZdpr1AeKLRoM9bOyOoFJtxP4WApw41ROcMzZ7c2le6Ehp7+ibB9x3LhE0YsxSOmeWgkgc3IjEoUCD5aCDDtKTtI28mxy5yrBYaSHCdDlhJlJaRrOyoHcAkwETA6sK36SFM4HUsB9A3lbLAqob6AkRKhrLCkR2TMxs2OWKXpiRF4RaOANW1AhCfYp2ibxQZVGqeJNSSCbhUNFYVrA1NsI2KgJc18qOvEAGqPJBSe9b7UnkhSqbUvts0GPEtX2ybHLk2/I5FNjAfURFiO9amZEXyCBliJBjzp0LRF7Y14RxW+p84RNBS8vtvLv9miJDriVj1bdh2dixY6ujcSwGBgwYoImGb5MwibwwT5RKHn0iaGm5HbJRXbkRiYMbkTgUaLBQGkXo3waKd9fmR1kgGxDR+CVp7wUcCpvi4GBxmEwKaaFIyuVYxebZEdAEpXEbbrihs+8AkYBSYG5AlLT3AuThgAMO0PawmsYppPUpgDwx4efd3EpAWSS9IkI3P8oCcwOipH4YZuQF2yEFaf0DWBFyblnFl2I/PTRIh9lgpYv9pazquYZ8NhG9pPNoRl6IJkAKiawlgT4DnNudd9451w6eAnqocI+67l2Op5TSZ+5hKnZIOaZtDS49PRiLEC2ISxLor5FlL5y0Eln7M4g08Hzc5Ko4iOLIAiFJHFaKopp2ubvuuqvaaquttLCxWbNm3teyz8KZZ56pX0Nvf0RztFNOAiLByy67TAvurrnmmsLZT7tk2ub26tVL3XrrrVrY5wPfg80tWrTQwr8TTjhBrb/++omf369fPzVx4kR17bXX6vNQNFU9e1TQFpgqEFpOY5sPfP8pp5yi9xugnTTtt9PU85xXBKO33HKLFp0WzX7apbOXApUwtMVm7wYf+H5EgrTQRvjI3ibsQZIE9uhgjxKEk7RrL5r9n376qW6LzR4a7MNBRUgSjj76aL2/y7vvvqtGjhyp29UnYe21167eCweRcV2JI+NeFQVCpZlLEVHJltOuFbdv18QQEEpl1chWuSGhbkLyRBrQNbCCImzvEgy6Vmq/+93vdKTCF9ZNA22gXSvuUhpgEUpl5cx5DRExkpLh9YjeiLwwDmiFHNrAivN1//335zrWc845xxmq9+V+Q4CIjagRefiQltXk7Wn7jUiTtJV00wyJJEhHUsSHpay47e/y7ZoYAq45Y5kUUIiIkbw9r6fRExFA0QOF2C8aAVMjk6fltB2qlwZYeUSI6GIQ8BI9C+m8aWp6SGnyvaSvQoTJokXifs0DhJeufiV10QArFDFV4UYkDgUaLIizXC2HaYxEDjErCEmifKYbY8ikS0iQCYOJhtcTdiVsHeo8CDGivicknKfLH1Ue5FPt78EhuToqpgGiRGiWkHNIfpwcMA4DXQOvZ7Lk3PtaMdvgfJEKIWydRwEvLYftUC0alzziWFISaGY4dyHNk8ihQxggTbze3L8jxHnw+uHDh+u0RZ7mYL6Ww9IOOauGhvNIjp4xHSIsxGZs5xyInoC27BwTYtK078d+0lWkrfI0K6Jig++y9/2QbeWzzkeMR8g/ac6QdtWMeca+dMcECGU595DIEA0PLbtJ8yFCzQoWHNhJ6qeuxLFZEYmDG5E4FGiwkMtnxWrnSWnviqApC5jkEIGRow2ZNMnTo5yn7NDMgZrOg0khzXkgkGLFygo/axWAiADt9xHJcO3hkQSOc+jQodrhhkya5E9Z7UM07PLCLM6DMcPkC9HL2ulRRID2BAl5ce3hkQSuGyJQxJBpOXoROUIwIJr292dxHggkEVTifLNu/CUiQHu8QhxxZlkgETCEvmgEQiJzEEyiMzbpJYKAM9xtt928okIBUaH+/fvr4yXalQWSy7erB4hkQMay6kckAiYlpEngWFlguDQ9RAIgQ8wnaVFL7o8ddthBR0izajK47thvXy8iGXmIYzkQiYMbkTgUaLDIZkb2hLv99ttrUWPWCgUmO7uEzOewcLCUVfqcPTsHhjoPyjZZ5ey6666Zei/ILoj2hMOETR19VqEhx2uXkLnAOYJgUVbpc/ZZnAdOiFUuq90sYjHZBdEWgUEccUZZQISIz3L15bDB5kFEiSir9KUzsjgPVsyQEIS+WdIrsguineqCALh2jU2rUOCzcDoh1RYIB0nn+Hb5xPkSDYPAp4kLOYekRojcZRG08t0cs+3oIQCuXWND0h6QjjQQXeB4SRP60hn07+Ce5h5J69tBeohzCQnNUqbMazlmyo9DIrH1gUgc3IjEoUCDhfAm32uvkMm5strP2uAobf8FVjCUwOFgcYhp5XT0d8B5sKJIiyYQXuRzceChgHC4dsFDn0EIOGuDI9n9M8l+9AsQAmxKu95ZnAcTLatdKkVCQfkrx02DHhMQkCzEUfa2MOvxfcCxoh+BNKaV02VxHuSl0SugEwhdKeNwOG5pMiRgbFLum6XslpX2qFGjUl9LxQpRGcZYWtUG9yeEkGhaWticexgyjk4mlDxDyLEfp2+CyBFloaGAeHFN2R487dxTos1xQhrTIiQQWiIpkIK01BfRA8g41y200oRjZczYmiLSpVmJY7kQiYMbkTgUaLAgfuJ77Zppwn44+BBIaWQa0YAkiPiNjoWhk5s4D+r205yHhPjZxjgE6Cp4PWI4E4SQ7YZVaaWR9MRImjRZCZN6kO2lQ8OgWZyHbKIUsoGWaBJc4jpSH6HEUUojIRpJ15RICKSG72NFH9qDwnQeaToWrnvoBlqA64XDo4uhCdJnXM8QSGkkTYuSHBb/k63U99tvv+At2/l8+pqwQk9LAeKUze3bQ8C9jhjaxMCBA6v23HPPoPdLaSRao6RrytgQMSufHRoZIZpG9IOuoWliReYx5iI20AqF616n70gW4lhOROLgRiQOBRosOHO+l9artjOhOUoahOXvtNNOiY6QlQV5aBwM2+tmhTgPcqJJPQ5wBPREYBXBCjQNTGZMNKRFzM+ACBB6TgOrICpIiAgkhchZWRJG53PzKOBN55E2eeKcQ/PsAJ2J2blQnAmphxBxG8fFDoZJ0SMiC9Tcc1zmuQ6FOA/C+2ltgKmUIfIUkmcH5NghsrYzQZyaBuxCCwLRSrp3CYlDLIhKIDzNqh3g/iEKSHonbVttKmW4f0Pvs/XXX79WpIRuqqQe0yD6Gs5BUvQIkiAVQ6QBstpPKhXNEQSNhUpapYwriuIDCxKasJmg9waRq0ogEgc3InEo2GCh4Yq5QmNVx7Gk7XtPmBdHzoSWlFckDYDTZzIuZVtsVjZ8F5NH0rHhwEXZ78sfm+B1iDEFTIDYb7bBdoHUCVEAxG1JkRCEZzhXnF4ImUlyHkyeXC+0KT5A4FgxEqUIKYfjGporNCGONMdJAroLVuasBJPKDiE6nCOcXlpjnzTnwfcR5k/SUUAGaW8MIUKAmQYI7eGHH56ZOLK63mabbbRdSecZck3unXGbt2wWoIXh+4iQJJUrc/xE9khxhXQ+JGW0zz771HiOsZNGHImgQIbSKnqYT0hLMG6JiOQFcyMLFIg+18ZHPnie68l5slOQLlCVxHgxAUHPkvIsJyJxcCMSh4INFlYLiKHM3vJpNcw4Jyk7YzXoAxMcNzAr8pCa/jSYKzdKKX2TB04GlX3aShiQyySnaQq3sN/eJ8F2TggxSaHY+2nYVRs4OnL05SjtkpUbK2pWlj77cTJUWaSthAEiSHLaZhQF+5OcHN+Ls8E5JUUAzHx2nnJZG5AawvxSrupLjUDqaMmcthIGiGDRNGQljuKcknqIcA5xrKzqy7HvA2RFeh3QNdUX5YPUMeYgrGllwaSYuJdN4h1CHCGbOPEkEg9RhFhBHKXcshRgL2k+jo/z70uN8DyEiGhgmjYCLRN6E5s4ErmoBCJxcCMSh4INFkLobDZlC92SVtFM2kwavnA4+WxCnXwOE12peyrYKx2IDp/NTe9LEUjunTr/pNAoqn124jPzpGnNb9B/8BoEmeXMZ4cAZ0kOm89mZemruGAVGNKWGCKCUDNNMGtCdja01eil5rNDwLUktSICW59oluuH00prS0xI2tzoTYhj0mpVWhX7Vv4cI1E8CC5Etxwbkpmg4RH3H2PXJ5qFqBINIkqTNP5IbZn7tQhxtAWzJiBVsr9G2s6bVGiVY0MyE6QhRGDr6xfD81RtsDBIqsohsmDu1wLpdglm6wuROLgRiUPBBgtCIEKAplPghvet5mTLYVtQJWCSYLLIm88OBVoBVgasmH3RDJngyKv6gGM3FeTSNdHnkFlF4RB84kmcBOFPXoPzKMcOmy6Qw2bFT47Wlypg8uc4zO2sbRx11FE6ImB3TfQRR0o4mbR94slS89mhoKSXiA/pIl80g10eGYdmRMkGBI8VsU0cfekHiAXn3SeeNKMi6C1K2UsiraQXLQqiUV80g2gQES8iSr7rwD4RrMxt4sheIy5QukwaiEiF6zPNqAiLh1L2kkgCxI6SSciBLzrKtSJFwhznm88gP5wjscVXaVVfiMTBjUgcCjZY7GZH7NZHiNOXZyc9gWN03YjcqIjYSs1nh4K0iugnfBOdbF3sCz3bXTLZrY+Vui8FglYBBbkrTFyufHYoiKqQkuGYfE2XSOkktSW2mx2xmvURR3QtTNSEdl1RpHLls0PBJC/jDZKQpy2xNDuyS2tdxJGVK2kHVuiuFBirfM4Njog0VV0DJy7jzZcykC6QPqJvd8mUygwXGYcUMVdwv7jmKsgmack0HUa5QDkxEYUk3Q99VbCPec0Fu0smhIy/k1KwdYlIHNyIxKFgg4WwN45HQMkg+VEbOApCujhpV+iRG5cbuFz57FCYFRuuPQtYSbCLIv937XZHCae5Eyi5YyZjG6wcyQXjZF15Y4gCFSblymeHAjKDGJRKElcZKvZzTYnOQLRsULppdg+lwoBKA9fnoOtgleu6vuXOZ4fCrNjACbpA+2pfczLZCVTC2T7iKLoOxrirsgfhK/cRpNvuxFiXCNH94DRxnmxdb4PnsF96SkiKwUUciSQwzlwkHeEzcwNRgPpcrYfofmTrbheZo9yb/0nLbyrM+LvULdvzIhIHNyJxKNhgYaJgUpWJgkkIB2EDURIrCbsygBtVVvXcwOXMZ4eCmxwtA8eA/sEOj/J/hJKutsT2ChOSgSNyESwmZyaa+sxnhwCdh2yQxMZldk4b0sdK0NWW2F5hUppG+sMGNvI6UgQ2SEnVVT47BFxvUi4cHykEe9KXduiutsT2CtNHHKVHhsv5EM3BoaIXKmUr7ryA9MkeJyNGjKg1j3BvE66H9NikTjZ0EjLgI47SI8PVGZO0GcQcAp+17XW5dT+0fbc3l+MeJX1EJMgW81J5w/ukzBX9DKmYSiESBzcicSjYYJH9Csjt4kRRotsd4CTvbYuhIAmI3ySfnaXdc7nB8VIjjwNjBU4Y0wQ6ABwneg7zOBF4cvyENJkcqWFHdGjaz7lhRUM+2JfPJldeV/nsEHC8OHAcGK2HbQdJGJkVIQTCPE7Zr4ANn3CKTP4IKk37WUFCLm2tBISEVFdd57NDQe8RHBjX0C7FRERI6SkE0kyzyH4FvJdzwNih7NG0n7JGIja2VsJU+ScJdesLHD/RM1IJdnSNiAp6EEqaTWJFekWahiEIxHbOkWk/fUSojmGsm89zHxHNEMJSqVW6GT2BHCJ2tBc43KukkYiImfOszL2krJjnIJjoRiqFSBzciMShIIOFlSarVG4SvlseotYm5IgzRSRG6JbKA3PSQH1NfpEJxe68WEkg7mLiYAKx940gnYCNhHRpEEQIn5JF036IB1UGdMNjJQXhQDzGOTEJh5nPJtxdFBAyxkHiQHAkJlhVERmBALHSpqSNa2hffyIHXHNW0kQiWIEiIDWJAUQEVXt95bNDAWHgmkIg7JJCSBLHCwGijBLSg5M07ef8YBerc5wphAMdBYTKjOSwqmVMcL4o3asrEWhWQBghjhBIoonmcXFuGK8QIBwrURqqLkz7IcikJDl/LBSoWoGIQTjMaCLPU9XC66kyKor9zEscP/ex3WyLShvuCwgQ9wlkF6KIDeY54PpXCpE4uBGJQ0EGC1oE82YRp8FPNA7yHA4UQZxZ9mXmsyuxZ30amNSZ1KS9s7nCxFmwekTk5bOfkLM8B2kgd21WGUBOeA6HmtbJsBJgHLEC5Pix13R4OE3sZMJ02Y/jpFJFnoNAIog1m2kx6ULO6jufHQocHCkLjp9SY9PhQZp4npW1bT+243BwHKb9OBuzyoIVOOQMchqyqVt9g+tNyorjJ4Vnps/Yl4HnaRJm248D5d4w7SdKB9kwIziQE8gE58WVuqo0ILhSsk1zJ3MjOdmMi5bStv08IFycu0ohEgc3InEoyGDB4TFJum4eCIH5N5MnIX1uSEKTTLDoACqRzw4FKw0iC6wwiQwg6COUzISPg8TxMUm67LejEDgIShsJ8SPAknRIJfLZWexn23QmQqIKhOQJrUOYsB/iw6rSXm3xYHVt/i1VEkRcCOly3iqVz84CUm/YyGqZ3D7HT+SE8QvxJZfN76bj5CcrVvN5yi9R30s6iL9xnJVS3oeC1AM2kn4k3cLxk6rDTp7nHJh2yu+ks8y5geuNw+X8kdJhPJAOgUAVGfRZgfSibRJhMGWk2M+44B6QxYIQZ/7nq8CpD0Ti4EYkDgUaLNLIRx44WSYPVhj2SoSfiMa4uVi1VWKv+jygTJGICRUPCMSwhQcTI2WV9opTiILLfpwFv9MAq9L5/FAgeiMdxWTP6lPsxxngIFzEiUiK63ly5Pxkb4NyNrWqS+DcKJ/E2UsUBvshVBAEF3HCKbrsl7QOUZxK5/NDAbkhHcP1Zrt0sZ97HPJnEgd5uKKRpv3sB1MJPVYeQG6JIHK/08/CJIOMC9fiKXSfl7pAJA5uROJQoMHCCkRKmfh+HKxL8yA/KTWrj/4M5QZpFjs0LXYRORH7WZnYTlNexwRD2Dapo15RQT6a1souMkSeXn5n3w60DeYqTBwL9pO2KpKeJRQ4eVaaLmdohqxZneJgWY3a9kOqOTdF0rPkqbqxx4A5LiCX/CQSYY8T7EfP5KqqKDrMnVnthYJpvyyY0nbhrUtE4uBGUxVRGDRp0kRde+21qm3btvrvZs2aqQ4dOtR4zQorrKB/9u7dW3300UfqwQcfVA0NyyyzjHr//fe1vQJI7Oqrr66ef/75aptbtGih1lxzzRrvXX755fXPnj17qs8//1zdd999qqGhefPmat68eapp0//efvyO/U8//bTq3Llz9bXu0qWLWrx4ca3rv+GGG6pvvvlGTZ06VTVE+997771a9nfs2FE98sgjqlu3bvq51q1bq3XWWUd9//33ta4/r1m0aJG6/fbbVUMc/67rv+qqq+r7eZNNNtHPMQ8w/hcsWFDL/vXWW0//vOWWW1RDw1JLLVXLfuaClVdeWd1///1qyy231M+tssoq+hzwM6JYWKrSBxBREyuuuKKaNGmS2nPPPdVXX32lVltttWqHwQ2HE2FimTVrln5++vTptU4hr2Gy+fTTT2s95s+fX+PvhQsXVt+45oObOu1vjhUnbz7at29f4++VVlqpBkEA559/vnr77bdrPLdkyRL1wQcf6EmCz8BZ/Pjjj2rppZfW/19uueXUsssuq51Fnz59qu3H0brsh1Sk2c7jiy++0KQlxF77b65Jku38zWRo2z9+/Hj1yiuv1Dpm7Od9OAecpowHIVH8/vXXX6stttii+rq77Odc2va7bOfB6/Laz3H6bJfn2rRpU8v+a665pvr6mccMEYY88TvnDZuFRONseY7jxbE89dRT3vHP+7muabaL/bw+zV7Xc9jvs1t+x37TQQLu72nTptU6Zo4HosA9id2tWrXSYwySxX3AvcFr+vfvr5588kn9vpkzZ+rrZ5NwsT/Jdh7MEy77Q8ZAy5YtnWPe/Bs7bPvvvvvuWoSXY+ZYIMrvvvuuateunbZXiFJEsdCEsEOlD6JoYHLmpsVxy8Rd35j55qdqwNDfqmMOGK4evvVvavbs2WrTTTfVzuWzzz6rXoUyuf72t7/VDN6cDOzLyg3IzWg/xLExefx/6qrG7/bf8js/v/zyS/XJJ5+ojz/+uPrBKtheXdqTCZPaCy+8oCdtbDGPlVUXz50w9go14aY71SHDd1FP3XWDniA33nhj/R4cjNgPmdp///21/TJJ8n6OzwSTnMt+cWx57Gd82PYzdkzg8Ez7+Z1z9NxzzznthzDwGceceZG6+V/T1N6/2U49c/9t2v7u3bur7777TjsSsY9jP+igg/S4kOtvjg8BxMtnPxN7iM22/dhh2s65YEyYwOGJ/fLzhx9+UM8++6wep/a14jr98ssvar9Ro9VDM15Qg7bsreY8/i9NEHAqfPebb75Z4z0HHnig/n7Tfj7DBKTTZb84thCb7d9N+2UcCBEXMD6x2xwDP//8syZOcv3Na8X9wnt2O/hY9ezc99UWG66j5j33mCZKLCKwY86cOTXGzH777ac/xyRKtv3MEz77iWyG2mz+/e2339awnQf3tgk+m+8x73/ey/Xktfa1wnbmqu32PEi9/dm3qnuntuqm8eeqxuwLiohIHAo4WM6/71V11eP/XZF/O+sO1WPxW+rxxx+vRQjARhttpNZff33nxMADZ4zjqA/g2Gxnak4uOP3XXntNT54ysbDKkvQEdizstLV67sf/rDTB1zNvV72avKceffTRWoQA4FB5uOyW33FI9QEiJbb99t+vvvqq+umnn/TrcVqdOnXSYXp+51z82HWQmv1d6//aP2Oy6tV0nnrsscdqEQIJW/fo0UM7J9tuedTXyg1SYNrrOhc4PiJHQnzEfkgGx9pk46Fq5jetqj/zq+m3qd5LfaDttx0iWGuttTSp9I1/sd+OfNQFiJKJzb5xwPXnPIn9RFkgBZAGiGOLviPU9K+Wr2U/97/cNybWWGMNHYWU6+96ELmoD/u5rtiZdA9gv5l+EvshN1ynVlsfoJ5a+N/56ndbr61OHvyf9FVj8wVFRSQOBRss/563UO1+Ze3wc/PHx6u5T/9HzyArRME999yjhgwZohoCmFhw4uIAmcwgDRAbzvdXS7VWHQ64pNb7VpwxQb306N1O+2+++Wa19957q4YAjhv7cTBiPxM+zzHuvmy2ktP+ts9dp5598Han/VdffbU69NBDVUMBq1xW2wJxbKzgFzZt5bR/9TmT1FNTb6xlP+fv4osvVqNGjVINBWhYiBoJIHrMN9j/RZMVnfZ3eesONe22a2vZD/E+88wz1ejRo1VDASTXTNWRkiClSQQD+9vvf3Gt90w5sp/q1em/ZLq+EImDG1EcWTC8s+A75/MffvWflQY3GDcaIXDBE088Ub2CKzpkVS0ggkIUgvAzYcvTx453vo+wJYDIYT+rMwH5XnHERQcTvgjbxH5WYdhPiPm4M893vu+1D/8TAsbBYj+rMwFhbFnBFh0Qxq5du9Z4jvA69vPzsONPd77v+bc+0j9ZkWI/IXs5f+g8zBVs0a8/wk5z9c91f+ONN/SqfOSRxznfN3POO/onBBP7JYLI+STsj9NtKPZz/SE8Au577Oc+GLr/4ZnmxYjKIEYcGkjE4aId26nF89/STJ1QLz+52czQNWHONLEeP7GpnGHLLGJMV/5VjoVc/dFnXqSGOey/eFAHtcSy//XXX69hP6QqSagnv3Nty21/qBiThyvcDtCqHH/u5WqPCTNq/e/SwR3Vks/erradBykf87OwK812n2C1FNhizDRBnivcDoYOHapOvXii2uvqmsJJcNmQ1WvZT8jb/CzGdZpYzydYLdV+8vVpdstD0lQ2Bg0apM4cf50ace2ztf43fuc1VNWCd7T9PF5++WX90/wsU6yaVbBaCiBvaDtCbOfhW+Rss8026uwrb1D7Xv9Crf/FiEOxEIlDA9A4HLnN2uqkQbVzfEwarNQobXTlVOVhr8ZYrTGJECIlr5xHUc0K11ZmJ4kxJe/O97744otqwoQJ+j2sPHBkt912m9puu+0y2Y/TeOutt7QwMklXYa/GWK1zHBwP9odWEZh/E+EwxXg+MaatN2DihvCNGzdOvw77OVco7QcPHpzJfkgD1SnYn6Sp8AlWeRC5ymM/k3+SGNMnRuQ7P/zwQ3XeeedV28/1uP7669WwYcMy2c93htjvE6zy4FzksZ97L0mM6RMj8p2QDNILYj9jkEqTkSNHZrafCgTSHr77P0mwyoPjDK0iMf/m3ktaDHBefXoL5o6TTz652n4eV1xxhTrkkEP0Z4fa3xh8QVERiUNBBwuRB8Jza7VtWXJuz6V+56fc8GmVBK7nfBOjPJLEmA8//LAaOHCg/n2rrbZSt956q57E6sp+l/pbVPg++9POSdLEmCbGRFHft29f/TulpZMnT9YCt7qy3ydYldV/iL323zjfNDGiD0QKELOKsPeOO+7QFRN1Zb9PsMoDApDHfhFy+gS5SWJEKmDkeiMGvvPOO2ulb8ppv0+wyk8IYOg9b/6N/WKrS4ybFNUkOkHUR4StU6ZM0X1Z6sr+hu4LiohIHByIg6VuwQoIFTwrrDFjxtTIdzYGMJHTwGm33XbTPS2kV0VjAStl7Cc0femll9bQazQG4HgprYY0/eUvf6m3ip8igQUDlRQTJ04stEOOvsCNSBwciIMlIiIiIiL6AjdiVUVEREREREREMCJxiIiIiIiIiAhGJA4RERERERERwYjEISIiIiIiIiIYkThEREREREREBCMSh4iIiIiIiIhgROIQEREREREREYxIHCIiIiIiIiKCEYlDRERERERERDAicYiIiIiIiIgIRiQOEREREREREcGIxCEiIiIiIiIiGJE4RERERERERAQjEoeIiIiIiIiIYETiEBERERERERGMSBwiIiIiIiIighGJQ0REREREREQwInGIiIiIiIiICEYkDhERERERERHBiMQhIiIiIiIiIhiROEREREREREQE41dLHK644grVuXNn1aJFC9W3b181a9asSh9SREREREREg8evkjjccsst6rjjjlNnnnmmeu6551TPnj3VTjvtpObPn1/pQ4uIiIiIiGjQ+FUSh0suuUQddthh6qCDDlLdu3dXV111lVpuueXUtddeW+lDi4iIiIiIaND41RGHn376ST377LNq4MCB1c81bdpU/z19+vSKHltERERERERDx1LqV4YFCxaoxYsXq3bt2tV4nr9fe+0153sWLVqkH4Kvv/66zo8zIiIiIiKiIeJXRxzy4LzzzlN/+tOfaj0fCURERERE44X4gKqqqkofSqHwqyMObdu2Vc2aNVOffvppjef5u3379s73nHLKKVpMKfjwww+1NmKNNdao8+ONiIiIiCg2vvnmG9WqVatKH0Zh8KsjDssss4zq3bu3evjhh9XQoUP1c0uWLNF/H3PMMc73NG/eXD8Eyy+/vJozZ44mD++//75accUV6+34Gzo7h2zFcxbPWRxnxUK8N/Odr3nz5qkmTZqojh071tGVaZj41REHQPTggAMOUJtuuqnq06ePGjdunPruu+90lUUIEFOuttpq+ndIQyQO2RDPWXbEcxbPWX0gjrNsIMoQ5/9GQhz23ntv9dlnn6kzzjhDffLJJ2rjjTdW999/fy3BZEREREREREQ2/CqJAyAt4UtNREREREREROTDr66PQ7mA5oHOk6b2ISKeszjOKo94b8ZzFsdYZdGkKtaZRERERERERAQiRhwiIiIiIiIighGJQ0REREREREQwInGIiIiIiIiICEYkDhERERERERHBiMTBgyuuuEJ17txZtWjRQvXt21fNmjUr/Kw2wr0+NttsM7XCCiuoVVddVXfsfP311yt9WA0G559/vu5O9z//8z+VPpRCg1bw++67r2rTpo1adtll1YYbbqhmz55d6cMqLNjsb/To0WqttdbS56tLly7qz3/+c9x3wcDjjz+udtllF90ZknvwzjvvrHEOqR2gH1CHDh30OWSX5TfeeEM1dkTi4MAtt9yiu09Sjvncc8+pnj17qp122knNnz+//q9QA8Bjjz2mjj76aDVjxgz10EMPqZ9//lntuOOOultnRDKeeeYZNWHCBLXRRhvFU5WAhQsXqi233FItvfTS6r777tMt4S+++GLVunXreN48GDt2rLryyivVX/7yF/Xqq6/qvy+44AJ1+eWXx3P2/2COYn5noegC52v8+PHqqquuUjNnzlQtW7bUvuDHH39s3OeQcsyImujTp0/V0UcfXf334sWLqzp27Fh13nnnxVMVgPnz57OVXNVjjz0Wz1cCvvnmm6p111236qGHHqraZpttqo499th4vjw46aSTqvr37x/PTwYMGTKk6uCDD67x3LBhw6pGjhwZz6MDzFlTpkyp/nvJkiVV7du3r7rwwgurn/vyyy+rmjdvXjVp0qRGfQ5jxMHCTz/9pJ599lkdkjL3ruDv6dOn1zeva5D46quv9M+VV1650odSaBClGTJkSI2xFuHG1KlT9d4ze+21l06H9erVS1199dXxdCWgX79+enO/uXPn6r9feOEF9eSTT6rBgwfH8xaAd955R29ZYN6f7F3Rt2/fRu8LfrUtp/NiwYIFOjdo72vB36+99lrFjquhgJ1IydUTVu7Ro0elD6ewuPnmm3UajFRFRDrefvttHXYnhXjqqafq8/aHP/xB74bLhnYRtXHyySfrXR67du2qmjVrpue1c845R40cOTKergBAGoDLF3zy//9rrIjEIaLsq+iXX35Zr2wi3GDb8WOPPVbrQRDfRoQRUiIO5557rv6biAPjjNxzJA5u3HrrrerGG29UN910k9pggw3U888/r0k9QsB4ziJKQUxVWGjbtq1m559++mmN5/m7ffv2JZ3sXzvYVOyee+5RjzzyiFp99dUrfTiFBakwhLabbLKJWmqppfQDgSkiLH5nZRhRE6jau3fvXuO5bt26qXnz5sVT5cEJJ5ygow4jRozQFSj77befGjVqlK6CikiHzPfRF9RGJA4WCH327t1b5wbN1Q5/b7HFFo5TGIGuCNIwZcoUNW3aNF3+FeHHgAED1EsvvaRXgPJgNU0Imd8hrhE1QerLLvEld7/mmmvGU+XB999/r/VZJhhbzGcR6WAegzyYvoDUz8yZMxu9L4ipCgfIoxLKYzLv06ePGjdunC7bOeigg+L95klPEA696667dC8Hyf8hJKL2OaImOEe2/oMyL/oTRF2IG6yUEfuRqhg+fLjuqzJx4kT9iHCD/gRoGjp16qRTFf/+97/VJZdcog4++OB4yv4f3377rXrzzTdrCCIh7wi7OW+kds4++2y17rrraiJBX4yOHTvqXjWNGpUu6ygqLr/88qpOnTpVLbPMMro8c8aMGZU+pMKCYeR6XHfddZU+tAaDWI6ZjrvvvruqR48euhyua9euVRMnTqyHK9Nw8fXXX+sSX+axFi1aVK299tpVp512WtWiRYsqfWiFwSOPPOKcuw444IDqkszRo0dXtWvXTo+7AQMGVL3++utVjR1xW+2IiIiIiIiIYESNQ0REREREREQwInGIiIiIiIiICEYkDhERERERERHBiMQhIiIiIiIiIhiROEREREREREQEIxKHiIiIiIiIiGBE4hARERERERERjEgcIiIiIiIiIoIRiUNEREREREREMCJxiIiIiIiIiAhGJA4RERERERERwYjEISIiIiIiIkKF4v8A2TsIO9ASLIoAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "graph_fine = wmg.create.archetype.create_keisler_graph(\n", " coords=xy,\n", @@ -241,46 +148,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "086f9fb1", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m2026-06-09 20:43:59.974\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36mweather_model_graphs.create.base\u001b[0m:\u001b[36mcreate_all_graph_components\u001b[0m:\u001b[36m229\u001b[0m - \u001b[34m\u001b[1mNo `coords_crs` given: Assuming `coords` contains in-projection Cartesian coordinates.\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mesh nodes : 10\n", - "Mesh edges : 36\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Triangular mesh (mesh_node_spacing=3)')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAHDCAYAAAB4ai4jAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnVhJREFUeJztnQm4TOX/wF/7FkL2nexb9iyRbMkSJSVUiJIlCqXSvklaJFvRZm1TtFiyVFSERJJ9i4RwrVnP//m8/c79z507yzlnZu7Mmfl+nueYMXfOzJlz3vN+9++bzjAMQwmCIAhCjJM+2gcgCIIgCFYQgSUIgiC4AhFYgiAIgisQgSUIgiC4AhFYgiAIgisQgSUIgiC4AhFYgiAIgisQgSUIgiC4AhFYgiAIgisQgfU/rr32Wr25jSeffFKlS5dOJRrm7z58+HBIn3PDDTeoPn36qFhk165d+je+/PLLyk3cddddqlSpUirR4Dfz293O1VdfrYYPH65ikbgRWNzYVrZly5ZF+1CFGGHFihVq4cKF6qGHHor2oQhCRNm4caO65ZZbVJkyZVT27NnVFVdcoZo0aaLmzZuX6r3cD2+++aY6cOBAzF2VjCpO+OCDD1L8//3331eLFi1K9XqlSpV87s/EJSQWo0ePVs2bN1dXXnlltA9FiAM2b96s0qePTRtg9+7d6sSJE+rOO+9URYoUUadPn1affPKJ6tChg5o0aZLq27dv8ntvvPFGlStXLjV+/Hj19NNPq1gibgRW9+7dU/z/p59+0gLL+3VvuHBoHJkzZ1aJDn2Q//33X5UtWzYV7xw8eFB9+eWXauLEidE+FCFOyJIli4pVbrjhBr15MmDAAFW7dm31yiuvpBBYCN3OnTtrpf+pp56KqZBDbKoDEYIYVdWqVdWaNWu0OYygeuSRR3zGsM6dO6cef/xxfUFz586tcuTIoa655hq1dOlSv3GGyZMnq7Jly+qBW7duXfXzzz+nOoaPPvpIVa5cWWXNmlUfy5w5c1L5/HFb+nJfmt/17rvvBvyd77zzjrruuutUgQIF9LHwfRMmTEj1Pr6zXbt2asGCBapOnTpaUKFtBTt/69evV02bNtXnD+vk448/1n//9ttvVf369fXnVKhQQX3zzTepPmPfvn2qV69eqmDBgvrYqlSpoqZOnZrqfW+88Yb+G9+RJ08efXwzZsxI9b5jx47p83f55Zfr69SzZ0+thAQDYXXhwgXVokWLFK9zbjnHy5cvV4MGDVL58+fXn33PPffoMcH33XHHHfqY2PD1ey94cOnSJfXaa6/p4+c681vZ/+jRoynet3r1atW6dWvtnuGclS5dWp8bX1gZW4Ewx9SHH36onnvuOVWsWDF9bFiY27Zt8zlOGfscF8eH4se18+azzz7TY8JzPPvC6jkJBlbC4MGD9djlXDDGW7ZsqdauXevzPm/YsGHyufVWTqze4+bxv/7666patWr6+BkX119/vb6G/mJY5ljC9fzAAw/offiOTp06qUOHDqX6fOKyWD+M+WbNmqnff/89onGxDBkyqOLFi+sx7Q3nFKts3bp1KpaIGwvLKv/8849q06aNuu222/RNyI3ji+PHj6u3335bde3aVQfluVGmTJmiJ5hVq1apq666KsX7mUx5Dzchg/Sll15SN910k9qxY4fKlClT8iR566236kH/wgsv6Ju1d+/eqmjRomH9jQgnJgbM/YwZM2o/9X333adviv79+6dyY/AbOW5+J4ImEBwzQo7zh0+c7+L59OnT9URy7733qttvv12729DS9u7dq3LmzKn3/fvvv3VAl/ODdscN/PXXX+tzwPlmf3jrrbe0sGD/+++/X1t9CMmVK1fqz/akS5cuejLifDJpcc2YxEaNGhXwd/zwww8qX758qmTJkj7/PnDgQFWoUCGtYWKtIzAQXOxXokQJ9fzzz6uvvvpK/04mR4SYCeeSyQrhye/YuXOnGjdunPrll1/05MV4wMJr1aqVPgcPP/yw/mwUkk8//TTVsVgZW1Z58cUXtQY9dOhQlZSUpD+rW7du+tyamMeOYOS8ct2YrDl2fgPHarrRb775Zq0Q8T7uLfZDGHpj5ZxYgfGFgsT44Xv5TpSLTZs2qVq1aqUYp1gUjA/GN4K6X79+2pNiKgV27nHGKMfP3HH33XdrZef777/XYwNlKhCMJZSbJ554Ql9jBDfHP3v27OT3jBgxQl+L9u3b6+//9ddf9SNj35NLly6pI0eOWDpXCGHv83rq1Cl15swZfe3nzp2r7z/mJG8Q4sC1qVmzpooZjDilf//+qL0pXmvatKl+beLEianez9/YTC5cuGCcPXs2xXuOHj1qFCxY0OjVq1fyazt37tSfmS9fPuPIkSPJr3/++ef69Xnz5iW/Vq1aNaNYsWLGiRMnkl9btmyZfl/JkiWTX1u6dKl+jUdPzO965513kl974oknUv3O06dPp/p9rVu3NsqUKZPiNb6TfefPn29YwTx/M2bMSH7tjz/+0K+lT5/e+Omnn5JfX7BgQapj7d27t1G4cGHj8OHDKT73tttuM3Lnzp183DfeeKNRpUqVgMdi/m7PawGdOnXS1yIYjRs3NmrXrp3qdY6Xz+V8Xbp0Kfn1Bg0aGOnSpTPuvffeFGOE6+k5br7//nu9//Tp01N8LufY8/U5c+bo///8889+j9HO2AqGOaYqVaqUYly//vrr+vUNGzbo/587d84oUKCAUbVqVePMmTPJ7/viiy/0+x5//PHk16666ip9PY8dO5b82sKFC1ONZ6vnxAqME+5tK+N0zJgxya/xmzlefhu/0c49vmTJEv15gwYNSvVdnmOE33znnXemGkstWrRI8b4hQ4YYGTJkSD5vBw4cMDJmzGh07NgxxWc/+eSTen/Pz9z5vzFhZfOeP+Cee+5J/jv3bOfOnVOMLU8yZ85s9OvXz4glEsolCLgR0PKsmMtmXMvUatCq0KY83Q8maCloUSa4FgAtGPbv3682bNigNfHLLrss+X241rC4wolnDApNitRvvodj4f+eYJ2gyVmFY8eiMsEiQ+MmmQV3oIn53Pz9uM0I8qJB8pxjMje+n+Myzyuf9+eff1pye6Fxe8J5R+tGew4E7/G8Xt6gUXv67vk9HDeve44RxoP5G01XGpotLhXP34jGyrkz3U2mlfLFF1+o8+fPBzzWYGPLDox9z3it92fh4sL6wyLH9WXStm1bVbFiRe0lgL/++ku7iwji83tN+N1YPp5YPSdW4LxhDXI/BQLPAladCb+Z//PbcBXauccZt4wFLCRvrMR3iA95vo9zfvHiRe1yg8WLF+vv5Zx7W2beFCpUSMfmrWw1atRItT9eDP723nvvaWuR48A16gvGXKhlI+Em4VyCuN+sJlhwUceMGaP++OOPFJMKk7w3uIk8MScY00dvDk5fGWm85ksIOgUznpvrxx9/TBXPQTB4TjC+fksgcPd436R8Hr5w79c8fz8+e3zluNbYfMFkYqbVEv+qV6+ePje4znAFNmrUyNZ5J9MpEIEW2/b+XPP3+PqdnnGYrVu36nOMWzLQb0SBwJ2Gy/HVV1/VcZeOHTvq3+kdvA82tuxgdZz6cg0jsHC/eb6vXLlyqd7Hvp7j2eo5sQJuM4Qk1wGBh9sPJZB0bU+IBREv8qR8+fL6Ebccrmmr9/j27dv15+XNm1c5wencwPd5K1VZs2ZNFXe1A9eQDThv3FsokSgB3vc190csJVwkpMCymgE3bdo0HexkEhk2bJi+2dDI8NUzgL3hb3YnRX/4GyRoQ8Hg2AikMyjJ/uHGRkATb2FiRJP0xG5GoL/fGez3m99L3JAJxxfVq1fXj1hrxNawPubPn681XFJsCZAzwdv5Xn8Qvwo04dv5nZ7fxe9krBDT8wUxK/MaE4shBkKMkcQXYitMnrzmaYWHc2yF87OsYvWcWIGYFBYKyR3E0IghEq8k9ofFYAe797hTwnnOL168mCphwx8IvGDKOXFiLM8tW7akUlJQMEm4iSUSTmBZhckErY0bwVOA+HILWMEM7vvKyPJ+zdSqvLN3TE0sEEx+Z8+e1QFVT83OjtslEjApkXzBDWdFQ0Q7xhXGhsuCJAOy2whOe7qqnIJARxCGGzL5sA6xBq0oA2j6bPw2kitIgJg1a5YO7EcDc5yiMJBp6gmvmX83H7GevOF9oZyTYBQuXFi7z9iwzki24Px5CixchiQYeFpZTMpgZuRavcc5fhQKXIZOrSyrc4OnZYfb2lup2rt3r2WvCPd8sO49JGCAd6iAjFDuO391q9Ei4WJYdrUiTy0Isxk3mxNwKZBNRm3DyZMnk18nFZzYlvcA5vu/++67FK9jZTg5bgYjqe7RhOPCBYaQ+O2331L93VNr5Eb1BC2RuAi/KVi8xyoNGjTQk4GTOFAwCwCh/Mwzz6T6G3EKUwnhu701bDMrDYUjWhC/wdIgBdzzOMgmIxOPWJYpNDheXGqekx3xEdKxnZyTYPAZ3hMrx8q95X3O+FzPEg0mX/6P4mRmwFm9xxm3vMfbuvfe1yl4RIi5eZeekEUZrhjWQR9uV+4l5iOUCO+4oxnnoywglhALyw+kbqN5UTPBTUoaLjcxF9ZT4NiBVGiqyNE0CX4zaTEoEWSen0lchJRxapHQ/NDwcI9Z8fXjk2aCxy+Nqc/nkibOjU2gPJqQUo3WRwIDacScS7RW4h1o4Ga6Lr+BG5PzRNkBEyXnietgpsiHCp/FJMH3ehZNhgqxKc47biWSEvgtpBZjiZB8QHo4bhgmehQQxhfXl5RqrhNxN+8Cz7SEY8XFxvjkt5Dybaa1Y5kMGTIk+b38Rs5j48aNtTuT62fWz3mOZ6vnJBicI2KovJfJGLcp14/kHFypniDE+B3Eq4hdkULOdxM/NVO9rd7j1ET16NFDjR07Vh8z9Ve4OUlr52+kqIcCY5zyDX4DpSh8PmntKAm45Dytv6wOY1icfxKRqD8ljk/bJVy0xO74Xk8XNCDw8NDEVEo7GAmW1u4vXdo7rZ001Oeff16nqmbJksWoWbOmTu0lxdQzZddMMx09enSqz+R10q89mTVrllGxYkX9maQOz50717j55pv1a54cOnRIv549e3YjT548Oh31t99+s5TWzmdWr17dyJo1q1GqVClj1KhRxtSpU/X7OF4Tfkfbtm0tnM3A58/f5/B93inIf//9t36tePHiRqZMmYxChQoZzZs3NyZPnpz8nkmTJhlNmjTR6dycp7JlyxrDhg0zkpKSUv1uzpMnZiqx5+/0R4cOHfR3+9rfO93c3/cxHnLkyJHqs/k9pM1ny5bNyJkzpy5pGD58uLF//37997Vr1xpdu3Y1SpQooX8j6dbt2rUzVq9e7XhsWUlr/+ijj4KWSsDs2bP1mOfY8ubNa3Tr1s34888/U33uJ598olPleV/lypWNTz/9NNU9YvWcBIMUdMZBjRo19P6cd56PHz/e5zjlXFKOwH3A8YwbNy7F+6ze42YKPNeB+5R07/z58xtt2rQx1qxZEzSt3Xss+Spb4fNHjhyp7wfOz3XXXWds2rRJ3wOepRROmTlzpk6vJ2WfFHrmFP5PiYQ3Fy9e1OUKjz32mBFrpOOfaAvNRAfXCq4KtBoh7UBDxsePlukr201wJ1xT0rF9uZ7dBK5S4tnPPvusevTRR9Pse+leQrYqiSe4fmMJiWGlIfiM8a17t8zB/Hfj0iZuh2wz3FOkSgtCNDGTHzyhIwak9dwwatQo7eaMNWEFYmGlIfjT8T+T2o2PHc0enzkxK7RBUq0FwQ4kEwRr1cP4ivWGxsSMgsWG8UL4SxF3u4VF2yc24pfEk6h3mzlzplaoyFAU/kOSLtIQzHsylOhfRlYcKbcEe0lGEGElOIHehgT+A0GGaKwvLEjzaF9ZeJ6QFBGvC0NSg0gSENY+yRFmIgbuQOH/EQtLEFwMmaZmCrI/yNqLRfeOJ5QXBCsxIBsxHDV4gnsRgSUIgiC4Akm6EARBEFxBmsewKLijbQoFoLHWWFEQBEFIG6ioohicBDTWaItJgYWw8u54LQiCICQme/fu9bnoZ0wILLO1DgcZbPkHQRAEIT45fvy4Nl7stFtLc4FlugERViKwBEEQEpt0NkJDknQhCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIryBjtAxCEaHPq1Cl18OBBdeLECf385MmTyZuT/585cyb5s9OlS+fo0XyeMWNGlTNnTnXZZZfpR+/ngf7m/b4cOXKo9OlFRxXciwgsIS45f/68FkIHDhwIuiFo/JEhQwY98Zsbk775PE+ePKp48eKp/pY1a1YtbAzD0J9h99Hz+blz55KFIQKVjed//fWX2rJlS/Lr5qPnZ3iD8CtYsKAqXLiwKlSokH703MzXeMycOXMYroIghBcRWILrOHr0qNq6davavn272r9/v08hdPjw4RT7IECuuOIKPRmzlS5dWjVo0CB5gs6fP7/KlStXKqHExO1p9cQyCKvTp0+nEm7m8yNHjuhzg7BjW7t2bfL5unjxYorPypcvXyqh5vl/BHWJEiW0EBSEtEJGmxAxvv32WzV27Fg1ZcoUdfnll9va959//lHbtm3TgolHz+dMvCa4ukwhxFapUqUU/zc3BFKmTJlUPINgRdiyYUlZ5dKlS1rAm4LMU6ix7dixQ/3www/6OQLRhPOJ4C9XrlzyduWVV+pHhBnWqSCEk3RGIB9CBDh+/LjKnTu3SkpK0hqtEH8wAb700kvqkUce0Vr/Z599pm688cYU7+F1hJIvgcSGFWWCwGEiNCdD8zmbjKG0g2uGpYbg2r17d/I1MzcE24ULF/R7sUzLlCmTQoiZG9aZxNKE4w5kgQgswTKnzl5QU5bvVDNW7VEHT/yrCuTMqm6vV0L1blxa5cjyn7GO9dOjRw/11Vdf6f/jMho0aJBq0aKF2rBhg1q/fr3avHmznuAYqCa4mbwFEs/Lli2rrSgh9kFY7dmzJ4UQM7edO3cmux2zZMmir6t5jStWrKiqVaumqlatqq3DUMaf4B5EYAkRg8ni1sk/qt//Oq4uedjk6dMpVblwLjW7bwO1ZuUPqnPnztpywsryhphQ9erV9QTl6UJi8uJvQnwnwWCVeQox00JDmDFecGkyFhgjCDAe2bDUzpy/FHT8idByFyKwhIgxdvFW9driLSkmC89Jo2/DYmpE+6t87ks23Zo1a1TJkiXFFSSkgjKAjz/+WL377rsqW7ZsOlFk48aNyYkz2bNnV2U69FcnSzdVhp/xN7h5eTWoeTk5u3EusMSOFiyBG8aXsAJe/3DNfvXwww+r1atXq5UrV+pYB0F33EDEoxiQErcQfIGQQjgtWbJE/59xUrduXdW7d28d70KgvX2olE9hZY4/xqcIrPhHBJZgCWIGgfjn9Hk1avQo7eZr1aqVtqoQWr/99pt2+XgW0wqCNzVq1Eh+jnsQpYcNSpUqpdJ1HaeU4Xx8CvGBCCzBEvkvy6z+PnHO79/zZc+knnj7bZ1UwbZ06dLk9HMC6V26dNFxiQoVKiTHr0iJJgAvJF48a9euXTp+heuP8UJNmDdmp48hQ4aoGaeyqAPHz/r9TBIwhPhHBJYQFJIoTv66QBmlmqp0Plr7EEMocX6Pat26nerVq1dyCjTpz6YAY/vpp5/UtGnTkmt5cP1Qr+OZ8mxuaNXSbcG90KHDFEreZQu8bmYMkmyDItO4cWP1559/6riGOTaqVKmi5syZo4oUKaKm9X9RGfnr+B1/BU5sUVu3/jeWhPhF0tqFgOzbt0+7+A4dPa4q9p+o/jz1X8xAYxhaMOVNf0r9OqanMs7/qzMA27dvr66//nrVqFGjVBYU76c7hXemmPn833//c+0Q/yJJw1dRKsIs3ouA3SKUcPd6XkdTOCGUzExRxoC/OjrPmixq9ebOnauf9+nTRxednz17VnXo0EGt/nWDqvnge2r/mfQesVRDGZcMVTjrBbXqhdv1+EMB4v2Mv2uvvTZgmrwQXSRLUAgrTDwtW7bU2vDw4cPV4KEPqYod71OX1bhexwzyZsuoti98Tw2+vrp69smRyUWjuHF4Tk+9vn37qtdff93S9zHBISC9BZnZhonJy/x8hFmxYsUCtg/Kmzeva9oqxRo08fXXe9FMT6fmyhRKXGtfQonnRYsWtZRw88orr6hHH31UTZo0Sd1xxx26FySCB6E4atQoNeiBYapAk9tUkWu66PF3xWWZ1Z7FM1SnyrnV7OnvJxebm+OPR4TgRx99JOMgBhGBJYSNX3/9VbVu3VqnnTZt2lS99dZb+vV27dqpefPmJb/v7rvv1loxgm3WrFmp6q+6d++uPvjgg5CPh8/du3dvCk3e7CNothDyLEQGrLBAAs38P22MEsFiC6UhsHku2VAUvIUSbrtQs0BRjEjOwU2IMGRMMal17dpVKz2MASz4TZs2Je/z7LPPqmeeeUb1798/+T2eYOUvX748pOMSIoOktQthYcWKFapt27baXYOW+vbbb+vXsVawWjx57LHH1Pvvv6/T1r0ni4YNGyYLulBhMsSqYmvevLnP9xAbMydcz1545v+JofHIpO3dkYxaHytLdARbyoNHc+K2uoSIv0fOJ5ZOOJY8OXbsWKqGwECPRe+GwL56MZL1GWlr1eyM/8cff2hhxf8RUK+++mrye7zH3/3336//7uuaIkxNF6MQH0jShZACamGIQZUvX173hmOyMycCJmLvSYF4EvUys2fP1hMe7hvzfWjMxKRwF6UFusC0TBm9BQJ30aFDh1IINLOjuWeHcx5JOCEe49n1nM27u3k0m936W/4EQWP+H4XCc/mQWG0ITPuu6667TjdL5px///33Ad+PkoC7euTIkVrYopSYMAYZv95CTnAvIrCEZBYvXqyFVZMmTXRft3Xr1qVy8/jqlUzcYerUqapevXpaYOEymjBhgnYHYg0tWrQopiYNrEbTJegEzgHxNO/lO0yLhr8HWvPK6rpY3gLJWzhRcBtPMToySRFWJE5069ZNDR06NFXHd1/jb8CAAWrMmDE6uQOrFDf2zJkzVb9+/fRYpsQCxUqIA4w0JikpiRGnH4XYYdGiRUbWrFmN66+/3jhz5oxx6dIlY8GCBUapUqX09UqfPr2RLl06o1u3bj73HzhwoJErVy6ja9euxtatW/Vrv/76q3HFFVcYtWrVMv755580/kWCm1i3bp2RL1++FGPlxx9/1P83xx+PV199tc/9x4wZo99z6623GitXrtSv7dmzxyhTpowewzt37kzT3yNERhbIetmCtoCwrJo1a6brXswVc9FOSV1G661fv77Wbv25kEaMGKFdbcSYiB0AjUux2gig063dcx0rQTDBkmeMYQV5WuOMOSx8xhGlFeCvNg9rCjcn4xZLH4jBLlu2TH8GKe64dgWXY6QxYmHFFlhRWFY33HCD8e+//6b428svv2xkyJDB2Lx5s7a4fvjhB2PXrl1+P2vkyJFGlixZjN27d6d4ff369drSqlmzplhaQgrWrl1r5M2b16hTp45x5MiRFH/7+OOPtQa+ePFi/f9ffvnF+P333/2ewSlTpuj3mxaWCZZW2bJljZIlS4qlFUM4kQUisBKY+fPnawHTtm3bVMLq8OHDxuWXX27069fP8ucdP37cKFiwoNGjR49UfxOhJXizZs0aI0+ePFpYHT16NMXfzp49q4VMmzZtLJ+4CxcuGNWqVTOuueYarWB5IkIr9hCBJVjm66+/1sKqXbt2qYQVDB482MiZM6fx999/2zqrEydO1FoTk5E3IrQEb2FVt27dVMIKXnvtNR2T2rBhg20ljPE3Z86cVH/bu3evWFoxhAgswRJfffWVFlbt27f3KaxImsiUKZPx3HPP2T6j58+fNypVqmQ0a9YslZYLTEC4B6+66iptxQmJx+rVq7X1Xq9ePePYsWOp/o5rEDdhnz59HH1+q1atjPLlyxvnzp1L9TcRWrGDCCwhKF9++aWROXNm48Ybb9RuF1907tzZKFasmHHq1ClHZ3TevHlay/3iiy98/h2hlT9/fhFaCcjPP/+shVX9+vV9Cit48MEHjRw5chj79+939B1kp5LROm7cOJ9/R2hdeeWVEtOKMiKwhIAgQBBWHTt29CusVqxYoYXNe++95/hsYllhYVWuXFlbXL4QoZV4rFq1ysidO7dOTfcXaN++fbseo0899VRI39WzZ09tyfsTiqbQKlGihLFjx46QvktwhggsIaDVg5uvU6dOfoUVgobJhGy+ixcvhuz2QfBNmjTJ73tMoVWjRg1xD8Y5ZO5Rp9egQYOAWWHUURUpUsQ4efJkSN/3559/GtmyZTNGjBgR8D0itKKHCCzBbyAaYXXTTTf59OubzJ49O0Uacah0795dZw2eOHHC73t+++03EVoJkLqOsGrYsKHOJPUHhcKMv6lTp4blex977DFdskGGoD9EaEUPEVhCKqidyp49u06wCCSsSL4oXbq0zhoMF9Rskdzx+OOPB3wfQqtAgQJG7dq1A05ogvvYsmWLVkjIBgx0bbHuEWjVq1fX6enhgO9jXN1xxx0B34fQKleunO6IsW/fvrB8txAcEVhCKkFA6jB1KadPnw54dmhtQ5FwoMJMJzz00ENaYAabCGjNgxbevHlzn5mLgvvgmiMEKlasaBw6dCjge80i4YULF4b1GCZMmKATMLDyAkGxO4lG1HH5SrMXwo8ILCGFdVO0aFEdHwp2A9K7zW6RsFUIetMjrnfv3kHf++2332qLrEuXLmHTsoXoQGp61apVtRDw7nzijZMiYauQ9IPAvO6663yWWXiyceNGnU5vRcETQkcElqA5ePCgrkOh8edff/0V9KwMGTLEUZGwVcaOHau1XAqHg0HBJwWj/fv3DzrBCLEJ5RCNGjXSiooVi91pkbBV5s6dq603SjqsuNBJ1qDsw1+GqxAeRGAJ2m9PqxuSHbZt2xb0jPAep0XCVkGDJkbQunVrS0Lorbfe0hPM008/HbFjEiIDcVL6UlJH5d3TzxehFglbgTF37bXXBiyz8ATBhnscr4AoTZFDBFaCQ+wH1wexIBqFWuHmm28OqUjYKp999pkWQp988oml9z/77LP6/cQgBHdAKQSZoShANFW2wgMPPBBSkbCdVlBYccRqrfD+++/r8RcoLV4IDRFYCQwxH4QPabzEgqz2E+SmnD59esSPD02VDESEY6A0d8/3Dxo0SLsSCcgLsQ3XC9cy12vWrFmW9sFFjCUTSevekwEDBhiXXXaZLhq2AsKN+wOXpRB+RGAl8GTRt29fffN//vnnlvYhqEyMi6y8tHJ7sIge8QFa71jV2FkQks4HS5YsifjxCc55/vnn9eT+5ptvWr62FBHTd9JfIXskEoAKFSqkFTurDB8+XP+uadOmRfTYEpGkSC8vghZPMR6pqmjyTHjEGexMeLIeVvh59NFH9YV/5513bO2DIGCtq7TkhRde0IKVfm9WYDKjmSlJIcFSk4XoMHnyZD3+nnzySdv7LFu2zEhLZs6caTkBA5jbaPOUMWNG7ZEQXCSwMN3J/KEnHdryRx99pE3s119/PaIHKfgHdwXnc/To0ZZPE5lbxBnsTDDhAgFE8Bvt2mr7J1yIFJ5SBEoneSF2ICZJbAh3m1XFlWxU6gPvuusuI63hGFu0aKGL5K3GbUnUoPCeesKffvop4seYKCRFWmCx0F+vXr1SvEa7n27dukX0IAXf4KbgXOK2sHPDNmnSRGftnTlzJiqnFq2a4yYbMFKp+kLkwU2LlX7bbbfZ6j3JAp9kBgYrJo4UeBU4brwMTlL1N23aFNHjSxSS0sLCYplp041EdwK0Xjv+XRFY4eG7777TVhLuCjsuWdyGDJJvvvnGiCZ33nmn7UmLYmgao1IMLS2coguTNp3XcdfaiUHRp5Lxx3L20YR2Ydw/doSPWQxdvHhxaeHkBoGFFkWrHTKB8OnySLA1WKo1B2RuZOiIhRUaLMGApkcKe6D+gN4gHNjPjkUcKbCYcAshcO1AcSnxrA4dOoTcUV5wBp1R6HKOa9fOZMNcgJXcuHHjqF87vAt01/C30GigvoN0kMFFLd0wYlxgEbAkLZlHUlKpVUBLfvfdd/3u88QTT+iD8t7EJegMzhsTBRMGE4cdcOfSgunAgQNGLMDSI4wFrEU7EENFWZIambQHBYlJHsUHxckOrHGFokuPy1hZxYDx98EHH9heOods19tvv10Ki2NZYCGsvFfxfOaZZ4wKFSr43UcsrPBBlib91nDF2PWjIxQYHBMnTjRiBbRs1t+qUqWKLUsRSDKRdOPolE/gSrNa6+fZtZ0+kQ8//LARS9C3krAG7j47fPjhh3r8BfMwCVEUWFhT48ePT/EaF4wAvlUkhuUcCjNJCbfb0drMzEM4RNsV4w1xUH7TqFGjbE+exMGYBK20ABJCh2xgJ/EnrlXLli11OUykO6o46SiPi9lJ42fTe0QXFyEGBRYTBP5bM639008/1ctQ28lSE4HlDLNuxdvCtQJKhZ3ap2gIYlKGSaqwA9Y76fEUg1rtXiA4gxok0teHDh1qe98ZM2bYqn2KRmkILma7ig/KX+fOnXVrqVi9txJaYJGZdf/99xslSpRILhwmNdROlpAILPssXbpU+/7vu+8+2/sSZ+BaOZlo0grGFYoQiRR2IR5H1haLP8aa9h4vULdHf0paa9ld9oWlbWjEzMQeq1BnddVVVxk1a9a03aH95MmTej+ypyO12kG8khRpgRUORGDZg27quGIpdrQb58EVQ8yLCd1K/75oYi7gZ7UPnSc0+sVCIx4h3bXDy+HDh7ViSjq3k1ICXG243Miui2UoCMbKsuuahj179mihTPajLD5qHRFYcQa9z1h8jlRgu0FhINaAEGA9IDeAwEE4O+ncTccFWZIkvOA5adq0qV7inhCAXaj145q88cYbhhsYNmyYLii2sm6bNz/++KOOp9qti0xkksTCih9wTbB+FGnoTvr9McGg2dqtc4om1ImhqeJ6cnLTk7HKBCnd3UOH8896UEzgy5cvt70/rkCyiqkVjLVEn0C1WSQn4eJz0pDXXJLklVdeicjxxRsisOIIltYgUcJJRwomCDRj/Opuq3ej2zw3/dSpUx1NsrQJwj0ojXJDg0mX6xCoxjIQd9xxh4577d6923AT1FgRL6YThhNorEByyldffRX2Y4s3RGDFCdRKhbJ4oTnZuHVJDpqiYh3azRoEug+w4jJxO+k56Ayy+Zh0mXydQPZwKMIu2tAUGmXx559/tr0vSSk0ykVYk6wi+EcEVhxAai2Fmf3793e0/8aNG7UvffDgwYabY3cIHKfuJAL8hQsXNho2bGg7USXR2bFjh3ZDM+k6OfdkyhHz6tixo2tjOYyZWrVq6bW6nDSIJjmFJBW60TCWBd+IwHI5tFrCjUeBrxMfOjca6d0kari9z9miRYsc152ZQXBcO1YXixT+q2vDOiUrkBiUXRBQN954oxZYbk/xpn0U8Tun5SCUk9CRhsUi3Sq4I40ILBeDNkuyAVlyTv3+VN47dWXEItSd0bONtj6huEatrsKc6GDVM0mvWbPG0f7mSgBz5swx4oGXXnpJp7rb7XXp7Rp1S5ZkWiMCy8VQ/xFKNwCEFMIKoRUvUJRJR226WdgtWPXU+OkK7yQelkhQ/xZK3JTzS9yGbjjxAmMOtzIWp9M6RhotoATEixIZTkRguRQ0OISN0+7juP9wA+IOjLeYDSnVTgs6gfo13Kz169d35GZNBCibYOXwrl27OnJf4R2ggztxx3iL2bDCNVmnTnoNAmOOpUhY4diJmzWeSZI6LPeBr59FCUlDt9sWxoQECxIt4jUrySzoZC2sUBJZHnjggbAfm9tB2alWrZpeccHpopj04sM6Y3HGeIQ4Kr9vwYIFjhNZiGexOrvEs/4fEVgudDnQconlDZx0dwBS1+O9WNGzoNOpBfnqq69KZ20/a6QRJ3SqDLDMDb0qqRuMV7AgmzdvrguhnVpJZjxr7NixYT8+tyICy4X1Hri7nGqmXHAaEWOduaWbQCgFnbhNnRZ0otmSak3KtpM2Q/GImSThtF4K5YGsQqyzeG88TCIUMToKop2CJwRLX+JZ/yECy2Vp2wirp59+2vFncPNQYJsoEzACnoLWZcuWOY5nsSZTvXr1Ej6ehUWFZYWF5RSUB5SIRFmPDMHuZIViE4lnpUQElktg0ThqVVq1auXYMqJ1ETcP/csSyYV67bXX6qJglhVxwqpVq7SWyxpciQoZb1hFxK6cWkbhULjcBlZ6jx499PpXdlf8NkG5xMrv1KlTwsezkiTpIvYhseKaa67R6z8dPHjQ0WewWBxxg7vvvttINIj1EfMj9uck1d1z5dxEXCmWSff222/XWYF//PFH1BQuNwt7MnLpZOFU2DPuGH+Mw0QmSQRW7EN/NtwoTjpgmxeZ5UZq1Kjh+m4WTjG1e7qzO5200XDRdMngSiSos3K67li4FK54cafSzd4pWPhY+oniTvWFCKwYZ+HChXqyoILe6UR766236riV0+4P8QLxE+JZThv8ku1FbQw1MolSn8VES/mDk5Wrw6VwxQuhuuQZc8RSiak6WesuHhCBFcMwKNFKW7Zs6diN8uabb+qb5MMPPzQSHdyBFKsWKlTIcTyLbC36DT722GNGvMMEyTLwVapUcdTQFebNm6fH3+jRo41EB+WRpCeKip3WP9IdhPqs7t27G4lIkrgEYxcGJYNz7969jidXimcHDhwY9mNzKywfwoKPocSzSBpIhEw3hDLC2ek6YUyutLiii7sUv/5/6zA6uqMEOI1nmYs+smJ2opEkAis2+eijj0JKhzXTsXFf0VFb+H9Y4DKUbDWzligeOtwH6lyP+9RpzE/cV4G7uodSHmDWB8ZDh3u7iMCKUSsgX758jpcZ8Gzgmij1Vnah4W8o8SxzDbF4bN2E5l+uXDkdL3Ha+osuFtLANXgB9nvvvefo/OLSvuKKKxKudVOSWFixBYOPJUNIw3aaUfXyyy/rm4H4geAb3IEs9oh70Okqw2PGjNGW2rfffhtXp3nAgAHaAnCawm56B5yuS5YosEo28SyUn1DO87Rp04xEIUkEVmwxZcqUkNZjIhOL+Mrw4cPDfmzxGs+i55uTeBb7kK5N5qDTJrCxugim0/WY6FRORmqXLl0SSvN3Gs+i3yUbz51AfRylFqyYnQgkicCKHajvoTjTqW8bi4yswsaNG8fdkiGRgp6MuAZp4eSEbdu26S4G99xzj+F2SNunWSsC3ElWKvE8sgpxJzKxCMHBusLKwtpyGqtm5YbWrVsnhIKQJAIrNmCCaNKkiV6HycnNjrbPoCUQmyjaVrh46qmntGvP6UKYZmHt/PnzDTdDCyGyUvfs2eNo/z59+uhuKnRVEaxDHIvxM3HiREen7auvvtL7T5o0Ke5Pe5IIrNiAeAiDbunSpY7Xf8JSoNBYsC/sSb2ms7aT+hg0W1oOYd26taCTFOlQilrN9Z8ojhXs079/f11C4PT+R1nA0t++fXtcn/4kEVjRx8w4c9pc1aygZ1E8wRnEoKiNKVu2rHH48GHb+1Mrh3WCleI2Qs04Q0kibspSGIIzcOGTBER2sBOhw/iljAUvTTz3akwSgRX9gVqrVi1dTOikpue7777T/cX69u2bED7sSMJEwYTBxOEkBmgWdLLwnltgzGBdOs1KpQM5grpNmzaOU+CF//jnn3+0woTi5CQsgHXG+GPh0XglSQRWdDHXB3KyQJs5wbJ8hiRZhAfWzcI146R3nmdBp1uavJrWuZMu9EywV155pc5yO3bsWESOL9HAJY1rmtIWJ5mr999/v44jOl3KJNYRgRVF1q9frydHilidXDgmCiYMJy4swT+TJ0/Wkzh9GJ261yj6dkNaP9aRkwy1UF1YQuAkCuLRTkpTKPpmZYZQir5jGRFYUQI/c6NGjXR7H7utk9C8brjhBj3ZxKsmFW3o1IDlS9q7XWbPnh1SLV1aQQ0PwhVLya4lSRo/ruh4K5qOFV555RXHnTB++OEHnfUaj2tnJYlLMDq89dZbjrMCaQfEZLpgwYKIHJvw3xpOdMmnvRXFsHYn9Ouvv94oUaKE44LQtFq2xsmEOHbsWL3v22+/HZFjE/4bQ9Rj0t4KAWQXFAoKuPft2xdXp1MEVhQgvsFEeOeddzoWdE47EQjWIUUd9wpWsN0YDQXFxBJYCyrWYKkQXMnEPu0m6nz99dfaXfXggw9G7PiE/8DzQhMAEmJ2795te+wSS7311lvj6nSKwIoCrImTN29e24F5rDFiXv369ZOMwDRi8+bNuvUNFpPdIDidzrledOeOtUQf3Hl23clmQkDbtm0dL80i2INu7DQToIOIXWvdzFpdEEeeGBFYaQzdwZ24U9DYEXK0zZGMwLTFrDOy25kdDblChQq632CslBzQ0BY308iRI23tR2JPmTJlHKdcC86hcwhFwSTy2KmxYsxde+212pp2ugBnrCECKw0xJzCSLewMPNxR1GnRo81ugFwID2bchubEdiBpg/1YTiLaMIGR2Uetj52aP9a2atq0qU7QoN+lkPZQdkAiBdaxXas4U6ZMjjKRYxERWGmI6SLasGGD5X2wpugRiFvK6XIPQngme4qzufntuli6deumJ/tolx+wGKhdFxG/++6779a/+/vvv4/o8QmBef755x21v3rkkUe0Vb1lyxbXn2IRWGkEmWa0X7IThMcKI97FZMGyD0J0QXmgnAD3zMqVK23VZlGCQL+3aIFlThD+tttus7UfrkMmyXfffTdixybYU5pwT8+dO9dWbVapUqV01musuKadIgIrDTCboxI8tRo4ZR9iJrgBZs6cGfFjFKzf/A0aNNAFs3YsXoqQmfhXrFgRlVPNREfCxP79+y3vQx0Pxzxq1KiIHptgHZJd6PlIBqodi/eLL77Q19Ltc4kIrDRg1qxZerAwaKzywgsvSPp6jIK1QpcR6qysLuXCRFOnTh2jevXqad6BACFpt3PH9OnT9T5Dhw6N6LEJ9iGBgmQKwgR0y7FKp06djEKFCrm6jZYIrDRYFI9BglZkt9bKboBVSDvozl68eHGjatWqlpcUWb16ta5hYimZtHRjVqtWzahbt67lVHRaAxFrpWWT211I8QpCh1R3Fm/ctWuXpX327Nmj3dkDBw403IoIrDRY54ZVhJngrK5LxKRG81WZLGIb6phwDZL1iavQCkwWTBpOF0m0y+jRo/V4Wrt2raX301UhW7ZsRocOHeKyF108QS9ISg0obrda0/nyyy/r8YDy5EZEYEWQdevW6RgUfcGs1miRzUN1uhRmuoOffvpJL3FOd20r9XFoxnYtbqcQr0I40sHbChQ404GFNZWcLHUjpD3UZxYsWFC7m1kTy6rFXadOHVfOMSKwIgTWUYsWLXTdlZWJbM2aNbr3F5k81L0I7mH+/Pm2XGgEvnH5Rjrzk3R0LEDc0sHYuXOndi/VqFHD1TGORATrmbmD+cbK3LHifzFNN/aCFIEVIYgDWO3YTfsfUo5ZEuDEiROROiQhgphJClaWhECoNWzYUMcgIrU6LMF4XD8UPFtp/0NROu4l3EyC+6BtG94ZyhasjKnbbrvNKFy4cMw2Z/aHCKwIgO+fLDK6AwTTuOmmTLo7DVYPHToUicMR0ojXXntNCy0rSRXEipx2S7cCvQ8RQsE0biYAVrzGrYR7SXAvZvybOGmweWfHjh1awD311FOGmxCBFcEFAIOtIkx2GVlmZJulVRBeiCwjRozQ157Go8Ho3LmzUaxYsbDHi+hkwTF8+umnQdOjadVEUTPxVsH9TJo0SV/7Z599Nuh7H3zwQR3jdJNVLQIrzBD4RFulHU8gyCrDLUSMQRZhjB/QbHv37q27EQRzB9P9hC4mtNwJFwTSCaqzLEUgLduzAPW7774L2/cLsdECDqE1fvz4oAozSTYUlbsFEVhhhlY2tGAKtH4NGjWdL+y2+BEM17iEsZ4QRsFa6JDBR8CcOFI4oDkvkxXZi4GEFWux2W3xI7gDFJUhQ4bocTBhwoSA7yWDGTfixo0b0+z4QkEEVhih6wE1LA8//HBAYUUmIO8jjV2IT8gMZTkIhFYgS4uGuLjkqNcLFQLoBNID9QtEWNGfkklqxowZIX+nELtCC2VIBbG0WEGCZBvWOHMDIrDCSM+ePXVXbn9pwbgBST2lboesHiH+hZZpaQUSWi+99JK2dkLtxk8AnUA6Ker+hFWPHj20sHJ7TzkhfEJr9uzZ+j0shRPriMAKc5HwuHHj/AorAtwIq2XLloXrawUXCS3WNPKX/ECmaMeOHUMuEh42bJhfYdW9e3ctGOltKSSO0Bo8eHDAXpK8p379+kbNmjUjVmYRLkRgpUGRsCmsmFC+/fbbcHyl4CIYE7fccktAoWXWcTlNgKBImBWpfRUJI6xIAkJYffjhh44+X4hvobV8+XL9d9ZMi2VEYEW4SJi4QrNmzbSwkmysxCWY0EKzpV0OTWrtarlmkTDLgfhKALn99ttFWCU4lzwSMfx5gcgapcQmlttyicCKYJEwwoplAGh+K6u1CqbQoo2TL6GFq9jJmkUUCV955ZWpioQZmyRg8H0ff/yxXIAE51IQocWKxIyVF1980YhVRGBFqEiYFks0EUVYYW4LgilEAgktuqSzOizZW1ZYuHChHn90OfD+Hpoo8z3efxMSl0tBhBZdMljo02r397RGBJaDE0bLm379+mmNhE4F3mnECKtrrrlG19dEa4VZwR1Ca86cOSn+RhE5sSaWBfE34dSuXVuPOWpncCGyArKndc/nd+nSRX9+sG4XQuJx6X+rmfsSWrSHQ2ANGDDAiEVEYNlk+/bt+kKzETfwTgel0wVdBhBW9IsTBF94ChVPocVqxsScSKDg5vSVQGGOP3OjWNiX29FbGApCMKFFGIPXibX6K4+IJiKwbELTSM/JglR2Jod77rlHtzphMT80lB9//DEyV0yIS6FF9h7dLkqXLq2FFd1SaLHjDQkZ3gKLMUjqPMLOLFb2l40oCL6E1quvvqqzmUlvZ/xQT0rmaTwIrHT8o9KQ48ePq9y5c6ukpCSVK1cuFU127typypQpk+r1bNmyqSpVqqgtW7aohQsXqvr166tY5tKlS+ro0aPq5MmTydupU6d8Prfyt3///Tf5s9OlS+fo0XyeKVMmddlll6mcOXPqzc5zz9e4Jp6fHYtcuHBB3XXXXWrGjBmqWLFiat++ffratGvXTi1fvlyPt8svvzz5/dx66dOnT/EZ/MYMGTKoa665Ru/zySefqPbt26tYht9x7NgxdeLEiYDjy+o4PHPmTPJnOx135mPGjBn1OHI6Bs3nOXLkiPnxZxiGGjFihBo1apS68sor1Y4dO/RrHTp0UF988YXavHmzKlu2rIoVnMiChBZYu3btUqVLl07+P5MHF5qBeejQIfX111+revXqReXYuCzcvAcOHAi6/f333+rixYt+P4vfww1n3riez339P0uWLHofc2jYffR8fu7cueSJjEd/z0+fPh3wfHBt8uTJowoVKqQKFy6cYvN+jd8QrckFYc8YQlgBwufaa69VP/zwgxo2bJh66qmnUrzf8zh5b4ECBVTRokXVb7/9pj7++GPVtm1bFS24JlbGH9v58+cDfhZjLNi4M/9vKiehjDvzkeMyx5i/MciGwAwEx8O85T3WfI1H3het8WcYhqpTp45au3Zt8msVKlTQ823r1q3Vu+++q2IFEVg22b17typVqlTy/7t06aJ+/vlndfbsWW1ZYWVFAj4fbXv79u3qr7/+0je8+ei5eU/iCBJuEF9b/vz5tQLgayJwg3WCwDU1bH+C7Z9//tHnyfOcsXlq5JA9e/aAkwr/L1GihBaA4QRrqmvXrlrQ8NyEc9+3b19teXHd8+XLl+JvJi1btlSHDx/W42LevHmqSZMmKlKWIGN/27Ztav/+/X7HH+fdE6wVf+MPQWuOP28BxPXwtiRjDa4XQiuQYMOL4Wv88R5PsmbNmmLM+Rp/xYsXV1dccUXY78vhw4er0aNHp3r9wQcfVK+++qr6/ffftQBzq8DKqBIYc1JBs3322WfVG2+8oSf3FStWaEGGS+b9999XY8eO1YPQrqbN5LR161Y9MZiPbHv27En+bgYswsYcyOXKldPuIF+TQjQ1t0jDNeD3sdnVKBn43pOI58SyceNG/ZwJxxMEB9YQ59xz4zVP151V+J4PP/zQ5+ScN29efc3HjBmjnn/++VR/f+yxx7T7D4G1bNkyVbNmTT25MPmwMbnZAcsCD4L32OM5ryO0PM+DOf5KliypXeC+xh8CPtYFj1P4XaYL0C4ILF/jz/z/999/rx+5tp4wSXuPO/M518TuvX7s2DE9vjytU+D/fHeRIkXU008/raZPn67cSkK7BNHqMZOxrPD9EndYsGCBKliwoL7wDz30kJ5kGHCNGzdOtT+aPX5iX5PC3r17kwcNGqY5GHk0n+NPZiJAcxUiD0qEOYmYFgbXytw8JxQEhC9BxmOgcfvTTz+pL7/8UscM1q1bl/w61saAAQPUuHHjtCKDkgI33XSTatasmR5vjJdFixap8uXLq2nTpqk+ffroY/7ggw9U9+7dU30X7laEj/fY45HXTTcxljljzXPsmc+ZxDJnzhzmMy34gut18OBBPf5QWs1xZ143XjdBYfIWYuX+t6H8+GPDhg3aOmf8rVy5MlkxRiAzxh544AHtbq5cuXLUL5K4BINw6uwFNWX5TjVj1R518MS/qkDOrKpxYaUmDumirqpSSV9kuPPOO9XcuXOTtROCmA0aNFDr16/XA4LgJYPszz//TBZKTEjeAsl8jvYar5ZRPIGG6i3EzP/jjjTB/eU5geBiqV69uhYKnhYIkxMC6K233lJ//PGHWrlmnWrW7xl1ee126tjZS3r8tSqbXU1+4DaVJ2d27YZGkN1///1q8uTJ+jNQZu677z7VrVu35PHHZ3FMCF1zQsIDYAolz4mOR2JiWLBCbIOl5ql0eI5D4tQmCCxPQWaOPxQdT+UXo2Dx4sU6boXSvWLVanXzI2+qzJWuUycupNPj7/Z6JVTvxqVVjixprzSLwAoirG6d/KP6/a/j6pKHTZlOGSr7uaNq2cgb1c4tf6iOHTvqweEZgzBhMFSsWFFVqlQplXDCKhOhFL/gTvQ1kbCZrkYs6apVq+rJw9yqVaumJ5hA4y/L6UNqwfA26vyZkzqjkOxUX44PhCFjzRx/nmMQoRSv7jpB6RjaNo+x5/kcxci0pLGcGHOeY5C5yd/4S59OqcqFc6nZfRukudASgRWAsYu3qtcWb0lxsTwvWo+a+dTTXRr43BdXIW4ehJW4TwRvUHA++ugj9fnnn2uhwQRC/AkXECBMil3fRx0sUMfv+BvYrKwaen0Vn4oS1hMaMklAxFgFwZMjR47ojOb33ntPjz+8AYw/M2kLj0Cx1n3UkaINdLGfr/E3uHl5Nah5OZWWSNJFAHAD+posgNe//OOY6tmzp/rll1+0j5egNBYVj8Q9RFgJ/kCDRWh98803+v8IFTL+ateurWNhxCY+Pl854Pib/tNuNXjwYC2YcP2RSWqOP+JYuApFWAm+wIJnjOB+BmofyTAleYaxiQCbebqKT2Fljj/mx7QWWE5ImGg/MatAHDp5TmvJmNM9evTQlhSTEGnuPJLyKtaV4A9cL57JOF999ZW2yqFu3brqQotG//Wy8Dv+zqrx48drK+rWW2/V7kUmGuppSOxBGxUEK+OPDNElS5bo+BWQQp+x+4SA4y/Y/BgrJIzAIsB44Lj/i5InawY14PHHtXa7Zs0atWnTpuRiSFyCCDGEGYFNM36AqS1xq8SD+BJuP+IHWOOMmVWrVqV6D2AlUZs1+98s6sDxs34/M2+2DOqBF1/Un8XG55odR9CSqaNhUiLAbsauyPCTuFVi8s8//+g4FqUUjBc8Q77GH/PTLbfcolYEmf+YH91AwggssmECxbCqZUtS9957b3IdBvEHgt/mBMJG/QLp6ia811cNBVskigKFtIMbHsvaVx0dm1lUi0BCiKDMMEZMJQdBght5zpw5WsOd2f9FZeSvo9L5SIxg/FXKdESnrptFxaSk8z1kBZrjj88iXd2Mc+Ei9B535v8lM9X9488USr7KFo7+L9GHOYbrzfhj7JjZrGSFUjLz6aefatd0qwdeVUbWCn7HH/OjG0iYOiyfWTL6pxsq54UktXFsH5Xu4jldb3XDDTeo66+/Xmu03kIHdw+dCLwzxRhEZjse4Df6qqEwiwKF6MPQJ77kb1LwbNeD0PFVtsAj2VnQsGFD9eOPP+rnxEPffPNNrfjQy231rxtUraHvq32n06UYfxxD/kxn1dqXeijj/L+6rQ7tmBh/uBK909HNLim+shWp7fEss/AnzCSjNTbgWlH752vssVFmYYICcqWPkhmUJdzHgBeI+j1o06aNfk6nERShT+d+qeo8PF0dPJdJsgTdWod1eZb0asfC99VjtzRUw4YMSn4f2jFaLIHuoUOH6nYnlj7/1KlUwsxXUSAdA6iZIXvMX188JhUpKHYO1w9t01ffO7MDBJuZSYViQrsmX5MCDZKtJDxQaP7aa6+piRMnaoFFP0oEDzEoavkGPTBMlWzdU+Wp016Pv3zZM+nx1++6Cmr0C88mZxUipLCwuD/4HD7TbncV783bM2CmwvtrYcVzidmGJoywgnyNPxQLc17wjE3i4vWlFDFXIHiCMWHCBF2c/txzz+k5C+X65ptvVkuXLlWvvPKKevSJp1WOWu1V8WZdk+tQpQ7LRZ0ugE7YuP6YrAhSehucvXr1UlOmTAl7USCCjT5uZhsXYiLe7VQ8WzYFavhqaliJgHdDYF898Pw1BDabl/qylmiCbLf9ljdMEBwf141JqVWrVlpLRvNlwkCIXn311clWGAwcOFC7mqn/Iy3ZO639uuuuSw6eh3psCE5PRcpz/Pk6X3gCrDQbdtLOyK2g4HCuAo09c/yZCogJQodzh6LgXUeHUMIqDoWLFy/q7+bzEZZY6riUBw0apMcfCg3Xi+seC6RJHRZuLzRJ8v65eJzsd955R7syInWQkYQsLHy8TBz0EvQUGLgHSRU1XT6RhPRlhJa/fnie//e+EZgwOJd2l+zw9ZybJpyBfGI6VpeYCPR/Jn7Og3dXbawAs9edOZn62rBY0yotnE4opLWb8QVPgXPjjTeqzz77LPn/TB5MVnRXmTRpUvLr5r60egp3k15/k51nc+FA489Xs2Hu6VCXkDGb5oazKwf3lTmGQhmHzFcIIe9sTbwgjK1gY5D3WLGSwsGBAwe0ssRc3bRpUx37NCGuSkJZLBDxOiykdqNGjXTvMwQWmiTaWlrcUJGiVq1aqlOnTrotE/27mBhNl2Ba/i4GPi4BNiuuBs+JxLyRvLtLM2C9u057d5a2gq+1h6ysT8Q59BauvkCQ+FpygudkaPLctI68N65ZLCW3oNE2b95c34AodDSy9cRbP+R69+vXT02dOlV3sKDtktm8NC2bHZtLm7DVqFEjaLNhTyHGc3P8eY41s5O59+t2w+aBxlg4xh+Wtb+lTrg+POd6+hp/1EDFUqbmn3/+qednzjMWMsXs8YQtC+vhhx/WncwpbnRKrFlYQAYWNylaCf3c6FhNV2OWhODio6GE6i6KFbiJmUj9LaOAZsmQCGUNIs+U2mDrb6Gdx0ufO8YRwgqXI02VX3zxxWTlx9MFbfapNEHhIE5Gl36aLyOEiUfQQxBXJVZ+oIanboKxwfjzNfZMa4bzFcq48xx/jK9A62+xxUuseO/evXrtNaxl3ICUQniPP5I0UIpiAUeywM6SxpUqVTIGDx6sl/DOnz+/cdVVVxmTJ08OuM+///6rl0A2t71799peFjktYHnzokWLGu3atTO2bdumX/vmm2+MbNmyGddff71x5syZaB+iEMOsW7fOyJcvn1GrVi29vD1LlrO0fcmSJfV4T58+vX5s27atz/2HDx9uXHbZZcYNN9xgrFy5Ur/266+/6s+sWbOm/kxB8Mfu3buNMmXKGKVKlTJ27typX1u2bJkeO57jr3z58kasgAywKwtsCawsWbLobcSIEcbatWuNSZMmGVmzZjXeffddv/s88cQT/+WOe22xJrB+//13fVFff/31FK+bQqt169YitISAwqp27dopBMvFixeNKlWqGDVq1NDKHeO+Q4cOPj/j0KFDRs6cOY0hQ4akeF2ElhCMXbt2GaVLl9bCiueeoCAVL17cuPbaa/X4q1y5cuIIrEyZMhkNGjRI8drAgQONq6++2vUWFvTp08fImzevcfTo0RSvL168WISW4JNffvlFj5k6deoYR44cSfG36dOn67G+YsUKbXEtWrTIWL9+vd8z+dxzz+l7zLTwPYXWFVdcIZaWkAqsKQQVAgsry5Ply5fr8Tdjxgz9/x9//FFvCSOwSpQoYfTu3TvFa+PHjzeKFCkS0YNMK/bv32/kyJFDu2e8EaEleIOXIU+ePFpYeSs5uJC5Xzp27Gj5xJ06dUq7pXFPeyNCS/AlrHA54wr0FlYoSPXr19cuaiz9WCTiAqtr165G48aNU7xGTMvb6gr3QaYlTz75pHZ7mn5gX0KrVatWxunTp6NyfEJssGbNGi2s6tatm0pYwYsvvmhkzJjR2Lx5s63Pxb3O/fHDDz+k+hvWGZYW7sXDhw+HdPyCu9mxY0eysNqzZ0+qv8+aNUuPo6VLlxqxSsQF1qpVq/RNiOti69at2uWRPXt2Y9q0aRE9yLTkxIkTRqFChYzbb7/d59+XLFkiQivBWb16tXH55Zcb9erVM44dO5bq7wcPHjRy5cql3eV2uXDhgo55NWzYUGvJ3ojQErZv366t97Jly+oQi68wDG5Cf/HShBFYMG/ePKNq1araCqlYsWLQLMFwHGRa89Zbb+lj/PnnnwMKrZYtW4qllWAwJhBWuFt8CSsYMGCAFlgkUjiBWBfj75NPPvH5dxFaiS2sihcvblx55ZU+hRW8/PLLRoYMGYxNmzYZRqILrFBxg8BCyyW7q2nTpj61XMDUFqGVWOBhyJ07t04y8jd+//jjD+2FGDVqVEjfRSkFk9LZs2d9/n3Dhg3aPYg1Ju7BxGDbtm1GsWLFjHLlyhl//vmnz/cwFlCo7rvvPiPWEYEVRr766istWOfOnev3PQgtXKJiacU/1EYhrIjXBlK2brzxRh1bCLVuD4FEmcXYsWMDvod6SISWU2tOcAeEYIoVK6brqPwJK7j//vt1ecTff/9txDoisMIIllXz5s212/P8+fNBhVaLFi3EPRjHCRa4+IgrHT9+3O/7KNT0TCMOFTJyqe/yldRhIkIr/iEBjOzR8uXLG/v27fP7vi1btmjr/vnnnzfcgAisMEONTbp06YwJEyYEfJ8ptNq0aWOcO3cu3IchRBGy/LBiSLAIJKxIHSa9nazBcKURMzkxrh566KGA7zOFFl0NYtnVLtgHSwnXMNmA+wIIK7j55pu1FeaWDGYRWBHgjjvuMAoUKBBwsjID5RR9du/ePWbrHgR74HrBvYeVHczlZhYJf/vtt2E9zY8//rhOcPLuYOCr2wZW4HXXXaezxAT3w4SOElKwYMFUxeTemEXC77//vuEWRGBFAGocaD/12GOPBX0vtQ9YZLTX8ZesIbgDWiyReENGlq86l1CLhO2UWTBhoQgFA2GJcKPXJ4lDgnthTNFOibgpykggLrmgSNgXIrAiBL0TyQgMFOw0eeONN7SmQ+Go4E7oOEFyBfEjK6nBTouErULPTsYU9V/BmDNnjk7W6NevnyhNLgVlo1OnTlpR/u6774K+f9b/ioQpt3ETIrAieGKJEdx1112W3j9y5Eg9gKZOnRqpQxIiBDFIYpG06DK7pgcilCJhq5D0Q9NSNG4rlrtZR0jXFsFdcH3vvvtuXUcVKEPZu0i4ffv2htsQgRVBSLwwG5laGXR9+/a1POiE2AB3Srdu3XQskpikFfr37x9SkbBVvv76az3+Zs6caen9dKPh/fT6FAxXeXO4boFWwPBk9OjRep5htQm3IQIrwmY6GWDVqlWzlAnI+2+66SZt1n///feRPDQhDKBkUMNCDPLDDz+0nO6O+43OAmkBWWC0DfPXYcP79wwaNMjW7xGiyyuvvKKFldXxtHfvXr2GGp1V3IgIrAhjd4LyDJwGWlZCiD7PPvusniyClTB4KiSksVevXj3NShnsTlBYjDSszpw5s27cLMQu7733nh5/wUoYPEEhtqrAxCIisNIAYhXEN4JljpkwmOhEULhwYZ8d4IXoM3HiRD1ZPP3005b3MZNrfHVVjyRjxozRSpOVBAygtROLjyLoULiE2IP+rLj1KBS3ml08b948Pf5IuHArIrDSAAQQwgftxip//fWXLvyjB5gbWqYkEh999JF2m6GIWJ0sKOCk/Q1xyrSGBAysOqw7q6nrpMZT+EziEN0QhNiBcAFhA0oiAnXU8eTkyZO6PpBljtxcPiMCK40w00i/+OILy/tQ+Ec9DcuoBytCFtKGb775RrvLWErGTv0KCywy+XuvMJxWYNUx/t58803L+5AUUqFCBZ1RxkKlQvRhUU7CBYQN7PSeHD58uK63C1ZMHOuIwEoj0GpoeMvNT82OnRVq0czpOygtnKLLxo0bdXYfXdH9dUQPlK33wQcfGNGkT58++vix3q3CqrT0pMNCkxZO0QWlgTZKLMZp51qsX79e1/w988wzhtsRgZWG4FpBy3nkkUds7UdxHwPODe3/4xWsDVy0rOtmx9qlRxv70f4o2q4YOnGwvIi/hUb98dtvv2lB165dO+mGESUYR7hoixQpYqkZgcnFixeNRo0a6VZh8dB+SwRWGkNhJjU7dmsgWPTSrktHCA9YU02aNNEuPbtJMI8++qh2IbLmVSzwzjvv6HGEa9Pu0jkkbtjJSBPCA4rObbfdpjvn+FsgNlhB+NIYXvbeDiKw0hj8znRSttqBwBNqZMgMknTjtINrRCYWQodmoXZAKUE5eeKJJ4xY+j3XXHONXnbCrsZt1vy4qVlqPIArj/NutzaOjip58uQx7rzzTiNeEIEVBRYuXOjoxicjiDgYg5DF2YTIY07S1LzYFQysPk2WZ6gLM4YbXHy4mO2k5Ju/qVevXlp4//jjjxE7PiFlRirj76mnnnK0akTevHm14IoXRGBFCUx8J1ljvB/tGJ+0W4v/3AIZnU7dYLTJYaKx2q4preE3Ockawypr3Lixzl61WlcoOIO6OdyAzBV2vTHEvRl/b7/9dlydfhFYUcz4IZB977332t6XDt+XX365zlaTJSEiAwsckp3J8vV2l184fPiwo+SGtMSsy2EM2Z0MqQtkX9Zd4nOE8EPdHgkWtHazu7giSgXlCCRbXHTR0iFWEIEVReh8QAEqy6Q7cSsSz3rggQcicmyJDC4Uyg/oNkIBrV2IeVErYyd9PBrQZNlpTIp6ILq30Ksw3ibFaEPZC0XelBM4qX8j5oXLF6Ur3hCBFUW40ck+K126tKPC4LFjx+oJZ8qUKRE5vkTEdHmxYjQ1SHYxa65o3eQG6DSPcKXnoF0+++wzrXDFUlJJPMwJt9xyi3YFOmmLhSJBos/DDz9sxCNJSUn6/rJTh6YMFxykW9i+fbvWVO+55x7b+5pLkjBApbt76HA+Wb+MpAIn/f6oc8KNQx++aNdc2YmJhnLMzz//vL43Z8+eHZHjSzQQ/pzPjz/+2JGyRYE3tYLxUHPlCxFYMdRIFe3cSY0Q2WgkcOzatSsix5covPTSSyF1pKDLObFFO4WdsQA1Vk6tQoQcsTosAqvNdYXA7dtYBcDpulgor7/88kvcnuIksbCiDzc9TSnRdJ30mqMLA25FtCsnMRfhv3gO7i27XUi8J5vp06e78nTStglLH4vfaRcGpzEXwTBWrVqlG9oi/J1YuiwSS0Yri3DGM0kisGIDYgjEErp37+64toblIDp16uQad1SsQE0bGZt0v3aSQMAkTb0LsQe3nntiqCSaUFTs9BwgsOrXrx+37qhIgcJJj0CEvpOaPTI1y5Yta1x99dWWu7e7FRFYMQTZWmjpn3zyiaP9CYKz/6uvvhr2Y4tXmCBoJkr3EScxUgTUDTfcoBfFi/SS95GG9j2MH4qlnVoJxP9YhVmwBspBmzZtjHz58jmua6PHaPbs2RNiGZgksbBiByY/tHziUU7XwHrwwQd1SutPP/0U9uOLR0h2oYB23bp1jvY3ezzaWTYmlkHYcD7s9rr0XqTy008/DfuxxSNm0oqT+DXMnz8/oXqMJonAii0QVBSdstijE/cSS5DgGqCwk6w1wT/Tpk3TNzsNQkPJ8Lz77rvjqgaITioUrDpxLzFmqc3Cve0kHpZIUH9J3IkGyaFkeNKuza2uaLuIwIpBcAkykTKhOoFsQfoNdujQIWEGsl2wIBA2PXr0cHSO6DBCvRZxn3hbXBPrnInUabYaLcNYUoXiV4ln+ebAgQPajUwTbKdxJxI0nNbQuRURWDFc0BlKirTZxWDMmDFhPza3Q5C6cuXKenPaWmj06NE6q/Dbb7814hGyJUNJkSbFnXgWKwwIqZUd1kejH6PTrEo6t4ei1LoVEVgximnuO+n1ZjJ06FAdz5LO2v8P5xKriiC10zgNLW+YjIkXxitmEWq1atUcW0njxo0LKYkoXhk5cqS2YGlQ6wSEHEkauF4TzYOSJDGs+Czo9IxnlShRQuJZ/4Pu1aEUB1OoTVYh1lmsLRsSbkhECaXND5Np586dJZ7llSSBZe7U3co5bdu2rbbO4mnZEKuIwIpxaL1EFwHqrJxAPzxqhNq3b59w2pivCZjiTM6pU+gmgNXqpM+bG6EQlQnW6aKhxLOoEapdu3bCx7OINZFQRRsspw2DJ02apBUuXP6JSJJYWLGftVWlSpWQ4i3z5s3Tg/zll182EhUGOospYh05tYxMi5dU5ESKtzRv3lxr9E67zyPccaEOHDjQSFTwdrDcB8XVTuv1iCdSchCKwuV2RGC5AGItxFxCWep62LBh2jJw0tTV7WBZ0oWC9a2crtRMUSdxA4o8E205DTOjrVmzZo7XX6NOCGHPCrqJiHn/0ULJ6URNcXsoClc8IALLZV0w3nnnHccaXoMGDYzixYvrBQYTCTP476QDdqKfOxMSBEgUcLqUiKk00ALL7irHbufzzz8PycPhee6cKlzxgggsF8HCgMSznC7MhpVAPIugbaLEs3CjkDgQSrsgs3tIomdbPv300zqetWjRopDiWbVq1UqYeBZxK2oiWbna6T1ndg9xqnDFEyKwXBbPYq2bihUrOu7KTgshBv/48eONeIdJkfNFerbTCXLOnDnSn/F/4A5s0aKFXtzSaf3Q2rVrdTzroYceMuIdz1UYnHadWblyZcgKVzwhAstlbNq0KaQODWb/PGJi8e6aYVLkZmcVVifQWohOAtIBP2XrsMKFC+sODU7jWS+88IJ2LzqN57gFlMJQ+gQi5GixRhd3yikEQwSWm3vgTZ061dH+tBJi/SxaCzmddGIdVmDGffXiiy862p/ANq4rWgwdPXo07McXDz3wHn/8cUf704qI+kCSCJxmvsY6dE5HKbz33nsd7U9iT7t27bQ7URZm/X/EwnIpNFwNJZ5FSyEm9HhMdcddiqBp2LChY4HMkg2kECdKvZVdKHxl/CxcuNDR/ps3b9bjNx5T3RHIJOkQr3PqujdXv46XVQDChQgsl8Iqr7TNCSWe9cADD+hJ2WlRcqxiujydZlTNnDkzpA4jiQAWAPEZlsLZt2+fo88YO3asPs/ffPONEU9Qp4cFunz5csfegQwZMjjuMBLPJEnhsHv5448/dDyLVYqdxLMQegg8uhCQuh0PmMW9EyZMcHxOWbnZ6VLliRbPIqGgadOmjjqOI/So7aJ1GBmE8UCo7azMc8rKz/G+erATRGDFSTyLHnlOs5DQ5p566inD7RCkJiGA1jdOhE04sjATDVzLWBOPPfaYo/137typC7p79epluB0yUfF6OM1KNbMwQ7Fa450ksbDcT58+fXSPPJZ0cAKTTTz0x7vtttscL8mCgLvrrrtCigsmKma/QVqAhdKQ2On+sZaV6nT16ieffDKkOrdEIEkElvsho43UV/qUOamPMTuQ07PQrQWdZtxpxowZjvZ//fXX9f7vvfde2I8t3sG117FjR20pOYmHmh3Iaf/k1k4iZlYqKfuh1PvFg6cjkojAihMQVAgsBBexKbusX79ea4duLOjEfUL6b5cuXRy5AqmTwa0Vz+tbRRpcqLjCyM500tyV8cs1xEpOtKxUurEQi2YplkTrU2kXEVhxBC5BXFqsVuxk4nZjQSe/k0UunWrnNBamRxsafrzWpKUV1AsRfyEJw0mhq2klz54920iUrFQ64NOjksQnYqhCYERgxRnc7Nz0TlwTbizoNNcH+vLLL23vi4BDMybRghtBCI9rDEudJTDsKk1mk1e64jtdyiRaWalOWp3hyq9fv75OFHISd01EkiSGFX/QgQB/+meffea4oHPAgAGGGxqLkoJOEbVdsACwBFhQj0w1IXxMmTJFT+I0bbUL7kR6FbphwVE6xhQrVkzXozkRzpROkCy1atWqiB1jvCECKw7BD37zzTdrv7iTPnqvvvqqFng//fSTEcvwG3EF2m2dxGRBZiWWABaBEH4oSqdcwkknDDMBIdbXzuI3otzt2LHDUacQN7o/o40IrDgFlx6ZfzTPPHjwoG3XIH302D9WixfNrvPEPZwI5FDWFhOCQzyQ2CJlBljtdmE5DpKIsGJiERIlEMhOXO8sE8L4I41dsIcIrDhm9+7demlzmtzaDYLjpsDKeu2114xYg+A0grhly5a2XTHEukgsGT58eMSOT/gPuldQhF2+fHnjyJEjtscuiQxDhgyJSWFMNi5lIHY7xFDriFV26623xrzLMxYRgRXn/PDDD3r9IToJ2L1B+vXrp2trYi0gTNsbeiDazcqiRojf06FDB8kITMOu5aSrE+exa62PGjVKKxdYM7EEbb+wkOy6k83Sk7p16zoqPREMEViJAMWw3GC4wuxAbIgAOJlbsQJdKOjKweq3doP5LKlCrVCsupniFZrb4j6zuwgh1gtWDJmrsVKfRPYia6Sx+rcdEFAIKgSWtF1yjlhYCQIuMLRVu4vJmb0K58+fb0QbJi3cmxUqVLDVkQN3KM1EEb6ytlB0ePPNN/U4mjx5sq39vvvuO70f5QuxAJl9ZJbaqfnDs4ELEFeg29ufRRsRWAkCfncWhMMlZsfFws123XXX6bV9ou3GMHvOLVmyxNbx9+zZU7tFcY8K0QMXM9axXeWH60fyBp3MowkZj4y/d99919Z+JFewH8kWQmiIwEogaCFTp04dnYixbds2y/tt2rRJp4A7XWE2HJDpmDdvXuOOO+6wtd+jjz6qJ4sPPvggYscmWHfx0VGEcgtWCbDjznVy7cMJRb4U1FO7ZycWbBa2k8YuhI4IrASDiZ+sLTo82OkmwMSPleIkRTkc3HnnnTp4b0fLJsORyWL06NERPTbBXoYnPffoZoEiZJW33npLX8tly5ZF5XSjrKG00crLKlhUuOEpwpeMwPAgAisBobMDi8RRZ2V14TzcgSQtNG/ePM1vvqVLl+rJiknLKlhU7CPp67G5bhnJFPTQo1uJ1fgly85XqlTJUZ/CUGBRT5Q1lDarLF68WO9DM99YSRiJB0RgJSh0ZycucO2112p3h9UaplCW8HACyRXU8jRq1Mjyjc9xEitxksovpA2USrDScOXKlbUAswJdW8g2ZAn6tMKM4eKRsBrDpQk1LcNYSDSthWu8kyS9BBMX6kjoZXbTTTdZrksy2yGl1ZLm+P4RPlYXVVy+fLnOxqJTQqx26RD+A5cgrkFchFY7lbMEjNN2SE4wLXWriSK4zOlYT1NbtzSQdhMisBKcuXPnaq3Vandts+FsWjTHpdsBAtWqW8+0Gps0aRL1jEbBGiRfkIRBMoaVrhEkDtFwlvdH2nqmXo8EJdZZs2M14rZ060KUsY4ILMGYOnWq1iJHjhxp6WyMGTNGt21y0ljXDj169NAThpVCXzRulmmwE5cTYoMFCxbohAayAK24fT/55BM9XuknGUkee+wxrTChOAUDtybuTeJye/bsiehxJTJJ4hIU4MUXX9STwNixY4OeEDThcuXKaR99pCAOYLVg9MCBAzrlmFoxngvug7go13vo0KFB34tlRewVAREpty+eBFyPI0aMCPpeXH9047Cb+SjYRwSWkDwJsFwCltOsWbOCnpVPP/1UTzBox+HGzoTEAK5Zs6aOq23fvj3sxyKkHa+//roeUy+99FJYFRqnZRTEooIt7ElSBV3pcWvKulaRRwSWkAzumO7du2v3TLB1jBAqZO7Rmy/cS8sTV2MyYjXXQJDdiGCjt1uk3ZNC2mAWelvpJtGtWzftMiauFU7Wrl2rFbdgqwhzv3Tt2lWnry9atCisxyD4RgSWkMrd16ZNG60x/vjjjwHPDgs8MrkQAwvn99MrsEWLFgGD6lhenTp10jEGWYQxfjAX1yQRKNiK2fSFpGt/ODuwmGnslFIESgLhfQMHDtSCLdYXmownRGAJPn3yWE+5cuUKKrTIoKII2WpacjDQapkEAvU7xKIjQM+kFunAu5D2oIx07txZW/qff/55wPeSQcq6WeHqgG7WGmLlBxJWJGTwvokTJ4blewVriMASfEJmnhWhRdyIieWZZ54Jy2AkbnDXXXcFFFZkD9LyJi0LmIW0BeuGmj/GViBLiyVwSHawu9yHP0FJ3BQ3sz/rntdNt6WVWJsQXkRgCQGFFst50OE9kNBiVVhqs0LN0CMji8wsf+16PIXVzJkz5crFOVaFFskajAnq8ELBbFRLQoc/YfXII49If8ooIgJLCFloUYNCwe69994bcpEwrhZ/woogO25AK1mMQvwILdM96E9okalHWQPZeqEWCZN05E9YoVAh0F5++WXH3yOEhggswZbQ8remFDcxwsRON2urRcK4alg4j8//8MMP5YolqNCiRZc/oUVndIRJsOxWJ0XCCKuHHnpIf/4rr7zi6PMFlwqsF154QX+hneWynRykEF5IHQ4ktGhSW6pUKaN9+/a2PztQTQ3CitRhEVaJDULrlltu8Su0ECr0JKxRo4btMotARcJ8LokdIqwSUGBRWMekRu2OCKz4E1rElRhMLAcSjiJh/s/yDExSslqr4Cm05syZk+qEMCadrAhMko+vImHGJp03+EzWVhMSSGAx2dHOhwI7Vu0UgeVOuI7XXHONFlorVqxIdYPXq1fPqF27tuWlQMwiYdKJvYUVKfNMTvSOEwQrQou/FS1a1HKZxbp163QZxZtvvplqLNMZnrFJUoeQYAKLupnBgwfr58EEFu4lDsjcMNnFJegOofXdd9/pazVt2jS/AXJcN4wFameqVatmNGvWLEUaseekRAsoQfAk0PjYtm2bTtAItCQ9S8/07NlTv7ddu3ZakfYsEmYskvnKOH7jjTfk5CeawMJVVLVq1eSFAoMJrCeeeEIflPcmMazYElos4+EttLhGZGuxOrGvTgEsu2BeTyYcHj1jEp4Bdl8atCCYFrgvocUcQ00W9YP+FoYkXsW4IxWeR1Yf8BRWKFO8Pm7cODnZiSawaLVfoECBFL3exMKKL6FFDRaWFXVYJUuW1HFKf0vaM4l4KyJoxKyvhRvHSt2NIHgLLbJH6dBSp04dXWKBUPK3pD2dMTzHHy5B0tkpQkaR5jVvF6HgXoGVjn+URT777DPVqVMnlSFDhuTXLl68qNKlS6fSp0+vzp49m+Jvvjh+/LjKnTu3SkpKUrly5bL61UIacPLkSdWhQwf1ww8/qMKFC6vdu3ej0KjrrrtObdu2TW3ZskVlyZIl+f1Hjx5VefPmTfU5jIFmzZqpb7/9Vn3yySeqffv2MX/9Lly4oE6dOqU3zoO5Ofn/mTNnkj+Xe8PJo/k8Y8aMKmfOnOqyyy7Tj97PA/3NfM418/zcWL4Gd9xxh5o1a5aqVKmS+uOPP9SlS5dUu3bt1LJly9TOnTvVFVdckWIffiPn3JuOHTvq+WrChAnq3nvvTcNfIVjFiSzIaPnTlVLNmzdXGzZsSPFaz549VcWKFdVDDz0UVFgJsQ03/5w5c1TZsmXVrl279GtMmJdffrnau3evmjp1qurXr1/y+70nQa5//vz5VdGiRdXy5cv1Z7Vt21ZFCya7I0eOqAMHDgTd/vnnn6CflzVrVpUjRw59ntg8nxcpUiT5/7yPc2PqgnYfPZ+fO3cuWRieOHFCH6v5nI3n//77b8DjNoUe1xFFhK1QoULJzz1f4/pF6z7mON9//321evVq9fvvv+vXUIRRjGD06NFq1KhRKfbxHIPsny1bNlWrVi31+eefq8mTJ6s+ffqk8a8QIoktgcWgr1q1aorXuEnz5cuX6nXBfTDB33333ckThKn1fvXVV+qWW25Rzz33nFZQmJB9CaymTZvqfbdu3aoWLFigmjRpEpHjZDI/ePCg2r59u9q/f79fIfT333/r4/cETY6J2dwYt+ZEzd+8BZH5fzYmxFjk/Pnz2srwFGK+npvC+6+//tLWMo+HDx9O8VkIqwIFCvgUap7/R0Bnzpw57L/l4Ycf1uPHc0yuWLFC9e/fX40bN0498MADqmDBgik8POZYrFatmhbKKEtYaV26dAn78QnRJTbvQCEqcKN//PHHWqv1BA2+evXq2r2H1jpo0KBUAmvEiBHaBcMEuHTpUq3lbtq0Sb399tvqmWeeUdmzZ7ctlBA4TF64I9k8nzMBmzBxegqh2rVrp/i/uTHR2T0ON5ApUyY9UbM5EXacZ4SXuZlCjW39+vVa+eA1T+HPGClRooQqV65ciu3KK69UpUuXdiTM9uzZo8aMGZPCOgX+j5KEwoCF9corryT/DQsU7rnnHu39WblypZo3b55q3bq17e8XYh9bMaxwIDGs2IWhwM2ORcUj1osJWjWTwNdff6127NihJ37e37hxY219vfbaa1obXrRokapQoYKaOXOm6tWrlxZ2fF6bNm18fh+TordAMh89YxPFixfXkyGbOTGyFStWTE/UbojRuBnTvWoKMuKb5rUyr5fpmsRKK1myZCpBxmOpUqW0gPUHyg5jj43PNEFgDR8+XL300kvassbCA+JbdevW1S5AYlxffvmlatiwYRqcESEaskAEluAThAluo/nz56uJEyfqGM/S739QLQe8oApfc4s6+u9FVSBnVtWyTDb11oNd1eWXZdPCCnfS4MGD9T7m5PXkk0+qm266SWvAaOybN29OnuROnz7930BMl86nUOKxTJkyOjYhxLZA27dvXwohZm4IGBKyzPGABeZ5fYmB487DAvZUPBCKWHdY6cS01v22STXv/5zKU6e9On5e6fHXoXJe9e6IO9TxI4fUwoULtSdAcAcisISIcersBXXr5B/V738dV5c8bPJ0ylCZTx1UCx+6QRnn/9UZgRs3bkzh0sF9xIQGaMZMUN6aN5OYCKX4hGv/559/phJkCDeEmenWI46IwGFDgPFYuXJlPS78jz+lMhzfr+YMaKqqVSofvR8p2EYElhAxxi7eql5bvCXFZGGSPp1S9zQsrh65sWayYPIkT5486tNPP9WTEAk6guCZNIGLGUtq7ty5Ok5GRiqCDKUHZad8+fLqimt7qH15avgdf4Obl1eDmpeTE+siIp7WLiQuM1bt8TlZAK9/8usB1blzZ7VmzRo9ATHZECRnAiJzkCQMqbsTvMFFiIVNDAqXMhCTvPnmm1WVKlX0mKHE4qvMZQOOP8anCKz4RwSWYImDJwLX+vx9/F+159tvtRuH5AwEFpoyRcgE69lEYAn+8CyLOXbsmLbIyVgFlJ1LZP0ZzsenEB+IwBIsUSBnFnXg+H+Bc19cniWd6njPPTqpgkQNrCwwXTqkveMSJIPQjF3FY4q5YA0yCnH7Ee9kzPz8888p/m66lknCoJ7vx5xZ1YHj/oUSCRhC/CMCSwgKrYaMbcuVcUVtlc6rRsuMIVyd/6J6pO8jya2bqJP67bff9GRkbqTE4682oSOGmXThudFpQxIw4mPcIJR81dFhfZuJOSTioMxwzc22VmYBM5YWaeutH3hNGVnL+x1/1bIn6TIICryF+EXS2oWggVH6C/78y3pVa9gHat/p/2IGGj3hGCqPOqV+faWnymBcUK1atVI33HCDuv7667Xg8YQJisJi70wx87lnMTD1Vb6KUvlMs9OGEH0oSzCFkneRN5mBJnQM8a6hYyML0OwPyJgh+QJatGiha/lwI/fo0UN98vkXqu7D09Xf5zJ5xLIMZVwyVOFsF9Wq57uqdBfPaWuMdmB8FjEwqc+LXSRLUAgrhw4d0jc+ExJ93O5/cLiqcGM/laVycx0zyJM1g9q+4D014qb6asSwB7RAMicInlM8OmDAADV06FDL7ZZ8CTI2s4jYs14LoeavfRBtxITQIN2ca+Ld8or6KPMaUXvlKZQ8lQtPAeVdY+WLp556Sj399NP68ZFHHtHWFskXFBNTmP7oE0+rPFffpPI3uEmPv3w5Mqmdiz5QvRqWUuNeG5NsnZllFFhoNNOl2FgEV+whAksIG7hsWrZsqQPgd911lxZYTAIkVBCjMqHLBc1Ka9SoobsTeKe10+GCThehgDBjovTurGD2EaTzgmeHdMA1FKwfHhtp9t6tqOKZUBoCM+lTK2Vav95CCQERimDgGnJNsaLJLKWLxa+//qr7BzL+iHvxXRS0mwwbNkxNmjRJW2EUq3uPP7q+EycTgRV7SFq7EBboRIGw4iYn68+zQ7Zn41GgiwXxBwqGPScL9iXBYvr06SEfD59lCphrrrnGp0Bj8PvqhWf+n0mL556NfYHUeyZa6kGCLdcRbCkPkkgiMTFyXnG9hbLkCYqH1YbAuNJ89WJEWEWyATAxLIQVx4lrGesNC59elCYcgye0a2IJEaxB7/HHe1GuRFjFD5J0IaSA9kksI8Mkhka7ZMmS5L9hiXi3nmRyu+2223RwnEmNycZ0ydBSKS0yAZmQEDhsdNEIBL/JV7NXs6O52eEct5d313Nf6y55wu/GsjMtNqtrXvl75BzynWb7KitLiPjqNE+MiGthCh7T0ozFhsBY9qy/xjlH4LBETSB4D82Yx44dq2rWrKktsv8tTKuTeqSUIr4QgSUkQyYfkwVduKl9mTJlSoqz491F2+Txxx/XggutGI2WSeKFF17QPQVZSI9JJ1YSJTgOYmtsTroymNaLv6U82MwJE3w9Wl0Xi/Ptb/0t7/9HYqmPtIZu7Sz8yXmmcTJjyNs68jX+HnzwQb30CMILIc+5QIBRSoHyRUGyr4VGBRdiuGBZZCHyrFu3zsiXL59Rq1Yt459//jHOnj1rTJo0yciTJ0/y8uPp06c3unXr5nP/Hj16GAUKFDCuueYaY9WqVfq1xYsX6+XNW7dubZw5c0Yuo+CX3bt3G6VLlzZKlSpl7Nq1y7hw4YIxa9Yso0SJEnrspUuXTj9effXVPvcfOXKkkSVLFj3+vvjiC/3ar7/+alxxxRVGzZo19ZgWYgsnskAElmD88ssvWljVrl3bOHLkSPIZOX/+vFGuXDmjWrVqRrFixfTg6t69u88ztnXrViNjxozGqFGjUrwuQksIBgIKYcXGc0+uu+46o3jx4kalSpX0+GvQoIHPzzh69Khx+eWXG/369Uvxugit2EUElmCbtWvXGnnz5jXq1KmTQljBlClT9CSxevVq49y5c8aMGTO0JeaPAQMGGLly5TIOHTqU4nURWoI/du7cqa0qhBVWlve4Yfx98sknxsWLF43PP//c+O677/x+1ssvv2xkyJDB2LRpU4rX169fL5ZWDCICS7DFmjVrtMuvbt26WkP15OTJk0bhwoWNW2+91fLnHTx4UAusQYMGpfrbkiVLtHuwVatWxunTp+VKCVpYlSxZ0ihTpoyxZ8+eFGcEAXXVVVdpF+ClS5csna1///1XC78OHTqk+psIrdhDBJZgW1jVq1cvlbCCp556ysicObOxY8cOW2f1hRde0K7BLVu2pPqbCC3BhHFFfKps2bKphBW899572rpasWKFrZM2c+ZMvd+yZcv8Ci0E4eHDh+ViRBkRWIIlcPHh769fv75x7NixVH/fv3+/kSNHDmPo0KG2zyjWEzGHm2++2effly5dqi2tli1biqWVoGzfvl0LqyuvvNLYu3dvqr+fOnVKx0w7d+5s+7OxxlDCcHFjpXmzYcMGEVoxgggsISg///yzFla4WnwJK+jTp4+Oa3nHtKzy/vvvay13+fLlfoVW9uzZRWglINu2bdMKDck8f/75p8/3PPfcc0amTJl0Io8TiHMx/qZPn+7z7wit/Pnzi6UVZURgCQEh3Tx37tw608pfKik3M+nrr732muOziWZLKnGg+IMIrcQUVlhOgYTVgQMHjMsuu8wYPHhwSN/VsWNHHR/zV04hQiv6iMAS/LJy5UotrBo2bBiw7qFNmzbaVUMdViiYGV4ffvih3/cQZ8DSatGihbgH4xysJYRV+fLljX379vl937333qs9AKHWTf3xxx86Y/Cll17y+x5TaNWoUUNiWlFABJbgN2ZF9l6jRo2M48eP+z1LCxcuTE4jDgdt27bVGWCBhJ8IrcRIsChatKhRoUIFHR/1x8aNG7WQGTNmTFi+t3///lpJC5Rg8dtvv4nQihIisIRUbN68Wd+QJFgEElZ0FqhevboWalbTiIPBBIR78dVXXw34PlNoXX/99breS4gfcPFhsZMNGEhYQbt27XQ9Funp4YAyi5w5cxr3339/wPeZQgs3tnTgSTtEYAkpIE5ANhZdAoKl8U6dOlVbVz/99FNYz2Lfvn0tJXB88803Oo2e1k++srsE90FSD0KgUKFCOjPQigt59uzZYT2G559/3lICBx0xsMaaNWsmbcTSCBFYQjLEACpXrqwFlq/UYe8i4SJFitgqErbKX3/9ZTlFnngXPeMIuIfLyhOiA8kOTZs21UIAYRBqko5TKLOwmiJPdmHWrFl1SQYeByGyiMASkgUQNz9FkgSfg/H00087KhK2ilmETGeDYIwfP15r2hQgC+6EHpRk6TH5f//990Hf77RI2Crm5//www9B30v7J+JoJH+I0hRZRGAJOsGBWBCpwdRchdMCcorZ5um2226z9P4nnnhCTzBvv/12xI5JiAxM8r1799aTvtk1PRChFAlbxWzzRDmHFSFk9tBkHAqRQwRWgsON2bVrV23NEBOyQqhFwlYxY2TUXwWDSQUNl4SNzz77LKLHJYSXhx9+WF9niset8Oyzz4ZUJGwV2oJxXO+++66l97/44ov6/W+++WZEjyuRSZLlRRIXJvmBAwfqGNBHH31kaR8SLHj/2LFj00SYUgNGAoiVGi9iCGjduJUCdegWYgfS0ZnkX3nlFUvvx0VMm64HHnjASAtQ5nCTW6nx4n4aMmSIvj/CnQgi/IcIrATmmWee0ZMFiy5ajTPgJmENrLQKMNN8FFcRmVtWIL2ZrC0rgXshuphxohEjRlh6PwKBOj3cgYHKLcIJ7m/GEpmrVpUs1n/DArTqsRCsIwIrQZkwYYKeLHCvWAUtGJeblThXOCFWhtVkNcGDQU0GGTGwSCWFCKExb948rYjgXraaqEBxOmP2008/TdPTP27cOMsJGEBdoBkTpgBfCB8isBIQMxWc4kirkwXLOZBogQsxrTlx4oRufop2bfV4KT6l8JQC1L///jvixyhYhyxAFJCbbrrJsqWORUXni/bt26d5Jh7HSCd32jHhZbCaNEThPcXFvpbNEZwhAivBWLRokXZX2C227dSpk7ZY/HVrjzRo1Xa1awpPKUDFhZlWLiTBiEixLXV2dDbZtWtXVE4xXgWUPKuxNqDwnvgrC0QG6oUoWEcEVgJBOxnaztCs1k47o7lz5wZtShtp0Kppw0P8AovLKuvWrdM9EZs3bx5yc14hNGizhJVkt53R2rVrtSs6UFPatIA+g7j5ghXVe3smGLPVqlWLmrIXT4jAShDokUbPNdwadiZ8XBt0vsAnH+2iSDNDzG79F30HsSoJnEf7NyQqdI+oW7euFljB+gN6u+PYjwk/2j0jWWW7YMGCtuu/6I+JVXnDDTdIN4wQEYGVAJA517hxY6NAgQLG7t27be07bNgwHW8I1tctrSBbkGC93QxACoqxEt94442IHZvgG5QEWnjh0sNasgM1TZHsaGGXGTNm6OP56quvbO23YMECbSVGstg+EUiSOqz4nyx69uypC4OtZjl5p5SzmmusgFuPuAD1WXYb3lIjw+9hSRQh7aDNlpMlaLDEcOeSSRhL9xPuZZbAwWq0w+uvv67PwzvvvBOx44t3kkRgxTejR4/WN8kHH3xgaz+EAW1prBbtpiW4+Jy0YSLDC9cmi/2xhIoQeSigtVs+YUJbLrLsQl2YMdwwdlAAH3vsMdvCDuHLvsuXL4/Y8cUzSSKw4heSJchseuSRR2zvSzExE823335rxCJ33HGHbg916NAhW/sR+K5YsaJexTbSraUSnVWrVml38u233247dogLzU67prRm5MiROi66adMmW/uh/DVp0kS756OV8ehmRGDFKcR4yGgiHd2u64y6JawQXImxCseYJ08eR8dIXQz7tmrVynJdjWB/XTXKIKhFspO+DrjaqKEj9T1Wk2Q4RtyCTo4RJYtUd7sJUIIhAiseYTIns482SmT52YXWMvny5bNtvaQ1phXopAUO+xDPCrayrGAfuqlT+0axN62N7IKrDbeZlWVuosnXX3+txx+d2u2yYcMGxwplIpMkLsH4ywgkIYGCWWpA7GLWXLkhMMyNft111+mJ0UmNi5mB9tZbb0Xk+BIRrglp33RFoQbOLmvWrDEyZszommU67rrrLl3b6MS9Z7rs7cbCEpkkEVjxA64JYjvEDVauXOmoVgvfOgW6seqK8YaJggnDqfuyX79+OhYRq7E6t/H444/rSXjOnDm298V1yIrXFBbHWqKPP1CUUJhQnJxYSqNGjdJKE+nyQnBEYMUR5no8TgY/AoplvnEFOnHjRBNz8Tw0VrtQjEocgiUkpFFueGqUnK78/OCDD2pXIO4yt7U7c1rjx33Xo0cPrWSSpCIERgRWnMCihWi2ZC85Ydq0afqms7ouVixhLjtBFwL6t9mFfQjyV61aVXoOOgSLPkuWLHrydWKdY+EyfinDcCP33Xef7sLipNEtluXVV1+tk1RIVhH8IwIrDqAuhAAuFpITtwS90WgdQ0Nct0KRKZl/dFRwwu+//66LVDt06CBBcAeuZFouUbdHDNUuNCYma+6aa65xbesikptQejgHTn4DXg16DtIV3m5WZSKRJDEsd0N6LX3WKlSo4Mg6QBtu2bKlnnDcXpc0c+ZMbSXOmjXL0f5ffPGF3t+tWn40QEGiPIACX6fWwd13362TNGKl/ZdTKAbGSiQu5QQSTrBSabIr+EYElsvp3bu3dkU49fubmXIUarodhO8tt9yiC4rtNFj15KGHHtLp7rHSu84Nq1YzSRPHCUVJmDx5shEP0HuTOBxtzUJZWJUOIUJqRGC5mHfffVcPbh6dgL8dYYf/PV6gdiyUTEeSMBo1aqTdM07iYYnE4sWLdUPXJ5980vG1Iu5IF3O3ZKVGOtPRbBRM5uvWrVsjcoxuRgSWS8GiQtj06tXL0f50eCDQy4q8ToqLY5nPP/9cC/KpU6c62p+YHtmSJHJIUadvsGARNi1atHAUs2Fipl4rFGs4Vlm9erW20knxdzoplytXTgs9iWelRASWC6GdCzErYld0FXACHdjRju12cHcLoRR0AstHIPScxiPiGZSdpk2b6qw2uqo4Yfr06XHt+qLwGaHFSsVO+OWXX3Q8izpB4f8RgeUy0ExpJkpWoNPWNdwMFMuOGDHCiFdCLeiEhx9+WE860lk7JTRT5rw4LbYmOYNelV27djXiFVzLWEisduDUSpo4cWJISUTxSJJkCbqLUAcxacfUG9F40y3dBKJR0GlaEix8STwr1vsqphWm5UmRulOFi6zCIkWKxNyyIZFw25OAQUG003PFEit4CpzUd8UjSSKw3ANpr9wAoaS9suIpn2F3xV63QkIJXQSc/l7iWXTBIDEg0eNZ9KYk5kRCi9NzMW7cOC3w5s+fbyQCL730ks6idPp7KVUhnkUja4lnGSKw3MLRo0f1cgZ0wXZSnAnz5s1LuDoj6tSqV6+u179yUqfm2ZXbqVURD2CNk6TDKgBOLaNwKFxuA8HeunVrrfQ4rVOjiTDxrHvvvddIdJLEwop9cA2wDAHdKJz2uyP5gE4Q7du3j5sUYqsQ6yPm52QhQRPifcRtvv/+eyMRGTJkiI57/vTTT1FTuNzcCQQXKJ08nK6/Zi6lQ3F8IpMkAiv2efXVV/VgpV+gU+24Xr16uv2N27tZhNqY1WmBKhMNEw4dQRItnvXpp5/qc/f6669HTeFyO999951WeJys/u2dbJXI8awkEVixDWmxrA/kNHALLFKIdpzo3aDvuece7Vpxsk4T4NLBtXP99dcnTDxr9+7dWtDQp9KpdRqqwhUv0MU+lPgdLm1c2yRM4epORJJEYMUuDErSYmvVqqXTZJ3w8ccfh5QpF2/nk5s9lHgWk00o1oab8FwgE5eeE3788ceQFa54Op8oOyg9JPM4geQhlC5ctIlIkgis2IVByeDcuHGjo/1p7UIH8i5duiRc3CpYZ3tqgJyek4EDB+rMw1hfwj1UEMoI52+++cbR/rS2QtixArZThSvewJ2MW5lyCafxrDFjxujMw2XLlhmJRpIIrNhkyZIlerJ45ZVXHFsTpMKSEstFFlJ3dSeQ7QS6i3BeyZpzOunEOps2bdJCedCgQY6tiTZt2ugWV06tiXiFxB3iWU4L92mFRTy1dOnSCbd+W5IIrNi8KCVLltTtb5zGSvr27asnHKfxmniHFGGsV7p+OIGWVrS2crq6biyDEK5bt65u/+W09dfzzz+vrQBKAgT/q4NTiO2Ebdu26SVZiMsmEkkisGIPGtrittq5c6ej/T/44AN9M7z99tthP7Z4gSLMUC1QWjeRzOJ0KYlY5emnn9YWAKsIOwFXFcL8scceC/uxxQsoohSjh2KBmkuRJEoRNojAitFO41OmTHG0P/Gu7NmzG3feeafErYJAejBtb1jOwUk8y2xzheCLlzZXdBonSWLkyJGO9j9w4IBRqFAho1mzZq5dPTgt41m0/WI5GyeuZbPNVTwsvmoVEVgxVmAYylpOLBPCWjxVqlSJuyVDIgU9GVEQ6NHohLVr1+oJPh6sCXMtJ7JSnQhgBBRZhQgslnwXgkNjZaxZrHUnYJ1RdtC9e/eEON1J4hKMDRBQN910k3YROLnZ2b9Hjx7ar/37779H5BjjFZZwIJ7l1AUWqgstViD1nPPw22+/OdofqwxX4NKlS8N+bPEMS9iEUqf2/vvv6/0/+eQTI95JEoEVG5hxJ+qmQinOZJ0hwb5lQcYf6zs56fdGynadOnWMihUruragk7gTSRKkTDuByZLxxzprgv14FsoqyqaTJs0oqx07djTy58/veH0ytyACK0a6YIdi1n/55Zdasx0+fHjYjy1RwKolnoDgcZIZR+wQ6+SBBx4w3DgJ0LarSZMmjrJSaWpL3NRpLFD4z51PUTvZwYQGnMQOKUhG8MXzNUgSCyu6MEGwzDiBUyfdBHDfkDjQoUMHCXKHCPGoUCZes6DT6cKG0aJ37946K9VJnz+Wt2fskgbvVusyltpgEcOmqNhJDPGjjz7SVu60adOMeCVJBFZ0MdcHWrhwoe190cQoHmT5jEQrIIwU5k3/zDPPhFTQeeLECcMNmEvOOCmBQEAhqBBY+/bti8jxJRorVqzQS7BQ2uJEaaJBLqs5O13KJNYRgRVFWPIDjZ5FBu2CBsbkiEbG5wjh46mnnnIcxHZTQeexY8d03K5t27a2J0dzNdxs2bJpl6AQPt599109/ohL24W1yrim9CyMR9dgklhY0YHBRPo62qld64h9e/bsqTUxOi4I4b829F9EmXDSCePNN9/UE06sr51FT0RcgU4KV8mMDCVJSAjMsGHDdFzaSaeQL774Im5dg0kisKK7xpATLf7ll1/W+5LOKkQGEi+oR6J5KwFtu3HJ+vXr66LiWG36yrI1xNuc9Kr88MMPHbtNBevuZSxfmlfT19EunTt31t6Xow677CeswKKnGJlXaHKkXd544422u1w7OchYBouKjDQnBcLEHJhonDbOFKyD5UERbIMGDWyvkotlhob80ksvxeRkiDCmQ4fdDgsIOtyAoXS7F6zBfEch95VXXqldfXYghsWce5+DcENCC6zWrVsb77zzjs5moxEr/bNKlChhqxNDvAkslg3hprfbK5CedQxCai4SZQHBaMOS8KSr33HHHbYn6MGDB2u3ItlfsbZsCEqP3eXumQRZ6h3rUTIC04bt27frZgLNmze3ba0TA0uXLl1cLdya5i5BMtv4Qjupv/EksEidRvOmW7MdKAikRgOt2C0ZaPECsQDG3+jRo21b0kzweBViBYQOZRB097DrIq1du7Z2kUrbpbSFziG0/+rfv7+t/bCer7rqKm1Nx0tfxzQXWCwqyBdu2LDB73twv3BA5oZrJh4EFoOmXr16utefHW2J88EieAULFtRFxkLagwsWbZWAtpN4z9y5c41Y4JZbbtHjyE5sA2uemIjTJBQhdFi7jXE0fvx42ys+p0uXzhg7dmxcXIY0FVgMfAKJdCcOxBNPPKEPyntzu8BisPE7aHhpFdxQuKNwSzH4hOjA2MVSwiVrJ42b60eKMdZxtBsSs/YS42/GjBm29nv88cf1fiQKCdHN6qRnpd01tO655x6dvEGRt9tJU4HFonncuMHSaOPRwsKNQvulu+++27ZmLz0CYwNcsRTKkn2Fp8BObRaLaTrtyB0OcOlR0NyyZUtbsTi62DP+SJ4Sogsuvvbt22tL147yeuTIEZ3wRt2c20kzgYX/lcw4J+1f4iGGRVYVvb4OHz5seR9SjvndpLELsQExWFbiZfK3o7FSt0Qcwmkn9FBB8cFKZw0wO10/cCcNGDBAMgJjBBQPWjflzZvX1qoM7733nuOOOgklsNDmEFYEn+3cLPEksBgkHD8V7HYH2EMPPRTRYxPsQ2cRCr5pVkq3CCvgNShfvrxuMJvW6eAISYQlHTys8s033+jCdBQtyUiNLbCYqPHDALAa07506ZLRtGlTnSLP6gRuJeICi2wkXGEsX4BbzNzspMW6WWAxOBgkDBarExW1VviqaUoqtS6xCUlD9GzjulqdABACdhWXUEHY0MILYWm1loxaK2J1lKTEy0rK8Qa9GwmvVKpUybLXZuPGjVpxefLJJw23EnGB5St5go3arEgeZKxAwDpTpkyWq9Vp50O8g1orJ8tmC2kHyTPU03Xq1Mly2jDNSXEN2y0EdcrUqVP1vbNkyRJL76eon+NjfbBoJ4kIgdm8ebPtazXCgWs4lpDWTBEu+sOt8uijj1ouDEZrv/baa11tticSpLljDffp08eSNWwm3/D+SEPqOkWnVtdZI7mJon66K6SVQBVCw7SG27RpY6lU5tSpU3rtM7vJN7GCCKwIQgNVYh1WFgQkGYUuyzVr1nSlJZnImN21rSom5pIyTDaRhAU9ySizkhyCWwlBhcBy0gxXiB6LFi3SXhwUEyvxxnn/W1LGSR/TaCMCK0LQRd1qvILmqmXLltWxLruNVoXYgJ6BXG8rBZq4eikex5KOlJZL2y+seyvxCtxJuJVwL+FmEtzHrFmzdEYnK15bGVOtW7fW843bYpQisCIAA4aGqbRFCRbbIMuM92FdOUn5F2KHoUOH6klj5syZQd/75ZdfRrQDBtl9jKlgsQ0mLCYv3EqrV6+OyLEIacMbb7yhx9SoUaOCvvfXX391ZQcMEVgRXLWWrLBAEKciy4y4FfErwd3gjqErCe6ZYPUuKDU0NK1YsWLYk2tWrlypx9+UKVOCHi+CDUts8eLFYT0GITqMHDnSclJbr169dIzTamlGLCACK8ygsZYpU0Z3pQ8EkxStfsgys9OqSYhtCHzTfoxVh4N1I6AvH1ruhAkTwvb9CELS2KtVqxbQuud9FATTiFkWYYwfuK59+/bViUCfffZZ0EbIxDjdVOspAivM0J2CSSBQRwMmEjRxBpXdZqqCe7oR0L8t2BIejANaPdlddTrYwqALFiwIOKk99thj+n2TJ08Oy/cKsQPzC02OsfQ///zzoBYZae6xtgSOP0RghRFSgfPkyaObTQYaTD169NBCzW4TUsE9IIBMoRXI0qJTAXV3CJBwWPcE0olJBRJWZDM6WS5FcJelT4f9TJkyBbS0GKd077da+hBtRGCFETJ0CF77Wy/IU1hZCcwLiSG0KObENYyLJhQIoDO2/MVDEVaPPPKI9KdMEKwKrYn/a3BsZxWCaCECK4xFwgyMZ555xq+w6tatm3YDkoIqJE6Hd4QWiyb6E1rchHTT7tmzZ8hFwv5WA0BYmZ3/x4wZ4/h7BPcJrVv+5x70J7SIp9PiqVmzZjFfTCwCKw2KhBkQtORBWM2ePTtcXym4SGiRCBFIaFFMTALGunXrwl4kzCREYB1hRYxVSEyhlTFjRr9CyywmjvWYugisCBcJI6xIHUZYsfqskJgEE1pMKjSobdWqVViLhBFWCDPG56uvvur4+IX4FlqXLl3SFhaWViz3MBWBFcEiYS48i6YxSCR1WPAUWig53syZM0cLlvnz54elSJixSTEzn/n666/LBUhwznkILcaaNxSOM1YmTZpkxCoisCJUJIywwk3I4HBjzy4hckKLNbF8CS2rNVSerFq1So+/t99+O9VnPfjgg5bbRQmJwfnz5wMKLbIFyRoMV5lFuBGBZRNiVHQ6fvHFF3WFOKvPXn/99X41GepiBMGf0FqxYoWtLhUIoptvvlknUBw6dMho0aKF7kvoKeB4z5AhQ/TnEBsTBH/KtPf8xOKk1GWxLFIsIgLLQTaguaYXQW4eWZzSO5XUnwYjCIGEFuOH9bVI4PG1xAyCyRx/xK28hRvCavDgwfr1N998U062YEto0a5r4MCBem77+++/jVhDBFYIAsvcWN/ohRde0IWbaL/B6h4EAYg5IbSo3fvuu+/0/2vXrq2XPqeeypcrjwnFe/yhEROrYkXh+++/X782fvx4OcmCZaFFaIP/d+jQQStRbLiU40FgpeMflYYcP35c5c6dWyUlJalcuXKpaLJz505VpkyZVK9nyJBBtWrVSn3zzTfq448/Vh06dFBu4NKlS+r06dPq5MmT6tSpU/rR+7mVv/3777/Jn5kuXTpHj+bzTJkyqcsuu0zlzJlTb3ae88j+boFz1759e/Xjjz+qSpUqqXXr1rGitx5L69evVzt27FDZsmVLfj9/S58+vc/PuuWWW9RHH32kJkyYoO69917lBvg9jD9/48vqODxz5kzyZzodd+ZjxowZ9ThyOgYzZ86s3MKFCxfUHXfcoWbNmqUaNWqkVqxYoa8JY3LRokV6/BUuXFjFCk5kQUaVwHgOclNQ5cuXTxUvXlwtWbJEffrpp6pdu3Yqmpw9e1b9/fff6sCBAwG3gwcP6ps+GJ43sLnlyJFDP15xxRWqVKlSKkuWLPrcmLqM3UfP5+fOnVMnTpxQR44cUbt379bPmZR4ZOMmCwTHYk4gefPmVYUKFdI3nedmvsZj1qxZVbTgPH7xxReqfPny6pdffkk+3wjdQ4cOqYkTJ6ohQ4b4HX+8l+OvXbu2VpQmT56s+vTpo6LJ+fPn9dgKNv4Yo1zXYPov95j3uDO3yy+/XBUrVkwLdSfjz9drHD/HxaS4b9++5HFnjkHGZyAQWKbw4vi8x5/3/7Nnz66iRcaMGdUHH3ygNm/erJYvX65fQyH6888/9X00atQo9dprryk3k9AWFhMoE7RJ06ZN9SDeunWrmjdvnv5/pEATReP566+/9A1vPnpvR48eTbEfA7BAgQL6RvHc8ufPr8+nr4nA8/+xpDEy9EyB5j2R+Hr+zz//6PPkea68BV6ePHmCTipsnCtvgRGO3/Pggw+qV199NcXrCKxbb71VLVy4UF9zrocva6BatWpaYWKymTZtmurSpYuKpCKEh2H//v0Bx9/hw4dT7ctY8x5/jElz/PkTSPzfVIZiBXP8BRp35nPuRc/xx6O3wOMcWBl/jNNInIc33nhDDRo0KNXrAwcO1ArQtm3btFIQC4iF5cCFZjJ8+HCtHaNNLlu2TNWqVUtt2bJFa7r8De3FLlg8DBA2hKDncyYKT0ztzdxq1KiRalJgwwpCS40HuGGZwNj4XU6un7cQM5+zoZCsXLlSP/e2PtGYr7zySlWuXLlUG8fiZDLZsGGDFlae1oGp5eN6ZsJ788039Xjypnfv3uqPP/7Qx4uy1Lp1a33cTDIIQSZ8u+DaRUB6jz0e9+zZk+IYOR+e4wyXpq/xh7Byk5s2GChwKAlsduH8+RJinhuWNo9Mzp5gRXqPP/P/CDQn4+/YsWPq/vvvT/U6n3Xx4kWtMLzwwgt6DLqVhLaw0DKrV6+u+vXrp15//XV9UdGCK1asqOMHd911l7aEmETq1avn8zPQvLZv3+5zUmCgmvCbzUFpDsyyZcuqokWLqoIFC6aIbQjhh+vkLczMa+WtQHCtfAkzXmNi8zeZcCt9+OGHWvH56quvtBvUFF4IwZtvvlkrQFg2CAioW7euuuGGG/Q+CJcvv/xSNWzYUCtNnTt31gJ59uzZfq0t4j2MP++xxyOuIPP2ZrLyHHvmc7Rtxp8TgShYh3nEU7ChMJhjj23v3r2prpWnEDO3ggULBhRm8+fP16EMxhPfZY4/lIzHH39cPf300/r7SpYsGfXL50QWJJTAOnX2gpqyfKeasWqPOnjiX1UgZ1bVonRW9fbQ21XuHFl1YBItEo123LhxyQODwDeTCoFztGh8xOakgO/e00ryHGSeE0SgiU6IPqY1bE4gns+ZYLyvsacQQ8GpUqVKCqUD64+kCyaQKVOmaIG4dsNGdW3fp1WRJl1U0jlDj7/2lfKo9x+9SyX9c1ArS1WrVtWxhkcffVSPF1zAw4YN05qzOf6wxMxjRCiZIHS8JzpzDDKuZfzFLp7WsOfGNUaYeV7jcl6CrEKFCnrcmEoQMK0zThh/77zzjtq0aZP6afUvqtOIN9Tltduqkxcz6PF3e70Sqnfj0ipHlrRPZxCBFURY3Tr5R/X7X8fVJQ8RnU4ZKuOJA2rRw21V+kvnVceOHZOzuzwz3UxfNUKWCcpbIJnatxCf1pmnBeO54UIGBAvjAIvdc0OTZQwFGn/pju1Tnw9qpooWvELddtttWnHyhPGHWxEI6jNBeQpMcwwSRxKhFH+YVvRWL0HGI4kkJridGXPEQs3xhxeHEIK/8Zc+nVKVC+dSs/s2SHOhJQIrAGMXb1WvLd6S4mJ5XrS76hRQT91ydYq4lkmRIkV0hhcDoESJEjIpCCluOrRXhMzSpUu1pUbs00yWQetlAsl5dRe1JcuVfsffwGZl1SMdaqYoKTDBciMJg/HHpOQvFV5IPE6dOqU9Pt9//712A/J/LDXT88PY0dbX1V3Uzssq+R1/g5uXV4Oal0vTY5ekiwDgBvR1sYDXv9h0TF1zzTXqt99+03EDNFU2M7CPSzBekh2E8IHFXb9+fZ0oQSkEkHmKpV66dGk9hrQ7xigQcPzN+vlPXa+1atWqZBck4424Khp2gwYNYqqGRogNcuTIoRPE1q5dq+tGAffv7bffrq1ukkqwxL7LWDTg+GN+TGuB5YSEqcMiZhWIv4//qy47dEi1aNFCJ0IQJMUH/NNPP2mtlwwccfkJ/iCrzmTXrl3q/fff18IGgYWyY5TM9V8vCz8cSDqjjvz+u064QOAx5nADUfxJajUBdBFYgpXxh8JDoo45/sg4Ntp0Djj+gs2PsULCCCwCjAeO+78ouTJdUk2bNdOBbQKVJIXo13Pl0iY1GTa4digKRXNBqIlrJnHB8iZ+gEXOmDELNU2YLIBYKOPlcJDxlzuzoVq0b68/C2Fn1j8Rs2LCGT9+vH4041e4psXiT1wMw9Buv40bN+oxs2bNGr/jDzfyviDjj/nRDSSMwCIbJlAMq0+zympQ8xuTLzLZVwwEcyPNeNKkSckDAd8wAU3vGgo2Yl4S/I4PocQ48FVHh/VjxpuIU6HUoMCYMVCECansn3zyiW6TEyyGeve1ldSg5h1STEZmVqA5IdHFwEz+IRGDichX6j2dWkSYuR/GAdaSr5KZbdu2acvbnIvIUiWD0HyN68/r06dP163lgo0/5kc3kDBp7eHIkmGywN3jnSnGRl2FOVmhFfuro5D04tgCBQSh5GtSQChRq2dOALjqvDNDmSjMTEBaKhFLgOuuu073dKPQNlzjj64eZv2Od8YitV1m1w8Ksb2FmXnM1F2JZyB2YPql5MFXHR2PhCaA8VW8ePFU5QqVK1dOzgSkVo86P96LAjVnzpzkXqmSJRgndVjhqkMwW934Sj317CrgWcCJW9FXXzxiZTKphA7nnJR073ZDKB3mBIFQMq0WbnoSJXzV0SGUgrW1GjBggHbdjRw5UruQva2cSI4/hJX5u7yVKV43PQP0KjQ9A97jz2whhJAVCy08kLXnPf6YDzwtdU+hxDjzVeCN4MkapE/myy+/rGv2+vbtqxsheL8/kuPPCZLW7pKiQHOiRLMimO7dL5A2UJ79x/w1fGWLpzY5VkHAmA2B/fXAMzfPzt+m9UH8x1cdHZNFKOeTbFKuKbHOWIIaLm/PAGPQHH/e/QIRVtR0BRp7sdBsONYbArOZLjoTxheKgq86OpQlxqdTzpw5o13I/rryxBoisFws0DwnX+9+ZObrTNLedWLESZg4sFadLN9hvob1EMm4G9YOvzPQEhOB/k+WpjkJ0PLIE47bbAjsKcx9bZFoehsvCoC/8ec5Nv01G6YDiK9xZXUMIvgiPf74nXbHnbnhETKVJAS8dyTFvA+Djb9INb11IyKw4hzcOixT4T2RcCNx8QN1mg62jAJWHRMHLkvTHRlo7SEr6xMhXD1vfF9F2Z7wvZ4dvj2f40b2NwkwWThpTiw4bzbsKdh4bo4/f2PQV0G0v2VHTHeklTEWbPx5rg8XbCkb8DX2eG52Yfe1oSwloqcjVERgCX4xtUvPScTXxMKNjfYYyhpEnm2tgi134vk80lq2EF03GmMrkFDzVGxCGXee448EqEDLnXg+J6tOYsdph3S6EPyCy48FENkEIa3BAsFtyCYITpGmZIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguIKMaf2FhmHox+PHj6f1VwuCIAgxgikDTJkQkwLrxIkT+rF48eJp/dWCIAhCjIFMyJ07t6X3pjPsiLcwcOnSJbV582ZVuXJltXfvXpUrVy7lRs0AgSvHL+dfxo/cvzL/OJs/9+zZo9KlS6eKFCmi0qdPH5sWFgdWtGhR/Rxh5UaBZSLHL+dfxo/cvzL/OAOryu78L0kXgiAIgisQgSUIgiC4gqgIrCxZsqgnnnhCP7oROX45/zJ+5P6V+Sft5880T7oQBEEQBCeIS1AQBEFwBSKwBEEQBFcgAksQBEFwBSKwBEEQBFeQpgLru+++U+3bt9eVzVQ4f/bZZ8pNvPDCC6pu3boqZ86cqkCBAqpjx466a4dbmDBhgqpevXpywXODBg3U119/rdzKiy++qMfR4MGDlRt48skn9fF6bhUrVlRuYt++fap79+4qX758Klu2bKpatWpq9erVyg2UKlUq1fln69+/v3IDFy9eVCNHjlSlS5fW575s2bLqmWeesdWLLxbaMHG/lixZUv+Ghg0bqp9//tny/mna6eLUqVOqRo0aqlevXuqmm25SbuPbb7/VgxuhdeHCBfXII4+oVq1aqd9//13lyJFDxTrFihXTk3y5cuX0IH/vvffUjTfeqH755RdVpUoV5SYY5JMmTdIC2E1wnr/55pvk/2fMmObNZhxz9OhR1ahRI9WsWTOt6OTPn19t3bpV5cmTR7llzDDpm/z222+qZcuW6pZbblFuYNSoUVrp5L5lHKEo9OzZU3eMGDRokHIDd999tz7vH3zwgTZcpk2bplq0aKHnULMDUkCMKMFXz5kzx3AzBw8e1L/j22+/NdxKnjx5jLfffttwEydOnDDKlStnLFq0yGjatKlx//33G27giSeeMGrUqGG4lYceesho3LixES8wbsqWLWtcunTJcANt27Y1evXqleK1m266yejWrZvhBk6fPm1kyJDB+OKLL1K8XqtWLePRRx+19BkSwwqBpKQk/Zg3b17lNtA0Z82apa1eXINuAiu3bdu2WjNzG1gkaJZlypRR3bp10w1A3cLcuXNVnTp1tEWCS7xmzZrqrbfeUm7k3LlzWrvH24Nb0A00bNhQLV68WG3ZskX//9dff1XLly9Xbdq0UW4ArxTzTtasWVO8jmuQ32EJI0q43cK6ePGi1ngaNWpkuIn169cbOXLk0JpO7ty5jS+//NJwEzNnzjSqVq1qnDlzRv/fTRbWV199ZXz44YfGr7/+asyfP99o0KCBUaJECeP48eOGG8iSJYveRowYYaxdu9aYNGmSkTVrVuPdd9813Mbs2bP1PbBv3z7DTXPOQw89ZKRLl87ImDGjfnz++ecNN8GY557lvF+4cMH44IMPjPTp0xvly5e3tL8ILIfce++9RsmSJY29e/cabuLs2bPG1q1bjdWrVxsPP/ywccUVVxgbN2403MCePXuMAgUK6AnfxE0Cy5ujR48auXLlco1LNlOmTHrC8WTgwIHG1VdfbbiNVq1aGe3atTPcpqwVK1ZMP6J4vv/++0bevHldpTBs27bNaNKkiTZYUBjq1q2rXZoVK1a0tL8ILAf0799fD5wdO3YYbqd58+ZG3759DTeARW4OdHPj/2iaPEdjcxt16tTRioMbwBrs3bt3itfGjx9vFClSxHATu3bt0lr9Z599ZriJYsWKGePGjUvx2jPPPGNUqFDBcBsnT5409u/fr5936dLFuOGGGyztJzEsGyDgBwwYoObMmaOWLFmi00vdDgtqnj17VrmB5s2bqw0bNqh169Ylb8RUiAXxPEOGDMpNnDx5Um3fvl0VLlxYuQEyBL3LOIinkKLsJt555x0dgyMO6iZOnz6daqFDxjz3sNsgq5pxT+bpggULdLayFTKm9Q26bdu25P/v3LlTTzQkLZQoUUK5Idg/Y8YM9fnnn+tarAMHDujXSSslcBjrjBgxQgdoOdfUQ/Bbli1bpgeMG+CcV61aNdXApybI+/VYZOjQoboOkQl+//79umM1E07Xrl2VGxgyZIgO/D///POqS5cuatWqVWry5Ml6cwtM7gisO++801UlBdC+fXv13HPP6fuXtHbKUV555RWdOOIWmGtQ/CtUqKBlwbBhw3QtIun5ljDSkKVLl2oXjvd25513Gm7A17GzvfPOO4YbICWWuFvmzJmN/Pnza3fgwoULDTfjphjWrbfeahQuXFif/6JFi+r/49N3E/PmzdNJLyRfEHeYPHmy4SYWLFig79nNmzcbbuP48eN6rOOaJdmlTJkyOh2cuLSbkl04bu6BQoUK6fDKsWPHLO8vy4sIgiAIrkBiWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIguAIRWIIgCIIrEIElCIIgKDfwf+xgChIKRc4iAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "graph_triangular = wmg.create.create_all_graph_components(\n", " coords=xy,\n", @@ -319,21 +190,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "fdd4e7aa", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", "\n", @@ -380,8 +240,7 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.6" + "pygments_lexer": "ipython3" } }, "nbformat": 4, diff --git a/docs/prebuilt_mesh.ipynb b/docs/prebuilt_mesh.ipynb index d423925..1613aea 100644 --- a/docs/prebuilt_mesh.ipynb +++ b/docs/prebuilt_mesh.ipynb @@ -303,8 +303,7 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.6" + "pygments_lexer": "ipython3" } }, "nbformat": 4,