{ "cells": [ { "cell_type": "markdown", "execution_count": null, "id": "2034d9a9", "metadata": { "papermill": { "duration": 0.00356, "end_time": "2026-08-04T16:49:24.773028+00:00", "exception": false, "start_time": "2026-08-04T16:49:24.769468+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "### Vivaldi antenna\n", "\n", "Full parametric Vivaldi antenna mesh using gmsh/OpenCASCADE.\n", "\n", "The exponential taper profile follows:\n", "$$y = \\pm\\frac{w_s}{2} \\cdot e^{C(x - x_0)}$$\n", "where $C$ is the opening rate (25 here) and $x_0$ is the taper start.\n", "\n", "**Coordinate convention** (matches the diagram, x is the long axis):\n", "- Ground plane centred at origin in XY plane\n", "- Aperture opens toward +x\n", "- Cavity is on the −x side\n", "- Z is vertical (substrate thickness)" ] }, { "cell_type": "code", "execution_count": 1, "id": "49322625", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:24.779903Z", "iopub.status.busy": "2026-08-04T16:49:24.779712Z", "iopub.status.idle": "2026-08-04T16:49:25.576171Z", "shell.execute_reply": "2026-08-04T16:49:25.575491Z" }, "papermill": { "duration": 0.801017, "end_time": "2026-08-04T16:49:25.577058+00:00", "exception": false, "start_time": "2026-08-04T16:49:24.776041+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "import gmsh\n", "import math\n", "import numpy as np\n", "from palacetoolkit.mesh import (\n", " Entity, \n", " run_entity_pipeline, \n", " generate_3d_mesh, \n", " create_graded_mesh\n", ")\n", "from palacetoolkit.viz import run_with_scrollable_output, view_mesh \n" ] }, { "cell_type": "markdown", "execution_count": null, "id": "ae61f8ba", "metadata": { "papermill": { "duration": 0.002963, "end_time": "2026-08-04T16:49:25.583256+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.580293+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Antenna parameters" ] }, { "cell_type": "code", "execution_count": 2, "id": "396c6947", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.590054Z", "iopub.status.busy": "2026-08-04T16:49:25.589780Z", "iopub.status.idle": "2026-08-04T16:49:25.595234Z", "shell.execute_reply": "2026-08-04T16:49:25.594497Z" }, "papermill": { "duration": 0.009894, "end_time": "2026-08-04T16:49:25.595974+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.586080+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ground plane: [-0.1500, 0.1500]\n", "Taper starts at: x = -0.0930\n", "Parallel section: x = [-0.1160, -0.0930] length = 23.0 mm (= cavity_to_taper)\n", "Cavity centre at: x = -0.1280\n", "Cavity right edge: x = -0.1160 (= x_taper_start - s)\n" ] } ], "source": [ "taper_length: float = 0.243 \n", "aperture_width: float = 0.105 \n", "opening_rate: float = 25.0 \n", "slot_width: float = 5e-4 \n", "cavity_diameter: float = 0.024 \n", "cavity_to_taper: float = 0.023 \n", "ground_plane_length: float = 0.300 \n", "ground_plane_width: float = 0.125 \n", "h_sub: float = 0.015 \n", "air_height: float = 0.05 \n", "air_margin: float = 0.05\n", "\n", "freq_ghz = 4.5\n", "c0 = 3e8\n", "wavelength = c0 / (freq_ghz * 1e9)\n", "\n", "mesh_file = \"vivaldi.msh\"\n", "\n", "# Derived coordinates\n", "Lx = ground_plane_length\n", "Ly = ground_plane_width\n", "\n", "# Left edge of the ground plane.\n", "x0 = -Lx/2 \n", "\n", "# Right edge of the ground plane.\n", "x1 = Lx/2 \n", "\n", "# x_taper_start: where the exponential section begins\n", "x_taper_start = x1 - taper_length\n", "\n", "# x_slot_left: start of parallel section = end of cavity = x_taper_start - s\n", "x_slot_left = x_taper_start - cavity_to_taper\n", "\n", "# cavity centre\n", "x_cav = x_slot_left - cavity_diameter / 2\n", "\n", "print(f\"Ground plane: [{x0:.4f}, {x1:.4f}]\")\n", "print(f\"Taper starts at: x = {x_taper_start:.4f}\")\n", "print(f\"Parallel section: x = [{x_slot_left:.4f}, {x_taper_start:.4f}] \"\n", " f\"length = {cavity_to_taper*1e3:.1f} mm (= cavity_to_taper)\")\n", "print(f\"Cavity centre at: x = {x_cav:.4f}\")\n", "print(f\"Cavity right edge: x = {x_slot_left:.4f} (= x_taper_start - s)\")\n" ] }, { "cell_type": "markdown", "execution_count": null, "id": "taper_math", "metadata": { "papermill": { "duration": 0.002841, "end_time": "2026-08-04T16:49:25.601939+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.599098+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Exponential taper mathematics\n", "\n", "The upper edge of the Vivaldi slot follows:\n", "$$y_{\\text{upper}}(x) = \\frac{w_s}{2} \\cdot e^{C(x - x_{\\text{ts}})}$$\n", "scaled so that $y_{\\text{upper}}(x_1) = w_a/2$.\n", "\n", "We solve for the normalisation constant $A$:\n", "$$A = \\frac{w_a/2}{e^{C(x_1 - x_{\\text{ts}})}}$$\n", "which gives:\n", "$$y_{\\text{upper}}(x) = A \\cdot e^{C(x - x_{\\text{ts}})}$$\n", "\n", "The lower edge is the mirror: $y_{\\text{lower}} = -y_{\\text{upper}}$." ] }, { "cell_type": "code", "execution_count": 3, "id": "taper_func", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.608648Z", "iopub.status.busy": "2026-08-04T16:49:25.608475Z", "iopub.status.idle": "2026-08-04T16:49:25.612344Z", "shell.execute_reply": "2026-08-04T16:49:25.611719Z" }, "papermill": { "duration": 0.008271, "end_time": "2026-08-04T16:49:25.613042+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.604771+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "y at taper start : +0.00012 (expected ≈ +0.00025)\n", "y at aperture : +0.05250 (expected ≈ +0.05250)\n" ] } ], "source": [ "def taper_y(x: float, sign: float = 1.0) -> float:\n", " \n", " # Normalisation: amplitude A chosen so y(x1) = aperture_width/2\n", " A = (aperture_width / 2) / math.exp(opening_rate * (x1 - x_taper_start))\n", " \n", " return sign * A * math.exp(opening_rate * (x - x_taper_start))\n", "\n", "# Quick sanity checks\n", "print(f\"y at taper start : {taper_y(x_taper_start):+.5f} (expected ≈ {slot_width/2:+.5f})\")\n", "print(f\"y at aperture : {taper_y(x1):+.5f} (expected ≈ {aperture_width/2:+.5f})\")" ] }, { "cell_type": "markdown", "execution_count": null, "id": "gmsh_init_md", "metadata": { "papermill": { "duration": 0.00279, "end_time": "2026-08-04T16:49:25.618765+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.615975+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Initialise gmsh" ] }, { "cell_type": "code", "execution_count": 4, "id": "7054c50f", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.625370Z", "iopub.status.busy": "2026-08-04T16:49:25.625225Z", "iopub.status.idle": "2026-08-04T16:49:25.628883Z", "shell.execute_reply": "2026-08-04T16:49:25.628370Z" }, "papermill": { "duration": 0.007822, "end_time": "2026-08-04T16:49:25.629542+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.621720+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "gmsh.initialize()\n", "gmsh.model.add(\"vivaldi_antenna\")\n", "kernel = gmsh.model.occ " ] }, { "cell_type": "markdown", "execution_count": null, "id": "volumes_md", "metadata": { "papermill": { "duration": 0.003171, "end_time": "2026-08-04T16:49:25.636052+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.632881+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Build the 3-D volumes (substrate + air sphere)" ] }, { "cell_type": "code", "execution_count": 5, "id": "c3ee11e8", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.643057Z", "iopub.status.busy": "2026-08-04T16:49:25.642909Z", "iopub.status.idle": "2026-08-04T16:49:25.646955Z", "shell.execute_reply": "2026-08-04T16:49:25.646333Z" }, "papermill": { "duration": 0.008335, "end_time": "2026-08-04T16:49:25.647540+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.639205+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Substrate tag: 1\n", "Air sphere tag: 2\n" ] } ], "source": [ "# Bounding box extents \n", "total_xmin = x0 - air_margin\n", "total_xmax = x1 + air_margin\n", "total_ymin = -Ly/2 - air_margin\n", "total_ymax = Ly/2 + air_margin\n", "total_zmax = h_sub + air_height\n", "\n", "# Substrate \n", "substrate = kernel.addBox(\n", " x0, -Ly/2, 0,\n", " Lx, Ly, h_sub\n", ")\n", "\n", "# Air sphere (replace air box, consistent with patch_antenna workflow)\n", "airsphere_radius = max(abs(total_xmin), abs(total_xmax), abs(total_ymin), abs(total_ymax), total_zmax)\n", "air_sphere = kernel.addSphere(0.0, 0.0, 0.0, airsphere_radius)\n", "\n", "print(\"Substrate tag:\", substrate)\n", "print(\"Air sphere tag:\", air_sphere)" ] }, { "cell_type": "markdown", "execution_count": null, "id": "copper_md", "metadata": { "papermill": { "duration": 0.00315, "end_time": "2026-08-04T16:49:25.654014+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.650864+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Build the copper patch (ground plane + taper slot + cavity)\n", "\n", "Strategy:\n", "1. Start with a full rectangular ground-plane surface.\n", "2. Subtract the exponential slot (built from a spline boundary).\n", "3. Subtract the circular cavity.\n", "4. The result is the physical copper surface at z = h_sub." ] }, { "cell_type": "code", "execution_count": 6, "id": "copper_patch", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.661336Z", "iopub.status.busy": "2026-08-04T16:49:25.661175Z", "iopub.status.idle": "2026-08-04T16:49:25.671978Z", "shell.execute_reply": "2026-08-04T16:49:25.671460Z" }, "papermill": { "duration": 0.01555, "end_time": "2026-08-04T16:49:25.672727+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.657177+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Parallel section: x=[-0.1160, -0.0930] y=±0.00025\n", "Exponential section: x=[-0.0930, 0.1500]\n", "Aperture width at x1: 105.00 mm (target 105.00 mm)\n", "Top rectangle tag: 8\n", "Slot surface tag: 9\n", "Cavity surface tag: 10\n" ] } ], "source": [ "# Top rectangle. We´ll cut the slot and cavity out of this.\n", "top_rect = kernel.addRectangle(x0, -Ly/2, h_sub, Lx, Ly)\n", "\n", "# Parallel section geometry.\n", "p_ul = kernel.addPoint(x_slot_left, +slot_width/2, h_sub)\n", "p_ur = kernel.addPoint(x_taper_start, +slot_width/2, h_sub)\n", "p_lr = kernel.addPoint(x_taper_start, -slot_width/2, h_sub)\n", "p_ll = kernel.addPoint(x_slot_left, -slot_width/2, h_sub)\n", "\n", "# Straight lines\n", "line_top_par = kernel.addLine(p_ul, p_ur) # upper parallel edge\n", "line_bot_par = kernel.addLine(p_lr, p_ll) # lower parallel edge (reversed for CCW)\n", "line_left = kernel.addLine(p_ll, p_ul) # left closing line (at x_slot_left)\n", "\n", "# Interpolate points along the exponential taper curve from x_taper_start to x1.\n", "N_pts = 100\n", "xs = np.linspace(x_taper_start, x1, N_pts)\n", "\n", "# Upper spline\n", "upper_inner = [kernel.addPoint(float(x), taper_y(float(x), +1.0), h_sub)\n", " for x in xs[1:]]\n", "upper_spline = kernel.addSpline([p_ur] + upper_inner)\n", "\n", "# Lower spline: starts at p_lr, reversed direction for CCW loop.\n", "lower_inner = [kernel.addPoint(float(x), taper_y(float(x), -1.0), h_sub)\n", " for x in xs[1:]]\n", "\n", "# In the loop we traverse lower in reverse (aperture → taper_start),\n", "# so we list points aperture-end first.\n", "lower_spline = kernel.addSpline(lower_inner[::-1] + [p_lr])\n", "\n", "# Aperture closing line (right edge, x = x1)\n", "p_apt = upper_inner[-1] # top-right aperture point\n", "p_apb = lower_inner[-1] # bottom-right aperture point\n", "line_aperture = kernel.addLine(p_apt, p_apb)\n", "\n", "slot_loop = kernel.addCurveLoop([\n", " line_left, # up the left edge (x_slot_left, bot→top)\n", " line_top_par, # rightward along upper parallel\n", " upper_spline, # upper exponential curve to aperture\n", " line_aperture, # down the aperture edge\n", " lower_spline, # lower exponential back to x_taper_start (reversed)\n", " line_bot_par, # leftward along lower parallel back to start\n", "])\n", "\n", "slot_surf = kernel.addPlaneSurface([slot_loop])\n", "\n", "# Circular cavity\n", "cav_r = cavity_diameter / 2\n", "cav_cx = x_cav\n", "cav_cy = 0.0\n", "\n", "cav_circle = kernel.addCircle(cav_cx, cav_cy, h_sub, cav_r)\n", "cav_loop = kernel.addCurveLoop([cav_circle])\n", "cav_surf = kernel.addPlaneSurface([cav_loop])\n", "\n", "print(f\"Parallel section: x=[{x_slot_left:.4f}, {x_taper_start:.4f}] y=±{slot_width/2:.5f}\")\n", "print(f\"Exponential section: x=[{x_taper_start:.4f}, {x1:.4f}]\")\n", "print(f\"Aperture width at x1: {2*taper_y(x1,1)*1e3:.2f} mm (target {aperture_width*1e3:.2f} mm)\")\n", "print(\"Top rectangle tag: \", top_rect)\n", "print(\"Slot surface tag: \", slot_surf)\n", "print(\"Cavity surface tag: \", cav_surf)" ] }, { "cell_type": "markdown", "execution_count": null, "id": "feed_md", "metadata": { "papermill": { "duration": 0.002904, "end_time": "2026-08-04T16:49:25.678788+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.675884+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Feed port\n", "\n", "From the inset diagram, the feed port is a **square face** in the YZ plane\n", "at the left edge of the ground plane (`x = x0`). It is centred on the slot\n", "(`y = 0`) and spans the substrate thickness in z.\n", "\n", "- `feed_offset` is the **x-axis** offset that positions where along the slot\n", " the port is referenced — here it locates the port at `x = x0 + feed_offset`\n", " inside the ground plane, but the excitation face itself sits flush at\n", " `x = x0` (the left wall of the computational domain).\n", "- The port is square: width = height = `slot_width` in the YZ cross-section.\n", "- It is centred at `y = 0, z = h_sub / 2` (mid-height of the substrate)." ] }, { "cell_type": "code", "execution_count": 7, "id": "feed_strip", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.685961Z", "iopub.status.busy": "2026-08-04T16:49:25.685803Z", "iopub.status.idle": "2026-08-04T16:49:25.690658Z", "shell.execute_reply": "2026-08-04T16:49:25.689973Z" }, "papermill": { "duration": 0.009456, "end_time": "2026-08-04T16:49:25.691185+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.681729+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Feed port surface tag: 11\n", "Port centre: x=-0.0932 y=0 z=0.01500 (top of substrate)\n", "Port x range: [-0.0935, -0.0930]\n", "Port y range: [-0.00025, 0.00025]\n", "Port size: 0.50 mm × 0.50 mm (square)\n", "Sanity: port_x_ctr (-0.0932) should be between cavity right edge (-0.1160) and taper start (-0.0930)\n" ] } ], "source": [ "port_size = slot_width # square side length [m]\n", "port_x_ctr = x_taper_start - port_size / 2 # port centre along x\n", "port_x0 = port_x_ctr - port_size / 2 # left x of port\n", "port_y0 = -port_size / 2 # bottom y (centred on slot)\n", "\n", "# Flat XY-plane rectangle at z = h_sub — no rotation needed.\n", "feed_port_surf = kernel.addRectangle(\n", " port_x0, # x start\n", " port_y0, # y start (centred: -w_s/2 .. +w_s/2)\n", " h_sub, # z = top of substrate\n", " port_size, # dx = slot_width (square in x)\n", " port_size, # dy = slot_width (square in y, touches both copper edges)\n", ")\n", "\n", "print(f\"Feed port surface tag: {feed_port_surf}\")\n", "print(f\"Port centre: x={port_x_ctr:.4f} y=0 z={h_sub:.5f} (top of substrate)\")\n", "print(f\"Port x range: [{port_x0:.4f}, {port_x0+port_size:.4f}]\")\n", "print(f\"Port y range: [{port_y0:.5f}, {-port_y0:.5f}]\")\n", "print(f\"Port size: {port_size*1e3:.2f} mm × {port_size*1e3:.2f} mm (square)\")\n", "print(f\"Sanity: port_x_ctr ({port_x_ctr:.4f}) should be between \"\n", " f\"cavity right edge ({x_cav + cavity_diameter/2:.4f}) \"\n", " f\"and taper start ({x_taper_start:.4f})\")" ] }, { "cell_type": "markdown", "execution_count": null, "id": "boolean_md", "metadata": { "papermill": { "duration": 0.003234, "end_time": "2026-08-04T16:49:25.697731+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.694497+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Boolean operations — assemble the copper patch\n", "\n", "Cut the slot and cavity out of the ground-plane rectangle.\n", "The feed strip is kept separate (it is a distinct conductor patch)." ] }, { "cell_type": "code", "execution_count": 8, "id": "boolean_ops", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.705001Z", "iopub.status.busy": "2026-08-04T16:49:25.704841Z", "iopub.status.idle": "2026-08-04T16:49:25.717160Z", "shell.execute_reply": "2026-08-04T16:49:25.716547Z" }, "papermill": { "duration": 0.016714, "end_time": "2026-08-04T16:49:25.717654+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.700940+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Info : [ 0%] Difference \r", "Info : [ 10%] Difference \r", "Info : [ 20%] Difference \r", "Info : [ 30%] Difference \r", "Info : [ 40%] Difference \r", "Info : [ 50%] Difference \r", "Info : [ 70%] Difference - Filling splits of edges \r", "Info : [ 80%] Difference - Making faces \r", "Info : [ 90%] Difference - Adding holes \r", " \r", "Copper patch surfaces after boolean cut:\n", " dim=2, tag=8\n" ] } ], "source": [ "kernel.synchronize()\n", "\n", "# Cut slot + cavity from ground-plane rectangle\n", "# BooleanCut returns (result_dimtags, map)\n", "copper_patch, _ = kernel.cut(\n", " [(2, top_rect)], # object: full rectangle\n", " [(2, slot_surf), (2, cav_surf)], # tools: slot + cavity\n", " removeObject=True, removeTool=True\n", ")\n", "\n", "kernel.synchronize()\n", "print(\"Copper patch surfaces after boolean cut:\")\n", "for dim, tag in copper_patch:\n", " print(f\" dim={dim}, tag={tag}\")" ] }, { "cell_type": "markdown", "execution_count": null, "id": "embed_md", "metadata": { "papermill": { "duration": 0.00301, "end_time": "2026-08-04T16:49:25.724229+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.721219+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Entity definition. \n", "\n", "In order to get a good mesh we need to fragment it and restore it, run_entity_pipeline does this and also defines the physical groups." ] }, { "cell_type": "code", "execution_count": 9, "id": "7691895e", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:49:25.731272Z", "iopub.status.busy": "2026-08-04T16:49:25.731079Z", "iopub.status.idle": "2026-08-04T16:50:08.505732Z", "shell.execute_reply": "2026-08-04T16:50:08.505127Z" }, "papermill": { "duration": 42.779172, "end_time": "2026-08-04T16:50:08.506433+00:00", "exception": false, "start_time": "2026-08-04T16:49:25.727261+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Physical group 'substrate' (dim=3): pg=1, tags=[1]\n", " Physical group 'air_sphere' (dim=3): pg=2, tags=[2]\n", " Physical group 'copper_patch' (dim=2): pg=3, tags=[8]\n", " Physical group 'feed_port' (dim=2): pg=4, tags=[11]\n", " Physical group 'air_sphere__substrate' (dim=2): pg=5, tags=[12, 13, 14, 15, 5, 16, 17, 18]\n", " Physical group 'air_sphere__None' (dim=2): pg=6, tags=[19]\n", " ignoring 3 curves from {'air_sphere__None'}\n", " global: 25 curves, SizeMin=0.0002\n", " ppw_near=300 ppw_far=5\n", " SizeMax=0.0133 transition=0.0167\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Mesh saved to vivaldi.msh\n", " Nodes: 60154\n", " Elements: 393336\n", "Info : Writing 'vivaldi.msh'...\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Info : Done writing 'vivaldi.msh'\n" ] } ], "source": [ "entities = [\n", " Entity(\"copper_patch\", dim=2, btype=\"pec\", mesh_order=1, tags=[copper_patch[0][1]]),\n", " Entity(\"substrate\", dim=3, btype=\"dielectric\", mesh_order=1, tags=[substrate], loss_tan=0.0009, eps_r=2.2, mu_r=1.0),\n", " Entity(\"air_sphere\", dim=3, btype=\"dielectric\", mesh_order=2, tags=[air_sphere], loss_tan=0.0, eps_r=1.0, mu_r=1.0),\n", " Entity(\"feed_port\", dim=2, btype=\"waveport\", mesh_order=0, tags=[feed_port_surf]),\n", "]\n", "\n", "pg_map = run_entity_pipeline(entities)\n", "create_graded_mesh( wavelength, \n", " ppw_near=300, \n", " ppw_far=5, \n", " transition_distance=wavelength/4,\n", " set_as_background=True)\n", "\n", "generate_3d_mesh(entities, mesh_file, optimize=True)\n", "gmsh.option.setNumber(\"Mesh.MshFileVersion\", 2.2)\n", "gmsh.write(mesh_file)\n", "gmsh.finalize()" ] }, { "cell_type": "markdown", "execution_count": null, "id": "mesh_md", "metadata": { "papermill": { "duration": 0.003494, "end_time": "2026-08-04T16:50:08.513684+00:00", "exception": false, "start_time": "2026-08-04T16:50:08.510190+00:00", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "#### Mesh generation" ] }, { "cell_type": "code", "execution_count": 10, "id": "93234454", "metadata": { "execution": { "iopub.execute_input": "2026-08-04T16:50:08.521939Z", "iopub.status.busy": "2026-08-04T16:50:08.521743Z", "iopub.status.idle": "2026-08-04T16:50:11.661181Z", "shell.execute_reply": "2026-08-04T16:50:11.660580Z" }, "papermill": { "duration": 3.145007, "end_time": "2026-08-04T16:50:11.662163+00:00", "exception": false, "start_time": "2026-08-04T16:50:08.517156+00:00", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading mesh file: vivaldi.msh\n", "Groups to render transparent: air_sphere__None\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Mesh loaded successfully with 2 cell blocks\n", "Found 59308 triangles total\n", "Physical group tags in mesh: {3: 'copper_patch', 4: 'feed_port', 5: 'air_sphere__substrate', 6: 'air_sphere__None'}\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "view_mesh(mesh_file, transparent_groups=\"air_sphere__None\", transparent_alpha=0)" ] } ], "metadata": { "kernelspec": { "display_name": ".venv (3.12.3.final.0)", "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.13" }, "papermill": { "default_parameters": {}, "duration": 48.248345, "end_time": "2026-08-04T16:50:12.082297+00:00", "environment_variables": {}, "exception": null, "input_path": "docs/examples/vivaldi_antenna.ipynb", "output_path": "docs/examples/vivaldi_antenna.ipynb", "parameters": {}, "start_time": "2026-08-04T16:49:23.833952+00:00", "version": "2.7.0" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "033aa55a922c4a5dae9d60702adcf1c2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "0a372271a6dd438c82a9ff61229395e1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "8170065c2523417486acac13dc0a3218": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_033aa55a922c4a5dae9d60702adcf1c2", "placeholder": "​", "style": "IPY_MODEL_0a372271a6dd438c82a9ff61229395e1", "tabbable": null, "tooltip": null, "value": "" } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }