incompy2d 0.1.0__py3-none-any.whl

incompy2d/__init__.py

@@ -0,0 +1,35 @@
+"""Incompy2D: A 2D incompressible Navier-Stokes CFD solver."""
+
+__version__ = "0.1.0"
+
+from .mesh_util import (
+	StructuredMesh2D,
+	uniform_msh,
+	load_npz,
+)
+from .geom_util import (
+	solid_poly,
+	geom_geojson,
+)
+from .incomp_2d import (
+	SolverConfig,
+	default_pressure_bc,
+	default_velocity_bc,
+	wind_pressure_bc,
+	wind_velocity_bc,
+	solve_incomp,
+)
+
+__all__ = [
+	"SolverConfig",
+	"StructuredMesh2D",
+	"uniform_msh",
+	"load_npz",
+	"solid_poly",
+	"geom_geojson",
+	"default_velocity_bc",
+	"default_pressure_bc",
+	"wind_velocity_bc",
+	"wind_pressure_bc",
+	"solve_incomp",
+]

incompy2d/fetch_overture.py

@@ -0,0 +1,91 @@
+import subprocess
+import geopandas as gpd
+from pathlib import Path
+import argparse
+
+def fetch_overture(bbox, output_dir=None, output_filename="overture_bld.geojson"):
+    """
+    Fetch building footprints for specified bounding box
+    using the overturemaps CLI (for streaming, low-RAM downloads)
+    and saves to geojson
+    
+    Usage:
+        python fetch_overture.py 
+            --bbox <xmin> <ymin> <xmax> <ymax> 
+            --output <file-name>.geojson
+    """
+    
+    print(f"Fetching buildings for bbox: {bbox}")
+    
+    ###Define output path
+    if output_dir is None:
+        output_dir = Path.cwd() / "geom"
+    else:
+        output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_file = output_dir / output_filename
+    
+    ###Construct bbox string (xmin,ymin,xmax,ymax)
+    bbox_str = f"{bbox[0]},{bbox[1]},{bbox[2]},{bbox[3]}"
+    
+    cmd = [
+        "overturemaps", "download",
+        "--bbox", bbox_str,
+        "-f", "geojson",
+        "--type", "building",
+        "-o", str(output_file)
+    ]
+    
+    print(f"Running CLI command: {' '.join(cmd)}")
+    
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Error downloading Overture data: {e}")
+        return None
+        
+    print(f"Successfully saved building footprints to {output_file}")
+    
+    print("Loading saved GeoJSON into GeoDataFrame...")
+    
+    ###rewrite as UTF-8 for GeoPandas/pyogrio to parse
+    try:
+        with open(output_file, 'r', encoding='mbcs') as f:
+            file_data = f.read()
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(file_data)
+    except Exception as e:
+        print(f"Warning: Could not re-encode GeoJSON: {e}")
+        
+    bld_gdf = gpd.read_file(output_file)
+    print(f"Loaded {len(bld_gdf)} buildings.")
+    
+    return bld_gdf
+
+if __name__ == "__main__":
+    print("\n=========Fetch building footprints from Overture Maps=========")
+    user_input = input("Use this link to find your bounding box (Copy CSV format): https://boundingbox.klokantech.com \n\
+Paste CSV bounding box: ").strip()
+    
+    default_bbox = (6.076267, 50.776895, 6.080700, 50.778798)
+    
+    if user_input:
+        try:
+            cleaned = user_input.replace(',', ' ').replace('[', ' ').replace(']', ' ')
+            coords = [float(x) for x in cleaned.split()]
+            if len(coords) == 4:
+                bbox = tuple(coords)
+            elif len(coords) >= 8 and len(coords) % 2 == 0:
+                x_coords = coords[0::2]
+                y_coords = coords[1::2]
+                bbox = (min(x_coords), min(y_coords), max(x_coords), max(y_coords))
+            else:
+                raise ValueError("Could not parse coordinates. Expected 4 values or a polygon list.")
+        except Exception as e:
+            print(f"Invalid input ({e}). Using default bbox.")
+            bbox = default_bbox
+    else:
+        print("No input provided. Using default bbox.")
+        bbox = default_bbox
+        
+    fetch_overture(bbox=bbox)

incompy2d/geom_util.py

@@ -0,0 +1,141 @@
+import numpy as np
+
+def solid_poly(mesh, vertices):
+    """Mark cells inside polygon as solid using ray-casting.
+
+    Args:
+        mesh: Mesh object
+        vertices: List of (x, y) tuples representing the polygon vertices
+    
+    Returns:
+        None
+    """
+    
+    ###Convert vertices to numpy arrays
+    xv = np.asarray([pt[0] for pt in vertices], dtype=float)
+    yv = np.asarray([pt[1] for pt in vertices], dtype=float)
+
+    ###Get mesh coordinates
+    xq = mesh.X
+    yq = mesh.Y
+    
+    ###Initialize inside mask for the polygon ray-casting
+    inside = np.zeros_like(xq, dtype=bool)
+
+    ###Ray-casting algorithm to find points inside the polygon
+    j = len(xv) - 1
+    for i in range(len(xv)):
+        xi, yi = xv[i], yv[i]
+        xj, yj = xv[j], yv[j]
+        cond = ((yi > yq) != (yj > yq)) & (
+            xq < (xj - xi) * (yq - yi) / (yj - yi + 1.0e-14) + xi
+        )
+        inside = np.logical_xor(inside, cond)
+        j = i
+
+    mesh.fluid_mask[inside] = False
+
+def geom_png(mesh, output_path):
+    """
+    Export geom (fluid/solid mask) to PNG
+    
+    Args:
+        mesh (StructuredMesh2D): Mesh object containing fluid mask.
+        output_path (str): .png file path to save
+    """
+    import matplotlib.pyplot as plt
+    import os
+
+    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+    
+    plt.figure(figsize=(10, 8))
+    
+    fig_width = 10
+    fig_height = fig_width * (mesh.y[-1] / mesh.x[-1])
+    plt.figure(figsize=(fig_width, fig_height))
+    
+    ###fluid mask: 1 fluid, 0 solid
+    plt.pcolormesh(mesh.X, mesh.Y, mesh.fluid_mask.astype(float), cmap='gray', shading='nearest')
+    
+    plt.title("Computational Domain")
+    plt.xlabel("X")
+    plt.ylabel("Y")
+    plt.axis('equal')
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=300)
+    plt.close()
+
+
+def geom_geojson(geojson_path, dx=1, padding=30):
+    """
+    Read GeoJSON 
+    -> projects to metric CRS 
+    -> adds padding 
+    -> creates Cartesian mesh
+    -> rasterizes polygons into solid/fluid mask
+    
+    Args:
+        geojson_path: Path to the GeoJSON file
+        dx: Grid spacing
+        padding: Padding around bbox
+        
+    Returns:
+        mesh (StructuredMesh2D)
+        gdf (GeoDataFrame): Shifted GeoDataFrame (origin = 0,0)
+    """
+    
+    import geopandas as gpd
+    import shapely.affinity
+    from .mesh_util import uniform_msh
+    from pathlib import Path
+    
+    geojson_path = Path(geojson_path)
+    if not geojson_path.exists():
+        raise FileNotFoundError(f"Could not find GeoJSON file at {geojson_path}")
+        
+    gdf = gpd.read_file(geojson_path)
+    
+    ###Project to metric coord system (UTM zone 32N for Aachen)
+    print("Projecting footprints to EPSG:32632 metric coordinates")
+    gdf = gdf.to_crs(epsg=32632)
+    
+    ###Define domain bounds and shift to origin
+    minx, miny, maxx, maxy = gdf.total_bounds
+    
+    minx -= padding
+    miny -= padding
+    maxx += padding
+    maxy += padding
+    
+    lx = maxx - minx
+    ly = maxy - miny
+    print(f"Domain size with padding: lx = {lx:.1f} m, ly = {ly:.1f} m")
+    
+    ###Shift geometries for bottom-left of padded domain to be at (0, 0)
+    gdf['geometry'] = gdf['geometry'].apply(
+        lambda geom: shapely.affinity.translate(geom, xoff=-minx, yoff=-miny)
+    )
+    
+    ###Create mesh
+    nx = int(lx / dx)
+    ny = int(ly / dx)
+    print(f"Creating uniform mesh of size {nx} x {ny} (dx = {lx/(nx-1):.2f}m)...")
+    mesh = uniform_msh(nx=nx, ny=ny, lx=lx, ly=ly)
+    
+    ###Rasterize buildings onto the mesh
+    print("Rasterizing building footprints onto mesh...")
+    for geom in gdf.geometry:
+        if geom is None:
+            continue
+        if geom.geom_type == 'Polygon':
+            coords = list(geom.exterior.coords)
+            solid_poly(mesh, coords)
+        elif geom.geom_type == 'MultiPolygon':
+            for poly in geom.geoms:
+                coords = list(poly.exterior.coords)
+                solid_poly(mesh, coords)
+                
+    num_solid = np.sum(~mesh.fluid_mask)
+    print(f"Rasterization complete. {num_solid} cells marked as solid obstacles.")
+    
+    return mesh, gdf

incompy2d/incomp_2d.py

@@ -0,0 +1,360 @@
+"""Generic 2D incompressible Navier-Stokes solver (projection method)."""
+
+from typing import Callable
+
+import numpy as np
+import numba
+
+from .mesh_util import StructuredMesh2D
+
+
+class SolverConfig:
+    """
+    Time-stepping and physical parameters for the NS solver
+    
+    Attributes:
+        rho: Fluid density
+        nu: Fluid kinematic viscosity
+        dt: Time step size
+        nt: Number of time steps
+        nit: Number of pressure Poisson iterations
+        fx: Body force in the x-direction
+        fy: Body force in the y-direction
+        monitor: Number of steps between pressure updates
+    
+    """
+
+    def __init__(
+        self,
+        rho: float = 1.0,
+        nu: float = 0.1,
+        dt: float = 0.001,
+        nt: int = 600,
+        nit: int = 60,
+        fx: float = 0.0,
+        fy: float = 0.0,
+        monitor: int = 50,
+    ):
+        """Initialize solver constants and runtime options."""
+        self.rho = rho
+        self.nu = nu
+        self.dt = dt
+        self.nt = nt
+        self.nit = nit
+        self.fx = fx
+        self.fy = fy
+        self.monitor = monitor
+
+
+def init_field(mesh: StructuredMesh2D):
+    """Allocate zero-initialized velocity and pressure fields."""
+    u = np.zeros((mesh.ny, mesh.nx))
+    v = np.zeros((mesh.ny, mesh.nx))
+    p = np.zeros((mesh.ny, mesh.nx))
+    return u, v, p
+
+
+@numba.njit(parallel=True, fastmath=True)
+def divergence(u: np.ndarray, v: np.ndarray, dx: float, dy: float):
+    """
+    Compute cell-centered velocity divergence with central differences.
+    """
+    ny, nx = u.shape
+    div = np.zeros_like(u)
+    for i in numba.prange(1, ny - 1):  # type: ignore
+        for j in range(1, nx - 1):
+            div[i, j] = (u[i, j+1] - u[i, j-1]) / (2.0 * dx) + (v[i+1, j] - v[i-1, j]) / (2.0 * dy)
+    return div
+
+@numba.njit(parallel=True, fastmath=True)
+def _compute_intermediate_velocity(u, v, p, fluid_mask, active_inner, dx, dy, dt, rho, nu, fx, fy):
+    ny, nx = u.shape
+    u_star = u.copy()
+    v_star = v.copy()
+    
+    for i in numba.prange(1, ny - 1):  # type: ignore
+        for j in range(1, nx - 1):
+            if active_inner[i, j]:
+                u_c = u[i, j]
+                v_c = v[i, j]
+                
+                u_pos = max(u_c, 0.0)
+                u_neg = min(u_c, 0.0)
+                v_pos = max(v_c, 0.0)
+                v_neg = min(v_c, 0.0)
+                
+                u_adv_x = u_pos * (u_c - u[i, j-1]) / dx + u_neg * (u[i, j+1] - u_c) / dx
+                u_adv_y = v_pos * (u_c - u[i-1, j]) / dy + v_neg * (u[i+1, j] - u_c) / dy
+                
+                v_adv_x = u_pos * (v_c - v[i, j-1]) / dx + u_neg * (v[i, j+1] - v_c) / dx
+                v_adv_y = v_pos * (v_c - v[i-1, j]) / dy + v_neg * (v[i+1, j] - v_c) / dy
+                
+                u_diff = nu * ((u[i, j+1] - 2.0*u_c + u[i, j-1])/dx**2 + (u[i+1, j] - 2.0*u_c + u[i-1, j])/dy**2)
+                v_diff = nu * ((v[i, j+1] - 2.0*v_c + v[i, j-1])/dx**2 + (v[i+1, j] - 2.0*v_c + v[i-1, j])/dy**2)
+                
+                p_grad_x = (p[i, j+1] - p[i, j-1]) / (2.0 * dx * rho)
+                p_grad_y = (p[i+1, j] - p[i-1, j]) / (2.0 * dy * rho)
+                
+                u_star[i, j] = u_c + dt * (-u_adv_x - u_adv_y - p_grad_x + u_diff + fx)
+                v_star[i, j] = v_c + dt * (-v_adv_x - v_adv_y - p_grad_y + v_diff + fy)
+                
+    for i in range(ny):
+        for j in range(nx):
+            if not fluid_mask[i, j]:
+                u_star[i, j] = 0.0
+                v_star[i, j] = 0.0
+                
+    return u_star, v_star
+
+@numba.njit(parallel=True, fastmath=True)
+def pressure_poisson(
+    phi: np.ndarray,
+    b: np.ndarray,
+    fluid_mask: np.ndarray,
+    dx: float,
+    dy: float,
+    nit: int,
+    bc_type: int
+):
+    """
+    Solve pressure-correction Poisson equation by Jacobi iterations
+    bc_type=1 implies wind_pressure_bc
+    bc_type=0 implies default_pressure_bc
+    """
+    ny, nx = phi.shape
+    dx2 = dx**2
+    dy2 = dy**2
+    denom = 2.0 * (dx2 + dy2)
+    coeff_b = (dx2 * dy2) / denom
+    
+    for _ in range(nit):
+        phin = phi.copy()
+        
+        for i in numba.prange(1, ny - 1):  # type: ignore
+            for j in range(1, nx - 1):
+                phi[i, j] = ((phin[i, j+1] + phin[i, j-1]) * dy2 + (phin[i+1, j] + phin[i-1, j]) * dx2) / denom - coeff_b * b[i, j]
+                if not fluid_mask[i, j]:
+                    phi[i, j] = 0.0
+                    
+        if bc_type == 1:
+            for i in range(ny):
+                phi[i, 0] = phi[i, 1]
+                phi[i, nx-1] = 0.0
+            for j in range(nx):
+                phi[0, j] = phi[1, j]
+                phi[ny-1, j] = phi[ny-2, j]
+        else:
+            for i in range(ny):
+                phi[i, nx-1] = phi[i, nx-2]
+                phi[i, 0] = phi[i, 1]
+            for j in range(nx):
+                phi[0, j] = phi[1, j]
+                phi[ny-1, j] = phi[ny-2, j]
+            phi[ny-1, nx-1] = 0.0
+            
+    return phi
+
+@numba.njit(parallel=True, fastmath=True)
+def _apply_corrections(u_star, v_star, phi, fluid_mask, active_inner, dx, dy, dt, rho):
+    ny, nx = u_star.shape
+    u_corr = u_star.copy()
+    v_corr = v_star.copy()
+    
+    for i in numba.prange(1, ny - 1):  # type: ignore
+        for j in range(1, nx - 1):
+            if active_inner[i, j]:
+                u_corr[i, j] = u_star[i, j] - dt / (2.0 * rho * dx) * (phi[i, j+1] - phi[i, j-1])
+                v_corr[i, j] = v_star[i, j] - dt / (2.0 * rho * dy) * (phi[i+1, j] - phi[i-1, j])
+                
+    for i in range(ny):
+        for j in range(nx):
+            if not fluid_mask[i, j]:
+                u_corr[i, j] = 0.0
+                v_corr[i, j] = 0.0
+                
+    return u_corr, v_corr
+
+
+def default_velocity_bc(u: np.ndarray, v: np.ndarray, mesh: StructuredMesh2D, step_idx: int):
+    """
+    Apply no-slip velocity boundary conditions on all outer walls.
+    
+    Args:
+        u: Velocity field in the x-direction
+        v: Velocity field in the y-direction
+        mesh: Mesh object
+        step_idx: Step index
+    """
+    _ = mesh
+    _ = step_idx
+    u[0, :] = 0.0
+    u[-1, :] = 0.0
+    u[:, 0] = 0.0
+    u[:, -1] = 0.0
+
+    v[0, :] = 0.0
+    v[-1, :] = 0.0
+    v[:, 0] = 0.0
+    v[:, -1] = 0.0
+
+
+def default_pressure_bc(p: np.ndarray, mesh: StructuredMesh2D, step_idx: int):
+    """
+    Apply simple zero-normal-gradient pressure boundaries.
+    
+    Args:
+        p: Pressure field
+        mesh: Mesh object
+        step_idx: Step index
+    """
+    _ = mesh
+    _ = step_idx
+    p[:, -1] = p[:, -2]
+    p[:, 0] = p[:, 1]
+    p[0, :] = p[1, :]
+    p[-1, :] = p[-2, :]
+    p[-1, -1] = 0.0
+
+
+def wind_velocity_bc(u: np.ndarray, v: np.ndarray, mesh: StructuredMesh2D, step_idx: int):
+    """
+    Boundary conditions for a wind flow from West to East.
+    - Left boundary: Uniform inflow velocity (e.g., 5 m/s)
+    - Right boundary: Outflow (zero gradient)
+    - Top/Bottom boundaries: Free-slip
+    """
+    u[:, 0] = 5.0
+    v[:, 0] = 0.0
+    
+    ###Right boundary: outflow (zero normal gradient)
+    u[:, -1] = u[:, -2]
+    v[:, -1] = v[:, -2]
+    
+    ###Top and bottom boundaries: free slip
+    u[0, :] = u[1, :]
+    u[-1, :] = u[-2, :]
+    v[0, :] = 0.0
+    v[-1, :] = 0.0
+
+
+def wind_pressure_bc(p: np.ndarray, mesh: StructuredMesh2D, step_idx: int):
+    """
+    Fixed pressure at the outlet to allow mass flux to balance.
+    Zero gradient on other boundaries.
+    """
+    p[:, 0] = p[:, 1]
+    p[0, :] = p[1, :]
+    p[-1, :] = p[-2, :]
+    p[:, -1] = 0.0  ###Dirichlet outlet
+
+
+from typing import Optional
+
+def solve_incomp(
+    mesh: StructuredMesh2D,
+    cfg: SolverConfig,
+    velocity_bc: Optional[Callable[[np.ndarray, np.ndarray, StructuredMesh2D, int], None]] = None,
+    pressure_bc: Optional[Callable[[np.ndarray, StructuredMesh2D, int], None]] = None,
+    u0: Optional[np.ndarray] = None,
+    v0: Optional[np.ndarray] = None,
+    p0: Optional[np.ndarray] = None,
+):
+    """
+    Advance 2D incompressible flow using a projection method.
+    
+    Args:
+        mesh: Mesh object
+        cfg: Solver configuration
+        velocity_bc: Velocity boundary conditions
+        pressure_bc: Pressure boundary conditions
+        u0: Initial velocity in the x-direction
+        v0: Initial velocity in the y-direction
+        p0: Initial pressure
+    
+    Returns:
+        u, v, p, history: Solution fields and history
+    """
+
+    velocity_bc = velocity_bc or default_velocity_bc
+    pressure_bc = pressure_bc or default_pressure_bc
+
+    if u0 is None or v0 is None or p0 is None:
+        u, v, p = init_field(mesh)
+    else:
+        u = np.asarray(u0, dtype=float).copy()
+        v = np.asarray(v0, dtype=float).copy()
+        p = np.asarray(p0, dtype=float).copy()
+    
+    ###Fluid mask and interior mask
+    fluid = mesh.fluid_mask
+    interior = np.zeros_like(fluid, dtype=bool)
+    interior[1:-1, 1:-1] = True
+    active = interior & fluid
+
+    history = []
+    
+    import time
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.info("Iteration\tAvgResidual\tRemainingTime(s)")
+    start_time = time.time()
+
+    bc_type = 1 if pressure_bc is wind_pressure_bc else 0
+
+    ###Time-stepping loop
+    for n in range(cfg.nt):
+        un = u.copy()
+        vn = v.copy()
+
+        u_star, v_star = _compute_intermediate_velocity(
+            un, vn, p, fluid, active, mesh.dx, mesh.dy, cfg.dt, cfg.rho, cfg.nu, cfg.fx, cfg.fy
+        )
+
+        ###Apply boundary conditions for u and v
+        velocity_bc(u_star, v_star, mesh, n)
+
+        ###Compute the source term for the pressure Poisson equation
+        b = cfg.rho / cfg.dt * divergence(u_star, v_star, mesh.dx, mesh.dy)
+        b[~fluid] = 0.0
+
+        ###Solve for the pressure correction (phi)
+        phi = np.zeros_like(p)
+        phi = pressure_poisson(phi, b, fluid, mesh.dx, mesh.dy, cfg.nit, bc_type)
+
+        ###Update velocity and pressure fields
+        u, v = _apply_corrections(u_star, v_star, phi, fluid, active, mesh.dx, mesh.dy, cfg.dt, cfg.rho)
+        p = p + phi
+
+        ###Apply boundary conditions for u, v, and p
+        velocity_bc(u, v, mesh, n)
+        pressure_bc(p, mesh, n)
+
+        ###Record divergence for monitoring
+        if (n + 1) % cfg.monitor == 0 or n == 0:
+            div = divergence(u, v, mesh.dx, mesh.dy)
+            div[~fluid] = 0.0
+            residual = float(np.sum(np.abs(div)) / max(1, np.sum(fluid)))
+            history.append((n + 1, residual))
+            
+            elapsed = time.time() - start_time
+            time_per_iter = elapsed / (n + 1)
+            remaining_time = time_per_iter * (cfg.nt - (n + 1))
+            
+            msg = f"Iter: {n+1}/{cfg.nt} | Avg Residual: {residual:.6e} | Remaining Time: {remaining_time:.1f}s"
+            logger.info(msg)
+            # We skip writing to log_file.
+
+
+    return {
+        "x": mesh.x,
+        "y": mesh.y,
+        "X": mesh.X,
+        "Y": mesh.Y,
+        "fluid_mask": mesh.fluid_mask,
+        "u": u,
+        "v": v,
+        "p": p,
+        "history": history,
+        "dx": mesh.dx,
+        "dy": mesh.dy,
+    }

incompy2d/mesh_util.py

@@ -0,0 +1,128 @@
+"""Mesh generation and basic loading utilities for 2D structured grids."""
+
+import numpy as np
+
+class StructuredMesh2D:
+    """Container for a 2D structured mesh and fluid/solid mask."""
+
+    def __init__(self, x, y, X, Y, dx, dy, fluid_mask):
+        """Store mesh coordinates, spacing, and fluid mask arrays.
+        
+        Args:
+            x (np.ndarray): 1D array of x-coordinates
+            y (np.ndarray): 1D array of y-coordinates
+            X (np.ndarray): 2D grid of x-coordinates
+            Y (np.ndarray): 2D grid of y-coordinates
+            dx (float): Grid spacing in the x-direction
+            dy (float): Grid spacing in the y-direction
+            fluid_mask (np.ndarray): Boolean mask indicating fluid cells
+            
+        """
+        self.x = x
+        self.y = y
+        self.X = X
+        self.Y = Y
+        self.dx = dx
+        self.dy = dy
+        self.fluid_mask = fluid_mask
+        self.nx = X.shape[1]
+        self.ny = X.shape[0]
+
+
+def uniform_msh(nx, ny, lx, ly):
+    """Create uniform rectangular mesh. All cells marked as fluid
+
+    Args:
+        nx (int): # grid points in x-direction
+        ny (int): # grid points in y-direction
+        lx (float): Domain length in x-direction
+        ly (float): Domain length in y-direction
+    Returns:
+        StructuredMesh2D: Mesh object (coords, spacing, fluid mask)
+        
+    """
+    dx = lx / (nx - 1)
+    dy = ly / (ny - 1)
+    
+    ###Create linearly spaced xy-coord
+    x = np.linspace(0, lx, nx)
+    y = np.linspace(0, ly, ny)
+    xg, yg = np.meshgrid(x, y)
+    
+    ###Mark all cells as fluid
+    fluid_mask = np.ones((ny, nx), dtype=bool)
+    return StructuredMesh2D(x=x, y=y, X=xg, Y=yg, dx=dx, dy=dy, fluid_mask=fluid_mask)
+
+
+def load_npz(npz_path):
+    """Load x, y and optional fluid_mask from .npz file
+
+    Args:
+        npz_path (str): Path to the .npz file containing the mesh
+    Returns:
+        StructuredMesh2D: Mesh object containing coordinates, spacing, and fluid mask
+    Raises:
+        ValueError: If x or y are not 1D arrays or if the mesh is not uniformly spaced
+
+    """
+    data = np.load(npz_path)
+    x = np.asarray(data["x"], dtype=float)
+    y = np.asarray(data["y"], dtype=float)
+
+    if x.ndim != 1 or y.ndim != 1:
+        raise ValueError("x and y must be 1D arrays")
+
+    dxs = np.diff(x)
+    dys = np.diff(y)
+    if not np.allclose(dxs, dxs[0]) or not np.allclose(dys, dys[0]):
+        raise ValueError("Current solver requires uniformly spaced x and y")
+
+    xg, yg = np.meshgrid(x, y)
+    ny, nx = yg.shape
+
+    if "fluid_mask" in data:
+        fluid_mask = np.asarray(data["fluid_mask"], dtype=bool)
+        if fluid_mask.shape != (ny, nx):
+            raise ValueError("fluid_mask shape must match (ny, nx)")
+    else:
+        fluid_mask = np.ones((ny, nx), dtype=bool)
+
+    return StructuredMesh2D(
+        x=x,
+        y=y,
+        X=xg,
+        Y=yg,
+        dx=float(dxs[0]),
+        dy=float(dys[0]),
+        fluid_mask=fluid_mask,
+    )
+
+def msh_png(mesh, output_path):
+    """
+    Export a visualization of the mesh grid to a PNG file.
+    
+    Args:
+        mesh (StructuredMesh2D): The mesh object to visualize.
+        output_path (str): The file path where the PNG will be saved.
+    """
+    import matplotlib.pyplot as plt
+    import os
+    
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+    
+    plt.figure(figsize=(10, 8))
+    # Plot horizontal grid lines
+    for i in range(mesh.ny):
+        plt.plot(mesh.X[i, :], mesh.Y[i, :], color='gray', lw=0.5, alpha=0.5)
+    # Plot vertical grid lines
+    for j in range(mesh.nx):
+        plt.plot(mesh.X[:, j], mesh.Y[:, j], color='gray', lw=0.5, alpha=0.5)
+        
+    plt.title(f"Structured Mesh ({mesh.nx} x {mesh.ny})")
+    plt.xlabel("X")
+    plt.ylabel("Y")
+    plt.axis('equal')
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=300)
+    plt.close()

incompy2d/post.py

@@ -0,0 +1,200 @@
+import numpy as np
+import geopandas as gpd
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+def draw_buildings(gdf):
+    if gdf is None:
+        return
+    for geom in gdf.geometry:
+        if geom is None:
+            continue
+        if geom.geom_type == 'Polygon':
+            x, y = geom.exterior.xy
+            plt.plot(x, y, color='black', linewidth=1)
+        elif geom.geom_type == 'MultiPolygon':
+            for poly in geom.geoms:
+                x, y = poly.exterior.xy
+                plt.plot(x, y, color='black', linewidth=1)
+
+def main(output_dir=None):
+    if output_dir is None:
+        output_dir = Path.cwd() / "outputs"
+    else:
+        output_dir = Path(output_dir)
+    sim_data_file = output_dir / "sim_data.npz"
+    shifted_geojson = output_dir / "shifted_buildings.geojson"
+    
+    if not sim_data_file.exists():
+        raise FileNotFoundError(f"Simulation data not found at {sim_data_file}")
+        
+    print(f"Loading simulation data from {sim_data_file}...")
+    # Allow pickle might be needed if objects are stored, but our dict is pure numpy arrays
+    res = np.load(sim_data_file)
+    
+    print(f"Loading building geometries from {shifted_geojson}...")
+    if not shifted_geojson.exists():
+        print(f"Warning: Shifted geojson not found at {shifted_geojson}, buildings won't be drawn.")
+        gdf = None
+    else:
+        gdf = gpd.read_file(shifted_geojson)
+    
+    print("Plotting results...")
+    plt.figure(figsize=(12, 10))
+    
+    # Compute velocity magnitude
+    vel_mag = np.sqrt(res['u']**2 + res['v']**2)
+    
+    # Mask out the solid regions in the plot
+    fluid_mask = res['fluid_mask']
+    vel_mag[~fluid_mask] = np.nan
+    
+    # Create contour plot
+    contour = plt.contourf(res['X'], res['Y'], vel_mag, levels=100, cmap='turbo', antialiased=True)
+    plt.colorbar(contour, label='Velocity Magnitude (m/s)')
+    
+    # Draw building boundaries
+    draw_buildings(gdf)
+                
+    plt.title("Wind Flow Around RWTH Aachen Buildings")
+    plt.xlabel("X [m]")
+    plt.ylabel("Y [m]")
+    plt.axis('equal')
+    
+    output_png = output_dir / "rwth_flow_result.png"
+    plt.savefig(output_png, dpi=300, bbox_inches='tight')
+    print(f"Saved result image to {output_png}")
+    
+    print("Plotting vector field...")
+    plt.figure(figsize=(12, 10))
+    
+    # Subsample for quiver plot to avoid overcrowding
+    step = 5
+    X_sub = res['X'][::step, ::step]
+    Y_sub = res['Y'][::step, ::step]
+    u_sub = res['u'][::step, ::step]
+    v_sub = res['v'][::step, ::step]
+    mask_sub = fluid_mask[::step, ::step]
+    
+    # Mask solid regions
+    u_sub = np.where(mask_sub, u_sub, np.nan)
+    v_sub = np.where(mask_sub, v_sub, np.nan)
+    
+    # Draw buildings
+    draw_buildings(gdf)
+    
+    # Draw vector field
+    # Calculate velocity magnitude for color mapping the arrows
+    mag_sub = np.sqrt(u_sub**2 + v_sub**2)
+    
+    # Normalize vectors so all arrows have a length of 1 (showing only direction)
+    u_norm = u_sub / (mag_sub + 1e-10)
+    v_norm = v_sub / (mag_sub + 1e-10)
+    
+    plt.quiver(X_sub, Y_sub, u_norm, v_norm, mag_sub, cmap='turbo', scale=75, width=0.002)
+    
+    plt.title("Wind Vector Field Around RWTH Aachen Buildings")
+    plt.xlabel("X [m]")
+    plt.ylabel("Y [m]")
+    plt.axis('equal')
+    
+    output_vector_png = output_dir / "rwth_vector_field.png"
+    plt.savefig(output_vector_png, dpi=300, bbox_inches='tight')
+    print(f"Saved vector field image to {output_vector_png}")
+    
+    print("Plotting streamlines...")
+    plt.figure(figsize=(12, 10))
+    
+    # We use the full resolution grids for streamplot for smooth lines
+    u_full = res['u'].copy()
+    v_full = res['v'].copy()
+    
+    # Mask solid regions
+    u_full[~fluid_mask] = np.nan
+    v_full[~fluid_mask] = np.nan
+    
+    # Calculate magnitude for color mapping
+    mag_full = np.sqrt(u_full**2 + v_full**2)
+    
+    # Draw buildings
+    draw_buildings(gdf)
+    
+    # Draw streamlines
+    # streamplot expects 1D arrays for x and y coordinates
+    strm = plt.streamplot(res['X'][0, :], res['Y'][:, 0], u_full, v_full, 
+                          color=mag_full, cmap='turbo', density=5.0, linewidth=1)
+    plt.colorbar(strm.lines, label='Velocity Magnitude (m/s)')
+    
+    plt.title("Wind Streamlines Around RWTH Aachen Buildings")
+    plt.xlabel("X [m]")
+    plt.ylabel("Y [m]")
+    plt.axis('equal')
+    
+    output_stream_png = output_dir / "rwth_streamlines.png"
+    plt.savefig(output_stream_png, dpi=300, bbox_inches='tight')
+    print(f"Saved streamlines image to {output_stream_png}")
+
+    print("Plotting convergence history...")
+    log_file = Path(__file__).parent / "solver.log"
+    if log_file.exists():
+        try:
+            data = np.loadtxt(log_file, skiprows=1)
+            if data.size > 0:
+                # If there's only one row, reshape it to 2D
+                if data.ndim == 1:
+                    data = data.reshape(1, -1)
+                iterations = data[:, 0]
+                residuals = data[:, 1]
+                
+                plt.figure(figsize=(10, 6))
+                plt.plot(iterations, residuals, 'b-', linewidth=2)
+                plt.yscale('log')
+                plt.title("Solver Convergence History")
+                plt.xlabel("Iteration")
+                plt.ylabel("Average Divergence (Residual)")
+                plt.grid(True, which="both", ls="--")
+                
+                output_conv_png = output_dir / "rwth_convergence.png"
+                plt.savefig(output_conv_png, dpi=300, bbox_inches='tight')
+                print(f"Saved convergence history to {output_conv_png}")
+            else:
+                print("solver.log is empty.")
+        except Exception as e:
+            print(f"Could not plot solver.log: {e}")
+    else:
+        print(f"solver.log not found at {log_file}")
+
+    print("Plotting geometry mask...")
+    plt.figure(figsize=(12, 10))
+    solid_int = np.where(fluid_mask, 0, 1)
+    plt.pcolormesh(res['X'], res['Y'], solid_int, cmap='binary', shading='nearest')
+    draw_buildings(gdf)
+    plt.title("Building Geometry Mask")
+    plt.xlabel("X [m]")
+    plt.ylabel("Y [m]")
+    plt.axis('equal')
+    
+    output_geom_png = output_dir / "geometry_mask.png"
+    plt.savefig(output_geom_png, dpi=300, bbox_inches='tight')
+    print(f"Saved geometry mask image to {output_geom_png}")
+
+    print("Plotting mesh grid (with subtracted buildings)...")
+    plt.figure(figsize=(12, 10))
+    # Draw grid lines by plotting an empty grid with edgecolors, using subset if too dense? No, we plot all.
+    # We can plot grid lines everywhere as lightgray, and overlay black solid mask
+    plt.pcolormesh(res['X'], res['Y'], np.zeros_like(fluid_mask), cmap='binary', edgecolors='lightgray', linewidth=0.1, shading='nearest', vmin=0, vmax=1)
+    solid_nan = np.where(fluid_mask, np.nan, 1)
+    plt.pcolormesh(res['X'], res['Y'], solid_nan, cmap='binary', shading='nearest', vmin=0, vmax=1)
+    draw_buildings(gdf)
+    
+    plt.title("Mesh Grid (Subtracted Buildings)")
+    plt.xlabel("X [m]")
+    plt.ylabel("Y [m]")
+    plt.axis('equal')
+    
+    output_mesh_png = output_dir / "mesh_grid.png"
+    plt.savefig(output_mesh_png, dpi=300, bbox_inches='tight')
+    print(f"Saved mesh grid image to {output_mesh_png}")
+
+if __name__ == "__main__":
+    main()

incompy2d/run.py

@@ -0,0 +1,115 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+# Local solver imports
+from .mesh_util import msh_png
+from .geom_util import geom_geojson, geom_png
+from .incomp_2d import solve_incomp, SolverConfig, wind_pressure_bc
+
+def get_input(prompt, default, cast_type):
+    user_input = input(f"{prompt} (Default: {default}): ").strip()
+    if not user_input:
+        return default
+    try:
+        return cast_type(user_input)
+    except ValueError:
+        print(f"Invalid input. Using default: {default}")
+        return default
+
+def main():
+    print("\n========= Incomp2D Solver Configuration =========")
+    default_geojson = "overture_bld.geojson"
+    geojson_in = get_input("GeoJSON path", default_geojson, str)
+    dx_in = get_input("Grid spacing dx [m]", 1.0, float)
+    padding_in = get_input("Domain padding [m]", 30.0, float)
+    
+    rho_in = get_input("Air density (rho) [kg/m^3]", 1.225, float)
+    nu_in = get_input("Kinematic viscosity (nu) [m^2/s]", 1.5e-5, float)
+    wind_u = get_input("Wind velocity X (u) [m/s])", 5.0, float)
+    wind_v = get_input("Wind velocity Y (v) [m/s])", 0.0, float)
+    
+    ###Estimate CFL and recommend [dt]
+    wind_speed = np.sqrt(wind_u**2 + wind_v**2)
+    max_local_vel = wind_speed * 2.5 ###Heuristic for flow acceleration around buildings
+    dx_est = dx_in ###Use user-specified grid spacing
+    dt_recommended = dx_est / max_local_vel if max_local_vel > 0 else 0.01
+    dt_recommended = round(dt_recommended * 0.9, 4) ###Add 10% safety margin
+    
+    print(f"\n   [INFO] Estimated max local velocity around buildings: ~{max_local_vel:.1f} m/s")
+    print(f"   [INFO] To maintain CFL < 1.0 (stability), recommended dt <= {dt_recommended} s\n")
+    
+    dt_in = get_input("Timestep size (dt) [s]", dt_recommended, float)
+    
+    ###Check CFL violation
+    actual_cfl = max_local_vel * dt_in / dx_est
+    if actual_cfl > 1.0:
+        print(f"\n   [WARNING] CRITICAL: Your dt={dt_in} s gives an estimated CFL of {actual_cfl:.2f} > 1.0!")
+        print("   [WARNING] The simulation is highly likely to blow up (Residual = NaN).")
+        print("   [WARNING] Consider pressing Ctrl+C and lowering your timestep.\n")
+        
+    nt_in = get_input("Number of timesteps (nt)", 20000, int)
+    nit_in = get_input("Pressure Poisson iterations (nit)", 50, int)
+    monitor_in = get_input("Print to console every (iter)", 100, int)
+    print("============================================\n")
+    
+    def custom_velocity_bc(u: np.ndarray, v: np.ndarray, mesh, step_idx: int):
+        u[:, 0] = wind_u
+        v[:, 0] = wind_v
+        u[:, -1] = u[:, -2]
+        v[:, -1] = v[:, -2]
+        u[0, :] = u[1, :]
+        u[-1, :] = u[-2, :]
+        v[0, :] = 0.0
+        v[-1, :] = 0.0
+
+    ###1-5. Load GeoJSON, project, pad, and rasterize onto mesh
+    geojson_path = Path(geojson_in)
+    print(f"Generating mesh and geometry from {geojson_path}")
+    
+    mesh, gdf = geom_geojson(geojson_path, dx=dx_in, padding=padding_in)
+    
+    ###Export mesh and geometry visualizations
+    output_dir = Path.cwd() / "outputs"
+    output_dir.mkdir(exist_ok=True)
+    msh_png(mesh, str(output_dir / "mesh_grid.png"))
+    geom_png(mesh, str(output_dir / "geometry_mask.png"))
+    print(f"Exported mesh and geometry PNGs to {output_dir}")
+    
+    ###6. Configure and run the solver
+    print("Setting up the NS solver...")
+    cfg = SolverConfig(
+        rho=rho_in,             
+        nu=nu_in,               
+        dt=dt_in,               
+        nt=nt_in,
+        nit=nit_in,
+        monitor=monitor_in
+    )
+    
+    print("Running incompressible Navier-Stokes solver (this might take several minutes)...")
+    res = solve_incomp(
+        mesh=mesh,
+        cfg=cfg,
+        velocity_bc=custom_velocity_bc,
+        pressure_bc=wind_pressure_bc
+    )
+    
+    ###7. Postprocessing Export
+    print("Exporting simulation data for postprocessing...")
+    output_dir = Path.cwd() / "outputs"
+    output_dir.mkdir(exist_ok=True)
+    
+    ###Save the shifted geometries to a geojson
+    shifted_geojson = output_dir / "shifted_buildings.geojson"
+    gdf.to_file(shifted_geojson, driver='GeoJSON')
+    
+    ###Save the simulation results
+    sim_data_file = output_dir / "sim_data.npz"
+    np.savez_compressed(sim_data_file, **res)
+    print(f"Saved simulation data to {sim_data_file}")
+    print(f"Saved shifted building footprints to {shifted_geojson}")
+    print("Run post.py to generate visualizations.")
+
+if __name__ == "__main__":
+    main()

incompy2d-0.1.0.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: incompy2d
+Version: 0.1.0
+Summary: A 2D incompressible Navier-Stokes CFD solver in Python
+Project-URL: Repository, https://gitlab.git.nrw/phuong-nam.nguyen/sce_incompy2d
+Author-email: Phuong-Nam Nguyen <phuong-nam.nguyen@rwth-aachen.de>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: numba
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: cookiecutter; extra == 'dev'
+Requires-Dist: geopandas; extra == 'dev'
+Requires-Dist: ipympl; extra == 'dev'
+Requires-Dist: jupyterlab; extra == 'dev'
+Requires-Dist: matplotlib; extra == 'dev'
+Requires-Dist: meshio; extra == 'dev'
+Requires-Dist: osmnx; extra == 'dev'
+Requires-Dist: overturemaps; extra == 'dev'
+Requires-Dist: pandas; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: scikit-learn; extra == 'dev'
+Requires-Dist: scipy; extra == 'dev'
+Requires-Dist: shapely; extra == 'dev'
+Requires-Dist: sphinx; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == 'docs'
+Provides-Extra: geo
+Requires-Dist: geopandas; extra == 'geo'
+Requires-Dist: meshio; extra == 'geo'
+Requires-Dist: osmnx; extra == 'geo'
+Requires-Dist: overturemaps; extra == 'geo'
+Requires-Dist: shapely; extra == 'geo'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Provides-Extra: viz
+Requires-Dist: matplotlib; extra == 'viz'
+Description-Content-Type: text/markdown
+
+# incompy2d
+
+A 2D incompressible Navier-Stokes CFD solver in Python.
+
+## Installation
+
+```bash
+pip install incompy2d
+```
+
+## Usage
+
+Please refer to the examples in the documentation.

incompy2d-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+incompy2d/__init__.py,sha256=njQhdVACwpF07SEvfzXLwiv-qUfmOoCXk4UYzgqA2tQ,606
+incompy2d/fetch_overture.py,sha256=X6rMLEJowT_-JzQabDWzp3qO4IoJh5mi2gIcdJxW9hI,3071
+incompy2d/geom_util.py,sha256=mtug0W2Chq5exy8MM4Hl0k6L0ARAAXjiADFQbPRyQKQ,4151
+incompy2d/incomp_2d.py,sha256=vzfum1VI4HTK5dLR1bglxC-siOqyz_jM1CHd-NM0B1k,11444
+incompy2d/mesh_util.py,sha256=r_txpBA8L9OSCFNURAensg2QMSBAt5U8Sr8zSsgp3Jo,3918
+incompy2d/post.py,sha256=M-8NswRRNUITxlY0Iq_j9aUhBcE6VtwUKGYC2tug49o,7302
+incompy2d/run.py,sha256=ZGKp74DCDOLUWbIzgtiJP8TJrgeuTNMS49VVfeROzfU,4503
+incompy2d-0.1.0.dist-info/METADATA,sha256=FJk6QHSRn1TYJAEv-NhaCy-2dM6VlAD-3IXWQQyrZkM,1692
+incompy2d-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+incompy2d-0.1.0.dist-info/entry_points.txt,sha256=yreDzzgbZWxHSKNgo_ZGsJVdUZ5i4AOI6JImWCPAJcA,53
+incompy2d-0.1.0.dist-info/licenses/LICENSE,sha256=dr0kk7GMiSG5WKjro9K-Vd0S8d61NuKMoCExZzGNLnA,1074
+incompy2d-0.1.0.dist-info/RECORD,,

incompy2d-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

incompy2d-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+incompy2d-run = incompy2d.run:main

incompy2d-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Phuong-Nam Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.