+
+
+
+Useful links: +Installation | +Source repository | +Issues
+This repository contains end-to-end embedding examples that demonstrate how to use +PyAEDT.
+
+
+Provides examples of some general AEDT pre-processing and post-processing capabilities.
+![](\"_static/e3dcomp.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2e2e0be",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Import the required packages.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0bfd88e3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "14fedc24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pyaedt import Desktop, Hfss, settings\n",
+ "from pyedb.misc.downloads import download_file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8ddb879c",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8cd38813",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "OLD_AEDT_VERSION = \"2024.1\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f7b0f04d",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0be37da2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "39bd99fc",
+ "metadata": {},
+ "source": [
+ "## Download encrypted example\n",
+ "\n",
+ "Download the encrypted 3D component example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "74b1a681",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a3dcomp = download_file(\n",
+ " directory=\"component_3d\",\n",
+ " filename=\"SMA_Edge_Connector_23r2_encrypted_password_ansys.a3dcomp\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34bc23a9",
+ "metadata": {},
+ "source": [
+ "## Enable multiple desktop support"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "35fa96b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "settings.use_multi_desktop = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a2bb7f0",
+ "metadata": {},
+ "source": [
+ "## Prepare encrypted 3D component in ACIS\n",
+ "\n",
+ "Launch the old AEDT release."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b0480f3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt_old = Desktop(new_desktop=True, version=OLD_AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "673f5ac0",
+ "metadata": {},
+ "source": [
+ "Insert an empty HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "29ca1956",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss1 = Hfss(aedt_process_id=aedt_old.aedt_process_id, solution_type=\"Terminal\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "85f66490",
+ "metadata": {},
+ "source": [
+ "Insert the encrypted 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8049214f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cmp = hfss1.modeler.insert_3d_component(comp_file=a3dcomp, password=\"ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81dbdd7f",
+ "metadata": {},
+ "source": [
+ "Open the 3D component in an HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "997852b4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app_comp = cmp.edit_definition(password=\"ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "823641e7",
+ "metadata": {},
+ "source": [
+ "## Create an encrypted 3D component in Parasolid\n",
+ "\n",
+ "Launch the new AEDT release"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a296d043",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt = Desktop(new_desktop_session=True, specified_version=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e02eb24c",
+ "metadata": {},
+ "source": [
+ "Insert an empty HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "638d0d5f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2 = Hfss(aedt_process_id=aedt.aedt_process_id, solution_type=\"Terminal\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1c2e14c2",
+ "metadata": {},
+ "source": [
+ "Copy objects from the old design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c1eb149e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.copy_solid_bodies_from(design=app_comp, no_vacuum=False, no_pec=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eba68ee8",
+ "metadata": {},
+ "source": [
+ "Create the new encrypted 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "42405c1e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.create_3dcomponent(\n",
+ " input_file=os.path.join(temp_folder.name, r\"SMA_Edge_Connector_encrypted.a3dcomp\"),\n",
+ " is_encrypted=True,\n",
+ " edit_password=\"ansys\",\n",
+ " hide_contents=False,\n",
+ " allow_edit=True,\n",
+ " password_type=\"InternalPassword\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11da5d28",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08b38d51",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt.save_project()\n",
+ "aedt_old.save_project()\n",
+ "aedt.release_desktop()\n",
+ "aedt_old.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8c29029",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "696c7da2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/components/index.rst.txt b/version/dev/_sources/examples/aedt_general/components/index.rst.txt
new file mode 100644
index 00000000..e4c9a142
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/components/index.rst.txt
@@ -0,0 +1,38 @@
+3D components
+~~~~~~~~~~~~~
+
+These examples use PyAEDT to show some 3D component capabilities.
+
+.. grid:: 2
+
+ .. grid-item-card:: 3D component creation and reuse
+ :padding: 2 2 2 2
+ :link: reuse_component
+ :link-type: doc
+
+ .. image:: _static/component_3d.png
+ :alt: Component creation
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create and use 3D components.
+
+ .. grid-item-card:: Encrypted 3D component conversion
+ :padding: 2 2 2 2
+ :link: component_conversion
+ :link-type: doc
+
+ .. image:: _static/e3dcomp.png
+ :alt: Connector component
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to convert an encrypted 3D component from ACIS to Parasolid in different AEDT releases.
+
+.. toctree::
+ :hidden:
+
+ reuse_component
+ component_conversion
diff --git a/version/dev/_sources/examples/aedt_general/components/reuse_component.ipynb.txt b/version/dev/_sources/examples/aedt_general/components/reuse_component.ipynb.txt
new file mode 100644
index 00000000..0496adf7
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/components/reuse_component.ipynb.txt
@@ -0,0 +1,537 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "9e93bcda",
+ "metadata": {},
+ "source": [
+ "# 3D component creation and reuse"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c862d61d",
+ "metadata": {},
+ "source": [
+ "Here is a workflow for creating a 3D component and reusing it:\n",
+ "\n",
+ "Step 1: Create an antenna using PyAEDT and HFSS 3D Modeler. (The antenna can also be created using EDB and\n",
+ "HFSS 3D Layout).\n",
+ "\n",
+ "Step 2. Store the object as a 3D component on the disk.\n",
+ "\n",
+ "Step 3. Reuse the 3D component in another project.\n",
+ "\n",
+ "Step 4. Parametrize and optimize the target design.\n",
+ "\n",
+ "Keywords: **AEDT**, **General**, **3D component**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "898d3405",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4504b934",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a73b9478",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import Hfss"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a24dff17",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75c03e2c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6972cb66",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ec12a0a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed0dd63d",
+ "metadata": {},
+ "source": [
+ "Create an HFSS object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c6c05a85",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = Hfss(\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " close_on_exit=True,\n",
+ " non_graphical=NG_MODE,\n",
+ " solution_type=\"Modal\",\n",
+ ")\n",
+ "hfss.save_project(os.path.join(temp_folder.name, \"example.aedt\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e06724f",
+ "metadata": {},
+ "source": [
+ "## Define variables\n",
+ "\n",
+ "PyAEDT can create and store all variables available in AEDT (such as design, project,\n",
+ "and postprocessing)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eca62da2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss[\"thick\"] = \"0.1mm\"\n",
+ "hfss[\"width\"] = \"1mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7041026",
+ "metadata": {},
+ "source": [
+ "## Create modeler objects\n",
+ "\n",
+ "PyAEDT supports all modeler functionalities available in AEDT.\n",
+ "You can create, delete, and modify objects using all available Boolean operations.\n",
+ "PyAEDT can also fully access history."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0653d5dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "substrate = hfss.modeler.create_box(\n",
+ " [\"-width\", \"-width\", \"-thick\"],\n",
+ " [\"2*width\", \"2*width\", \"thick\"],\n",
+ " material=\"FR4_epoxy\",\n",
+ " name=\"sub\",\n",
+ ")\n",
+ "\n",
+ "patch = hfss.modeler.create_rectangle(\n",
+ " \"XY\", [\"-width/2\", \"-width/2\", \"0mm\"], [\"width\", \"width\"], name=\"patch1\"\n",
+ ")\n",
+ "\n",
+ "via1 = hfss.modeler.create_cylinder(\n",
+ " 2,\n",
+ " [\"-width/8\", \"-width/4\", \"-thick\"],\n",
+ " \"0.01mm\",\n",
+ " \"thick\",\n",
+ " material=\"copper\",\n",
+ " name=\"via_inner\",\n",
+ ")\n",
+ "\n",
+ "via_outer = hfss.modeler.create_cylinder(\n",
+ " 2,\n",
+ " [\"-width/8\", \"-width/4\", \"-thick\"],\n",
+ " \"0.025mm\",\n",
+ " \"thick\",\n",
+ " material=\"Teflon_based\",\n",
+ " name=\"via_teflon\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "beb3f969",
+ "metadata": {},
+ "source": [
+ "## Assign bundaries\n",
+ "\n",
+ "Most of HFSS boundaries and excitations are already available in PyAEDT.\n",
+ "You can easily assign a boundary to a face or to an object by taking advantage of\n",
+ "Object-Oriented Programming (OOP) available in PyAEDT."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c7b5509e",
+ "metadata": {},
+ "source": [
+ "### Assign Perfect E boundary to sheets\n",
+ "\n",
+ "Assign a Perfect E boundary to sheets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "82bd6ef0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.assign_perfecte_to_sheets(patch)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4870ff2",
+ "metadata": {},
+ "source": [
+ "### Assign boundaries to faces\n",
+ "\n",
+ "Assign boundaries to the top and bottom faces of an object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "655418fb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "side_face = [\n",
+ " i\n",
+ " for i in via_outer.faces\n",
+ " if i.id not in [via_outer.top_face_z.id, via_outer.bottom_face_z.id]\n",
+ "]\n",
+ "\n",
+ "hfss.assign_perfecte_to_sheets(side_face)\n",
+ "hfss.assign_perfecte_to_sheets(substrate.bottom_face_z)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d1c6a16",
+ "metadata": {},
+ "source": [
+ "## Create wave port\n",
+ "\n",
+ "You can assign a wave port to a sheet or to a face of an object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d9bc0cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.wave_port(\n",
+ " via_outer.bottom_face_z,\n",
+ " name=\"P1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6936b951",
+ "metadata": {},
+ "source": [
+ "## Create 3D component\n",
+ "\n",
+ "Once the model is ready, you can create a 3D component.\n",
+ "Multiple options are available to partially select objects, coordinate systems,\n",
+ "boundaries, and mesh operations. You can also create encrypted 3D components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6caeac47",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "component_path = os.path.join(temp_folder.name, \"component_test.aedbcomp\")\n",
+ "hfss.modeler.create_3dcomponent(component_path, \"patch_antenna\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7866ee3e",
+ "metadata": {},
+ "source": [
+ "## Manage multiple project\n",
+ "\n",
+ "PyAEDT lets you control multiple projects, designs, and solution types at the same time."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27579f2a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_project = os.path.join(temp_folder.name, \"new_project.aedt\")\n",
+ "hfss2 = Hfss(\n",
+ " version=AEDT_VERSION,\n",
+ " project=new_project,\n",
+ " design=\"new_design\",\n",
+ " solution_type=\"Modal\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0503a565",
+ "metadata": {},
+ "source": [
+ "## Insert 3D component\n",
+ "\n",
+ "You can insert a 3D component without supplying additional information.\n",
+ "All needed information is read from the file itself."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "083cb34b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.insert_3d_component(component_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4cb39e37",
+ "metadata": {},
+ "source": [
+ "## Parametrize 3D components\n",
+ "\n",
+ "You can specify parameters for any 3D components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2bbd98cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.user_defined_components[\"patch_antenna1\"].parameters\n",
+ "hfss2[\"p_thick\"] = \"1mm\"\n",
+ "hfss2.modeler.user_defined_components[\"patch_antenna1\"].parameters[\"thick\"] = \"p_thick\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0b01852",
+ "metadata": {},
+ "source": [
+ "## Insert multiple 3D components\n",
+ "\n",
+ "There is no limit to the number of 3D components that can be inserted in a design.\n",
+ "These components can be the same or linked to different files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "393795db",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.create_coordinate_system(origin=[20, 20, 10], name=\"Second_antenna\")\n",
+ "ant2 = hfss2.modeler.insert_3d_component(\n",
+ " component_path, coordinate_system=\"Second_antenna\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "45a5326b",
+ "metadata": {},
+ "source": [
+ "## Move 3D components\n",
+ "\n",
+ "Move a 3D component by either changing its position or moving the relative coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "152482ce",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.coordinate_systems[0].origin = [10, 10, 3]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "821df3fc",
+ "metadata": {},
+ "source": [
+ "## Create air region\n",
+ "\n",
+ "Create an air region and assign a boundary to a face or an object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d55c94ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.create_air_region(30, 30, 30, 30, 30, 30)\n",
+ "hfss2.assign_radiation_boundary_to_faces(hfss2.modeler[\"Region\"].faces)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b97669c",
+ "metadata": {},
+ "source": [
+ "## Create setup and optimetrics analysis\n",
+ "\n",
+ "Once a project is ready to be solved, use PyAEDT to create a setup and parametrics analysis.\n",
+ "All setup parameters can be edited."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4d487443",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = hfss2.create_setup()\n",
+ "optim = hfss2.parametrics.add(\"p_thick\", \"0.2mm\", \"1.5mm\", step=14)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e5691cf7",
+ "metadata": {},
+ "source": [
+ "## Plot objects"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5b3a2a9c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.modeler.fit_all()\n",
+ "hfss2.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(hfss.working_directory, \"Image.jpg\"),\n",
+ " plot_air_objects=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dcd5fcfb",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "802e595f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss2.save_project()\n",
+ "hfss2.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81098606",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "034b325e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/configuration_files.ipynb.txt b/version/dev/_sources/examples/aedt_general/configuration_files.ipynb.txt
new file mode 100644
index 00000000..94ce7d89
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/configuration_files.ipynb.txt
@@ -0,0 +1,367 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "8033469e",
+ "metadata": {},
+ "source": [
+ "# Configuration files\n",
+ "\n",
+ "This example shows how to use PyAEDT to export configuration files and reuse\n",
+ "them to import in a new project. A configuration file is supported by these applications:\n",
+ "\n",
+ "* HFSS\n",
+ "* 2D Extractor and Q3D Extractor\n",
+ "* Maxwell\n",
+ "* Icepak (in AEDT)\n",
+ "* Mechanical (in AEDT)\n",
+ "\n",
+ "The following topics are covered:\n",
+ "\n",
+ "* Variables\n",
+ "* Mesh operations (except Icepak)\n",
+ "* Setup and optimetrics\n",
+ "* Material properties\n",
+ "* Object properties\n",
+ "* Boundaries and excitations\n",
+ "\n",
+ "When a boundary is attached to a face, PyAEDT tries to match it with a\n",
+ "``FaceByPosition`` on the same object name on the target design. If for\n",
+ "any reason this face position has changed or the object name in the target\n",
+ "design has changed, the boundary fails to apply.\n",
+ "\n",
+ "Keywords: **AEDT**, **general**, **configuration file**, **setup**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0c64f02c",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9dff340f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cf386af5",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4b1c7b61",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78f5717c",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create the temporary directory.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "391836a9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4bd925b7",
+ "metadata": {},
+ "source": [
+ "## Download project\n",
+ "\n",
+ "Download the Icepack project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7c3e0983",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_full_name = ansys.aedt.core.downloads.download_icepak(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b9559b9",
+ "metadata": {},
+ "source": [
+ "## Open project\n",
+ "\n",
+ "Open the Icepak project from the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53000521",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = ansys.aedt.core.Icepak(\n",
+ " project=project_full_name,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")\n",
+ "ipk.autosave_disable()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "de8395ad",
+ "metadata": {},
+ "source": [
+ "## Create source blocks\n",
+ "\n",
+ "Create a source block on the CPU and memories."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae3d2774",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.create_source_block(object_name=\"CPU\", input_power=\"25W\")\n",
+ "ipk.create_source_block(object_name=[\"MEMORY1\", \"MEMORY1_1\"], input_power=\"5W\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b91a428",
+ "metadata": {},
+ "source": [
+ "## Assign boundaries\n",
+ "\n",
+ "Assign the opening and grille."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c9ae4db9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = ipk.modeler[\"Region\"]\n",
+ "ipk.assign_openings(air_faces=region.bottom_face_x.id)\n",
+ "ipk.assign_grille(air_faces=region.top_face_x.id, free_area_ratio=0.8)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "213e5a32",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create the setup. Properties can be set up from the ``setup`` object\n",
+ "with getters and setters. They don't have to perfectly match the property\n",
+ "syntax."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7de5f26e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = ipk.create_setup()\n",
+ "setup1[\"FlowRegime\"] = \"Turbulent\"\n",
+ "setup1[\"Max Iterations\"] = 5\n",
+ "setup1[\"Solver Type Pressure\"] = \"flex\"\n",
+ "setup1[\"Solver Type Temperature\"] = \"flex\"\n",
+ "ipk.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ead7af2",
+ "metadata": {},
+ "source": [
+ "## Export project to step file\n",
+ "\n",
+ "Export the project to the step file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "45547b7d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filename = ipk.design_name\n",
+ "file_path = os.path.join(ipk.working_directory, filename + \".step\")\n",
+ "ipk.export_3d_model(\n",
+ " file_name=filename,\n",
+ " file_path=ipk.working_directory,\n",
+ " file_format=\".step\",\n",
+ " assignment_to_export=[],\n",
+ " assignment_to_remove=[],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "74adca7c",
+ "metadata": {},
+ "source": [
+ "## Export configuration files\n",
+ "\n",
+ "Export the configuration files. You can optionally disable the export and\n",
+ "import sections. Supported formats are JSON and TOML files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f0bff19c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "conf_file = ipk.configurations.export_config(\n",
+ " os.path.join(ipk.working_directory, \"config.toml\")\n",
+ ")\n",
+ "ipk.close_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8fe1b924",
+ "metadata": {},
+ "source": [
+ "## Create project\n",
+ "\n",
+ "Create an Icepak project and import the step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6fb8dd66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_project = os.path.join(temp_folder.name, \"example.aedt\")\n",
+ "app = ansys.aedt.core.Icepak(version=AEDT_VERSION, project=new_project)\n",
+ "app.modeler.import_3d_cad(file_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d3d0d75",
+ "metadata": {},
+ "source": [
+ "## Import and apply configuration file\n",
+ "\n",
+ "Import and apply the configuration file. You can apply all or part of the\n",
+ "JSON file that you import using options in the ``configurations`` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "317d3d25",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "out = app.configurations.import_config(conf_file)\n",
+ "is_conf_imported = app.configurations.results.global_import_success"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb77b6c1",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "Close the project and release AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "785b333e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app.release_desktop()\n",
+ "time.sleep(3) # Allow AEDT to shut down before cleaning the temporary project folder."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "251930e7",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "256439c4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/index.rst.txt b/version/dev/_sources/examples/aedt_general/index.rst.txt
new file mode 100644
index 00000000..fb57196c
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/index.rst.txt
@@ -0,0 +1,81 @@
+Pre-processing and post-processing
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides examples of some general AEDT pre-processing and post-processing capabilities.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: Configuration files
+ :padding: 2 2 2 2
+ :link: configuration_files
+ :link-type: doc
+
+ .. image:: _static/configuration_file_icepak.png
+ :alt: Configuration file
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to export configuration files and reuse them to import in a new project.
+
+ .. grid-item-card:: Modeler
+ :padding: 2 2 2 2
+ :link: modeler/index
+ :link-type: doc
+
+ .. image:: _static/modeler.png
+ :alt: Modeler
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some modeler capabilities.
+
+ .. grid-item-card:: Optimetrics setup
+ :padding: 2 2 2 2
+ :link: optimetrics
+ :link-type: doc
+
+ .. image:: _static/optimetrics.png
+ :alt: Optimetrics
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a project in HFSS and create all optimetrics setups.
+
+ .. grid-item-card:: Components
+ :padding: 2 2 2 2
+ :link: components/index
+ :link-type: doc
+
+ .. image:: _static/components.png
+ :alt: Components
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some 3D component capabilities.
+
+ .. grid-item-card:: Report
+ :padding: 2 2 2 2
+ :link: report/index
+ :link-type: doc
+
+ .. image:: _static/touchstone.png
+ :alt: Components
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some report capabilities.
+
+
+.. toctree::
+ :hidden:
+
+ configuration_files
+ modeler/index
+ optimetrics
+ components/index
+ report/index
\ No newline at end of file
diff --git a/version/dev/_sources/examples/aedt_general/modeler/circuit_schematic.ipynb.txt b/version/dev/_sources/examples/aedt_general/modeler/circuit_schematic.ipynb.txt
new file mode 100644
index 00000000..dae08b9a
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/modeler/circuit_schematic.ipynb.txt
@@ -0,0 +1,377 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a6af69d0",
+ "metadata": {},
+ "source": [
+ "# Circuit schematic creation and analysis\n",
+ "\n",
+ "This example shows how to build a circuit schematic\n",
+ "and run a transient circuit simulation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25befadb",
+ "metadata": {},
+ "source": [
+ "![](\"_static/circuit.png\")
\n",
+ "\n",
+ "Keywords: **AEDT**, **Circuit**, **Schematic**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6a932cae",
+ "metadata": {},
+ "source": [
+ "## Import packages and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "838f1ff0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6c091407",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e2e61507",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10f06d61",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b7c711f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "67bf31a1",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with Circuit\n",
+ "\n",
+ "Launch AEDT with Circuit. The [pyaedt.Desktop](\n",
+ "https://aedt.docs.pyansys.com/version/stable/API/_autosummary/pyaedt.desktop.Desktop.html#pyaedt.desktop.Desktop)\n",
+ "class initializes AEDT and starts the specified version in the specified mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1037d9ed",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "circuit = ansys.aedt.core.Circuit(\n",
+ " project=os.path.join(temp_folder.name, \"CircuitExample\"),\n",
+ " design=\"Simple\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "\n",
+ "circuit.modeler.schematic.schematic_units = \"mil\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4ccaff7",
+ "metadata": {},
+ "source": [
+ "## Create circuit setup\n",
+ "\n",
+ "Create and customize a linear network analysis (LNA) setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5012a0e5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = circuit.create_setup(\"MyLNA\")\n",
+ "setup1.props[\"SweepDefinition\"][\"Data\"] = \"LINC 0GHz 4GHz 10001\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3591843",
+ "metadata": {},
+ "source": [
+ "## Place components\n",
+ "\n",
+ "Place components such as an inductor, resistor, and capacitor. The ``location`` argument\n",
+ "provides the ``[x, y]`` coordinates to place the component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0260688f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "inductor = circuit.modeler.schematic.create_inductor(\n",
+ " name=\"L1\", value=1e-9, location=[0, 0]\n",
+ ")\n",
+ "resistor = circuit.modeler.schematic.create_resistor(\n",
+ " name=\"R1\", value=50, location=[500, 0]\n",
+ ")\n",
+ "capacitor = circuit.modeler.schematic.create_capacitor(\n",
+ " name=\"C1\", value=1e-12, location=[1000, 0]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd06dc77",
+ "metadata": {},
+ "source": [
+ "## Get all pins\n",
+ "\n",
+ "The component pins are instances of the\n",
+ "``ansys.aedt.core.modeler.circuits.objct3dcircuit.CircuitPins`` class and\n",
+ "provide access to the\n",
+ "pin location, net connectivity, and the ``connect_to_component()`` method, which\n",
+ "can be used to connect components in the schematic\n",
+ "as demonstrated in this example."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8d45ebc1",
+ "metadata": {},
+ "source": [
+ "## Place a port and ground\n",
+ "\n",
+ "Place a port and a ground in the schematic."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c68edcc1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "port = circuit.modeler.components.create_interface_port(\n",
+ " name=\"myport\", location=[-300, 50]\n",
+ ")\n",
+ "gnd = circuit.modeler.components.create_gnd(location=[1200, -100])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0edb9619",
+ "metadata": {},
+ "source": [
+ "## Connect components\n",
+ "\n",
+ "Connect components with wires in the schematic. The ``connect_to_component()``\n",
+ "method is used to create connections between pins."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8f5befb8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "port.pins[0].connect_to_component(assignment=inductor.pins[0], use_wire=True)\n",
+ "inductor.pins[1].connect_to_component(assignment=resistor.pins[1], use_wire=True)\n",
+ "resistor.pins[0].connect_to_component(assignment=capacitor.pins[0], use_wire=True)\n",
+ "capacitor.pins[1].connect_to_component(assignment=gnd.pins[0], use_wire=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "edc4b5ac",
+ "metadata": {},
+ "source": [
+ "## Create transient setup\n",
+ "\n",
+ "Create a transient setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0227be59",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup2 = circuit.create_setup(\n",
+ " name=\"MyTransient\", setup_type=circuit.SETUPS.NexximTransient\n",
+ ")\n",
+ "setup2.props[\"TransientData\"] = [\"0.01ns\", \"200ns\"]\n",
+ "setup3 = circuit.create_setup(name=\"MyDC\", setup_type=circuit.SETUPS.NexximDC)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1cc68419",
+ "metadata": {},
+ "source": [
+ "## Solve transient setup\n",
+ "\n",
+ "Solve the transient setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bcc57ffd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.analyze_setup(\"MyLNA\")\n",
+ "circuit.export_fullwave_spice()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1fbd881",
+ "metadata": {},
+ "source": [
+ "## Create report\n",
+ "\n",
+ "Create a report displaying the scattering parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f1737d60",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions = circuit.post.get_solution_data(\n",
+ " expressions=circuit.get_traces_for_plot(category=\"S\"),\n",
+ ")\n",
+ "solutions.enable_pandas_output = True\n",
+ "real, imag = solutions.full_matrix_real_imag\n",
+ "print(real)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5192bc6e",
+ "metadata": {},
+ "source": [
+ "## Create plot\n",
+ "\n",
+ "Create a plot based on solution data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "04769cac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig = solutions.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "877028be",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b298a65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()\n",
+ "circuit.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1189a035",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ec8a3d9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/modeler/coordinate_system.ipynb.txt b/version/dev/_sources/examples/aedt_general/modeler/coordinate_system.ipynb.txt
new file mode 100644
index 00000000..4b554f46
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/modeler/coordinate_system.ipynb.txt
@@ -0,0 +1,805 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "af69791c",
+ "metadata": {},
+ "source": [
+ "# Coordinate system creation\n",
+ "\n",
+ "This example shows how to use PyAEDT to create and modify coordinate systems in the modeler.\n",
+ "\n",
+ "Keywords: **AEDT**, **modeler**, **coordinate system**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "276b4356",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "566d1217",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "17489a1f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "75cef5f0",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "24bc0497",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open the AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8a04d896",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "69859c52",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78c166a7",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "47714c6b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d = ansys.aedt.core.launch_desktop(\n",
+ " version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "691b9c45",
+ "metadata": {},
+ "source": [
+ "## Insert HFSS design\n",
+ "\n",
+ "Insert an HFSS design with the default name."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c3518ddf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"CoordSysDemo.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(version=AEDT_VERSION, project=project_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12cbe4fd",
+ "metadata": {},
+ "source": [
+ "## Create coordinate system\n",
+ "\n",
+ "The coordinate system is centered on the global origin and has the axis\n",
+ "aligned to the global coordinate system. The new coordinate system is\n",
+ "saved in the object ``cs1``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5e8c4d71",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1 = hfss.modeler.create_coordinate_system()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "949183ee",
+ "metadata": {},
+ "source": [
+ "## Modify coordinate system\n",
+ "\n",
+ "The ``cs1`` object exposes properties and methods to manipulate the\n",
+ "coordinate system. The origin can be changed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3cc3c201",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1[\"OriginX\"] = 10\n",
+ "cs1.props[\"OriginY\"] = 10\n",
+ "cs1.props[\"OriginZ\"] = 10"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eca82062",
+ "metadata": {},
+ "source": [
+ "The orientation of the coordinate system can be modified by\n",
+ "updating the direction vectors for the coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5a6d30e0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ypoint = [0, -1, 0]\n",
+ "cs1.props[\"YAxisXvec\"] = ypoint[0]\n",
+ "cs1.props[\"YAxisYvec\"] = ypoint[1]\n",
+ "cs1.props[\"YAxisZvec\"] = ypoint[2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce780c45",
+ "metadata": {},
+ "source": [
+ "## Rename coordinate system\n",
+ "\n",
+ "Rename the coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae622e75",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1.rename(\"newCS\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e4c48060",
+ "metadata": {},
+ "source": [
+ "## Change coordinate system mode\n",
+ "\n",
+ "Use the ``change_cs_mode`` method to change the mode. Options are:\n",
+ "\n",
+ "- ``0`` for axis/position\n",
+ "- ``1`` for Euler angle ZXZ\n",
+ "- ``2`` for Euler angle ZYZ\n",
+ "\n",
+ "Here ``1`` sets Euler angle ZXZ as the mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f2a52e22",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1.change_cs_mode(1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc9de659",
+ "metadata": {},
+ "source": [
+ "The following lines use the ZXZ Euler angle definition to rotate the coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b54b5430",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1.props[\"Phi\"] = \"10deg\"\n",
+ "cs1.props[\"Theta\"] = \"22deg\"\n",
+ "cs1.props[\"Psi\"] = \"30deg\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81dd2a0b",
+ "metadata": {},
+ "source": [
+ "## Delete coordinate system\n",
+ "\n",
+ "Delete the coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2ee19ed0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs1.delete()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd7cd675",
+ "metadata": {},
+ "source": [
+ "## Define a new coordinate system\n",
+ "\n",
+ "Create a coordinate system by defining the axes. You can\n",
+ "specify all coordinate system properties as shown here."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d4c90c06",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs2 = hfss.modeler.create_coordinate_system(\n",
+ " name=\"CS2\",\n",
+ " origin=[1, 2, 3.5],\n",
+ " mode=\"axis\",\n",
+ " x_pointing=[1, 0, 1],\n",
+ " y_pointing=[0, -1, 0],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d8dd76d",
+ "metadata": {},
+ "source": [
+ "A new coordinate system can also be created based on the Euler angle convention."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c895a23d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs3 = hfss.modeler.create_coordinate_system(\n",
+ " name=\"CS3\", origin=[2, 2, 2], mode=\"zyz\", phi=10, theta=20, psi=30\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1285050d",
+ "metadata": {},
+ "source": [
+ "Create a coordinate system that is defined by standard views in the modeler. The options are:\n",
+ "\n",
+ "- ``\"iso\"``\n",
+ "- ``\"XY\"``\n",
+ "- ``\"XZ\"``\n",
+ "- ``\"XY\"``\n",
+ "\n",
+ "Here ``\"iso\"`` is specified. The axes are set automatically."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "502a368f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs4 = hfss.modeler.create_coordinate_system(\n",
+ " name=\"CS4\", origin=[1, 0, 0], reference_cs=\"CS3\", mode=\"view\", view=\"iso\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42c42271",
+ "metadata": {},
+ "source": [
+ "## Create coordinate system by defining axis and angle rotation\n",
+ "\n",
+ "Create a coordinate system by defining the axis and angle rotation. When you\n",
+ "specify the axis and angle rotation, this data is automatically translated\n",
+ "to Euler angles."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "008c0822",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cs5 = hfss.modeler.create_coordinate_system(\n",
+ " name=\"CS5\", mode=\"axisrotation\", u=[1, 0, 0], theta=123\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb44f908",
+ "metadata": {},
+ "source": [
+ "Face coordinate systems are bound to an object face.\n",
+ "First create a box and then define the face coordinate system on one of its\n",
+ "faces. To create the reference face for the face coordinate system, you must\n",
+ "specify starting and ending points for the axis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7a51a41d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "box = hfss.modeler.create_box([0, 0, 0], [2, 2, 2])\n",
+ "face = box.faces[0]\n",
+ "fcs1 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face.edges[0], axis_position=face.edges[1], name=\"FCS1\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "959c3119",
+ "metadata": {},
+ "source": [
+ "Create a face coordinate system centered on the face with the X axis pointing\n",
+ "to the edge vertex."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "04c1db1a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs2 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face, axis_position=face.edges[0].vertices[0], name=\"FCS2\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c40e2b21",
+ "metadata": {},
+ "source": [
+ "Swap the X axis and Y axis of the face coordinate system. The X axis is the\n",
+ "pointing ``axis_position`` by default. You can optionally select the Y axis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ab741f4e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs3 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face, axis_position=face.edges[0], axis=\"Y\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e173e188",
+ "metadata": {},
+ "source": [
+ "The face coordinate system can also be rotated by changing the\n",
+ "reference axis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb69a55c",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "fcs3.props[\"WhichAxis\"] = \"X\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "209b6cea",
+ "metadata": {},
+ "source": [
+ "### Rotate the coordinate system\n",
+ "\n",
+ "Apply a rotation around the Z axis. The Z axis of a face coordinate system\n",
+ "is always orthogonal to the face. A rotation can be applied at definition.\n",
+ "Rotation is expressed in degrees."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "204c8d84",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs4 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face, axis_position=face.edges[1], rotation=10.3\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e25f14a",
+ "metadata": {},
+ "source": [
+ "Rotation can also be changed after coordinate system creation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cd445020",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs4.props[\"ZRotationAngle\"] = \"3deg\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30afb38c",
+ "metadata": {},
+ "source": [
+ "### Offset the coordinate system\n",
+ "\n",
+ "Apply an offset to the X axis and Y axis of a face coordinate system.\n",
+ "The offset is in respect to the face coordinate system itself."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cfe4bfd0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs5 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face, axis_position=face.edges[2], offset=[0.5, 0.3]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ddf7a8ed",
+ "metadata": {},
+ "source": [
+ "The offset can be changed after the coordinate system has been created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a118f052",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fcs5.props[\"XOffset\"] = \"0.2mm\"\n",
+ "fcs5.props[\"YOffset\"] = \"0.1mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a26b2f6",
+ "metadata": {},
+ "source": [
+ "### Create a dependent coordinate system\n",
+ "\n",
+ "The use of dependent coordinate systems can simplify model creation. The following\n",
+ "cell shows how to create a coordinate system whose reference is the face coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fede8210",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "face = box.faces[1]\n",
+ "fcs6 = hfss.modeler.create_face_coordinate_system(\n",
+ " face=face, origin=face, axis_position=face.edges[0]\n",
+ ")\n",
+ "cs_fcs = hfss.modeler.create_coordinate_system(\n",
+ " name=\"CS_FCS\", origin=[0, 0, 0], reference_cs=fcs6.name, mode=\"view\", view=\"iso\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e000fa6d",
+ "metadata": {},
+ "source": [
+ "### Create object coordinate systems\n",
+ "\n",
+ "A coordinate system can also be defined relative to elements\n",
+ "belonging to an object. For example, the coordinate system can be\n",
+ "connected to an object face."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "254186cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj_cs = hfss.modeler.create_object_coordinate_system(\n",
+ " assignment=box,\n",
+ " origin=box.faces[0],\n",
+ " x_axis=box.edges[0],\n",
+ " y_axis=[0, 0, 0],\n",
+ " name=\"box_obj_cs\",\n",
+ ")\n",
+ "obj_cs.rename(\"new_obj_cs\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b235966",
+ "metadata": {},
+ "source": [
+ "Create an object coordinate system whose origin is linked to the edge of an object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a505b05c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj_cs_1 = hfss.modeler.create_object_coordinate_system(\n",
+ " assignment=box.name,\n",
+ " origin=box.edges[0],\n",
+ " x_axis=[1, 0, 0],\n",
+ " y_axis=[0, 1, 0],\n",
+ " name=\"obj_cs_1\",\n",
+ ")\n",
+ "obj_cs_1.set_as_working_cs()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "79468c1a",
+ "metadata": {},
+ "source": [
+ "Create an object coordinate system with an origin specified on a point within an object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e7406b9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj_cs_2 = hfss.modeler.create_object_coordinate_system(\n",
+ " assignment=box.name,\n",
+ " origin=[0, 0.8, 0],\n",
+ " x_axis=[1, 0, 0],\n",
+ " y_axis=[0, 1, 0],\n",
+ " name=\"obj_cs_2\",\n",
+ ")\n",
+ "new_obj_cs_2 = hfss.modeler.duplicate_coordinate_system_to_global(obj_cs_2)\n",
+ "obj_cs_2.delete()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "570ff418",
+ "metadata": {},
+ "source": [
+ "Create an object coordinate system with an origin on the vertex."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af092c0f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj_cs_3 = hfss.modeler.create_object_coordinate_system(\n",
+ " obj=box.name,\n",
+ " origin=box.vertices[1],\n",
+ " x_axis=box.faces[2],\n",
+ " y_axis=box.faces[4],\n",
+ " name=\"obj_cs_3\",\n",
+ ")\n",
+ "obj_cs_3.props[\"MoveToEnd\"] = False\n",
+ "obj_cs_3.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c12699bc",
+ "metadata": {},
+ "source": [
+ "### Get all coordinate systems\n",
+ "\n",
+ "Easily retrieve and subsequently manipulate all coordinate systems."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e94dea78",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "css = hfss.modeler.coordinate_systems\n",
+ "names = [i.name for i in css]\n",
+ "print(names)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9508b21b",
+ "metadata": {},
+ "source": [
+ "## Select coordinate system\n",
+ "\n",
+ "Select an existing coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d89a788f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "css = hfss.modeler.coordinate_systems\n",
+ "cs_selected = css[0]\n",
+ "cs_selected.delete()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53e39bc0",
+ "metadata": {},
+ "source": [
+ "## Get point coordinate under another coordinate system\n",
+ "\n",
+ "Get a point coordinate under another coordinate system. A point coordinate\n",
+ "can be translated in respect to any coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f9828145",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.create_box([-10, -10, -10], [20, 20, 20], \"Box1\")\n",
+ "p = hfss.modeler[\"Box1\"].faces[0].vertices[0].position\n",
+ "print(\"Global: \", p)\n",
+ "p2 = hfss.modeler.global_to_cs(p, \"CS5\")\n",
+ "print(\"CS5 :\", p2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42dfb192",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "Close the project and release AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3afb43ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d.release_desktop()\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a989358",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2929e3f6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/modeler/index.rst.txt b/version/dev/_sources/examples/aedt_general/modeler/index.rst.txt
new file mode 100644
index 00000000..b1884194
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/modeler/index.rst.txt
@@ -0,0 +1,67 @@
+Modeler
+~~~~~~~
+These examples use PyAEDT to show some modeler capabilities.
+
+.. grid:: 2
+
+ .. grid-item-card:: Coordinate system creation
+ :padding: 2 2 2 2
+ :link: coordinate_system
+ :link-type: doc
+
+ .. image:: _static/coordinate_system.png
+ :alt: Coordinate system
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create and modify coordinate systems in the modeler.
+
+
+ .. grid-item-card:: Polyline creation
+ :padding: 2 2 2 2
+ :link: polyline
+ :link-type: doc
+
+ .. image:: _static/polyline.png
+ :alt: Polyline
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create and manipulate polylines.
+
+ .. grid-item-card:: Circuit schematic creation and analysis
+ :padding: 2 2 2 2
+ :link: circuit_schematic
+ :link-type: doc
+
+ .. image:: _static/circuit.png
+ :alt: Circuit
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Circuit Netlist to Schematic
+ :padding: 2 2 2 2
+ :link: netlist_to_schematic
+ :link-type: doc
+
+ .. image:: _static/netlist.png
+ :alt: Netlist
+ :width: 250px
+ :height: 250px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+
+.. toctree::
+ :hidden:
+
+ coordinate_system
+ polyline
+ circuit_schematic
+ netlist_to_schematic
diff --git a/version/dev/_sources/examples/aedt_general/modeler/netlist_to_schematic.ipynb.txt b/version/dev/_sources/examples/aedt_general/modeler/netlist_to_schematic.ipynb.txt
new file mode 100644
index 00000000..f24ce5c1
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/modeler/netlist_to_schematic.ipynb.txt
@@ -0,0 +1,207 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "71f53177",
+ "metadata": {},
+ "source": [
+ "# Circuit Netlist to Schematic\n",
+ "\n",
+ "This example shows how to create components\n",
+ "in the circuit schematic editor from a netlist file.\n",
+ "\n",
+ "Note that HSPICE files are fully supported and that broad coverage is provided for many other formats.\n",
+ "\n",
+ "Keywords: **Circuit**, **netlist**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22fe7b1d",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "285f39c3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a4dc0b3c",
+ "metadata": {},
+ "source": [
+ "## Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e8f6a2d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "905bd882",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "84601239",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6f8bc1a",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with Circuit\n",
+ "\n",
+ "Launch AEDT with Circuit. The `ansys.aedt.core.Desktop` class initializes AEDT\n",
+ "and starts it on the specified version in the specified graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "05bb52f7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "netlist = ansys.aedt.core.downloads.download_netlist(destination=temp_folder.name)\n",
+ "circuit = ansys.aedt.core.Circuit(\n",
+ " project=os.path.join(temp_folder.name, \"NetlistExample\"),\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4cb2064b",
+ "metadata": {},
+ "source": [
+ "## Define a parameter\n",
+ "\n",
+ "Specify the voltage as a parameter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "36cc6210",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit[\"Voltage\"] = \"5\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ffa36466",
+ "metadata": {},
+ "source": [
+ "## Create schematic from netlist file\n",
+ "\n",
+ "Create a schematic from a netlist file. The ``create_schematic_from_netlist()``\n",
+ "method reads the netlist file and parses it. All components are parsed,\n",
+ "but only these categories are mapped: R, L, C, Q, U, J, V, and I."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8291a87c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.create_schematic_from_netlist(netlist)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3c49d141",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0490d447",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()\n",
+ "circuit.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "030d1716",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ca570476",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/modeler/polyline.ipynb.txt b/version/dev/_sources/examples/aedt_general/modeler/polyline.ipynb.txt
new file mode 100644
index 00000000..5973ecf4
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/modeler/polyline.ipynb.txt
@@ -0,0 +1,754 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "cb481a38",
+ "metadata": {},
+ "source": [
+ "# Polyline creation\n",
+ "\n",
+ "This example shows how to use PyAEDT to create and manipulate polylines.\n",
+ "\n",
+ "Keywords: **AEDT**, **modeler**, **polyline**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eec8e5be",
+ "metadata": {},
+ "source": [
+ "## Import packages and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "40d45015",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5801f8c2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9ceea99",
+ "metadata": {},
+ "source": [
+ "Define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4e2af8ec",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3339c701",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee02b4f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b38eb2ed",
+ "metadata": {},
+ "source": [
+ "## Create Maxwell 3D object\n",
+ "\n",
+ "Create a `Maxwell3d` object and set the unit type to ``\"mm\"``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "60e793d8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"polyline.aedt\")\n",
+ "maxwell = ansys.aedt.core.Maxwell3d(\n",
+ " project=project_name,\n",
+ " solution_type=\"Transient\",\n",
+ " design=\"test_polyline_3D\",\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")\n",
+ "maxwell.modeler.model_units = \"mm\"\n",
+ "modeler = maxwell.modeler"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7cf2f2d6",
+ "metadata": {},
+ "source": [
+ "## Define variables\n",
+ "\n",
+ "Define two design variables as parameters for the polyline objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b47a5f4a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "maxwell[\"p1\"] = \"100mm\"\n",
+ "maxwell[\"p2\"] = \"71mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1860d541",
+ "metadata": {},
+ "source": [
+ "## Input data\n",
+ "\n",
+ "Input data. All data for the polyline functions can be entered as either floating point\n",
+ "values or strings. Floating point values are assumed to be in model units\n",
+ "(``maxwell.modeler.model_units``)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e60f3c16",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "test_points = [\n",
+ " [\"0mm\", \"p1\", \"0mm\"],\n",
+ " [\"-p1\", \"0mm\", \"0mm\"],\n",
+ " [\"-p1/2\", \"-p1/2\", \"0mm\"],\n",
+ " [\"0mm\", \"0mm\", \"0mm\"],\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12ff46e4",
+ "metadata": {},
+ "source": [
+ "## Create polyline primitives\n",
+ "\n",
+ "The following examples are for creating polyline primitives."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a064425",
+ "metadata": {},
+ "source": [
+ "### Create line primitive\n",
+ "\n",
+ "Create a line primitive. The basic polyline command takes a list of positions\n",
+ "(``[X, Y, Z]`` coordinates) and creates a polyline object with one or more\n",
+ "segments. The supported segment types are ``Line``, ``Arc`` (3 points),\n",
+ "``AngularArc`` (center-point + angle), and ``Spline``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2fd6244c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line1 = modeler.create_polyline(points=test_points[0:2], name=\"PL01_line\")\n",
+ "print(\"Created Polyline with name: {}\".format(modeler.objects[line1.id].name))\n",
+ "print(\"Segment types : {}\".format([s.type for s in line1.segment_types]))\n",
+ "print(\"primitive id = {}\".format(line1.id))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e3fcb3f3",
+ "metadata": {},
+ "source": [
+ "### Create arc primitive\n",
+ "\n",
+ "Create an arc primitive. The ``position_list`` parameter must contain at\n",
+ "least three position values. The first three position values are used."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "054b91e2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line2 = modeler.create_polyline(\n",
+ " points=test_points[0:3], segment_type=\"Arc\", name=\"PL02_arc\"\n",
+ ")\n",
+ "print(\n",
+ " \"Created object with id {} and name {}.\".format(\n",
+ " line2.id, modeler.objects[line2.id].name\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "463253c9",
+ "metadata": {},
+ "source": [
+ "### Create spline primitive\n",
+ "\n",
+ "Create a spline primitive. Defining the segment using a ``PolylineSegment``\n",
+ "object allows you to provide additional input parameters for the spine, such\n",
+ "as the number of points (in this case 4). The ``points`` parameter\n",
+ "must contain at least four position values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88fa3701",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line3 = modeler.create_polyline(\n",
+ " points=test_points,\n",
+ " segment_type=modeler.polyline_segment(\"Spline\", num_points=4),\n",
+ " name=\"PL03_spline_4pt\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b15556a",
+ "metadata": {},
+ "source": [
+ "### Create center-point arc primitive\n",
+ "\n",
+ "Create a center-point arc primitive. A center-point arc segment is defined\n",
+ "by a starting point, a center point, and an angle of rotation around the\n",
+ "center point. The rotation occurs in a plane parallel to the XY, YZ, or ZX\n",
+ "plane of the active coordinate system. The starting point and the center point\n",
+ "must therefore have one coordinate value (X, Y, or Z) with the same value.\n",
+ "\n",
+ "In this first code example, ``start-point`` and ``center-point`` have a common\n",
+ "Z position, ``\"0mm\"``. The curve therefore lies in the XY plane at $ z = 0 $."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e62d54f4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "start_point = [100, 100, 0]\n",
+ "center_point = [0, 0, 0]\n",
+ "line4 = modeler.create_polyline(\n",
+ " points=[start_point],\n",
+ " segment_type=modeler.polyline_segment(\n",
+ " \"AngularArc\", arc_center=center_point, arc_angle=\"30deg\"\n",
+ " ),\n",
+ " name=\"PL04_center_point_arc\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "07fc9211",
+ "metadata": {},
+ "source": [
+ "In this second code example, ``start_point`` and ``center_point`` have the same\n",
+ "values for the Y and Z coordinates, so the plane or rotation could be either XY or ZX.\n",
+ "For these special cases when the rotation plane is ambiguous, you can specify\n",
+ "the plane explicitly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d986d41e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "start_point = [100, 0, 0]\n",
+ "center_point = [0, 0, 0]\n",
+ "line4_xy = modeler.create_polyline(\n",
+ " points=[start_point],\n",
+ " segment_type=modeler.polyline_segment(\n",
+ " \"AngularArc\", arc_center=center_point, arc_angle=\"30deg\", arc_plane=\"XY\"\n",
+ " ),\n",
+ " name=\"PL04_center_point_arc_rot_XY\",\n",
+ ")\n",
+ "line4_zx = modeler.create_polyline(\n",
+ " points=[start_point],\n",
+ " segment_type=modeler.polyline_segment(\n",
+ " \"AngularArc\", arc_center=center_point, arc_angle=\"30deg\", arc_plane=\"ZX\"\n",
+ " ),\n",
+ " name=\"PL04_center_point_arc_rot_ZX\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3c6871a",
+ "metadata": {},
+ "source": [
+ "## Create compound polylines\n",
+ "\n",
+ "You can pass a list of points to the ``create_polyline()`` method to create a multi-segment\n",
+ "polyline.\n",
+ "\n",
+ "If the type of segment is not specified, all points\n",
+ "are connected by straight line segments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "79b6e69c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line6 = modeler.create_polyline(points=test_points, name=\"PL06_segmented_compound_line\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c89ca1b5",
+ "metadata": {},
+ "source": [
+ "You can specify the segment type as an optional named argument to\n",
+ "define the segment type used to connect the points."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a75c82d7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line5 = modeler.create_polyline(\n",
+ " points=test_points, segment_type=[\"Line\", \"Arc\"], name=\"PL05_compound_line_arc\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2204a104",
+ "metadata": {},
+ "source": [
+ "Setting the named argument ``close_surface=True`` ensures\n",
+ "that the polyline starting point and\n",
+ "ending point are the same. You can also explicitly close the\n",
+ "polyline by setting the last point equal\n",
+ "to the first point in the list of points."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4f417131",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line7 = modeler.create_polyline(\n",
+ " points=test_points, close_surface=True, name=\"PL07_segmented_compound_line_closed\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e3407cb",
+ "metadata": {},
+ "source": [
+ "Setting the named argument ``cover_surface=True`` also\n",
+ "covers the polyline and creates a sheet object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5c14cc82",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line_cover = modeler.create_polyline(\n",
+ " points=test_points, cover_surface=True, name=\"SPL01_segmented_compound_line\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1567168e",
+ "metadata": {},
+ "source": [
+ "## Insert compound lines\n",
+ "\n",
+ "The following examples are for inserting compound lines.\n",
+ "\n",
+ "### Insert line segment\n",
+ "\n",
+ "Insert a line segment starting at vertex 1 ``[\"100mm\", \"0mm\", \"0mm\"]``\n",
+ "of an existing polyline and ending at some new point ``[\"90mm\", \"20mm\", \"0mm\"].``\n",
+ "By numerical comparison of the starting point with the existing vertices of the\n",
+ "original polyline object, it is determined automatically that the segment is\n",
+ "inserted after the first segment of the original polyline."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5cb0262b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line8_segment = modeler.create_polyline(\n",
+ " points=test_points,\n",
+ " close_surface=True,\n",
+ " name=\"PL08_segmented_compound_insert_segment\",\n",
+ ")\n",
+ "points_line8_segment = line8_segment.points[1]\n",
+ "insert_point = [\"-100mm\", \"20mm\", \"0mm\"]\n",
+ "line8_segment.insert_segment(points=[insert_point, points_line8_segment])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f8d244d1",
+ "metadata": {},
+ "source": [
+ "### Insert compound line with insert curve\n",
+ "\n",
+ "Insert a compound line starting a line segment at vertex 1 ``[\"100mm\", \"0mm\", \"0mm\"]``\n",
+ "of an existing polyline and ending at some new point ``[\"90mm\", \"20mm\", \"0mm\"]``.\n",
+ "By numerical comparison of the starting point, it is determined automatically\n",
+ "that the segment is inserted after the first segment of the original polyline."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "71bb3218",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line8_segment_arc = modeler.create_polyline(\n",
+ " points=test_points, close_surface=False, name=\"PL08_segmented_compound_insert_arc\"\n",
+ ")\n",
+ "\n",
+ "start_point = line8_segment_arc.vertex_positions[1]\n",
+ "insert_point1 = [\"90mm\", \"20mm\", \"0mm\"]\n",
+ "insert_point2 = [40, 40, 0]\n",
+ "\n",
+ "line8_segment_arc.insert_segment(\n",
+ " points=[start_point, insert_point1, insert_point2], segment=\"Arc\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "55873040",
+ "metadata": {},
+ "source": [
+ "### Insert compound line at end of a center-point arc\n",
+ "\n",
+ "Insert a compound line at the end of a center-point arc (``type=\"AngularArc\"``).\n",
+ "This is a special case.\n",
+ "\n",
+ "Step 1: Draw a center-point arc."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "16845092",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "start_point = [2200.0, 0.0, 1200.0]\n",
+ "arc_center_1 = [1400, 0, 800]\n",
+ "arc_angle_1 = \"43.47deg\"\n",
+ "\n",
+ "line_arc = modeler.create_polyline(\n",
+ " name=\"First_Arc\",\n",
+ " points=[start_point],\n",
+ " segment_type=modeler.polyline_segment(\n",
+ " type=\"AngularArc\", arc_angle=arc_angle_1, arc_center=arc_center_1\n",
+ " ),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80994fb",
+ "metadata": {},
+ "source": [
+ "Step 2: Insert a line segment at the end of the arc with a specified end point."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53cf9a02",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "start_of_line_segment = line_arc.end_point\n",
+ "end_of_line_segment = [3600, 200, 30]\n",
+ "line_arc.insert_segment(points=[start_of_line_segment, end_of_line_segment])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "831e6c4a",
+ "metadata": {},
+ "source": [
+ "Step 3: Append a center-point arc segment to the line object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7003986a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "arc_angle_2 = \"39.716deg\"\n",
+ "arc_center_2 = [3400, 200, 3800]\n",
+ "line_arc.insert_segment(\n",
+ " points=[end_of_line_segment],\n",
+ " segment=modeler.polyline_segment(\n",
+ " type=\"AngularArc\", arc_center=arc_center_2, arc_angle=arc_angle_2\n",
+ " ),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73d9259e",
+ "metadata": {},
+ "source": [
+ "You can use the compound polyline definition to complete all three steps in\n",
+ "a single step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "350b01ab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "modeler.create_polyline(\n",
+ " points=[start_point, end_of_line_segment],\n",
+ " segment_type=[\n",
+ " modeler.polyline_segment(\n",
+ " type=\"AngularArc\", arc_angle=\"43.47deg\", arc_center=arc_center_1\n",
+ " ),\n",
+ " modeler.polyline_segment(type=\"Line\"),\n",
+ " modeler.polyline_segment(\n",
+ " type=\"AngularArc\", arc_angle=arc_angle_2, arc_center=arc_center_2\n",
+ " ),\n",
+ " ],\n",
+ " name=\"Compound_Polyline_One_Command\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b4aadd7",
+ "metadata": {},
+ "source": [
+ "## Insert two 3-point arcs forming a circle\n",
+ "\n",
+ "Insert two 3-point arcs forming a circle.\n",
+ "Note that the last point of the second arc segment is not defined in\n",
+ "the position list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fd395ac7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line_three_points = modeler.create_polyline(\n",
+ " points=[\n",
+ " [34.1004, 14.1248, 0],\n",
+ " [27.646, 16.7984, 0],\n",
+ " [24.9725, 10.3439, 0],\n",
+ " [31.4269, 7.6704, 0],\n",
+ " ],\n",
+ " segment_type=[\"Arc\", \"Arc\"],\n",
+ " cover_surface=True,\n",
+ " close_surface=True,\n",
+ " name=\"line_covered\",\n",
+ " material=\"vacuum\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b22147d2",
+ "metadata": {},
+ "source": [
+ "Here is an example of a complex polyline where the number of points is\n",
+ "insufficient to populate the requested segments. This results in an\n",
+ "``IndexError`` that PyAEDT catches silently. The return value of the command\n",
+ "is ``False``, which can be caught at the app level. While this example might\n",
+ "not be so useful in a Jupyter Notebook, it is important for unit tests."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7bd89ffc",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "line_points = [\n",
+ " [\"67.1332mm\", \"2.9901mm\", \"0mm\"],\n",
+ " [\"65.9357mm\", \"2.9116mm\", \"0mm\"],\n",
+ " [\"65.9839mm\", \"1.4562mm\", \"0mm\"],\n",
+ " [\"66mm\", \"0mm\", \"0mm\"],\n",
+ " [\"99mm\", \"0mm\", \"0mm\"],\n",
+ " [\"98.788mm\", \"6.4749mm\", \"0mm\"],\n",
+ " [\"98.153mm\", \"12.9221mm\", \"0mm\"],\n",
+ " [\"97.0977mm\", \"19.3139mm\", \"0mm\"],\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "daed3e74",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line_segments = [\"Line\", \"Arc\", \"Line\", \"Arc\", \"Line\"]\n",
+ "line_complex1 = modeler.create_polyline(\n",
+ " points=line_points, segment_type=line_segments, name=\"Polyline_example\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1fa4ba0f",
+ "metadata": {},
+ "source": [
+ "Here is an example that provides more points than the segment list requires.\n",
+ "This is valid usage. The remaining points are ignored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d291cc16",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line_segments = [\"Line\", \"Arc\", \"Line\", \"Arc\"]\n",
+ "line_complex2 = modeler.create_polyline(\n",
+ " line_points, segment_type=line_segments, name=\"Polyline_example2\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3ab4d869",
+ "metadata": {},
+ "source": [
+ "## Save project\n",
+ "\n",
+ "Save the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "483c9ba1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "maxwell.save_project()\n",
+ "maxwell.release_desktop()\n",
+ "time.sleep(3) # Allow AEDT to shut down before cleaning the temporary project folder."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dadc5011",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aaee0729",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/optimetrics.ipynb.txt b/version/dev/_sources/examples/aedt_general/optimetrics.ipynb.txt
new file mode 100644
index 00000000..c6ec1a85
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/optimetrics.ipynb.txt
@@ -0,0 +1,410 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "b46082c1",
+ "metadata": {},
+ "source": [
+ "# Optimetrics setup\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a project in HFSS and create all optimetrics\n",
+ "setups.\n",
+ "\n",
+ "Keywords: **AEDT**, **General**, **optimetrics**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bce4154b",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c404d44c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "73f9be52",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c81dde65",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a24bd2b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd362e3e",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8cd631f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ad2ba67",
+ "metadata": {},
+ "source": [
+ "## Initialize HFSS and create variables\n",
+ "\n",
+ "Initialize the ``Hfss`` object and create two needed design variables,\n",
+ "``w1`` and ``w2``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "02f6b8e2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"optimetrics.aedt\")\n",
+ "\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ " solution_type=\"Modal\",\n",
+ ")\n",
+ "\n",
+ "hfss[\"w1\"] = \"1mm\"\n",
+ "hfss[\"w2\"] = \"100mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1f839152",
+ "metadata": {},
+ "source": [
+ "## Create waveguide with sheets on it\n",
+ "\n",
+ "Create one of the standard waveguide structures and parametrize it.\n",
+ "You can also create rectangles of waveguide openings and assign ports later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "113645f4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wg1, p1, p2 = hfss.modeler.create_waveguide(\n",
+ " [0, 0, 0],\n",
+ " hfss.AXIS.Y,\n",
+ " \"WG17\",\n",
+ " wg_thickness=\"w1\",\n",
+ " wg_length=\"w2\",\n",
+ " create_sheets_on_openings=True,\n",
+ ")\n",
+ "\n",
+ "model = hfss.plot(show=False)\n",
+ "\n",
+ "model.show_grid = False\n",
+ "model.plot(os.path.join(hfss.working_directory, \"Image.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "70b6feb0",
+ "metadata": {},
+ "source": [
+ "## Create wave ports on sheets\n",
+ "\n",
+ "Create two wave ports on the sheets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "044f0adb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.wave_port(p1, integration_line=hfss.AxisDir.ZPos, name=\"1\")\n",
+ "hfss.wave_port(p2, integration_line=hfss.AxisDir.ZPos, name=\"2\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcf86371",
+ "metadata": {},
+ "source": [
+ "## Create setup and frequency sweep\n",
+ "\n",
+ "Create a setup and a frequency sweep to use as the base for optimetrics\n",
+ "setups."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53c47c9c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup()\n",
+ "hfss.create_linear_step_sweep(\n",
+ " setup=setup.name,\n",
+ " unit=\"GHz\",\n",
+ " start_frequency=1,\n",
+ " stop_frequency=5,\n",
+ " step_size=0.1,\n",
+ " name=\"Sweep1\",\n",
+ " save_fields=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b1fdf779",
+ "metadata": {},
+ "source": [
+ "## Create optimetrics analyses\n",
+ "\n",
+ "### Create parametric analysis\n",
+ "\n",
+ "Create a simple optimetrics parametrics analysis with output calculations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7dddf513",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep = hfss.parametrics.add(\"w2\", 90, 200, 5)\n",
+ "sweep.add_variation(\"w1\", 0.1, 2, 10)\n",
+ "sweep.add_calculation(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.5GHz\"})\n",
+ "sweep.add_calculation(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.6GHz\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b29b97db",
+ "metadata": {},
+ "source": [
+ "### Create sensitivity analysis\n",
+ "\n",
+ "Create an optimetrics sensitivity analysis with output calculations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a6e68484",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep2 = hfss.optimizations.add(\n",
+ " calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.5GHz\"}, optimization_type=\"Sensitivity\"\n",
+ ")\n",
+ "sweep2.add_variation(\"w1\", 0.1, 3, 0.5)\n",
+ "sweep2.add_calculation(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.6GHz\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe967c17",
+ "metadata": {},
+ "source": [
+ "### Create an optimization analysis\n",
+ "\n",
+ "Create an optimization analysis based on goals and calculations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "17237722",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep3 = hfss.optimizations.add(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.5GHz\"})\n",
+ "sweep3.add_variation(\"w1\", 0.1, 3, 0.5)\n",
+ "sweep3.add_goal(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.6GHz\"})\n",
+ "sweep3.add_goal(calculation=\"dB(S(1,1))\", ranges={\"Freq\": (\"2.6GHz\", \"5GHz\")})\n",
+ "sweep3.add_goal(\n",
+ " calculation=\"dB(S(1,1))\",\n",
+ " ranges={\"Freq\": (\"2.6GHz\", \"5GHz\")},\n",
+ " condition=\"Maximize\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd982e3f",
+ "metadata": {},
+ "source": [
+ "### Create a DesignXplorer optimization\n",
+ "\n",
+ "Create a DesignXplorer optimization based on a goal and a calculation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d51077d8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep4 = hfss.optimizations.add(\n",
+ " calculation=\"dB(S(1,1))\",\n",
+ " ranges={\"Freq\": \"2.5GHz\"},\n",
+ " optimization_type=\"DesignExplorer\",\n",
+ ")\n",
+ "sweep4.add_goal(calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.6GHz\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5dce746b",
+ "metadata": {},
+ "source": [
+ "### Create a Design of Experiments (DOE)\n",
+ "\n",
+ "Create a DOE based on a goal and a calculation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "401a17d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep5 = hfss.optimizations.add(\n",
+ " calculation=\"dB(S(1,1))\", ranges={\"Freq\": \"2.5GHz\"}, optimization_type=\"DXDOE\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "93fd413b",
+ "metadata": {},
+ "source": [
+ "### Create another DOE\n",
+ "\n",
+ "Create another DOE based on a goal and a calculation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da373329",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = hfss.modeler.create_region()\n",
+ "hfss.assign_radiation_boundary_to_objects(region)\n",
+ "hfss.insert_infinite_sphere(name=\"Infinite_1\")\n",
+ "sweep6 = hfss.optimizations.add(\n",
+ " calculation=\"RealizedGainTotal\",\n",
+ " solution=hfss.nominal_adaptive,\n",
+ " ranges={\"Freq\": \"5GHz\", \"Theta\": [\"0deg\", \"10deg\", \"20deg\"], \"Phi\": \"0deg\"},\n",
+ " context=\"Infinite_1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88e16765",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "850eebea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "time.sleep(3) # Allow AEDT to shut down before cleaning the temporary project folder."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "527ccb06",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48f8686c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/report/automatic_report.ipynb.txt b/version/dev/_sources/examples/aedt_general/report/automatic_report.ipynb.txt
new file mode 100644
index 00000000..e891791f
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/report/automatic_report.ipynb.txt
@@ -0,0 +1,321 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "9ee12c45",
+ "metadata": {},
+ "source": [
+ "# Automatic report creation\n",
+ "\n",
+ "This example shows how to create reports from a JSON template file.\n",
+ "\n",
+ "\n",
+ "Keywords: **Circuit**, **report**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e07ccd79",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Import the required packages. This example uses\n",
+ "data from the [example-data repository](https://github.com/ansys/example-data/tree/master)\n",
+ "located in ``pyaedt\\custom_reports``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ffad5fb1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n",
+ "from IPython.display import Image\n",
+ "\n",
+ "# Define constants.\n",
+ "\n",
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched.\n",
+ "\n",
+ "# ## Create temporary directory\n",
+ "#\n",
+ "# Create a temporary directory where downloaded data or\n",
+ "# dumped data can be stored.\n",
+ "# If you'd like to retrieve the project data for subsequent use,\n",
+ "# the temporary folder name is given by ``temp_folder.name``.\n",
+ "\n",
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "\n",
+ "# ## Launch AEDT with Circuit\n",
+ "#\n",
+ "# AEDT is started by instantiating an instance of\n",
+ "# [pyaedt.Circuit](https://aedt.docs.pyansys.com/version/stable/API/_autosummary/pyaedt.circuit.Circuit.html).\n",
+ "#\n",
+ "# ### Application keyword arguments\n",
+ "#\n",
+ "# - The argument ``non_graphical`` specifies whether an interactive session is launched or if\n",
+ "# AEDT is to run in non-graphical mode.\n",
+ "# - The Boolean parameter ``new_desktop`` specifies if a new instance\n",
+ "# of AEDT is launched. If it is set to ``False``, the API tries to connect to a running session.\n",
+ "#\n",
+ "# This example extracts an archived project. The full path\n",
+ "# to the extracted project is accessible from the ``cir.project_file`` property."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb4e0f85",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_path = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"custom_reports/\", destination=temp_folder.name\n",
+ ")\n",
+ "\n",
+ "circuit = ansys.aedt.core.Circuit(\n",
+ " project=os.path.join(project_path, \"CISPR25_Radiated_Emissions_Example23R1.aedtz\"),\n",
+ " non_graphical=NG_MODE,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "circuit.analyze() # Run the circuit analysis."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4c27c923",
+ "metadata": {},
+ "source": [
+ "## Create a spectral report\n",
+ "\n",
+ "The JSON file is used to customize the report. In a spectral report, you can add limit lines. You can also\n",
+ "add notes to a report and modify the axes, grid, and legend. Custom reports\n",
+ "can be created in AEDT in non-graphical mode using version 2023 R2 and later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0cb63d01",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report1 = circuit.post.create_report_from_configuration(\n",
+ " os.path.join(project_path, \"Spectrum_CISPR_Basic.json\")\n",
+ ")\n",
+ "out = circuit.post.export_report_to_jpg(\n",
+ " project_path=circuit.working_directory, plot_name=report1.plot_name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a74b793a",
+ "metadata": {},
+ "source": [
+ "Render the image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1b5dfdd8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "Image(os.path.join(circuit.working_directory, report1.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8d65a98e",
+ "metadata": {},
+ "source": [
+ "You can customize every aspect of the report. The method ``crate_report_from_configuration()`` reads the\n",
+ "report configuration from a JSON file and generates the custom report."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "536b42ed",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report1_full = circuit.post.create_report_from_configuration(\n",
+ " os.path.join(project_path, \"Spectrum_CISPR_Custom.json\")\n",
+ ")\n",
+ "out = circuit.post.export_report_to_jpg(\n",
+ " circuit.working_directory, report1_full.plot_name\n",
+ ")\n",
+ "Image(os.path.join(circuit.working_directory, report1_full.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "caaf2146",
+ "metadata": {},
+ "source": [
+ "## Create a transient report\n",
+ "\n",
+ "The JSON configuration file can be read and modified from the API prior to creating the report.\n",
+ "The following code modifies the trace rendering prior to creating the report."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6564f187",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "props = ansys.aedt.core.general_methods.read_json(\n",
+ " os.path.join(project_path, \"Transient_CISPR_Custom.json\")\n",
+ ")\n",
+ "\n",
+ "report2 = circuit.post.create_report_from_configuration(\n",
+ " report_settings=props, solution_name=\"NexximTransient\"\n",
+ ")\n",
+ "out = circuit.post.export_report_to_jpg(circuit.working_directory, report2.plot_name)\n",
+ "Image(os.path.join(circuit.working_directory, report2.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adb1febf",
+ "metadata": {},
+ "source": [
+ "The ``props`` dictionary can be used to customize any aspect of an existing report or generate a new report.\n",
+ "In this example, the name of the curve is customized."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "043b50dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "props[\"expressions\"] = {\"V(Battery)\": {}, \"V(U1_VDD)\": {}}\n",
+ "props[\"plot_name\"] = \"Battery Voltage\"\n",
+ "report3 = circuit.post.create_report_from_configuration(\n",
+ " report_settings=props, solution_name=\"NexximTransient\"\n",
+ ")\n",
+ "out = circuit.post.export_report_to_jpg(circuit.working_directory, report3.plot_name)\n",
+ "Image(os.path.join(circuit.working_directory, report3.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "315e2545",
+ "metadata": {},
+ "source": [
+ "## Create an eye diagram\n",
+ "\n",
+ "You can use the JSON file to create an eye diagram. The following code includes the eye."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1a01547",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report4 = circuit.post.create_report_from_configuration(\n",
+ " os.path.join(project_path, \"EyeDiagram_CISPR_Basic.json\")\n",
+ ")\n",
+ "out = circuit.post.export_report_to_jpg(circuit.working_directory, report4.plot_name)\n",
+ "Image(os.path.join(circuit.working_directory, report4.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1aca9ddf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report4_full = circuit.post.create_report_from_configuration(\n",
+ " os.path.join(project_path, \"EyeDiagram_CISPR_Custom.json\")\n",
+ ")\n",
+ "\n",
+ "out = circuit.post.export_report_to_jpg(\n",
+ " circuit.working_directory, report4_full.plot_name\n",
+ ")\n",
+ "Image(os.path.join(circuit.working_directory, report4_full.plot_name + \".jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76d853df",
+ "metadata": {},
+ "source": [
+ "## Save project and close AEDT\n",
+ "\n",
+ "Save the project and close AEDT. The example has finished running. You can retrieve project files\n",
+ "from ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d17058f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()\n",
+ "print(\"Project Saved in {}\".format(circuit.project_path))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7efeab4b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.release_desktop()\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1107dfa6",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "The following cell cleans up the temporary directory and\n",
+ "removes all project files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "10228dc3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/report/index.rst.txt b/version/dev/_sources/examples/aedt_general/report/index.rst.txt
new file mode 100644
index 00000000..fe31a0b1
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/report/index.rst.txt
@@ -0,0 +1,52 @@
+Report
+~~~~~~
+
+These examples use PyAEDT to show some report capabilities.
+
+.. grid:: 2
+
+ .. grid-item-card:: PCIE virtual compliance
+ :padding: 2 2 2 2
+ :link: virtual_compliance
+ :link-type: doc
+
+ .. image:: _static/virtual_compliance_eye.png
+ :alt: Virtual compliance
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to generate a compliance report in PyAEDT using the VirtualCompliance class.
+
+ .. grid-item-card:: Touchstone files
+ :padding: 2 2 2 2
+ :link: touchstone_file
+ :link-type: doc
+
+ .. image:: _static/touchstone_skitrf.png
+ :alt: Touchstone file
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use objects in a Touchstone file without opening AEDT.
+
+ .. grid-item-card:: Automatic report creation
+ :padding: 2 2 2 2
+ :link: automatic_report
+ :link-type: doc
+
+ .. image:: _static/automatic_report.png
+ :alt: Automatic report
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create reports from a JSON template file.
+
+.. toctree::
+ :hidden:
+
+ virtual_compliance
+ touchstone_file
+ automatic_report
diff --git a/version/dev/_sources/examples/aedt_general/report/touchstone_file.ipynb.txt b/version/dev/_sources/examples/aedt_general/report/touchstone_file.ipynb.txt
new file mode 100644
index 00000000..48fe0eb1
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/report/touchstone_file.ipynb.txt
@@ -0,0 +1,154 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4d0a528f",
+ "metadata": {},
+ "source": [
+ "# Touchstone files\n",
+ "\n",
+ "This example shows how to use objects in a Touchstone file without opening AEDT.\n",
+ "\n",
+ "To provide the advanced postprocessing features needed for this example, Matplotlib and NumPy\n",
+ "must be installed on your machine.\n",
+ "\n",
+ "This example runs only on Windows using CPython.\n",
+ "\n",
+ "Keywords: **Touchstone**, **report**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e52a4411",
+ "metadata": {},
+ "source": [
+ "## Perform imports\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "730f89fb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import downloads\n",
+ "from ansys.aedt.core.visualization.advanced.touchstone_parser import \\\n",
+ " read_touchstone"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f2b5ebf0",
+ "metadata": {},
+ "source": [
+ "## Download example data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ed354134",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "example_path = downloads.download_touchstone()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e45c526",
+ "metadata": {},
+ "source": [
+ "## Read the Touchstone file"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e2ee151c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = read_touchstone(example_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aaa83af1",
+ "metadata": {},
+ "source": [
+ "## Plot data\n",
+ "\n",
+ "Get the curve plot by category. The following code shows how to plot lists of the return losses,\n",
+ "insertion losses, next, and fext based on a few inputs and port names."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a9af705",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data.plot_return_losses()\n",
+ "data.plot_insertion_losses()\n",
+ "data.plot_next_xtalk_losses(\"U1\")\n",
+ "data.plot_fext_xtalk_losses(tx_prefix=\"U1\", rx_prefix=\"U7\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "196e5124",
+ "metadata": {},
+ "source": [
+ "## Identify cross-talk\n",
+ "\n",
+ "Identify the worst case cross-talk."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bceb65e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "worst_rl, global_mean = data.get_worst_curve(\n",
+ " freq_min=1,\n",
+ " freq_max=20,\n",
+ " worst_is_higher=True,\n",
+ " curve_list=data.get_return_loss_index(),\n",
+ ")\n",
+ "worst_il, mean2 = data.get_worst_curve(\n",
+ " freq_min=1,\n",
+ " freq_max=20,\n",
+ " worst_is_higher=False,\n",
+ " curve_list=data.get_insertion_loss_index(),\n",
+ ")\n",
+ "worst_fext, mean3 = data.get_worst_curve(\n",
+ " freq_min=1,\n",
+ " freq_max=20,\n",
+ " worst_is_higher=True,\n",
+ " curve_list=data.get_fext_xtalk_index_from_prefix(tx_prefix=\"U1\", rx_prefix=\"U7\"),\n",
+ ")\n",
+ "worst_next, mean4 = data.get_worst_curve(\n",
+ " freq_min=1,\n",
+ " freq_max=20,\n",
+ " worst_is_higher=True,\n",
+ " curve_list=data.get_next_xtalk_index(\"U1\"),\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/aedt_general/report/virtual_compliance.ipynb.txt b/version/dev/_sources/examples/aedt_general/report/virtual_compliance.ipynb.txt
new file mode 100644
index 00000000..c6be99e7
--- /dev/null
+++ b/version/dev/_sources/examples/aedt_general/report/virtual_compliance.ipynb.txt
@@ -0,0 +1,496 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "053977ea",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "# PCIE virtual compliance\n",
+ "\n",
+ "This example shows how to generate a compliance report in PyAEDT using\n",
+ "the ``VirtualCompliance`` class.\n",
+ "\n",
+ "Keywords: **Circuit**, **Automatic report**, **virtual compliance**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b9f88c6",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee8889ad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os.path\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3232a161",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.visualization.post.compliance import VirtualCompliance"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6073c7f",
+ "metadata": {},
+ "source": [
+ "## Define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a612324a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38616916",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored. In this example, the temporary directory\n",
+ "in where the example is stored and simulation data is saved.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8b1cc552",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "00dd7f6a",
+ "metadata": {},
+ "source": [
+ "## Download example data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee08c572",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "download_folder = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"pcie_compliance\", destination=temp_folder.name\n",
+ ")\n",
+ "project_folder = os.path.join(download_folder, \"project\")\n",
+ "project_path = os.path.join(project_folder, \"PCIE_GEN5_only_layout.aedtz\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1d285122",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and solve layout\n",
+ "\n",
+ "Open the HFSS 3D Layout project and analyze it using the SIwave solver.\n",
+ "Before solving, this code ensures that the model is solved from DC to 70GHz and that\n",
+ "causality and passivity are enforced."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "79c908f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d = ansys.aedt.core.Hfss3dLayout(\n",
+ " project=project_path, version=AEDT_VERSION, non_graphical=NG_MODE\n",
+ ")\n",
+ "h3d.remove_all_unused_definitions()\n",
+ "h3d.edit_cosim_options(simulate_missing_solution=False)\n",
+ "h3d.setups[0].sweeps[0].props[\"EnforcePassivity\"] = True\n",
+ "h3d.setups[0].sweeps[0].props[\"Sweeps\"][\"Data\"] = \"LIN 0MHz 70GHz 0.1GHz\"\n",
+ "h3d.setups[0].sweeps[0].props[\"EnforceCausality\"] = True\n",
+ "h3d.setups[0].sweeps[0].update()\n",
+ "h3d.analyze(cores=NUM_CORES)\n",
+ "h3d = ansys.aedt.core.Hfss3dLayout()\n",
+ "touchstone_path = h3d.export_touchstone()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0129a1f8",
+ "metadata": {},
+ "source": [
+ "## Create LNA project\n",
+ "\n",
+ "Use the LNA (linear network analysis) setup to retrieve Touchstone files\n",
+ "and generate frequency domain reports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "45cff16e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit = ansys.aedt.core.Circuit(project=h3d.project_name, design=\"Touchstone\")\n",
+ "status, diff_pairs, comm_pairs = circuit.create_lna_schematic_from_snp(\n",
+ " input_file=touchstone_path,\n",
+ " start_frequency=0,\n",
+ " stop_frequency=70,\n",
+ " auto_assign_diff_pairs=True,\n",
+ " separation=\".\",\n",
+ " pattern=[\"component\", \"pin\", \"net\"],\n",
+ " analyze=True,\n",
+ ")\n",
+ "insertion = circuit.get_all_insertion_loss_list(\n",
+ " drivers=diff_pairs,\n",
+ " receivers=diff_pairs,\n",
+ " drivers_prefix_name=\"X1\",\n",
+ " receivers_prefix_name=\"U1\",\n",
+ " math_formula=\"dB\",\n",
+ " nets=[\"RX0\", \"RX1\", \"RX2\", \"RX3\"],\n",
+ ")\n",
+ "return_diff = circuit.get_all_return_loss_list(\n",
+ " excitations=diff_pairs,\n",
+ " excitation_name_prefix=\"X1\",\n",
+ " math_formula=\"dB\",\n",
+ " nets=[\"RX0\", \"RX1\", \"RX2\", \"RX3\"],\n",
+ ")\n",
+ "return_comm = circuit.get_all_return_loss_list(\n",
+ " excitations=comm_pairs,\n",
+ " excitation_name_prefix=\"COMMON_X1\",\n",
+ " math_formula=\"dB\",\n",
+ " nets=[\"RX0\", \"RX1\", \"RX2\", \"RX3\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0de28b89",
+ "metadata": {},
+ "source": [
+ "## Create TDR project\n",
+ "\n",
+ "Create a TDR project to compute transient simulation and retrieve\n",
+ "the TDR measurement on a differential pair.\n",
+ "The original circuit schematic is duplicated and modified to achieve this target."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ede57c8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "result, tdr_probe_name = circuit.create_tdr_schematic_from_snp(\n",
+ " input_file=touchstone_path,\n",
+ " tx_schematic_pins=[\"X1.A2.PCIe_Gen4_RX0_P\"],\n",
+ " tx_schematic_differential_pins=[\"X1.A3.PCIe_Gen4_RX0_N\"],\n",
+ " termination_pins=[\"U1.AP26.PCIe_Gen4_RX0_P\", \"U1.AN26.PCIe_Gen4_RX0_N\"],\n",
+ " differential=True,\n",
+ " rise_time=35,\n",
+ " use_convolution=True,\n",
+ " analyze=True,\n",
+ " design_name=\"TDR\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4bef898c",
+ "metadata": {},
+ "source": [
+ "## Create AMI project\n",
+ "\n",
+ "Create an Ibis AMI project to compute an eye diagram simulation and retrieve\n",
+ "eye mask violations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "23b1b677",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_, eye_curve_tx, eye_curve_rx = circuit.create_ami_schematic_from_snp(\n",
+ " input_file=touchstone_path,\n",
+ " ibis_tx_file=os.path.join(project_folder, \"models\", \"pcieg5_32gt.ibs\"),\n",
+ " tx_buffer_name=\"1p\",\n",
+ " rx_buffer_name=\"2p\",\n",
+ " tx_schematic_pins=[\"U1.AM25.PCIe_Gen4_TX0_CAP_P\"],\n",
+ " rx_schematic_pins=[\"X1.B2.PCIe_Gen4_TX0_P\"],\n",
+ " tx_schematic_differential_pins=[\"U1.AL25.PCIe_Gen4_TX0_CAP_N\"],\n",
+ " rx_schematic_differentialial_pins=[\"X1.B3.PCIe_Gen4_TX0_N\"],\n",
+ " ibis_tx_component_name=\"Spec_Model\",\n",
+ " use_ibis_buffer=False,\n",
+ " differential=True,\n",
+ " bit_pattern=\"random_bit_count=2.5e3 random_seed=1\",\n",
+ " unit_interval=\"31.25ps\",\n",
+ " use_convolution=True,\n",
+ " analyze=True,\n",
+ " design_name=\"AMI\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "544082fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7090d693",
+ "metadata": {},
+ "source": [
+ "## Create virtual compliance report\n",
+ "\n",
+ "Initialize the ``VirtualCompliance`` class\n",
+ "and set up the main project information needed to generate the report.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4f0b3b8",
+ "metadata": {},
+ "source": [
+ "![](\"_static/virtual_compliance_class.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b75927ef",
+ "metadata": {},
+ "source": [
+ "![](\"_static/virtual_compliance_configs.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da8fc790",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "template = os.path.join(download_folder, \"pcie_gen5_templates\", \"main.json\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68d1fe39",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "v = VirtualCompliance(circuit.desktop_class, str(template))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e2947f1",
+ "metadata": {},
+ "source": [
+ "## Customize project and design\n",
+ "\n",
+ "Define the path to the project file and the\n",
+ "design names to be used in each report generation.\n",
+ "\n",
+ "![](\"_static/virtual_compliance_scattering1.png\")
\n",
+ "![](\"_static/virtual_compliance_scattering2.png\")
\n",
+ "![](\"_static/virtual_compliance_eye.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76db3a3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "v.create_compliance_report()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1d1334d3",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "26b51015",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a77e8a6",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "153c022c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/coaxial_hfss_icepak.ipynb.txt b/version/dev/_sources/examples/electrothermal/coaxial_hfss_icepak.ipynb.txt
new file mode 100644
index 00000000..9f58b764
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/coaxial_hfss_icepak.ipynb.txt
@@ -0,0 +1,904 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "99e77596",
+ "metadata": {},
+ "source": [
+ "# Coaxial\n",
+ "\n",
+ "This example shows how to create a project from scratch in HFSS and Icepak.\n",
+ "This includes creating a setup, solving it, and creating postprocessing outputs.\n",
+ "\n",
+ "Keywords: **Multiphysics**, **HFSS**, **Icepak**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ab042d15",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b6ad55e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "029a2c9e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.visualization.plot.pdf import AnsysReport"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "095403f2",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b95eadfe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27a237ca",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3697249c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7aa4a3f",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and initialize HFSS\n",
+ "\n",
+ "Launch AEDT and initialize HFSS. If there is an active HFSS design, the ``hfss``\n",
+ "object is linked to it. Otherwise, a new design is created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "425f7508",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=os.path.join(temp_folder.name, \"Icepak_HFSS_Coupling\"),\n",
+ " design=\"RF\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " solution_type=\"Modal\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "df0f6513",
+ "metadata": {},
+ "source": [
+ "## Define parameters\n",
+ "\n",
+ "Parameters can be instantiated by defining them as a key used for the application\n",
+ "instance as demonstrated in the following code. The prefix ``$`` is used to define\n",
+ "a project-wide scope for the parameter. Otherwise, the parameter scope is limited to\n",
+ "the current design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6d8fabce",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss[\"$coax_dimension\"] = \"100mm\" # Project-wide scope.\n",
+ "udp = hfss.modeler.Position(0, 0, 0)\n",
+ "hfss[\"inner\"] = \"3mm\" # Local \"Design\" scope."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3385655c",
+ "metadata": {},
+ "source": [
+ "## Create coaxial and cylinders\n",
+ "\n",
+ "Create a coaxial and three cylinders. You can apply parameters\n",
+ "directly using the `ansys.aedt.core.modeler.Primitives3D.Primitives3D.create_cylinder()`\n",
+ "method. You can assign a material directly to the object creation action.\n",
+ "Optionally, you can assign a material using the `assign_material()` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06b70064",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "o1 = hfss.modeler.create_cylinder(\n",
+ " orientation=hfss.PLANE.ZX,\n",
+ " origin=udp,\n",
+ " radius=\"inner\",\n",
+ " height=\"$coax_dimension\",\n",
+ " num_sides=0,\n",
+ " name=\"inner\",\n",
+ ")\n",
+ "o2 = hfss.modeler.create_cylinder(\n",
+ " orientation=hfss.PLANE.ZX,\n",
+ " origin=udp,\n",
+ " radius=8,\n",
+ " height=\"$coax_dimension\",\n",
+ " num_sides=0,\n",
+ " name=\"teflon_based\",\n",
+ ")\n",
+ "o3 = hfss.modeler.create_cylinder(\n",
+ " orientation=hfss.PLANE.ZX,\n",
+ " origin=udp,\n",
+ " radius=10,\n",
+ " height=\"$coax_dimension\",\n",
+ " num_sides=0,\n",
+ " name=\"outer\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "63b3491a",
+ "metadata": {},
+ "source": [
+ "## Assign colors\n",
+ "\n",
+ "Assign colors to each primitive."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4496fc7e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "o1.color = (255, 0, 0)\n",
+ "o2.color = (0, 255, 0)\n",
+ "o3.color = (255, 0, 0)\n",
+ "o3.transparency = 0.8\n",
+ "hfss.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1758ec9b",
+ "metadata": {},
+ "source": [
+ "## Assign materials\n",
+ "\n",
+ "Assign materials. You can assign materials either directly when creating the primitive,\n",
+ "which was done for ``id2``, or after the object is created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "44b14ebd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "o1.material_name = \"Copper\"\n",
+ "o3.material_name = \"Copper\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1555d98",
+ "metadata": {},
+ "source": [
+ "## Perform modeler operations\n",
+ "\n",
+ "Perform modeler operations. You can subtract, add, and perform other operations\n",
+ "using either the object ID or object name."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85bc69fb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.subtract(o3, o2, True)\n",
+ "hfss.modeler.subtract(o2, o1, True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e157c3da",
+ "metadata": {},
+ "source": [
+ "## Assign mesh operations\n",
+ "\n",
+ "Most mesh operations are accessible using the ``mesh`` property,\n",
+ "which is an instance of the ``ansys.aedt.core.modules.MeshIcepak.IcepakMesh`` class.\n",
+ "\n",
+ "This code shows how to use several common mesh operations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "49cfd3e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.mesh.assign_initial_mesh_from_slider(level=6)\n",
+ "hfss.mesh.assign_model_resolution(assignment=[o1.name, o3.name], defeature_length=None)\n",
+ "hfss.mesh.assign_length_mesh(\n",
+ " assignment=o2.faces, inside_selection=False, maximum_length=1, maximum_elements=2000\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8d43c29e",
+ "metadata": {},
+ "source": [
+ "## Create HFSS sources\n",
+ "\n",
+ "The RF power dissipated in the HFSS model acts as the thermal\n",
+ "source for in Icepak. The ``create_wave_port_between_objects()`` method\n",
+ "is used to assign the RF ports that inject RF power into the HFSS\n",
+ "model. If ``add_pec_cap=True``, then the method\n",
+ "creates a perfectly conducting (lossless) cap covering the port."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "99a3b249",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.wave_port(\n",
+ " assignment=\"inner\",\n",
+ " reference=\"outer\",\n",
+ " integration_line=1,\n",
+ " create_port_sheet=True,\n",
+ " create_pec_cap=True,\n",
+ " name=\"P1\",\n",
+ ")\n",
+ "\n",
+ "hfss.wave_port(\n",
+ " assignment=\"inner\",\n",
+ " reference=\"outer\",\n",
+ " integration_line=4,\n",
+ " create_pec_cap=True,\n",
+ " create_port_sheet=True,\n",
+ " name=\"P2\",\n",
+ ")\n",
+ "\n",
+ "port_names = hfss.get_all_sources()\n",
+ "hfss.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe7e3006",
+ "metadata": {},
+ "source": [
+ "## Set up simulation\n",
+ "\n",
+ "Create a HFSS setup with default values. After its creation,\n",
+ "you can change values and update the setup. The ``update()`` method returns a Boolean\n",
+ "value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "33efd95d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.set_active_design(hfss.design_name)\n",
+ "setup = hfss.create_setup(\"MySetup\")\n",
+ "setup.props[\"Frequency\"] = \"1GHz\"\n",
+ "setup.props[\"BasisOrder\"] = 2\n",
+ "setup.props[\"MaximumPasses\"] = 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0b046a10",
+ "metadata": {},
+ "source": [
+ "## Create frequency sweep\n",
+ "\n",
+ "The HFSS frequency sweep defines the RF frequency range over which the RF power is\n",
+ "injected into the structure."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f67195c4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweepname = hfss.create_linear_count_sweep(\n",
+ " setup=\"MySetup\",\n",
+ " units=\"GHz\",\n",
+ " start_frequency=0.8,\n",
+ " stop_frequency=1.2,\n",
+ " num_of_freq_points=401,\n",
+ " sweep_type=\"Interpolating\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3d73f57c",
+ "metadata": {},
+ "source": [
+ "## Create Icepak model\n",
+ "\n",
+ "After an HFSS setup has been defined, the model can be lnked to an Icepak\n",
+ "design. The coupled physics analysis can then be run. The `FieldAnalysis3D.copy_solid_bodies_from()`\n",
+ "method imports a model from HFSS into Icepak, including all material definitions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b676c202",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = ansys.aedt.core.Icepak(design=\"CalcTemp\", version=AEDT_VERSION)\n",
+ "ipk.copy_solid_bodies_from(hfss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a73d7a24",
+ "metadata": {},
+ "source": [
+ "## Link RF thermal source\n",
+ "\n",
+ "The RF loss in HFSS is used as the thermal source in Icepak."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8e52cf4a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "surfaceobj = [\"inner\", \"outer\"]\n",
+ "ipk.assign_em_losses(\n",
+ " design=hfss.design_name,\n",
+ " setup=\"MySetup\",\n",
+ " sweep=\"LastAdaptive\",\n",
+ " map_frequency=\"1GHz\",\n",
+ " surface_objects=surfaceobj,\n",
+ " parameters=[\"$coax_dimension\", \"inner\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb01993c",
+ "metadata": {},
+ "source": [
+ "## Set direction of gravity\n",
+ "\n",
+ "Set the direction of gravity for convection in Icepak. Gravity drives a temperature gradient\n",
+ "due to the dependence of gas density on temperature."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a5620ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.edit_design_settings(hfss.GRAVITY.ZNeg)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76e25afb",
+ "metadata": {},
+ "source": [
+ "## Set up Icepak Project\n",
+ "\n",
+ "The initial solution setup applies default values that can subsequently\n",
+ "be modified as shown in the following code.\n",
+ "The ``props`` property enables access to all solution settings.\n",
+ "\n",
+ "The ``update`` function applies the settings to the setup. The setup creation\n",
+ "process is identical for all tools."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1f5157ad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup_ipk = ipk.create_setup(\"SetupIPK\")\n",
+ "setup_ipk.props[\"Convergence Criteria - Max Iterations\"] = 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a1082ae",
+ "metadata": {},
+ "source": [
+ "### Access Icepak solution properties\n",
+ "\n",
+ "Setup properties are accessible through the ``props`` property as\n",
+ "an ordered dictionary. You can use the ``keys()`` method to retrieve all settings for\n",
+ "the setup.\n",
+ "\n",
+ "Find properties that contain the string ``\"Convergence\"`` and print the default values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "098f8184",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "conv_props = [k for k in setup_ipk.props.keys() if \"Convergence\" in k]\n",
+ "print(\"Here are some default setup properties:\")\n",
+ "for p in conv_props:\n",
+ " print('\"' + p + '\" -> ' + str(setup_ipk.props[p]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cd444c2",
+ "metadata": {},
+ "source": [
+ "### Edit or review mesh parameters\n",
+ "\n",
+ "Edit or review the mesh parameters. After a mesh is created, you can access\n",
+ "a mesh operation to edit or review parameter values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3642fbd4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "airbox = ipk.modeler.get_obj_id(\"Region\")\n",
+ "ipk.modeler[airbox].display_wireframe = True\n",
+ "airfaces = ipk.modeler.get_object_faces(airbox)\n",
+ "ipk.assign_openings(airfaces)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa91eb21",
+ "metadata": {},
+ "source": [
+ "Save the project and attach to the Icepak instance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "28d5696c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "ipk = ansys.aedt.core.Icepak(version=AEDT_VERSION)\n",
+ "ipk.solution_type = ipk.SOLUTIONS.Icepak.SteadyTemperatureAndFlow\n",
+ "ipk.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed3a6c70",
+ "metadata": {},
+ "source": [
+ "## Solve models\n",
+ "\n",
+ "Solve the Icepak and HFSS models."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "89b9f05e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.setups[0].analyze(cores=NUM_CORES, tasks=NUM_CORES)\n",
+ "hfss.save_project()\n",
+ "hfss.modeler.fit_all()\n",
+ "hfss.setups[0].analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57203272",
+ "metadata": {},
+ "source": [
+ "### Plot and export results\n",
+ "\n",
+ "Generate field plots in the HFSS project and export them as images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d7366d4f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "quantity_name = \"ComplexMag_H\"\n",
+ "intrinsic = {\"Freq\": hfss.setups[0].props[\"Frequency\"], \"Phase\": \"0deg\"}\n",
+ "surface_list = hfss.modeler.get_object_faces(\"outer\")\n",
+ "plot1 = hfss.post.create_fieldplot_surface(\n",
+ " assignment=surface_list,\n",
+ " quantity=quantity_name,\n",
+ " setup=hfss.nominal_adaptive,\n",
+ " intrinsics=intrinsic,\n",
+ ")\n",
+ "\n",
+ "hfss.post.plot_field_from_fieldplot(\n",
+ " plot1.name,\n",
+ " project_path=temp_folder.name,\n",
+ " mesh_plot=False,\n",
+ " image_format=\"jpg\",\n",
+ " view=\"isometric\",\n",
+ " show=False,\n",
+ " plot_cad_objs=False,\n",
+ " log_scale=False,\n",
+ " file_format=\"aedtplt\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "300833bf",
+ "metadata": {},
+ "source": [
+ "## Generate animation from field plots\n",
+ "\n",
+ "Generate an animation from field plots using PyVista."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ccba501a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "start = time.time()\n",
+ "cutlist = [\"Global:XY\"]\n",
+ "phase_values = [str(i * 5) + \"deg\" for i in range(18)]\n",
+ "\n",
+ "animated = hfss.post.plot_animated_field(\n",
+ " quantity=\"Mag_E\",\n",
+ " assignment=cutlist,\n",
+ " plot_type=\"CutPlane\",\n",
+ " setup=hfss.nominal_adaptive,\n",
+ " intrinsics=intrinsic,\n",
+ " export_path=temp_folder.name,\n",
+ " variation_variable=\"Phase\",\n",
+ " variations=phase_values,\n",
+ " show=False,\n",
+ " export_gif=False,\n",
+ " log_scale=True,\n",
+ ")\n",
+ "animated.gif_file = os.path.join(temp_folder.name, \"animate.gif\")\n",
+ "\n",
+ "# Set off_screen to False to visualize the animation.\n",
+ "# animated.off_screen = False\n",
+ "\n",
+ "animated.animate()\n",
+ "\n",
+ "end_time = time.time() - start\n",
+ "print(\"Total Time\", end_time)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b2ce2e48",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Create Icepak plots and export them as images using the same functions that\n",
+ "were used early. Only the quantity is different."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c1532819",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup_name = ipk.existing_analysis_sweeps[0]\n",
+ "intrinsic = \"\"\n",
+ "surface_list = ipk.modeler.get_object_faces(\"inner\") + ipk.modeler.get_object_faces(\n",
+ " \"outer\"\n",
+ ")\n",
+ "plot5 = ipk.post.create_fieldplot_surface(surface_list, quantity=\"SurfTemperature\")\n",
+ "\n",
+ "hfss.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d06f5424",
+ "metadata": {},
+ "source": [
+ "Plot results using Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "874a7ae6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trace_names = hfss.get_traces_for_plot(category=\"S\")\n",
+ "context = [\"Domain:=\", \"Sweep\"]\n",
+ "families = [\"Freq:=\", [\"All\"]]\n",
+ "my_data = hfss.post.get_solution_data(expressions=trace_names)\n",
+ "my_data.plot(\n",
+ " trace_names,\n",
+ " formula=\"db20\",\n",
+ " x_label=\"Frequency (Ghz)\",\n",
+ " y_label=\"SParameters(dB)\",\n",
+ " title=\"Scattering Chart\",\n",
+ " snapshot_path=os.path.join(temp_folder.name, \"Touchstone_from_matplotlib.jpg\"),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b543086",
+ "metadata": {},
+ "source": [
+ "Create a PDF report summarizig results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ef66b46e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report = AnsysReport(\n",
+ " project_name=hfss.project_name, design_name=hfss.design_name, version=AEDT_VERSION\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7dc79083",
+ "metadata": {},
+ "source": [
+ "Create the report."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "de1b4436",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report.create()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1eca3a19",
+ "metadata": {},
+ "source": [
+ "Add a section for plots."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9e82eab8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report.add_section()\n",
+ "pdf_report.add_chapter(\"HFSS Results\")\n",
+ "pdf_report.add_sub_chapter(\"Field plot\")\n",
+ "pdf_report.add_text(\"This section contains field plots of HFSS Coaxial.\")\n",
+ "pdf_report.add_image(\n",
+ " os.path.join(temp_folder.name, plot1.name + \".jpg\"), caption=\"Coaxial cable\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e10e928",
+ "metadata": {},
+ "source": [
+ "Add a page break and a subchapter for S Parameter results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ed1cbd37",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report.add_page_break()\n",
+ "pdf_report.add_sub_chapter(\"S Parameters\")\n",
+ "pdf_report.add_chart(\n",
+ " x_values=my_data.intrinsics[\"Freq\"],\n",
+ " y_values=my_data.data_db20(),\n",
+ " x_caption=\"Freq\",\n",
+ " y_caption=trace_names[0],\n",
+ " title=\"S-Parameters\",\n",
+ ")\n",
+ "pdf_report.add_image(\n",
+ " path=os.path.join(temp_folder.name, \"Touchstone_from_matplotlib.jpg\"),\n",
+ " caption=\"Touchstone from Matplotlib\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "79cb9d1d",
+ "metadata": {},
+ "source": [
+ "Add a new section for Icepak results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d88c4a9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report.add_section()\n",
+ "pdf_report.add_chapter(\"Icepak Results\")\n",
+ "pdf_report.add_sub_chapter(\"Temperature Plot\")\n",
+ "pdf_report.add_text(\"This section contains Multiphysics temperature plot.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db615ebe",
+ "metadata": {},
+ "source": [
+ "Add table of content and save the PDF."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e66bad58",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pdf_report.add_toc()\n",
+ "pdf_report.save_pdf(file_path=temp_folder.name, file_name=\"AEDT_Results.pdf\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c42bcd3",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c4a81aa8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1671de7",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5e9d7243",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/component_3d.ipynb.txt b/version/dev/_sources/examples/electrothermal/component_3d.ipynb.txt
new file mode 100644
index 00000000..cd875531
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/component_3d.ipynb.txt
@@ -0,0 +1,595 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4e5a5558",
+ "metadata": {},
+ "source": [
+ "# Thermal analysis with 3D components"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6cf4cf0a",
+ "metadata": {},
+ "source": [
+ "This example shows how to create a thermal analysis of an electronic package by\n",
+ "taking advantage of 3D components with advanced features added by PyAEDT.\n",
+ "\n",
+ "Keywords: **Icepak**, **3D components**, **mesh regions**, **monitor objects**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1033eef",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e5b7307c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "862c55bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import Icepak, downloads"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4649595f",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e302de88",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf48a7ba",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4492ee1b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "package_temp_name, qfp_temp_name = downloads.download_icepak_3d_component(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "161c5e44",
+ "metadata": {},
+ "source": [
+ "## Create heatsink\n",
+ "Create an empty project in non-graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c0b8edd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = Icepak(\n",
+ " project=os.path.join(temp_folder.name, \"Heatsink.aedt\"),\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " close_on_exit=True,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "661669f5",
+ "metadata": {},
+ "source": [
+ "Remove the air region, which is present by default. An air region is not needed as the heatsink\n",
+ "is to be exported as a 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5c72e0c5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler[\"Region\"].delete()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "494901cf",
+ "metadata": {},
+ "source": [
+ "Define the heatsink using multiple boxes."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "39983b41",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs_base = ipk.modeler.create_box(\n",
+ " origin=[0, 0, 0], sizes=[37.5, 37.5, 2], name=\"HS_Base\"\n",
+ ")\n",
+ "hs_base.material_name = \"Al-Extruded\"\n",
+ "hs_fin = ipk.modeler.create_box(origin=[0, 0, 2], sizes=[37.5, 1, 18], name=\"HS_Fin1\")\n",
+ "hs_fin.material_name = \"Al-Extruded\"\n",
+ "n_fins = 11\n",
+ "hs_fins = hs_fin.duplicate_along_line(vector=[0, 3.65, 0], clones=n_fins)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a020f9a2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.plot(show=False, output_file=os.path.join(temp_folder.name, \"Heatsink.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "51a0d692",
+ "metadata": {},
+ "source": [
+ "Define a mesh region around the heatsink."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "44d231e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh_region = ipk.mesh.assign_mesh_region(\n",
+ " assignment=[hs_base.name, hs_fin.name] + hs_fins\n",
+ ")\n",
+ "mesh_region.manual_settings = True\n",
+ "mesh_region.settings[\"MaxElementSizeX\"] = \"5mm\"\n",
+ "mesh_region.settings[\"MaxElementSizeY\"] = \"5mm\"\n",
+ "mesh_region.settings[\"MaxElementSizeZ\"] = \"1mm\"\n",
+ "mesh_region.settings[\"MinElementsInGap\"] = 4\n",
+ "mesh_region.settings[\"MaxLevels\"] = 2\n",
+ "mesh_region.settings[\"BufferLayers\"] = 2\n",
+ "mesh_region.settings[\"EnableMLM\"] = True\n",
+ "mesh_region.settings[\"UniformMeshParametersType\"] = \"Average\"\n",
+ "mesh_region.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fb69a213",
+ "metadata": {},
+ "source": [
+ "Assign monitor objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1a9e3fac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hs_middle_fin = ipk.modeler.get_object_from_name(assignment=hs_fins[n_fins // 2])\n",
+ "point_monitor_position = [\n",
+ " 0.5 * (hs_base.bounding_box[i] + hs_base.bounding_box[i + 3]) for i in range(2)\n",
+ "] + [\n",
+ " hs_middle_fin.bounding_box[-1]\n",
+ "] # average x,y, top z\n",
+ "ipk.monitor.assign_point_monitor(\n",
+ " point_position=point_monitor_position,\n",
+ " monitor_quantity=[\"Temperature\", \"HeatFlux\"],\n",
+ " monitor_name=\"TopPoint\",\n",
+ ")\n",
+ "ipk.monitor.assign_face_monitor(\n",
+ " face_id=hs_base.bottom_face_z.id,\n",
+ " monitor_quantity=\"Temperature\",\n",
+ " monitor_name=\"Bottom\",\n",
+ ")\n",
+ "ipk.monitor.assign_point_monitor_in_object(\n",
+ " name=hs_middle_fin.name,\n",
+ " monitor_quantity=\"Temperature\",\n",
+ " monitor_name=\"MiddleFinCenter\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "055cb27f",
+ "metadata": {},
+ "source": [
+ "Export the heatsink 3D component to a ``\"componentLibrary\"`` folder.\n",
+ "The ``auxiliary_dict`` parameter is set to ``True`` to export the monitor objects\n",
+ "along with the A3DCOMP file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff34a854",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "os.mkdir(os.path.join(temp_folder.name, \"componentLibrary\"))\n",
+ "ipk.modeler.create_3dcomponent(\n",
+ " input_file=os.path.join(temp_folder.name, \"componentLibrary\", \"Heatsink.a3dcomp\"),\n",
+ " name=\"Heatsink\",\n",
+ " export_auxiliary=True,\n",
+ ")\n",
+ "ipk.close_project(save=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d246b6fe",
+ "metadata": {},
+ "source": [
+ "## Create QFP\n",
+ "Open the previously downloaded project containing a QPF."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "40a98d2e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = Icepak(project=qfp_temp_name, version=AEDT_VERSION)\n",
+ "ipk.plot(show=False, output_file=os.path.join(temp_folder.name, \"QFP2.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f568b9a7",
+ "metadata": {},
+ "source": [
+ "Create a dataset for power dissipation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "262b0620",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_datalist = [45, 53, 60, 70]\n",
+ "y_datalist = [0.5, 3, 6, 9]\n",
+ "ipk.create_dataset(\n",
+ " name=\"PowerDissipationDataset\",\n",
+ " x=x_datalist,\n",
+ " y=y_datalist,\n",
+ " is_project_dataset=False,\n",
+ " x_unit=\"cel\",\n",
+ " y_unit=\"W\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "482c3e11",
+ "metadata": {},
+ "source": [
+ "Assign a source power condition to the die."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "932f3c58",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.create_source_power(\n",
+ " face_id=\"DieSource\",\n",
+ " thermal_dependent_dataset=\"PowerDissipationDataset\",\n",
+ " source_name=\"DieSource\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a82db31",
+ "metadata": {},
+ "source": [
+ "Assign thickness to the die attach surface."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c8a48a82",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assign_conducting_plate_with_thickness(\n",
+ " obj_plate=\"Die_Attach\",\n",
+ " shell_conduction=True,\n",
+ " thickness=\"0.05mm\",\n",
+ " solid_material=\"Epoxy Resin-Typical\",\n",
+ " boundary_name=\"Die_Attach\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd35e20f",
+ "metadata": {},
+ "source": [
+ "Assign monitor objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0b80a8dd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.monitor.assign_point_monitor_in_object(\n",
+ " name=\"QFP2_die\", monitor_quantity=\"Temperature\", monitor_name=\"DieCenter\"\n",
+ ")\n",
+ "ipk.monitor.assign_surface_monitor(\n",
+ " surface_name=\"Die_Attach\", monitor_quantity=\"Temperature\", monitor_name=\"DieAttach\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "551d7696",
+ "metadata": {},
+ "source": [
+ "Export the QFP 3D component in the ``\"componentLibrary\"`` folder and close the project.\n",
+ "Here the auxiliary dictionary allows exporting not only the monitor objects but also the dataset\n",
+ "used for the power source assignment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1e6e3e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler.create_3dcomponent(\n",
+ " input_file=os.path.join(temp_folder.name, \"componentLibrary\", \"QFP.a3dcomp\"),\n",
+ " name=\"QFP\",\n",
+ " export_auxiliary=True,\n",
+ " datasets=[\"PowerDissipationDataset\"],\n",
+ ")\n",
+ "ipk.release_desktop(close_projects=False, close_desktop=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "769a0965",
+ "metadata": {},
+ "source": [
+ "## Create complete electronic package\n",
+ "Download and open a project containing the electronic package."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c37bbbf2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = Icepak(\n",
+ " project=package_temp_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ ")\n",
+ "ipk.plot(\n",
+ " assignment=[o for o in ipk.modeler.object_names if not o.startswith(\"DomainBox\")],\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"electronic_package_missing_obj.jpg\"),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "68f31aed",
+ "metadata": {},
+ "source": [
+ "The heatsink and the QFP are missing. They can be inserted as 3D components.\n",
+ "The auxiliary files are needed because the goal is to also import monitor objects and datasets."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4daeb87",
+ "metadata": {},
+ "source": [
+ "Create a coordinate system for the heatsink so that it is placed on top of the AGP."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d40eadfa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "agp = ipk.modeler.get_object_from_name(assignment=\"AGP_IDF\")\n",
+ "cs = ipk.modeler.create_coordinate_system(\n",
+ " origin=[agp.bounding_box[0], agp.bounding_box[1], agp.bounding_box[-1]],\n",
+ " name=\"HeatsinkCS\",\n",
+ " reference_cs=\"Global\",\n",
+ " x_pointing=[1, 0, 0],\n",
+ " y_pointing=[0, 1, 0],\n",
+ ")\n",
+ "heatsink_obj = ipk.modeler.insert_3d_component(\n",
+ " input_file=os.path.join(temp_folder.name, \"componentLibrary\", \"Heatsink.a3dcomp\"),\n",
+ " coordinate_system=\"HeatsinkCS\",\n",
+ " auxiliary_parameters=True,\n",
+ ")\n",
+ "\n",
+ "QFP2_obj = ipk.modeler.insert_3d_component(\n",
+ " input_file=os.path.join(temp_folder.name, \"componentLibrary\", \"QFP.a3dcomp\"),\n",
+ " coordinate_system=\"Global\",\n",
+ " auxiliary_parameters=True,\n",
+ ")\n",
+ "\n",
+ "ipk.plot(\n",
+ " assignment=[o for o in ipk.modeler.object_names if not o.startswith(\"DomainBox\")],\n",
+ " show=False,\n",
+ " plot_air_objects=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"electronic_package.jpg\"),\n",
+ " force_opacity_value=0.5,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0dbb9fe",
+ "metadata": {},
+ "source": [
+ "Create a coordinate system at the xmin, ymin, and zmin of the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b0a2f547",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bounding_box = ipk.modeler.get_model_bounding_box()\n",
+ "cs_pcb_assembly = ipk.modeler.create_coordinate_system(\n",
+ " origin=[bounding_box[0], bounding_box[1], bounding_box[2]],\n",
+ " name=\"PCB_Assembly\",\n",
+ " reference_cs=\"Global\",\n",
+ " x_pointing=[1, 0, 0],\n",
+ " y_pointing=[0, 1, 0],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5849b550",
+ "metadata": {},
+ "source": [
+ "Export the entire assembly as a 3D component and close the project. First, the nested\n",
+ "hierarchy must be flattened because nested 3D components are currently not supported. Subsequently,\n",
+ "the whole package can be exported as a 3D component. The auxiliary dictionary is needed\n",
+ "to export monitor objects, datasets, and native components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8264069c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.flatten_3d_components()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6da2df65",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c4817d1f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd73f6d8",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "244e9ebc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/components_csv.ipynb.txt b/version/dev/_sources/examples/electrothermal/components_csv.ipynb.txt
new file mode 100644
index 00000000..95e67b4f
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/components_csv.ipynb.txt
@@ -0,0 +1,492 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "b28546fd",
+ "metadata": {},
+ "source": [
+ "# PCB component definition from CSV file and model image exports"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1208b546",
+ "metadata": {},
+ "source": [
+ "This example shows how to create different types of blocks and assign power\n",
+ "and material to them using a CSV input file\n",
+ "\n",
+ "Keywords: **Icepak**, **boundaries**, **PyVista**, **CSV**, **PCB**, **components**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce7cdd76",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76753767",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import csv\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "from pathlib import Path\n",
+ "\n",
+ "import ansys.aedt.core\n",
+ "import matplotlib as mpl\n",
+ "import numpy as np\n",
+ "import pyvista as pv\n",
+ "from IPython.display import Image\n",
+ "from matplotlib import cm\n",
+ "from matplotlib import pyplot as plt\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a338af7",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c35f6a1a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6c35202b",
+ "metadata": {},
+ "source": [
+ "## Download and open project\n",
+ "\n",
+ "Download the project and open it in non-graphical mode, using a temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e8bbf960",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "project_name = os.path.join(temp_folder.name, \"Icepak_CSV_Import.aedt\")\n",
+ "ipk = ansys.aedt.core.Icepak(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "653e2447",
+ "metadata": {},
+ "source": [
+ "Create the PCB as a simple block with lumped material properties."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4e9f2491",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "board = ipk.modeler.create_box(\n",
+ " origin=[-30.48, -27.305, 0],\n",
+ " sizes=[146.685, 71.755, 0.4064],\n",
+ " name=\"board_outline\",\n",
+ " material=\"FR-4_Ref\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "033a5fae",
+ "metadata": {},
+ "source": [
+ "## Create components from CSV file\n",
+ "\n",
+ "Components are represented as simple cubes with dimensions and properties specified in a CSV file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e49b7640",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filename = ansys.aedt.core.downloads.download_file(\n",
+ " \"icepak\", \"blocks-list.csv\", destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9057fc27",
+ "metadata": {},
+ "source": [
+ "The CSV file lists block properties:\n",
+ "\n",
+ "- Type (solid, network, hollow)\n",
+ "- Name\n",
+ "- Dtart point (xs, ys, zs) and end point (xd, yd, zd)\n",
+ "- Material properties (for solid blocks)\n",
+ "- Power assignment\n",
+ "- Resistances to the board and to the case (for network blocks)\n",
+ "- Whether to add a monitor point to the block (0 or 1)\n",
+ "\n",
+ "The following table does not show entire rows and dat. It provides only a sample.\n",
+ "\n",
+ "\n",
+ "| block_type | name | xs | ys | zs | xd | yd | zd | matname | power | Rjb | Rjc | Monitor_point |\n",
+ "|------------|------|--------|--------|------|-------|-------|------|------------------|-------|-----|-----|---------------|\n",
+ "| hollow | R8 | 31.75 | -20.32 | 0.40 | 15.24 | 2.54 | 2.54 | | 1 | | | 0 |\n",
+ "| solid | U1 | 16.55 | 10.20 | 0.40 | 10.16 | 20.32 | 5.08 | Ceramic_material | 0.2 | | | 1 |\n",
+ "| solid | U2 | -51 | 10.16 | 0.40 | 10.16 | 27.94 | 5.08 | Ceramic_material | 0.1 | | | 1 |\n",
+ "| network | C180 | 47.62 | 19.05 | 0.40 | 3.81 | 2.54 | 2.43 | | 1.13 | 2 | 3 | 0 |\n",
+ "| network | C10 | 65.40 | -1.27 | 0.40 | 3.81 | 2.54 | 2.43 | | 0.562 | 2 | 3 | 0 |\n",
+ "| network | C20 | 113.03 | -0.63 | 0.40 | 2.54 | 3.81 | 2.43 | | 0.445 | 2 | 3 | 0 |\n",
+ "\n",
+ "The following code loops over each line of the CSV file, creating solid blocks\n",
+ "and assigning boundary conditions.\n",
+ "\n",
+ "Every row of the CSV file has information on a particular block."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cddb4604",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "with open(filename, \"r\") as csv_file:\n",
+ " csv_reader = csv.DictReader(csv_file)\n",
+ " for row in csv_reader:\n",
+ " origin = [\n",
+ " float(row[\"xs\"]),\n",
+ " float(row[\"ys\"]),\n",
+ " float(row[\"zs\"]),\n",
+ " ] # block starting point\n",
+ " dimensions = [\n",
+ " float(row[\"xd\"]),\n",
+ " float(row[\"yd\"]),\n",
+ " float(row[\"zd\"]),\n",
+ " ] # block lengths in 3 dimensions\n",
+ " block_name = row[\"name\"] # block name\n",
+ "\n",
+ " # Define material name\n",
+ " if row[\"matname\"]:\n",
+ " material_name = row[\"matname\"]\n",
+ " else:\n",
+ " material_name = \"copper\"\n",
+ "\n",
+ " # Creates the block with the given name, coordinates, material, and type\n",
+ " block = ipk.modeler.create_box(\n",
+ " origin=origin, sizes=dimensions, name=block_name, material=material_name\n",
+ " )\n",
+ "\n",
+ " # Assign boundary conditions\n",
+ " if row[\"block_type\"] == \"solid\":\n",
+ " ipk.assign_solid_block(\n",
+ " object_name=block_name,\n",
+ " power_assignment=row[\"power\"] + \"W\",\n",
+ " boundary_name=block_name,\n",
+ " )\n",
+ " elif row[\"block_type\"] == \"network\":\n",
+ " ipk.create_two_resistor_network_block(\n",
+ " object_name=block_name,\n",
+ " pcb=board.name,\n",
+ " power=row[\"power\"] + \"W\",\n",
+ " rjb=row[\"Rjb\"],\n",
+ " rjc=row[\"Rjc\"],\n",
+ " )\n",
+ " else:\n",
+ " ipk.modeler[block.name].solve_inside = False\n",
+ " ipk.assign_hollow_block(\n",
+ " object_name=block_name,\n",
+ " assignment_type=\"Total Power\",\n",
+ " assignment_value=row[\"power\"] + \"W\",\n",
+ " boundary_name=block_name,\n",
+ " )\n",
+ "\n",
+ " # Create temperature monitor points if assigned value is 1 in the last\n",
+ " # column of the CSV file\n",
+ " if row[\"Monitor_point\"] == \"1\":\n",
+ " ipk.monitor.assign_point_monitor_in_object(\n",
+ " name=row[\"name\"],\n",
+ " monitor_quantity=\"Temperature\",\n",
+ " monitor_name=row[\"name\"],\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8e6177ea",
+ "metadata": {},
+ "source": [
+ "## Calculate the power assigned to all components"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "42ca2357",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "power_budget, total_power = ipk.post.power_budget(units=\"W\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4be813f1",
+ "metadata": {},
+ "source": [
+ "## Plot model using AEDT\n",
+ "\n",
+ "Set the colormap to use. You can use the previously computed power budget to set the minimum and maximum values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5eab415e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cmap = plt.get_cmap(\"plasma\")\n",
+ "norm = mpl.colors.Normalize(\n",
+ " vmin=min(power_budget.values()), vmax=max(power_budget.values())\n",
+ ")\n",
+ "scalarMap = cm.ScalarMappable(norm=norm, cmap=cmap)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "84e2557a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Color the objects depending\n",
+ "for obj in ipk.modeler.objects.values():\n",
+ " if obj.name in power_budget:\n",
+ " obj.color = [\n",
+ " int(i * 255) for i in scalarMap.to_rgba(power_budget[obj.name])[0:3]\n",
+ " ]\n",
+ " obj.transparency = 0\n",
+ " else:\n",
+ " obj.color = [0, 0, 0]\n",
+ " obj.transparency = 0.9"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "43b53dde",
+ "metadata": {},
+ "source": [
+ "Export the model image by creating a list of all objects that excludes ``Region``.\n",
+ "This list is then passed to the `export_model_picture()` function.\n",
+ "This approach ensures that the exported image is fitted to the PCB and its components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1c4d8214",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj_list_noregion = list(ipk.modeler.object_names)\n",
+ "obj_list_noregion.remove(\"Region\")\n",
+ "export_file = os.path.join(temp_folder.name, \"object_power_AEDTExport.jpg\")\n",
+ "ipk.post.export_model_picture(\n",
+ " export_file, selections=obj_list_noregion, width=1920, height=1080\n",
+ ")\n",
+ "Image(export_file)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53313e93",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# ### Plot model using PyAEDT\n",
+ "#\n",
+ "# Initialize a PyVista plotter\n",
+ "plotter = pv.Plotter(off_screen=True, window_size=[2048, 1536])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f2bebd55",
+ "metadata": {},
+ "source": [
+ "Export all models objects to OBJ files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "32e3f623",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "f = ipk.post.export_model_obj(\n",
+ " export_path=temp_folder.name, export_as_single_objects=True, air_objects=False\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac8ad73d",
+ "metadata": {},
+ "source": [
+ "Add objects to the PyVista plotter. These objects are either set to a black color or assigned scalar values,\n",
+ "allowing them to be visualized with a colormap."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "51e5ef29",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for file, color, opacity in f:\n",
+ " if color == (0, 0, 0):\n",
+ " plotter.add_mesh(mesh=pv.read(file), color=\"black\", opacity=opacity)\n",
+ " else:\n",
+ " mesh = pv.read(filename=file)\n",
+ " mesh[\"Power\"] = np.full(\n",
+ " shape=mesh.n_points, fill_value=power_budget[Path(file).stem]\n",
+ " )\n",
+ " plotter.add_mesh(mesh=mesh, scalars=\"Power\", cmap=\"viridis\", opacity=opacity)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d286891f",
+ "metadata": {},
+ "source": [
+ "Add a label to the object with the maximum temperature."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "902150f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "max_pow_obj = \"MP1\"\n",
+ "plotter.add_point_labels(\n",
+ " points=[ipk.modeler[max_pow_obj].top_face_z.center],\n",
+ " labels=[f\"{max_pow_obj}, {power_budget[max_pow_obj]}W\"],\n",
+ " point_size=20,\n",
+ " font_size=30,\n",
+ " text_color=\"red\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "32107ea2",
+ "metadata": {},
+ "source": [
+ "Export the file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "834a87f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "export_file = os.path.join(temp_folder.name, \"object_power_pyVista.png\")\n",
+ "plotter.screenshot(filename=export_file, scale=1)\n",
+ "Image(export_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a160af54",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1b33f8a5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "time.sleep(\n",
+ " 3\n",
+ ") # Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "daef81f3",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "97aae2fd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/ecad_import.ipynb.txt b/version/dev/_sources/examples/electrothermal/ecad_import.ipynb.txt
new file mode 100644
index 00000000..99c0c353
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/ecad_import.ipynb.txt
@@ -0,0 +1,317 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "62228d71",
+ "metadata": {},
+ "source": [
+ "# Import of a PCB and its components via IDF and EDB"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5ff95aa",
+ "metadata": {},
+ "source": [
+ "This example shows how to import a PCB and its components using IDF files (LDB and BDF).\n",
+ "You can also use a combination of EMN and EMP files in a similar way.\n",
+ "\n",
+ "Keywords: **Icepak**, **PCB**, **IDF**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c18b4ab0",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e5d0ed2c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5565f262",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core import Hfss3dLayout, Icepak"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "16fb7707",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e0a19b7b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ec5331d",
+ "metadata": {},
+ "source": [
+ "## Open project\n",
+ "\n",
+ "Open an empty project in non-graphical mode, using a temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92d5356d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "\n",
+ "ipk = Icepak(\n",
+ " project=os.path.join(temp_folder.name, \"Icepak_ECAD_Import.aedt\"),\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "541e5eb4",
+ "metadata": {},
+ "source": [
+ "## Import the IDF files\n",
+ "\n",
+ "Import the BDF and LDF files. Sample files are shown here.\n",
+ "\n",
+ "![](\"_static\\bdf.png\")
\n",
+ "\n",
+ "![](\"_static\\ldf.png\")
\n",
+ "\n",
+ "You can import the IDF files with several filtering options, including caps, resistors,\n",
+ "inductors, power, specific power, and size.\n",
+ "There are also options for PCB creation, including number of layers, copper percentages, and layer sizes.\n",
+ "\n",
+ "This example uses the default values for the PCB.\n",
+ "The imported PCB (from the IDF files) are deleted later and replaced by a PCB that has the trace\n",
+ "information (from ECAD) for higher accuracy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "52e91f1a",
+ "metadata": {},
+ "source": [
+ "Download ECAD and IDF files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bba7ac25",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def_path = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"icepak/Icepak_ECAD_Import/A1_uprev.aedb\",\n",
+ " name=\"edb.def\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "board_path = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"icepak/Icepak_ECAD_Import/\", name=\"A1.bdf\", destination=temp_folder.name\n",
+ ")\n",
+ "library_path = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"icepak/Icepak_ECAD_Import/\", name=\"A1.ldf\", destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78746ad7",
+ "metadata": {},
+ "source": [
+ "Import IDF file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "07b4f651",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.import_idf(board_path=board_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88cba287",
+ "metadata": {},
+ "source": [
+ "Save the project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bfb06f20",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "24a9d999",
+ "metadata": {},
+ "source": [
+ "## Import ECAD\n",
+ "Add an HFSS 3D Layout design with the layout information of the PCB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "05286480",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss3d_lo = Hfss3dLayout(project=def_path, version=AEDT_VERSION)\n",
+ "hfss3d_lo.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e65fc679",
+ "metadata": {},
+ "source": [
+ "Create a PCB component in Icepak linked to the HFSS 3D Layout project. The polygon ``\"poly_0\"``\n",
+ "is used as the outline of the PCB, and a dissipation of ``\"1W\"`` is applied to the PCB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ceb8b896",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_file = hfss3d_lo.project_file\n",
+ "design_name = hfss3d_lo.design_name"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b6ef88b6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.create_pcb_from_3dlayout(\n",
+ " component_name=\"PCB_pyAEDT\",\n",
+ " project_name=project_file,\n",
+ " design_name=design_name,\n",
+ " extent_type=\"Polygon\",\n",
+ " outline_polygon=\"poly_0\",\n",
+ " power_in=1,\n",
+ " close_linked_project_after_import=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0645aa0f",
+ "metadata": {},
+ "source": [
+ "Delete the simplified PCB object coming from the IDF import."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c9bca1d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler.delete_objects_containing(\"IDF_BoardOutline\", False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dee6f291",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7c3b793c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9da9ef81",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5d0b0391",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/electrothermal.ipynb.txt b/version/dev/_sources/examples/electrothermal/electrothermal.ipynb.txt
new file mode 100644
index 00000000..2da18efa
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/electrothermal.ipynb.txt
@@ -0,0 +1,540 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "135ab44f",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "# Electrothermal analysis\n",
+ "\n",
+ "This example shows how to use the EDB for DC IR analysis and\n",
+ "electrothermal analysis. The EDB is loaded into SIwave for analysis and postprocessing.\n",
+ "In the end, an Icepak project is exported from SIwave.\n",
+ "\n",
+ "- Set up EDB:\n",
+ " - Assign package and heatsink model to components.\n",
+ " - Create voltage and current sources.\n",
+ " - Create SIwave DC analysis.\n",
+ " - Define cutout.\n",
+ "- Import EDB into SIwave:\n",
+ " - Analyze DC IR.\n",
+ " - Export Icepak project."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0924ccc",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e429da21",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import os\n",
+ "import sys\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ed18e366",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core.downloads import download_file\n",
+ "from pyedb import Edb, Siwave"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22faf632",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff4d1df6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = True # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "93f06b18",
+ "metadata": {},
+ "source": [
+ "Check if AEDT is launched in graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7a00634f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if not NG_MODE:\n",
+ " print(\"Warning: this example requires graphical mode enabled.\")\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73f032d2",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "973aeb8e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "97ea1863",
+ "metadata": {},
+ "source": [
+ "Download the example PCB data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b04377d7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedb = download_file(source=\"edb/ANSYS-HSD_V1.aedb\", destination=temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a393437e",
+ "metadata": {},
+ "source": [
+ "## Create configuration file\n",
+ "\n",
+ "This example uses a configuration file to set up the layout for analysis.\n",
+ "Create an empty dictionary to host all configurations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a80b7849",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg = dict()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3862dd1",
+ "metadata": {},
+ "source": [
+ "## Add component thermal information and heatsink definition"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2f44ab63",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"package_definitions\"] = [\n",
+ " {\n",
+ " \"name\": \"package_1\",\n",
+ " \"component_definition\": \"SMTC-MECT-110-01-M-D-RA1_V\",\n",
+ " \"maximum_power\": 1,\n",
+ " \"therm_cond\": 1,\n",
+ " \"theta_jb\": 1,\n",
+ " \"theta_jc\": 1,\n",
+ " \"height\": \"2mm\",\n",
+ " \"heatsink\": {\n",
+ " \"fin_base_height\": \"2mm\",\n",
+ " \"fin_height\": \"4mm\",\n",
+ " \"fin_orientation\": \"x_oriented\",\n",
+ " \"fin_spacing\": \"1mm\",\n",
+ " \"fin_thickness\": \"1mm\",\n",
+ " },\n",
+ " \"apply_to_all\": False,\n",
+ " \"components\": [\"J5\"],\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4611454c",
+ "metadata": {},
+ "source": [
+ "## Create pin groups\n",
+ "\n",
+ "Group all pins on the \"GND\" net on the ``J5`` component into one group.\n",
+ "Pin groups are assigned by net name using the ``net`` key."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "31348862",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"pin_groups\"] = [{\"name\": \"J5_GND\", \"reference_designator\": \"J5\", \"net\": \"GND\"}]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e55296dc",
+ "metadata": {},
+ "source": [
+ "## Create current sources\n",
+ "\n",
+ "Create two current sources on the ``J5`` component.\n",
+ "A current source is placed between positive and negative terminals.\n",
+ "When the ``net`` keyword is used, all pins on the specified net are grouped into a\n",
+ "new pin group that is assigned as the positive terminal.\n",
+ "\n",
+ "Negative terminal can be assigned by pin group name by using the ``pin_group`` keyword.\n",
+ "The two current sources share the same ``J5_GND`` pin group as the negative terminal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f08b2045",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "i_src_1 = {\n",
+ " \"name\": \"J5_VCCR\",\n",
+ " \"reference_designator\": \"J5\",\n",
+ " \"type\": \"current\",\n",
+ " \"magnitude\": 0.5,\n",
+ " \"positive_terminal\": {\"net\": \"SFPA_VCCR\"},\n",
+ " \"negative_terminal\": {\"pin_group\": \"J5_GND\"}, # Defined in \"pin_groups\" section.\n",
+ "}\n",
+ "i_src_2 = {\n",
+ " \"name\": \"J5_VCCT\",\n",
+ " \"reference_designator\": \"J5\",\n",
+ " \"type\": \"current\",\n",
+ " \"magnitude\": 0.5,\n",
+ " \"positive_terminal\": {\"net\": \"SFPA_VCCT\"},\n",
+ " \"negative_terminal\": {\"pin_group\": \"J5_GND\"}, # Defined in \"pin_groups\" section.\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7aeab567",
+ "metadata": {},
+ "source": [
+ "## Create a voltage source\n",
+ "\n",
+ "Create a voltage source on the ``U4`` componebt between two nets using the ``net`` keyword."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "83a7031a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "v_src = {\n",
+ " \"name\": \"VSOURCE_5V\",\n",
+ " \"reference_designator\": \"U4\",\n",
+ " \"type\": \"voltage\",\n",
+ " \"magnitude\": 5,\n",
+ " \"positive_terminal\": {\"net\": \"5V\"},\n",
+ " \"negative_terminal\": {\"net\": \"GND\"},\n",
+ "}\n",
+ "\n",
+ "cfg[\"sources\"] = [v_src, i_src_1, i_src_2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e0accd2",
+ "metadata": {},
+ "source": [
+ "## Define cutout\n",
+ "\n",
+ "The following assignments define the region of the PCB to be cut out for analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "65720b2c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"operations\"] = {\n",
+ " \"cutout\": {\n",
+ " \"signal_list\": [\"SFPA_VCCR\", \"SFPA_VCCT\", \"5V\"],\n",
+ " \"reference_list\": [\"GND\"],\n",
+ " \"extent_type\": \"Bounding\",\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fb4b6ed9",
+ "metadata": {},
+ "source": [
+ "## Create SIwave DC analysis"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af0fdafa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"setups\"] = [\n",
+ " {\n",
+ " \"name\": \"siwave_dc\",\n",
+ " \"type\": \"siwave_dc\",\n",
+ " \"dc_slider_position\": 0,\n",
+ " \"dc_ir_settings\": {\"export_dc_thermal_data\": True},\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "960d91a4",
+ "metadata": {},
+ "source": [
+ "## Save configuration to a JSON file\n",
+ "\n",
+ "The configuration file can be saved in JSON format and applied to layout data using the EDB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "804d41ae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pi_json = os.path.join(temp_folder.name, \"pi.json\")\n",
+ "\n",
+ "with open(pi_json, \"w\") as f:\n",
+ " json.dump(cfg, f, indent=4, ensure_ascii=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5589f84a",
+ "metadata": {},
+ "source": [
+ "## Load configuration into EDB\n",
+ "\n",
+ "Load the configuration from the JSON file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "22044bde",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp = Edb(aedb, edbversion=AEDT_VERSION)\n",
+ "edbapp.configuration.load(config_file=pi_json)\n",
+ "edbapp.configuration.run()\n",
+ "edbapp.save()\n",
+ "edbapp.close()\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1600c7cc",
+ "metadata": {},
+ "source": [
+ "The configured EDB file is saved in the temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "84811b63",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d344444f",
+ "metadata": {},
+ "source": [
+ "## Analyze in SIwave\n",
+ "\n",
+ "Load EDB into SIwave."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cdce8b70",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siwave = Siwave(specified_version=AEDT_VERSION)\n",
+ "time.sleep(10)\n",
+ "siwave.open_project(proj_path=aedb)\n",
+ "siwave.save_project(projectpath=temp_folder.name, projectName=\"ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9048fd77",
+ "metadata": {},
+ "source": [
+ "## Analyze"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "157000b3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siwave.run_dc_simulation()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac402459",
+ "metadata": {},
+ "source": [
+ "## Export Icepak project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f990b598",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siwave.export_icepak_project(\n",
+ " os.path.join(temp_folder.name, \"from_siwave.aedt\"), \"siwave_dc\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "70f46be3",
+ "metadata": {},
+ "source": [
+ "## Close SIWave project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f274248e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siwave.close_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ded1c440",
+ "metadata": {},
+ "source": [
+ "## Shut down SIwave"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "000a92d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siwave.quit_application()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11904458",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.dir``. If you've run this example as a Jupyter notbook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d6804a22",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "time.sleep(3)\n",
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/graphic_card.ipynb.txt b/version/dev/_sources/examples/electrothermal/graphic_card.ipynb.txt
new file mode 100644
index 00000000..024457d0
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/graphic_card.ipynb.txt
@@ -0,0 +1,742 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4a228ece",
+ "metadata": {},
+ "source": [
+ "# Graphic card thermal analysis"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3c1fd34",
+ "metadata": {},
+ "source": [
+ "This example shows how to use pyAEDT to create a graphic card setup in\n",
+ "Icepak and postprocess the results.\n",
+ "The example file is an Icepak project with a model that is already created and\n",
+ "has materials assigned.\n",
+ "\n",
+ "Keywords: **Icepak**, **boundary conditions**, **postprocessing**, **monitors**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ee0c348f",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4be8525d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b7d1008e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import pandas as pd\n",
+ "from IPython.display import Image"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7dc0602c",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53742c97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Do not show the graphical user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "77d95b0f",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download project\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eb7b22bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "project_temp_name = ansys.aedt.core.downloads.download_icepak(\n",
+ " destination=temp_folder.name\n",
+ ")\n",
+ "# ## Open project\n",
+ "#\n",
+ "# Open the project without the GUI."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d63ae0d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = ansys.aedt.core.Icepak(\n",
+ " project=project_temp_name,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa3d112c",
+ "metadata": {},
+ "source": [
+ "## Plot model and rotate\n",
+ "\n",
+ "Plot the model using the pyAEDT-PyVista integration and save the result to a file.\n",
+ "Rotate the model and plot the rotated model again."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "20f474b2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot1 = ipk.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Graphics_card_1.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")\n",
+ "\n",
+ "ipk.modeler.rotate(ipk.modeler.object_names, \"X\")\n",
+ "\n",
+ "plot2 = ipk.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Graphics_card_2.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "19f17b00",
+ "metadata": {},
+ "source": [
+ "## Define boundary conditions\n",
+ "\n",
+ "Create source blocks on the CPU and memories."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d8628440",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.create_source_block(object_name=\"CPU\", input_power=\"25W\")\n",
+ "ipk.create_source_block(object_name=[\"MEMORY1\", \"MEMORY1_1\"], input_power=\"5W\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3172f767",
+ "metadata": {},
+ "source": [
+ "The air region object handler is used to specify the inlet (fixed velocity condition) and outlet\n",
+ "(fixed pressure condition) at x_max and x_min."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2f76e167",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = ipk.modeler[\"Region\"]\n",
+ "ipk.assign_pressure_free_opening(\n",
+ " assignment=region.top_face_x.id, boundary_name=\"Outlet\"\n",
+ ")\n",
+ "ipk.assign_velocity_free_opening(\n",
+ " assignment=region.bottom_face_x.id,\n",
+ " boundary_name=\"Inlet\",\n",
+ " velocity=[\"1m_per_sec\", \"0m_per_sec\", \"0m_per_sec\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cfe2b583",
+ "metadata": {},
+ "source": [
+ "## Assign mesh settings\n",
+ "\n",
+ "### Assign mesh region\n",
+ "Assign a mesh region around the heat sink and CPU."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e4d2f49e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh_region = ipk.mesh.assign_mesh_region(assignment=[\"HEAT_SINK\", \"CPU\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1790668e",
+ "metadata": {},
+ "source": [
+ "Print the available settings for the mesh region"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b72f01bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh_region.settings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f84030e7",
+ "metadata": {},
+ "source": [
+ "Set the mesh region settings to manual and see newly available settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ddd55c37",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh_region.manual_settings = True\n",
+ "mesh_region.settings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8468755a",
+ "metadata": {},
+ "source": [
+ "Modify settings and update."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5482444d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh_region.settings[\"MaxElementSizeX\"] = \"2mm\"\n",
+ "mesh_region.settings[\"MaxElementSizeY\"] = \"2mm\"\n",
+ "mesh_region.settings[\"MaxElementSizeZ\"] = \"2mm\"\n",
+ "mesh_region.settings[\"EnableMLM\"] = True\n",
+ "mesh_region.settings[\"MaxLevels\"] = \"2\"\n",
+ "mesh_region.settings[\"MinElementsInGap\"] = 4\n",
+ "mesh_region.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "261f7d7b",
+ "metadata": {},
+ "source": [
+ "Modify the slack of the subregion around the objects."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9a3ee4a1",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "subregion = mesh_region.assignment\n",
+ "subregion.positive_x_padding = \"20mm\"\n",
+ "subregion.positive_y_padding = \"5mm\"\n",
+ "subregion.positive_z_padding = \"5mm\"\n",
+ "subregion.negative_x_padding = \"5mm\"\n",
+ "subregion.negative_y_padding = \"5mm\"\n",
+ "subregion.negative_z_padding = \"10mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "502c02cb",
+ "metadata": {},
+ "source": [
+ "## Assign monitors\n",
+ "\n",
+ "Assign a temperature face monitor to the CPU face in contact with the heatsink."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ac940303",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cpu = ipk.modeler[\"CPU\"]\n",
+ "m1 = ipk.monitor.assign_face_monitor(\n",
+ " face_id=cpu.top_face_z.id,\n",
+ " monitor_quantity=\"Temperature\",\n",
+ " monitor_name=\"TemperatureMonitor1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fb517baf",
+ "metadata": {},
+ "source": [
+ "Assign multiple speed point monitors downstream of the assembly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9af1c849",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "speed_monitors = []\n",
+ "for x_pos in range(0, 10, 2):\n",
+ " m = ipk.monitor.assign_point_monitor(\n",
+ " point_position=[f\"{x_pos}mm\", \"40mm\", \"15mm\"], monitor_quantity=\"Speed\"\n",
+ " )\n",
+ " speed_monitors.append(m)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c412560",
+ "metadata": {},
+ "source": [
+ "## Solve project\n",
+ "\n",
+ "Create a setup, modify solver settings, and run the simulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cb6be5e2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = ipk.create_setup()\n",
+ "setup1.props[\"Flow Regime\"] = \"Turbulent\"\n",
+ "setup1.props[\"Convergence Criteria - Max Iterations\"] = 5\n",
+ "setup1.props[\"Linear Solver Type - Pressure\"] = \"flex\"\n",
+ "setup1.props[\"Linear Solver Type - Temperature\"] = \"flex\"\n",
+ "ipk.save_project()\n",
+ "ipk.analyze(setup=setup1.name, cores=NUM_CORES, tasks=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4eeb5d3d",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "### Perform quantitative postprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2b3ccfc8",
+ "metadata": {},
+ "source": [
+ "Get the point monitor data. A dictionary is returned with ``'Min'``, ``'Max'``, and ``'Mean'`` keys."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "83218f77",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temperature_data = ipk.post.evaluate_monitor_quantity(\n",
+ " monitor=m1, quantity=\"Temperature\"\n",
+ ")\n",
+ "temperature_data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f30ef06e",
+ "metadata": {},
+ "source": [
+ "It is also possible to get the data as a Pandas dataframe for advanced postprocessing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "706ceb9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "speed_fs = ipk.post.create_field_summary()\n",
+ "for m_name in speed_monitors:\n",
+ " speed_fs.add_calculation(\n",
+ " entity=\"Monitor\", geometry=\"Volume\", geometry_name=m_name, quantity=\"Speed\"\n",
+ " )\n",
+ "speed_data = speed_fs.get_field_summary_data(pandas_output=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b790873e",
+ "metadata": {},
+ "source": [
+ "All the data is now in a dataframe, making it easy to visualize and manipulate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eadeae40",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "speed_data.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6342b03e",
+ "metadata": {},
+ "source": [
+ "The ``speed_data`` dataframe contains data from monitors, so it can be expanded with information\n",
+ "of their position."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c02bb5be",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in range(3):\n",
+ " direction = [\"X\", \"Y\", \"Z\"][i]\n",
+ " speed_data[\"Position\" + direction] = [\n",
+ " ipk.monitor.all_monitors[entity].location[i] for entity in speed_data[\"Entity\"]\n",
+ " ]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "264d32be",
+ "metadata": {},
+ "source": [
+ "Plot the velocity profile at different X positions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "067a2295",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "speed_data.plot(\n",
+ " x=\"PositionX\",\n",
+ " y=\"Mean\",\n",
+ " kind=\"line\",\n",
+ " marker=\"o\",\n",
+ " ylabel=speed_data.at[0, \"Quantity\"],\n",
+ " xlabel=f\"x [{ipk.modeler.model_units}]\",\n",
+ " grid=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fc4c4e55",
+ "metadata": {},
+ "source": [
+ "Extract temperature data at those same locations (so the ``speed_monitors`` list is used)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "074bc141",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temperature_fs = ipk.post.create_field_summary()\n",
+ "for m_name in speed_monitors:\n",
+ " temperature_fs.add_calculation(\n",
+ " entity=\"Monitor\",\n",
+ " geometry=\"Volume\",\n",
+ " geometry_name=m_name,\n",
+ " quantity=\"Temperature\",\n",
+ " )\n",
+ "temperature_fs = temperature_fs.get_field_summary_data(pandas_output=True)\n",
+ "temperature_fs.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aad28d46",
+ "metadata": {},
+ "source": [
+ "The two dataframes can be merged using the `pd.merge()` function. With the merge, suffixes are\n",
+ "added to the column names to differentiate between the columns from each original dataframe."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "55df38c7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "merged_df = pd.merge(\n",
+ " temperature_fs, speed_data, on=\"Entity\", suffixes=(\"_temperature\", \"_speed\")\n",
+ ")\n",
+ "merged_df.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6823643d",
+ "metadata": {},
+ "source": [
+ "The column names are renamed based on the ``Quantity`` column of the original dataframes.\n",
+ "Finally, only the ``'Entity'``, ``'Mean_temperature'``, and ``'Mean_speed'`` columns are selected and\n",
+ "assigned to the merged dataframe."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "71af4e3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temperature_quantity = temperature_fs[\"Quantity\"].iloc[0]\n",
+ "velocity_quantity = speed_data[\"Quantity\"].iloc[0]\n",
+ "merged_df.rename(\n",
+ " columns={\"Mean_temperature\": temperature_quantity, \"Mean_speed\": velocity_quantity},\n",
+ " inplace=True,\n",
+ ")\n",
+ "merged_df = merged_df[\n",
+ " [\n",
+ " \"Entity\",\n",
+ " temperature_quantity,\n",
+ " velocity_quantity,\n",
+ " \"PositionX\",\n",
+ " \"PositionY\",\n",
+ " \"PositionZ\",\n",
+ " ]\n",
+ "]\n",
+ "merged_df.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd048b12",
+ "metadata": {},
+ "source": [
+ "Compute the correlation coefficient between velocity and temperature from the merged dataframe\n",
+ "and plot a scatter plot to visualize their relationship."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c639584f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "correlation = merged_df[velocity_quantity].corr(merged_df[temperature_quantity])\n",
+ "ax = merged_df.plot.scatter(x=velocity_quantity, y=temperature_quantity)\n",
+ "ax.set_xlabel(velocity_quantity)\n",
+ "ax.set_ylabel(temperature_quantity)\n",
+ "ax.set_title(f\"Correlation between Temperature and Velocity: {correlation:.2f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34247816",
+ "metadata": {},
+ "source": [
+ "The further away from the assembly, the faster and colder the air due to mixing.\n",
+ "Despite being extremely simple, this example demonstrates the potential of importing field\n",
+ "summary data into Pandas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "09d3f95d",
+ "metadata": {},
+ "source": [
+ "### Perform qualitative Postprocessing\n",
+ "Create a temperature plot on main components and export it to a PNG file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ac3f4660",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "surflist = [i.id for i in ipk.modeler[\"CPU\"].faces]\n",
+ "surflist += [i.id for i in ipk.modeler[\"MEMORY1\"].faces]\n",
+ "surflist += [i.id for i in ipk.modeler[\"MEMORY1_1\"].faces]\n",
+ "plot3 = ipk.post.create_fieldplot_surface(\n",
+ " assignment=surflist, quantity=\"SurfTemperature\"\n",
+ ")\n",
+ "path = plot3.export_image(\n",
+ " full_path=os.path.join(temp_folder.name, \"temperature.png\"),\n",
+ " orientation=\"top\",\n",
+ " show_region=False,\n",
+ ")\n",
+ "Image(filename=path) # Display the image"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7cdb089",
+ "metadata": {},
+ "source": [
+ "Use PyVista to display the temperature map."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7f350d51",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot4 = ipk.post.plot_field(\n",
+ " quantity=\"Temperature\",\n",
+ " assignment=[\n",
+ " \"SERIAL_PORT\",\n",
+ " \"MEMORY1\",\n",
+ " \"MEMORY1_1\",\n",
+ " \"CAPACITOR\",\n",
+ " \"CAPACITOR_1\",\n",
+ " \"KB\",\n",
+ " \"HEAT_SINK\",\n",
+ " \"CPU\",\n",
+ " \"ALPHA_MAIN_PCB\",\n",
+ " ],\n",
+ " plot_cad_objs=False,\n",
+ " show=False,\n",
+ " export_path=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5ed54886",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e6082981",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5bc55a0d",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d958ed66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/icepak_circuit_hfss_coupling.ipynb.txt b/version/dev/_sources/examples/electrothermal/icepak_circuit_hfss_coupling.ipynb.txt
new file mode 100644
index 00000000..8f952dfc
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/icepak_circuit_hfss_coupling.ipynb.txt
@@ -0,0 +1,675 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "5c885ae3",
+ "metadata": {},
+ "source": [
+ "# Circuit-HFSS-Icepak coupling workflow\n",
+ "\n",
+ "This example shows how to create a two-way coupling\n",
+ "between HFSS and Icepak.\n",
+ "\n",
+ "Consider a design where some components are simulated in\n",
+ "HFSS with a full 3D model, while others are simulated in Circuit as lumped elements.\n",
+ "The electrical simulation is done by placing the HFSS design into a Circuit design as\n",
+ "a subcomponent and connecting the lumped components to its ports.\n",
+ "\n",
+ "The purpose of the workflow is to perform a thermal simulation\n",
+ "of the Circuit-HFSS design, creating a two-way coupling with Icepak\n",
+ "that allows running multiple iterations. The losses from both designs\n",
+ "are accounted for.\n",
+ "- EM losses are evaluated by the HFSS solver and fed into Icepak via a direct link.\n",
+ "- Losses from the lumped components in the Circuit design are evaluated\n",
+ "analytically and must be manually set into the Icepak boundary.\n",
+ "\n",
+ "On the back of the coupling, temperature information\n",
+ "is handled differently for HFSS and Circuit.\n",
+ "\n",
+ "- For HFSS, a temperature map is exported from the Icepak design and used to create a\n",
+ "3D dataset. Then, the material properties in the HFSS design are updated based on this\n",
+ "dataset.\n",
+ "- For Circuit, the average temperature of the lumped components is extracted from the\n",
+ "Icepak design and used to update the temperature-dependent characteristics of the\n",
+ "lumped components in Circuit.\n",
+ "\n",
+ "The Circuit design in this example contains only a\n",
+ "resistor component, with temperature-dependent resistance\n",
+ "described by this formula: ``0.162*(1+0.004*(TempE-TempE0))``,\n",
+ "where TempE is the current temperature and TempE0 is the\n",
+ "ambient temperature. The HFSS design includes only a cylinder\n",
+ "with temperature-dependent material conductivity, defined by\n",
+ "a 2D dataset. The resistor and the cylinder have\n",
+ "matching resistances.\n",
+ "\n",
+ "Keywords: **Multiphysics**, **HFSS**, **Icepak**, **Circuit**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cec0de88",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cc925ded",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "36eb221d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core as aedt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "818b3271",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8bda42f4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "62533b2e",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fbe71bbe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e827810f",
+ "metadata": {},
+ "source": [
+ "## Download and open project\n",
+ "\n",
+ "Download and open the project. Save it to the temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d204636d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = aedt.downloads.download_file(\n",
+ " \"circuit_hfss_icepak\", \"Circuit-HFSS-Icepak-workflow.aedtz\", temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "445fca08",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and initialize HFSS\n",
+ "\n",
+ "Launch AEDT and initialize HFSS. If there is an active HFSS design, the ``hfss``\n",
+ "object is linked to it. Otherwise, a new design is created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ddc662f7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit = aedt.Circuit(\n",
+ " project=project_name,\n",
+ " new_desktop=True,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2b94d31c",
+ "metadata": {},
+ "source": [
+ "## Set variable names\n",
+ "\n",
+ "Set the name of the resistor in Circuit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "39a0d5f3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "resistor_body_name = \"Circuit_Component\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9ee23752",
+ "metadata": {},
+ "source": [
+ "Set the name of the cylinder body in HFSS."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "55bb3e12",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "device3D_body_name = \"Device_3D\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "16d41209",
+ "metadata": {},
+ "source": [
+ "## Get HFSS design\n",
+ "\n",
+ "Get the HFSS design and prepare the material for the thermal link."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6aedf41e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = aedt.Hfss(project=circuit.project_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "838a36a9",
+ "metadata": {},
+ "source": [
+ "## Create a material\n",
+ "\n",
+ "Create a material to be used to set the temperature map on it.\n",
+ "The material is created by duplicating the material assigned to the cylinder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "96e80c5c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "material_name = hfss.modeler.objects_by_name[device3D_body_name].material_name\n",
+ "new_material_name = material_name + \"_dataset\"\n",
+ "new_material = hfss.materials.duplicate_material(\n",
+ " material=material_name, name=new_material_name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4e9b28f6",
+ "metadata": {},
+ "source": [
+ "## Modify material properties\n",
+ "\n",
+ "Save the conductivity value. It is used later in the iterations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c25df4b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "old_conductivity = new_material.conductivity.value"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d80226d6",
+ "metadata": {},
+ "source": [
+ "Assign the new material to the cylinder object in HFSS."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ea6a6116",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.objects_by_name[device3D_body_name].material_name = new_material_name"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3763d282",
+ "metadata": {},
+ "source": [
+ "Because this material has a high conductivity, HFSS automatically deactivates ``solve_inside``.\n",
+ "It must be turned back on to evaluate the losses inside the cylinder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9b9454bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.objects_by_name[device3D_body_name].solve_inside = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7d474ba",
+ "metadata": {},
+ "source": [
+ "## Get Icepak design"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b9c07a5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "icepak = aedt.Icepak(project=circuit.project_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21e6c139",
+ "metadata": {},
+ "source": [
+ "## Set parameters for iterations\n",
+ "\n",
+ "Set the initial temperature to a value closer to the final one, to speed up the convergence."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bbe86c73",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit[\"TempE\"] = \"300cel\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "24f09e8b",
+ "metadata": {},
+ "source": [
+ "Set the maximum number of iterations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "de9e01a3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "max_iter = 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "628fe956",
+ "metadata": {},
+ "source": [
+ "Set the residual convergence criteria to stop the iterations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06fa02ea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_residual_limit = 0.02\n",
+ "loss_residual_limit = 0.02"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8b9d96f1",
+ "metadata": {},
+ "source": [
+ "This variable is to contain iteration statistics."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0b3fa01c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "stats = {}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "901c2f77",
+ "metadata": {},
+ "source": [
+ "## Start iterations\n",
+ "\n",
+ "Each ``for`` loop is a complete two-way iteration.\n",
+ "The code is thoroughly commented.\n",
+ "For a full understanding, read the inline comments carefully."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dde1a61c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for cp_iter in range(1, max_iter + 1):\n",
+ " stats[cp_iter] = {}\n",
+ "\n",
+ " # Step 1: Solve the HFSS design.\n",
+ " #\n",
+ " # Solve the HFSS design.\n",
+ " hfss.analyze(cores=NUM_CORES)\n",
+ "\n",
+ " # Step 2: Refresh the dynamic link and solve the Circuit design.\n",
+ " #\n",
+ " # Find the HFSS subcomponent in Circuit.\n",
+ " # This information is required by the ``refresh_dynamic_link()`` and ``push_excitations()`` methods.\n",
+ " hfss_component_name = \"\"\n",
+ " hfss_instance_name = \"\"\n",
+ " for component in circuit.modeler.components.components.values():\n",
+ " if (\n",
+ " component.model_name is not None\n",
+ " and hfss.design_name in component.model_name\n",
+ " ):\n",
+ " hfss_component_name = component.model_name\n",
+ " hfss_instance_name = component.refdes\n",
+ " break\n",
+ " if not hfss_component_name or not hfss_instance_name:\n",
+ " raise \"Hfss component not found in Circuit design\"\n",
+ "\n",
+ " # Refresh the dynamic link.\n",
+ " circuit.modeler.schematic.refresh_dynamic_link(name=hfss_component_name)\n",
+ "\n",
+ " # Solve the Circuit design.\n",
+ " circuit.analyze()\n",
+ "\n",
+ " # Step 3: Push the excitations. (HFSS design results are scaled automatically.)\n",
+ " #\n",
+ " # Push the excitations.\n",
+ " circuit.push_excitations(instance=hfss_instance_name)\n",
+ "\n",
+ " # Step 4: Extract the resistor's power loss value from the Circuit design.\n",
+ " #\n",
+ " # Evaluate the power loss on the resistor.\n",
+ " r_losses = circuit.post.get_solution_data(\n",
+ " expressions=\"0.5*mag(I(I1)*V(V1))\"\n",
+ " ).data_magnitude()[0]\n",
+ "\n",
+ " # Save the losses in the stats.\n",
+ " stats[cp_iter][\"losses\"] = r_losses\n",
+ "\n",
+ " # Step 5: Set the resistor's power loss value in the Icepak design (block thermal condition)\n",
+ " #\n",
+ " # Find the solid block boundary in Icepak.\n",
+ " boundaries = icepak.boundaries\n",
+ " boundary = None\n",
+ " for bb in boundaries:\n",
+ " if bb.name == \"Block1\":\n",
+ " boundary = bb\n",
+ " break\n",
+ " if not boundary:\n",
+ " raise \"Block boundary not defined in Icepak design.\"\n",
+ "\n",
+ " # Set the resistor's power loss in the Block Boundary.\n",
+ " boundary.props[\"Total Power\"] = str(r_losses) + \"W\"\n",
+ "\n",
+ " # Step 6: Solve the Icepak design.\n",
+ " #\n",
+ " # Clear linked data. Otherwise, Icepak continues to run the simulation with the initial losses.\n",
+ " icepak.clear_linked_data()\n",
+ "\n",
+ " # Solve the Icepak design.\n",
+ " icepak.analyze(cores=NUM_CORES)\n",
+ "\n",
+ " # Step 7: Export the temperature map from the Icepak design and create a new 3D dataset with it.\n",
+ " #\n",
+ " # Export the temperature map to a file.\n",
+ " fld_filename = os.path.join(\n",
+ " icepak.working_directory, f\"temperature_map_{cp_iter}.fld\"\n",
+ " )\n",
+ " icepak.post.export_field_file(\n",
+ " quantity=\"Temp\",\n",
+ " output_file=fld_filename,\n",
+ " assignment=\"AllObjects\",\n",
+ " objects_type=\"Vol\",\n",
+ " )\n",
+ "\n",
+ " # Convert the FLD file into a dataset tab file compatible with the dataset import.\n",
+ " # The existing header lines must be removed and replaced with a single header line\n",
+ " # containing the value unit.\n",
+ " with open(fld_filename, \"r\") as f:\n",
+ " lines = f.readlines()\n",
+ "\n",
+ " _ = lines.pop(0)\n",
+ " _ = lines.pop(0)\n",
+ " lines.insert(0, '\"X\" \"Y\" \"Z\" \"cel\"\\n')\n",
+ "\n",
+ " basename, _ = os.path.splitext(fld_filename)\n",
+ " tab_filename = basename + \"_dataset.tab\"\n",
+ "\n",
+ " with open(tab_filename, \"w\") as f:\n",
+ " f.writelines(lines)\n",
+ "\n",
+ " # Import the 3D dataset.\n",
+ " dataset_name = f\"temp_map_step_{cp_iter}\"\n",
+ " hfss.import_dataset3d(\n",
+ " input_file=tab_filename, name=dataset_name, is_project_dataset=True\n",
+ " )\n",
+ "\n",
+ " # Step 8: Update material properties in the HFSS design based on the new dataset.\n",
+ " #\n",
+ " # Set the new conductivity value.\n",
+ " new_material.conductivity.value = (\n",
+ " f\"{old_conductivity}*Pwl($TempDepCond,clp(${dataset_name},X,Y,Z))\"\n",
+ " )\n",
+ "\n",
+ " # Switch off the thermal modifier of the material, if any.\n",
+ " new_material.conductivity.thermalmodifier = None\n",
+ "\n",
+ " # Step 9: Extract the average temperature of the resistor from the Icepak design.\n",
+ " #\n",
+ " # Get the mean temperature value on the high-resistivity object.\n",
+ " mean_temp = icepak.post.get_scalar_field_value(\n",
+ " quantity=\"Temp\", scalar_function=\"Mean\", object_name=resistor_body_name\n",
+ " )\n",
+ "\n",
+ " # Save the temperature in the iteration statistics.\n",
+ " stats[cp_iter][\"temp\"] = mean_temp\n",
+ "\n",
+ " # Step 10: Update the resistance value in the Circuit design.\n",
+ " #\n",
+ " # Set this temperature in Circuit in the ``TempE`` variable.\n",
+ " circuit[\"TempE\"] = f\"{mean_temp}cel\"\n",
+ "\n",
+ " # Save the project\n",
+ " circuit.save_project()\n",
+ "\n",
+ " # Check the convergence of the iteration\n",
+ " #\n",
+ " # Evaluate the relative residuals on temperature and losses.\n",
+ " # If the residuals are smaller than the threshold, set the convergence flag to ``True```.\n",
+ " # Residuals are calculated starting from the second iteration.\n",
+ " converged = False\n",
+ " stats[cp_iter][\"converged\"] = converged\n",
+ " if cp_iter > 1:\n",
+ " delta_temp = abs(stats[cp_iter][\"temp\"] - stats[cp_iter - 1][\"temp\"]) / abs(\n",
+ " stats[cp_iter - 1][\"temp\"]\n",
+ " )\n",
+ " delta_losses = abs(\n",
+ " stats[cp_iter][\"losses\"] - stats[cp_iter - 1][\"losses\"]\n",
+ " ) / abs(stats[cp_iter - 1][\"losses\"])\n",
+ " if delta_temp <= temp_residual_limit and delta_losses <= loss_residual_limit:\n",
+ " converged = True\n",
+ " stats[cp_iter][\"converged\"] = converged\n",
+ " else:\n",
+ " delta_temp = None\n",
+ " delta_losses = None\n",
+ "\n",
+ " # Save the relative residuals in the iteration stats.\n",
+ " stats[cp_iter][\"delta_temp\"] = delta_temp\n",
+ " stats[cp_iter][\"delta_losses\"] = delta_losses\n",
+ "\n",
+ " # Exit from the loop if the convergence is reached.\n",
+ " if converged:\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c8a014b",
+ "metadata": {},
+ "source": [
+ "## Print overall statistics\n",
+ "\n",
+ "Print the overall statistics for the multiphysics loop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cbd1e434",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for i in stats:\n",
+ " txt = \"yes\" if stats[i][\"converged\"] else \"no\"\n",
+ " delta_temp = (\n",
+ " f\"{stats[i]['delta_temp']:.4f}\"\n",
+ " if stats[i][\"delta_temp\"] is not None\n",
+ " else \"None\"\n",
+ " )\n",
+ " delta_losses = (\n",
+ " f\"{stats[i]['delta_losses']:.4f}\"\n",
+ " if stats[i][\"delta_losses\"] is not None\n",
+ " else \"None\"\n",
+ " )\n",
+ " print(\n",
+ " f\"Step {i}: temp={stats[i]['temp']:.3f}, losses={stats[i]['losses']:.3f}, \"\n",
+ " f\"delta_temp={delta_temp}, delta_losses={delta_losses}, \"\n",
+ " f\"converged={txt}\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b30a3215",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f1d27630",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "icepak.save_project()\n",
+ "icepak.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64c538c3",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3206b82c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/electrothermal/index.rst.txt b/version/dev/_sources/examples/electrothermal/index.rst.txt
new file mode 100644
index 00000000..b6322b74
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/index.rst.txt
@@ -0,0 +1,146 @@
+Electrothermal
+~~~~~~~~~~~~~~
+
+These examples use PyAEDT to show electrothermal capabilities of AEDT
+
+.. grid:: 2
+
+ .. grid-item-card:: PCB component definition from CSV file and model image exports
+ :padding: 2 2 2 2
+ :link: components_csv
+ :link-type: doc
+
+ .. image:: _static/icepak_csv.png
+ :alt: Icepak CSV
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create different types of blocks and assign power and material to them using a CSV input file.
+
+
+ .. grid-item-card:: Import of a PCB and its components via IDF and EDB
+ :padding: 2 2 2 2
+ :link: ecad_import
+ :link-type: doc
+
+ .. image:: _static/ecad.png
+ :alt: Icepak ECAD
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to import a PCB and its components using IDF files (LDB and BDF).
+ You can also use a combination of EMN and EMP files in a similar way.
+
+
+ .. grid-item-card:: Thermal analysis with 3D components
+ :padding: 2 2 2 2
+ :link: component_3d
+ :link-type: doc
+
+ .. image:: _static/component.png
+ :alt: Thermal component
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a thermal analysis of an electronic package by taking advantage of 3D components with advanced features added by PyAEDT.
+
+
+ .. grid-item-card:: Graphic card thermal analysis
+ :padding: 2 2 2 2
+ :link: graphic_card
+ :link-type: doc
+
+ .. image:: _static/graphic.png
+ :alt: Graphic card
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use pyAEDT to create a graphic card setup in Icepak and postprocess the results.
+ The example file is an Icepak project with a model that is already created and has materials assigned.
+
+
+ .. grid-item-card:: Coaxial
+ :padding: 2 2 2 2
+ :link: coaxial_hfss_icepak
+ :link-type: doc
+
+ .. image:: _static/coaxial.png
+ :alt: Coaxial
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a project from scratch in HFSS and Icepak.
+
+
+ .. grid-item-card:: Setup from Sherlock inputs
+ :padding: 2 2 2 2
+ :link: sherlock
+ :link-type: doc
+
+ .. image:: _static/sherlock.png
+ :alt: Sherlock PCB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create an Icepak project from Sherlock files (STEP and CSV) and an AEDB board.
+
+ .. grid-item-card:: Circuit-HFSS-Icepak coupling workflow
+ :padding: 2 2 2 2
+ :link: icepak_circuit_hfss_coupling
+ :link-type: doc
+
+ .. image:: _static/ring.png
+ :alt: Ring
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a two-way coupling between HFSS and Icepak.
+
+
+ .. grid-item-card:: Electrothermal analysis
+ :padding: 2 2 2 2
+ :link: electrothermal
+ :link-type: doc
+
+ .. image:: _static/electrothermal.png
+ :alt: Electrothermal
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use the EDB for DC IR analysis and electrothermal analysis.
+ The EDB is loaded into SIwave for analysis and postprocessing.
+ In the end, an Icepak project is exported from SIwave.
+
+
+ .. grid-item-card:: Maxwell 3D-Icepak electrothermal analysis
+ :padding: 2 2 2 2
+ :link: ../low_frequency/multiphysics/maxwell_icepak
+ :link-type: doc
+
+ .. image:: ../low_frequency/multiphysics/_static/charging.png
+ :alt: Charging
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses PyAEDT to set up a simple Maxwell design consisting of a coil and a ferrite core.
+
+.. toctree::
+ :hidden:
+
+ components_csv
+ ecad_import
+ graphic_card
+ coaxial_hfss_icepak
+ sherlock
+ icepak_circuit_hfss_coupling
+ electrothermal
+ ../low_frequency/multiphysics/maxwell_icepak
diff --git a/version/dev/_sources/examples/electrothermal/sherlock.ipynb.txt b/version/dev/_sources/examples/electrothermal/sherlock.ipynb.txt
new file mode 100644
index 00000000..dfaabd4b
--- /dev/null
+++ b/version/dev/_sources/examples/electrothermal/sherlock.ipynb.txt
@@ -0,0 +1,515 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "91400903",
+ "metadata": {},
+ "source": [
+ "# Setup from Sherlock inputs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "82908d28",
+ "metadata": {},
+ "source": [
+ "This example shows how to create an Icepak project from Sherlock\n",
+ "files (STEP and CSV) and an AEDB board.\n",
+ "\n",
+ "Keywords: **Icepak**, **Sherlock**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "50fb8a90",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4e8c27f6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "18b1101d",
+ "metadata": {},
+ "source": [
+ "Define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fd0abdea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99447076",
+ "metadata": {},
+ "source": [
+ "## Set paths and define input files and variables\n",
+ "\n",
+ "Set paths."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "56d2df1e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "input_dir = ansys.aedt.core.downloads.download_sherlock(destination=temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b76b789",
+ "metadata": {},
+ "source": [
+ "Define input files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f42e65d8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "material_name = \"MaterialExport.csv\"\n",
+ "component_properties = \"TutorialBoardPartsList.csv\"\n",
+ "component_step = \"TutorialBoard.stp\"\n",
+ "aedt_odb_project = \"SherlockTutorial.aedt\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e750ae7a",
+ "metadata": {},
+ "source": [
+ "Define variables that are needed later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "67eb9202",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt_odb_design_name = \"PCB\"\n",
+ "outline_polygon_name = \"poly_14188\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e0e43b4b",
+ "metadata": {},
+ "source": [
+ "Define input files with paths."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e1509323",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "material_list = os.path.join(input_dir, material_name)\n",
+ "component_list = os.path.join(input_dir, component_properties)\n",
+ "validation = os.path.join(temp_folder.name, \"validation.log\")\n",
+ "file_path = os.path.join(input_dir, component_step)\n",
+ "project_name = os.path.join(temp_folder.name, component_step[:-3] + \"aedt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3ebfd3a",
+ "metadata": {},
+ "source": [
+ "## Create Icepak model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f961be3f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = ansys.aedt.core.Icepak(\n",
+ " project=project_name, version=AEDT_VERSION, non_graphical=NG_MODE\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "14fd5dd2",
+ "metadata": {},
+ "source": [
+ "Disable autosave to speed up the import."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "42c5fe7b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.autosave_disable()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a49c868",
+ "metadata": {},
+ "source": [
+ "Import a PCB from an AEDB file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "02e07cb9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "odb_path = os.path.join(input_dir, aedt_odb_project)\n",
+ "ipk.create_pcb_from_3dlayout(\n",
+ " component_name=\"Board\", project_name=odb_path, design_name=aedt_odb_design_name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a017dd39",
+ "metadata": {},
+ "source": [
+ "Create an offset coordinate system to match ODB++ with the Sherlock STEP file.\n",
+ "The thickness is computed from the ``\"Board\"`` component. (``\"Board1\"`` is the\n",
+ "instance name of the ``\"Board\"`` native component and is used to offset the coordinate system.)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "497162f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bb = ipk.modeler.user_defined_components[\"Board1\"].bounding_box\n",
+ "stackup_thickness = bb[-1] - bb[2]\n",
+ "ipk.modeler.create_coordinate_system(\n",
+ " origin=[0, 0, stackup_thickness / 2], mode=\"view\", view=\"XY\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0c6bcfd6",
+ "metadata": {},
+ "source": [
+ "Import the board components from an MCAD file and remove the PCB object as it is already\n",
+ "imported with the ECAD."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e48910ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler.import_3d_cad(file_path, refresh_all_ids=False)\n",
+ "ipk.modeler.delete_objects_containing(\"pcb\", False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a4e41472",
+ "metadata": {},
+ "source": [
+ "Modify the air region. Padding values are passed in this order: [+X, -X, +Y, -Y, +Z, -Z]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2cdc3d09",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.mesh.global_mesh_region.global_region.padding_values = [20, 20, 20, 20, 300, 300]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76a82dd9",
+ "metadata": {},
+ "source": [
+ "## Assign materials and power dissipation conditions from Sherlock\n",
+ "\n",
+ "Use the Sherlock file to assign materials."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "26e9ff94",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assignmaterial_from_sherlock_files(\n",
+ " component_file=component_list, material_file=material_list\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8f5f59c7",
+ "metadata": {},
+ "source": [
+ "Delete objects with no material assignments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "244cdd8d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "no_material_objs = ipk.modeler.get_objects_by_material(material=\"\")\n",
+ "ipk.modeler.delete(assignment=no_material_objs)\n",
+ "ipk.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8f1a14ec",
+ "metadata": {},
+ "source": [
+ "Assign power blocks from the Sherlock file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df88237f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "total_power = ipk.assign_block_from_sherlock_file(csv_name=component_list)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5d5f05c8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# ## Assign openings\n",
+ "#\n",
+ "# Assign opening boundary condition to all the faces of the region.\n",
+ "ipk.assign_openings(ipk.modeler.get_object_faces(\"Region\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e0b4b8b0",
+ "metadata": {},
+ "source": [
+ "## Create simulation setup\n",
+ "### Set global mesh settings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bc5cb8ec",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "ipk.globalMeshSettings(\n",
+ " 3,\n",
+ " gap_min_elements=\"1\",\n",
+ " noOgrids=True,\n",
+ " MLM_en=True,\n",
+ " MLM_Type=\"2D\",\n",
+ " edge_min_elements=\"2\",\n",
+ " object=\"Region\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e0daec05",
+ "metadata": {},
+ "source": [
+ "### Add postprocessing object\n",
+ "Create the point monitor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d0e11e73",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "point1 = ipk.monitor.assign_point_monitor(\n",
+ " point_position=ipk.modeler[\"COMP_U10\"].top_face_z.center, monitor_name=\"Point1\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "195de966",
+ "metadata": {},
+ "source": [
+ "Create a line for reporting after the simulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "78598730",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "line = ipk.modeler.create_polyline(\n",
+ " points=[\n",
+ " ipk.modeler[\"COMP_U10\"].top_face_z.vertices[0].position,\n",
+ " ipk.modeler[\"COMP_U10\"].top_face_z.vertices[2].position,\n",
+ " ],\n",
+ " non_model=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a19f478",
+ "metadata": {},
+ "source": [
+ "### Solve\n",
+ "To solve quickly, the maximum iterations are set to 20. For better accuracy, you\n",
+ "can increase the maximum to at least 100."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e3adc6cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = ipk.create_setup()\n",
+ "setup1.props[\"Solution Initialization - Y Velocity\"] = \"1m_per_sec\"\n",
+ "setup1.props[\"Radiation Model\"] = \"Discrete Ordinates Model\"\n",
+ "setup1.props[\"Include Gravity\"] = True\n",
+ "setup1.props[\"Secondary Gradient\"] = True\n",
+ "setup1.props[\"Convergence Criteria - Max Iterations\"] = 100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "35a969b5",
+ "metadata": {},
+ "source": [
+ "Check for intersections using validation and fix them by\n",
+ "assigning priorities."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2994411f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assign_priority_on_intersections()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "692ddeba",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "770c753a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c15d4344",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3f8fd526",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/array.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/array.ipynb.txt
new file mode 100644
index 00000000..3bdca6f6
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/array.ipynb.txt
@@ -0,0 +1,486 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "1bad59ab",
+ "metadata": {},
+ "source": [
+ "# Component antenna array"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a45b17b7",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to create an example using a 3D component file. It sets\n",
+ "up the analysis, solves it, and uses postprocessing functions to create plots using Matplotlib and\n",
+ "PyVista without opening the HFSS user interface. This example runs only on Windows using CPython.\n",
+ "\n",
+ "Keywords: **HFSS**, **antenna array**, **3D components**, **far field**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e46e559",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "70d0aecf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "387fc4f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.visualization.advanced.farfield_visualization import \\\n",
+ " FfdSolutionData"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd7db759",
+ "metadata": {},
+ "source": [
+ "Define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "04814fd3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ca9536c",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2d7ddc98",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3045b754",
+ "metadata": {},
+ "source": [
+ "## Download 3D component\n",
+ "Download the 3D component that is needed to run the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d8732970",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "example_path = ansys.aedt.core.downloads.download_3dcomponent(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e5eb2ffb",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS and open project\n",
+ "\n",
+ "Launch HFSS and open the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6d78c008",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"array.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " design=\"Array_Simple\",\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "\n",
+ "print(\"Project name \" + project_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a3cf8a2",
+ "metadata": {},
+ "source": [
+ "## Read array definition\n",
+ "\n",
+ "Read array definition from the JSON file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9cd0b09f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dict_in = ansys.aedt.core.general_methods.read_json(\n",
+ " os.path.join(example_path, \"array_simple.json\")\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "01257dfb",
+ "metadata": {},
+ "source": [
+ "## Define 3D component\n",
+ "\n",
+ "Define the 3D component cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fc5fa147",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dict_in[\"Circ_Patch_5GHz1\"] = os.path.join(example_path, \"Circ_Patch_5GHz.a3dcomp\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d07ecc66",
+ "metadata": {},
+ "source": [
+ "## Add 3D component array\n",
+ "\n",
+ "A 3D component array is created from the previous dictionary.\n",
+ "If a 3D component is not available in the design, it is loaded\n",
+ "into the dictionary from the path that you specify. The following\n",
+ "code edits the dictionary to point to the location of the A3DCOMP file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "918e1358",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "array = hfss.add_3d_component_array_from_json(dict_in)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64d4f42d",
+ "metadata": {},
+ "source": [
+ "## Modify cells\n",
+ "\n",
+ "Make the center element passive and rotate the corner elements."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ddecb761",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "array.cells[1][1].is_active = False\n",
+ "array.cells[0][0].rotation = 90\n",
+ "array.cells[0][2].rotation = 90\n",
+ "array.cells[2][0].rotation = 90\n",
+ "array.cells[2][2].rotation = 90"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04b2eb34",
+ "metadata": {},
+ "source": [
+ "## Set up simulation and analyze\n",
+ "\n",
+ "Set up a simulation and analyze it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a324ad43",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup()\n",
+ "setup.props[\"Frequency\"] = \"5GHz\"\n",
+ "setup.props[\"MaximumPasses\"] = 3\n",
+ "hfss.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0636626b",
+ "metadata": {},
+ "source": [
+ "## Get far field data\n",
+ "\n",
+ "Get far field data. After the simulation completes, the far\n",
+ "field data is generated port by port and stored in a data class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d3694481",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata = hfss.get_antenna_data(setup=hfss.nominal_adaptive, sphere=\"Infinite Sphere1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3b37837",
+ "metadata": {},
+ "source": [
+ "## Generate contour plot\n",
+ "\n",
+ "Generate a contour plot. You can define the Theta scan and Phi scan."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c18dc33a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.farfield_data.plot_contour(\n",
+ " quantity=\"RealizedGain\",\n",
+ " title=\"Contour at {}Hz\".format(ffdata.farfield_data.frequency),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cec1ec33",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT.\n",
+ "You can perform far field postprocessing without AEDT because the data is stored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b27a2433",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "metadata_file = ffdata.metadata_file\n",
+ "working_directory = hfss.working_directory"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5f504b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6af3798",
+ "metadata": {},
+ "source": [
+ "## Load far field data\n",
+ "\n",
+ "Load the stored far field data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85b5597b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata = FfdSolutionData(input_file=metadata_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "647e00ad",
+ "metadata": {},
+ "source": [
+ "## Generate contour plot\n",
+ "\n",
+ "Generate a contour plot. You can define the Theta scan\n",
+ "and Phi scan."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae761c00",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.plot_contour(\n",
+ " quantity=\"RealizedGain\", title=\"Contour at {}Hz\".format(ffdata.frequency)\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3ecc3cc",
+ "metadata": {},
+ "source": [
+ "## Generate 2D cutout plots\n",
+ "\n",
+ "Generate 2D cutout plots. You can define the Theta scan\n",
+ "and Phi scan."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "543e1e94",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.plot_cut(\n",
+ " quantity=\"RealizedGain\",\n",
+ " primary_sweep=\"theta\",\n",
+ " secondary_sweep_value=[-180, -75, 75],\n",
+ " title=\"Azimuth at {}Hz\".format(ffdata.frequency),\n",
+ " quantity_format=\"dB10\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4c7f8c24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.plot_cut(\n",
+ " quantity=\"RealizedGain\",\n",
+ " primary_sweep=\"phi\",\n",
+ " secondary_sweep_value=30,\n",
+ " title=\"Elevation\",\n",
+ " quantity_format=\"dB10\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b86291e",
+ "metadata": {},
+ "source": [
+ "## Generate 3D plot\n",
+ "\n",
+ "Generate 3D plots. You can define the Theta scan and Phi scan."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "28ad94d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.plot_3d(\n",
+ " quantity=\"RealizedGain\",\n",
+ " output_file=os.path.join(working_directory, \"Image.jpg\"),\n",
+ " show=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a951134",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "31260724",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/dipole.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/dipole.ipynb.txt
new file mode 100644
index 00000000..88c9f0ff
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/dipole.ipynb.txt
@@ -0,0 +1,561 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a54ce209",
+ "metadata": {},
+ "source": [
+ "# Dipole antenna\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a dipole antenna in HFSS\n",
+ "and postprocess results.\n",
+ "\n",
+ "Keywords: **HFSS**, **modal**, **antenna**, **3D components**, **far field**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d97597c",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "37a43ae9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d2957ddf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d83e9ee6",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f226a2be",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8e7b5f3d",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "87491e59",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "31c60132",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a5ec3f09",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d = ansys.aedt.core.launch_desktop(\n",
+ " AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b4890305",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS\n",
+ "\n",
+ "Create an HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3d08925a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"dipole.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " version=AEDT_VERSION, project=project_name, solution_type=\"Modal\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "296e0440",
+ "metadata": {},
+ "source": [
+ "## Define variable\n",
+ "\n",
+ "Define a variable for the dipole length."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "82c413f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss[\"l_dipole\"] = \"13.5cm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bfb627e4",
+ "metadata": {},
+ "source": [
+ "## Get 3D component from system library\n",
+ "\n",
+ "Get a 3D component from the ``syslib`` directory. For this example to run\n",
+ "correctly, you must get all geometry parameters of the 3D component or, in\n",
+ "case of an encrypted 3D component, create a dictionary of the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ba251163",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "compfile = hfss.components3d[\"Dipole_Antenna_DM\"]\n",
+ "geometryparams = hfss.get_components3d_vars(\"Dipole_Antenna_DM\")\n",
+ "geometryparams[\"dipole_length\"] = \"l_dipole\"\n",
+ "hfss.modeler.insert_3d_component(compfile, geometryparams)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "07a55c94",
+ "metadata": {},
+ "source": [
+ "## Create boundaries\n",
+ "\n",
+ "Create an open region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8199cda2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.create_open_region(frequency=\"1GHz\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d38e9a2f",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup with a sweep to run the simulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1fdfcd46",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(\"MySetup\")\n",
+ "setup.props[\"Frequency\"] = \"1GHz\"\n",
+ "setup.props[\"MaximumPasses\"] = 1\n",
+ "hfss.create_linear_count_sweep(\n",
+ " setup=setup.name,\n",
+ " units=\"GHz\",\n",
+ " start_frequency=0.5,\n",
+ " stop_frequency=1.5,\n",
+ " num_of_freq_points=101,\n",
+ " name=\"sweep1\",\n",
+ " sweep_type=\"Interpolating\",\n",
+ " interpolation_tol=3,\n",
+ " interpolation_max_solutions=255,\n",
+ " save_fields=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce4c5bda",
+ "metadata": {},
+ "source": [
+ "## Run simulation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8072f37e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.analyze_setup(name=\"MySetup\", cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b8a7c72",
+ "metadata": {},
+ "source": [
+ "### Postprocess\n",
+ "\n",
+ "Plot s-parameters and far field."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "80376707",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.create_scattering(\"MyScattering\")\n",
+ "variations = hfss.available_variations.nominal_w_values_dict\n",
+ "variations[\"Freq\"] = [\"1GHz\"]\n",
+ "variations[\"Theta\"] = [\"All\"]\n",
+ "variations[\"Phi\"] = [\"All\"]\n",
+ "hfss.post.create_report(\n",
+ " \"db(GainTotal)\",\n",
+ " hfss.nominal_adaptive,\n",
+ " variations,\n",
+ " primary_sweep_variable=\"Theta\",\n",
+ " context=\"3D\",\n",
+ " report_category=\"Far Fields\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "592ac52d",
+ "metadata": {},
+ "source": [
+ "Create a far fields report using the ``report_by_category.far field()`` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "79b64157",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_report = hfss.post.reports_by_category.far_field(\n",
+ " \"db(RealizedGainTotal)\", hfss.nominal_adaptive, \"3D\"\n",
+ ")\n",
+ "new_report.variations = variations\n",
+ "new_report.primary_sweep = \"Theta\"\n",
+ "new_report.create(\"Realized2D\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28ccb26f",
+ "metadata": {},
+ "source": [
+ "Generate multiple plots using the ``new_report`` object. This code generates\n",
+ "2D and 3D polar plots."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76aa73f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_report.report_type = \"3D Polar Plot\"\n",
+ "new_report.secondary_sweep = \"Phi\"\n",
+ "new_report.create(\"Realized3D\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "563144c7",
+ "metadata": {},
+ "source": [
+ "Get solution data using the ``new_report`` object and postprocess or plot the\n",
+ "data outside AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2613185a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solution_data = new_report.get_solution_data()\n",
+ "solution_data.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e732675",
+ "metadata": {},
+ "source": [
+ "Generate a far field plot by creating a postprocessing variable and assigning\n",
+ "it to a new coordinate system. You can use the ``post`` prefix to create a\n",
+ "postprocessing variable directly from a setter, or you can use the ``set_variable()``\n",
+ "method with an arbitrary name."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ec1ea0cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss[\"post_x\"] = 2\n",
+ "hfss.variable_manager.set_variable(name=\"y_post\", expression=1, is_post_processing=True)\n",
+ "hfss.modeler.create_coordinate_system(origin=[\"post_x\", \"y_post\", 0], name=\"CS_Post\")\n",
+ "hfss.insert_infinite_sphere(custom_coordinate_system=\"CS_Post\", name=\"Sphere_Custom\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec9592a2",
+ "metadata": {},
+ "source": [
+ "## Retrieve solution data\n",
+ "\n",
+ "You can also process solution data using Python libraries like Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92dbaba2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_report = hfss.post.reports_by_category.far_field(\n",
+ " \"GainTotal\", hfss.nominal_adaptive, \"3D\"\n",
+ ")\n",
+ "new_report.primary_sweep = \"Theta\"\n",
+ "new_report.far_field_sphere = \"3D\"\n",
+ "solutions = new_report.get_solution_data()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b5e14220",
+ "metadata": {},
+ "source": [
+ "Generate a 3D plot using Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06ae4838",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions.plot_3d()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "508c6aa4",
+ "metadata": {},
+ "source": [
+ "Generate a far fields plot using Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff8628b8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_report.far_field_sphere = \"Sphere_Custom\"\n",
+ "solutions_custom = new_report.get_solution_data()\n",
+ "solutions_custom.plot_3d()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bcd8d97",
+ "metadata": {},
+ "source": [
+ "Generate a 2D plot using Matplotlib where you specify whether it is a polar\n",
+ "plot or a rectangular plot."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "39359be7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions.plot(formula=\"db20\", is_polar=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c50c7e59",
+ "metadata": {},
+ "source": [
+ "## Retrieve far-field data\n",
+ "\n",
+ "After the simulation completes, the far\n",
+ "field data is generated port by port and stored in a data class. You can use this data\n",
+ "once AEDT is released."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "933ac125",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata = hfss.get_antenna_data(\n",
+ " sphere=\"Sphere_Custom\",\n",
+ " setup=hfss.nominal_adaptive,\n",
+ " frequencies=[\"1000MHz\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4141581",
+ "metadata": {},
+ "source": [
+ "## Generate 2D cutout plot\n",
+ "\n",
+ "Generate a 2D cutout plot. You can define the Theta scan\n",
+ "and Phi scan."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "661af993",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ffdata.farfield_data.plot_cut(\n",
+ " primary_sweep=\"theta\",\n",
+ " secondary_sweep_value=0,\n",
+ " quantity=\"RealizedGain\",\n",
+ " title=\"FarField\",\n",
+ " quantity_format=\"dB20\",\n",
+ " is_polar=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8674ee6a",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f9718dfb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ae95846",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files.\n",
+ "The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8a351e21",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/fss_unitcell.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/fss_unitcell.ipynb.txt
new file mode 100644
index 00000000..658c8163
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/fss_unitcell.ipynb.txt
@@ -0,0 +1,414 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "879eb82a",
+ "metadata": {},
+ "source": [
+ "# FSS unit cell simulation\n",
+ "\n",
+ "This example shows how to use PyAEDT to model and simulate a unit cell\n",
+ "for a frequency-selective surface in HFSS.\n",
+ "\n",
+ "Keywords: **HFSS**, **FSS**, **Floquet**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe6e3f75",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8af92b73",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d6ac051a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2482bd83",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66bbe6d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0648ff65",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c42a36a1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a05155a",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "213a699c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"FSS.aedt\")\n",
+ "d = ansys.aedt.core.launch_desktop(\n",
+ " AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc9ab9f5",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS\n",
+ "\n",
+ "Create an HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c4dcb2cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " version=AEDT_VERSION, project=project_name, solution_type=\"Modal\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11f35b22",
+ "metadata": {},
+ "source": [
+ "## Define variable\n",
+ "\n",
+ "Define a variable for the 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bd5553ed",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss[\"patch_dim\"] = \"10mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "18507b6d",
+ "metadata": {},
+ "source": [
+ "## Set up model\n",
+ "\n",
+ "Download the 3D component from the example data and insert the 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0535f030",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "unitcell_3d_component_path = ansys.aedt.core.downloads.download_FSS_3dcomponent(\n",
+ " destination=temp_folder.name\n",
+ ")\n",
+ "unitcell_path = os.path.join(unitcell_3d_component_path, \"FSS_unitcell_23R2.a3dcomp\")\n",
+ "comp = hfss.modeler.insert_3d_component(unitcell_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f431b2ed",
+ "metadata": {},
+ "source": [
+ "Assign the parameter to the 3D component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb7088c5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "component_name = hfss.modeler.user_defined_component_names\n",
+ "comp.parameters[\"a\"] = \"patch_dim\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c95a3be8",
+ "metadata": {},
+ "source": [
+ "Create an open region along +Z direction for unit cell analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4078b0c5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bounding_dimensions = hfss.modeler.get_bounding_dimension()\n",
+ "\n",
+ "periodicity_x = bounding_dimensions[0]\n",
+ "periodicity_y = bounding_dimensions[1]\n",
+ "\n",
+ "region = hfss.modeler.create_air_region(\n",
+ " z_pos=10 * bounding_dimensions[2],\n",
+ " is_percentage=False,\n",
+ ")\n",
+ "\n",
+ "[x_min, y_min, z_min, x_max, y_max, z_max] = region.bounding_box"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11fb6414",
+ "metadata": {},
+ "source": [
+ "Assign the lattice pair boundary condition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "71310b66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.auto_assign_lattice_pairs(assignment=region.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ba816dd",
+ "metadata": {},
+ "source": [
+ "Define the Floquet port."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "59d83194",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "id_z_pos = region.top_face_z\n",
+ "hfss.create_floquet_port(\n",
+ " assignment=id_z_pos,\n",
+ " lattice_origin=[0, 0, z_max],\n",
+ " lattice_a_end=[0, y_max, z_max],\n",
+ " lattice_b_end=[x_max, 0, z_max],\n",
+ " name=\"port_z_max\",\n",
+ " deembed_distance=10 * bounding_dimensions[2],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be91a55e",
+ "metadata": {},
+ "source": [
+ "Create a solution setup, including the frequency sweep."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bb6fc7f3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(\"MySetup\")\n",
+ "setup.props[\"Frequency\"] = \"10GHz\"\n",
+ "setup.props[\"MaximumPasses\"] = 10\n",
+ "hfss.create_linear_count_sweep(\n",
+ " setup=setup.name,\n",
+ " units=\"GHz\",\n",
+ " start_frequency=6,\n",
+ " stop_frequency=15,\n",
+ " num_of_freq_points=51,\n",
+ " name=\"sweep1\",\n",
+ " sweep_type=\"Interpolating\",\n",
+ " interpolation_tol=6,\n",
+ " save_fields=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86cfd411",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Create S-parameter reports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "77f19fd2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "all_quantities = hfss.post.available_report_quantities()\n",
+ "str_mag = []\n",
+ "str_ang = []\n",
+ "\n",
+ "variation = {\"Freq\": [\"All\"]}\n",
+ "\n",
+ "for i in all_quantities:\n",
+ " str_mag.append(\"mag(\" + i + \")\")\n",
+ " str_ang.append(\"ang_deg(\" + i + \")\")\n",
+ "\n",
+ "hfss.post.create_report(\n",
+ " expressions=str_mag,\n",
+ " variations=variation,\n",
+ " plot_name=\"magnitude_plot\",\n",
+ ")\n",
+ "hfss.post.create_report(\n",
+ " expressions=str_ang,\n",
+ " variations=variation,\n",
+ " plot_name=\"phase_plot\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0a46a4a7",
+ "metadata": {},
+ "source": [
+ "## Save and run simulation\n",
+ "\n",
+ "Save and run the simulation. Uncomment the following line to run the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d774cb9a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# hfss.analyze()\n",
+ "hfss.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5da0b144",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ddd2a6e3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6938617c",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cb795392",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/index.rst.txt b/version/dev/_sources/examples/high_frequency/antenna/index.rst.txt
new file mode 100644
index 00000000..532af2f8
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/index.rst.txt
@@ -0,0 +1,107 @@
+Antenna
+~~~~~~~
+These examples use PyAEDT to show some antenna applications.
+
+.. grid:: 2
+
+ .. grid-item-card:: Dipole antenna
+ :padding: 2 2 2 2
+ :link: dipole
+ :link-type: doc
+
+ .. image:: _static/dipole.png
+ :alt: Antenna
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a dipole antenna in HFSS and postprocess results.
+
+ .. grid-item-card:: Component antenna array
+ :padding: 2 2 2 2
+ :link: array
+ :link-type: doc
+
+ .. image:: _static/array.png
+ :alt: Antenna
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create an antenna array.
+
+ .. grid-item-card:: Probe-fed patch antenna
+ :padding: 2 2 2 2
+ :link: patch
+ :link-type: doc
+
+ .. image:: _static/patch.png
+ :alt: Patch
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use the Stackup3D class to create and analyze a patch antenna in HFSS.
+
+ .. grid-item-card:: FSS unit cell simulation
+ :padding: 2 2 2 2
+ :link: fss_unitcell
+ :link-type: doc
+
+ .. image:: _static/unitcell.png
+ :alt: FSS
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to model and simulate a unit cell for a frequency-selective surface in HFSS.
+
+ .. grid-item-card:: Circuit schematic creation and analysis
+ :padding: 2 2 2 2
+ :link: ../../aedt_general/modeler/circuit_schematic
+ :link-type: doc
+
+ .. image:: ../../aedt_general/modeler/_static/circuit.png
+ :alt: Circuit
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Large scenarios
+ :padding: 2 2 2 2
+ :link: large_scenarios/index
+ :link-type: doc
+
+ .. image:: _static/car_w_pedestrians.png
+ :alt: FSS
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some general capabilities of HFSS SBR+ for large scenarios.
+
+ .. grid-item-card:: RF interference
+ :padding: 2 2 2 2
+ :link: interferences/index
+ :link-type: doc
+
+ .. image:: _static/emit_simple_cosite.png
+ :alt: EMIT logo
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some general capabilities of EMIT for RF interference.
+
+ .. toctree::
+ :hidden:
+
+ dipole
+ array
+ patch
+ fss_unitcell
+ ../../aedt_general/modeler/circuit_schematic
+ large_scenarios/index
+ interferences/index
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/antenna.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/antenna.ipynb.txt
new file mode 100644
index 00000000..90464d45
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/antenna.ipynb.txt
@@ -0,0 +1,277 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "65c69ee3",
+ "metadata": {},
+ "source": [
+ "# Antenna\n",
+ "\n",
+ "This example shows how to create a project in EMIT for\n",
+ "the simulation of an antenna using HFSS.\n",
+ "\n",
+ "![](\"_static/emit_simple_cosite.png\")
\n",
+ "\n",
+ "Keywords: **EMIT**, **Antenna**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a515d09a",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "970dcff4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "543c6359",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e11611d8",
+ "metadata": {},
+ "source": [
+ "from ansys.aedt.core.emit_core.emit_constants import ResultType, TxRxMode"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "852b937e",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0d63e838",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d77aba8f",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b4323629",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2efc2caf",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with EMIT\n",
+ "\n",
+ "Launch AEDT with EMIT. The ``launch_desktop()`` method initializes AEDT\n",
+ "using the specified version. The second argument can be set to ``True`` to\n",
+ "run AEDT in non-graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fd97bc90",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = ansys.aedt.core.generate_unique_project_name(\n",
+ " root_name=temp_folder.name, project_name=\"antenna_cosite\"\n",
+ ")\n",
+ "d = ansys.aedt.core.launch_desktop(AEDT_VERSION, NG_MODE, new_desktop=True)\n",
+ "aedtapp = ansys.aedt.core.Emit(project_name, version=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbf161f7",
+ "metadata": {},
+ "source": [
+ "## Create and connect EMIT components\n",
+ "\n",
+ "Create three radios and connect an antenna to each one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9451b3bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rad1 = aedtapp.modeler.components.create_component(\"New Radio\")\n",
+ "ant1 = aedtapp.modeler.components.create_component(\"Antenna\")\n",
+ "if rad1 and ant1:\n",
+ " ant1.move_and_connect_to(rad1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "46271a9d",
+ "metadata": {},
+ "source": [
+ "## Place radio/antenna pair\n",
+ "\n",
+ "Use the ``create_radio_antenna()`` method to place the radio/antenna pair. The first\n",
+ "argument is the type of radio. The second argument is the name to\n",
+ "assign to the radio."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2e9a38f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rad2, ant2 = aedtapp.modeler.components.create_radio_antenna(\"GPS Receiver\")\n",
+ "rad3, ant3 = aedtapp.modeler.components.create_radio_antenna(\n",
+ " \"Bluetooth Low Energy (LE)\", \"Bluetooth\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c447cc3e",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Define the RF environment\n",
+ "\n",
+ "Specify the RF coupling among antennas.\n",
+ "This functionality is not yet implemented in the API, but it can be entered from the UI.\n",
+ "\n",
+ "![](\"_static/coupling.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "460ed128",
+ "metadata": {},
+ "source": [
+ "## Run EMIT simulation\n",
+ "\n",
+ "Run the EMIT simulation.\n",
+ "\n",
+ "This part of the example requires Ansys AEDT 2023 R2."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "020745db",
+ "metadata": {},
+ "source": [
+ "> **Note:** You can uncomment the following code.\n",
+ "\n",
+ "if AEDT_VERSION > \"2023.1\":\n",
+ " rev = aedtapp.results.analyze()\n",
+ " rx_bands = rev.get_band_names(rad2.name, TxRxMode.RX)\n",
+ " tx_bands = rev.get_band_names(rad3.name, TxRxMode.TX)\n",
+ " domain = aedtapp.results.interaction_domain()\n",
+ " domain.set_receiver(rad2.name, rx_bands[0], -1)\n",
+ " domain.set_interferer(rad3.name, tx_bands[0])\n",
+ " interaction = rev.run(domain)\n",
+ " worst = interaction.get_worst_instance(ResultType.EMI)\n",
+ " if worst.has_valid_values():\n",
+ " emi = worst.get_value(ResultType.EMI)\n",
+ " print(\"Worst case interference is: {} dB\".format(emi))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aea3a9a9",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9bbf229f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedtapp.save_project()\n",
+ "aedtapp.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be5a5a07",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a12f59b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/hfss_emit.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/hfss_emit.ipynb.txt
new file mode 100644
index 00000000..4d64917d
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/hfss_emit.ipynb.txt
@@ -0,0 +1,370 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a1eeb2ad",
+ "metadata": {},
+ "source": [
+ "# HFSS to EMIT coupling\n",
+ "\n",
+ "This example shows how to link an HFSS design\n",
+ "to EMIT and model RF interference among various components.\n",
+ "\n",
+ "![](\"_static/emit_hfss.png\")
\n",
+ "\n",
+ "> **Note:** This example uses the ``Cell Phone RFI Desense``\n",
+ "> project that is available with the AEDT installation in the\n",
+ "> ``\\Examples\\EMIT\\`` directory.\n",
+ "\n",
+ "Keywords: **EMIT**, **Coupling**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1c06e578",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "30b09931",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import shutil\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cbe2a0a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.emit_core.emit_constants import ResultType, TxRxMode"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "985e2b45",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be0dd39e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc962c3a",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3f3eee2f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "416d1c17",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with EMIT\n",
+ "\n",
+ "Launch AEDT with EMIT. The ``Desktop`` class initializes AEDT and starts it\n",
+ "on the specified version and in the specified graphical mode.\n",
+ "A temporary working directory is created using ``tempfile``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ff9c169",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d = ansys.aedt.core.launch_desktop(\n",
+ " version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "877e0685",
+ "metadata": {},
+ "source": [
+ "## Copy example files\n",
+ "\n",
+ "Copy the ``Cell Phone RFT Defense`` example data from the\n",
+ "installed ``Examples`` directory to the temporary working\n",
+ "directory.\n",
+ "\n",
+ "> **Note:** The HFSS design from the installed example\n",
+ "> used to model the RF environment\n",
+ "> has been pre-solved. Hence, the results folder is copied and\n",
+ "> the RF interference between transceivers is calculated in EMIT using\n",
+ "> results from the linked HFSS design.\n",
+ "\n",
+ "The following lambda functions help create file and directory\n",
+ "names when copying data from the ``Examples`` directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "29ef75c0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "file_name = lambda s: s + \".aedt\"\n",
+ "results_name = lambda s: s + \".aedtresults\"\n",
+ "pdf_name = lambda s: s + \" Example.pdf\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a90f54fa",
+ "metadata": {},
+ "source": [
+ "Build the names of the source files for this example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7ab7a934",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "example = \"Cell Phone RFI Desense\"\n",
+ "example_dir = os.path.join(d.install_path, \"Examples\\\\EMIT\")\n",
+ "example_project = os.path.join(example_dir, file_name(example))\n",
+ "example_results_folder = os.path.join(example_dir, results_name(example))\n",
+ "example_pdf = os.path.join(example_dir, pdf_name(example))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "caaed79f",
+ "metadata": {},
+ "source": [
+ "Copy the files to the temporary working directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "039f16ad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = shutil.copyfile(\n",
+ " example_project, os.path.join(temp_folder.name, file_name(example))\n",
+ ")\n",
+ "results_folder = shutil.copytree(\n",
+ " example_results_folder, os.path.join(temp_folder.name, results_name(example))\n",
+ ")\n",
+ "project_pdf = shutil.copyfile(\n",
+ " example_pdf, os.path.join(temp_folder.name, pdf_name(example))\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9fe1e1ac",
+ "metadata": {},
+ "source": [
+ "Open the project in the working directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "293d8e99",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedtapp = ansys.aedt.core.Emit(project_name, version=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ebe0b430",
+ "metadata": {},
+ "source": [
+ "## Create and connect EMIT components\n",
+ "\n",
+ "Create two radios with antennas connected to each one."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b6418087",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rad1, ant1 = aedtapp.modeler.components.create_radio_antenna(\n",
+ " \"Bluetooth Low Energy (LE)\"\n",
+ ")\n",
+ "rad2, ant2 = aedtapp.modeler.components.create_radio_antenna(\n",
+ " \"Bluetooth Low Energy (LE)\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be634a81",
+ "metadata": {},
+ "source": [
+ "## Define coupling among RF systems\n",
+ "\n",
+ "Define coupling among the RF systems."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e827b87d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for link in aedtapp.couplings.linkable_design_names:\n",
+ " aedtapp.couplings.add_link(link)\n",
+ " print('linked \"' + link + '\".')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c5b30e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for link in aedtapp.couplings.coupling_names:\n",
+ " aedtapp.couplings.update_link(link)\n",
+ " print('linked \"' + link + '\".')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "007125b9",
+ "metadata": {},
+ "source": [
+ "## Calculate RF interference\n",
+ "\n",
+ "Run the EMIT simulation. This portion of the EMIT API is not yet implemented.\n",
+ "\n",
+ "This part of the example requires Ansys AEDT 2023 R2."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "93b4ffb4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if AEDT_VERSION > \"2023.1\":\n",
+ " rev = aedtapp.results.analyze()\n",
+ " rx_bands = rev.get_band_names(rad1.name, TxRxMode.RX)\n",
+ " tx_bands = rev.get_band_names(rad2.name, TxRxMode.TX)\n",
+ " domain = aedtapp.results.interaction_domain()\n",
+ " domain.set_receiver(rad1.name, rx_bands[0], -1)\n",
+ " domain.set_interferer(rad2.name, tx_bands[0])\n",
+ " interaction = rev.run(domain)\n",
+ " worst = interaction.get_worst_instance(ResultType.EMI)\n",
+ " if worst.has_valid_values():\n",
+ " emi = worst.get_value(ResultType.EMI)\n",
+ " print(\"Worst case interference is: {} dB\".format(emi))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f3d2b439",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "96054cfa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedtapp.save_project()\n",
+ "aedtapp.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "95055e9d",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "83fab209",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/index.rst.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/index.rst.txt
new file mode 100644
index 00000000..b8f1e62f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/index.rst.txt
@@ -0,0 +1,81 @@
+RF interference
+~~~~~~~~~~~~~~~
+These examples use PyAEDT to show some general capabilities of EMIT for RF interference
+
+.. grid:: 2
+
+ .. grid-item-card:: Antenna
+ :padding: 2 2 2 2
+ :link: antenna
+ :link-type: doc
+
+ .. image:: _static/emit.png
+ :alt: Antenna
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a project in EMIT for the simulation of an antenna using HFSS.
+
+ .. grid-item-card:: HFSS to EMIT coupling
+ :padding: 2 2 2 2
+ :link: hfss_emit
+ :link-type: doc
+
+ .. image:: _static/emit_hfss.png
+ :alt: EMIT HFSS
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to link an HFSS design to EMIT and model RF interference among various components.
+
+ .. grid-item-card:: Interference type classification
+ :padding: 2 2 2 2
+ :link: interference
+ :link-type: doc
+
+ .. image:: _static/interference.png
+ :alt: EMIT HFSS
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to load an existing AEDT EMIT design and analyze the results to classify the worst-case interference.
+
+ .. grid-item-card:: Compute receiver protection levels
+ :padding: 2 2 2 2
+ :link: interference_type
+ :link-type: doc
+
+ .. image:: _static/protection.png
+ :alt: EMIT protection
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to open an AEDT project with an EMIT design and analyze the results to determine if
+ the received power at the input to each receiver exceeds the specified protection levels.
+
+ .. grid-item-card:: Interference type classification using a GUI
+ :padding: 2 2 2 2
+ :link: interference_type
+ :link-type: doc
+
+ .. image:: _static/interference_type.png
+ :alt: EMIT protection
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses a GUI to open an AEDT project with an EMIT design and analyze the results to classify
+ the worst-case interference.
+
+ .. toctree::
+ :hidden:
+
+ antenna
+ hfss_emit
+ interference
+ protection
+ interference_type
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/interference.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/interference.ipynb.txt
new file mode 100644
index 00000000..0d21a741
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/interference.ipynb.txt
@@ -0,0 +1,436 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a732cc8c",
+ "metadata": {},
+ "source": [
+ "# Interference type classification\n",
+ "\n",
+ "This example shows how to load an existing AEDT EMIT\n",
+ "design and analyze the results to classify the\n",
+ "worst-case interference.\n",
+ "\n",
+ "Keywords: **EMIT**, **interference**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6d1130c3",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bd3a5e08",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "import tempfile\n",
+ "\n",
+ "import ansys.aedt.core\n",
+ "import plotly.graph_objects as go\n",
+ "from ansys.aedt.core import Emit\n",
+ "from ansys.aedt.core.emit_core.emit_constants import InterfererType\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "197a103f",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06edfef5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49b1b93a",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7eeb5a9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2aff02cf",
+ "metadata": {},
+ "source": [
+ "Check that EMIT 2023.2 or later is installed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "47672662",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if AEDT_VERSION <= \"2023.1\":\n",
+ " print(\"Warning: This example requires AEDT 2023.2 or later.\")\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5cf5eed0",
+ "metadata": {},
+ "source": [
+ "Download project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ed9881ea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = ansys.aedt.core.downloads.download_file(\n",
+ " \"emit\", \"interference.aedtz\", destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0af34448",
+ "metadata": {},
+ "source": [
+ "## Launch EMIT and open project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "315c08b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "emitapp = Emit(\n",
+ " non_graphical=NG_MODE, new_desktop=True, project=project_name, version=AEDT_VERSION\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "af03c247",
+ "metadata": {},
+ "source": [
+ "## Get lists of transmitters and receivers\n",
+ "\n",
+ "Get lists of all transmitters and receivers in the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "18019b7a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rev = emitapp.results.analyze()\n",
+ "tx_interferer = InterfererType().TRANSMITTERS\n",
+ "rx_radios = rev.get_receiver_names()\n",
+ "tx_radios = rev.get_interferer_names(tx_interferer)\n",
+ "domain = emitapp.results.interaction_domain()\n",
+ "\n",
+ "if tx_radios is None or rx_radios is None:\n",
+ " print(\"No receivers or transmitters are in the design.\")\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e4b78d7b",
+ "metadata": {},
+ "source": [
+ "## Classify the interference\n",
+ "\n",
+ "Iterate over all the transmitters and receivers and compute the power\n",
+ "at the input to each receiver due to each of the transmitters. Compute\n",
+ "which type of interference occurred, if any."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7d71df93",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "power_matrix = []\n",
+ "all_colors = []"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5a9ea3e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "all_colors, power_matrix = rev.interference_type_classification(\n",
+ " domain, use_filter=False, filter_list=[]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c9097ab2",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ca481f76",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "emitapp.release_desktop()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f9026eea",
+ "metadata": {},
+ "source": [
+ "## Create a scenario matrix view\n",
+ "\n",
+ "Create a scenario matrix view with the transmitters defined across the top\n",
+ "and receivers down the left-most column. The power at the input to each\n",
+ "receiver is shown in each cell of the matrix and color-coded based on the\n",
+ "interference type.\n",
+ "\n",
+ "Set up colors to visualize results in a table."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cbc2207e",
+ "metadata": {
+ "lines_to_end_of_cell_marker": 2,
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "table_colors = {\n",
+ " \"green\": \"#7d73ca\",\n",
+ " \"yellow\": \"#d359a2\",\n",
+ " \"orange\": \"#ff6361\",\n",
+ " \"red\": \"#ffa600\",\n",
+ " \"white\": \"#ffffff\",\n",
+ "}\n",
+ "header_color = \"grey\"\n",
+ "\n",
+ "\n",
+ "def create_scenario_view(emis, colors, tx_radios, rx_radios):\n",
+ " \"\"\"Create a scenario matrix-like table with the higher received\n",
+ " power for each Tx-Rx radio combination. The colors\n",
+ " used for the scenario matrix view are based on the interference type.\"\"\"\n",
+ "\n",
+ " all_colors = []\n",
+ " for color in colors:\n",
+ " col = []\n",
+ " for cell in color:\n",
+ " col.append(table_colors[cell])\n",
+ " all_colors.append(col)\n",
+ "\n",
+ " fig = go.Figure(\n",
+ " data=[\n",
+ " go.Table(\n",
+ " header=dict(\n",
+ " values=[\n",
+ " \"Tx/Rx\",\n",
+ " \"{}\".format(tx_radios[0]),\n",
+ " \"{}\".format(tx_radios[1]),\n",
+ " ],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=\"grey\",\n",
+ " align=[\"left\", \"center\"],\n",
+ " font=dict(color=\"white\", size=16),\n",
+ " ),\n",
+ " cells=dict(\n",
+ " values=[rx_radios, emis[0], emis[1]],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=[\"white\", all_colors[0], all_colors[1]],\n",
+ " align=[\"left\", \"center\"],\n",
+ " height=25,\n",
+ " font=dict(color=[\"darkslategray\", \"black\"], size=15),\n",
+ " ),\n",
+ " )\n",
+ " ]\n",
+ " )\n",
+ " fig.update_layout(\n",
+ " title=dict(\n",
+ " text=\"Interference Type Classification\",\n",
+ " font=dict(color=\"darkslategray\", size=20),\n",
+ " x=0.5,\n",
+ " ),\n",
+ " width=600,\n",
+ " )\n",
+ " fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c12b14c7",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Create a legend\n",
+ "\n",
+ "Create a legend, defining the interference types and colors used to display the results of\n",
+ "the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76f88ae5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_legend_table():\n",
+ " \"\"\"Create a table showing the interference types.\"\"\"\n",
+ " classifications = [\n",
+ " \"In-band/In-band\",\n",
+ " \"Out-of-band/In-band\",\n",
+ " \"In-band/Out-of-band\",\n",
+ " \"Out-of-band/Out-of-band\",\n",
+ " ]\n",
+ " fig = go.Figure(\n",
+ " data=[\n",
+ " go.Table(\n",
+ " header=dict(\n",
+ " values=[\"Interference Type (Source/Victim)\"],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=header_color,\n",
+ " align=[\"center\"],\n",
+ " font=dict(color=\"white\", size=16),\n",
+ " ),\n",
+ " cells=dict(\n",
+ " values=[classifications],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=[\n",
+ " [\n",
+ " table_colors[\"red\"],\n",
+ " table_colors[\"orange\"],\n",
+ " table_colors[\"yellow\"],\n",
+ " table_colors[\"green\"],\n",
+ " ]\n",
+ " ],\n",
+ " align=[\"center\"],\n",
+ " height=25,\n",
+ " font=dict(color=[\"darkslategray\", \"black\"], size=15),\n",
+ " ),\n",
+ " )\n",
+ " ]\n",
+ " )\n",
+ " fig.update_layout(\n",
+ " title=dict(\n",
+ " text=\"Interference Type Classification\",\n",
+ " font=dict(color=\"darkslategray\", size=20),\n",
+ " x=0.5,\n",
+ " ),\n",
+ " width=600,\n",
+ " )\n",
+ " fig.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1d1b96d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create a scenario view for all the interference types\n",
+ "create_scenario_view(power_matrix, all_colors, tx_radios, rx_radios)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3ba58a65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create a legend for the interference types\n",
+ "create_legend_table()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9fdfe7d",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "252ebcb2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/interference_type.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/interference_type.ipynb.txt
new file mode 100644
index 00000000..b960267a
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/interference_type.ipynb.txt
@@ -0,0 +1,880 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4f3f8ea4",
+ "metadata": {},
+ "source": [
+ "# Interference type classification using a GUI\n",
+ "\n",
+ "This example uses a GUI to open an AEDT project with\n",
+ "an EMIT design and analyze the results to classify the\n",
+ "worst-case interference.\n",
+ "\n",
+ "> **Note:** This example requires PySide6.\n",
+ "\n",
+ "Keywords: **EMIT**, **user interface**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "941a8591",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c82aac1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ca557f63",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import openpyxl\n",
+ "from ansys.aedt.core import get_pyaedt_app\n",
+ "from ansys.aedt.core.emit_core.emit_constants import InterfererType\n",
+ "from openpyxl.styles import PatternFill\n",
+ "from PySide6 import QtCore, QtGui, QtUiTools, QtWidgets"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f43cb62b",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9ab8490f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "56ac1c73",
+ "metadata": {},
+ "source": [
+ "Uncomment the following code if there are Qt plugin errors\n",
+ "import PySide6\n",
+ "dirname = os.path.dirname(PySide6.__file__)\n",
+ "plugin_path = os.path.join(dirname, 'plugins', 'platforms')\n",
+ "os.environ['QT_QPA_PLATFORM_PLUGIN_PATH'] = plugin_path"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "18f98daa",
+ "metadata": {},
+ "source": [
+ "## Launch EMIT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "988a98d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "desktop = ansys.aedt.core.launch_desktop(AEDT_VERSION, NG_MODE, new_desktop=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bea26649",
+ "metadata": {},
+ "source": [
+ "## Add ``EmitApiPython`` module to system path to import it"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6a0dd082",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "emit_path = os.path.join(desktop.install_path, \"Delcross\")\n",
+ "sys.path.insert(0, emit_path)\n",
+ "import EmitApiPython"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d39eed0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "api = EmitApiPython.EmitApi()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64180643",
+ "metadata": {},
+ "source": [
+ "## Define GUI\n",
+ "\n",
+ "Define the UI extension file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7d671d30",
+ "metadata": {
+ "lines_to_next_cell": 1
+ },
+ "outputs": [],
+ "source": [
+ "ui_file = ansys.aedt.core.downloads.download_file(\"emit\", \"interference_gui.ui\")\n",
+ "Ui_MainWindow, _ = QtUiTools.loadUiType(ui_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b1dd3b5",
+ "metadata": {},
+ "source": [
+ "Customize the GUI."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1feef6d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class DoubleDelegate(QtWidgets.QStyledItemDelegate):\n",
+ " def __init__(self, decimals, values, max_power, min_power):\n",
+ " super().__init__()\n",
+ " self.decimals = decimals\n",
+ " self.values = values\n",
+ " self.max_power = max_power\n",
+ " self.min_power = min_power\n",
+ "\n",
+ " def createEditor(self, parent, option, index):\n",
+ " editor = super().createEditor(parent, option, index)\n",
+ " if isinstance(editor, QtWidgets.QLineEdit):\n",
+ " validator = QtGui.QDoubleValidator(parent)\n",
+ " num_rows = len(self.values)\n",
+ " cur_row = index.row()\n",
+ " if cur_row == 0:\n",
+ " min_val = self.values[1]\n",
+ " max_val = self.max_power\n",
+ " elif cur_row == num_rows - 1:\n",
+ " min_val = self.min_power\n",
+ " max_val = self.values[cur_row - 1]\n",
+ " else:\n",
+ " min_val = self.values[cur_row + 1]\n",
+ " max_val = self.values[cur_row - 1]\n",
+ " validator.setRange(min_val, max_val, self.decimals)\n",
+ " validator.setNotation(QtGui.QDoubleValidator.Notation.StandardNotation)\n",
+ " editor.setValidator(validator)\n",
+ " return editor\n",
+ "\n",
+ " def update_values(self, values):\n",
+ " self.values = values"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5292dcf8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):\n",
+ " def __init__(self):\n",
+ " super(MainWindow, self).__init__()\n",
+ " self.emitapp = None\n",
+ " self.populating_dropdown = False\n",
+ " self.setupUi(self)\n",
+ " self.setup_widgets()\n",
+ "\n",
+ " # ## Setup widgets\n",
+ " #\n",
+ " # Define all widgets from the UI file, connect the widgets to functions, define\n",
+ " # table colors, and format table settings.\n",
+ "\n",
+ " def setup_widgets(self):\n",
+ " # Widget definitions for file selection/tab management\n",
+ " self.file_select_btn = self.findChild(QtWidgets.QToolButton, \"file_select_btn\")\n",
+ " self.file_path_box = self.findChild(QtWidgets.QLineEdit, \"file_path_box\")\n",
+ " self.design_name_dropdown = self.findChild(\n",
+ " QtWidgets.QComboBox, \"design_name_dropdown\"\n",
+ " )\n",
+ " self.design_name_dropdown.setEnabled(True)\n",
+ " self.tab_widget = self.findChild(QtWidgets.QTabWidget, \"tab_widget\")\n",
+ "\n",
+ " # Widget definitions for protection level classification\n",
+ " self.protection_results_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"protection_results_btn\"\n",
+ " )\n",
+ " self.protection_matrix = self.findChild(\n",
+ " QtWidgets.QTableWidget, \"protection_matrix\"\n",
+ " )\n",
+ " self.protection_legend_table = self.findChild(\n",
+ " QtWidgets.QTableWidget, \"protection_legend_table\"\n",
+ " )\n",
+ "\n",
+ " self.damage_check = self.findChild(QtWidgets.QCheckBox, \"damage_check\")\n",
+ " self.overload_check = self.findChild(QtWidgets.QCheckBox, \"overload_check\")\n",
+ " self.intermodulation_check = self.findChild(\n",
+ " QtWidgets.QCheckBox, \"intermodulation_check\"\n",
+ " )\n",
+ " self.desensitization_check = self.findChild(\n",
+ " QtWidgets.QCheckBox, \"desensitization_check\"\n",
+ " )\n",
+ " self.protection_export_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"protection_export_btn\"\n",
+ " )\n",
+ " self.radio_specific_levels = self.findChild(\n",
+ " QtWidgets.QCheckBox, \"radio_specific_levels\"\n",
+ " )\n",
+ " self.radio_dropdown = self.findChild(QtWidgets.QComboBox, \"radio_dropdown\")\n",
+ " self.protection_save_img_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"protection_save_img_btn\"\n",
+ " )\n",
+ "\n",
+ " # warning label\n",
+ " self.warning_label = self.findChild(QtWidgets.QLabel, \"warnings\")\n",
+ " myFont = QtGui.QFont()\n",
+ " myFont.setBold(True)\n",
+ " self.warning_label.setFont(myFont)\n",
+ " self.warning_label.setHidden(True)\n",
+ " self.design_name_dropdown.currentIndexChanged.connect(\n",
+ " self.design_dropdown_changed\n",
+ " )\n",
+ "\n",
+ " # Setup for protection level buttons and table\n",
+ " self.protection_results_btn.setEnabled(False)\n",
+ " self.protection_export_btn.setEnabled(False)\n",
+ " self.protection_save_img_btn.setEnabled(False)\n",
+ " self.file_select_btn.clicked.connect(self.open_file_dialog)\n",
+ " self.protection_export_btn.clicked.connect(self.save_results_excel)\n",
+ " self.protection_results_btn.clicked.connect(self.protection_results)\n",
+ " self.protection_legend_table.resizeRowsToContents()\n",
+ " self.protection_legend_table.resizeColumnsToContents()\n",
+ " self.damage_check.stateChanged.connect(self.protection_results)\n",
+ " self.overload_check.stateChanged.connect(self.protection_results)\n",
+ " self.intermodulation_check.stateChanged.connect(self.protection_results)\n",
+ " self.desensitization_check.stateChanged.connect(self.protection_results)\n",
+ " self.protection_legend_table.setEditTriggers(\n",
+ " QtWidgets.QTableWidget.DoubleClicked\n",
+ " )\n",
+ " self.global_protection_level = True\n",
+ " self.protection_levels = {}\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " self.protection_levels[\"Global\"] = values\n",
+ " self.changing = False\n",
+ " self.radio_dropdown.currentIndexChanged.connect(self.radio_dropdown_changed)\n",
+ " self.protection_legend_table.itemChanged.connect(self.table_changed)\n",
+ " self.protection_save_img_btn.clicked.connect(self.save_image)\n",
+ "\n",
+ " # Widget definitions for interference type\n",
+ " self.interference_results_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"interference_results_btn\"\n",
+ " )\n",
+ " self.interference_matrix = self.findChild(\n",
+ " QtWidgets.QTableWidget, \"interference_matrix\"\n",
+ " )\n",
+ " self.interference_legend_table = self.findChild(\n",
+ " QtWidgets.QTableWidget, \"interference_legend_table\"\n",
+ " )\n",
+ "\n",
+ " # set the items read only\n",
+ " for i in range(0, self.interference_legend_table.rowCount()):\n",
+ " item = self.interference_legend_table.item(i, 0)\n",
+ " item.setFlags(QtCore.Qt.ItemIsEnabled)\n",
+ " self.interference_legend_table.setItem(i, 0, item)\n",
+ "\n",
+ " self.in_in_check = self.findChild(QtWidgets.QCheckBox, \"in_in_check\")\n",
+ " self.in_out_check = self.findChild(QtWidgets.QCheckBox, \"in_out_check\")\n",
+ " self.out_in_check = self.findChild(QtWidgets.QCheckBox, \"out_in_check\")\n",
+ " self.out_out_check = self.findChild(QtWidgets.QCheckBox, \"out_out_check\")\n",
+ " self.interference_export_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"interference_export_btn\"\n",
+ " )\n",
+ " self.interference_save_img_btn = self.findChild(\n",
+ " QtWidgets.QPushButton, \"interference_save_img_btn\"\n",
+ " )\n",
+ "\n",
+ " # Setup for interference type buttons and table\n",
+ " self.interference_results_btn.setEnabled(False)\n",
+ " self.interference_export_btn.setEnabled(False)\n",
+ " self.interference_save_img_btn.setEnabled(False)\n",
+ " self.interference_export_btn.clicked.connect(self.save_results_excel)\n",
+ " self.interference_results_btn.clicked.connect(self.interference_results)\n",
+ " self.interference_legend_table.resizeRowsToContents()\n",
+ " self.interference_legend_table.resizeColumnsToContents()\n",
+ " self.in_in_check.stateChanged.connect(self.interference_results)\n",
+ " self.in_out_check.stateChanged.connect(self.interference_results)\n",
+ " self.out_in_check.stateChanged.connect(self.interference_results)\n",
+ " self.out_out_check.stateChanged.connect(self.interference_results)\n",
+ " self.radio_specific_levels.stateChanged.connect(self.radio_specific)\n",
+ " self.interference_save_img_btn.clicked.connect(self.save_image)\n",
+ "\n",
+ " # Color definition dictionary and previous project/design names\n",
+ " self.color_dict = {\n",
+ " \"green\": [QtGui.QColor(125, 115, 202), \"#7d73ca\"],\n",
+ " \"yellow\": [QtGui.QColor(211, 89, 162), \"#d359a2\"],\n",
+ " \"orange\": [QtGui.QColor(255, 99, 97), \"#ff6361\"],\n",
+ " \"red\": [QtGui.QColor(255, 166, 0), \"#ffa600\"],\n",
+ " \"white\": [QtGui.QColor(\"white\"), \"#ffffff\"],\n",
+ " }\n",
+ " self.previous_design = \"\"\n",
+ " self.previous_project = \"\"\n",
+ "\n",
+ " # Set the legend tables to stretch resize mode\n",
+ " header = self.protection_legend_table.horizontalHeader()\n",
+ " v_header = self.protection_legend_table.verticalHeader()\n",
+ "\n",
+ " header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ "\n",
+ " header = self.interference_legend_table.horizontalHeader()\n",
+ " v_header = self.interference_legend_table.verticalHeader()\n",
+ "\n",
+ " header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ " v_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeMode.Stretch)\n",
+ "\n",
+ " # Input validation for protection level legend table\n",
+ " self.delegate = DoubleDelegate(\n",
+ " decimals=2, values=values, max_power=1000, min_power=-200\n",
+ " )\n",
+ " self.protection_legend_table.setItemDelegateForColumn(0, self.delegate)\n",
+ " self.open_file_dialog()\n",
+ "\n",
+ " # ## Open file dialog and select project\n",
+ " #\n",
+ " # Open the file dialog for project selection and populate the design dropdown\n",
+ " # with all EMIT designs in the project.\n",
+ "\n",
+ " def open_file_dialog(self):\n",
+ " fname, _ = QtWidgets.QFileDialog.getOpenFileName(\n",
+ " self,\n",
+ " \"Select EMIT Project\",\n",
+ " \"\",\n",
+ " \"Ansys Electronics Desktop Files (*.aedt)\",\n",
+ " )\n",
+ " if fname:\n",
+ " self.file_path_box.setText(fname)\n",
+ "\n",
+ " # Close previous project and open specified one\n",
+ " if self.emitapp is not None:\n",
+ " self.emitapp.close_project()\n",
+ " self.emitapp = None\n",
+ " desktop_proj = desktop.load_project(self.file_path_box.text())\n",
+ "\n",
+ " # check for an empty project (i.e. no designs)\n",
+ " if isinstance(desktop_proj, bool):\n",
+ " self.file_path_box.setText(\"\")\n",
+ " msg = QtWidgets.QMessageBox()\n",
+ " msg.setWindowTitle(\"Error: Project missing designs.\")\n",
+ " msg.setText(\n",
+ " \"The selected project has no designs. Projects must have at least \"\n",
+ " \"one EMIT design. See AEDT log for more information.\"\n",
+ " )\n",
+ " x = msg.exec()\n",
+ " return\n",
+ "\n",
+ " # Check if project is already open\n",
+ " if desktop_proj.lock_file == None:\n",
+ " msg = QtWidgets.QMessageBox()\n",
+ " msg.setWindowTitle(\"Error: Project already open\")\n",
+ " msg.setText(\n",
+ " \"Project is locked. Close or remove the lock before proceeding. See AEDT log for more information.\"\n",
+ " )\n",
+ " x = msg.exec()\n",
+ " return\n",
+ "\n",
+ " # Populate design dropdown with all design names\n",
+ " designs = desktop_proj.design_list\n",
+ " emit_designs = []\n",
+ " self.populating_dropdown = True\n",
+ " self.design_name_dropdown.clear()\n",
+ " self.populating_dropdown = False\n",
+ " for d in designs:\n",
+ " design_type = desktop.design_type(desktop_proj.project_name, d)\n",
+ " if design_type == \"EMIT\":\n",
+ " emit_designs.append(d)\n",
+ "\n",
+ " # Add warning if no EMIT design\n",
+ " # NOTE: This should never happen because loading a project without an EMIT design\n",
+ " # should add a blank EMIT design\n",
+ " self.warning_label.setHidden(True)\n",
+ " if len(emit_designs) == 0:\n",
+ " self.warning_label.setText(\n",
+ " \"Warning: The project must contain at least one EMIT design.\"\n",
+ " )\n",
+ " self.warning_label.setHidden(False)\n",
+ " return\n",
+ "\n",
+ " self.populating_dropdown = True\n",
+ " self.design_name_dropdown.addItems(emit_designs)\n",
+ " self.populating_dropdown = False\n",
+ " self.emitapp = get_pyaedt_app(desktop_proj.project_name, emit_designs[0])\n",
+ " self.design_name_dropdown.setCurrentIndex(0)\n",
+ "\n",
+ " # Check for at least 2 radios\n",
+ " radios = self.emitapp.modeler.components.get_radios()\n",
+ " self.warning_label.setHidden(True)\n",
+ " if len(radios) < 2:\n",
+ " self.warning_label.setText(\n",
+ " \"Warning: The selected design must contain at least two radios.\"\n",
+ " )\n",
+ " self.warning_label.setHidden(False)\n",
+ "\n",
+ " if self.radio_specific_levels.isEnabled():\n",
+ " self.radio_specific_levels.setChecked(False)\n",
+ " self.radio_dropdown.clear()\n",
+ " self.radio_dropdown.setEnabled(False)\n",
+ " self.protection_levels = {}\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " self.protection_levels[\"Global\"] = values\n",
+ "\n",
+ " self.radio_specific_levels.setEnabled(True)\n",
+ " self.protection_results_btn.setEnabled(True)\n",
+ " self.interference_results_btn.setEnabled(True)\n",
+ "\n",
+ " # ### Change design selection\n",
+ " #\n",
+ " # Refresh the warning messages when the selected design changes\n",
+ "\n",
+ " def design_dropdown_changed(self):\n",
+ " if self.populating_dropdown:\n",
+ " # Don't load design's on initial project load\n",
+ " return\n",
+ "\n",
+ " design_name = self.design_name_dropdown.currentText()\n",
+ " self.emitapp = get_pyaedt_app(self.emitapp.project_name, design_name)\n",
+ " # Check for at least 2 radios\n",
+ " radios = self.emitapp.modeler.components.get_radios()\n",
+ " self.warning_label.setHidden(True)\n",
+ " if len(radios) < 2:\n",
+ " self.warning_label.setText(\n",
+ " \"Warning: The selected design must contain at least two radios.\"\n",
+ " )\n",
+ " self.warning_label.setHidden(False)\n",
+ "\n",
+ " # Clear the table if the design is changed\n",
+ " self.clear_table()\n",
+ "\n",
+ " # ### Enable radio specific protection levels\n",
+ " #\n",
+ " # Activate radio selection dropdown and initialize dictionary to store protection levels\n",
+ " # when the radio-specific level dropdown is checked.\n",
+ "\n",
+ " def radio_specific(self):\n",
+ " self.radio_dropdown.setEnabled(self.radio_specific_levels.isChecked())\n",
+ " self.radio_dropdown.clear()\n",
+ " if self.radio_dropdown.isEnabled():\n",
+ " self.emitapp.set_active_design(self.design_name_dropdown.currentText())\n",
+ " radios = self.emitapp.modeler.components.get_radios()\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " for radio in radios:\n",
+ " if radios[radio].has_rx_channels():\n",
+ " self.protection_levels[radio] = values\n",
+ " self.radio_dropdown.addItem(radio)\n",
+ " else:\n",
+ " self.radio_dropdown.clear()\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " self.protection_levels[\"Global\"] = values\n",
+ " self.global_protection_level = not self.radio_specific_levels.isChecked()\n",
+ "\n",
+ " # ### Update legend table\n",
+ " #\n",
+ " # Update shown legend table values when the radio dropdown value changes.\n",
+ "\n",
+ " def radio_dropdown_changed(self):\n",
+ " if self.radio_dropdown.isEnabled():\n",
+ " self.changing = True\n",
+ " for row in range(self.protection_legend_table.rowCount()):\n",
+ " item = self.protection_legend_table.item(row, 0)\n",
+ " item.setText(\n",
+ " str(self.protection_levels[self.radio_dropdown.currentText()][row])\n",
+ " )\n",
+ " self.changing = False\n",
+ " # update the validator so min/max for each row is properly set\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " self.delegate.update_values(values)\n",
+ "\n",
+ " # ### Save legend table values\n",
+ " #\n",
+ " # Save inputted radio protection level threshold values every time one is changed\n",
+ " # in the legend table.\n",
+ "\n",
+ " def table_changed(self):\n",
+ " if self.changing == False:\n",
+ " values = [\n",
+ " float(self.protection_legend_table.item(row, 0).text())\n",
+ " for row in range(self.protection_legend_table.rowCount())\n",
+ " ]\n",
+ " if self.radio_dropdown.currentText() == \"\":\n",
+ " index = \"Global\"\n",
+ " else:\n",
+ " index = self.radio_dropdown.currentText()\n",
+ " self.protection_levels[index] = values\n",
+ " self.delegate.update_values(values)\n",
+ "\n",
+ " # ### Save scenario matrix to as PNG file\n",
+ " #\n",
+ " # Save the scenario matrix table as a PNG file.\n",
+ "\n",
+ " def save_image(self):\n",
+ " if self.tab_widget.currentIndex() == 0:\n",
+ " table = self.protection_matrix\n",
+ " else:\n",
+ " table = self.interference_matrix\n",
+ "\n",
+ " fname, _ = QtWidgets.QFileDialog.getSaveFileName(\n",
+ " self, \"Save Scenario Matrix\", \"Scenario Matrix\", \"png (*.png)\"\n",
+ " )\n",
+ " if fname:\n",
+ " image = QtGui.QImage(table.size(), QtGui.QImage.Format_ARGB32)\n",
+ " table.render(image)\n",
+ " image.save(fname)\n",
+ "\n",
+ " # ### Save scenario matrix to Excel file\n",
+ " #\n",
+ " # Write the scenario matrix results to an Excel file with color coding.\n",
+ "\n",
+ " def save_results_excel(self):\n",
+ " defaultName = \"\"\n",
+ " if self.tab_widget.currentIndex() == 0:\n",
+ " table = self.protection_matrix\n",
+ " defaultName = \"Protection Level Classification\"\n",
+ " else:\n",
+ " table = self.interference_matrix\n",
+ " defaultName = \"Interference Type Classification\"\n",
+ "\n",
+ " fname, _ = QtWidgets.QFileDialog.getSaveFileName(\n",
+ " self, \"Save Scenario Matrix\", defaultName, \"xlsx (*.xlsx)\"\n",
+ " )\n",
+ "\n",
+ " if fname:\n",
+ " workbook = openpyxl.Workbook()\n",
+ " worksheet = workbook.active\n",
+ " header = self.tx_radios[:]\n",
+ " header.insert(0, \"Tx/Rx\")\n",
+ " worksheet.append(header)\n",
+ " for row in range(2, table.rowCount() + 2):\n",
+ " worksheet.cell(row=row, column=1, value=str(self.rx_radios[row - 2]))\n",
+ " for col in range(2, table.columnCount() + 2):\n",
+ " text = str(table.item(row - 2, col - 2).text())\n",
+ " worksheet.cell(row=row, column=col, value=text)\n",
+ " cell = worksheet.cell(row, col)\n",
+ " cell.fill = PatternFill(\n",
+ " start_color=self.color_dict[self.all_colors[col - 2][row - 2]][\n",
+ " 1\n",
+ " ][1:],\n",
+ " end_color=self.color_dict[self.all_colors[col - 2][row - 2]][1][\n",
+ " 1:\n",
+ " ],\n",
+ " fill_type=\"solid\",\n",
+ " )\n",
+ " workbook.save(fname)\n",
+ "\n",
+ " # ### Run interference type simulation\n",
+ " #\n",
+ " # Run interference type simulation and classify results.\n",
+ "\n",
+ " def interference_results(self):\n",
+ " # Initialize filter check marks and expected filter results\n",
+ " self.interference_checks = [\n",
+ " self.in_in_check.isChecked(),\n",
+ " self.out_in_check.isChecked(),\n",
+ " self.in_out_check.isChecked(),\n",
+ " self.out_out_check.isChecked(),\n",
+ " ]\n",
+ "\n",
+ " self.interference_filters = [\n",
+ " \"TxFundamental:In-band\",\n",
+ " [\"TxHarmonic/Spurious:In-band\", \"Intermod:In-band\", \"Broadband:In-band\"],\n",
+ " \"TxFundamental:Out-of-band\",\n",
+ " [\n",
+ " \"TxHarmonic/Spurious:Out-of-band\",\n",
+ " \"Intermod:Out-of-band\",\n",
+ " \"Broadband:Out-of-band\",\n",
+ " ],\n",
+ " ]\n",
+ "\n",
+ " # Create list of problem types to analyze according to inputted filters\n",
+ " filter = [\n",
+ " i\n",
+ " for (i, v) in zip(self.interference_filters, self.interference_checks)\n",
+ " if v\n",
+ " ]\n",
+ "\n",
+ " if (\n",
+ " self.file_path_box.text() != \"\"\n",
+ " and self.design_name_dropdown.currentText() != \"\"\n",
+ " ):\n",
+ " if (\n",
+ " self.previous_design != self.design_name_dropdown.currentText()\n",
+ " or self.previous_project != self.file_path_box.text()\n",
+ " ):\n",
+ " self.previous_design = self.design_name_dropdown.currentText()\n",
+ " self.previous_project = self.file_path_box.text()\n",
+ " self.emitapp.set_active_design(self.design_name_dropdown.currentText())\n",
+ "\n",
+ " # Check if file is read-only\n",
+ " if self.emitapp.save_project() == False:\n",
+ " msg = QtWidgets.QMessageBox()\n",
+ " msg.setWindowTitle(\"Writing Error\")\n",
+ " msg.setText(\n",
+ " \"An error occurred while writing to the file. Is it readonly? Disk full? See AEDT log for more information.\"\n",
+ " )\n",
+ " x = msg.exec()\n",
+ " return\n",
+ "\n",
+ " # Get results and radios\n",
+ " self.rev = self.emitapp.results.analyze()\n",
+ " self.tx_interferer = InterfererType().TRANSMITTERS\n",
+ " self.rx_radios = self.rev.get_receiver_names()\n",
+ " self.tx_radios = self.rev.get_interferer_names(self.tx_interferer)\n",
+ "\n",
+ " # Check if design is valid\n",
+ " if self.tx_radios is None or self.rx_radios is None:\n",
+ " return\n",
+ "\n",
+ " # Classify the interference\n",
+ " # Iterate over all the transmitters and receivers and compute the power\n",
+ " # at the input to each receiver due to each of the transmitters. Compute\n",
+ " # which, if any, type of interference occurred.\n",
+ " domain = self.emitapp.results.interaction_domain()\n",
+ " (\n",
+ " self.all_colors,\n",
+ " self.power_matrix,\n",
+ " ) = self.rev.interference_type_classification(\n",
+ " domain, use_filter=True, filter_list=filter\n",
+ " )\n",
+ "\n",
+ " # Save project and plot results on table widget\n",
+ " self.emitapp.save_project()\n",
+ " self.populate_table()\n",
+ "\n",
+ " # ### Run protection level simulation\n",
+ " #\n",
+ " # Run protection level simulation and classify results according to inputted\n",
+ " # threshold levels.\n",
+ "\n",
+ " def protection_results(self):\n",
+ " # Initialize filter check marks and expected filter results\n",
+ " self.protection_checks = [\n",
+ " self.damage_check.isChecked(),\n",
+ " self.overload_check.isChecked(),\n",
+ " self.intermodulation_check.isChecked(),\n",
+ " self.desensitization_check.isChecked(),\n",
+ " ]\n",
+ "\n",
+ " self.protection_filters = [\n",
+ " \"damage\",\n",
+ " \"overload\",\n",
+ " \"intermodulation\",\n",
+ " \"desensitization\",\n",
+ " ]\n",
+ "\n",
+ " filter = [\n",
+ " i for (i, v) in zip(self.protection_filters, self.protection_checks) if v\n",
+ " ]\n",
+ "\n",
+ " if (\n",
+ " self.file_path_box.text() != \"\"\n",
+ " and self.design_name_dropdown.currentText() != \"\"\n",
+ " ):\n",
+ " if (\n",
+ " self.previous_design != self.design_name_dropdown.currentText()\n",
+ " or self.previous_project != self.file_path_box.text()\n",
+ " ):\n",
+ " self.previous_design = self.design_name_dropdown.currentText()\n",
+ " self.previous_project = self.file_path_box.text()\n",
+ " self.emitapp.set_active_design(self.design_name_dropdown.currentText())\n",
+ "\n",
+ " # Check if file is read-only\n",
+ " if self.emitapp.save_project() == False:\n",
+ " msg = QtWidgets.QMessageBox()\n",
+ " msg.setWindowTitle(\"Writing Error\")\n",
+ " msg.setText(\n",
+ " \"An error occurred while writing to the file. Is it readonly? Disk full? See AEDT log for more information.\"\n",
+ " )\n",
+ " x = msg.exec()\n",
+ " return\n",
+ "\n",
+ " # Get results and design radios\n",
+ " self.tx_interferer = InterfererType().TRANSMITTERS\n",
+ " self.rev = self.emitapp.results.analyze()\n",
+ " self.rx_radios = self.rev.get_receiver_names()\n",
+ " self.tx_radios = self.rev.get_interferer_names(self.tx_interferer)\n",
+ "\n",
+ " # Check if there are radios in the design\n",
+ " if self.tx_radios is None or self.rx_radios is None:\n",
+ " return\n",
+ "\n",
+ " domain = self.emitapp.results.interaction_domain()\n",
+ " (\n",
+ " self.all_colors,\n",
+ " self.power_matrix,\n",
+ " ) = self.rev.protection_level_classification(\n",
+ " domain,\n",
+ " self.global_protection_level,\n",
+ " self.protection_levels[\"Global\"],\n",
+ " self.protection_levels,\n",
+ " use_filter=True,\n",
+ " filter_list=filter,\n",
+ " )\n",
+ "\n",
+ " self.populate_table()\n",
+ "\n",
+ " # ### Populate the scenario matrix\n",
+ " #\n",
+ " # Create a scenario matrix view with the transmitters defined across the top\n",
+ " # and receivers down the left-most column.\n",
+ "\n",
+ " def populate_table(self):\n",
+ " if self.tab_widget.currentIndex() == 0:\n",
+ " table = self.protection_matrix\n",
+ " button = self.protection_export_btn\n",
+ " img_btn = self.protection_save_img_btn\n",
+ " else:\n",
+ " table = self.interference_matrix\n",
+ " button = self.interference_export_btn\n",
+ " img_btn = self.interference_save_img_btn\n",
+ "\n",
+ " num_cols = len(self.all_colors)\n",
+ " num_rows = len(self.all_colors[0])\n",
+ " table.setColumnCount(num_cols)\n",
+ " table.setRowCount(num_rows)\n",
+ " table.setVerticalHeaderLabels(self.rx_radios)\n",
+ " table.setHorizontalHeaderLabels(self.tx_radios)\n",
+ "\n",
+ " for col in range(num_cols):\n",
+ " for row in range(num_rows):\n",
+ " item = QtWidgets.QTableWidgetItem(str(self.power_matrix[col][row]))\n",
+ " table.setItem(row, col, item)\n",
+ " cell = table.item(row, col)\n",
+ " cell.setBackground(self.color_dict[self.all_colors[col][row]][0])\n",
+ "\n",
+ " button.setEnabled(True)\n",
+ " img_btn.setEnabled(True)\n",
+ "\n",
+ " def clear_table(self):\n",
+ " # get the table/buttons based on current tab\n",
+ " if self.tab_widget.currentIndex() == 0:\n",
+ " table = self.protection_matrix\n",
+ " button = self.protection_export_btn\n",
+ " img_btn = self.protection_save_img_btn\n",
+ " else:\n",
+ " table = self.interference_matrix\n",
+ " button = self.interference_export_btn\n",
+ " img_btn = self.interference_save_img_btn\n",
+ "\n",
+ " # disable export options\n",
+ " button.setEnabled(False)\n",
+ " img_btn.setEnabled(False)\n",
+ "\n",
+ " # clear the table\n",
+ " table.setColumnCount(0)\n",
+ " table.setRowCount(0)\n",
+ "\n",
+ " # ### GUI closing event\n",
+ " #\n",
+ " # Close AEDT if the GUI is closed.\n",
+ " def closeEvent(self, event):\n",
+ " msg = QtWidgets.QMessageBox()\n",
+ " msg.setWindowTitle(\"Closing GUI\")\n",
+ " msg.setText(\"Closing AEDT. Wait for the GUI to close on its own.\")\n",
+ " x = msg.exec()\n",
+ " if self.emitapp:\n",
+ " self.emitapp.close_project()\n",
+ " self.emitapp.close_desktop()\n",
+ " else:\n",
+ " desktop.release_desktop(True, True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04f96cd8",
+ "metadata": {},
+ "source": [
+ "## Run GUI\n",
+ "\n",
+ "Run the GUI."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9729cc5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if __name__ == \"__main__\":\n",
+ " app = QtWidgets.QApplication([])\n",
+ " window = MainWindow()\n",
+ " window.show()\n",
+ " app.exec()\n",
+ "else:\n",
+ " desktop.release_desktop(True, True)"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/interferences/protection.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/interferences/protection.ipynb.txt
new file mode 100644
index 00000000..1dfedd69
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/interferences/protection.ipynb.txt
@@ -0,0 +1,546 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "bb0760a5",
+ "metadata": {},
+ "source": [
+ "# Compute receiver protection levels\n",
+ "\n",
+ "This example shows how to open an AEDT project with\n",
+ "an EMIT design and analyze the results to determine if the received\n",
+ "power at the input to each receiver exceeds the specified protection\n",
+ "levels.\n",
+ "\n",
+ "Keywords: **EMIT**, **protection levels**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1dd84447",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6d0793e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import sys\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "95e02ce8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import plotly.graph_objects as go\n",
+ "from ansys.aedt.core import Emit"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e87be65a",
+ "metadata": {},
+ "source": [
+ "from ansys.aedt.core.emit_core.emit_constants import \\\n",
+ " InterfererType # noqa: F401"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a9c40637",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88d80596",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6f48bd0",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c1de5f94",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b605ed6",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with EMIT\n",
+ "\n",
+ "Launch AEDT with EMIT. The ``Desktop`` class initializes AEDT and starts it\n",
+ "on the specified version and in the specified graphical mode.\n",
+ "\n",
+ "Check that the correct version of EMIT is installed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dece5c13",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if AEDT_VERSION <= \"2023.1\":\n",
+ " print(\"Warning: This example requires AEDT 2023.2 or later.\")\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85fbaec5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"emit.aedt\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "67991559",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "emitapp = Emit(\n",
+ " non_graphical=NG_MODE, new_desktop=True, project=project_name, version=AEDT_VERSION\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcfe279a",
+ "metadata": {},
+ "source": [
+ "## Specify protection levels\n",
+ "\n",
+ "The protection levels are specified in dBm.\n",
+ "If the damage threshold is exceeded, permanent damage to the receiver front\n",
+ "end may occur.\n",
+ "Exceeding the overload threshold severely densensitizes the receiver.\n",
+ "Exceeding the intermod threshold can drive the victim receiver into non-linear\n",
+ "operation, where it operates as a mixer.\n",
+ "Exceeding the desense threshold reduces the signal-to-noise ratio and can\n",
+ "reduce the maximum range, maximum bandwidth, and/or the overall link quality."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1d809c17",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "header_color = \"grey\"\n",
+ "damage_threshold = 30\n",
+ "overload_threshold = -4\n",
+ "intermod_threshold = -30\n",
+ "desense_threshold = -104\n",
+ "\n",
+ "protection_levels = [\n",
+ " damage_threshold,\n",
+ " overload_threshold,\n",
+ " intermod_threshold,\n",
+ " desense_threshold,\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3d6755b4",
+ "metadata": {},
+ "source": [
+ "## Create and connect EMIT components\n",
+ "\n",
+ "Set up the scenario with radios connected to antennas."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f01d2ec9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bluetooth, blue_ant = emitapp.modeler.components.create_radio_antenna(\n",
+ " \"Bluetooth Low Energy (LE)\", \"Bluetooth\"\n",
+ ")\n",
+ "gps, gps_ant = emitapp.modeler.components.create_radio_antenna(\"GPS Receiver\", \"GPS\")\n",
+ "wifi, wifi_ant = emitapp.modeler.components.create_radio_antenna(\n",
+ " \"WiFi - 802.11-2012\", \"WiFi\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "854e115c",
+ "metadata": {},
+ "source": [
+ "## Configure the radios\n",
+ "\n",
+ "Enable the HR-DSSS bands for the Wi-Fi radio and set the power level\n",
+ "for all transmit bands to -20 dBm."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "59c6fcef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bands = wifi.bands()\n",
+ "for band in bands:\n",
+ " if \"HR-DSSS\" in band.node_name:\n",
+ " if \"Ch 1-13\" in band.node_name:\n",
+ " band.enabled = True\n",
+ " band.set_band_power_level(-20)\n",
+ "\n",
+ "# Reduce the bluetooth transmit power\n",
+ "bands = bluetooth.bands()\n",
+ "for band in bands:\n",
+ " band.set_band_power_level(-20)\n",
+ "\n",
+ "\n",
+ "def get_radio_node(radio_name):\n",
+ " \"\"\"Get the radio node that matches the\n",
+ " given radio name.\n",
+ "\n",
+ " Arguments:\n",
+ " radio_name: String name of the radio.\n",
+ "\n",
+ " Returns: Instance of the radio.\n",
+ " \"\"\"\n",
+ " if gps.name == radio_name:\n",
+ " radio = gps\n",
+ " elif bluetooth.name == radio_name:\n",
+ " radio = bluetooth\n",
+ " else:\n",
+ " radio = wifi\n",
+ " return radio\n",
+ "\n",
+ "\n",
+ "bands = gps.bands()\n",
+ "for band in bands:\n",
+ " for child in band.children:\n",
+ " if \"L2 P(Y)\" in band.node_name:\n",
+ " band.enabled = True\n",
+ " else:\n",
+ " band.enabled = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aaae9536",
+ "metadata": {},
+ "source": [
+ "## Load the results set\n",
+ "\n",
+ "Create a results revision and load it for analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5c62eb7e",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "rev = emitapp.results.analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "afe83b7f",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Create a legend\n",
+ "\n",
+ "Create a legend, defining the thresholds and colors used to display the results of\n",
+ "the protection level analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d7c4924",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "def create_legend_table():\n",
+ " \"\"\"Create a table showing the defined protection levels.\"\"\"\n",
+ " protectionLevels = [\n",
+ " \">{} dBm\".format(damage_threshold),\n",
+ " \">{} dBm\".format(overload_threshold),\n",
+ " \">{} dBm\".format(intermod_threshold),\n",
+ " \">{} dBm\".format(desense_threshold),\n",
+ " ]\n",
+ " fig = go.Figure(\n",
+ " data=[\n",
+ " go.Table(\n",
+ " header=dict(\n",
+ " values=[\"Interference\", \"Power Level Threshold\"],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=header_color,\n",
+ " align=[\"left\", \"center\"],\n",
+ " font=dict(color=\"white\", size=16),\n",
+ " ),\n",
+ " cells=dict(\n",
+ " values=[\n",
+ " [\"Damage\", \"Overload\", \"Intermodulation\", \"Clear\"],\n",
+ " protectionLevels,\n",
+ " ],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=[\"white\", [\"red\", \"orange\", \"yellow\", \"green\"]],\n",
+ " align=[\"left\", \"center\"],\n",
+ " font=dict(color=[\"darkslategray\", \"black\"], size=15),\n",
+ " ),\n",
+ " )\n",
+ " ]\n",
+ " )\n",
+ " fig.update_layout(\n",
+ " title=dict(\n",
+ " text=\"Protection Levels (dBm)\",\n",
+ " font=dict(color=\"darkslategray\", size=20),\n",
+ " x=0.5,\n",
+ " ),\n",
+ " width=600,\n",
+ " )\n",
+ " fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ba08e8fb",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Create a scenario matrix view\n",
+ "\n",
+ "Create a scenario matrix view with the transmitters defined across the top\n",
+ "and receivers down the left-most column. The power at the input to each\n",
+ "receiver is shown in each cell of the matrix and color-coded based on the\n",
+ "protection level thresholds defined."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9102b818",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_scenario_view(emis, colors, tx_radios, rx_radios):\n",
+ " \"\"\"Create a scenario matrix-like table with the higher received\n",
+ " power for each Tx-Rx radio combination. The colors\n",
+ " used for the scenario matrix view are based on the highest\n",
+ " protection level that the received power exceeds.\"\"\"\n",
+ " fig = go.Figure(\n",
+ " data=[\n",
+ " go.Table(\n",
+ " header=dict(\n",
+ " values=[\n",
+ " \"Tx/Rx\",\n",
+ " \"{}\".format(tx_radios[0]),\n",
+ " \"{}\".format(tx_radios[1]),\n",
+ " ],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=header_color,\n",
+ " align=[\"left\", \"center\"],\n",
+ " font=dict(color=\"white\", size=16),\n",
+ " ),\n",
+ " cells=dict(\n",
+ " values=[rx_radios, emis[0], emis[1]],\n",
+ " line_color=\"darkslategray\",\n",
+ " fill_color=[\"white\", colors[0], colors[1]],\n",
+ " align=[\"left\", \"center\"],\n",
+ " font=dict(color=[\"darkslategray\", \"black\"], size=15),\n",
+ " ),\n",
+ " )\n",
+ " ]\n",
+ " )\n",
+ " fig.update_layout(\n",
+ " title=dict(\n",
+ " text=\"Protection Levels (dBm)\",\n",
+ " font=dict(color=\"darkslategray\", size=20),\n",
+ " x=0.5,\n",
+ " ),\n",
+ " width=600,\n",
+ " )\n",
+ " fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22cf3f0b",
+ "metadata": {},
+ "source": [
+ "## Get all the radios in the project\n",
+ "\n",
+ "Get lists of all transmitters and receivers in the project."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e49b62b",
+ "metadata": {},
+ "source": [
+ "> **Note:** You can uncomment the following code.\n",
+ "\n",
+ "rev = emitapp.results.current_revision\n",
+ "rx_radios = rev.get_receiver_names()\n",
+ "tx_radios = rev.get_interferer_names(InterfererType.TRANSMITTERS)\n",
+ "domain = emitapp.results.interaction_domain()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "84003cb6",
+ "metadata": {},
+ "source": [
+ "## Classify the results\n",
+ "\n",
+ "Iterate over all the transmitters and receivers and compute the power\n",
+ "at the input to each receiver due to each of the transmitters. Computes\n",
+ "which protection levels are exceeded by these power levels, if any."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25246f44",
+ "metadata": {},
+ "source": [
+ "> **Note:** Your ability to uncomment the following code depends on whether you uncommented the earlier code.\n",
+ "\n",
+ "power_matrix = []\n",
+ "all_colors = []"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc45b37a",
+ "metadata": {},
+ "source": [
+ "all_colors, power_matrix = rev.protection_level_classification(\n",
+ " domain, global_levels=protection_levels\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3307b19c",
+ "metadata": {},
+ "source": [
+ "## Create a scenario matrix-like view for the protection levels\n",
+ "create_scenario_view(power_matrix, all_colors, tx_radios, rx_radios)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9e11a0f9",
+ "metadata": {},
+ "source": [
+ "## Create a legend for the protection levels\n",
+ "create_legend_table()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4baeda8",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a626e28f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "emitapp.save_project()\n",
+ "emitapp.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7d7cb2a",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4faa25e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/city.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/city.ipynb.txt
new file mode 100644
index 00000000..6781705b
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/city.ipynb.txt
@@ -0,0 +1,245 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "eebeb8c5",
+ "metadata": {},
+ "source": [
+ "# Geometry import from maps\n",
+ "\n",
+ "This example shows how to use PyAEDT to create an HFSS SBR+ project from\n",
+ "OpenStreetMap.\n",
+ "\n",
+ "Keywords: **HFSS**, **SBR+**, **city**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6832ec76",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports and set up the local path to the PyAEDT\n",
+ "directory path."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1d2a221e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7c939b78",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "979ed6d2",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ef9543f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "acf9e418",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "999bdb93",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a9de85c",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS and open project\n",
+ "\n",
+ "Launch HFSS and open the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c20c141",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"city.aedt\")\n",
+ "app = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " design=\"Ansys\",\n",
+ " solution_type=\"SBR+\",\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "604b3e92",
+ "metadata": {},
+ "source": [
+ "## Define location to import\n",
+ "\n",
+ "Define the latitude and longitude of the location to import."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08df5696",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ansys_home = [40.273726, -80.168269]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f714aa23",
+ "metadata": {},
+ "source": [
+ "## Generate map and import\n",
+ "\n",
+ "Assign boundaries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0f3977bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app.modeler.import_from_openstreet_map(\n",
+ " ansys_home,\n",
+ " terrain_radius=250,\n",
+ " road_step=3,\n",
+ " plot_before_importing=False,\n",
+ " import_in_aedt=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d37a4a6",
+ "metadata": {},
+ "source": [
+ "## Plot model\n",
+ "\n",
+ "Plot the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "01effd49",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_obj = app.plot(show=False, plot_air_objects=True)\n",
+ "plot_obj.background_color = [153, 203, 255]\n",
+ "plot_obj.zoom = 1.5\n",
+ "plot_obj.show_grid = False\n",
+ "plot_obj.show_axes = False\n",
+ "plot_obj.bounding_box = False\n",
+ "plot_obj.plot(os.path.join(temp_folder.name, \"Source.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ecda1c5",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c05adba7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app.save_project()\n",
+ "app.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7537ed5",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "589bd2c7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/doppler.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/doppler.ipynb.txt
new file mode 100644
index 00000000..4e36472c
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/doppler.ipynb.txt
@@ -0,0 +1,416 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "b8ebd4a9",
+ "metadata": {},
+ "source": [
+ "# Doppler setup\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a multipart scenario in HFSS SBR+\n",
+ "and set up a doppler analysis.\n",
+ "\n",
+ "Keywords: **HFSS**, **SBR+**, **doppler**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03ac125e",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "23302f9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2849351e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a77790d",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b4f4eee0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1109e63",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66746f90",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "488faf25",
+ "metadata": {},
+ "source": [
+ "## Download 3D component\n",
+ "Download the 3D component that is needed to run the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "472d3d88",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "library_path = ansys.aedt.core.downloads.download_multiparts(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6bebabe",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS and open project\n",
+ "\n",
+ "Launch HFSS and open the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75701772",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"doppler.aedt\")\n",
+ "app = ansys.aedt.core.Hfss(\n",
+ " version=AEDT_VERSION,\n",
+ " solution_type=\"SBR+\",\n",
+ " new_desktop=True,\n",
+ " project=project_name,\n",
+ " close_on_exit=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b255abd",
+ "metadata": {},
+ "source": [
+ "Creation of the \"actors\" in the scene is comprised of many editing steps. Disabling the autosave option helps\n",
+ "avoid delays that occur while the project is being saved."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae7df522",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app.autosave_disable()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3fadd9ca",
+ "metadata": {},
+ "source": [
+ "## Save project and rename design\n",
+ "\n",
+ "Save the project to the temporary folder and rename the design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a1edb54",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "design = \"doppler_sbr\"\n",
+ "app.rename_design(design)\n",
+ "app.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0f6a7c56",
+ "metadata": {},
+ "source": [
+ "## Set up library paths\n",
+ "\n",
+ "Specify the location of 3D components used to create the scene."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08a4b56e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "actor_lib = os.path.join(library_path, \"actor_library\")\n",
+ "env_lib = os.path.join(library_path, \"environment_library\")\n",
+ "radar_lib = os.path.join(library_path, \"radar_modules\")\n",
+ "env_folder = os.path.join(env_lib, \"road1\")\n",
+ "person_folder = os.path.join(actor_lib, \"person3\")\n",
+ "car_folder = os.path.join(actor_lib, \"vehicle1\")\n",
+ "bike_folder = os.path.join(actor_lib, \"bike1\")\n",
+ "bird_folder = os.path.join(actor_lib, \"bird1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ffdc46c4",
+ "metadata": {},
+ "source": [
+ "## Define environment\n",
+ "\n",
+ "Define the background environment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7cc9f526",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "road1 = app.modeler.add_environment(input_dir=env_folder, name=\"Bari\")\n",
+ "prim = app.modeler"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "92e3b261",
+ "metadata": {},
+ "source": [
+ "## Place actors\n",
+ "\n",
+ "Place actors in the environment. This code places persons, birds, bikes, and cars\n",
+ "in the environment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "09fb6d9e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "person1 = app.modeler.add_person(\n",
+ " input_dir=person_folder,\n",
+ " speed=1.0,\n",
+ " global_offset=[25, 1.5, 0],\n",
+ " yaw=180,\n",
+ " name=\"Massimo\",\n",
+ ")\n",
+ "person2 = app.modeler.add_person(\n",
+ " input_dir=person_folder,\n",
+ " speed=1.0,\n",
+ " global_offset=[25, 2.5, 0],\n",
+ " yaw=180,\n",
+ " name=\"Devin\",\n",
+ ")\n",
+ "car1 = app.modeler.add_vehicle(\n",
+ " input_dir=car_folder, speed=8.7, global_offset=[3, -2.5, 0], name=\"LuxuryCar\"\n",
+ ")\n",
+ "bike1 = app.modeler.add_vehicle(\n",
+ " input_dir=bike_folder,\n",
+ " speed=2.1,\n",
+ " global_offset=[24, 3.6, 0],\n",
+ " yaw=180,\n",
+ " name=\"Alberto_in_bike\",\n",
+ ")\n",
+ "bird1 = app.modeler.add_bird(\n",
+ " input_dir=bird_folder,\n",
+ " speed=1.0,\n",
+ " global_offset=[19, 4, 3],\n",
+ " yaw=120,\n",
+ " pitch=-5,\n",
+ " flapping_rate=30,\n",
+ " name=\"Pigeon\",\n",
+ ")\n",
+ "bird2 = app.modeler.add_bird(\n",
+ " input_dir=bird_folder,\n",
+ " speed=1.0,\n",
+ " global_offset=[6, 2, 3],\n",
+ " yaw=-60,\n",
+ " pitch=10,\n",
+ " name=\"Eagle\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd20e5f8",
+ "metadata": {},
+ "source": [
+ "## Place radar\n",
+ "\n",
+ "Place radar on the car. The radar is created relative to the car's coordinate\n",
+ "system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "71e0d4b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "radar1 = app.create_sbr_radar_from_json(\n",
+ " radar_file=radar_lib,\n",
+ " name=\"Example_1Tx_1Rx\",\n",
+ " offset=[2.57, 0, 0.54],\n",
+ " use_relative_cs=True,\n",
+ " relative_cs_name=car1.cs_name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e5c6e765",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create setup and validate it. The ``create_sbr_pulse_doppler_setup()`` method\n",
+ "creates a setup and a parametric sweep on the time variable with a\n",
+ "duration of two seconds. The step is computed automatically from CPI."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50441094",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup, sweep = app.create_sbr_pulse_doppler_setup(sweep_time_duration=2)\n",
+ "app.set_sbr_current_sources_options()\n",
+ "app.validate_simple()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ee6ca2d3",
+ "metadata": {},
+ "source": [
+ "## Solve and release AEDT\n",
+ "\n",
+ "Solve and release AEDT. To solve, uncomment the ``app.analyze_setup`` command\n",
+ "to activate the simulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a75eaca5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# app.analyze_setup(sweep.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f5f8628b",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dda79c4f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "app.save_project()\n",
+ "app.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a692189a",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "edadf58d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/index.rst.txt b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/index.rst.txt
new file mode 100644
index 00000000..9ffc6bbf
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/index.rst.txt
@@ -0,0 +1,66 @@
+Large scenarios
+~~~~~~~~~~~~~~~
+These examples use PyAEDT to show some general capabilities of HFSS SBR+ for large scenarios
+
+.. grid:: 2
+
+ .. grid-item-card:: Geometry import from maps
+ :padding: 2 2 2 2
+ :link: city
+ :link-type: doc
+
+ .. image:: _static/city.png
+ :alt: City
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create an HFSS SBR+ project from OpenStreetMap.
+
+ .. grid-item-card:: Doppler setup
+ :padding: 2 2 2 2
+ :link: doppler
+ :link-type: doc
+
+ .. image:: _static/doppler.png
+ :alt: Doppler
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a multipart scenario in HFSS SBR+ and set up a doppler analysis.
+
+ .. grid-item-card:: Reflector
+ :padding: 2 2 2 2
+ :link: reflector
+ :link-type: doc
+
+ .. image:: _static/reflector.png
+ :alt: Reflector
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create an HFSS SBR+ project from an HFSS antenna and run a simulation.
+
+ .. grid-item-card:: HFSS to SBR+ time animation
+ :padding: 2 2 2 2
+ :link: time_domain
+ :link-type: doc
+
+ .. image:: _static/time_domain.png
+ :alt: SBR Time
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create an SBR+ time animation and save it to a GIF file.
+
+
+ .. toctree::
+ :hidden:
+
+ city
+ doppler
+ reflector
+ time_domain
diff --git a/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/reflector.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/reflector.ipynb.txt
new file mode 100644
index 00000000..8eb946de
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/reflector.ipynb.txt
@@ -0,0 +1,324 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7292b3b0",
+ "metadata": {},
+ "source": [
+ "# Reflector\n",
+ "\n",
+ "This example shows how to use PyAEDT to create an HFSS SBR+ project from an\n",
+ "HFSS antenna and run a simulation.\n",
+ "\n",
+ "Keywords: **HFSS**, **SBR+**, **reflector**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a2c5cce9",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports and set up the local path to the path for the PyAEDT\n",
+ "directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68e55d67",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "78620880",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ebe01376",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae48b4ff",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d0ff9de",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "96d363dd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "51135a14",
+ "metadata": {},
+ "source": [
+ "## Download project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5eaca295",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_full_name = ansys.aedt.core.downloads.download_sbr(destination=temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc3981ae",
+ "metadata": {},
+ "source": [
+ "## Define designs\n",
+ "\n",
+ "Define two designs, one source and one target, with each design connected to\n",
+ "a different object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "63de29a2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "target = ansys.aedt.core.Hfss(\n",
+ " project=project_full_name,\n",
+ " design=\"Cassegrain_\",\n",
+ " solution_type=\"SBR+\",\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")\n",
+ "\n",
+ "source = ansys.aedt.core.Hfss(\n",
+ " project=target.project_name,\n",
+ " design=\"feeder\",\n",
+ " version=AEDT_VERSION,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be3f9cd2",
+ "metadata": {},
+ "source": [
+ "## Define linked antenna\n",
+ "\n",
+ "Define a linked antenna. This is HFSS far field applied to HFSS SBR+."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "58d3219e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "target.create_sbr_linked_antenna(\n",
+ " source, target_cs=\"feederPosition\", field_type=\"farfield\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "362cd194",
+ "metadata": {},
+ "source": [
+ "## Assign boundaries\n",
+ "\n",
+ "Assign boundaries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "195c5cf7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "target.assign_perfecte_to_sheets([\"Reflector\", \"Subreflector\"])\n",
+ "target.mesh.assign_curvilinear_elements([\"Reflector\", \"Subreflector\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c1411cf",
+ "metadata": {},
+ "source": [
+ "## Create setup and solve\n",
+ "\n",
+ "Create a setup and solve it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9dab4241",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = target.create_setup()\n",
+ "setup1.props[\"RadiationSetup\"] = \"ATK_3D\"\n",
+ "setup1.props[\"ComputeFarFields\"] = True\n",
+ "setup1.props[\"RayDensityPerWavelength\"] = 2\n",
+ "setup1.props[\"MaxNumberOfBounces\"] = 3\n",
+ "setup1[\"RangeType\"] = \"SinglePoints\"\n",
+ "setup1[\"RangeStart\"] = \"10GHz\"\n",
+ "target.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ae8f68d4",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Plot results in AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e4a503a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "variations = target.available_variations.nominal_w_values_dict\n",
+ "variations[\"Freq\"] = [\"10GHz\"]\n",
+ "variations[\"Theta\"] = [\"All\"]\n",
+ "variations[\"Phi\"] = [\"All\"]\n",
+ "target.post.create_report(\n",
+ " \"db(GainTotal)\",\n",
+ " target.nominal_adaptive,\n",
+ " variations=variations,\n",
+ " primary_sweep_variable=\"Theta\",\n",
+ " context=\"ATK_3D\",\n",
+ " report_category=\"Far Fields\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5b18d56",
+ "metadata": {},
+ "source": [
+ "Plot results using Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fda9547e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solution = target.post.get_solution_data(\n",
+ " \"GainTotal\",\n",
+ " target.nominal_adaptive,\n",
+ " variations=variations,\n",
+ " primary_sweep_variable=\"Theta\",\n",
+ " context=\"ATK_3D\",\n",
+ " report_category=\"Far Fields\",\n",
+ ")\n",
+ "solution.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e4e89fe0",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ec6d1418",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "target.save_project()\n",
+ "target.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "16dd8409",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bbec5691",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/time_domain.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/time_domain.ipynb.txt
new file mode 100644
index 00000000..a08a0a9f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/large_scenarios/time_domain.ipynb.txt
@@ -0,0 +1,298 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "ee6e2143",
+ "metadata": {},
+ "source": [
+ "# HFSS to SBR+ time animation\n",
+ "\n",
+ "This example shows how to use PyAEDT to create an SBR+ time animation\n",
+ "and save it to a GIF file. This example works only on CPython.\n",
+ "\n",
+ "Keywords: **HFSS**, **SBR+**, **time domain**, **IFFT**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a7e49fc",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2f9d7853",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "56f76afa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import Hfss, downloads"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53f026f5",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "908cb895",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9672a33",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b276c4f6",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6e7c020",
+ "metadata": {},
+ "source": [
+ "## Download project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c62a986d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_file = downloads.download_sbr_time(destination=temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0dec890",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS and analyze"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "56533a26",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = Hfss(\n",
+ " project=project_file,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee905692",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "58c3e4be",
+ "metadata": {},
+ "source": [
+ "## Get solution data\n",
+ "\n",
+ "Get solution data. After the simulation is performed, you can load solutions\n",
+ "in the ``solution_data`` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "90e9b466",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solution_data = hfss.post.get_solution_data(\n",
+ " expressions=[\"NearEX\", \"NearEY\", \"NearEZ\"],\n",
+ " variations={\"_u\": [\"All\"], \"_v\": [\"All\"], \"Freq\": [\"All\"]},\n",
+ " context=\"Near_Field\",\n",
+ " report_category=\"Near Fields\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f499ca42",
+ "metadata": {},
+ "source": [
+ "## Compute IFFT\n",
+ "\n",
+ "Compute IFFT (Inverse Fast Fourier Transform)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cb1b944e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "t_matrix = solution_data.ifft(\"NearE\", window=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03e76082",
+ "metadata": {},
+ "source": [
+ "## Export IFFT to CSV file\n",
+ "\n",
+ "Export IFFT to a CSV file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9ca756fe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "frames_list_file = solution_data.ifft_to_file(\n",
+ " coord_system_center=[-0.15, 0, 0],\n",
+ " db_val=True,\n",
+ " csv_path=os.path.join(hfss.working_directory, \"csv\"),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3cfe8949",
+ "metadata": {},
+ "source": [
+ "## Plot scene\n",
+ "\n",
+ "Plot the scene to create the time plot animation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41e88377",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.post.plot_scene(\n",
+ " frames=frames_list_file,\n",
+ " gif_path=os.path.join(hfss.working_directory, \"animation.gif\"),\n",
+ " norm_index=15,\n",
+ " dy_rng=35,\n",
+ " show=False,\n",
+ " view=\"xy\",\n",
+ " zoom=1,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "68cfde29",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bb4602e3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1cc58d13",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ae0a6f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/antenna/patch.ipynb.txt b/version/dev/_sources/examples/high_frequency/antenna/patch.ipynb.txt
new file mode 100644
index 00000000..406ef552
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/antenna/patch.ipynb.txt
@@ -0,0 +1,275 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "112e1a97",
+ "metadata": {},
+ "source": [
+ "# Probe-fed patch antenna\n",
+ "\n",
+ "This example shows how to use the ``Stackup3D`` class\n",
+ "to create and analyze a patch antenna in HFSS.\n",
+ "\n",
+ "Note that the HFSS 3D Layout interface may offer advantages for\n",
+ "laminate structures such as the patch antenna.\n",
+ "\n",
+ "Keywords: **HFSS**, **terminal**, **antenna**., **patch**.\n",
+ "\n",
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ab3800b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "17041071",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.modeler.advanced_cad.stackup_3d import Stackup3D"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f1b507ef",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "91bf1b78",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9d10eca",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9e13e500",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e4d95a56",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS\n",
+ "\n",
+ "Launch HFSS and change the length units."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ea37d896",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"patch.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " solution_type=\"Terminal\",\n",
+ " design=\"patch\",\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " version=AEDT_VERSION,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e55cf538",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "length_units = \"mm\"\n",
+ "freq_units = \"GHz\"\n",
+ "hfss.modeler.model_units = length_units"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a5a6e966",
+ "metadata": {},
+ "source": [
+ "## Create patch\n",
+ "\n",
+ "Create the patch."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bf4e3273",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "stackup = Stackup3D(hfss)\n",
+ "ground = stackup.add_ground_layer(\n",
+ " \"ground\", material=\"copper\", thickness=0.035, fill_material=\"air\"\n",
+ ")\n",
+ "dielectric = stackup.add_dielectric_layer(\n",
+ " \"dielectric\", thickness=\"0.5\" + length_units, material=\"Duroid (tm)\"\n",
+ ")\n",
+ "signal = stackup.add_signal_layer(\n",
+ " \"signal\", material=\"copper\", thickness=0.035, fill_material=\"air\"\n",
+ ")\n",
+ "patch = signal.add_patch(\n",
+ " patch_length=9.57, patch_width=9.25, patch_name=\"Patch\", frequency=1e10\n",
+ ")\n",
+ "\n",
+ "stackup.resize_around_element(patch)\n",
+ "pad_length = [3, 3, 3, 3, 3, 3] # Air bounding box buffer in mm.\n",
+ "region = hfss.modeler.create_region(pad_length, is_percentage=False)\n",
+ "hfss.assign_radiation_boundary_to_objects(region)\n",
+ "\n",
+ "patch.create_probe_port(ground, rel_x_offset=0.485)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a8e2fb34",
+ "metadata": {},
+ "source": [
+ "## Set up simulation\n",
+ "Set up a simulation and analyze it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8fd26d99",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(name=\"Setup1\", setup_type=\"HFSSDriven\", Frequency=\"10GHz\")\n",
+ "\n",
+ "setup.create_frequency_sweep(\n",
+ " unit=\"GHz\",\n",
+ " name=\"Sweep1\",\n",
+ " start_frequency=8,\n",
+ " stop_frequency=12,\n",
+ " sweep_type=\"Interpolating\",\n",
+ ")\n",
+ "\n",
+ "hfss.save_project()\n",
+ "hfss.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d592539d",
+ "metadata": {},
+ "source": [
+ "## Plot S11\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cf4bab2b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_data = hfss.get_traces_for_plot()\n",
+ "report = hfss.post.create_report(plot_data)\n",
+ "solution = report.get_solution_data()\n",
+ "plt = solution.plot(solution.expressions)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "372cba41",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6d0f580b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "14562d6f",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "07815046",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/armoured_cable.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/armoured_cable.ipynb.txt
new file mode 100644
index 00000000..b0524069
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/armoured_cable.ipynb.txt
@@ -0,0 +1,723 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "41fa7460",
+ "metadata": {},
+ "source": [
+ "# Cable parameter identification"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ca55c2c",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to perform these tasks:\n",
+ "\n",
+ " - Create a Q2D design using modeler primitives and an imported CAD.\n",
+ " - Set up the simulation.\n",
+ " - Link the solution to a Simplorer design.\n",
+ "\n",
+ "For information on the cable model used in this example, see\n",
+ "[4 Core Armoured Power Cable](https://www.luxingcable.com/low-voltage-cables/4-core-armoured-power-cable.html).\n",
+ "\n",
+ "Keywords: **Q2D**, **EMC**, **cable**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dfa4c71e",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8a32fc0b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "35c45c67",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "96108f9d",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5aaef4aa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90c54876",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4bf9d73a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1947cc2",
+ "metadata": {},
+ "source": [
+ "## Set up for model creation\n",
+ "\n",
+ "Initialize cable sizing by specifying radii in millimeters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a86c870e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "c_strand_radius = 2.575\n",
+ "cable_n_cores = 4\n",
+ "core_n_strands = 6\n",
+ "core_xlpe_ins_thickness = 0.5\n",
+ "core_xy_coord = math.ceil(3 * c_strand_radius + 2 * core_xlpe_ins_thickness)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe526d9f",
+ "metadata": {},
+ "source": [
+ "Initialize radii of further structures incrementally adding thicknesses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a4a63eac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filling_radius = 1.4142 * (\n",
+ " core_xy_coord + 3 * c_strand_radius + core_xlpe_ins_thickness + 0.5\n",
+ ")\n",
+ "inner_sheath_radius = filling_radius + 0.75\n",
+ "armour_thickness = 3\n",
+ "armour_radius = inner_sheath_radius + armour_thickness\n",
+ "outer_sheath_radius = armour_radius + 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "35548c55",
+ "metadata": {},
+ "source": [
+ "Initialize radii."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5823bdc6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "armour_centre_pos = inner_sheath_radius + armour_thickness / 2.0\n",
+ "arm_strand_rad = armour_thickness / 2.0 - 0.2\n",
+ "n_arm_strands = 30"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "079949ae",
+ "metadata": {},
+ "source": [
+ "Start an instance of Q2D Extractor, providing the version, project name, design\n",
+ "name, and type."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "78cd2cfe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"Q2D_ArmouredCableExample.aedt\")\n",
+ "q2d_design_name = \"2D_Extractor_Cable\"\n",
+ "setup_name = \"AnalysisSeetup\"\n",
+ "sweep_name = \"FreqSweep\"\n",
+ "tb_design_name = \"CableSystem\"\n",
+ "q2d = ansys.aedt.core.Q2d(\n",
+ " project=project_name,\n",
+ " design=q2d_design_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ ")\n",
+ "q2d.modeler.model_units = \"mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "529ea6a5",
+ "metadata": {},
+ "source": [
+ "Assign variables to the Q3D design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0cf5dce6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "core_params = {\n",
+ " \"n_cores\": str(cable_n_cores),\n",
+ " \"n_strands_core\": str(core_n_strands),\n",
+ " \"c_strand_radius\": str(c_strand_radius) + \"mm\",\n",
+ " \"c_strand_xy_coord\": str(core_xy_coord) + \"mm\",\n",
+ "}\n",
+ "outer_params = {\n",
+ " \"filling_radius\": str(filling_radius) + \"mm\",\n",
+ " \"inner_sheath_radius\": str(inner_sheath_radius) + \"mm\",\n",
+ " \"armour_radius\": str(armour_radius) + \"mm\",\n",
+ " \"outer_sheath_radius\": str(outer_sheath_radius) + \"mm\",\n",
+ "}\n",
+ "armour_params = {\n",
+ " \"armour_centre_pos\": str(armour_centre_pos) + \"mm\",\n",
+ " \"arm_strand_rad\": str(arm_strand_rad) + \"mm\",\n",
+ " \"n_arm_strands\": str(n_arm_strands),\n",
+ "}\n",
+ "for k, v in core_params.items():\n",
+ " q2d[k] = v\n",
+ "for k, v in outer_params.items():\n",
+ " q2d[k] = v\n",
+ "for k, v in armour_params.items():\n",
+ " q2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3031d418",
+ "metadata": {},
+ "source": [
+ "Cable insulators require the definition of specific materials since they are not\n",
+ "included in the ``Sys`` library.\n",
+ "\n",
+ "Define Plastic, PE (cross-linked, wire, and cable grade):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c2f35667",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat_pe_cable_grade = q2d.materials.add_material(\"plastic_pe_cable_grade\")\n",
+ "mat_pe_cable_grade.conductivity = \"1.40573e-16\"\n",
+ "mat_pe_cable_grade.permittivity = \"2.09762\"\n",
+ "mat_pe_cable_grade.dielectric_loss_tangent = \"0.000264575\"\n",
+ "mat_pe_cable_grade.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c4eb1ed",
+ "metadata": {},
+ "source": [
+ "Define Plastic, PP (10% carbon fiber):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d49cd6ad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat_pp = q2d.materials.add_material(\"plastic_pp_carbon_fiber\")\n",
+ "mat_pp.conductivity = \"0.0003161\"\n",
+ "mat_pp.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86150202",
+ "metadata": {},
+ "source": [
+ "## Create model\n",
+ "\n",
+ "Create the geometry for core strands, fill, and XLPE insulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "934a1516",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.create_coordinate_system(\n",
+ " origin=[\"c_strand_xy_coord\", \"c_strand_xy_coord\", \"0mm\"], name=\"CS_c_strand_1\"\n",
+ ")\n",
+ "q2d.modeler.set_working_coordinate_system(\"CS_c_strand_1\")\n",
+ "c1_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"c_strand_radius\",\n",
+ " name=\"c_strand_1\",\n",
+ " material=\"copper\",\n",
+ ")\n",
+ "c2_id = c1_id.duplicate_along_line(\n",
+ " vector=[\"0mm\", \"2.0*c_strand_radius\", \"0mm\"], clones=2\n",
+ ")\n",
+ "q2d.modeler.duplicate_around_axis(c2_id, axis=\"Z\", angle=360 / core_n_strands, clones=6)\n",
+ "c_unite_name = q2d.modeler.unite(q2d.get_all_conductors_names())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b9f090c0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fill_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"3*c_strand_radius\",\n",
+ " name=\"c_strand_fill\",\n",
+ " material=\"plastic_pp_carbon_fiber\",\n",
+ ")\n",
+ "fill_id.color = (255, 255, 0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b01dc69a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "xlpe_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"3*c_strand_radius+\" + str(core_xlpe_ins_thickness) + \"mm\",\n",
+ " name=\"c_strand_xlpe\",\n",
+ " material=\"plastic_pe_cable_grade\",\n",
+ ")\n",
+ "xlpe_id.color = (0, 128, 128)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "884b2b8a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.set_working_coordinate_system(\"Global\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c0672ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "all_obj_names = q2d.get_all_conductors_names() + q2d.get_all_dielectrics_names()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c67e829a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.duplicate_around_axis(\n",
+ " all_obj_names, axis=\"Z\", angle=360 / cable_n_cores, clones=4\n",
+ ")\n",
+ "cond_names = q2d.get_all_conductors_names()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "635c7c8b",
+ "metadata": {},
+ "source": [
+ "Define the filling object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2672bb17",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filling_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"filling_radius\",\n",
+ " name=\"Filling\",\n",
+ " material=\"plastic_pp_carbon_fiber\",\n",
+ ")\n",
+ "filling_id.color = (255, 255, 180)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bea40677",
+ "metadata": {},
+ "source": [
+ "Define the inner sheath."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "07dab0b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "inner_sheath_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"inner_sheath_radius\",\n",
+ " name=\"InnerSheath\",\n",
+ " material=\"PVC plastic\",\n",
+ ")\n",
+ "inner_sheath_id.color = (0, 0, 0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0e0d58a",
+ "metadata": {},
+ "source": [
+ "Create the armature fill."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41e648fb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "arm_fill_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"armour_radius\",\n",
+ " name=\"ArmourFilling\",\n",
+ " material=\"plastic_pp_carbon_fiber\",\n",
+ ")\n",
+ "arm_fill_id.color = (255, 255, 255)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "574a1436",
+ "metadata": {},
+ "source": [
+ "Create the geometry for the outer sheath."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7f72dc4e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "outer_sheath_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"0mm\", \"0mm\"],\n",
+ " radius=\"outer_sheath_radius\",\n",
+ " name=\"OuterSheath\",\n",
+ " material=\"PVC plastic\",\n",
+ ")\n",
+ "outer_sheath_id.color = (0, 0, 0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c3ad9232",
+ "metadata": {},
+ "source": [
+ "Create the geometry for the armature steel strands."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "42b28f8a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "arm_strand_1_id = q2d.modeler.create_circle(\n",
+ " origin=[\"0mm\", \"armour_centre_pos\", \"0mm\"],\n",
+ " radius=\"1.1mm\",\n",
+ " name=\"arm_strand_1\",\n",
+ " material=\"steel_stainless\",\n",
+ ")\n",
+ "arm_strand_1_id.color = (128, 128, 64)\n",
+ "arm_strand_1_id.duplicate_around_axis(\n",
+ " axis=\"Z\", angle=\"360deg/n_arm_strands\", clones=\"n_arm_strands\"\n",
+ ")\n",
+ "arm_strand_names = q2d.modeler.get_objects_w_string(\"arm_strand\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "40dfd10d",
+ "metadata": {},
+ "source": [
+ "Define the outer region that defines the solution domain."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d098f603",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = q2d.modeler.create_region([500, 500, 500, 500])\n",
+ "region.material_name = \"vacuum\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ee44db7",
+ "metadata": {},
+ "source": [
+ "Assign conductors and reference ground."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1e3ad740",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj = [q2d.modeler.get_object_from_name(i) for i in cond_names]\n",
+ "[\n",
+ " q2d.assign_single_conductor(\n",
+ " name=\"C1\" + str(obj.index(i) + 1), assignment=i, conductor_type=\"SignalLine\"\n",
+ " )\n",
+ " for i in obj\n",
+ "]\n",
+ "obj = [q2d.modeler.get_object_from_name(i) for i in arm_strand_names]\n",
+ "q2d.assign_single_conductor(\n",
+ " name=\"gnd\", assignment=obj, conductor_type=\"ReferenceGround\"\n",
+ ")\n",
+ "q2d.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6bb6122",
+ "metadata": {},
+ "source": [
+ "Specify the design settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "16d84c09",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lumped_length = \"100m\"\n",
+ "q2d.design_settings[\"LumpedLength\"] = lumped_length"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6d83a316",
+ "metadata": {},
+ "source": [
+ "## Solve model\n",
+ "\n",
+ "Insert the setup and frequency sweep."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8e0fb51e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d_setup = q2d.create_setup(name=setup_name)\n",
+ "q2d_sweep = q2d_setup.add_sweep(name=sweep_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "52580044",
+ "metadata": {},
+ "source": [
+ "The cable model is generated by running two solution types:\n",
+ "\n",
+ "1. Capacitance and conductance per unit length (CG).\n",
+ "For this model, the CG solution runs in a few seconds.\n",
+ "\n",
+ "2. Series resistance and inductance (RL).\n",
+ "For this model, the solution time can range from 15-20 minutes,\n",
+ "depending on the available hardware.\n",
+ "\n",
+ "Uncomment the following line to run the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0770843c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# q2d.analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "62be9820",
+ "metadata": {},
+ "source": [
+ "## Evaluate results\n",
+ "\n",
+ "Add a Simplorer/Twin Builder design and the Q3D dynamic component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68808cec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb = ansys.aedt.core.TwinBuilder(design=tb_design_name, version=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a739216",
+ "metadata": {},
+ "source": [
+ "Add a Q2D dynamic component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e6b35525",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.add_q3d_dynamic_component(\n",
+ " project_name,\n",
+ " q2d_design_name,\n",
+ " q2d_setup.name,\n",
+ " q2d_sweep.name,\n",
+ " model_depth=lumped_length,\n",
+ " coupling_matrix_name=\"Original\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1d78865",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0d1cc96c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.save_project()\n",
+ "tb.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9e736edb",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b357c45d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/busbar.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/busbar.ipynb.txt
new file mode 100644
index 00000000..620094c4
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/busbar.ipynb.txt
@@ -0,0 +1,400 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "6de1d237",
+ "metadata": {},
+ "source": [
+ "# Busbar analysis"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc409118",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to create a busbar design in\n",
+ "Q3D Extractor and run a simulation.\n",
+ "\n",
+ "Keywords: **Q3D**, **EMC*, **busbar**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d36854a1",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "07d1c6b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2f4dbb11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ba0dc9e0",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1278ece5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad4dec7c",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b56ee9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c419d03",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and Q3D Extractor\n",
+ "\n",
+ "Launch AEDT 2024 R2 in graphical mode and launch Q3D Extractor. This example uses SI units."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68c6b06f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d = ansys.aedt.core.Q3d(\n",
+ " project=os.path.join(temp_folder.name, \"busbar.aedt\"),\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6196298",
+ "metadata": {},
+ "source": [
+ "## Create and set up the Q3D model\n",
+ "\n",
+ "Create polylines for three busbars and a box for the substrate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "80d7d634",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "b1 = q3d.modeler.create_polyline(\n",
+ " points=[[0, 0, 0], [-100, 0, 0]],\n",
+ " name=\"Bar1\",\n",
+ " material=\"copper\",\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=\"5mm\",\n",
+ " xsection_height=\"1mm\",\n",
+ ")\n",
+ "q3d.modeler[\"Bar1\"].color = (255, 0, 0)\n",
+ "\n",
+ "q3d.modeler.create_polyline(\n",
+ " points=[[0, -15, 0], [-150, -15, 0]],\n",
+ " name=\"Bar2\",\n",
+ " material=\"aluminum\",\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=\"5mm\",\n",
+ " xsection_height=\"1mm\",\n",
+ ")\n",
+ "q3d.modeler[\"Bar2\"].color = (0, 255, 0)\n",
+ "\n",
+ "q3d.modeler.create_polyline(\n",
+ " points=[[0, -30, 0], [-175, -30, 0], [-175, -10, 0]],\n",
+ " name=\"Bar3\",\n",
+ " material=\"copper\",\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=\"5mm\",\n",
+ " xsection_height=\"1mm\",\n",
+ ")\n",
+ "q3d.modeler[\"Bar3\"].color = (0, 0, 255)\n",
+ "\n",
+ "q3d.modeler.create_box(\n",
+ " origin=[50, 30, -0.5],\n",
+ " sizes=[-250, -100, -3],\n",
+ " name=\"substrate\",\n",
+ " material=\"FR4_epoxy\",\n",
+ ")\n",
+ "q3d.modeler[\"substrate\"].color = (128, 128, 128)\n",
+ "q3d.modeler[\"substrate\"].transparency = 0.8\n",
+ "\n",
+ "q3d.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Q3D.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c32f83d2",
+ "metadata": {},
+ "source": [
+ "Identify nets and assign sources and sinks to all nets.\n",
+ "There is a source and sink for each busbar."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c32a01ad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.auto_identify_nets()\n",
+ "\n",
+ "q3d.source(assignment=\"Bar1\", direction=q3d.AxisDir.XPos, name=\"Source1\")\n",
+ "q3d.sink(assignment=\"Bar1\", direction=q3d.AxisDir.XNeg, name=\"Sink1\")\n",
+ "\n",
+ "q3d.source(assignment=\"Bar2\", direction=q3d.AxisDir.XPos, name=\"Source2\")\n",
+ "q3d.sink(assignment=\"Bar2\", direction=q3d.AxisDir.XNeg, name=\"Sink2\")\n",
+ "q3d.source(assignment=\"Bar3\", direction=q3d.AxisDir.XPos, name=\"Source3\")\n",
+ "bar3_sink = q3d.sink(assignment=\"Bar3\", direction=q3d.AxisDir.YPos, name=\"Sink3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa040603",
+ "metadata": {},
+ "source": [
+ "Print information about nets and terminal assignments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ed06f9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(q3d.nets)\n",
+ "print(q3d.net_sinks(\"Bar1\"))\n",
+ "print(q3d.net_sinks(\"Bar2\"))\n",
+ "print(q3d.net_sinks(\"Bar3\"))\n",
+ "print(q3d.net_sources(\"Bar1\"))\n",
+ "print(q3d.net_sources(\"Bar2\"))\n",
+ "print(q3d.net_sources(\"Bar3\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da61c443",
+ "metadata": {},
+ "source": [
+ "Create the solution setup and define the frequency range for the solution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a3203ee8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = q3d.create_setup(props={\"AdaptiveFreq\": \"100MHz\"})\n",
+ "sweep = setup1.add_sweep()\n",
+ "sweep.props[\"RangeStart\"] = \"1MHz\"\n",
+ "sweep.props[\"RangeEnd\"] = \"100MHz\"\n",
+ "sweep.props[\"RangeStep\"] = \"5MHz\"\n",
+ "sweep.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6468ce36",
+ "metadata": {},
+ "source": [
+ "### Set up for postprocessing\n",
+ "\n",
+ "Specify the traces to display after solving the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a5f1416a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_plot_self = q3d.matrices[0].get_sources_for_plot(\n",
+ " get_self_terms=True, get_mutual_terms=False\n",
+ ")\n",
+ "data_plot_mutual = q3d.get_traces_for_plot(\n",
+ " get_self_terms=False, get_mutual_terms=True, category=\"C\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cac7c7f",
+ "metadata": {},
+ "source": [
+ "Define a plot and a data table in AEDT for visualizing results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "815357ae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.post.create_report(expressions=data_plot_self)\n",
+ "q3d.post.create_report(\n",
+ " expressions=data_plot_mutual, context=\"Original\", plot_type=\"Data Table\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a3fe09c9",
+ "metadata": {},
+ "source": [
+ "## Analyze\n",
+ "\n",
+ "Solve the setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7d337c63",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.analyze(cores=NUM_CORES)\n",
+ "q3d.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a4aaf7d0",
+ "metadata": {},
+ "source": [
+ "Retrieve solution data for processing in Python."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b7e83ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = q3d.post.get_solution_data(expressions=data_plot_self, context=\"Original\")\n",
+ "data.data_magnitude()\n",
+ "data.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "249ba60e",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "29aac39a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.save_project()\n",
+ "q3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e480eff5",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0244701c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/choke.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/choke.ipynb.txt
new file mode 100644
index 00000000..f325d48f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/choke.ipynb.txt
@@ -0,0 +1,516 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e38eff9e",
+ "metadata": {},
+ "source": [
+ "# Choke\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a choke setup in HFSS.\n",
+ "\n",
+ "Keywords: **HFSS**, **EMC**, **choke**, ."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9d1aa84",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8090fac2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1de66d38",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21b5571f",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e3c776c9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "551fe177",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ebb49e0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "63118e7b",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "faa9d89a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"choke.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " solution_type=\"Terminal\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "338e7cd6",
+ "metadata": {},
+ "source": [
+ "## Define parameters\n",
+ "\n",
+ "The dictionary values contain the different parameter values of the core and\n",
+ "the windings that compose the choke. You must not change the main structure of\n",
+ "the dictionary. The dictionary has many primary keys, including\n",
+ "``\"Number of Windings\"``, ``\"Layer\"``, and ``\"Layer Type\"``, that have\n",
+ "dictionaries as values. The keys of these dictionaries are secondary keys\n",
+ "of the dictionary values, such as ``\"1\"``, ``\"2\"``, ``\"3\"``, ``\"4\"``, and\n",
+ "``\"Simple\"``.\n",
+ "\n",
+ "You must not modify the primary or secondary keys. You can modify only their values.\n",
+ "You must not change the data types for these keys. For the dictionaries from\n",
+ "``\"Number of Windings\"`` through ``\"Wire Section\"``, values must be Boolean. Only\n",
+ "one value per dictionary can be ``True``. If all values are ``True``, only the first one\n",
+ "remains set to ``True``. If all values are ``False``, the first value is chosen as the\n",
+ "correct one by default. For the dictionaries from ``\"Core\"`` through ``\"Inner Winding\"``,\n",
+ "values must be strings, floats, or integers.\n",
+ "\n",
+ "Descriptions follow for the primary keys:\n",
+ "\n",
+ "- ``\"Number of Windings\"``: Number of windings around the core.\n",
+ "- ``\"Layer\"``: Number of layers of all windings.\n",
+ "- ``\"Layer Type\"``: Whether layers of a winding are linked to each other\n",
+ "- ``\"Similar Layer\"``: Whether layers of a winding have the same number of turns and\n",
+ "same spacing between turns.\n",
+ "- ``\"Mode\"``: When there are only two windows, whether they are in common or differential mode.\n",
+ "- ``\"Wire Section\"``: Type of wire section and number of segments.\n",
+ "- ``\"Core\"``: Design of the core.\n",
+ "- ``\"Outer Winding\"``: Design of the first layer or outer layer of a winding and the common\n",
+ "parameters for all layers.\n",
+ "- ``\"Mid Winding\"``: Turns and turns spacing (``Coil Pit``) for the second or\n",
+ "mid layer if it is necessary.\n",
+ "- ``\"Inner Winding\"``: Turns and turns spacing (``Coil Pit``) for the third or inner\n",
+ "layer if it is necessary.\n",
+ "- ``\"Occupation(%)\"``: An informative parameter that is useless to modify.\n",
+ "\n",
+ "The following parameter values work. You can modify them if you want."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8d9e707c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "values = {\n",
+ " \"Number of Windings\": {\"1\": False, \"2\": True, \"3\": False, \"4\": False},\n",
+ " \"Layer\": {\"Simple\": False, \"Double\": True, \"Triple\": False},\n",
+ " \"Layer Type\": {\"Separate\": False, \"Linked\": True},\n",
+ " \"Similar Layer\": {\"Similar\": False, \"Different\": True},\n",
+ " \"Mode\": {\"Differential\": False, \"Common\": True},\n",
+ " \"Wire Section\": {\"None\": False, \"Hexagon\": True, \"Octagon\": False, \"Circle\": False},\n",
+ " \"Core\": {\n",
+ " \"Name\": \"Core\",\n",
+ " \"Material\": \"ferrite\",\n",
+ " \"Inner Radius\": 20,\n",
+ " \"Outer Radius\": 30,\n",
+ " \"Height\": 10,\n",
+ " \"Chamfer\": 0.8,\n",
+ " },\n",
+ " \"Outer Winding\": {\n",
+ " \"Name\": \"Winding\",\n",
+ " \"Material\": \"copper\",\n",
+ " \"Inner Radius\": 20,\n",
+ " \"Outer Radius\": 30,\n",
+ " \"Height\": 10,\n",
+ " \"Wire Diameter\": 1.5,\n",
+ " \"Turns\": 20,\n",
+ " \"Coil Pit(deg)\": 0.1,\n",
+ " \"Occupation(%)\": 0,\n",
+ " },\n",
+ " \"Mid Winding\": {\"Turns\": 25, \"Coil Pit(deg)\": 0.1, \"Occupation(%)\": 0},\n",
+ " \"Inner Winding\": {\"Turns\": 4, \"Coil Pit(deg)\": 0.1, \"Occupation(%)\": 0},\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83ead17e",
+ "metadata": {},
+ "source": [
+ "## Convert dictionary to JSON file\n",
+ "\n",
+ "Convert the dictionary to a JSON file. You must supply the path of the\n",
+ "JSON file as an argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6aa91692",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "json_path = os.path.join(hfss.working_directory, \"choke_example.json\")\n",
+ "with open(json_path, \"w\") as outfile:\n",
+ " json.dump(values, outfile)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "301c557a",
+ "metadata": {},
+ "source": [
+ "## Verify parameters of JSON file\n",
+ "\n",
+ "Verify parameters of the JSON file. The ``check_choke_values()`` method takes\n",
+ "the JSON file path as an argument and does the following:\n",
+ "\n",
+ "- Checks if the JSON file is correctly written (as explained earlier).\n",
+ "- Checks equations on windings parameters to avoid having unintended intersections."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9b369a1c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dictionary_values = hfss.modeler.check_choke_values(\n",
+ " json_path, create_another_file=False\n",
+ ")\n",
+ "print(dictionary_values)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fa29d250",
+ "metadata": {},
+ "source": [
+ "## Create choke\n",
+ "\n",
+ "Create the choke. The ``Hfss.modeler.create_choke()`` method takes the JSON file path as an\n",
+ "argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "036df8e8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "list_object = hfss.modeler.create_choke(json_path)\n",
+ "print(list_object)\n",
+ "core = list_object[1]\n",
+ "first_winding_list = list_object[2]\n",
+ "second_winding_list = list_object[3]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b02f3c7",
+ "metadata": {},
+ "source": [
+ "## Create ground"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4c8f93df",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ground_radius = 1.2 * dictionary_values[1][\"Outer Winding\"][\"Outer Radius\"]\n",
+ "ground_position = [0, 0, first_winding_list[1][0][2] - 2]\n",
+ "ground = hfss.modeler.create_circle(\n",
+ " \"XY\", ground_position, ground_radius, name=\"GND\", material=\"copper\"\n",
+ ")\n",
+ "coat = hfss.assign_coating(ground, is_infinite_ground=True)\n",
+ "ground.transparency = 0.9"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb9b4c1f",
+ "metadata": {},
+ "source": [
+ "## Create lumped ports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ea0259b8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "port_position_list = [\n",
+ " [\n",
+ " first_winding_list[1][0][0],\n",
+ " first_winding_list[1][0][1],\n",
+ " first_winding_list[1][0][2] - 1,\n",
+ " ],\n",
+ " [\n",
+ " first_winding_list[1][-1][0],\n",
+ " first_winding_list[1][-1][1],\n",
+ " first_winding_list[1][-1][2] - 1,\n",
+ " ],\n",
+ " [\n",
+ " second_winding_list[1][0][0],\n",
+ " second_winding_list[1][0][1],\n",
+ " second_winding_list[1][0][2] - 1,\n",
+ " ],\n",
+ " [\n",
+ " second_winding_list[1][-1][0],\n",
+ " second_winding_list[1][-1][1],\n",
+ " second_winding_list[1][-1][2] - 1,\n",
+ " ],\n",
+ "]\n",
+ "port_dimension_list = [2, dictionary_values[1][\"Outer Winding\"][\"Wire Diameter\"]]\n",
+ "for position in port_position_list:\n",
+ " sheet = hfss.modeler.create_rectangle(\n",
+ " \"XZ\", position, port_dimension_list, name=\"sheet_port\"\n",
+ " )\n",
+ " sheet.move([-dictionary_values[1][\"Outer Winding\"][\"Wire Diameter\"] / 2, 0, -1])\n",
+ " hfss.lumped_port(\n",
+ " assignment=sheet.name,\n",
+ " name=\"port_\" + str(port_position_list.index(position) + 1),\n",
+ " reference=[ground],\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cd41db2",
+ "metadata": {},
+ "source": [
+ "## Create mesh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2eebfccc",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "cylinder_height = 2.5 * dictionary_values[1][\"Outer Winding\"][\"Height\"]\n",
+ "cylinder_position = [0, 0, first_winding_list[1][0][2] - 4]\n",
+ "mesh_operation_cylinder = hfss.modeler.create_cylinder(\n",
+ " \"XY\",\n",
+ " cylinder_position,\n",
+ " ground_radius,\n",
+ " cylinder_height,\n",
+ " num_sides=36,\n",
+ " name=\"mesh_cylinder\",\n",
+ ")\n",
+ "\n",
+ "hfss.mesh.assign_length_mesh(\n",
+ " [mesh_operation_cylinder],\n",
+ " maximum_length=15,\n",
+ " maximum_elements=None,\n",
+ " name=\"choke_mesh\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1f5f4a56",
+ "metadata": {},
+ "source": [
+ "## Create boundaries\n",
+ "\n",
+ "Create the boundaries. A region with openings is needed to run the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c7168f64",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "region = hfss.modeler.create_region(pad_percent=1000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "700ff2eb",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup with a sweep to run the simulation. Depending on your machine's\n",
+ "computing power, the simulation can take some time to run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a8a498a8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(\"MySetup\")\n",
+ "setup.props[\"Frequency\"] = \"50MHz\"\n",
+ "setup[\"MaximumPasses\"] = 10\n",
+ "hfss.create_linear_count_sweep(\n",
+ " setup=setup.name,\n",
+ " units=\"MHz\",\n",
+ " start_frequency=0.1,\n",
+ " stop_frequency=100,\n",
+ " num_of_freq_points=100,\n",
+ " name=\"sweep1\",\n",
+ " sweep_type=\"Interpolating\",\n",
+ " save_fields=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2612fbcc",
+ "metadata": {},
+ "source": [
+ "## Plot objects"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "babd155e",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "hfss.modeler.fit_all()\n",
+ "hfss.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(hfss.working_directory, \"Image.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1230d7d3",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9c1ad07d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "75f7ed5c",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a6ffa549",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/eigenmode.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/eigenmode.ipynb.txt
new file mode 100644
index 00000000..115262a3
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/eigenmode.ipynb.txt
@@ -0,0 +1,384 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "2c39f60f",
+ "metadata": {},
+ "source": [
+ "# Eigenmode filter\n",
+ "\n",
+ "This example shows how to use PyAEDT to automate the Eigenmode solver in HFSS.\n",
+ "Eigenmode analysis can be applied to open radiating structures\n",
+ "using an absorbing boundary condition. This type of analysis is useful for\n",
+ "determining the resonant frequency of a geometry or an antenna, and it can be used to refine\n",
+ "the mesh at the resonance, even when the resonant frequency of the antenna is not known.\n",
+ "\n",
+ "The challenge posed by this method is to identify and filter the non-physical modes\n",
+ "resulting from reflection from boundaries of the main domain.\n",
+ "Because the Eigenmode solver sorts by frequency and does not filter on the\n",
+ "quality factor, these virtual modes are present when the Eigenmode approach is\n",
+ "applied to nominally open structures.\n",
+ "\n",
+ "When looking for resonant modes over a wide frequency range for nominally\n",
+ "enclosed structures, several iterations may be required because the minimum frequency\n",
+ "is determined manually. Simulations re-run until the complete frequency range is covered\n",
+ "and all important physical modes are calculated.\n",
+ "\n",
+ "The following script finds the physical modes of a model in a wide frequency\n",
+ "range by automating the solution setup.\n",
+ "During each simulation, a user-defined number of modes is simulated, and the modes\n",
+ "with a Q higher than a user-defined value are filtered.\n",
+ "The next simulation automatically continues to find modes having a frequency higher\n",
+ "than the last mode of the previous analysis.\n",
+ "This continues until the maximum frequency in the desired range is achieved.\n",
+ "\n",
+ "Keywords: **HFSS**, **Eigenmode**, **resonance**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0940c1ee",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2507e663",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af391995",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7bd5efc6",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ce9b9872",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb4ef8ea",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e671fee8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e699b97e",
+ "metadata": {},
+ "source": [
+ "## Download 3D component\n",
+ "Download the 3D component that is needed to run the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c435fef4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_path = ansys.aedt.core.downloads.download_file(\n",
+ " \"eigenmode\", \"emi_PCB_house.aedt\", temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8033fa65",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9790767b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d = ansys.aedt.core.launch_desktop(\n",
+ " AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9777d937",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS\n",
+ "\n",
+ "Create an HFSS design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "55cb0626",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " version=AEDT_VERSION, project=project_path, non_graphical=NG_MODE\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b82a8bd6",
+ "metadata": {},
+ "source": [
+ "## Input parameters for Eigenmode solver\n",
+ "\n",
+ "The geometry and material should be already set. The analyses are generated by the code.\n",
+ "The ``num_modes`` parameter is the number of modes during each analysis. The maximum\n",
+ "allowed number is 20. Entering a number higher than 10 might result in a long simulation\n",
+ "time as the Eigenmode solver must converge on modes. The ``fmin`` parameter is the lowest\n",
+ "frequency of interest. The ``fmax`` parameter is the highest frequency of interest.\n",
+ "The ``limit`` parameter determines which modes are ignored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c646ba8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "num_modes = 6\n",
+ "fmin = 1\n",
+ "fmax = 2\n",
+ "next_fmin = fmin\n",
+ "setup_nr = 1\n",
+ "limit = 10\n",
+ "resonance = {}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "236fcff2",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Find modes\n",
+ "\n",
+ "The following cell defines a function that can be used to create and solve an Eigenmode setup.\n",
+ "After solving the model, information about each mode is saved for subsequent processing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5f1112f9",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "def find_resonance():\n",
+ " # Setup creation\n",
+ " next_min_freq = f\"{next_fmin} GHz\"\n",
+ " setup_name = f\"em_setup{setup_nr}\"\n",
+ " setup = hfss.create_setup(setup_name)\n",
+ " setup.props[\"MinimumFrequency\"] = next_min_freq\n",
+ " setup.props[\"NumModes\"] = num_modes\n",
+ " setup.props[\"ConvergeOnRealFreq\"] = True\n",
+ " setup.props[\"MaximumPasses\"] = 10\n",
+ " setup.props[\"MinimumPasses\"] = 3\n",
+ " setup.props[\"MaxDeltaFreq\"] = 5\n",
+ "\n",
+ " # Analyze the Eigenmode setup\n",
+ " hfss.analyze_setup(setup_name, cores=NUM_CORES, use_auto_settings=True)\n",
+ "\n",
+ " # Get the Q and real frequency of each mode\n",
+ " eigen_q_quantities = hfss.post.available_report_quantities(\n",
+ " quantities_category=\"Eigen Q\"\n",
+ " )\n",
+ " eigen_mode_quantities = hfss.post.available_report_quantities()\n",
+ " data = {}\n",
+ " for i, expression in enumerate(eigen_mode_quantities):\n",
+ " eigen_q_value = hfss.post.get_solution_data(\n",
+ " expressions=eigen_q_quantities[i],\n",
+ " setup_sweep_name=f\"{setup_name} : LastAdaptive\",\n",
+ " report_category=\"Eigenmode\",\n",
+ " )\n",
+ " eigen_mode_value = hfss.post.get_solution_data(\n",
+ " expressions=expression,\n",
+ " setup_sweep_name=f\"{setup_name} : LastAdaptive\",\n",
+ " report_category=\"Eigenmode\",\n",
+ " )\n",
+ " data[i] = [eigen_q_value.data_real()[0], eigen_mode_value.data_real()[0]]\n",
+ "\n",
+ " print(data)\n",
+ " return data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3c09d109",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Automate Eigenmode solution\n",
+ "\n",
+ "Running the next cell calls the resonance function and saves\n",
+ "only those modes with a Q higher than the defined\n",
+ "limit. The ``find_resonance()`` function is called until the complete\n",
+ "frequency range is covered.\n",
+ "When the automation ends, the physical modes in the whole frequency\n",
+ "range are reported."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a1a1901f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "while next_fmin < fmax:\n",
+ " output = find_resonance()\n",
+ " next_fmin = output[len(output) - 1][1] / 1e9\n",
+ " setup_nr += 1\n",
+ " cont_res = len(resonance)\n",
+ " for q in output:\n",
+ " if output[q][0] > limit:\n",
+ " resonance[cont_res] = output[q]\n",
+ " cont_res += 1\n",
+ "\n",
+ "resonance_frequencies = [f\"{resonance[i][1] / 1e9:.5} GHz\" for i in resonance]\n",
+ "print(str(resonance_frequencies))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03716c45",
+ "metadata": {},
+ "source": [
+ "Plot the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76f50fba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.fit_all()\n",
+ "hfss.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(hfss.working_directory, \"Image.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4d46d983",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be3afcf1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "456f4587",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "247f3d68",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/flex_cable.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/flex_cable.ipynb.txt
new file mode 100644
index 00000000..e670b4f4
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/flex_cable.ipynb.txt
@@ -0,0 +1,520 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "075311ae",
+ "metadata": {},
+ "source": [
+ "# Flex cable CPWG\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a flex cable CPWG\n",
+ "(coplanar waveguide with ground).\n",
+ "\n",
+ "Keywords: **HFSS**, **flex cable**, **CPWG**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5359f0bf",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41fa41ab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "from math import cos, radians, sin, sqrt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c5ccd72",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.generic.general_methods import generate_unique_name"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "946de46a",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "db7908ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b7b9c56",
+ "metadata": {},
+ "source": [
+ "## Set non-graphical mode\n",
+ "\n",
+ "Set non-graphical mode.\n",
+ "You can set ``non_graphical`` either to ``True`` or ``False``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bab39419",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "non_graphical = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "545ffe13",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8bfb585f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "85eb0351",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT\n",
+ "\n",
+ "Launch AEDT, create an HFSS design, and save the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5bf09148",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " version=AEDT_VERSION,\n",
+ " solution_type=\"DrivenTerminal\",\n",
+ " new_desktop=True,\n",
+ " non_graphical=non_graphical,\n",
+ ")\n",
+ "hfss.save_project(\n",
+ " os.path.join(temp_folder.name, generate_unique_name(\"example\") + \".aedt\")\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "68b509ec",
+ "metadata": {},
+ "source": [
+ "## Modify design settings\n",
+ "\n",
+ "Modify some design settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4f5bc909",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.change_material_override(True)\n",
+ "hfss.change_automatically_use_causal_materials(True)\n",
+ "hfss.create_open_region(\"100GHz\")\n",
+ "hfss.modeler.model_units = \"mil\"\n",
+ "hfss.mesh.assign_initial_mesh_from_slider(applycurvilinear=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7afd754f",
+ "metadata": {},
+ "source": [
+ "## Create variables\n",
+ "\n",
+ "Create input variables for creating the flex cable CPWG."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5eb9b17a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "total_length = 300\n",
+ "theta = 120\n",
+ "r = 100\n",
+ "width = 3\n",
+ "height = 0.1\n",
+ "spacing = 1.53\n",
+ "gnd_width = 10\n",
+ "gnd_thickness = 2\n",
+ "\n",
+ "xt = (total_length - r * radians(theta)) / 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e10b129",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Create bend\n",
+ "\n",
+ "The ``create_bending()`` method creates a list of points for\n",
+ "the bend based on the curvature radius and extension."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a79835db",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_bending(radius, extension=0):\n",
+ " points = [(-xt, 0, -radius), (0, 0, -radius)]\n",
+ "\n",
+ " for i in [radians(i) for i in range(theta)] + [radians(theta + 0.000000001)]:\n",
+ " points.append((radius * sin(i), 0, -radius * cos(i)))\n",
+ "\n",
+ " x1, y1, z1 = points[-1]\n",
+ " x0, y0, z0 = points[-2]\n",
+ "\n",
+ " scale = (xt + extension) / sqrt((x1 - x0) ** 2 + (z1 - z0) ** 2)\n",
+ " x, y, z = (x1 - x0) * scale + x0, 0, (z1 - z0) * scale + z0\n",
+ "\n",
+ " points[-1] = (x, y, z)\n",
+ " return points"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9306d01a",
+ "metadata": {},
+ "source": [
+ "## Draw signal line\n",
+ "\n",
+ "Draw a signal line to create a bent signal wire."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae3778a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "points = create_bending(r, 1)\n",
+ "line = hfss.modeler.create_polyline(\n",
+ " points=points,\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=height,\n",
+ " xsection_height=width,\n",
+ " material=\"copper\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98cc17a9",
+ "metadata": {},
+ "source": [
+ "## Draw ground line\n",
+ "\n",
+ "Draw a ground line to create two bent ground wires."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9fb15acc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "gnd_r = [(x, spacing + width / 2 + gnd_width / 2, z) for x, y, z in points]\n",
+ "gnd_l = [(x, -y, z) for x, y, z in gnd_r]\n",
+ "\n",
+ "gnd_objs = []\n",
+ "for gnd in [gnd_r, gnd_l]:\n",
+ " x = hfss.modeler.create_polyline(\n",
+ " points=gnd,\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=height,\n",
+ " xsection_height=gnd_width,\n",
+ " material=\"copper\",\n",
+ " )\n",
+ " x.color = (255, 0, 0)\n",
+ " gnd_objs.append(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7046d7fb",
+ "metadata": {},
+ "source": [
+ "## Draw dielectric\n",
+ "\n",
+ "Draw a dielectric to create a dielectric cable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fd30d1ba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "points = create_bending(r + (height + gnd_thickness) / 2)\n",
+ "\n",
+ "fr4 = hfss.modeler.create_polyline(\n",
+ " points=points,\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=gnd_thickness,\n",
+ " xsection_height=width + 2 * spacing + 2 * gnd_width,\n",
+ " material=\"FR4_epoxy\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bfacfb93",
+ "metadata": {},
+ "source": [
+ "## Create bottom metals\n",
+ "\n",
+ "Create the bottom metals."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "31bfe513",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "points = create_bending(r + height + gnd_thickness, 1)\n",
+ "\n",
+ "bot = hfss.modeler.create_polyline(\n",
+ " points=points,\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=height,\n",
+ " xsection_height=width + 2 * spacing + 2 * gnd_width,\n",
+ " material=\"copper\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cf76e81e",
+ "metadata": {},
+ "source": [
+ "## Create port interfaces\n",
+ "\n",
+ "Create port interfaces (PEC enclosures)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aef7e50a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "port_faces = []\n",
+ "for face, blockname in zip([fr4.top_face_z, fr4.bottom_face_x], [\"b1\", \"b2\"]):\n",
+ " xc, yc, zc = face.center\n",
+ " positions = [i.position for i in face.vertices]\n",
+ "\n",
+ " port_sheet_list = [\n",
+ " ((x - xc) * 10 + xc, (y - yc) + yc, (z - zc) * 10 + zc) for x, y, z in positions\n",
+ " ]\n",
+ " s = hfss.modeler.create_polyline(\n",
+ " port_sheet_list, close_surface=True, cover_surface=True\n",
+ " )\n",
+ " center = [round(i, 6) for i in s.faces[0].center]\n",
+ "\n",
+ " port_block = hfss.modeler.thicken_sheet(s.name, -5)\n",
+ " port_block.name = blockname\n",
+ " for f in port_block.faces:\n",
+ "\n",
+ " if [round(i, 6) for i in f.center] == center:\n",
+ " port_faces.append(f)\n",
+ "\n",
+ " port_block.material_name = \"PEC\"\n",
+ "\n",
+ " for i in [line, bot] + gnd_objs:\n",
+ " i.subtract([port_block], True)\n",
+ "\n",
+ " print(port_faces)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8140fa20",
+ "metadata": {},
+ "source": [
+ "## Create boundary condition\n",
+ "\n",
+ "Creates a Perfect E boundary condition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fdeea8cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "boundary = []\n",
+ "for face in [fr4.top_face_y, fr4.bottom_face_y]:\n",
+ " s = hfss.modeler.create_object_from_face(face)\n",
+ " boundary.append(s)\n",
+ " hfss.assign_perfecte_to_sheets(s)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b8889f1",
+ "metadata": {},
+ "source": [
+ "## Create ports\n",
+ "\n",
+ "Create ports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a0f85b28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for s, port_name in zip(port_faces, [\"1\", \"2\"]):\n",
+ " reference = [i.name for i in gnd_objs + boundary + [bot]] + [\"b1\", \"b2\"]\n",
+ "\n",
+ " hfss.wave_port(s.id, name=port_name, reference=reference)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b6a2f31",
+ "metadata": {},
+ "source": [
+ "## Create setup and sweep\n",
+ "\n",
+ "Create the setup and sweep."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fd03c100",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(\"setup1\")\n",
+ "setup[\"Frequency\"] = \"2GHz\"\n",
+ "setup.props[\"MaximumPasses\"] = 10\n",
+ "setup.props[\"MinimumConvergedPasses\"] = 2\n",
+ "hfss.create_linear_count_sweep(\n",
+ " setup=\"setup1\",\n",
+ " units=\"GHz\",\n",
+ " start_frequency=1e-1,\n",
+ " stop_frequency=4,\n",
+ " num_of_freq_points=101,\n",
+ " name=\"sweep1\",\n",
+ " save_fields=False,\n",
+ " sweep_type=\"Interpolating\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "58129389",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "24b1a041",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.release_desktop()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44554bdf",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files.\n",
+ "The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e509809c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/emc/index.rst.txt b/version/dev/_sources/examples/high_frequency/emc/index.rst.txt
new file mode 100644
index 00000000..1fa02e6b
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/index.rst.txt
@@ -0,0 +1,124 @@
+EMC
+~~~
+
+These examples use PyAEDT to show some EMC applications.
+
+.. grid:: 2
+
+ .. grid-item-card:: Choke
+ :padding: 2 2 2 2
+ :link: choke
+ :link-type: doc
+
+ .. image:: _static/choke.png
+ :alt: Choke
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a choke setup in HFSS.
+
+ .. grid-item-card:: Eigenmode filter
+ :padding: 2 2 2 2
+ :link: eigenmode
+ :link-type: doc
+
+ .. image:: _static/eigenmode.png
+ :alt: Eigenmode
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to automate the Eigenmode solver in HFSS.
+
+ .. grid-item-card:: Flex cable CPWG
+ :padding: 2 2 2 2
+ :link: flex_cable
+ :link-type: doc
+
+ .. image:: _static/flex_cable.png
+ :alt: Flex cable
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a flex cable CPWG (coplanar waveguide with ground).
+
+ .. grid-item-card:: Cable parameter identification
+ :padding: 2 2 2 2
+ :link: armoured_cable
+ :link-type: doc
+
+ .. image:: _static/armoured.png
+ :alt: Cable
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create see a 4 Core Armoured Power Cable.
+
+ .. grid-item-card:: Busbar analysis
+ :padding: 2 2 2 2
+ :link: busbar
+ :link-type: doc
+
+ .. image:: _static/busbar.png
+ :alt: Busbar
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a busbar design in Q3D Extractor and run a simulation.
+
+ .. grid-item-card:: Schematic subcircuit management
+ :padding: 2 2 2 2
+ :link: subcircuit
+ :link-type: doc
+
+ .. image:: _static/subcircuit.png
+ :alt: Cable
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to add a subcircuit to a circuit design.
+ It changes the focus within the hierarchy between the child subcircuit and the parent design.
+
+
+ .. grid-item-card:: Circuit schematic creation and analysis
+ :padding: 2 2 2 2
+ :link: ../../aedt_general/modeler/circuit_schematic
+ :link-type: doc
+
+ .. image:: ../../aedt_general/modeler/_static/circuit.png
+ :alt: Circuit
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: RF interference
+ :padding: 2 2 2 2
+ :link: ../antenna/interferences/index
+ :link-type: doc
+
+ .. image:: ../antenna/_static/emit_simple_cosite.png
+ :alt: EMIT logo
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some general capabilities of EMIT for RF interference.
+
+ .. toctree::
+ :hidden:
+
+ choke
+ eigenmode
+ flex_cable
+ armoured_cable
+ busbar
+ subcircuit
+ ../../aedt_general/modeler/circuit_schematic
+ ../antenna/interferences/index
diff --git a/version/dev/_sources/examples/high_frequency/emc/subcircuit.ipynb.txt b/version/dev/_sources/examples/high_frequency/emc/subcircuit.ipynb.txt
new file mode 100644
index 00000000..684044b8
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/emc/subcircuit.ipynb.txt
@@ -0,0 +1,229 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "31d2b9f9",
+ "metadata": {},
+ "source": [
+ "# Schematic subcircuit management\n",
+ "\n",
+ "This example shows how to add a subcircuit to a circuit design.\n",
+ "It changes the focus within the hierarchy between\n",
+ "the child subcircuit and the parent design.\n",
+ "\n",
+ "Keywords: **Circuit**, **EMC**, **schematic**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81cb2e62",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cb4da868",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b3d6779c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b32004c7",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2a661845",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed0cbcda",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1389ef8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "619b1cd3",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with Circuit\n",
+ "\n",
+ "Launch AEDT in graphical mode. Instantite an instance of the ``Circuit`` class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9022024f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit = ansys.aedt.core.Circuit(\n",
+ " project=os.path.join(temp_folder.name, \"SubcircuitExampl.aedt\"),\n",
+ " design=\"SimpleExample\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "circuit.modeler.schematic_units = \"mil\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "953fb965",
+ "metadata": {},
+ "source": [
+ "## Add subcircuit\n",
+ "\n",
+ "Add a new subcircuit to the previously created circuit design, creating a\n",
+ "child circuit. Push this child circuit down into the child subcircuit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "90c6c143",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "subcircuit = circuit.modeler.schematic.create_subcircuit(location=[0.0, 0.0])\n",
+ "subcircuit_name = subcircuit.composed_name\n",
+ "circuit.push_down(subcircuit)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9f47d67",
+ "metadata": {},
+ "source": [
+ "## Parametrize subcircuit\n",
+ "\n",
+ "Parametrize the subcircuit and add a resistor, inductor, and a capacitor with\n",
+ "parameter values. Components are connected in series,\n",
+ "and the focus is changed to the parent schematic using\n",
+ "the ``pop_up()`` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "618f2b3d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.variable_manager.set_variable(name=\"R_val\", expression=\"35ohm\")\n",
+ "circuit.variable_manager.set_variable(name=\"L_val\", expression=\"1e-7H\")\n",
+ "circuit.variable_manager.set_variable(name=\"C_val\", expression=\"5e-10F\")\n",
+ "p1 = circuit.modeler.schematic.create_interface_port(name=\"In\")\n",
+ "r1 = circuit.modeler.schematic.create_resistor(value=\"R_val\")\n",
+ "l1 = circuit.modeler.schematic.create_inductor(value=\"L_val\")\n",
+ "c1 = circuit.modeler.schematic.create_capacitor(value=\"C_val\")\n",
+ "p2 = circuit.modeler.schematic.create_interface_port(name=\"Out\")\n",
+ "circuit.modeler.schematic.connect_components_in_series(\n",
+ " assignment=[p1, r1, l1, c1, p2], use_wire=True\n",
+ ")\n",
+ "circuit.pop_up()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4f15e159",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b278eae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()\n",
+ "circuit.release_desktop()\n",
+ "# Wait 5 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27950e01",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4171e405",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/index.rst.txt b/version/dev/_sources/examples/high_frequency/index.rst.txt
new file mode 100644
index 00000000..53690eff
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/index.rst.txt
@@ -0,0 +1,95 @@
+High frequency
+==============
+
+These end-to-end examples show how to use PyAEDT for high-frequency applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: Antenna
+ :padding: 2 2 2 2
+ :link: antenna/index
+ :link-type: doc
+
+ .. image:: antenna/_static/array.png
+ :alt: Antenna
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Antenna examples
+
+ .. grid-item-card:: IC-Package-PCB
+ :padding: 2 2 2 2
+ :link: layout/index
+ :link-type: doc
+
+ .. image:: ./_static/layout.png
+ :alt: PCB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Layout automation examples
+
+ .. grid-item-card:: Radio frequency and millimeter wave
+ :padding: 2 2 2 2
+ :link: radiofrequency_mmwave/index
+ :link-type: doc
+
+ .. image:: ./_static/wgf.png
+ :alt: Filter
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Radio frequency and millimeter wave examples
+
+ .. grid-item-card:: EMC
+ :padding: 2 2 2 2
+ :link: emc/index
+ :link-type: doc
+
+ .. image:: ./_static/emc.png
+ :alt: Busbar
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ EMC examples
+
+ .. grid-item-card:: Multiphysics
+ :padding: 2 2 2 2
+ :link: multiphysics/index
+ :link-type: doc
+
+ .. image:: ./_static/pcb_stress.png
+ :alt: Stress PCB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Multiphysics examples
+
+ .. grid-item-card:: Report
+ :padding: 2 2 2 2
+ :link: ../aedt_general/report/index
+ :link-type: doc
+
+ .. image:: ../aedt_general/_static/touchstone.png
+ :alt: Components
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some report capabilities.
+
+ .. toctree::
+ :hidden:
+
+ antenna/index
+ radiofrequency_mmwave/index
+ layout/index
+ emc/index
+ multiphysics/index
+ ../aedt_general/report/index
diff --git a/version/dev/_sources/examples/high_frequency/layout/gui_manipulation.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/gui_manipulation.ipynb.txt
new file mode 100644
index 00000000..2bafcf7b
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/gui_manipulation.ipynb.txt
@@ -0,0 +1,314 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "df94ca13",
+ "metadata": {},
+ "source": [
+ "# HFSS Layout UI modification\n",
+ "\n",
+ "This example shows how to modify the HFSS 3D Layout UI.\n",
+ "![](\"_static/user_interface.png\")
\n",
+ "\n",
+ "Keywords: **HFSS 3D Layout**, **UI**, **user interface**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e7f8f19",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2ceb5e7d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "import sys\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "from ansys.aedt.core import Hfss3dLayout\n",
+ "from ansys.aedt.core.downloads import download_file\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a3a3ab6d",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1dd25bc0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = True # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a49a2183",
+ "metadata": {},
+ "source": [
+ "Check if AEDT is launched in graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92d7261a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if not NG_MODE:\n",
+ " print(\"Warning: This example requires graphical mode enabled.\")\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c94f569",
+ "metadata": {},
+ "source": [
+ "Download example board."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "83257185",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "aedb = download_file(source=\"edb/ANSYS-HSD_V1.aedb\", destination=temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "55d6a248",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS 3D Layout\n",
+ "\n",
+ "Initialize AEDT and launch HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "173e41b9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d = Hfss3dLayout(aedb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True)\n",
+ "h3d.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2172f525",
+ "metadata": {},
+ "source": [
+ "## Net visibility\n",
+ "Hide all nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "662151bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.modeler.change_net_visibility(visible=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2ce27eb2",
+ "metadata": {},
+ "source": [
+ "Show two specified nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7736cfa2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.modeler.change_net_visibility([\"5V\", \"1V0\"], visible=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7326ba0",
+ "metadata": {},
+ "source": [
+ "Show all layers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "389b2e66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for layer in h3d.modeler.layers.all_signal_layers:\n",
+ " layer.is_visible = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "642477d8",
+ "metadata": {},
+ "source": [
+ "Change the layer color."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41cdf867",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "layer = h3d.modeler.layers.layers[h3d.modeler.layers.layer_id(\"1_Top\")]\n",
+ "layer.set_layer_color(0, 255, 0)\n",
+ "h3d.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "916b18a7",
+ "metadata": {},
+ "source": [
+ "## Disable component visibility"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf8ea770",
+ "metadata": {},
+ "source": [
+ "Disable component visibility for the ``\"1_Top\"`` and ``\"16_Bottom\"`` layers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cba853d3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "top = h3d.modeler.layers.layers[h3d.modeler.layers.layer_id(\"1_Top\")]\n",
+ "top.is_visible_component = False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ef9e29e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bot = h3d.modeler.layers.layers[h3d.modeler.layers.layer_id(\"16_Bottom\")]\n",
+ "bot.is_visible_component = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce342523",
+ "metadata": {},
+ "source": [
+ "## Display the layout\n",
+ "\n",
+ "Fit all so that you can visualize all."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d25f4e76",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7ddb973c",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be03b61d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.save_project()\n",
+ "h3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44e1aceb",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "130ecdfe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/index.rst.txt b/version/dev/_sources/examples/high_frequency/layout/index.rst.txt
new file mode 100644
index 00000000..73a67978
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/index.rst.txt
@@ -0,0 +1,80 @@
+IC-Package-PCB
+==============
+
+These examples use PyAEDT to show some layout applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: Layout preprocessing
+ :padding: 2 2 2 2
+ :link: https://edb.docs.pyansys.com/version/stable/examples/legacy_standalone/index.html
+ :link-type: url
+
+ .. image:: _static/pyedb.png
+ :alt: PyEDB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Links to examples in the AEDT documentation that show how to use the legacy PyEDB API as a standalone package.
+
+ .. grid-item-card:: PyEDB configuration files
+ :padding: 2 2 2 2
+ :link: https://edb.docs.pyansys.com/version/stable/examples/use_configuration/index.html
+ :link-type: url
+
+ .. image:: _static/pyedb2.png
+ :alt: PyEDB2
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Links to examples in the PyAEDT documentation that show how to use PyEDB configuration files.
+
+ .. grid-item-card:: Power integrity
+ :padding: 2 2 2 2
+ :link: power_integrity/index
+ :link-type: doc
+
+ .. image:: _static/power_integrity.png
+ :alt: Power
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Provides power integrity examples.
+
+ .. grid-item-card:: Signal integrity
+ :padding: 2 2 2 2
+ :link: signal_integrity/index
+ :link-type: doc
+
+ .. image:: _static/signal_integrity.png
+ :alt: Signal
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Provides signal integrity examples
+
+ .. grid-item-card:: HFSS 3D Layout GUI modificatation
+ :padding: 2 2 2 2
+ :link: gui_manipulation
+ :link-type: doc
+
+ .. image:: _static/user_interface.png
+ :alt: UI 3D Layout
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Provides HFSS 3D Layout GUI modification examples.
+
+
+ .. toctree::
+ :hidden:
+
+ power_integrity/index
+ signal_integrity/index
+ gui_manipulation
\ No newline at end of file
diff --git a/version/dev/_sources/examples/high_frequency/layout/power_integrity/ac_q3d.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/power_integrity/ac_q3d.ipynb.txt
new file mode 100644
index 00000000..7f7e6f93
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/power_integrity/ac_q3d.ipynb.txt
@@ -0,0 +1,438 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "4a00bc14",
+ "metadata": {},
+ "source": [
+ "# PCB AC analysis"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6a09a473",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to create a design in\n",
+ "Q3D Extractor and run a simulation starting from an EDB project.\n",
+ "\n",
+ "Keywords: **Q3D**, **PCB**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1eee620",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dc15730f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e2117aac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import pyedb"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbb9b531",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2bd5afa1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e04779e7",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ef10924f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b42f78d",
+ "metadata": {},
+ "source": [
+ "## Set up project files and path\n",
+ "\n",
+ "Download needed project file and set up temporary project directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ca80388a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_dir = os.path.join(temp_folder.name, \"edb\")\n",
+ "aedb_project = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"edb/ANSYS-HSD_V1.aedb\", destination=project_dir\n",
+ ")\n",
+ "\n",
+ "project_name = os.path.join(temp_folder.name, \"HSD\")\n",
+ "output_edb = os.path.join(project_dir, project_name + \".aedb\")\n",
+ "output_q3d = os.path.join(project_dir, project_name + \"_q3d.aedt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "79f2abf6",
+ "metadata": {},
+ "source": [
+ "## Open EDB and create cutout\n",
+ "\n",
+ "Open the EDB project and create a cutout on the selected nets\n",
+ "before exporting to Q3D."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bf73b42f",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "edb = pyedb.Edb(aedb_project, edbversion=AEDT_VERSION)\n",
+ "cutout_points = edb.cutout(\n",
+ " [\"CLOCK_I2C_SCL\", \"CLOCK_I2C_SDA\"],\n",
+ " [\"GND\"],\n",
+ " output_aedb_path=output_edb,\n",
+ " use_pyaedt_extent_computing=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d49659b6",
+ "metadata": {},
+ "source": [
+ "## Identify locations of pins\n",
+ "\n",
+ "Identify $(x,y)$ pin locations on the components to define where to assign sources\n",
+ "and sinks for Q3D."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c8694886",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pin_u13_scl = [\n",
+ " i for i in edb.components[\"U13\"].pins.values() if i.net_name == \"CLOCK_I2C_SCL\"\n",
+ "]\n",
+ "pin_u1_scl = [\n",
+ " i for i in edb.components[\"U1\"].pins.values() if i.net_name == \"CLOCK_I2C_SCL\"\n",
+ "]\n",
+ "pin_u13_sda = [\n",
+ " i for i in edb.components[\"U13\"].pins.values() if i.net_name == \"CLOCK_I2C_SDA\"\n",
+ "]\n",
+ "pin_u1_sda = [\n",
+ " i for i in edb.components[\"U1\"].pins.values() if i.net_name == \"CLOCK_I2C_SDA\"\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dc350f8a",
+ "metadata": {},
+ "source": [
+ "## Append Z elevation positions\n",
+ "\n",
+ "> **Note:** The factor 1000 converts from meters to millimeters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cf3e99b5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "location_u13_scl = [i * 1000 for i in pin_u13_scl[0].position]\n",
+ "location_u13_scl.append(edb.components[\"U13\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u1_scl = [i * 1000 for i in pin_u1_scl[0].position]\n",
+ "location_u1_scl.append(edb.components[\"U1\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u13_sda = [i * 1000 for i in pin_u13_sda[0].position]\n",
+ "location_u13_sda.append(edb.components[\"U13\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u1_sda = [i * 1000 for i in pin_u1_sda[0].position]\n",
+ "location_u1_sda.append(edb.components[\"U1\"].upper_elevation * 1000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf7bc41f",
+ "metadata": {},
+ "source": [
+ "## Save and close EDB\n",
+ "\n",
+ "Save and close EDB. Then, open the EDB project in HFSS 3D Layout to generate the 3D model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be8a38ea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.save_edb()\n",
+ "edb.close_edb()\n",
+ "\n",
+ "h3d = ansys.aedt.core.Hfss3dLayout(\n",
+ " output_edb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9a9050d",
+ "metadata": {},
+ "source": [
+ "## Set up the Q3D Project\n",
+ "\n",
+ "Use HFSS 3D Layout to export the model to Q3D Extractor. The named parameter\n",
+ "``keep_net_name=True`` ensures that net names are retained when the model is exported from HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5001292c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = h3d.create_setup()\n",
+ "setup.export_to_q3d(output_q3d, keep_net_name=True)\n",
+ "h3d.close_project()\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4ebb0d2e",
+ "metadata": {},
+ "source": [
+ "Open the newly created Q3D project and display the layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0af6acc4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d = ansys.aedt.core.Q3d(output_q3d, version=AEDT_VERSION)\n",
+ "q3d.plot(\n",
+ " show=False,\n",
+ " assignment=[\"CLOCK_I2C_SCL\", \"CLOCK_I2C_SDA\"],\n",
+ " output_file=os.path.join(temp_folder.name, \"Q3D.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd1f77f7",
+ "metadata": {},
+ "source": [
+ "Use the previously calculated positions to identify faces and\n",
+ "assign sources and sinks on nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "509b09bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "f1 = q3d.modeler.get_faceid_from_position(location_u13_scl, assignment=\"CLOCK_I2C_SCL\")\n",
+ "q3d.source(f1, net_name=\"CLOCK_I2C_SCL\")\n",
+ "f1 = q3d.modeler.get_faceid_from_position(location_u13_sda, assignment=\"CLOCK_I2C_SDA\")\n",
+ "q3d.source(f1, net_name=\"CLOCK_I2C_SDA\")\n",
+ "f1 = q3d.modeler.get_faceid_from_position(location_u1_scl, assignment=\"CLOCK_I2C_SCL\")\n",
+ "q3d.sink(f1, net_name=\"CLOCK_I2C_SCL\")\n",
+ "f1 = q3d.modeler.get_faceid_from_position(location_u1_sda, assignment=\"CLOCK_I2C_SDA\")\n",
+ "q3d.sink(f1, net_name=\"CLOCK_I2C_SDA\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c663c551",
+ "metadata": {},
+ "source": [
+ "Define the solution setup and the frequency sweep ranging from DC to 2GHz."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ffb985d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = q3d.create_setup()\n",
+ "setup.dc_enabled = True\n",
+ "setup.capacitance_enabled = False\n",
+ "sweep = setup.add_sweep()\n",
+ "sweep.add_subrange(\n",
+ " \"LinearStep\", 0, end=2, count=0.05, unit=\"GHz\", save_single_fields=False, clear=True\n",
+ ")\n",
+ "setup.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dced36e2",
+ "metadata": {},
+ "source": [
+ "## Solve\n",
+ "\n",
+ "Compute AC inductance and resistance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c7b20aff",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "traces_acl = q3d.post.available_report_quantities(quantities_category=\"ACL Matrix\")\n",
+ "solution = q3d.post.get_solution_data(traces_acl)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cf4fe578",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Plot AC inductance and resistance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50c16c82",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solution.plot()\n",
+ "traces_acr = q3d.post.available_report_quantities(quantities_category=\"ACR Matrix\")\n",
+ "solution2 = q3d.post.get_solution_data(traces_acr)\n",
+ "solution2.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "902eef60",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "72cb203f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.save_project()\n",
+ "q3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6d3b3fa6",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76f720f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir.ipynb.txt
new file mode 100644
index 00000000..8da112b1
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir.ipynb.txt
@@ -0,0 +1,555 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "99e4644c",
+ "metadata": {},
+ "source": [
+ "# DC IR analysis\n",
+ "This example shows how to configure EDB for DC IR analysis and load EDB into the HFSS 3D Layout UI for analysis and\n",
+ "postprocessing.\n",
+ "\n",
+ "- Set up EDB:\n",
+ "\n",
+ " - Edit via padstack.\n",
+ " - Assign SPICE model to components.\n",
+ " - Create pin groups.\n",
+ " - Create voltage and current sources.\n",
+ " - Create SIwave DC analysis.\n",
+ " - Create cutout.\n",
+ "\n",
+ "- Import EDB into HFSS 3D Layout:\n",
+ "\n",
+ " - Analyze.\n",
+ " - Get DC IR analysis results.\n",
+ "\n",
+ "Keywords: **HFSS 3D Layout**, **DC IR**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdd17ead",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7d9c82f6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "481c991c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.downloads import download_file\n",
+ "from pyedb import Edb"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9632fbe",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "13804b87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "960939fb",
+ "metadata": {},
+ "source": [
+ "Download example board."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6fe063b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "aedb = download_file(source=\"edb/ANSYS-HSD_V1.aedb\", destination=temp_folder.name)\n",
+ "download_file(\n",
+ " source=\"spice\", name=\"ferrite_bead_BLM15BX750SZ1.mod\", destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6fee2373",
+ "metadata": {},
+ "source": [
+ "## Create configuration file\n",
+ "This example uses a configuration file to set up the layout for analysis.\n",
+ "Initialize and create an empty dictionary to host all configurations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "443e3f1d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg = dict()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "14342b17",
+ "metadata": {},
+ "source": [
+ "Define model library paths."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a653b8cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"general\"] = {\n",
+ " \"s_parameter_library\": os.path.join(temp_folder.name, \"touchstone\"),\n",
+ " \"spice_model_library\": os.path.join(temp_folder.name, \"spice\"),\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6c59e15f",
+ "metadata": {},
+ "source": [
+ "### Change via hole size and plating thickness"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b9634204",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"padstacks\"] = {\n",
+ " \"definitions\": [\n",
+ " {\"name\": \"v40h15-3\", \"hole_diameter\": \"0.2mm\", \"hole_plating_thickness\": \"25um\"}\n",
+ " ],\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0703ff77",
+ "metadata": {},
+ "source": [
+ "### Assign SPICE models"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "32c73173",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"spice_models\"] = [\n",
+ " {\n",
+ " \"name\": \"ferrite_bead_BLM15BX750SZ1\", # Give a name to the SPICE Mode.\n",
+ " \"component_definition\": \"COIL-1008CS_V\", # Part name of the components\n",
+ " \"file_path\": \"ferrite_bead_BLM15BX750SZ1.mod\", # File name or full file path to the SPICE file.\n",
+ " \"sub_circuit_name\": \"BLM15BX750SZ1\",\n",
+ " \"apply_to_all\": True, # If True, SPICE model is to be assigned to all components share the same part name.\n",
+ " # If False, only assign SPICE model to components in \"components\".\n",
+ " \"components\": [],\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4b636e46",
+ "metadata": {},
+ "source": [
+ "### Create voltage source\n",
+ "Create a voltage source from a net."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0b51bf23",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"sources\"] = [\n",
+ " {\n",
+ " \"name\": \"VSOURCE_5V\",\n",
+ " \"reference_designator\": \"U4\",\n",
+ " \"type\": \"voltage\",\n",
+ " \"magnitude\": 5,\n",
+ " \"positive_terminal\": {\"net\": \"5V\"},\n",
+ " \"negative_terminal\": {\"net\": \"GND\"},\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1eac2af9",
+ "metadata": {},
+ "source": [
+ "### Create current sources\n",
+ "Create current sources between the net and pin group."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9e8f4bda",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"pin_groups\"] = [{\"name\": \"J5_GND\", \"reference_designator\": \"J5\", \"net\": \"GND\"}]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "016d66b9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"sources\"].append(\n",
+ " {\n",
+ " \"name\": \"J5_VCCR\",\n",
+ " \"reference_designator\": \"J5\",\n",
+ " \"type\": \"current\",\n",
+ " \"magnitude\": 0.5,\n",
+ " \"positive_terminal\": {\"net\": \"SFPA_VCCR\"},\n",
+ " \"negative_terminal\": {\n",
+ " \"pin_group\": \"J5_GND\" # Defined in \"pin_groups\" section.\n",
+ " },\n",
+ " }\n",
+ ")\n",
+ "cfg[\"sources\"].append(\n",
+ " {\n",
+ " \"name\": \"J5_VCCT\",\n",
+ " \"reference_designator\": \"J5\",\n",
+ " \"type\": \"current\",\n",
+ " \"magnitude\": 0.5,\n",
+ " \"positive_terminal\": {\"net\": \"SFPA_VCCT\"},\n",
+ " \"negative_terminal\": {\n",
+ " \"pin_group\": \"J5_GND\" # Defined in \"pin_groups\" section.\n",
+ " },\n",
+ " }\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a4d29e4",
+ "metadata": {},
+ "source": [
+ "### Create SIwave DC analysis"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "024e7849",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"setups\"] = [{\"name\": \"siwave_dc\", \"type\": \"siwave_dc\", \"dc_slider_position\": 0}]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0e6c7b44",
+ "metadata": {},
+ "source": [
+ "### Define cutout"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "14278054",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"operations\"] = {\n",
+ " \"cutout\": {\n",
+ " \"signal_list\": [\"SFPA_VCCR\", \"SFPA_VCCT\", \"5V\"],\n",
+ " \"reference_list\": [\"GND\"],\n",
+ " \"extent_type\": \"ConvexHull\",\n",
+ " \"expansion_size\": 0.002,\n",
+ " \"use_round_corner\": False,\n",
+ " \"output_aedb_path\": \"\",\n",
+ " \"open_cutout_at_end\": True,\n",
+ " \"use_pyaedt_cutout\": True,\n",
+ " \"number_of_threads\": 4,\n",
+ " \"use_pyaedt_extent_computing\": True,\n",
+ " \"extent_defeature\": 0,\n",
+ " \"remove_single_pin_components\": False,\n",
+ " \"custom_extent\": \"\",\n",
+ " \"custom_extent_units\": \"mm\",\n",
+ " \"include_partial_instances\": False,\n",
+ " \"keep_voids\": True,\n",
+ " \"check_terminals\": False,\n",
+ " \"include_pingroups\": False,\n",
+ " \"expansion_factor\": 0,\n",
+ " \"maximum_iterations\": 10,\n",
+ " \"preserve_components_with_model\": False,\n",
+ " \"simple_pad_check\": True,\n",
+ " \"keep_lines_as_path\": False,\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2258380",
+ "metadata": {},
+ "source": [
+ "### Save configuration as a JSON file"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4c3c8716",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pi_json = os.path.join(temp_folder.name, \"pi.json\")\n",
+ "with open(pi_json, \"w\") as f:\n",
+ " json.dump(cfg, f, indent=4, ensure_ascii=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4890c96c",
+ "metadata": {},
+ "source": [
+ "## Load configuration into EDB"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca5aeaf4",
+ "metadata": {},
+ "source": [
+ "Load the configuration from the JSON file into EDB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bf78e4fc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp = Edb(aedb, edbversion=AEDT_VERSION)\n",
+ "edbapp.configuration.load(config_file=pi_json)\n",
+ "edbapp.configuration.run()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ee74afc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# # Load configuration into EDB\n",
+ "edbapp.nets.plot(None, None, color_by_net=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca7acc2f",
+ "metadata": {},
+ "source": [
+ "## Save and close EDB"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8c923b24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.save()\n",
+ "edbapp.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1641e4cd",
+ "metadata": {},
+ "source": [
+ "The configured EDB file is saved in the temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0f7abf8e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "079d897f",
+ "metadata": {},
+ "source": [
+ "## Analyze DCIR with SIwave\n",
+ "\n",
+ "The HFSS 3D Layout interface to SIwave is used to open the EDB and run the DCIR analysis\n",
+ "using SIwave"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "60d18dcf",
+ "metadata": {},
+ "source": [
+ "### Load EDB into HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "22fb0318",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siw = ansys.aedt.core.Hfss3dLayout(\n",
+ " aedb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "760f4f09",
+ "metadata": {},
+ "source": [
+ "### Analyze"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "21103df3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siw.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "14f8ed8c",
+ "metadata": {},
+ "source": [
+ "### Get DC IR results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "508d542c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siw.get_dcir_element_data_current_source(\"siwave_dc\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9155870",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e1c3ff2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "siw.save_project()\n",
+ "siw.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bcd45e93",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9a869f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir_q3d.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir_q3d.ipynb.txt
new file mode 100644
index 00000000..43676872
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/power_integrity/dcir_q3d.ipynb.txt
@@ -0,0 +1,627 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0d5130ff",
+ "metadata": {},
+ "source": [
+ "# PCB DCIR analysis\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a design in\n",
+ "Q3D Extractor and run a DC IR drop simulation starting from an EDB project.\n",
+ "\n",
+ "Keywords: **Q3D**, **layout**, **DCIR**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2f94c906",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4429fcdc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c2fabef2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import pyedb"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "190a61d2",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "476c24af",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "55a36b99",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c6f5f88b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "# ## Set up project files and path\n",
+ "#\n",
+ "# Download needed project file and set up temporary project directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df3e4b76",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedb_project = ansys.aedt.core.downloads.download_file(\n",
+ " \"edb/ANSYS-HSD_V1.aedb\", destination=temp_folder.name\n",
+ ")\n",
+ "coil = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"inductance_3d_component\",\n",
+ " name=\"air_coil.a3dcomp\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "res = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"resistors\", name=\"Res_0402.a3dcomp\", destination=temp_folder.name\n",
+ ")\n",
+ "project_name = \"HSD\"\n",
+ "output_edb = os.path.join(temp_folder.name, project_name + \".aedb\")\n",
+ "output_q3d = os.path.join(temp_folder.name, project_name + \"_q3d.aedt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4efff99e",
+ "metadata": {},
+ "source": [
+ "## Open EDB project\n",
+ "\n",
+ "Open the EDB project and create a cutout on the selected nets\n",
+ "before exporting to Q3D."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b159c5fb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb = pyedb.Edb(aedb_project, edbversion=AEDT_VERSION)\n",
+ "signal_nets = [\"1.2V_AVDLL_PLL\", \"1.2V_AVDDL\", \"1.2V_DVDDL\", \"NetR106_1\"]\n",
+ "ground_nets = [\"GND\"]\n",
+ "cutout_points = edb.cutout(\n",
+ " signal_list=signal_nets,\n",
+ " reference_list=ground_nets,\n",
+ " output_aedb_path=output_edb,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f2d9755b",
+ "metadata": {},
+ "source": [
+ "## Identify pin positions\n",
+ "\n",
+ "Identify [x,y] pin locations on the components to define where to assign sources\n",
+ "and sinks for Q3D."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "196371f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pin_u11_scl = [\n",
+ " i for i in edb.components[\"U11\"].pins.values() if i.net_name == \"1.2V_AVDLL_PLL\"\n",
+ "]\n",
+ "pin_u9_1 = [i for i in edb.components[\"U9\"].pins.values() if i.net_name == \"1.2V_AVDDL\"]\n",
+ "pin_u9_2 = [i for i in edb.components[\"U9\"].pins.values() if i.net_name == \"1.2V_DVDDL\"]\n",
+ "pin_u11_r106 = [\n",
+ " i for i in edb.components[\"U11\"].pins.values() if i.net_name == \"NetR106_1\"\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bebc4ba4",
+ "metadata": {},
+ "source": [
+ "## Append Z Positions\n",
+ "\n",
+ "Compute the Q3D 3D position. The units in EDB are meters so the\n",
+ "factor 1000 converts from meters to millimeters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "faab7b11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "location_u11_scl = [i * 1000 for i in pin_u11_scl[0].position]\n",
+ "location_u11_scl.append(edb.components[\"U11\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u9_1_scl = [i * 1000 for i in pin_u9_1[0].position]\n",
+ "location_u9_1_scl.append(edb.components[\"U9\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u9_2_scl = [i * 1000 for i in pin_u9_2[0].position]\n",
+ "location_u9_2_scl.append(edb.components[\"U9\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_u11_r106 = [i * 1000 for i in pin_u11_r106[0].position]\n",
+ "location_u11_r106.append(edb.components[\"U11\"].upper_elevation * 1000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66a37eb3",
+ "metadata": {},
+ "source": [
+ "## Identify pin positions for 3D components\n",
+ "\n",
+ "Identify the pin positions where 3D components of passives are to be added."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "91977381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "location_l2_1 = [i * 1000 for i in edb.components[\"L2\"].pins[\"1\"].position]\n",
+ "location_l2_1.append(edb.components[\"L2\"].upper_elevation * 1000)\n",
+ "location_l4_1 = [i * 1000 for i in edb.components[\"L4\"].pins[\"1\"].position]\n",
+ "location_l4_1.append(edb.components[\"L4\"].upper_elevation * 1000)\n",
+ "\n",
+ "location_r106_1 = [i * 1000 for i in edb.components[\"R106\"].pins[\"1\"].position]\n",
+ "location_r106_1.append(edb.components[\"R106\"].upper_elevation * 1000)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "94b18991",
+ "metadata": {},
+ "source": [
+ "## Save and close EDB\n",
+ "\n",
+ "Save and close EDB. Then, open EDT in HFSS 3D Layout to generate the 3D model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ebe8fc53",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.save_edb()\n",
+ "edb.close_edb()\n",
+ "time.sleep(3)\n",
+ "\n",
+ "h3d = ansys.aedt.core.Hfss3dLayout(\n",
+ " output_edb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28e376ae",
+ "metadata": {},
+ "source": [
+ "## Export to Q3D\n",
+ "\n",
+ "Create a dummy setup and export the layout to Q3D.\n",
+ "The ``keep_net_name`` parameter reassigns Q3D net names from HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f29f21e2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = h3d.create_setup()\n",
+ "setup.export_to_q3d(output_q3d, keep_net_name=True)\n",
+ "h3d.close_project()\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9d08886",
+ "metadata": {},
+ "source": [
+ "## Open Q3D\n",
+ "\n",
+ "Launch the newly created Q3D project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2a7f7108",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d = ansys.aedt.core.Q3d(output_q3d, version=AEDT_VERSION)\n",
+ "q3d.modeler.delete(\"GND\")\n",
+ "q3d.modeler.delete(\"16_Bottom_L6\")\n",
+ "q3d.delete_all_nets()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d945874",
+ "metadata": {},
+ "source": [
+ "## Insert inductors\n",
+ "\n",
+ "Create coordinate systems and place 3D component inductors."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ac157b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.modeler.create_coordinate_system(location_l2_1, name=\"L2\")\n",
+ "comp = q3d.modeler.insert_3d_component(coil, coordinate_system=\"L2\")\n",
+ "comp.rotate(q3d.AXIS.Z, -90)\n",
+ "comp.parameters[\"n_turns\"] = \"3\"\n",
+ "comp.parameters[\"d_wire\"] = \"100um\"\n",
+ "q3d.modeler.set_working_coordinate_system(\"Global\")\n",
+ "q3d.modeler.create_coordinate_system(location_l4_1, name=\"L4\")\n",
+ "comp2 = q3d.modeler.insert_3d_component(coil, coordinate_system=\"L4\")\n",
+ "comp2.rotate(q3d.AXIS.Z, -90)\n",
+ "comp2.parameters[\"n_turns\"] = \"3\"\n",
+ "comp2.parameters[\"d_wire\"] = \"100um\"\n",
+ "q3d.modeler.set_working_coordinate_system(\"Global\")\n",
+ "\n",
+ "q3d.modeler.set_working_coordinate_system(\"Global\")\n",
+ "q3d.modeler.create_coordinate_system(location_r106_1, name=\"R106\")\n",
+ "comp3 = q3d.modeler.insert_3d_component(\n",
+ " res, geometry_parameters={\"$Resistance\": 2000}, coordinate_system=\"R106\"\n",
+ ")\n",
+ "comp3.rotate(q3d.AXIS.Z, -90)\n",
+ "\n",
+ "q3d.modeler.set_working_coordinate_system(\"Global\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f938a0d3",
+ "metadata": {},
+ "source": [
+ "## Delete dielectrics\n",
+ "\n",
+ "Delete all dielectric objects since they are not needed in DC analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ecc339e5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.modeler.delete(q3d.modeler.get_objects_by_material(\"Megtron4\"))\n",
+ "q3d.modeler.delete(q3d.modeler.get_objects_by_material(\"Megtron4_2\"))\n",
+ "q3d.modeler.delete(q3d.modeler.get_objects_by_material(\"Megtron4_3\"))\n",
+ "q3d.modeler.delete(q3d.modeler.get_objects_by_material(\"Solder Resist\"))\n",
+ "\n",
+ "objs_copper = q3d.modeler.get_objects_by_material(\"copper\")\n",
+ "objs_copper_names = [i.name for i in objs_copper]\n",
+ "q3d.plot(\n",
+ " show=False,\n",
+ " assignment=objs_copper_names,\n",
+ " plot_as_separate_objects=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Q3D.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a29cd977",
+ "metadata": {},
+ "source": [
+ "## Assign source and sink\n",
+ "\n",
+ "Use previously calculated positions to identify faces. Select the net ``1_Top`` and\n",
+ "assign sources and sinks on nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c0b5274d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sink_f = q3d.modeler.create_circle(q3d.PLANE.XY, location_u11_scl, 0.1)\n",
+ "source_f1 = q3d.modeler.create_circle(q3d.PLANE.XY, location_u9_1_scl, 0.1)\n",
+ "source_f2 = q3d.modeler.create_circle(q3d.PLANE.XY, location_u9_2_scl, 0.1)\n",
+ "source_f3 = q3d.modeler.create_circle(q3d.PLANE.XY, location_u11_r106, 0.1)\n",
+ "sources_objs = [source_f1, source_f2, source_f3]\n",
+ "\n",
+ "q3d.auto_identify_nets()\n",
+ "\n",
+ "identified_net = q3d.nets[0]\n",
+ "\n",
+ "q3d.sink(sink_f, net_name=identified_net)\n",
+ "\n",
+ "source1 = q3d.source(source_f1, net_name=identified_net)\n",
+ "\n",
+ "source2 = q3d.source(source_f2, net_name=identified_net)\n",
+ "source3 = q3d.source(source_f3, net_name=identified_net)\n",
+ "sources_bounds = [source1, source2, source3]\n",
+ "\n",
+ "q3d.edit_sources(\n",
+ " dcrl={\n",
+ " \"{}:{}\".format(source1.props[\"Net\"], source1.name): \"-1.0A\",\n",
+ " \"{}:{}\".format(source2.props[\"Net\"], source2.name): \"-1.0A\",\n",
+ " \"{}:{}\".format(source2.props[\"Net\"], source3.name): \"-1.0A\",\n",
+ " }\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c564a2d",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup and a frequency sweep from DC to 2GHz.\n",
+ "Then, analyze the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d523b5f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = q3d.create_setup()\n",
+ "setup.dc_enabled = True\n",
+ "setup.capacitance_enabled = False\n",
+ "setup.ac_rl_enabled = False\n",
+ "setup.props[\"SaveFields\"] = True\n",
+ "setup.props[\"DC\"][\"Cond\"][\"MaxPass\"] = 3\n",
+ "setup.analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c26453be",
+ "metadata": {},
+ "source": [
+ "## Solve setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "edbe117b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.save_project()\n",
+ "q3d.analyze_setup(setup.name, cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9853b340",
+ "metadata": {},
+ "source": [
+ "## Create a named expression\n",
+ "\n",
+ "Use PyAEDT advanced fields calculator to add from the expressions catalog the voltage drop."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c6d96ac7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "voltage_drop = q3d.post.fields_calculator.add_expression(\"voltage_drop\", None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "60807b28",
+ "metadata": {},
+ "source": [
+ "## Create Phi plot\n",
+ "\n",
+ "Compute ACL solutions and plot them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7dca30eb",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "plot1 = q3d.post.create_fieldplot_surface(\n",
+ " q3d.modeler.get_objects_by_material(\"copper\"),\n",
+ " quantity=voltage_drop,\n",
+ " intrinsics={\"Freq\": \"1GHz\"},\n",
+ ")\n",
+ "\n",
+ "q3d.post.plot_field_from_fieldplot(\n",
+ " plot1.name,\n",
+ " project_path=temp_folder.name,\n",
+ " mesh_plot=False,\n",
+ " image_format=\"jpg\",\n",
+ " view=\"isometric\",\n",
+ " show=False,\n",
+ " plot_cad_objs=False,\n",
+ " log_scale=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76cd89e7",
+ "metadata": {},
+ "source": [
+ "## Compute voltage on source circles\n",
+ "\n",
+ "Use PyAEDT advanced field calculator to compute the voltage on source circles and get the value\n",
+ "using the ``get_solution_data()`` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "55858cdf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "v_surface = {\n",
+ " \"name\": \"\",\n",
+ " \"description\": \"Maximum value of voltage on a surface\",\n",
+ " \"design_type\": [\"Q3D Extractor\"],\n",
+ " \"fields_type\": [\"DC R/L Fields\"],\n",
+ " \"primary_sweep\": \"Freq\",\n",
+ " \"assignment\": \"\",\n",
+ " \"assignment_type\": [\"Face\", \"Sheet\"],\n",
+ " \"operations\": [\n",
+ " f\"NameOfExpression({voltage_drop})\",\n",
+ " \"EnterSurface('assignment')\",\n",
+ " \"Operation('SurfaceValue')\",\n",
+ " \"Operation('Maximum')\",\n",
+ " ],\n",
+ " \"report\": [\"Field_3D\"],\n",
+ "}\n",
+ "for source_circle, source_bound in zip(sources_objs, sources_bounds):\n",
+ " v_surface[\"name\"] = \"V{}\".format(source_bound.name)\n",
+ " q3d.post.fields_calculator.add_expression(v_surface, source_circle.name)\n",
+ "\n",
+ " data = q3d.post.get_solution_data(\n",
+ " \"V{}\".format(source_bound.name),\n",
+ " q3d.nominal_adaptive,\n",
+ " variations={\"Freq\": \"1GHz\"},\n",
+ " report_category=\"DC R/L Fields\",\n",
+ " )\n",
+ " if data:\n",
+ " print(data.data_real(\"V{}\".format(source_bound.name)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42f14b8d",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "62d89a4b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q3d.save_project()\n",
+ "q3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f742f1f6",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "31f520de",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/power_integrity/index.rst.txt b/version/dev/_sources/examples/high_frequency/layout/power_integrity/index.rst.txt
new file mode 100644
index 00000000..0d324b8c
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/power_integrity/index.rst.txt
@@ -0,0 +1,112 @@
+Power integrity
+~~~~~~~~~~~~~~~
+
+These examples use PyAEDT to show power integrity examples.
+
+.. grid:: 2
+
+ .. grid-item-card:: Power integrity analysis
+ :padding: 2 2 2 2
+ :link: power_integrity
+ :link-type: doc
+
+ .. image:: _static/power_integrity.png
+ :alt: Power integrity
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use the Ansys Electronics Database (EDB) for power integrity analysis.
+
+ .. grid-item-card:: DC IR analysis
+ :padding: 2 2 2 2
+ :link: dcir
+ :link-type: doc
+
+ .. image:: _static/dcir.png
+ :alt: DCIR
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to configure EDB for DC IR analysis and load EDB into the HFSS 3D Layout UI for analysis
+ and postprocessing.
+
+ .. grid-item-card:: PCB DCIR analysis
+ :padding: 2 2 2 2
+ :link: dcir_q3d
+ :link-type: doc
+
+ .. image:: _static/dcir_q3d.png
+ :alt: DCIR
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a design in Q3D Extractor and run a DC IR drop simulation starting
+ from an EDB project.
+
+ .. grid-item-card:: PCB AC analysis
+ :padding: 2 2 2 2
+ :link: ac_q3d
+ :link-type: doc
+
+ .. image:: _static/ac_q3d.png
+ :alt: AC Q3D
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a design in Q3D Extractor and run a simulation starting
+ from an EDB project.
+
+ .. grid-item-card:: Circuit schematic creation and analysis
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/modeler/circuit_schematic
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/modeler/_static/circuit.png
+ :alt: Circuit
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Circuit Netlist to Schematic
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/modeler/netlist_to_schematic
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/modeler/_static/netlist.png
+ :alt: Netlist
+ :width: 250px
+ :height: 250px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Touchstone files
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/report/touchstone_file
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/report/_static/touchstone_skitrf.png
+ :alt: Touchstone file
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use objects in a Touchstone file without opening AEDT.
+
+
+ .. toctree::
+ :hidden:
+
+ power_integrity
+ dcir
+ dcir_q3d
+ ac_q3d
+ ../../../aedt_general/modeler/circuit_schematic
+ ../../../aedt_general/modeler/netlist_to_schematic
+ ../../../aedt_general/report/touchstone_file
diff --git a/version/dev/_sources/examples/high_frequency/layout/power_integrity/power_integrity.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/power_integrity/power_integrity.ipynb.txt
new file mode 100644
index 00000000..91659105
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/power_integrity/power_integrity.ipynb.txt
@@ -0,0 +1,525 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "ab04d84c",
+ "metadata": {},
+ "source": [
+ "# Power integrity analysis\n",
+ "This example shows how to use the Ansys Electronics Database (EDB) for power integrity analysis. The\n",
+ "EDB is loaded into HFSS 3D Layout for analysis and postprocessing.\n",
+ "\n",
+ "- Set up EDB consists of these steps:\n",
+ "\n",
+ " - Assign S-parameter model to components.\n",
+ " - Create pin groups.\n",
+ " - Create ports.\n",
+ " - Create SIwave SYZ analysis.\n",
+ " - Create cutout.\n",
+ "\n",
+ "- Import EDB into HFSS 3D Layout:\n",
+ "\n",
+ " - Analyze.\n",
+ " - Plot ``$Z_{11}$``.\n",
+ "\n",
+ "Keywords: **HFSS 3D Layout**, **power integrity**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "37609507",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Import the required packages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8be1a7ab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "61aabfb9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.downloads import download_file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f51fde3b",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66c484b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb8c35ff",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8c62c7b2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b64e58e6",
+ "metadata": {},
+ "source": [
+ "Download the example PCB data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0cb43439",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedb = download_file(source=\"edb/ANSYS-HSD_V1.aedb\", destination=temp_folder.name)\n",
+ "download_file(\n",
+ " source=\"touchstone\",\n",
+ " name=\"GRM32_DC0V_25degC_series.s2p\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ade6d3a5",
+ "metadata": {},
+ "source": [
+ "## Create configuration file\n",
+ "This example uses a configuration file to set up the layout for analysis.\n",
+ "Initialize and create an empty dictionary to host all configurations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1420b40d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg = dict()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd44a03a",
+ "metadata": {},
+ "source": [
+ "Assigns S-parameter models to capacitors.\n",
+ "The first step is to use the \"general\" key to specify where the S-parameter files can be found."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b795d96e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"general\"] = {\"s_parameter_library\": os.path.join(temp_folder.name, \"touchstone\")}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21f0aab8",
+ "metadata": {},
+ "source": [
+ "## Assign model to capactitors\n",
+ "The model ``GRM32_DC0V_25degC_series.s2p`` is assigned to capacitors C3 and C4, which share the same component part number.\n",
+ "When \"apply_to_all\" is ``True``, all components having the part number \"CAPC3216X180X20ML20\" are assigned the S-parameter model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9965aacc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"s_parameters\"] = [\n",
+ " {\n",
+ " \"name\": \"GRM32_DC0V_25degC_series\",\n",
+ " \"component_definition\": \"CAPC0603X33X15LL03T05\",\n",
+ " \"file_path\": \"GRM32_DC0V_25degC_series.s2p\",\n",
+ " \"apply_to_all\": False,\n",
+ " \"components\": [\"C110\", \"C206\"],\n",
+ " \"reference_net\": \"GND\",\n",
+ " \"reference_net_per_component\": {\"C110\": \"GND\"},\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10f0bd47",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Create pin groups\n",
+ "Pins can be grouped explicitly by the pin name, or pin groups can be assigned by net name using the ''net'' key.\n",
+ "The following code combine the listed pins on component U2 into two pin groups using the ``net`` key."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "64c08c80",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"pin_groups\"] = [\n",
+ " {\n",
+ " \"name\": \"PIN_GROUP_1\",\n",
+ " \"reference_designator\": \"U1\",\n",
+ " \"pins\": [\"AD14\", \"AD15\", \"AD16\", \"AD17\"],\n",
+ " },\n",
+ " {\"name\": \"PIN_GROUP_2\", \"reference_designator\": \"U1\", \"net\": \"GND\"},\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6708057",
+ "metadata": {},
+ "source": [
+ "## Create ports\n",
+ "Create a circuit port between the two pin groups just created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0bf146a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"ports\"] = [\n",
+ " {\n",
+ " \"name\": \"port1\",\n",
+ " \"reference_designator\": \"U1\",\n",
+ " \"type\": \"circuit\",\n",
+ " \"positive_terminal\": {\"pin_group\": \"PIN_GROUP_1\"},\n",
+ " \"negative_terminal\": {\"pin_group\": \"PIN_GROUP_2\"},\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90962631",
+ "metadata": {},
+ "source": [
+ "## Create SIwave SYZ analysis setup\n",
+ "Both SIwave and HFSS can be used to run an analysis in the 3D Layout user interface."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b632cac6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"setups\"] = [\n",
+ " {\n",
+ " \"name\": \"siwave_syz\",\n",
+ " \"type\": \"siwave_syz\",\n",
+ " \"pi_slider_position\": 1,\n",
+ " \"freq_sweep\": [\n",
+ " {\n",
+ " \"name\": \"Sweep1\",\n",
+ " \"type\": \"Interpolation\",\n",
+ " \"frequencies\": [\n",
+ " {\n",
+ " \"distribution\": \"log scale\",\n",
+ " \"start\": 1e6,\n",
+ " \"stop\": 1e9,\n",
+ " \"samples\": 20,\n",
+ " }\n",
+ " ],\n",
+ " }\n",
+ " ],\n",
+ " }\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d903cdab",
+ "metadata": {},
+ "source": [
+ "## Define cutout\n",
+ "Define the region of the PCB to be cut out for analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "955cc733",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cfg[\"operations\"] = {\n",
+ " \"cutout\": {\n",
+ " \"signal_list\": [\"1V0\"],\n",
+ " \"reference_list\": [\"GND\"],\n",
+ " \"extent_type\": \"ConvexHull\",\n",
+ " \"expansion_size\": 0.002,\n",
+ " \"use_round_corner\": False,\n",
+ " \"output_aedb_path\": \"\",\n",
+ " \"open_cutout_at_end\": True,\n",
+ " \"use_pyaedt_cutout\": True,\n",
+ " \"number_of_threads\": 4,\n",
+ " \"use_pyaedt_extent_computing\": True,\n",
+ " \"extent_defeature\": 0,\n",
+ " \"remove_single_pin_components\": False,\n",
+ " \"custom_extent\": \"\",\n",
+ " \"custom_extent_units\": \"mm\",\n",
+ " \"include_partial_instances\": False,\n",
+ " \"keep_voids\": True,\n",
+ " \"check_terminals\": False,\n",
+ " \"include_pingroups\": False,\n",
+ " \"expansion_factor\": 0,\n",
+ " \"maximum_iterations\": 10,\n",
+ " \"preserve_components_with_model\": False,\n",
+ " \"simple_pad_check\": True,\n",
+ " \"keep_lines_as_path\": False,\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "39f459fb",
+ "metadata": {},
+ "source": [
+ "## Save configuration\n",
+ "\n",
+ "Save the configuration file to a JSON file and apply it to layout data using the EDB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3aa5496c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pi_json = os.path.join(temp_folder.name, \"pi.json\")\n",
+ "with open(pi_json, \"w\") as f:\n",
+ " json.dump(cfg, f, indent=4, ensure_ascii=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90bb9d6d",
+ "metadata": {},
+ "source": [
+ "## Load configuration into EDB"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "77aef84b",
+ "metadata": {},
+ "source": [
+ "Load the configuration into EDB from the JSON file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d718fdd8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp = ansys.aedt.core.Edb(aedb, edbversion=AEDT_VERSION)\n",
+ "edbapp.configuration.load(config_file=pi_json)\n",
+ "edbapp.configuration.run()\n",
+ "edbapp.save()\n",
+ "edbapp.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "482b6c33",
+ "metadata": {},
+ "source": [
+ "The configured EDB file is saved in the temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "23e061d0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e7f8028",
+ "metadata": {},
+ "source": [
+ "## Analyze in HFSS 3D Layout"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5ae14602",
+ "metadata": {},
+ "source": [
+ "### Load EDB into HFSS 3D Layout"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "54b2b6e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d = ansys.aedt.core.Hfss3dLayout(\n",
+ " aedb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b8e962a",
+ "metadata": {},
+ "source": [
+ "### Analyze"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8b05228e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe8588fa",
+ "metadata": {},
+ "source": [
+ "### Plot impedance"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "10f4b0f4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions = h3d.post.get_solution_data(expressions=\"Z(port1,port1)\")\n",
+ "solutions.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c551c6c",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "abaa8e1a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.save_project()\n",
+ "h3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ae8c1435",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5695a755",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/signal_integrity/ami.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/ami.ipynb.txt
new file mode 100644
index 00000000..f8984724
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/ami.ipynb.txt
@@ -0,0 +1,596 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e25dc40c",
+ "metadata": {},
+ "source": [
+ "# AMI Postprocessing\n",
+ "\n",
+ "This example demonstrates advanced postprocessing of AMI simulations.\n",
+ "\n",
+ "Keywords: **Circuit**, **AMI**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ae1d91e5",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports.\n",
+ "\n",
+ "> **Note:** [Numpy](https://numpy.org/)\n",
+ "> and [Matplotlib](https://matplotlib.org/) are required to run this example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a7e80e10",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n",
+ "import numpy as np\n",
+ "from matplotlib import pyplot as plt\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2ccae636",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d3c3b042",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "af50e57d",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download example files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b1f64654",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a27e969a",
+ "metadata": {},
+ "source": [
+ "## Download example data\n",
+ "\n",
+ "The ``download_file()`` method retrieves example\n",
+ "data from the PyAnsys\n",
+ "[example-data](https://github.com/ansys/example-data/tree/master/pyaedt) repository.\n",
+ "\n",
+ "- The fist argument is the folder name where\n",
+ " the example files are located in the GitHub repository.\n",
+ "- The 2nd argument is the file to retrieve.\n",
+ "- The 3rd argument is the destination folder.\n",
+ "\n",
+ "Files are placed in the destination folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5416c2ef",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "project_path = ansys.aedt.core.downloads.download_file(\n",
+ " \"ami\", name=\"ami_usb.aedtz\", destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "838225a6",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT with Circuit and enable Pandas as the output format\n",
+ "\n",
+ "All outputs obtained with the `get_solution_data()` method are in the\n",
+ "[Pandas](https://pandas.pydata.org/docs/user_guide/index.html) format.\n",
+ "Launch AEDT with Circuit. The `ansys.aedt.core.Desktop` class initializes AEDT\n",
+ "and starts the specified version in the specified mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e0199532",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ansys.aedt.core.settings.enable_pandas_output = True\n",
+ "circuit = ansys.aedt.core.Circuit(\n",
+ " project=os.path.join(project_path),\n",
+ " non_graphical=NG_MODE,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5df0261f",
+ "metadata": {},
+ "source": [
+ "## Solve AMI setup\n",
+ "\n",
+ "Solve the transient setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7e3a92c9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "089a206b",
+ "metadata": {},
+ "source": [
+ "## Get AMI report\n",
+ "\n",
+ "Get AMI report data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e843bfec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_name = \"WaveAfterProbe![](\"_static\\com_eye.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "688570a5",
+ "metadata": {},
+ "source": [
+ "## What is COM?\n",
+ "\n",
+ "- COM was developed as part of IEEE 802.3bj, 100GBASE Ethernet.\n",
+ "- COM is a figure of merit for an S-parameter representing a high-speed SerDes channel.\n",
+ "- COM is the ratio between eye height and noise."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "92f7d54f",
+ "metadata": {},
+ "source": [
+ "```math\n",
+ "COM = 20 * log10 (A_signal / A_noise)\n",
+ "```\n",
+ "\n",
+ "Keywords: **COM**, **signal integrity**, **virtual compliance**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c319271b",
+ "metadata": {},
+ "source": [
+ "## Perform imports\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1afdfca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cbc1701b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core.visualization.post.spisim import SpiSim\n",
+ "from ansys.aedt.core.visualization.post.spisim_com_configuration_files import \\\n",
+ " com_parameters\n",
+ "from pyedb.misc.downloads import download_file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a50fa9c7",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download example files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9c5d93da",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "\n",
+ "thru = download_file(\n",
+ " directory=\"com_analysis\",\n",
+ " filename=\"SerDes_Demo_02_Thru.s4p\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "fext_2_9 = download_file(\n",
+ " directory=\"com_analysis\",\n",
+ " filename=\"FCI_CC_Long_Link_Pair_2_to_Pair_9_FEXT.s4p\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "fext_5_9 = download_file(\n",
+ " directory=\"com_analysis\",\n",
+ " filename=\"FCI_CC_Long_Link_Pair_5_to_Pair_9_FEXT.s4p\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "next_11_9 = download_file(\n",
+ " directory=\"com_analysis\",\n",
+ " filename=\"FCI_CC_Long_Link_Pair_11_to_Pair_9_NEXT.s4p\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a2b1cd04",
+ "metadata": {},
+ "source": [
+ "## Run COM analysis\n",
+ "PyAEDT calls SPISim for COM analysis. For supported standardes, see the PyAEDT documentation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "abdc8eee",
+ "metadata": {},
+ "source": [
+ "Set ``port_order=\"EvenOdd\"`` when the S-parameter has this port order:\n",
+ "\n",
+ "1 - 2\n",
+ "\n",
+ "3 - 4\n",
+ "\n",
+ "Set ``port_order=\"Incremental\"`` when the S-parameter has this port order:\n",
+ "\n",
+ "1 - 3\n",
+ "\n",
+ "2 - 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b7127448",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "spi_sim = SpiSim(thru)\n",
+ "com_results = spi_sim.compute_com(\n",
+ " standard=1, # 50GAUI-1-C2C\n",
+ " port_order=\"EvenOdd\",\n",
+ " fext_s4p=[fext_5_9, fext_5_9],\n",
+ " next_s4p=next_11_9,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a2a29622",
+ "metadata": {},
+ "source": [
+ "## Print COM values\n",
+ "There are two COM values reported by the definition of the standard:\n",
+ "\n",
+ "- Case 0: COM value in dB when big package is used.\n",
+ "- Case 1: COM value in dB when small package is used."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "61a1538a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(*com_results)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "915b8c15",
+ "metadata": {},
+ "source": [
+ "## View COM report\n",
+ "A complete COM report is generated in the temporary folder in HTML format."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "814bb89a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(temp_folder.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca7ca704",
+ "metadata": {},
+ "source": [
+ "![](\"_static\\com_report.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "765a1715",
+ "metadata": {},
+ "source": [
+ "## Run COM analysis on custom configuration file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86a90831",
+ "metadata": {},
+ "source": [
+ "### Export template configuration file in JSON format"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "84dad2fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "custom_json = os.path.join(temp_folder.name, \"custom.json\")\n",
+ "spi_sim.export_com_configure_file(custom_json, standard=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05bcc85d",
+ "metadata": {},
+ "source": [
+ "Modify the custom JSON file as needed."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a28e527f",
+ "metadata": {},
+ "source": [
+ "### Import configuration file and run"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "278a1bbf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "com_results = spi_sim.compute_com(\n",
+ " standard=0, # Custom\n",
+ " config_file=custom_json,\n",
+ " port_order=\"EvenOdd\",\n",
+ " fext_s4p=[fext_5_9, fext_5_9],\n",
+ " next_s4p=next_11_9,\n",
+ ")\n",
+ "print(*com_results)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2daf3f66",
+ "metadata": {},
+ "source": [
+ "## Export SPISim supported configuration file\n",
+ "You can use the exported configuration file in the SPISim GUI."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d1e429e3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "com_param = com_parameters.COMParametersVer3p4()\n",
+ "com_param.load(custom_json)\n",
+ "custom_cfg = os.path.join(temp_folder.name, \"custom.cfg\")\n",
+ "com_param.export_spisim_cfg(custom_cfg)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb1ea64b",
+ "metadata": {},
+ "source": [
+ "PyAEDT also supports the SPISim configuration file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "61e92e30",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "com_results = spi_sim.compute_com(\n",
+ " standard=0, config_file=custom_cfg, port_order=\"EvenOdd\"\n",
+ ") # Custom\n",
+ "print(*com_results)"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/signal_integrity/index.rst.txt b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/index.rst.txt
new file mode 100644
index 00000000..0f782871
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/index.rst.txt
@@ -0,0 +1,166 @@
+Signal integrity
+~~~~~~~~~~~~~~~~
+
+These examples use PyAEDT to show signal integrity examples.
+
+.. grid:: 2
+
+ .. grid-item-card:: Channel Operating Margin (COM)
+ :padding: 2 2 2 2
+ :link: com_analysis
+ :link-type: doc
+
+ .. image:: _static/com_eye.png
+ :alt: COM
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT for COM analysis.
+
+ .. grid-item-card:: Pre-layout signal integrity
+ :padding: 2 2 2 2
+ :link: pre_layout
+ :link-type: doc
+
+ .. image:: _static/pre_layout_sma_connector_on_pcb.png
+ :alt: Pre layout connector
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a parameterized layout design and load the layout into HFSS 3D Layout
+ for analysis and postprocessing.
+
+ .. grid-item-card:: Pre-layout Parameterized PCB
+ :padding: 2 2 2 2
+ :link: pre_layout_parametrized
+ :link-type: doc
+
+ .. image:: _static/pre_layout_parameterized_pcb.png
+ :alt: Pre layout parametrized
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use the EDB interface along with HFSS 3D Layout to create and solve a parameterized layout.
+
+ .. grid-item-card:: AMI Postprocessing
+ :padding: 2 2 2 2
+ :link: ami
+ :link-type: doc
+
+ .. image:: _static/ami.png
+ :alt: AMI
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example demonstrates advanced postprocessing of AMI simulations.
+
+ .. grid-item-card:: Multi-zone simulation with SIwave
+ :padding: 2 2 2 2
+ :link: multizone
+ :link-type: doc
+
+ .. image:: _static/multizone.png
+ :alt: Multizone
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to simulate multiple zones with SIwave.
+
+ .. grid-item-card:: Circuit transient analysis and eye diagram
+ :padding: 2 2 2 2
+ :link: circuit_transient
+ :link-type: doc
+
+ .. image:: _static/circuit_transient.png
+ :alt: Circuit transient
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a circuit design, run a Nexxim time-domain simulation, and create an eye diagram.
+
+ .. grid-item-card:: Circuit schematic creation and analysis
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/modeler/circuit_schematic
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/modeler/_static/circuit.png
+ :alt: Circuit
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Circuit Netlist to Schematic
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/modeler/netlist_to_schematic
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/modeler/_static/netlist.png
+ :alt: Netlist
+ :width: 250px
+ :height: 250px
+ :align: center
+
+ This example shows how to build a circuit schematic and run a transient circuit simulation.
+
+ .. grid-item-card:: Schematic subcircuit management
+ :padding: 2 2 2 2
+ :link: ../../emc/subcircuit
+ :link-type: doc
+
+ .. image:: ../../emc/_static/subcircuit.png
+ :alt: Cable
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to add a subcircuit to a circuit design.
+ It changes the focus within the hierarchy between the child subcircuit and the parent design.
+
+ .. grid-item-card:: Touchstone files
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/report/touchstone_file
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/report/_static/touchstone_skitrf.png
+ :alt: Touchstone file
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use objects in a Touchstone file without opening AEDT.
+
+ .. grid-item-card:: PCIE virtual compliance
+ :padding: 2 2 2 2
+ :link: ../../../aedt_general/report/virtual_compliance
+ :link-type: doc
+
+ .. image:: ../../../aedt_general/report/_static/virtual_compliance_eye.png
+ :alt: Virtual compliance
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to generate a compliance report in PyAEDT using the VirtualCompliance class.
+
+ .. toctree::
+ :hidden:
+
+ com_analysis
+ pre_layout
+ pre_layout_parametrized
+ ami
+ multizone
+ circuit_transient
+ ../../../aedt_general/modeler/circuit_schematic
+ ../../../aedt_general/modeler/netlist_to_schematic
+ ../../emc/subcircuit
+ ../../../aedt_general/report/touchstone_file
+ ../../../aedt_general/report/virtual_compliance
diff --git a/version/dev/_sources/examples/high_frequency/layout/signal_integrity/multizone.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/multizone.ipynb.txt
new file mode 100644
index 00000000..9e6bfa8e
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/multizone.ipynb.txt
@@ -0,0 +1,402 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "edd759ec",
+ "metadata": {},
+ "source": [
+ "# Multi-zone simulation with SIwave\n",
+ "\n",
+ "This example shows how to simulate multiple zones with SIwave.\n",
+ "\n",
+ "Keywords: **Circuit**, **multi-zone**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0a88ebd8",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports, which includes importing a section."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a2759114",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os.path\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core import Circuit, Edb\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b4968d6",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9c61604",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "EDB_VERSION = \"2024.2\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5f0d3f4d",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d8f2a93a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29fe1fde",
+ "metadata": {},
+ "source": [
+ "## Download EDB folder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c560cc35",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "edb_file = ansys.aedt.core.downloads.download_file(\n",
+ " directory=\"edb/siwave_multi_zones.aedb\", destination=temp_folder.name\n",
+ ")\n",
+ "work_folder = os.path.join(temp_folder.name, \"work\")\n",
+ "aedt_file = os.path.splitext(edb_file)[0] + \".aedt\"\n",
+ "circuit_project_file = os.path.join(temp_folder.name, \"multizone_clipped_circuit.aedt\")\n",
+ "print(edb_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b9aae56",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Set AEDT version"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9eb148a1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb_version = EDB_VERSION"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "072bf311",
+ "metadata": {},
+ "source": [
+ "## Define ground net\n",
+ "\n",
+ "Define the common reference net used across all subdesigns, which is mandatory for this workflow."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "94eedb04",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "common_reference_net = \"GND\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fd3de4f",
+ "metadata": {},
+ "source": [
+ "## Load project\n",
+ "\n",
+ "Check if the AEDT file exists and remove it to allow EDB loading. Then, load the initial EDB file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8851c44e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if os.path.isfile(aedt_file):\n",
+ " os.remove(aedt_file)\n",
+ "edb = Edb(edbversion=edb_version, edbpath=edb_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "75fd12fe",
+ "metadata": {},
+ "source": [
+ "## Copy project zones\n",
+ "\n",
+ "Copy project zone into the subproject."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "076b3efd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb_zones = edb.copy_zones(working_directory=work_folder)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f2524340",
+ "metadata": {},
+ "source": [
+ "## Split zones\n",
+ "\n",
+ "Clip subdesigns along with corresponding zone definitions\n",
+ "and create a port of clipped signal traces."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a09655fc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "defined_ports, project_connexions = edb.cutout_multizone_layout(\n",
+ " edb_zones, common_reference_net\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed94a02a",
+ "metadata": {},
+ "source": [
+ "## Create circuit\n",
+ "\n",
+ "Create circuit design, import all subprojects as EM models, and connect\n",
+ "all corresponding pins in the circuit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f3ad1d10",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit = Circuit(version=edb_version, project=circuit_project_file)\n",
+ "circuit.connect_circuit_models_from_multi_zone_cutout(\n",
+ " project_connections=project_connexions,\n",
+ " edb_zones_dict=edb_zones,\n",
+ " ports=defined_ports,\n",
+ " model_inc=70,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d30cce8",
+ "metadata": {},
+ "source": [
+ "## Set up simulation\n",
+ "\n",
+ "Add Nexxim LNA simulation setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "67750d6b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit_setup = circuit.create_setup(\"Pyedt_LNA\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12f90791",
+ "metadata": {},
+ "source": [
+ "## Add frequency sweep\n",
+ "\n",
+ "Add a frequency sweep from 0 GHt to 20 GHz with a 10 NHz frequency step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9b6a96dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit_setup.props[\"SweepDefinition\"][\"Data\"] = \"LIN {} {} {}\".format(\n",
+ " \"0GHz\", \"20GHz\", \"10MHz\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06f42fd7",
+ "metadata": {},
+ "source": [
+ "## Start simulation\n",
+ "\n",
+ "Analyze all SIwave projects and solve the circuit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50f65d8c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.analyze()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da922936",
+ "metadata": {},
+ "source": [
+ "Define differential pairs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "daeffff7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.set_differential_pair(\n",
+ " differential_mode=\"U0\",\n",
+ " assignment=\"U0.via_38.B2B_SIGP\",\n",
+ " reference=\"U0.via_39.B2B_SIGN\",\n",
+ ")\n",
+ "circuit.set_differential_pair(\n",
+ " differential_mode=\"U1\",\n",
+ " assignment=\"U1.via_32.B2B_SIGP\",\n",
+ " reference=\"U1.via_33.B2B_SIGN\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f48e3d9d",
+ "metadata": {},
+ "source": [
+ "Plot results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "057bcf9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.post.create_report(\n",
+ " expressions=[\"dB(S(U0,U0))\", \"dB(S(U1,U0))\"], context=\"Differential Pairs\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "635baa85",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a83e096e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.save_project()\n",
+ "circuit.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5ec4a930",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "88964783",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout.ipynb.txt
new file mode 100644
index 00000000..6ceb1493
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout.ipynb.txt
@@ -0,0 +1,804 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "819943b4",
+ "metadata": {},
+ "source": [
+ "# Pre-layout signal integrity\n",
+ "This example shows how to create a parameterized layout design\n",
+ "and load the layout into HFSS 3D Layout for analysis and postprocessing.\n",
+ "\n",
+ "- Create EDB:\n",
+ "\n",
+ " - Add material.\n",
+ " - Create stackup.\n",
+ " - Create a parameterized via padstack definition.\n",
+ " - Create ground planes.\n",
+ " - Create a component.\n",
+ " - Create signal vias and traces.\n",
+ " - Create ground stitching vias.\n",
+ " - Create HFSS analysis setup and frequency sweep.\n",
+ "\n",
+ "- Import EDB into HFSS 3D Layout:\n",
+ "\n",
+ " - Place SMA connector.\n",
+ " - Analyze.\n",
+ " - Plot return loss."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "683d147d",
+ "metadata": {},
+ "source": [
+ "Here is an image of the model that is created in this example.\n",
+ "\n",
+ "![](\"_static/pre_layout_sma_connector_on_pcb.png\")
\n",
+ "\n",
+ "Keywords: **HFSS 3D Layout**, **signal integrity**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e322a53",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Perform required packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "027e3004",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "from ansys.aedt.core import Hfss3dLayout\n",
+ "from ansys.aedt.core.downloads import download_file\n",
+ "from pyedb import Edb\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27f7f5ef",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b79ddf4f",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4eced397",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download example files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "607bf32b",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "sma_rf_connector = download_file(\n",
+ " source=\"component_3d\",\n",
+ " name=\"SMA_RF_SURFACE_MOUNT.a3dcomp\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c8bdc1a",
+ "metadata": {},
+ "source": [
+ "# Create layout design"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6892fd66",
+ "metadata": {},
+ "source": [
+ "## Import example design"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a8145658",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedb = os.path.join(temp_folder.name, \"new_layout.aedb\")\n",
+ "edbapp = Edb(edbpath=aedb, edbversion=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a86bad1d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set antipad always on.\n",
+ "edbapp.design_options.antipads_always_on = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0e6a0adc",
+ "metadata": {},
+ "source": [
+ "## Add material definitions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b738d10",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.materials.add_conductor_material(name=\"copper\", conductivity=58000000)\n",
+ "edbapp.materials.add_dielectric_material(\n",
+ " name=\"FR4_epoxy\", permittivity=4, dielectric_loss_tangent=0.02\n",
+ ")\n",
+ "edbapp.materials.add_dielectric_material(\n",
+ " name=\"solder_mask\", permittivity=3.1, dielectric_loss_tangent=0.035\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0d27528",
+ "metadata": {},
+ "source": [
+ "## Create stackup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c107293e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.stackup.create_symmetric_stackup(\n",
+ " layer_count=4,\n",
+ " inner_layer_thickness=\"18um\",\n",
+ " outer_layer_thickness=\"50um\",\n",
+ " dielectric_thickness=\"100um\",\n",
+ " dielectric_material=\"FR4_epoxy\",\n",
+ " soldermask=True,\n",
+ " soldermask_thickness=\"20um\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7f79263b",
+ "metadata": {},
+ "source": [
+ "## Create parameterized padstack definition"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cc9e583b",
+ "metadata": {},
+ "source": [
+ "Create signal via padstack definition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "47ad9fc0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp[\"$antipad\"] = \"0.7mm\"\n",
+ "edbapp.padstacks.create(\n",
+ " padstackname=\"svia\", holediam=\"0.3mm\", antipaddiam=\"$antipad\", paddiam=\"0.5mm\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5996bee0",
+ "metadata": {},
+ "source": [
+ "Create component pin padstack definition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75e78efa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.padstacks.create(\n",
+ " padstackname=\"comp_pin\",\n",
+ " paddiam=\"400um\",\n",
+ " antipaddiam=\"600um\",\n",
+ " start_layer=\"TOP\",\n",
+ " stop_layer=\"TOP\",\n",
+ " antipad_shape=\"Circle\",\n",
+ " has_hole=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "45fb2dac",
+ "metadata": {},
+ "source": [
+ "## Review stackup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6dbe6662",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.stackup.plot(plot_definitions=\"svia\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fa6f766c",
+ "metadata": {},
+ "source": [
+ "## Create ground planes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "390adc43",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "board_width = \"22mm\"\n",
+ "board_length = \"18mm\"\n",
+ "board_center_point = [0, \"5mm\"]\n",
+ "\n",
+ "gnd_l2 = edbapp.modeler.create_rectangle(\n",
+ " layer_name=\"L2\",\n",
+ " net_name=\"GND\",\n",
+ " center_point=board_center_point,\n",
+ " width=board_width,\n",
+ " height=board_length,\n",
+ " representation_type=\"CenterWidthHeight\",\n",
+ " corner_radius=\"0mm\",\n",
+ " rotation=\"0deg\",\n",
+ ")\n",
+ "\n",
+ "gnd_l3 = edbapp.modeler.create_rectangle(\n",
+ " layer_name=\"L3\",\n",
+ " net_name=\"GND\",\n",
+ " center_point=board_center_point,\n",
+ " width=board_width,\n",
+ " height=board_length,\n",
+ " representation_type=\"CenterWidthHeight\",\n",
+ " corner_radius=\"0mm\",\n",
+ " rotation=\"0deg\",\n",
+ ")\n",
+ "\n",
+ "gnd_bottom = edbapp.modeler.create_rectangle(\n",
+ " layer_name=\"BOT\",\n",
+ " net_name=\"GND\",\n",
+ " center_point=board_center_point,\n",
+ " width=board_width,\n",
+ " height=board_length,\n",
+ " representation_type=\"CenterWidthHeight\",\n",
+ " corner_radius=\"0mm\",\n",
+ " rotation=\"0deg\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5255f095",
+ "metadata": {},
+ "source": [
+ "## Create a component"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "808843bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.padstacks.place(\n",
+ " position=[0, 0],\n",
+ " definition_name=\"comp_pin\",\n",
+ " net_name=\"SIG\",\n",
+ " is_pin=True,\n",
+ " via_name=\"1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a626b90c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "comp_pins = [\n",
+ " edbapp.padstacks.place(\n",
+ " position=[\"-6mm\", 0],\n",
+ " definition_name=\"comp_pin\",\n",
+ " net_name=\"GND\",\n",
+ " is_pin=True,\n",
+ " via_name=\"2\",\n",
+ " ),\n",
+ " edbapp.padstacks.place(\n",
+ " position=[\"6mm\", 0],\n",
+ " definition_name=\"comp_pin\",\n",
+ " net_name=\"GND\",\n",
+ " is_pin=True,\n",
+ " via_name=\"3\",\n",
+ " ),\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b82ab47b",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "comp_u1 = edbapp.components.create(\n",
+ " pins=comp_pins,\n",
+ " component_name=\"U1\",\n",
+ " component_part_name=\"BGA\",\n",
+ " placement_layer=\"TOP\",\n",
+ ")\n",
+ "comp_u1.create_clearance_on_component(extra_soldermask_clearance=3.5e-3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf9a37cc",
+ "metadata": {},
+ "source": [
+ "## Place vias"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca2096a1",
+ "metadata": {},
+ "source": [
+ "Place a signal via."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aed1a0f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.padstacks.place(\n",
+ " position=[0, 0], definition_name=\"svia\", net_name=\"SIG\", is_pin=False\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10e1916d",
+ "metadata": {},
+ "source": [
+ "Place ground stitching vias."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be1742c7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.padstacks.place(\n",
+ " position=[\"-1mm\", 0], definition_name=\"svia\", net_name=\"GND\", is_pin=False\n",
+ ")\n",
+ "edbapp.padstacks.place(\n",
+ " position=[\"1mm\", 0], definition_name=\"svia\", net_name=\"GND\", is_pin=False\n",
+ ")\n",
+ "edbapp.padstacks.place(\n",
+ " position=[0, \"-1mm\"], definition_name=\"svia\", net_name=\"GND\", is_pin=False\n",
+ ")\n",
+ "edbapp.padstacks.place(\n",
+ " position=[0, \"1mm\"], definition_name=\"svia\", net_name=\"GND\", is_pin=False\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d8cc02a",
+ "metadata": {},
+ "source": [
+ "## Create signal traces"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb6eba82",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp[\"width\"] = \"0.15mm\"\n",
+ "edbapp[\"gap\"] = \"0.1mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bde88f54",
+ "metadata": {},
+ "source": [
+ "Create signal fanout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a685928",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sig_trace = edbapp.modeler.create_trace(\n",
+ " path_list=[[0, 0]],\n",
+ " layer_name=\"BOT\",\n",
+ " width=\"width\",\n",
+ " net_name=\"SIG\",\n",
+ " start_cap_style=\"Round\",\n",
+ " end_cap_style=\"Round\",\n",
+ " corner_style=\"Round\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dc050736",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sig_trace.add_point(x=\"0.5mm\", y=\"0.5mm\", incremental=True)\n",
+ "sig_trace.add_point(x=0, y=\"1mm\", incremental=True)\n",
+ "sig_trace.add_point(x=\"-0.5mm\", y=\"0.5mm\", incremental=True)\n",
+ "sig_trace.add_point(x=0, y=\"1mm\", incremental=True)\n",
+ "sig_path = sig_trace.get_center_line()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3ffb929b",
+ "metadata": {},
+ "source": [
+ "Create coplanar waveguide with ground with ground stitching vias."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8b9152aa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sig2_trace = edbapp.modeler.create_trace(\n",
+ " path_list=[sig_path[-1]],\n",
+ " layer_name=\"BOT\",\n",
+ " width=\"width\",\n",
+ " net_name=\"SIG\",\n",
+ " start_cap_style=\"Round\",\n",
+ " end_cap_style=\"Flat\",\n",
+ " corner_style=\"Round\",\n",
+ ")\n",
+ "sig2_trace.add_point(x=0, y=\"6mm\", incremental=True)\n",
+ "sig2_trace.create_via_fence(distance=\"0.5mm\", gap=\"1mm\", padstack_name=\"svia\")\n",
+ "sig2_trace.add_point(x=0, y=\"1mm\", incremental=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3b89ac4",
+ "metadata": {},
+ "source": [
+ "Create trace-to-ground clearance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7a1d4131",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sig2_path = sig2_trace.get_center_line()\n",
+ "path_list = [sig_path, sig2_path]\n",
+ "for i in path_list:\n",
+ " void = edbapp.modeler.create_trace(\n",
+ " path_list=i,\n",
+ " layer_name=\"BOT\",\n",
+ " width=\"width+gap*2\",\n",
+ " start_cap_style=\"Round\",\n",
+ " end_cap_style=\"Round\",\n",
+ " corner_style=\"Round\",\n",
+ " )\n",
+ " edbapp.modeler.add_void(shape=gnd_bottom, void_shape=void)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ab34760",
+ "metadata": {},
+ "source": [
+ "Generate plot to review."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eba1f513",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.nets.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2247e0a",
+ "metadata": {},
+ "source": [
+ "## Create ports"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36270b08",
+ "metadata": {},
+ "source": [
+ "Create a wave port."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dba21cbc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sig2_trace.create_edge_port(\n",
+ " name=\"p1_wave_port\",\n",
+ " position=\"End\",\n",
+ " port_type=\"Wave\",\n",
+ " reference_layer=None,\n",
+ " horizontal_extent_factor=10,\n",
+ " vertical_extent_factor=10,\n",
+ " pec_launch_width=\"0.01mm\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cc942dce",
+ "metadata": {},
+ "source": [
+ "## Create HFSS analysis setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "046675a3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = edbapp.create_hfss_setup(\"Setup1\")\n",
+ "setup.set_solution_single_frequency(\"5GHz\", max_num_passes=1, max_delta_s=\"0.02\")\n",
+ "setup.hfss_solver_settings.order_basis = \"first\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e5dbdeb",
+ "metadata": {},
+ "source": [
+ "Add a frequency sweep to the setup.\n",
+ "\n",
+ "When the simulation results are to\n",
+ "be used for transient SPICE analysis, you should\n",
+ "use the following strategy:\n",
+ "\n",
+ "- DC point\n",
+ "- Logarithmic sweep from 1 kHz to 100 MHz\n",
+ "- Linear scale for higher frequencies"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "13533404",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup.add_frequency_sweep(\n",
+ " \"Sweep1\",\n",
+ " frequency_sweep=[\n",
+ " [\"log scale\", \"10MHz\", \"100MHz\", 3],\n",
+ " [\"linear scale\", \"0.1GHz\", \"5GHz\", \"0.2GHz\"],\n",
+ " ],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d175215",
+ "metadata": {},
+ "source": [
+ "## Save and close EDB"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0009d28f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edbapp.save()\n",
+ "edbapp.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d49def4",
+ "metadata": {},
+ "source": [
+ "# Analyze in HFSS 3D Layout"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1c8b378",
+ "metadata": {},
+ "source": [
+ "## Load EDB into HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6642eca4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d = Hfss3dLayout(aedb, version=AEDT_VERSION, non_graphical=NG_MODE, new_desktop=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5495477e",
+ "metadata": {},
+ "source": [
+ "## Place SMA RF connector"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "23910a70",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "comp = h3d.modeler.place_3d_component(\n",
+ " component_path=sma_rf_connector,\n",
+ " number_of_terminals=1,\n",
+ " placement_layer=\"TOP\",\n",
+ " component_name=\"sma_rf\",\n",
+ " pos_x=0,\n",
+ " pos_y=0,\n",
+ " create_ports=True,\n",
+ ")\n",
+ "comp.angle = \"90deg\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce24e432",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bfdd43b6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.save_project()\n",
+ "h3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08c1a2b9",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_dir.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ba7cd786",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout_parametrized.ipynb.txt b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout_parametrized.ipynb.txt
new file mode 100644
index 00000000..a62cf57f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/layout/signal_integrity/pre_layout_parametrized.ipynb.txt
@@ -0,0 +1,822 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "becc6e5a",
+ "metadata": {},
+ "source": [
+ "# Pre-layout Parameterized PCB\n",
+ "\n",
+ "This example shows how to use the EDB interface along with HFSS 3D Layout to create and solve a\n",
+ "parameterized layout. The layout shows a differential via transition on a printed circuit board\n",
+ "with back-to-back microstrip to stripline transitions.\n",
+ "The model is fully parameterized to enable investigation of the transition performance on the\n",
+ "many degrees of freedom.\n",
+ "\n",
+ "The resulting model is shown below\n",
+ "\n",
+ "![](\"_static\\pre_layout_parameterized_pcb.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cf9d875d",
+ "metadata": {},
+ "source": [
+ "## Preparation\n",
+ "Import the required packages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "73745dd0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "from ansys.aedt.core import Hfss3dLayout\n",
+ "from pyedb import Edb\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28bf4cfe",
+ "metadata": {},
+ "source": [
+ "## Define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4022175a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "39152bf4",
+ "metadata": {},
+ "source": [
+ "## Launch EDB"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76376d64",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")\n",
+ "aedb_path = os.path.join(temp_folder.name, \"pcb.aedb\")\n",
+ "edb = Edb(edbpath=aedb_path, edbversion=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adf990fe",
+ "metadata": {},
+ "source": [
+ "## Create layout\n",
+ "### Define the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8e0abbe2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "params = {\n",
+ " \"$ms_width\": \"0.4mm\",\n",
+ " \"$sl_width\": \"0.2mm\",\n",
+ " \"$ms_spacing\": \"0.2mm\",\n",
+ " \"$sl_spacing\": \"0.1mm\",\n",
+ " \"$via_spacing\": \"0.5mm\",\n",
+ " \"$via_diam\": \"0.3mm\",\n",
+ " \"$pad_diam\": \"0.6mm\",\n",
+ " \"$anti_pad_diam\": \"0.7mm\",\n",
+ " \"$pcb_len\": \"15mm\",\n",
+ " \"$pcb_w\": \"5mm\",\n",
+ " \"$x_size\": \"1.2mm\",\n",
+ " \"$y_size\": \"1mm\",\n",
+ " \"$corner_rad\": \"0.5mm\",\n",
+ "}\n",
+ "\n",
+ "for par_name in params:\n",
+ " edb.add_project_variable(par_name, params[par_name])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0bf1ac7",
+ "metadata": {},
+ "source": [
+ "### Create stackup\n",
+ "Define the stackup layers from bottom to top."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e99ebf71",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "layers = [\n",
+ " {\n",
+ " \"name\": \"bottom\",\n",
+ " \"layer_type\": \"signal\",\n",
+ " \"thickness\": \"35um\",\n",
+ " \"material\": \"copper\",\n",
+ " },\n",
+ " {\n",
+ " \"name\": \"diel_3\",\n",
+ " \"layer_type\": \"dielectric\",\n",
+ " \"thickness\": \"275um\",\n",
+ " \"material\": \"FR4_epoxy\",\n",
+ " },\n",
+ " {\n",
+ " \"name\": \"sig_2\",\n",
+ " \"layer_type\": \"signal\",\n",
+ " \"thickness\": \"35um\",\n",
+ " \"material\": \"copper\",\n",
+ " },\n",
+ " {\n",
+ " \"name\": \"diel_2\",\n",
+ " \"layer_type\": \"dielectric\",\n",
+ " \"thickness\": \"275um\",\n",
+ " \"material\": \"FR4_epoxy\",\n",
+ " },\n",
+ " {\n",
+ " \"name\": \"sig_1\",\n",
+ " \"layer_type\": \"signal\",\n",
+ " \"thickness\": \"35um\",\n",
+ " \"material\": \"copper\",\n",
+ " },\n",
+ " {\n",
+ " \"name\": \"diel_1\",\n",
+ " \"layer_type\": \"dielectric\",\n",
+ " \"thickness\": \"275um\",\n",
+ " \"material\": \"FR4_epoxy\",\n",
+ " },\n",
+ " {\"name\": \"top\", \"layer_type\": \"signal\", \"thickness\": \"35um\", \"material\": \"copper\"},\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ec49f92",
+ "metadata": {},
+ "source": [
+ "Define the bottom layer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e39c153d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "prev = None\n",
+ "for layer in layers:\n",
+ " edb.stackup.add_layer(\n",
+ " layer[\"name\"],\n",
+ " base_layer=prev,\n",
+ " layer_type=layer[\"layer_type\"],\n",
+ " thickness=layer[\"thickness\"],\n",
+ " material=layer[\"material\"],\n",
+ " )\n",
+ " prev = layer[\"name\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "af647387",
+ "metadata": {},
+ "source": [
+ "### Create a parametrized padstack for the signal via.\n",
+ "Create a padstack definition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bd0db260",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "signal_via_padstack = \"automated_via\"\n",
+ "edb.padstacks.create(\n",
+ " padstackname=signal_via_padstack,\n",
+ " holediam=\"$via_diam\",\n",
+ " paddiam=\"$pad_diam\",\n",
+ " antipaddiam=\"\",\n",
+ " antipad_shape=\"Bullet\",\n",
+ " x_size=\"$x_size\",\n",
+ " y_size=\"$y_size\",\n",
+ " corner_radius=\"$corner_rad\",\n",
+ " start_layer=layers[-1][\"name\"],\n",
+ " stop_layer=layers[-3][\"name\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9ad2eac0",
+ "metadata": {},
+ "source": [
+ "Assign net names. There are only two signal nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4f2fa23f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "net_p = \"p\"\n",
+ "net_n = \"n\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9001f1be",
+ "metadata": {},
+ "source": [
+ "Place the signal vias."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "494b0ee0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.padstacks.place(\n",
+ " position=[\"$pcb_len/3\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " definition_name=signal_via_padstack,\n",
+ " net_name=net_p,\n",
+ " via_name=\"\",\n",
+ " rotation=90.0,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bfe90f9e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.padstacks.place(\n",
+ " position=[\"2*$pcb_len/3\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " definition_name=signal_via_padstack,\n",
+ " net_name=net_p,\n",
+ " via_name=\"\",\n",
+ " rotation=90.0,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b5bbacb4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.padstacks.place(\n",
+ " position=[\"$pcb_len/3\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " definition_name=signal_via_padstack,\n",
+ " net_name=net_n,\n",
+ " via_name=\"\",\n",
+ " rotation=-90.0,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6bf3513f",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "edb.padstacks.place(\n",
+ " position=[\"2*$pcb_len/3\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " definition_name=signal_via_padstack,\n",
+ " net_name=net_n,\n",
+ " via_name=\"\",\n",
+ " rotation=-90.0,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05840d89",
+ "metadata": {},
+ "source": [
+ "### Draw parametrized traces\n",
+ "\n",
+ "Trace width and the routing (Microstrip-Stripline-Microstrip).\n",
+ "Applies to both p and n nets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f7605756",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Trace width, n and p\n",
+ "width = [\"$ms_width\", \"$sl_width\", \"$ms_width\"]\n",
+ "# Routing layer, n and p\n",
+ "route_layer = [layers[-1][\"name\"], layers[4][\"name\"], layers[-1][\"name\"]]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0fd82b57",
+ "metadata": {},
+ "source": [
+ "Define points for three traces in the \"p\" net"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5a31b39b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "points_p = [\n",
+ " [\n",
+ " [\"0.0\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len/3-2*$via_spacing\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len/3-$via_spacing\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " ],\n",
+ " [\n",
+ " [\"$pcb_len/3\", \"($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3+$via_spacing\", \"($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3+2*$via_spacing\", \"($sl_width+$sl_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3-2*$via_spacing\", \"($sl_width+$sl_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3-$via_spacing\", \"($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3\", \"($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " ],\n",
+ " [\n",
+ " [\"2*$pcb_len/3\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3+$via_spacing\", \"($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3+2*$via_spacing\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " ],\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed94054e",
+ "metadata": {},
+ "source": [
+ "Define points for three traces in the \"n\" net"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f3593fc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "points_n = [\n",
+ " [\n",
+ " [\"0.0\", \"-($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len/3-2*$via_spacing\", \"-($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len/3-$via_spacing\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " ],\n",
+ " [\n",
+ " [\"$pcb_len/3\", \"-($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3+$via_spacing\", \"-($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"$pcb_len/3+2*$via_spacing\", \"-($ms_width+$sl_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3-2*$via_spacing\", \"-($ms_width+$sl_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3-$via_spacing\", \"-($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3\", \"-($ms_width+$sl_spacing+$via_spacing)/2\"],\n",
+ " ],\n",
+ " [\n",
+ " [\"2*$pcb_len/3\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3 + $via_spacing\", \"-($ms_width+$ms_spacing+$via_spacing)/2\"],\n",
+ " [\"2*$pcb_len/3 + 2*$via_spacing\", \"-($ms_width+$ms_spacing)/2\"],\n",
+ " [\"$pcb_len\", \"-($ms_width + $ms_spacing)/2\"],\n",
+ " ],\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a3ddb26",
+ "metadata": {},
+ "source": [
+ "Add traces to the EDB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9d67b8bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trace_p = []\n",
+ "trace_n = []\n",
+ "for n in range(len(points_p)):\n",
+ " trace_p.append(\n",
+ " edb.modeler.create_trace(\n",
+ " points_p[n], route_layer[n], width[n], net_p, \"Flat\", \"Flat\"\n",
+ " )\n",
+ " )\n",
+ " trace_n.append(\n",
+ " edb.modeler.create_trace(\n",
+ " points_n[n], route_layer[n], width[n], net_n, \"Flat\", \"Flat\"\n",
+ " )\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7edc4a3",
+ "metadata": {},
+ "source": [
+ "Create the wave ports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1add7103",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.hfss.create_differential_wave_port(\n",
+ " trace_p[0].id,\n",
+ " [\"0.0\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " trace_n[0].id,\n",
+ " [\"0.0\", \"-($ms_width+$ms_spacing)/2\"],\n",
+ " \"wave_port_1\",\n",
+ ")\n",
+ "edb.hfss.create_differential_wave_port(\n",
+ " trace_p[2].id,\n",
+ " [\"$pcb_len\", \"($ms_width+$ms_spacing)/2\"],\n",
+ " trace_n[2].id,\n",
+ " [\"$pcb_len\", \"-($ms_width + $ms_spacing)/2\"],\n",
+ " \"wave_port_2\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d25e69d8",
+ "metadata": {},
+ "source": [
+ "Draw a conducting rectangle on the the ground layers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ac2e5de2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "gnd_poly = [\n",
+ " [0.0, \"-$pcb_w/2\"],\n",
+ " [\"$pcb_len\", \"-$pcb_w/2\"],\n",
+ " [\"$pcb_len\", \"$pcb_w/2\"],\n",
+ " [0.0, \"$pcb_w/2\"],\n",
+ "]\n",
+ "gnd_shape = edb.modeler.Shape(\"polygon\", points=gnd_poly)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6698216",
+ "metadata": {},
+ "source": [
+ "Void in ground for traces on the signal routing layer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1a671908",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "void_poly = [\n",
+ " [\n",
+ " \"$pcb_len/3\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2-$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"$pcb_len/3 + $via_spacing\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2-$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"$pcb_len/3 + 2*$via_spacing\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3 - 2*$via_spacing\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3 - $via_spacing\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2-$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3\",\n",
+ " \"-($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2-$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2+$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3 - $via_spacing\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2+$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"2*$pcb_len/3 - 2*$via_spacing\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"$pcb_len/3 + 2*$via_spacing\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"$pcb_len/3 + $via_spacing\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2+$via_spacing/2\",\n",
+ " ],\n",
+ " [\n",
+ " \"$pcb_len/3\",\n",
+ " \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2+$via_spacing/2\",\n",
+ " ],\n",
+ " [\"$pcb_len/3\", \"($ms_width+$ms_spacing+$via_spacing+$anti_pad_diam)/2\"],\n",
+ "]\n",
+ "\n",
+ "void_shape = edb.modeler.Shape(\"polygon\", points=void_poly)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38638279",
+ "metadata": {},
+ "source": [
+ "Add ground conductors."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae769a34",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for layer in layers[:-1:2]:\n",
+ "\n",
+ " # add void if the layer is the signal routing layer.\n",
+ " void = [void_shape] if layer[\"name\"] == route_layer[1] else []\n",
+ "\n",
+ " edb.modeler.create_polygon(\n",
+ " main_shape=gnd_shape, layer_name=layer[\"name\"], voids=void, net_name=\"gnd\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "52056954",
+ "metadata": {},
+ "source": [
+ "Plot the layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d7ff90ba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.nets.plot(None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fff22bd3",
+ "metadata": {},
+ "source": [
+ "Save the EDB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f8676473",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "edb.save_edb()\n",
+ "edb.close_edb()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f5f48b93",
+ "metadata": {},
+ "source": [
+ "## Open the project in HFSS 3D Layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0362e354",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d = Hfss3dLayout(\n",
+ " project=aedb_path,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90745913",
+ "metadata": {},
+ "source": [
+ "### Add a HFSS simulation setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fcdfab05",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = h3d.create_setup()\n",
+ "setup.props[\"AdaptiveSettings\"][\"SingleFrequencyDataList\"][\"AdaptiveFrequencyData\"][\n",
+ " \"MaxPasses\"\n",
+ "] = 3\n",
+ "\n",
+ "h3d.create_linear_count_sweep(\n",
+ " setup=setup.name,\n",
+ " unit=\"GHz\",\n",
+ " start_frequency=0,\n",
+ " stop_frequency=10,\n",
+ " num_of_freq_points=1001,\n",
+ " name=\"sweep1\",\n",
+ " sweep_type=\"Interpolating\",\n",
+ " interpolation_tol_percent=1,\n",
+ " interpolation_max_solutions=255,\n",
+ " save_fields=False,\n",
+ " use_q3d_for_dc=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adc7eb86",
+ "metadata": {},
+ "source": [
+ "### Define the differential pairs to used to calculate differential and common mode s-parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "233bf88b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.set_differential_pair(\n",
+ " differential_mode=\"In\", assignment=\"wave_port_1:T1\", reference=\"wave_port_1:T2\"\n",
+ ")\n",
+ "h3d.set_differential_pair(\n",
+ " differential_mode=\"Out\", assignment=\"wave_port_2:T1\", reference=\"wave_port_2:T2\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ed20748",
+ "metadata": {},
+ "source": [
+ "Solve the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "28f5c925",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdc090d4",
+ "metadata": {},
+ "source": [
+ "Plot the results and shut down AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ace0685",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions = h3d.post.get_solution_data(\n",
+ " expressions=[\"dB(S(In,In))\", \"dB(S(In,Out))\"], context=\"Differential Pairs\"\n",
+ ")\n",
+ "solutions.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e183114",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e4f8a28c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h3d.save_project()\n",
+ "h3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25e4fb21",
+ "metadata": {},
+ "source": [
+ "Note that the ground nets are only connected to each other due\n",
+ "to the wave ports. The problem with poor grounding can be seen in the\n",
+ "S-parameters. This example can be downloaded as a Jupyter Notebook, so\n",
+ "you can modify it. Try changing parameters or adding ground vias to improve performance.\n",
+ "\n",
+ "The final cell cleans up the temporary directory, removing all files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6021cdfb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/multiphysics/hfss_mechanical.ipynb.txt b/version/dev/_sources/examples/high_frequency/multiphysics/hfss_mechanical.ipynb.txt
new file mode 100644
index 00000000..458cb82f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/multiphysics/hfss_mechanical.ipynb.txt
@@ -0,0 +1,391 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f7591cc7",
+ "metadata": {},
+ "source": [
+ "# HFSS-Mechanical multiphysics analysis\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a multiphysics workflow that\n",
+ "includes Circuit, HFSS, and Mechanical.\n",
+ "\n",
+ "Keywords: **Multiphysics**, **HFSS**, **Mechanical AEDT**, **Circuit**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f8c4e69b",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "140111bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22e89ee8",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "affc88f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3afc3e0a",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0759a8a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "19e33010",
+ "metadata": {},
+ "source": [
+ "## Download and open project\n",
+ "\n",
+ "Download and open the project. Save it to the temporary folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "21e4a117",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = ansys.aedt.core.downloads.download_via_wizard(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3771976e",
+ "metadata": {},
+ "source": [
+ "## Start HFSS\n",
+ "\n",
+ "Initialize HFSS."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1e62fd55",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "hfss.change_material_override(True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3c5059c4",
+ "metadata": {},
+ "source": [
+ "## Initialize Circuit\n",
+ "\n",
+ "Initialize Circuit and add the HFSS dynamic link component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d99d0261",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit = ansys.aedt.core.Circuit(version=AEDT_VERSION)\n",
+ "hfss_comp = circuit.modeler.schematic.add_subcircuit_dynamic_link(pyaedt_app=hfss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "87648a94",
+ "metadata": {},
+ "source": [
+ "## Set up dynamic link options\n",
+ "\n",
+ "Set up dynamic link options. The argument for the ``set_sim_option_on_hfss_subcircuit()``\n",
+ "method can be the component name, component ID, or component object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7876a58e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.modeler.schematic.refresh_dynamic_link(name=hfss_comp.composed_name)\n",
+ "circuit.modeler.schematic.set_sim_option_on_hfss_subcircuit(component=hfss_comp)\n",
+ "hfss_setup_name = hfss.setups[0].name + \" : \" + hfss.setups[0].sweeps[0].name\n",
+ "circuit.modeler.schematic.set_sim_solution_on_hfss_subcircuit(\n",
+ " component=hfss_comp.composed_name, solution_name=hfss_setup_name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66bb7d71",
+ "metadata": {},
+ "source": [
+ "## Create ports and excitations\n",
+ "\n",
+ "Create ports and excitations. Find component pin locations and create interface\n",
+ "ports on them. Define the voltage source on the input port."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "86726827",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.modeler.schematic.create_interface_port(\n",
+ " name=\"Excitation_1\",\n",
+ " location=[hfss_comp.pins[0].location[0], hfss_comp.pins[0].location[1]],\n",
+ ")\n",
+ "circuit.modeler.schematic.create_interface_port(\n",
+ " name=\"Excitation_2\",\n",
+ " location=[hfss_comp.pins[1].location[0], hfss_comp.pins[1].location[1]],\n",
+ ")\n",
+ "circuit.modeler.schematic.create_interface_port(\n",
+ " name=\"Port_1\",\n",
+ " location=[hfss_comp.pins[2].location[0], hfss_comp.pins[2].location[1]],\n",
+ ")\n",
+ "circuit.modeler.schematic.create_interface_port(\n",
+ " name=\"Port_2\",\n",
+ " location=[hfss_comp.pins[3].location[0], hfss_comp.pins[3].location[1]],\n",
+ ")\n",
+ "\n",
+ "ports_list = [\"Excitation_1\", \"Excitation_2\"]\n",
+ "source = circuit.assign_voltage_sinusoidal_excitation_to_ports(ports_list)\n",
+ "source.ac_magnitude = 1\n",
+ "source.phase = 0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e257b3e",
+ "metadata": {},
+ "source": [
+ "## Create setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7ad711dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup_name = \"MySetup\"\n",
+ "LNA_setup = circuit.create_setup(name=setup_name)\n",
+ "sweep_list = [\"LINC\", str(4.3) + \"GHz\", str(4.4) + \"GHz\", str(1001)]\n",
+ "LNA_setup.props[\"SweepDefinition\"][\"Data\"] = \" \".join(sweep_list)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03314e19",
+ "metadata": {},
+ "source": [
+ "## Solve and push excitations\n",
+ "\n",
+ "Solve the circuit and push excitations to the HFSS model to calculate the\n",
+ "correct value of losses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "057cf70c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "circuit.analyze(cores=NUM_CORES)\n",
+ "circuit.push_excitations(instance=\"S1\", setup=setup_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57febed1",
+ "metadata": {},
+ "source": [
+ "## Start Mechanical\n",
+ "\n",
+ "Start Mechanical and copy bodies from the HFSS project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3ccb0ce6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech = ansys.aedt.core.Mechanical(version=AEDT_VERSION)\n",
+ "mech.copy_solid_bodies_from(design=hfss)\n",
+ "mech.change_material_override(True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c7a2424",
+ "metadata": {},
+ "source": [
+ "## Get losses from HFSS and assign convection to Mechanical"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "981ab267",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.assign_em_losses(\n",
+ " design=hfss.design_name,\n",
+ " setup=hfss.setups[0].name,\n",
+ " sweep=\"LastAdaptive\",\n",
+ " map_frequency=hfss.setups[0].props[\"Frequency\"],\n",
+ " surface_objects=hfss.get_all_conductors_names(),\n",
+ ")\n",
+ "diels = [\"1_pd\", \"2_pd\", \"3_pd\", \"4_pd\", \"5_pd\"]\n",
+ "for el in diels:\n",
+ " mech.assign_uniform_convection(\n",
+ " assignment=[mech.modeler[el].top_face_y, mech.modeler[el].bottom_face_y],\n",
+ " convection_value=3,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d99625f5",
+ "metadata": {},
+ "source": [
+ "## Solve and plot thermal results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ba56c5a0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.create_setup()\n",
+ "mech.save_project()\n",
+ "mech.analyze(cores=NUM_CORES)\n",
+ "surfaces = []\n",
+ "for name in mech.get_all_conductors_names():\n",
+ " surfaces.extend(mech.modeler.get_object_faces(name))\n",
+ "mech.post.create_fieldplot_surface(assignment=surfaces, quantity=\"Temperature\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e008a3c4",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cd46cd23",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.save_project()\n",
+ "mech.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "515d1552",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f8b950d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/multiphysics/index.rst.txt b/version/dev/_sources/examples/high_frequency/multiphysics/index.rst.txt
new file mode 100644
index 00000000..9b6d012f
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/multiphysics/index.rst.txt
@@ -0,0 +1,102 @@
+Multiphysics
+~~~~~~~~~~~~
+
+These examples use PyAEDT to show some multiphysics applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: HFSS-Mechanical MRI analysis
+ :padding: 2 2 2 2
+ :link: mri
+ :link-type: doc
+
+ .. image:: _static/mri.png
+ :alt: MRI
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses a coil tuned to 63.8 MHz to determine the temperature rise in a gel phantom near
+ an implant given a background SAR of 1 W/kg.
+
+ .. grid-item-card:: HFSS-Mechanical multiphysics analysis
+ :padding: 2 2 2 2
+ :link: hfss_mechanical
+ :link-type: doc
+
+ .. image:: _static/hfss_mechanical.png
+ :alt: HFSS Mechanical
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a multiphysics workflow that includes Circuit, HFSS, and Mechanical.
+
+
+ .. grid-item-card:: Import of a PCB and its components via IDF and EDB
+ :padding: 2 2 2 2
+ :link: ../../electrothermal/ecad_import
+ :link-type: doc
+
+ .. image:: ../../electrothermal/_static/ecad.png
+ :alt: Icepak ECAD
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to import a PCB and its components using IDF files (LDB and BDF).
+ You can also use a combination of EMN and EMP files in a similar way.
+
+ .. grid-item-card:: Coaxial
+ :padding: 2 2 2 2
+ :link: ../../electrothermal/coaxial_hfss_icepak
+ :link-type: doc
+
+ .. image:: ../../electrothermal/_static/coaxial.png
+ :alt: Coaxial
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a project from scratch in HFSS and Icepak.
+
+ .. grid-item-card:: Electrothermal analysis
+ :padding: 2 2 2 2
+ :link: ../../electrothermal/electrothermal
+ :link-type: doc
+
+ .. image:: ../../electrothermal/_static/electrothermal.png
+ :alt: Electrothermal
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use the EDB for DC IR analysis and electrothermal analysis.
+ The EDB is loaded into SIwave for analysis and postprocessing.
+ In the end, an Icepak project is exported from SIwave.
+
+ .. grid-item-card:: Circuit-HFSS-Icepak coupling workflow
+ :padding: 2 2 2 2
+ :link: ../../electrothermal/icepak_circuit_hfss_coupling
+ :link-type: doc
+
+ .. image:: ../../electrothermal/_static/ring.png
+ :alt: Ring
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to create a two-way coupling between HFSS and Icepak.
+
+
+ .. toctree::
+ :hidden:
+
+ mri
+ hfss_mechanical
+ ../../electrothermal/ecad_import
+ ../../electrothermal/coaxial_hfss_icepak
+ ../../electrothermal/electrothermal
+ ../../electrothermal/icepak_circuit_hfss_coupling
+
diff --git a/version/dev/_sources/examples/high_frequency/multiphysics/mri.ipynb.txt b/version/dev/_sources/examples/high_frequency/multiphysics/mri.ipynb.txt
new file mode 100644
index 00000000..0fb726ff
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/multiphysics/mri.ipynb.txt
@@ -0,0 +1,738 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3208039e",
+ "metadata": {},
+ "source": [
+ "# HFSS-Mechanical MRI analysis\n",
+ "\n",
+ "This example uses a coil tuned to 63.8 MHz to determine the temperature\n",
+ "rise in a gel phantom near an implant given a background SAR of 1 W/kg.\n",
+ "\n",
+ "Here is the workflow:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03a4d711",
+ "metadata": {},
+ "source": [
+ "Step 1: Simulate the coil loaded by the empty phantom:\n",
+ "Scale input to coil ports to produce desired background SAR of 1 W/kg at the location\n",
+ "that is to contain the implant."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b52b262b",
+ "metadata": {},
+ "source": [
+ "Step 2: Simulate the coil loaded by the phantom containing the implant in the proper location:\n",
+ "View SAR in the tissue surrounding implant."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73b6045c",
+ "metadata": {},
+ "source": [
+ "Step 3: Thermal simulation:\n",
+ "Link HFSS to the transient thermal solver to find the temperature rise in the tissue near the implant\n",
+ "versus the time.\n",
+ "\n",
+ "Keywords: **multiphysics**, **HFSS**, **Mechanical AEDT**, **Circuit**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aabb1a45",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "854a8729",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os.path\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "from ansys.aedt.core import Hfss, Icepak, Mechanical, downloads\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4227de24",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85e2f752",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3cd08010",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "363bcd64",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c2f4450",
+ "metadata": {},
+ "source": [
+ "## Load project\n",
+ "\n",
+ "Open AEDT and the ``background_SAR.aedt`` project. This project\n",
+ "contains the phantom and airbox. The phantom consists of two objects: ``phantom`` and ``implant_box``.\n",
+ "\n",
+ "Separate objects are used to selectively assign mesh operations.\n",
+ "Material properties defined in this project already contain electrical and thermal properties."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fc6f33ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_path = downloads.download_file(source=\"mri\", destination=temp_folder.name)\n",
+ "project_name = os.path.join(project_path, \"background_SAR.aedt\")\n",
+ "hfss = Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "166d8432",
+ "metadata": {},
+ "source": [
+ "## Insert 3D component\n",
+ "\n",
+ "The MRI coil is saved as a separate 3D component."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "abe69f5c",
+ "metadata": {},
+ "source": [
+ "‒ 3D components store geometry (including parameters),\n",
+ "material properties, boundary conditions, mesh assignments,\n",
+ "and excitations.\n",
+ "‒ 3D components make it easy to reuse and share parts of a simulation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff75eb1b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "component_file = os.path.join(project_path, \"coil.a3dcomp\")\n",
+ "hfss.modeler.insert_3d_component(input_file=component_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce6f2b43",
+ "metadata": {},
+ "source": [
+ "## Define convergence criteria\n",
+ "\n",
+ " On the **Expression Cache** tab, define additional convergence criteria for self\n",
+ " impedance of the four coil ports."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27d7af8d",
+ "metadata": {},
+ "source": [
+ "Set each of these convergence criteria to 2.5 ohm.\n",
+ "This example limits the number of passes to two to reduce simulation time."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d917bdc7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "im_traces = hfss.get_traces_for_plot(\n",
+ " get_mutual_terms=False, category=\"im(Z\", first_element_filter=\"Coil1_p*\"\n",
+ ")\n",
+ "\n",
+ "hfss.setups[0].enable_expression_cache(\n",
+ " report_type=\"Modal Solution Data\",\n",
+ " expressions=im_traces,\n",
+ " isconvergence=True,\n",
+ " isrelativeconvergence=False,\n",
+ " conv_criteria=2.5,\n",
+ " use_cache_for_freq=False,\n",
+ ")\n",
+ "hfss.setups[0].props[\"MaximumPasses\"] = 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "74a6e3cc",
+ "metadata": {},
+ "source": [
+ "## Edit sources\n",
+ "\n",
+ "The 3D component of the MRI coil contains all the ports,\n",
+ "but the sources for these ports are not yet defined.\n",
+ "Browse to and select the ``sources.csv`` file.\n",
+ "The sources in this file were determined by tuning the coil at 63.8 MHz.\n",
+ "Notice that ``input_scale`` is a multiplier that lets you quickly adjust the coil excitation power."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "edfbb8d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.edit_sources_from_file(os.path.join(project_path, \"sources.csv\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "15ef39a1",
+ "metadata": {},
+ "source": [
+ "## Run simulation\n",
+ "\n",
+ "Save and analyze the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a474b48c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project(file_name=os.path.join(project_path, \"solved.aedt\"))\n",
+ "hfss.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e11377b",
+ "metadata": {},
+ "source": [
+ "## Plot SAR on cut plane in phantom\n",
+ "\n",
+ "Ensure that the SAR averaging method is set to ``Gridless``.\n",
+ "Plot ``Average_SAR`` on the global YZ plane.\n",
+ "Draw ``Point1`` at the origin of the implant coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "45ac4785",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.sar_setup(\n",
+ " assignment=-1,\n",
+ " average_sar_method=1,\n",
+ " tissue_mass=1,\n",
+ " material_density=1,\n",
+ ")\n",
+ "hfss.post.create_fieldplot_cutplane(\n",
+ " assignment=[\"implant:YZ\"], quantity=\"Average_SAR\", filter_objects=[\"implant_box\"]\n",
+ ")\n",
+ "\n",
+ "hfss.modeler.set_working_coordinate_system(\"implant\")\n",
+ "hfss.modeler.create_point(position=[0, 0, 0], name=\"Point1\")\n",
+ "\n",
+ "plot = hfss.post.plot_field(\n",
+ " quantity=\"Average_SAR\",\n",
+ " assignment=\"implant:YZ\",\n",
+ " plot_type=\"CutPlane\",\n",
+ " show_legend=False,\n",
+ " filter_objects=[\"implant_box\"],\n",
+ " export_path=hfss.working_directory,\n",
+ " show=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6f38416e",
+ "metadata": {},
+ "source": [
+ "## Adjust input Power to MRI coil\n",
+ "\n",
+ "Adjust the MRI coil’s input power so that the average SAR at ``Point1`` is 1 W/kg.\n",
+ "Note that the SAR and input power are linearly related.\n",
+ "\n",
+ "To determine therequired input, calculate\n",
+ "``input_scale = 1/AverageSAR`` at ``Point1``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "29f331bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sol_data = hfss.post.get_solution_data(\n",
+ " expressions=\"Average_SAR\",\n",
+ " primary_sweep_variable=\"Freq\",\n",
+ " context=\"Point1\",\n",
+ " report_category=\"Fields\",\n",
+ ")\n",
+ "sol_data.data_real()\n",
+ "\n",
+ "hfss[\"input_scale\"] = 1 / sol_data.data_real()[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "13afee88",
+ "metadata": {},
+ "source": [
+ "## Analyze phantom with implant\n",
+ "\n",
+ "Import the implant geometry.\n",
+ "Subtract the rod from the implant box.\n",
+ "Assign titanium to the imported object rod.\n",
+ "Analyze the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5d922873",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.import_3d_cad(os.path.join(project_path, \"implant_rod.sat\"))\n",
+ "\n",
+ "hfss.modeler[\"implant_box\"].subtract(tool_list=\"rod\", keep_originals=True)\n",
+ "hfss.modeler[\"rod\"].material_name = \"titanium\"\n",
+ "hfss.analyze(cores=NUM_CORES)\n",
+ "hfss.save_project()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5c6f5328",
+ "metadata": {},
+ "source": [
+ "## Run a thermal simulation\n",
+ "\n",
+ "Initialize a new Mechanical transient thermal analysis.\n",
+ "This type of analysis is available in AEDT in 2023 R2 and later as a beta feature."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bc3f319a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech = Mechanical(solution_type=\"Transient Thermal\", version=AEDT_VERSION)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "07ab994c",
+ "metadata": {},
+ "source": [
+ "## Copy geometries\n",
+ "\n",
+ "Copy bodies from the HFSS project. The 3D component is not copied."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0d8bf704",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.copy_solid_bodies_from(hfss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3410bb87",
+ "metadata": {},
+ "source": [
+ "## Link sources to EM losses\n",
+ "\n",
+ "Link sources to the EM losses.\n",
+ "Assign external convection."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dc355b88",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "exc = mech.assign_em_losses(\n",
+ " design=hfss.design_name,\n",
+ " setup=hfss.setups[0].name,\n",
+ " sweep=\"LastAdaptive\",\n",
+ " map_frequency=hfss.setups[0].props[\"Frequency\"],\n",
+ " surface_objects=mech.get_all_conductors_names(),\n",
+ ")\n",
+ "mech.assign_uniform_convection(\n",
+ " assignment=mech.modeler[\"Region\"].faces, convection_value=1\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9916e2b9",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup and edit properties."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dcaa866a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = mech.create_setup()\n",
+ "# setup.add_mesh_link(\"backgroundSAR\")\n",
+ "# mech.create_dataset1d_design(\"PowerMap\", [0, 239, 240, 360], [1, 1, 0, 0])\n",
+ "# exc.props[\"LossMultiplier\"] = \"pwl(PowerMap,Time)\"\n",
+ "\n",
+ "mech.modeler.set_working_coordinate_system(\"implant\")\n",
+ "mech.modeler.create_point(position=[0, 0, 0], name=\"Point1\")\n",
+ "setup.props[\"Stop Time\"] = 30\n",
+ "setup.props[\"Time Step\"] = \"10s\"\n",
+ "setup.props[\"SaveFieldsType\"] = \"Every N Steps\"\n",
+ "setup.props[\"N Steps\"] = \"2\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e0c2362",
+ "metadata": {},
+ "source": [
+ "## Analyze project\n",
+ "\n",
+ "Analyze the Mechanical project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8c0203db",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dfe6f1d5",
+ "metadata": {},
+ "source": [
+ "## Plot fields\n",
+ "\n",
+ "Plot the temperature on cut plane.\n",
+ "Plot the temperature on the point."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6eb0aa7f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mech.post.create_fieldplot_cutplane(\n",
+ " assignment=[\"implant:YZ\"],\n",
+ " quantity=\"Temperature\",\n",
+ " filter_objects=[\"implant_box\"],\n",
+ " intrinsics={\"Time\": \"10s\"},\n",
+ ")\n",
+ "mech.save_project()\n",
+ "\n",
+ "data = mech.post.get_solution_data(\n",
+ " expressions=\"Temperature\",\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " context=\"Point1\",\n",
+ " report_category=\"Fields\",\n",
+ ")\n",
+ "data.plot()\n",
+ "\n",
+ "mech.post.plot_animated_field(\n",
+ " quantity=\"Temperature\",\n",
+ " assignment=\"implant:YZ\",\n",
+ " plot_type=\"CutPlane\",\n",
+ " intrinsics={\"Time\": \"10s\"},\n",
+ " variation_variable=\"Time\",\n",
+ " variations=[\"10s\", \"30s\"],\n",
+ " filter_objects=[\"implant_box\"],\n",
+ " show=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b854284",
+ "metadata": {},
+ "source": [
+ "## Run a new thermal simulation\n",
+ "\n",
+ "Initialize a new Icepak transient thermal analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e52c91c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = Icepak(solution_type=\"Transient\", version=AEDT_VERSION)\n",
+ "ipk.design_solutions.problem_type = \"TemperatureOnly\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ea8cc08",
+ "metadata": {},
+ "source": [
+ "## Copy geometries\n",
+ "\n",
+ "Copy bodies from the HFSS project. The 3D component is not copied."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eedcdf44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler.delete(\"Region\")\n",
+ "ipk.copy_solid_bodies_from(hfss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ef6402e3",
+ "metadata": {},
+ "source": [
+ "## Link sources to EM losses\n",
+ "\n",
+ "Link sources to the EM losses.\n",
+ "Assign external convection."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "562d6754",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assign_em_losses(\n",
+ " design=hfss.design_name,\n",
+ " setup=hfss.setups[0].name,\n",
+ " sweep=\"LastAdaptive\",\n",
+ " map_frequency=hfss.setups[0].props[\"Frequency\"],\n",
+ " surface_objects=ipk.get_all_conductors_names(),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7dcca430",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup and edit properties.\n",
+ "Simulation takes 30 seconds."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ad562d6c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = ipk.create_setup()\n",
+ "\n",
+ "setup.props[\"Stop Time\"] = 30\n",
+ "setup.props[\"N Steps\"] = 2\n",
+ "setup.props[\"Time Step\"] = 5\n",
+ "setup.props[\"Convergence Criteria - Energy\"] = 1e-12"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a59a054d",
+ "metadata": {},
+ "source": [
+ "## Create mesh region\n",
+ "\n",
+ "Create a mesh region and change the accuracy level to 4."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50de3674",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bound = ipk.modeler[\"implant_box\"].bounding_box\n",
+ "mesh_box = ipk.modeler.create_box(\n",
+ " origin=bound[:3],\n",
+ " sizes=[bound[3] - bound[0], bound[4] - bound[1], bound[5] - bound[2]],\n",
+ ")\n",
+ "mesh_box.model = False\n",
+ "mesh_region = ipk.mesh.assign_mesh_region([mesh_box.name])\n",
+ "mesh_region.UserSpecifiedSettings = False\n",
+ "mesh_region.Level = 4\n",
+ "mesh_region.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "357a3873",
+ "metadata": {},
+ "source": [
+ "## Create point monitor\n",
+ "\n",
+ "Create a point monitor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "359afee9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.modeler.set_working_coordinate_system(\"implant\")\n",
+ "ipk.monitor.assign_point_monitor(point_position=[0, 0, 0], monitor_name=\"Point1\")\n",
+ "ipk.assign_openings(ipk.modeler[\"Region\"].top_face_z)\n",
+ "# -"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "35d0284b",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "39cbd8a8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36c772ef",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2027f818",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/coplanar_waveguide.ipynb.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/coplanar_waveguide.ipynb.txt
new file mode 100644
index 00000000..72505cfd
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/coplanar_waveguide.ipynb.txt
@@ -0,0 +1,513 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e45b5cba",
+ "metadata": {},
+ "source": [
+ "# CPWG analysis"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a2c903b",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to create a CPWG (coplanar waveguide with ground) design\n",
+ "in 2D Extractor and run a simulation.\n",
+ "\n",
+ "Keywords: **Q2D**, **CPWG**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "934677da",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e420bd8c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be1c088b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d613cb7c",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "580e2bc4",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Run the example without opening the UI."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "932f487a",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92df4c87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e856c8ae",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and 2D Extractor\n",
+ "\n",
+ "Launch AEDT 2024.2 in graphical mode and launch 2D Extractor. This example\n",
+ "uses SI units."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "59d6c827",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d = ansys.aedt.core.Q2d(\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " project=os.path.join(temp_folder.name, \"cpwg\"),\n",
+ " design=\"coplanar_waveguide\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4f7e49ea",
+ "metadata": {},
+ "source": [
+ "## Create model\n",
+ "\n",
+ "Define variables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0feb186b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "e_factor = \"e_factor\"\n",
+ "sig_bot_w = \"sig_bot_w\"\n",
+ "co_gnd_w = \"gnd_w\"\n",
+ "clearance = \"clearance\"\n",
+ "cond_h = \"cond_h\"\n",
+ "d_h = \"d_h\"\n",
+ "sm_h = \"sm_h\"\n",
+ "\n",
+ "for var_name, var_value in {\n",
+ " \"sig_bot_w\": \"150um\",\n",
+ " \"e_factor\": \"2\",\n",
+ " \"gnd_w\": \"500um\",\n",
+ " \"clearance\": \"150um\",\n",
+ " \"cond_h\": \"50um\",\n",
+ " \"d_h\": \"150um\",\n",
+ " \"sm_h\": \"20um\",\n",
+ "}.items():\n",
+ " q2d[var_name] = var_value\n",
+ "\n",
+ "delta_w_half = \"({0}/{1})\".format(cond_h, e_factor)\n",
+ "sig_top_w = \"({1}-{0}*2)\".format(delta_w_half, sig_bot_w)\n",
+ "co_gnd_top_w = \"({1}-{0}*2)\".format(delta_w_half, co_gnd_w)\n",
+ "model_w = \"{}*2+{}*2+{}\".format(co_gnd_w, clearance, sig_bot_w)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1581e370",
+ "metadata": {},
+ "source": [
+ "Create primitives and define the layer heights."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "994374cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "layer_1_lh = 0\n",
+ "layer_1_uh = cond_h\n",
+ "layer_2_lh = layer_1_uh + \"+\" + d_h\n",
+ "layer_2_uh = layer_2_lh + \"+\" + cond_h"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4d8a0a8c",
+ "metadata": {},
+ "source": [
+ "Create a signal conductor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c0cc1927",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "base_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_lh, 0], [sig_bot_w, layer_2_lh, 0]], name=\"signal\"\n",
+ ")\n",
+ "top_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_uh, 0], [sig_top_w, layer_2_uh, 0]]\n",
+ ")\n",
+ "q2d.modeler.move(assignment=[top_line_obj], vector=[delta_w_half, 0, 0])\n",
+ "q2d.modeler.connect([base_line_obj, top_line_obj])\n",
+ "q2d.modeler.move(\n",
+ " assignment=[base_line_obj], vector=[\"{}+{}\".format(co_gnd_w, clearance), 0, 0]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1958fb66",
+ "metadata": {},
+ "source": [
+ "Create a coplanar ground."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3929a528",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "base_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_lh, 0], [co_gnd_w, layer_2_lh, 0]], name=\"co_gnd_left\"\n",
+ ")\n",
+ "top_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_uh, 0], [co_gnd_top_w, layer_2_uh, 0]]\n",
+ ")\n",
+ "q2d.modeler.move(objid=[top_line_obj], vector=[delta_w_half, 0, 0])\n",
+ "q2d.modeler.connect([base_line_obj, top_line_obj])\n",
+ "\n",
+ "base_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_lh, 0], [co_gnd_w, layer_2_lh, 0]], name=\"co_gnd_right\"\n",
+ ")\n",
+ "top_line_obj = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_uh, 0], [co_gnd_top_w, layer_2_uh, 0]]\n",
+ ")\n",
+ "q2d.modeler.move(objid=[top_line_obj], vector=[delta_w_half, 0, 0])\n",
+ "q2d.modeler.connect([base_line_obj, top_line_obj])\n",
+ "q2d.modeler.move(\n",
+ " assignment=[base_line_obj],\n",
+ " vector=[\"{}+{}*2+{}\".format(co_gnd_w, clearance, sig_bot_w), 0, 0],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "60c15ece",
+ "metadata": {},
+ "source": [
+ "Create a reference ground plane."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "72918d95",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_1_lh, 0], sizes=[model_w, cond_h], name=\"ref_gnd\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f4300ab",
+ "metadata": {},
+ "source": [
+ "Define the substrate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f4c85b98",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.create_rectangle(\n",
+ " position=[0, layer_1_uh, 0],\n",
+ " dimension_list=[model_w, d_h],\n",
+ " name=\"Dielectric\",\n",
+ " matname=\"FR4_epoxy\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1820b444",
+ "metadata": {},
+ "source": [
+ "Assign a conformal coating."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c2b3418d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sm_obj_list = []\n",
+ "ids = [1, 2, 3]\n",
+ "if AEDT_VERSION >= \"2023.1\":\n",
+ " ids = [0, 1, 2]\n",
+ "\n",
+ "for obj_name in [\"signal\", \"co_gnd_left\", \"co_gnd_right\"]:\n",
+ " obj = q2d.modeler.get_object_from_name(obj_name)\n",
+ " e_obj_list = []\n",
+ " for i in ids:\n",
+ " e_obj = q2d.modeler.create_object_from_edge(obj.edges[i])\n",
+ " e_obj_list.append(e_obj)\n",
+ " e_obj_1 = e_obj_list[0]\n",
+ " q2d.modeler.unite(e_obj_list)\n",
+ " new_obj = q2d.modeler.sweep_along_vector(\n",
+ " assignment=e_obj_1.id, sweep_vector=[0, sm_h, 0]\n",
+ " )\n",
+ " sm_obj_list.append(e_obj_1)\n",
+ "\n",
+ "new_obj = q2d.modeler.create_rectangle(\n",
+ " origin=[co_gnd_w, layer_2_lh, 0], sizes=[clearance, sm_h]\n",
+ ")\n",
+ "sm_obj_list.append(new_obj)\n",
+ "\n",
+ "new_obj = q2d.modeler.create_rectangle(\n",
+ " origin=[co_gnd_w, layer_2_lh, 0], sizes=[clearance, sm_h]\n",
+ ")\n",
+ "q2d.modeler.move(assignment=[new_obj], vector=[sig_bot_w + \"+\" + clearance, 0, 0])\n",
+ "sm_obj_list.append(new_obj)\n",
+ "\n",
+ "sm_obj = sm_obj_list[0]\n",
+ "q2d.modeler.unite(sm_obj_list)\n",
+ "sm_obj.material_name = \"SolderMask\"\n",
+ "sm_obj.color = (0, 150, 100)\n",
+ "sm_obj.name = \"solder_mask\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d771fff",
+ "metadata": {},
+ "source": [
+ "Assign a conductor to the signal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "140e9f7a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj = q2d.modeler.get_object_from_name(\"signal\")\n",
+ "q2d.assign_single_conductor(\n",
+ " name=obj.name,\n",
+ " assignment=[obj],\n",
+ " conductor_type=\"SignalLine\",\n",
+ " solve_option=\"SolveOnBoundary\",\n",
+ " units=\"mm\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "74cbaf7f",
+ "metadata": {},
+ "source": [
+ "Assign the reference ground."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df5592a8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj = [\n",
+ " q2d.modeler.get_object_from_name(i)\n",
+ " for i in [\"co_gnd_left\", \"co_gnd_right\", \"ref_gnd\"]\n",
+ "]\n",
+ "q2d.assign_single_conductor(\n",
+ " name=\"gnd\",\n",
+ " assignment=obj,\n",
+ " conductor_type=\"ReferenceGround\",\n",
+ " solve_option=\"SolveOnBoundary\",\n",
+ " units=\"mm\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fd3ce046",
+ "metadata": {},
+ "source": [
+ "Assign the Huray model for conductive losses on the signal trace."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "790a940e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "obj = q2d.modeler.get_object_from_name(\"signal\")\n",
+ "q2d.assign_huray_finitecond_to_edges(\n",
+ " obj.edges, radius=\"0.5um\", ratio=3, name=\"b_\" + obj.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "31fa40dd",
+ "metadata": {},
+ "source": [
+ "## Create the simulation setup\n",
+ "\n",
+ "Create the setup, analyze it, and plot solution data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "14c842e5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = q2d.create_setup(setupname=\"new_setup\")\n",
+ "\n",
+ "sweep = setup.add_sweep(name=\"sweep1\", sweep_type=\"Discrete\")\n",
+ "sweep.props[\"RangeType\"] = \"LinearStep\"\n",
+ "sweep.props[\"RangeStart\"] = \"1GHz\"\n",
+ "sweep.props[\"RangeStep\"] = \"100MHz\"\n",
+ "sweep.props[\"RangeEnd\"] = \"5GHz\"\n",
+ "sweep.props[\"SaveFields\"] = False\n",
+ "sweep.props[\"SaveRadFields\"] = False\n",
+ "sweep.props[\"Type\"] = \"Interpolating\"\n",
+ "\n",
+ "sweep.update()\n",
+ "\n",
+ "q2d.analyze(cores=NUM_CORES)\n",
+ "\n",
+ "data = q2d.post.get_solution_data(expressions=\"Z0(signal,signal)\", context=\"Original\")\n",
+ "data.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e21ef2bb",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ac3acba2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.save_project()\n",
+ "q2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c4520ded",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41bdbcb5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/index.rst.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/index.rst.txt
new file mode 100644
index 00000000..657650a4
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/index.rst.txt
@@ -0,0 +1,140 @@
+Radio frequency and millimeter wave
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+These examples use PyAEDT to show some radio frequency and millimeter wave applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: Inductive iris waveguide filter
+ :padding: 2 2 2 2
+ :link: iris_filter
+ :link-type: doc
+
+ .. image:: _static/wgf.png
+ :alt: Waveguide filter
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to build and analyze a four-pole X-Band waveguide filter using inductive irises.
+
+ .. grid-item-card:: Spiral inductor
+ :padding: 2 2 2 2
+ :link: spiral
+ :link-type: doc
+
+ .. image:: _static/spiral.png
+ :alt: Spiral
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a spiral inductor, solve it, and plot results.
+
+ .. grid-item-card:: CPWG analysis
+ :padding: 2 2 2 2
+ :link: coplanar_waveguide
+ :link-type: doc
+
+ .. image:: _static/cpwg.png
+ :alt: CPWG
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a CPWG (coplanar waveguide with ground) design in 2D Extractor and run a simulation.
+
+
+ .. grid-item-card:: Stripline analysis
+ :padding: 2 2 2 2
+ :link: stripline
+ :link-type: doc
+
+ .. image:: _static/stripline.png
+ :alt: Stripline
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a differential stripline design in 2D Extractor and run a simulation.
+
+ .. grid-item-card:: Lumped element filter design
+ :padding: 2 2 2 2
+ :link: lumped_element
+ :link-type: doc
+
+ .. image:: _static/lumped_filter.png
+ :alt: Lumped element filter
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to use the FilterSolutions module to design and visualize the frequency
+ response of a band-pass Butterworth filter.
+
+
+ .. grid-item-card:: Flex cable CPWG
+ :padding: 2 2 2 2
+ :link: ../emc/flex_cable
+ :link-type: doc
+
+ .. image:: ../emc/_static/flex_cable.png
+ :alt: Flex cable
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a flex cable CPWG (coplanar waveguide with ground).
+
+ .. grid-item-card:: Eigenmode filter
+ :padding: 2 2 2 2
+ :link: ../emc/eigenmode
+ :link-type: doc
+
+ .. image:: ../emc/_static/eigenmode.png
+ :alt: Eigenmode
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to automate the Eigenmode solver in HFSS.
+
+ .. grid-item-card:: FSS unit cell simulation
+ :padding: 2 2 2 2
+ :link: ../antenna/fss_unitcell
+ :link-type: doc
+
+ .. image:: ../antenna/_static/unitcell.png
+ :alt: FSS
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to model and simulate a unit cell for a frequency-selective surface in HFSS.
+
+ .. grid-item-card:: RF interference
+ :padding: 2 2 2 2
+ :link: ../antenna/interferences/index
+ :link-type: doc
+
+ .. image:: ../antenna/interferences/_static/emit_simple_cosite.png
+ :alt: EMIT logo
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some general capabilities of EMIT for RF interference.
+
+ .. toctree::
+ :hidden:
+
+ iris_filter
+ spiral
+ coplanar_waveguide
+ stripline
+ lumped_element
+ ../emc/flex_cable
+ ../emc/eigenmode
+ ../antenna/fss_unitcell
+ ../antenna/interferences/index
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/iris_filter.ipynb.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/iris_filter.ipynb.txt
new file mode 100644
index 00000000..c7e9656c
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/iris_filter.ipynb.txt
@@ -0,0 +1,555 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "51e13005",
+ "metadata": {},
+ "source": [
+ "# Inductive iris waveguide filter\n",
+ "\n",
+ "This example shows how to build and analyze a four-pole\n",
+ "X-Band waveguide filter using inductive irises.\n",
+ "\n",
+ "Keywords: **HFSS**, **modal**, **waveguide filter**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "baab99a2",
+ "metadata": {},
+ "source": [
+ "![](\"_static/wgf.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "13ce2fa7",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d282d22a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d106c065",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "946eafad",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a12e8341",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6579cb4",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6d67d9c4",
+ "metadata": {},
+ "source": [
+ "### Define parameters and values for waveguide iris filter\n",
+ "\n",
+ "Define these parameters:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98cec5a7",
+ "metadata": {},
+ "source": [
+ "l: Length of the cavity from the mid-point of one iris\n",
+ " to the midpoint of the next iris\n",
+ "\n",
+ "w: Width of the iris opening\n",
+ "\n",
+ "a: Long dimension of the waveguide cross-section (X-Band)\n",
+ "\n",
+ "b: Short dimension of the waveguide cross-section\n",
+ "\n",
+ "t: Metal thickness of the iris insert"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9093ea8c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wgparams = {\n",
+ " \"l\": [0.7428, 0.82188],\n",
+ " \"w\": [0.50013, 0.3642, 0.3458],\n",
+ " \"a\": 0.4,\n",
+ " \"b\": 0.9,\n",
+ " \"t\": 0.15,\n",
+ " \"units\": \"in\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "041d977c",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5c579d5d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fd31e02d",
+ "metadata": {},
+ "source": [
+ "### Create HFSS design"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6f3a76cf",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"waveguide.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " design=\"filter\",\n",
+ " solution_type=\"Modal\",\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " close_on_exit=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "200b82c6",
+ "metadata": {},
+ "source": [
+ "### Initialize design parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5b242217",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.model_units = \"in\" # Set to inches\n",
+ "var_mapping = dict() # Used by parse_expr to parse expressions.\n",
+ "for key in wgparams:\n",
+ " if type(wgparams[key]) in [int, float]:\n",
+ " hfss[key] = str(wgparams[key]) + wgparams[\"units\"]\n",
+ " var_mapping[key] = wgparams[key] # Used for expression parsing.\n",
+ " elif type(wgparams[key]) == list:\n",
+ " count = 1\n",
+ " for v in wgparams[key]:\n",
+ " this_key = key + str(count)\n",
+ " hfss[this_key] = str(v) + wgparams[\"units\"]\n",
+ " var_mapping[\n",
+ " this_key\n",
+ " ] = v # Used to parse expressions and generate numerical values.\n",
+ " count += 1\n",
+ "\n",
+ "if len(wgparams[\"l\"]) % 2 == 0:\n",
+ " zstart = \"-t/2\" # Even number of cavities, odd number of irises.\n",
+ " is_even = True\n",
+ "else:\n",
+ " zstart = \"l1/2 - t/2\" # Odd number of cavities, even number of irises.\n",
+ " is_even = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f9076635",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "### Draw parametric waveguide filter\n",
+ "\n",
+ "Define a function to place each iris at the correct longitudinal (z) position,\n",
+ "Loop from the largest index (interior of the filter) to 1, which is the first\n",
+ "iris nearest the waveguide ports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76350508",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def place_iris(z_pos, dz, param_count):\n",
+ " w_str = \"w\" + str(param_count) # Iris width parameter as a string.\n",
+ " this_name = \"iris_a_\" + str(param_count) # Iris object name in the HFSS project.\n",
+ " iris_new = [] # Return a list of the two objects that make up the iris.\n",
+ " if this_name in hfss.modeler.object_names:\n",
+ " this_name = this_name.replace(\"a\", \"c\")\n",
+ " iris_new.append(\n",
+ " hfss.modeler.create_box(\n",
+ " [\"-b/2\", \"-a/2\", z_pos],\n",
+ " [\"(b - \" + w_str + \")/2\", \"a\", dz],\n",
+ " name=this_name,\n",
+ " material=\"silver\",\n",
+ " )\n",
+ " )\n",
+ " iris_new.append(iris_new[0].mirror([0, 0, 0], [1, 0, 0], duplicate=True))\n",
+ " return iris_new"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3ab66711",
+ "metadata": {},
+ "source": [
+ "### Place irises\n",
+ "\n",
+ "Place the irises from inner (highest integer) to outer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27697b2f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "zpos = zstart\n",
+ "for count in reversed(range(1, len(wgparams[\"w\"]) + 1)):\n",
+ " if count < len(wgparams[\"w\"]): # Update zpos\n",
+ " zpos = zpos + \"\".join([\" + l\" + str(count) + \" + \"])[:-3]\n",
+ " iris = place_iris(zpos, \"t\", count)\n",
+ " iris = place_iris(\"-(\" + zpos + \")\", \"-t\", count)\n",
+ "\n",
+ " else: # Place first iris\n",
+ " iris = place_iris(zpos, \"t\", count)\n",
+ " if not is_even:\n",
+ " iris = place_iris(\"-(\" + zpos + \")\", \"-t\", count)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "860726f7",
+ "metadata": {},
+ "source": [
+ "### Draw full waveguide with ports\n",
+ "\n",
+ "Use ``hfss.variable_manager``, which acts like a dictionary, to return an instance of\n",
+ "the ``ansys.aedt.core.application.variables.VariableManager`` class for any variable.\n",
+ "The ``VariableManager`` instance takes the HFSS variable name as a key.\n",
+ "``VariableManager`` properties enable access to update, modify, and\n",
+ "evaluate variables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "882dbdf7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "var_mapping[\"port_extension\"] = 1.5 * wgparams[\"l\"][0]\n",
+ "hfss[\"port_extension\"] = str(var_mapping[\"port_extension\"]) + wgparams[\"units\"]\n",
+ "hfss[\"wg_z_start\"] = \"-(\" + zpos + \") - port_extension\"\n",
+ "hfss[\"wg_length\"] = \"2*(\" + zpos + \" + port_extension )\"\n",
+ "wg_z_start = hfss.variable_manager[\"wg_z_start\"]\n",
+ "wg_length = hfss.variable_manager[\"wg_length\"]\n",
+ "hfss[\"u_start\"] = \"-a/2\"\n",
+ "hfss[\"u_end\"] = \"a/2\"\n",
+ "hfss.modeler.create_box(\n",
+ " [\"-b/2\", \"-a/2\", \"wg_z_start\"],\n",
+ " [\"b\", \"a\", \"wg_length\"],\n",
+ " name=\"waveguide\",\n",
+ " material=\"vacuum\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "105fc214",
+ "metadata": {},
+ "source": [
+ "### Draw the entire waveguide\n",
+ "\n",
+ "The variable ``# wg_z`` is the total length of the waveguide, including the port extension.\n",
+ "Note that the ``.evaluated_value`` provides access to the numerical value of\n",
+ "``wg_z_start``, which is an expression in HFSS."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df14a35b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wg_z = [\n",
+ " wg_z_start.evaluated_value,\n",
+ " hfss.value_with_units(wg_z_start.numeric_value + wg_length.numeric_value, \"in\"),\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90280a85",
+ "metadata": {},
+ "source": [
+ "Assign wave ports to the end faces of the waveguide\n",
+ "and define the calibration lines to ensure self-consistent\n",
+ "polarization between wave ports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "98a09e0a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "count = 0\n",
+ "ports = []\n",
+ "for n, z in enumerate(wg_z):\n",
+ " face_id = hfss.modeler.get_faceid_from_position([0, 0, z], assignment=\"waveguide\")\n",
+ " u_start = [0, hfss.variable_manager[\"u_start\"].evaluated_value, z]\n",
+ " u_end = [0, hfss.variable_manager[\"u_end\"].evaluated_value, z]\n",
+ "\n",
+ " ports.append(\n",
+ " hfss.wave_port(\n",
+ " face_id,\n",
+ " integration_line=[u_start, u_end],\n",
+ " name=\"P\" + str(n + 1),\n",
+ " renormalize=False,\n",
+ " )\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b32744d",
+ "metadata": {},
+ "source": [
+ "### Insert mesh adaptation setup\n",
+ "\n",
+ "Insert a mesh adaptation setup using refinement at two frequencies.\n",
+ "This approach is useful for resonant structures because the coarse initial\n",
+ "mesh impacts the resonant frequency and, hence, the field propagation through the\n",
+ "filter. Adaptation at multiple frequencies helps to ensure that energy propagates\n",
+ "through the resonant structure while the mesh is refined."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e33d660a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = hfss.create_setup(\n",
+ " \"Setup1\",\n",
+ " setup_type=\"HFSSDriven\",\n",
+ " MultipleAdaptiveFreqsSetup=[\"9.8GHz\", \"10.2GHz\"],\n",
+ " MaximumPasses=5,\n",
+ ")\n",
+ "\n",
+ "setup.create_frequency_sweep(\n",
+ " unit=\"GHz\",\n",
+ " name=\"Sweep1\",\n",
+ " start_frequency=9.5,\n",
+ " stop_frequency=10.5,\n",
+ " sweep_type=\"Interpolating\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "796d3572",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ " Solve the project with two tasks.\n",
+ " Each frequency point is solved simultaneously."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "686bfb28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e318bd08",
+ "metadata": {},
+ "source": [
+ "### Postprocess\n",
+ "\n",
+ " The following commands fetch solution data from HFSS for plotting directly\n",
+ " from the Python interpreter.\n",
+ "\n",
+ " **Caution:** The syntax for expressions must be identical to that used\n",
+ " in HFSS."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1cb49e6b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "traces_to_plot = hfss.get_traces_for_plot(second_element_filter=\"P1*\")\n",
+ "report = hfss.post.create_report(traces_to_plot) # Creates a report in HFSS\n",
+ "solution = report.get_solution_data()\n",
+ "\n",
+ "plt = solution.plot(solution.expressions) # Matplotlib axes object."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e82d24fc",
+ "metadata": {},
+ "source": [
+ " The following command generates a field plot in HFSS and uses PyVista\n",
+ " to plot the field in Jupyter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66cab505",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot = hfss.post.plot_field(\n",
+ " quantity=\"Mag_E\",\n",
+ " assignment=[\"Global:XZ\"],\n",
+ " plot_type=\"CutPlane\",\n",
+ " setup=hfss.nominal_adaptive,\n",
+ " intrinsics={\"Freq\": \"9.8GHz\", \"Phase\": \"0deg\"},\n",
+ " export_path=hfss.working_directory,\n",
+ " show=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "545863cf",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ " The following command saves the project to a file and closes AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "14d39444",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9e1dec35",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d0201dae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/lumped_element.ipynb.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/lumped_element.ipynb.txt
new file mode 100644
index 00000000..51b91243
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/lumped_element.ipynb.txt
@@ -0,0 +1,202 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "77299eff",
+ "metadata": {},
+ "source": [
+ "# Lumped element filter design\n",
+ "\n",
+ "This example shows how to use PyAEDT to use the ``FilterSolutions`` module to design and\n",
+ "visualize the frequency response of a band-pass Butterworth filter.\n",
+ "\n",
+ "Keywords: **filter solutions**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3cf937e1",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1fdcf2a1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import matplotlib.pyplot as plt\n",
+ "from ansys.aedt.core.filtersolutions_core.attributes import (\n",
+ " FilterClass, FilterImplementation, FilterType)\n",
+ "from ansys.aedt.core.filtersolutions_core.ideal_response import \\\n",
+ " FrequencyResponseColumn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e622b1a4",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "418aca77",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2025.1\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "349ce467",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Define function used for plotting\n",
+ "\n",
+ "Define formal plot function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c96e74de",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def format_plot():\n",
+ " plt.xlabel(\"Frequency (Hz)\")\n",
+ " plt.ylabel(\"Magnitude S21 (dB)\")\n",
+ " plt.title(\"Ideal Frequency Response\")\n",
+ " plt.xscale(\"log\")\n",
+ " plt.legend()\n",
+ " plt.grid()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4388915e",
+ "metadata": {},
+ "source": [
+ "## Create lumped filter design\n",
+ "\n",
+ "Create a lumped element filter design and assign the class, type, frequency, and order."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06cf074e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "design = ansys.aedt.core.FilterSolutions(\n",
+ " version=AEDT_VERSION, implementation_type=FilterImplementation.LUMPED\n",
+ ")\n",
+ "design.attributes.filter_class = FilterClass.BAND_PASS\n",
+ "design.attributes.filter_type = FilterType.BUTTERWORTH\n",
+ "design.attributes.pass_band_center_frequency = \"1G\"\n",
+ "design.attributes.pass_band_width_frequency = \"500M\"\n",
+ "design.attributes.filter_order = 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e37b844",
+ "metadata": {},
+ "source": [
+ "## Plot frequency response of filter\n",
+ "\n",
+ "Plot the frequency response of the filter without any transmission zeros."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5bc3de7b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "freq, mag_db = design.ideal_response.frequency_response(\n",
+ " FrequencyResponseColumn.MAGNITUDE_DB\n",
+ ")\n",
+ "plt.plot(freq, mag_db, linewidth=2.0, label=\"Without Tx Zero\")\n",
+ "format_plot()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "131845b4",
+ "metadata": {},
+ "source": [
+ "## Add a transmission zero to filter design\n",
+ "\n",
+ "Add a transmission zero that yields nulls separated by two times the pass band width (1 GHz).\n",
+ "Plot the frequency response of the filter with the transmission zero."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e76cbeec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "design.transmission_zeros_ratio.append_row(\"2.0\")\n",
+ "freq_with_zero, mag_db_with_zero = design.ideal_response.frequency_response(\n",
+ " FrequencyResponseColumn.MAGNITUDE_DB\n",
+ ")\n",
+ "plt.plot(freq, mag_db, linewidth=2.0, label=\"Without Tx Zero\")\n",
+ "plt.plot(freq_with_zero, mag_db_with_zero, linewidth=2.0, label=\"With Tx Zero\")\n",
+ "format_plot()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73ea521d",
+ "metadata": {},
+ "source": [
+ "## Generate netlist for designed filter\n",
+ "\n",
+ "Generate and print the netlist for the designed filter with the added transmission zero to\n",
+ "the filter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b933739",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "netlist = design.topology.circuit_response()\n",
+ "print(\"Netlist: \\n\", netlist)"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ },
+ "nbsphinx": {
+ "execute": "never"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/spiral.ipynb.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/spiral.ipynb.txt
new file mode 100644
index 00000000..d0a94731
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/spiral.ipynb.txt
@@ -0,0 +1,553 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "36c8abfb",
+ "metadata": {},
+ "source": [
+ "# Spiral inductor\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a spiral inductor, solve it, and plot results.\n",
+ "\n",
+ "Keywords: **HFSS**, **spiral**, **inductance**, **output variable**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4dd3d503",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c5830ec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6e2cc20b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9510f1c",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "463b3bb0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0daa9df4",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "86ef0904",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "91745ab3",
+ "metadata": {},
+ "source": [
+ "## Launch HFSS\n",
+ "\n",
+ "Create an HFSS design and change the units to microns."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "87007356",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"spiral.aedt\")\n",
+ "hfss = ansys.aedt.core.Hfss(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " design=\"A1\",\n",
+ " new_desktop=True,\n",
+ " solution_type=\"Modal\",\n",
+ ")\n",
+ "hfss.modeler.model_units = \"um\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83a75d7e",
+ "metadata": {},
+ "source": [
+ "## Define variables\n",
+ "\n",
+ "Define input variables. You can use the values that follow or edit\n",
+ "them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d5bcd483",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rin = 10\n",
+ "width = 2\n",
+ "spacing = 1\n",
+ "thickness = 1\n",
+ "Np = 8\n",
+ "Nr = 10\n",
+ "gap = 3\n",
+ "hfss[\"Tsub\"] = \"6\" + hfss.modeler.model_units"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6a751d45",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "## Standardize polyline\n",
+ "\n",
+ "Define a function that creates a polyline using the ``create_line()`` method. This\n",
+ "function creates a polyline having a fixed width, thickness, and material."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da14ca57",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_line(pts):\n",
+ " hfss.modeler.create_polyline(\n",
+ " pts,\n",
+ " xsection_type=\"Rectangle\",\n",
+ " xsection_width=width,\n",
+ " xsection_height=thickness,\n",
+ " material=\"copper\",\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0ea3d7c",
+ "metadata": {},
+ "source": [
+ "## Create spiral inductor\n",
+ "\n",
+ "Create the spiral inductor. This spiral inductor is not\n",
+ "parametric, but you could parametrize it later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "00c927e4",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "ind = hfss.modeler.create_spiral(\n",
+ " internal_radius=rin,\n",
+ " width=width,\n",
+ " spacing=spacing,\n",
+ " turns=Nr,\n",
+ " faces=Np,\n",
+ " thickness=thickness,\n",
+ " material=\"copper\",\n",
+ " name=\"Inductor1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b6f93f1",
+ "metadata": {},
+ "source": [
+ "## Center return path\n",
+ "\n",
+ "Center the return path."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7a87febb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x0, y0, z0 = ind.points[0]\n",
+ "x1, y1, z1 = ind.points[-1]\n",
+ "create_line([(x0 - width / 2, y0, -gap), (abs(x1) + 5, y0, -gap)])\n",
+ "hfss.modeler.create_box(\n",
+ " [x0 - width / 2, y0 - width / 2, -gap - thickness / 2],\n",
+ " [width, width, gap + thickness],\n",
+ " matname=\"copper\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "509adbff",
+ "metadata": {},
+ "source": [
+ "Create port 1."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "03c74ce3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.create_rectangle(\n",
+ " orientation=ansys.aedt.core.constants.PLANE.YZ,\n",
+ " origin=[abs(x1) + 5, y0 - width / 2, -gap - thickness / 2],\n",
+ " sizes=[width, \"-Tsub+{}{}\".format(gap, hfss.modeler.model_units)],\n",
+ " name=\"port1\",\n",
+ ")\n",
+ "hfss.lumped_port(assignment=\"port1\", integration_line=ansys.aedt.core.constants.AXIS.Z)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c6f336b8",
+ "metadata": {},
+ "source": [
+ "Create port 2."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68ffe40a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "create_line([(x1 + width / 2, y1, 0), (x1 - 5, y1, 0)])\n",
+ "hfss.modeler.create_rectangle(\n",
+ " ansys.aedt.core.constants.PLANE.YZ,\n",
+ " [x1 - 5, y1 - width / 2, -thickness / 2],\n",
+ " [width, \"-Tsub\"],\n",
+ " name=\"port2\",\n",
+ ")\n",
+ "hfss.lumped_port(assignment=\"port2\", integration_line=ansys.aedt.core.constants.AXIS.Z)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "722b90e6",
+ "metadata": {},
+ "source": [
+ "Create the silicon substrate and the ground plane."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a04b13b8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.modeler.create_box(\n",
+ " [x1 - 20, x1 - 20, \"-Tsub-{}{}/2\".format(thickness, hfss.modeler.model_units)],\n",
+ " [-2 * x1 + 40, -2 * x1 + 40, \"Tsub\"],\n",
+ " material=\"silicon\",\n",
+ ")\n",
+ "\n",
+ "hfss.modeler.create_box(\n",
+ " [x1 - 20, x1 - 20, \"-Tsub-{}{}/2\".format(thickness, hfss.modeler.model_units)],\n",
+ " [-2 * x1 + 40, -2 * x1 + 40, -0.1],\n",
+ " material=\"PEC\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d2bd761",
+ "metadata": {},
+ "source": [
+ "## Set up model\n",
+ "\n",
+ "Create the air box and radiation boundary condition."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4eedd3f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "box = hfss.modeler.create_box(\n",
+ " [\n",
+ " x1 - 20,\n",
+ " x1 - 20,\n",
+ " \"-Tsub-{}{}/2 - 0.1{}\".format(\n",
+ " thickness, hfss.modeler.model_units, hfss.modeler.model_units\n",
+ " ),\n",
+ " ],\n",
+ " [-2 * x1 + 40, -2 * x1 + 40, 100],\n",
+ " name=\"airbox\",\n",
+ " material=\"air\",\n",
+ ")\n",
+ "\n",
+ "hfss.assign_radiation_boundary_to_objects(\"airbox\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bf74b571",
+ "metadata": {},
+ "source": [
+ "Assign a material override that allows object intersections,\n",
+ "assigning conductors higher priority than insulators."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9aecbf60",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.change_material_override()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc8afdb4",
+ "metadata": {},
+ "source": [
+ "View the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c6966442",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(hfss.working_directory, \"Image.jpg\"),\n",
+ " plot_air_objects=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e3bd3665",
+ "metadata": {},
+ "source": [
+ "## Generate the solution\n",
+ "\n",
+ "Create the setup, including a frequency sweep. Then, solve the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af43be06",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup1 = hfss.create_setup(name=\"setup1\")\n",
+ "setup1.props[\"Frequency\"] = \"10GHz\"\n",
+ "hfss.create_linear_count_sweep(\n",
+ " setup=\"setup1\",\n",
+ " units=\"GHz\",\n",
+ " start_frequency=1e-3,\n",
+ " stop_frequency=50,\n",
+ " num_of_freq_points=451,\n",
+ " sweep_type=\"Interpolating\",\n",
+ ")\n",
+ "hfss.save_project()\n",
+ "hfss.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28af3f94",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Get report data and use the following formulas to calculate\n",
+ "the inductance and quality factor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "52d4d49d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "L_formula = \"1e9*im(1/Y(1,1))/(2*pi*freq)\"\n",
+ "Q_formula = \"im(Y(1,1))/re(Y(1,1))\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ae0f1611",
+ "metadata": {},
+ "source": [
+ "Define the inductance as a postprocessing variable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5eeeb3fe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.create_output_variable(\"L\", L_formula, solution=\"setup1 : LastAdaptive\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e93151",
+ "metadata": {},
+ "source": [
+ "Plot the results using Matplotlib."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f02d2d75",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = hfss.post.get_solution_data([L_formula, Q_formula])\n",
+ "data.plot(\n",
+ " curves=[L_formula, Q_formula], formula=\"re\", x_label=\"Freq\", y_label=\"L and Q\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "72a4f2a9",
+ "metadata": {},
+ "source": [
+ "Export results to a CSV file"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "394513f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data.export_data_to_csv(os.path.join(hfss.toolkit_directory, \"output.csv\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d2ef5bb",
+ "metadata": {},
+ "source": [
+ "## Save project and close AEDT\n",
+ "\n",
+ "Save the project and close AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92256945",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hfss.save_project()\n",
+ "hfss.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d46c5b4",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6232003e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/stripline.ipynb.txt b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/stripline.ipynb.txt
new file mode 100644
index 00000000..fc07f612
--- /dev/null
+++ b/version/dev/_sources/examples/high_frequency/radiofrequency_mmwave/stripline.ipynb.txt
@@ -0,0 +1,600 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "02393221",
+ "metadata": {},
+ "source": [
+ "# Stripline analysis"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a2ed35d",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to create a differential stripline design in\n",
+ "2D Extractor and run a simulation.\n",
+ "\n",
+ "Keywords: **Q2D**, **Stripline**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b5b5dc3",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "56697484",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "\n",
+ "import ansys.aedt.core\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "25d6b4e1",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a1d9a1d1",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a6a1d1e",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b9c61243",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4d8ff56e",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and 2D Extractor\n",
+ "\n",
+ "Launch AEDT 2024.2 in graphical mode and launch 2D Extractor. This example\n",
+ "uses SI units."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4736118b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d = ansys.aedt.core.Q2d(\n",
+ " project=os.path.join(temp_folder.name, \"stripline\"),\n",
+ " design=\"differential_stripline\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=False,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7f2d1dc",
+ "metadata": {},
+ "source": [
+ "## Define variables\n",
+ "\n",
+ "Define variables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c21293d8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "e_factor = \"e_factor\"\n",
+ "sig_w = \"sig_bot_w\"\n",
+ "sig_gap = \"sig_gap\"\n",
+ "co_gnd_w = \"gnd_w\"\n",
+ "clearance = \"clearance\"\n",
+ "cond_h = \"cond_h\"\n",
+ "core_h = \"core_h\"\n",
+ "pp_h = \"pp_h\"\n",
+ "\n",
+ "for var_name, var_value in {\n",
+ " \"e_factor\": \"2\",\n",
+ " \"sig_bot_w\": \"150um\",\n",
+ " \"sig_gap\": \"150um\",\n",
+ " \"gnd_w\": \"500um\",\n",
+ " \"clearance\": \"150um\",\n",
+ " \"cond_h\": \"17um\",\n",
+ " \"core_h\": \"150um\",\n",
+ " \"pp_h\": \"150um\",\n",
+ "}.items():\n",
+ " q2d[var_name] = var_value\n",
+ "\n",
+ "delta_w_half = \"({0}/{1})\".format(cond_h, e_factor)\n",
+ "sig_top_w = \"({1}-{0}*2)\".format(delta_w_half, sig_w)\n",
+ "co_gnd_top_w = \"({1}-{0}*2)\".format(delta_w_half, co_gnd_w)\n",
+ "model_w = \"{}*2+{}*2+{}*2+{}\".format(co_gnd_w, clearance, sig_w, sig_gap)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "474c18c7",
+ "metadata": {},
+ "source": [
+ "## Create primitives\n",
+ "\n",
+ "Create primitives and define the layer heights."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "37255b5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "layer_1_lh = 0\n",
+ "layer_1_uh = cond_h\n",
+ "layer_2_lh = layer_1_uh + \"+\" + core_h\n",
+ "layer_2_uh = layer_2_lh + \"+\" + cond_h\n",
+ "layer_3_lh = layer_2_uh + \"+\" + pp_h\n",
+ "layer_3_uh = layer_3_lh + \"+\" + cond_h"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0474cd01",
+ "metadata": {},
+ "source": [
+ "## Create positive signal\n",
+ "\n",
+ "Create a positive signal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b050dd5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "signal_p_1 = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_lh, 0], [sig_w, layer_2_lh, 0]], name=\"signal_p_1\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1e5435db",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "signal_p_2 = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_uh, 0], [sig_top_w, layer_2_uh, 0]], name=\"signal_p_2\"\n",
+ ")\n",
+ "q2d.modeler.move([signal_p_2], [delta_w_half, 0, 0])\n",
+ "q2d.modeler.connect([signal_p_1, signal_p_2])\n",
+ "q2d.modeler.move(\n",
+ " assignment=[signal_p_1], vector=[\"{}+{}\".format(co_gnd_w, clearance), 0, 0]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0441a84f",
+ "metadata": {},
+ "source": [
+ "## Create negative signal\n",
+ "\n",
+ "Create a negative signal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "055bcbea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "signal_n_1 = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_lh, 0], [sig_w, layer_2_lh, 0]], name=\"signal_n_1\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "10a8dde7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "signal_n_2 = q2d.modeler.create_polyline(\n",
+ " points=[[0, layer_2_uh, 0], [sig_top_w, layer_2_uh, 0]], name=\"signal_n_2\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b58ad5c1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.move(assignment=[signal_n_2], vector=[delta_w_half, 0, 0])\n",
+ "q2d.modeler.connect([signal_n_1, signal_n_2])\n",
+ "q2d.modeler.move(\n",
+ " assignment=[signal_n_1],\n",
+ " vector=[\"{}+{}+{}+{}\".format(co_gnd_w, clearance, sig_w, sig_gap), 0, 0],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c75ae98c",
+ "metadata": {},
+ "source": [
+ "## Create reference ground plane\n",
+ "\n",
+ "Create a reference ground plane."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9960a09c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ref_gnd_u = q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_1_lh, 0], sizes=[model_w, cond_h], name=\"ref_gnd_u\"\n",
+ ")\n",
+ "ref_gnd_l = q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_3_lh, 0], sizes=[model_w, cond_h], name=\"ref_gnd_l\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ac3eda0",
+ "metadata": {},
+ "source": [
+ "## Create dielectric\n",
+ "\n",
+ "Create a dielectric."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e26fa940",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_1_uh, 0],\n",
+ " sizes=[model_w, core_h],\n",
+ " name=\"Core\",\n",
+ " material=\"FR4_epoxy\",\n",
+ ")\n",
+ "q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_2_uh, 0],\n",
+ " sizes=[model_w, pp_h],\n",
+ " name=\"Prepreg\",\n",
+ " material=\"FR4_epoxy\",\n",
+ ")\n",
+ "q2d.modeler.create_rectangle(\n",
+ " origin=[0, layer_2_lh, 0],\n",
+ " sizes=[model_w, cond_h],\n",
+ " name=\"Filling\",\n",
+ " material=\"FR4_epoxy\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1c14ded",
+ "metadata": {},
+ "source": [
+ "## Assign conductors\n",
+ "\n",
+ "Assign conductors to the signal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6520b24b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.assign_single_conductor(\n",
+ " name=signal_p_1.name,\n",
+ " assignment=[signal_p_1],\n",
+ " conductor_type=\"SignalLine\",\n",
+ " solve_option=\"SolveOnBoundary\",\n",
+ " units=\"mm\",\n",
+ ")\n",
+ "\n",
+ "q2d.assign_single_conductor(\n",
+ " name=signal_n_1.name,\n",
+ " assignment=[signal_n_1],\n",
+ " conductor_type=\"SignalLine\",\n",
+ " solve_option=\"SolveOnBoundary\",\n",
+ " units=\"mm\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe4350cf",
+ "metadata": {},
+ "source": [
+ "## Create reference ground\n",
+ "\n",
+ "Create a reference ground."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "db76dbc4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.assign_single_conductor(\n",
+ " name=\"gnd\",\n",
+ " assignment=[ref_gnd_u, ref_gnd_l],\n",
+ " conductor_type=\"ReferenceGround\",\n",
+ " solve_option=\"SolveOnBoundary\",\n",
+ " units=\"mm\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a47c1e30",
+ "metadata": {},
+ "source": [
+ "## Assign Huray model on signals\n",
+ "\n",
+ "Assign the Huray model on the signals."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "47b239a4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.assign_huray_finitecond_to_edges(\n",
+ " signal_p_1.edges, radius=\"0.5um\", ratio=3, name=\"b_\" + signal_p_1.name\n",
+ ")\n",
+ "\n",
+ "q2d.assign_huray_finitecond_to_edges(\n",
+ " signal_n_1.edges, radius=\"0.5um\", ratio=3, name=\"b_\" + signal_n_1.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7c2f6740",
+ "metadata": {},
+ "source": [
+ "## Define differential pair\n",
+ "\n",
+ "Define the differential pair."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e5d2b3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "matrix = q2d.insert_reduced_matrix(\n",
+ " operation_name=q2d.MATRIXOPERATIONS.DiffPair,\n",
+ " assignment=[\"signal_p_1\", \"signal_n_1\"],\n",
+ " reduced_matrix=\"diff_pair\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "134b01c3",
+ "metadata": {},
+ "source": [
+ "## Create setup, analyze, and plot\n",
+ "\n",
+ "Create a setup, analyze, and plot solution data."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a90c24fa",
+ "metadata": {},
+ "source": [
+ "Create a setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cf29e12e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = q2d.create_setup(name=\"new_setup\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d5cfe6c",
+ "metadata": {},
+ "source": [
+ "Add a sweep."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be9ff48d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sweep = setup.add_sweep(name=\"sweep1\", sweep_type=\"Discrete\")\n",
+ "sweep.props[\"RangeType\"] = \"LinearStep\"\n",
+ "sweep.props[\"RangeStart\"] = \"1GHz\"\n",
+ "sweep.props[\"RangeStep\"] = \"100MHz\"\n",
+ "sweep.props[\"RangeEnd\"] = \"5GHz\"\n",
+ "sweep.props[\"SaveFields\"] = False\n",
+ "sweep.props[\"SaveRadFields\"] = False\n",
+ "sweep.props[\"Type\"] = \"Interpolating\"\n",
+ "sweep.update()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a42eea42",
+ "metadata": {},
+ "source": [
+ "Analyze the nominal design and plot characteristic impedance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e552e879",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.analyze(cores=NUM_CORES)\n",
+ "plot_sources = matrix.get_sources_for_plot(category=\"Z0\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "82bff30a",
+ "metadata": {},
+ "source": [
+ "Get simulation results as a ``SolutionData`` object and plot to a JPG file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "34855f03",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = q2d.post.get_solution_data(expressions=plot_sources, context=matrix.name)\n",
+ "data.plot(snapshot_path=os.path.join(temp_folder.name, \"plot.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "338bde5c",
+ "metadata": {},
+ "source": [
+ "-"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cf7a91d6",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ed76a6b7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "q2d.save_project()\n",
+ "q2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac5e0222",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08cf74cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/index.rst.txt b/version/dev/_sources/examples/index.rst.txt
new file mode 100644
index 00000000..c0150441
--- /dev/null
+++ b/version/dev/_sources/examples/index.rst.txt
@@ -0,0 +1,97 @@
+.. _ref_examples:
+
+Examples
+========
+This repository contains end-to-end embedding examples that demonstrate how to use
+`PyAEDT ![](\"_static/rectifier.png\")
\n",
+ "\n",
+ "Keywords: **Twin Builder**, **rectifier**, **filter**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8de04611",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1a3910e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bb4b9a47",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fcbae602",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "444e5f5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "676ab954",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e60ed65b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "65aad1ce",
+ "metadata": {},
+ "source": [
+ "## Launch Twin Builder\n",
+ "\n",
+ "Launch Twin Builder using an implicit declaration and add a new design with\n",
+ "the default setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66fabb94",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"TB_Rectifier_Demo.aedt\")\n",
+ "tb = ansys.aedt.core.TwinBuilder(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "96394242",
+ "metadata": {},
+ "source": [
+ "## Create components\n",
+ "\n",
+ "Place components for a bridge rectifier and a capacitor filter in the schematic editor.\n",
+ "\n",
+ "Specify the grid spacing to use for placement\n",
+ "of components in the schematic editor. Components are placed using the named\n",
+ "argument ``location`` as a list of ``[x, y]`` values in millimeters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1376e0bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "G = 0.00254"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7bda17a8",
+ "metadata": {},
+ "source": [
+ "Create an AC sinosoidal voltage source."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "46e6ba08",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "source = tb.modeler.schematic.create_voltage_source(\n",
+ " \"V_AC\", \"ESINE\", 100, 50, location=[-1 * G, 0]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a494fbdf",
+ "metadata": {},
+ "source": [
+ "Place the four diodes of the bridge rectifier. The named argument ``angle`` is the rotation angle\n",
+ "of the component in radians."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4a977381",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "diode1 = tb.modeler.schematic.create_diode(\n",
+ " name=\"D1\", location=[10 * G, 6 * G], angle=270\n",
+ ")\n",
+ "diode2 = tb.modeler.schematic.create_diode(\n",
+ " name=\"D2\", location=[20 * G, 6 * G], angle=270\n",
+ ")\n",
+ "diode3 = tb.modeler.schematic.create_diode(\n",
+ " name=\"D3\", location=[10 * G, -4 * G], angle=270\n",
+ ")\n",
+ "diode4 = tb.modeler.schematic.create_diode(\n",
+ " name=\"D4\", location=[20 * G, -4 * G], angle=270\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e297faf",
+ "metadata": {},
+ "source": [
+ "Place a capacitor filter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fe03e2b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "capacitor = tb.modeler.schematic.create_capacitor(\n",
+ " name=\"C_FILTER\", value=1e-6, location=[29 * G, -10 * G]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d5238742",
+ "metadata": {},
+ "source": [
+ "Place a load resistor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7a8561dd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "resistor = tb.modeler.schematic.create_resistor(\n",
+ " name=\"RL\", value=100000, location=[39 * G, -10 * G]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cba3143a",
+ "metadata": {},
+ "source": [
+ "Place the ground component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "47f1292e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "gnd = tb.modeler.components.create_gnd(location=[5 * G, -16 * G])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "454e1520",
+ "metadata": {},
+ "source": [
+ "## Connect components\n",
+ "\n",
+ "Connect components with wires, and connect the diode pins to create the bridge."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5eca9993",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[diode1.pins[0].location, diode3.pins[0].location]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[diode2.pins[1].location, diode4.pins[1].location]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[diode1.pins[1].location, diode2.pins[0].location]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[diode3.pins[1].location, diode4.pins[0].location]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5dc45d00",
+ "metadata": {},
+ "source": [
+ "Connect the voltage source to the bridge."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a818461c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[source.pins[1].location, [0, 10 * G], [15 * G, 10 * G], [15 * G, 5 * G]]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[source.pins[0].location, [0, -10 * G], [15 * G, -10 * G], [15 * G, -5 * G]]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dbae03e3",
+ "metadata": {},
+ "source": [
+ "Connect the filter capacitor and load resistor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "17a6b905",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[resistor.pins[0].location, [40 * G, 0], [22 * G, 0]]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(points=[capacitor.pins[0].location, [30 * G, 0]])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66573c02",
+ "metadata": {},
+ "source": [
+ "Add the ground connection."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "13cb9f77",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.modeler.schematic.create_wire(\n",
+ " points=[resistor.pins[1].location, [40 * G, -15 * G], gnd.pins[0].location]\n",
+ ")\n",
+ "tb.modeler.schematic.create_wire(points=[capacitor.pins[1].location, [30 * G, -15 * G]])\n",
+ "tb.modeler.schematic.create_wire(points=[gnd.pins[0].location, [5 * G, 0], [8 * G, 0]])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "38386f4a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Zoom to fit the schematic\n",
+ "tb.modeler.zoom_to_fit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdad7f80",
+ "metadata": {},
+ "source": [
+ "The circuit schematic should now be visible in the Twin Builder\n",
+ "schematic editor and look like\n",
+ "the image shown at the beginning of the example.\n",
+ "\n",
+ "## Run the simulation\n",
+ "\n",
+ "Update the total time to be simulated and run the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9287a099",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.set_end_time(\"100ms\")\n",
+ "tb.analyze_setup(\"TR\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c304f38d",
+ "metadata": {},
+ "source": [
+ "## Get report data and plot using Matplotlib\n",
+ "\n",
+ "Get report data and plot it using Matplotlib. The following code gets and plots\n",
+ "the values for the voltage on the pulse voltage source and the values for the\n",
+ "voltage on the capacitor in the RC circuit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "341fb96e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "src_name = source.InstanceName + \".V\"\n",
+ "x = tb.post.get_solution_data(src_name, \"TR\", \"Time\")\n",
+ "plt.plot(x.intrinsics[\"Time\"], x.data_real(src_name))\n",
+ "plt.grid()\n",
+ "plt.xlabel(\"Time\")\n",
+ "plt.ylabel(\"AC Voltage\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dfdfce36",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "r_voltage = resistor.InstanceName + \".V\"\n",
+ "x = tb.post.get_solution_data(r_voltage, \"TR\", \"Time\")\n",
+ "plt.plot(x.intrinsics[\"Time\"], x.data_real(r_voltage))\n",
+ "plt.grid()\n",
+ "plt.xlabel(\"Time\")\n",
+ "plt.ylabel(\"AC to DC Conversion using Rectifier\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3c4ca105",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d01400d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.save_project()\n",
+ "tb.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3391a477",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "26cfbb5c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/general/twin_builder/static_rom.ipynb.txt b/version/dev/_sources/examples/low_frequency/general/twin_builder/static_rom.ipynb.txt
new file mode 100644
index 00000000..613d6536
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/general/twin_builder/static_rom.ipynb.txt
@@ -0,0 +1,495 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "5c6b65c3",
+ "metadata": {},
+ "source": [
+ "# Static ROM\n",
+ "\n",
+ "This example shows how to create a static reduced order model (ROM)\n",
+ "in Twin Builder and run a transient simulation.\n",
+ "\n",
+ "> **Note:** This example uses functionality only available in Twin Builder 2024 R2 and later.\n",
+ "\n",
+ "Keywords: **Twin Builder**, **Static ROM**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4995cd5c",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "87945652",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import shutil\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df6a22dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import TwinBuilder, downloads"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4bc681f8",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a9f959d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bba3ce8d",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c6b6ba99",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99d2ed16",
+ "metadata": {},
+ "source": [
+ "## Set up input data\n",
+ "\n",
+ "The following files are downloaded along with the\n",
+ "other project data used to run this example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8b543bab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "source_snapshot_data_zipfilename = \"Ex1_Fluent_StaticRom.zip\"\n",
+ "source_build_conf_file = \"SROMbuild.conf\"\n",
+ "source_props_conf_file = \"SROM_props.conf\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "788a44d9",
+ "metadata": {},
+ "source": [
+ "## Download example data\n",
+ "\n",
+ "The following cell downloads the required files needed to run this example and\n",
+ "extracts them in a local folder named ``\"Ex04\"``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5daf4d94",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ = downloads.download_twin_builder_data(\n",
+ " file_name=source_snapshot_data_zipfilename,\n",
+ " force_download=True,\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "\n",
+ "_ = downloads.download_twin_builder_data(source_build_conf_file, True, temp_folder.name)\n",
+ "source_data_folder = downloads.download_twin_builder_data(\n",
+ " source_props_conf_file, True, temp_folder.name\n",
+ ")\n",
+ "\n",
+ "# Target folder to extract project files.\n",
+ "data_folder = os.path.join(source_data_folder, \"Ex04\")\n",
+ "\n",
+ "# Unzip training data and config file\n",
+ "downloads.unzip(\n",
+ " os.path.join(source_data_folder, source_snapshot_data_zipfilename), data_folder\n",
+ ")\n",
+ "shutil.copyfile(\n",
+ " os.path.join(source_data_folder, source_build_conf_file),\n",
+ " os.path.join(data_folder, source_build_conf_file),\n",
+ ")\n",
+ "shutil.copyfile(\n",
+ " os.path.join(source_data_folder, source_props_conf_file),\n",
+ " os.path.join(data_folder, source_props_conf_file),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd311465",
+ "metadata": {},
+ "source": [
+ "## Launch Twin Builder and build ROM component\n",
+ "\n",
+ "Launch Twin Builder using an implicit declaration and add a new design with\n",
+ "the default setup for building the static ROM component."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d7df6566",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"static_rom.aedt\")\n",
+ "tb = TwinBuilder(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ff6e81c4",
+ "metadata": {},
+ "source": [
+ "## Configure AEDT\n",
+ "\n",
+ "> **Note:** Only run the following cell if AEDT is not configured to run Twin Builder.\n",
+ ">\n",
+ "> The following cell configures AEDT and the schematic editor\n",
+ "> to use the ``Twin Builder`` configuration.\n",
+ "> The Static ROM feature is only available with a Twin Builder license.\n",
+ "> A cell at the end of this example restores the AEDT configuration. If your\n",
+ "> environment is set up to use the ``Twin Builder`` configuration, you do not\n",
+ "> need to run these sections."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d00754ae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "current_desktop_config = tb._odesktop.GetDesktopConfiguration()\n",
+ "current_schematic_environment = tb._odesktop.GetSchematicEnvironment()\n",
+ "tb._odesktop.SetDesktopConfiguration(\"Twin Builder\")\n",
+ "tb._odesktop.SetSchematicEnvironment(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af6af5a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Get the static ROM builder object.\n",
+ "rom_manager = tb._odesign.GetROMManager()\n",
+ "static_rom_builder = rom_manager.GetStaticROMBuilder()\n",
+ "\n",
+ "# Build the static ROM with the specified configuration file\n",
+ "confpath = os.path.join(data_folder, source_build_conf_file)\n",
+ "static_rom_builder.Build(confpath.replace(\"\\\\\", \"/\"))\n",
+ "\n",
+ "# Test if the ROM was created successfully.\n",
+ "static_rom_path = os.path.join(data_folder, \"StaticRom.rom\")\n",
+ "if os.path.exists(static_rom_path):\n",
+ " tb.logger.info(\"Built intermediate rom file successfully at: %s\", static_rom_path)\n",
+ "else:\n",
+ " tb.logger.error(\"Intermediate rom file not found at: %s\", static_rom_path)\n",
+ "\n",
+ "# Create the ROM component definition in Twin Builder.\n",
+ "rom_manager.CreateROMComponent(static_rom_path.replace(\"\\\\\", \"/\"), \"staticrom\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8870b5e0",
+ "metadata": {},
+ "source": [
+ "## Create schematic\n",
+ "\n",
+ "Place components to create the schematic."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0308aae8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Define the grid distance for ease in calculations.\n",
+ "G = 0.00254\n",
+ "\n",
+ "# Place a dynamic ROM component.\n",
+ "rom1 = tb.modeler.schematic.create_component(\"ROM1\", \"\", \"staticrom\", [40 * G, 25 * G])\n",
+ "\n",
+ "# Place two excitation sources.\n",
+ "source1 = tb.modeler.schematic.create_periodic_waveform_source(\n",
+ " None, \"SINE\", 2.5, 0.01, 0, 7.5, 0, [20 * G, 29 * G]\n",
+ ")\n",
+ "source2 = tb.modeler.schematic.create_periodic_waveform_source(\n",
+ " None, \"SINE\", 50, 0.02, 0, 450, 0, [20 * G, 25 * G]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e5551422",
+ "metadata": {},
+ "source": [
+ "Connect components with wires."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b15a252b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.modeler.schematic.create_wire([[22 * G, 29 * G], [33 * G, 29 * G]])\n",
+ "tb.modeler.schematic.create_wire(\n",
+ " [[22 * G, 25 * G], [30 * G, 25 * G], [30 * G, 28 * G], [33 * G, 28 * G]]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c64f2534",
+ "metadata": {},
+ "source": [
+ "Enable storage of views."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dbdb8ff5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rom1.set_property(\"store_snapshots\", 1)\n",
+ "rom1.set_property(\"view1_storage_period\", \"10s\")\n",
+ "rom1.set_property(\"view2_storage_period\", \"10s\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e810b43a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Zoom to fit the schematic\n",
+ "tb.modeler.zoom_to_fit()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "726bbb90",
+ "metadata": {},
+ "source": [
+ "## Parametrize transient setup\n",
+ "\n",
+ "Parametrize the default transient setup by setting the end time."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f36fac04",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.set_end_time(\"300s\")\n",
+ "tb.set_hmin(\"1s\")\n",
+ "tb.set_hmax(\"1s\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "87fba2cc",
+ "metadata": {},
+ "source": [
+ "## Solve transient setup\n",
+ "\n",
+ "Solve the transient setup. Skipping this step in case the documentation is being built."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10694e4f",
+ "metadata": {},
+ "source": [
+ "> **Note:** The following code can be uncommented.\n",
+ "\n",
+ "tb.analyze_setup(\"TR\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7bfaf27",
+ "metadata": {},
+ "source": [
+ "## Get report data and plot using Matplotlib\n",
+ "\n",
+ "Get report data and plot it using Matplotlib. The following code gets and plots\n",
+ "the values for the voltage on the pulse voltage source and the values for the\n",
+ "output of the dynamic ROM."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f570009a",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "source": [
+ "> **Note:** The following code can be uncommented, but it depends on the previous commented code.\n",
+ "\n",
+ "e_value = \"ROM1.outfield_mode_1\"\n",
+ "x = tb.post.get_solution_data(e_value, \"TR\", \"Time\")\n",
+ "x.plot()\n",
+ "e_value = \"ROM1.outfield_mode_2\"\n",
+ "x = tb.post.get_solution_data(e_value, \"TR\", \"Time\")\n",
+ "x.plot()\n",
+ "e_value = \"SINE1.VAL\"\n",
+ "x = tb.post.get_solution_data(e_value, \"TR\", \"Time\")\n",
+ "x.plot()\n",
+ "e_value = \"SINE2.VAL\"\n",
+ "x = tb.post.get_solution_data(e_value, \"TR\", \"Time\")\n",
+ "x.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7507a93d",
+ "metadata": {},
+ "source": [
+ "## Close Twin Builder\n",
+ "\n",
+ "After the simulation is completed, either close Twin Builder or release it.\n",
+ "All methods provide for saving the project before closing."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50ac6cd1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Clean up the downloaded data.\n",
+ "shutil.rmtree(source_data_folder)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c6b19d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Restore earlier desktop configuration and schematic environment.\n",
+ "tb._odesktop.SetDesktopConfiguration(current_desktop_config)\n",
+ "tb._odesktop.SetSchematicEnvironment(current_schematic_environment)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c7ea149e",
+ "metadata": {},
+ "source": [
+ "## Release AEDT\n",
+ "\n",
+ "Release AEDT and close the example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d52e9c56",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tb.save_project()\n",
+ "tb.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28f783b9",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``. If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3e6d3168",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/index.rst.txt b/version/dev/_sources/examples/low_frequency/index.rst.txt
new file mode 100644
index 00000000..43c6af5b
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/index.rst.txt
@@ -0,0 +1,95 @@
+Low frequency
+=============
+
+These end-to-end examples show how to use PyAEDT for low-frequency applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: General
+ :padding: 2 2 2 2
+ :link: general/index
+ :link-type: doc
+
+ .. image:: _static/general.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ General examples
+
+ .. grid-item-card:: Motor
+ :padding: 2 2 2 2
+ :link: motor/index
+ :link-type: doc
+
+ .. image:: _static/motor_maxwell.png
+ :alt: PCB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Motor examples
+
+ .. grid-item-card:: Magnetics
+ :padding: 2 2 2 2
+ :link: magnetic/index
+ :link-type: doc
+
+ .. image:: _static/magnetic.png
+ :alt: Filter
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Magnetics examples
+
+ .. grid-item-card:: T.E.A.M
+ :padding: 2 2 2 2
+ :link: team_problem/index
+ :link-type: doc
+
+ .. image:: _static/TEAM.png
+ :alt: Filter
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ T.E.A.M. problems set by COMPUMAG
+
+ .. grid-item-card:: Multiphysics
+ :padding: 2 2 2 2
+ :link: multiphysics/index
+ :link-type: doc
+
+ .. image:: _static/CFD_coil.png
+ :alt: Stress PCB
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ Multiphysics examples
+
+ .. grid-item-card:: Report
+ :padding: 2 2 2 2
+ :link: ../aedt_general/report/index
+ :link-type: doc
+
+ .. image:: ../aedt_general/_static/touchstone.png
+ :alt: Components
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ These examples use PyAEDT to show some report capabilities.
+
+ .. toctree::
+ :hidden:
+
+ general/index
+ motor/index
+ magnetic/index
+ team_problem/index
+ multiphysics/index
+ ../aedt_general/report/index
diff --git a/version/dev/_sources/examples/low_frequency/magnetic/choke.ipynb.txt b/version/dev/_sources/examples/low_frequency/magnetic/choke.ipynb.txt
new file mode 100644
index 00000000..c4719db6
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/magnetic/choke.ipynb.txt
@@ -0,0 +1,525 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "9cf26695",
+ "metadata": {},
+ "source": [
+ "# Choke setup\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a choke setup in Maxwell 3D.\n",
+ "\n",
+ "Keywords: **Maxwell 3D**, **choke**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "41c71e82",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41ef124a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7cfada87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f63c25f0",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "295ee387",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a6fd95e",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eb8475d3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1b488f2",
+ "metadata": {},
+ "source": [
+ "## Launch Maxwell3D\n",
+ "\n",
+ "Launch Maxwell 3D 2024 R2 in graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3c79e494",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"choke.aedt\")\n",
+ "m3d = ansys.aedt.core.Maxwell3d(\n",
+ " project=project_name,\n",
+ " solution_type=\"EddyCurrent\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ab404213",
+ "metadata": {},
+ "source": [
+ "## Define parameters\n",
+ "\n",
+ "The dictionary values contain the different parameter values of the core and\n",
+ "the windings that compose the choke. You must not change the main structure of\n",
+ "the dictionary. The dictionary has many primary keys, including\n",
+ "``\"Number of Windings\"``, ``\"Layer\"``, and ``\"Layer Type\"``, that have\n",
+ "dictionaries as values. The keys of these dictionaries are secondary keys\n",
+ "of the dictionary values, such as ``\"1\"``, ``\"2\"``, ``\"3\"``, ``\"4\"``, and\n",
+ "``\"Simple\"``.\n",
+ "\n",
+ "You must not modify the primary or secondary keys. You can modify only their values.\n",
+ "You must not change the data types for these keys. For the dictionaries from\n",
+ "``\"Number of Windings\"`` through ``\"Wire Section\"``, values must be Boolean. Only\n",
+ "one value per dictionary can be ``True``. If all values are ``True``, only the first one\n",
+ "remains set to ``True``. If all values are ``False``, the first value is chosen as the\n",
+ "correct one by default. For the dictionaries from ``\"Core\"`` through ``\"Inner Winding\"``,\n",
+ "values must be strings, floats, or integers.\n",
+ "\n",
+ "Descriptions follow for the primary keys:\n",
+ "\n",
+ "- ``\"Number of Windings\"``: Number of windings around the core.\n",
+ "- ``\"Layer\"``: Number of layers of all windings.\n",
+ "- ``\"Layer Type\"``: Whether layers of a winding are linked to each other\n",
+ "- ``\"Similar Layer\"``: Whether layers of a winding have the same number of turns and\n",
+ "same spacing between turns.\n",
+ "- ``\"Mode\"``: When there are only two windows, whether they are in common or differential mode.\n",
+ "- ``\"Wire Section\"``: Type of wire section and number of segments.\n",
+ "- ``\"Core\"``: Design of the core.\n",
+ "- ``\"Outer Winding\"``: Design of the first layer or outer layer of a winding and the common\n",
+ "parameters for all layers.\n",
+ "- ``\"Mid Winding\"``: Turns and turns spacing (``Coil Pit``) for the second or\n",
+ "mid layer if it is necessary.\n",
+ "- ``\"Inner Winding\"``: Turns and turns spacing (``Coil Pit``) for the third or inner\n",
+ "layer if it is necessary.\n",
+ "- ``\"Occupation(%)\"``: An informative parameter that is useless to modify.\n",
+ "\n",
+ "The following parameter values work. You can modify them if you want."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aeae713e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "values = {\n",
+ " \"Number of Windings\": {\"1\": False, \"2\": False, \"3\": True, \"4\": False},\n",
+ " \"Layer\": {\"Simple\": False, \"Double\": False, \"Triple\": True},\n",
+ " \"Layer Type\": {\"Separate\": False, \"Linked\": True},\n",
+ " \"Similar Layer\": {\"Similar\": False, \"Different\": True},\n",
+ " \"Mode\": {\"Differential\": True, \"Common\": False},\n",
+ " \"Wire Section\": {\"None\": False, \"Hexagon\": False, \"Octagon\": True, \"Circle\": False},\n",
+ " \"Core\": {\n",
+ " \"Name\": \"Core\",\n",
+ " \"Material\": \"ferrite\",\n",
+ " \"Inner Radius\": 100,\n",
+ " \"Outer Radius\": 143,\n",
+ " \"Height\": 25,\n",
+ " \"Chamfer\": 0.8,\n",
+ " },\n",
+ " \"Outer Winding\": {\n",
+ " \"Name\": \"Winding\",\n",
+ " \"Material\": \"copper\",\n",
+ " \"Inner Radius\": 100,\n",
+ " \"Outer Radius\": 143,\n",
+ " \"Height\": 25,\n",
+ " \"Wire Diameter\": 5,\n",
+ " \"Turns\": 2,\n",
+ " \"Coil Pit(deg)\": 4,\n",
+ " \"Occupation(%)\": 0,\n",
+ " },\n",
+ " \"Mid Winding\": {\"Turns\": 7, \"Coil Pit(deg)\": 4, \"Occupation(%)\": 0},\n",
+ " \"Inner Winding\": {\"Turns\": 10, \"Coil Pit(deg)\": 4, \"Occupation(%)\": 0},\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b91022f",
+ "metadata": {},
+ "source": [
+ "## Convert dictionary to JSON file\n",
+ "\n",
+ "Convert the dictionary to a JSON file. PyAEDT methods ask for the path of the\n",
+ "JSON file as an argument. You can convert a dictionary to a JSON file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cd17183f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "json_path = os.path.join(temp_folder.name, \"choke_example.json\")\n",
+ "\n",
+ "with open(json_path, \"w\") as outfile:\n",
+ " json.dump(values, outfile)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f6a715e",
+ "metadata": {},
+ "source": [
+ "## Verify parameters of JSON file\n",
+ "\n",
+ "Verify parameters of the JSON file. The ``check_choke_values()`` method takes\n",
+ "the JSON file path as an argument and does the following:\n",
+ "\n",
+ "- Checks if the JSON file is correctly written (as explained earlier)\n",
+ "- Checks equations on windings parameters to avoid having unintended intersections"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "117d6549",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dictionary_values = m3d.modeler.check_choke_values(\n",
+ " input_dir=json_path, create_another_file=False\n",
+ ")\n",
+ "print(dictionary_values)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6287e25f",
+ "metadata": {},
+ "source": [
+ "## Create choke\n",
+ "\n",
+ "Create the choke. The ``create_choke()`` method takes the JSON file path as an\n",
+ "argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1203d80b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "list_object = m3d.modeler.create_choke(input_file=json_path)\n",
+ "print(list_object)\n",
+ "core = list_object[1]\n",
+ "first_winding_list = list_object[2]\n",
+ "second_winding_list = list_object[3]\n",
+ "third_winding_list = list_object[4]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "086c7351",
+ "metadata": {},
+ "source": [
+ "## Assign excitations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7d99132e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "first_winding_faces = m3d.modeler.get_object_faces(\n",
+ " assignment=first_winding_list[0].name\n",
+ ")\n",
+ "second_winding_faces = m3d.modeler.get_object_faces(\n",
+ " assignment=second_winding_list[0].name\n",
+ ")\n",
+ "third_winding_faces = m3d.modeler.get_object_faces(\n",
+ " assignment=third_winding_list[0].name\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[first_winding_faces[-1]],\n",
+ " amplitude=1000,\n",
+ " phase=\"0deg\",\n",
+ " swap_direction=False,\n",
+ " name=\"phase_1_in\",\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[first_winding_faces[-2]],\n",
+ " amplitude=1000,\n",
+ " phase=\"0deg\",\n",
+ " swap_direction=True,\n",
+ " name=\"phase_1_out\",\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[second_winding_faces[-1]],\n",
+ " amplitude=1000,\n",
+ " phase=\"120deg\",\n",
+ " swap_direction=False,\n",
+ " name=\"phase_2_in\",\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[second_winding_faces[-2]],\n",
+ " amplitude=1000,\n",
+ " phase=\"120deg\",\n",
+ " swap_direction=True,\n",
+ " name=\"phase_2_out\",\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[third_winding_faces[-1]],\n",
+ " amplitude=1000,\n",
+ " phase=\"240deg\",\n",
+ " swap_direction=False,\n",
+ " name=\"phase_3_in\",\n",
+ ")\n",
+ "m3d.assign_current(\n",
+ " assignment=[third_winding_faces[-2]],\n",
+ " amplitude=1000,\n",
+ " phase=\"240deg\",\n",
+ " swap_direction=True,\n",
+ " name=\"phase_3_out\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac55360b",
+ "metadata": {},
+ "source": [
+ "## Assign matrix"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "34d0270f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.assign_matrix(\n",
+ " assignment=[\"phase_1_in\", \"phase_2_in\", \"phase_3_in\"], matrix_name=\"current_matrix\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6c105c29",
+ "metadata": {},
+ "source": [
+ "## Create mesh operation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ef98381a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mesh = m3d.mesh\n",
+ "mesh.assign_skin_depth(\n",
+ " assignment=[first_winding_list[0], second_winding_list[0], third_winding_list[0]],\n",
+ " skin_depth=0.20,\n",
+ " triangulation_max_length=\"10mm\",\n",
+ " name=\"skin_depth\",\n",
+ ")\n",
+ "mesh.assign_surface_mesh_manual(\n",
+ " assignment=[first_winding_list[0], second_winding_list[0], third_winding_list[0]],\n",
+ " surface_deviation=None,\n",
+ " normal_dev=\"30deg\",\n",
+ " name=\"surface_approx\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c49cfeac",
+ "metadata": {},
+ "source": [
+ "## Create boundaries\n",
+ "\n",
+ "Create the boundaries. A region with openings is needed to run the analysis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9b392ce6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = m3d.modeler.create_air_region(\n",
+ " x_pos=100, y_pos=100, z_pos=100, x_neg=100, y_neg=100, z_neg=0\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b8ed5921",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup with a sweep to run the simulation. Depending on your machine's\n",
+ "computing power, the simulation can take some time to run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4e821124",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = m3d.create_setup(\"MySetup\")\n",
+ "print(setup.props)\n",
+ "setup.props[\"Frequency\"] = \"100kHz\"\n",
+ "setup.props[\"PercentRefinement\"] = 15\n",
+ "setup.props[\"MaximumPasses\"] = 10\n",
+ "setup.props[\"HasSweepSetup\"] = True\n",
+ "setup.add_eddy_current_sweep(\n",
+ " range_type=\"LinearCount\", start=100, end=1000, count=12, units=\"kHz\", clear=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "508dd90e",
+ "metadata": {},
+ "source": [
+ "## Save project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d76b066d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.save_project()\n",
+ "m3d.modeler.fit_all()\n",
+ "m3d.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Image.jpg\"),\n",
+ " plot_air_objects=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0186c92a",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "baee8b06",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.save_project()\n",
+ "m3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e8332cf",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6fa34b3e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/magnetic/index.rst.txt b/version/dev/_sources/examples/low_frequency/magnetic/index.rst.txt
new file mode 100644
index 00000000..0a0f440f
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/magnetic/index.rst.txt
@@ -0,0 +1,68 @@
+Magnetics
+~~~~~~~~~
+
+These examples use PyAEDT to show some magnetics applications.
+
+.. grid:: 2
+
+ .. grid-item-card:: Transient winding analysis
+ :padding: 2 2 2 2
+ :link: transient_winding
+ :link-type: doc
+
+ .. image:: _static/transient.png
+ :alt: Maxwell transient
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a project in Maxwell 2D and run a transient simulation.
+
+ .. grid-item-card:: Choke setup
+ :padding: 2 2 2 2
+ :link: choke
+ :link-type: doc
+
+ .. image:: _static/choke.png
+ :alt: Maxwell choke
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a choke setup in Maxwell 3D.
+
+
+ .. grid-item-card:: Magnetomotive force
+ :padding: 2 2 2 2
+ :link: magneto_motive_line
+ :link-type: doc
+
+ .. image:: _static/magneto.png
+ :alt: Maxwell magneto force
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to calculate the magnetomotive force.
+
+
+ .. grid-item-card:: Lorentz actuator
+ :padding: 2 2 2 2
+ :link: lorentz_actuator
+ :link-type: doc
+
+ .. image:: _static/lorentz_actuator.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses PyAEDT to set up a Lorentz actuator and solve it using the Maxwell 2D transient solver.
+
+ .. toctree::
+ :hidden:
+
+ transient_winding
+ choke
+ magneto_motive_line
+ lorentz_actuator
diff --git a/version/dev/_sources/examples/low_frequency/magnetic/lorentz_actuator.ipynb.txt b/version/dev/_sources/examples/low_frequency/magnetic/lorentz_actuator.ipynb.txt
new file mode 100644
index 00000000..0386edc2
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/magnetic/lorentz_actuator.ipynb.txt
@@ -0,0 +1,690 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3d3a9f0a",
+ "metadata": {},
+ "source": [
+ "# Lorentz actuator\n",
+ "\n",
+ "This example uses PyAEDT to set up a Lorentz actuator\n",
+ "and solve it using the Maxwell 2D transient solver.\n",
+ "\n",
+ "Keywords: **Maxwell2D**, **transient**, **translational motion**, **mechanical transient**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a08b9c5e",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constantss\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "56c2dd63",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2405f2af",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28f3c7b5",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "413579bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "68f9210f",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8e4fe6b8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d98da9e",
+ "metadata": {},
+ "source": [
+ "## Initialize dictionaries\n",
+ "\n",
+ "Initialize the following:\n",
+ "\n",
+ "- Electric and geometric parameters for the actuator\n",
+ "- Simulation specifications\n",
+ "- Materials for the actuator component"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0fc8291f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dimensions = {\n",
+ " \"Core_outer_x\": \"100mm\",\n",
+ " \"Core_outer_y\": \"80mm\",\n",
+ " \"Core_thickness\": \"10mm\",\n",
+ " \"Magnet_thickness\": \"10mm\",\n",
+ " \"Coil_width\": \"30mm\",\n",
+ " \"Coil_thickness\": \"5mm\",\n",
+ " \"Coil_inner_diameter\": \"20mm\",\n",
+ " \"Coil_magnet_distance\": \"5mm\",\n",
+ " \"Coil_start_position\": \"3mm\",\n",
+ " \"Band_clearance\": \"1mm\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "69ffb8e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coil_specifications = {\n",
+ " \"Winding_current\": \"5A\",\n",
+ " \"No_of_turns\": \"100\",\n",
+ " \"Coil_mass\": \"0.2kg\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b093e6d8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "simulation_specifications = {\n",
+ " \"Mesh_bands\": \"0.5mm\",\n",
+ " \"Mesh_other_objects\": \"2mm\",\n",
+ " \"Stop_time\": \"10ms\",\n",
+ " \"Time_step\": \"0.5ms\",\n",
+ " \"Save_fields_interval\": \"1\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b5c83aca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "materials = {\n",
+ " \"Coil_material\": \"copper\",\n",
+ " \"Core_material\": \"steel_1008\",\n",
+ " \"Magnet_material\": \"NdFe30\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "881a50e7",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and Maxwell 2D\n",
+ "\n",
+ "Launch AEDT and Maxwell 2D after first setting up the project name.\n",
+ "The following code also creates an instance of the\n",
+ "``Maxwell2d`` class named ``m2d`` by providing\n",
+ "the project name, the design name, the solver, the version, and the graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3cec67f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"Lorentz_actuator.aedt\")\n",
+ "m2d = ansys.aedt.core.Maxwell2d(\n",
+ " project=project_name,\n",
+ " design=\"1 transient 2D\",\n",
+ " solution_type=\"TransientXY\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49139e3a",
+ "metadata": {},
+ "source": [
+ "## Define variables from dictionaries\n",
+ "\n",
+ "Define design variables from the created dictionaries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a3910a86",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.variable_manager.set_variable(name=\"Dimensions\")\n",
+ "for k, v in dimensions.items():\n",
+ " m2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e874be83",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.variable_manager.set_variable(name=\"Winding data\")\n",
+ "for k, v in coil_specifications.items():\n",
+ " m2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ecc92ee",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.variable_manager.set_variable(name=\"Simulation data\")\n",
+ "for k, v in simulation_specifications.items():\n",
+ " m2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "91e85d27",
+ "metadata": {},
+ "source": [
+ "Definem materials."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "970be24b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.variable_manager.set_variable(name=\"Material data\")\n",
+ "m2d.logger.clear_messages()\n",
+ "for i, key in enumerate(materials.keys()):\n",
+ " if key == \"Coil_material\":\n",
+ " coil_mat_index = i\n",
+ " elif key == \"Core_material\":\n",
+ " core_mat_index = i\n",
+ " elif key == \"Magnet_material\":\n",
+ " magnet_mat_index = i\n",
+ "material_array = []\n",
+ "for k, v in materials.items():\n",
+ " material_array.append('\"' + v + '\"')\n",
+ "s = \", \".join(material_array)\n",
+ "m2d[\"Materials\"] = \"[{}]\".format(s)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1170f06a",
+ "metadata": {},
+ "source": [
+ "## Create geometry\n",
+ "\n",
+ "Create magnetic core, coils, and magnets. Assign materials and create a coordinate system to\n",
+ "define the magnet orientation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f90b469e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "core_id = m2d.modeler.create_rectangle(\n",
+ " origin=[0, 0, 0],\n",
+ " sizes=[\"Core_outer_x\", \"Core_outer_y\"],\n",
+ " name=\"Core\",\n",
+ " material=\"Materials[\" + str(core_mat_index) + \"]\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2e014839",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "hole_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\"Core_thickness\", \"Core_thickness\", 0],\n",
+ " sizes=[\"Core_outer_x-2*Core_thickness\", \"Core_outer_y-2*Core_thickness\"],\n",
+ " name=\"hole\",\n",
+ ")\n",
+ "m2d.modeler.subtract(blank_list=[core_id], tool_list=[hole_id])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "906dcd3e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "magnet_n_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\"Core_thickness\", \"Core_outer_y-2*Core_thickness\", 0],\n",
+ " sizes=[\"Core_outer_x-2*Core_thickness\", \"Magnet_thickness\"],\n",
+ " name=\"magnet_n\",\n",
+ " material=\"Materials[\" + str(magnet_mat_index) + \"]\",\n",
+ ")\n",
+ "magnet_s_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\"Core_thickness\", \"Core_thickness\", 0],\n",
+ " sizes=[\"Core_outer_x-2*Core_thickness\", \"Magnet_thickness\"],\n",
+ " name=\"magnet_s\",\n",
+ " material=\"Materials[\" + str(magnet_mat_index) + \"]\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48a5244a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.modeler.create_coordinate_system(\n",
+ " origin=[0, 0, 0], x_pointing=[0, 1, 0], y_pointing=[1, 0, 0], name=\"cs_x_positive\"\n",
+ ")\n",
+ "m2d.modeler.create_coordinate_system(\n",
+ " origin=[0, 0, 0], x_pointing=[0, -1, 0], y_pointing=[1, 0, 0], name=\"cs_x_negative\"\n",
+ ")\n",
+ "magnet_s_id.part_coordinate_system = \"cs_x_positive\"\n",
+ "magnet_n_id.part_coordinate_system = \"cs_x_negative\"\n",
+ "m2d.modeler.set_working_coordinate_system(\"Global\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8f437467",
+ "metadata": {},
+ "source": [
+ "## Assign current\n",
+ "\n",
+ "Create coil terminals with 100 turns and winding with 5A current."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "faae6287",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coil_in_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\n",
+ " \"Core_thickness+Coil_start_position\",\n",
+ " \"Core_thickness+Magnet_thickness+Coil_magnet_distance\",\n",
+ " 0,\n",
+ " ],\n",
+ " sizes=[\"Coil_width\", \"Coil_thickness\"],\n",
+ " name=\"coil_in\",\n",
+ " material=\"Materials[\" + str(coil_mat_index) + \"]\",\n",
+ ")\n",
+ "coil_out_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\n",
+ " \"Core_thickness+Coil_start_position\",\n",
+ " \"Core_thickness+Magnet_thickness+Coil_magnet_distance+Coil_inner_diameter+Coil_thickness\",\n",
+ " 0,\n",
+ " ],\n",
+ " sizes=[\"Coil_width\", \"Coil_thickness\"],\n",
+ " name=\"coil_out\",\n",
+ " material=\"Materials[\" + str(coil_mat_index) + \"]\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "53e3a945",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_coil(\n",
+ " assignment=[coil_in_id],\n",
+ " conductors_number=\"No_of_turns\",\n",
+ " name=\"coil_terminal_in\",\n",
+ " polarity=\"Negative\",\n",
+ ")\n",
+ "m2d.assign_coil(\n",
+ " assignment=[coil_out_id],\n",
+ " conductors_number=\"No_of_turns\",\n",
+ " name=\"coil_terminal_out\",\n",
+ " polarity=\"Positive\",\n",
+ ")\n",
+ "m2d.assign_winding(is_solid=False, current=\"Winding_current\", name=\"Winding1\")\n",
+ "m2d.add_winding_coils(\n",
+ " assignment=\"Winding1\", coils=[\"coil_terminal_in\", \"coil_terminal_out\"]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c48d1ba",
+ "metadata": {},
+ "source": [
+ "## Assign motion\n",
+ "\n",
+ "Create band objects. All the objects within the band move. The inner band ensures that the mesh is good,\n",
+ "and additionally it is required when there is more than one moving object.\n",
+ "Assign linear motion with mechanical transient."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d6898b98",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "band_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\n",
+ " \"Core_thickness + Band_clearance\",\n",
+ " \"Core_thickness+Magnet_thickness+Band_clearance\",\n",
+ " 0,\n",
+ " ],\n",
+ " sizes=[\n",
+ " \"Core_outer_x-2*(Core_thickness+Band_clearance)\",\n",
+ " \"Core_outer_y-2*(Core_thickness+Band_clearance+Magnet_thickness)\",\n",
+ " ],\n",
+ " name=\"Motion_band\",\n",
+ ")\n",
+ "inner_band_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\n",
+ " \"Core_thickness+Coil_start_position-Band_clearance\",\n",
+ " \"Core_thickness+Magnet_thickness+Coil_magnet_distance-Band_clearance\",\n",
+ " 0,\n",
+ " ],\n",
+ " sizes=[\n",
+ " \"Coil_width + 2*Band_clearance\",\n",
+ " \"Coil_inner_diameter+2*(Coil_thickness+Band_clearance)\",\n",
+ " ],\n",
+ " name=\"Motion_band_inner\",\n",
+ ")\n",
+ "motion_limit = \"Core_outer_x-2*(Core_thickness+Band_clearance)-(Coil_width + 2*Band_clearance)-2*Band_clearance\"\n",
+ "m2d.assign_translate_motion(\n",
+ " assignment=\"Motion_band\",\n",
+ " axis=\"X\",\n",
+ " periodic_translate=None,\n",
+ " mechanical_transient=True,\n",
+ " mass=\"Coil_mass\",\n",
+ " start_position=0,\n",
+ " negative_limit=0,\n",
+ " positive_limit=motion_limit,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "518f4ed1",
+ "metadata": {},
+ "source": [
+ "## Create simulation domain\n",
+ "\n",
+ "Create a region and assign zero vector potential on the region edges."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "103ea704",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region_id = m2d.modeler.create_region(pad_percent=2)\n",
+ "m2d.assign_vector_potential(assignment=region_id.edges, boundary=\"VectorPotential1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a6fb2cb6",
+ "metadata": {},
+ "source": [
+ "## Assign mesh operations\n",
+ "\n",
+ "The transient solver does not have adaptive mesh refinement, so the mesh operations must be assigned."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bcdd7b9f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=[band_id, inner_band_id],\n",
+ " maximum_length=\"Mesh_bands\",\n",
+ " maximum_elements=None,\n",
+ " name=\"Bands\",\n",
+ ")\n",
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=[coil_in_id, coil_in_id, core_id, magnet_n_id, magnet_s_id, region_id],\n",
+ " maximum_length=\"Mesh_other_objects\",\n",
+ " maximum_elements=None,\n",
+ " name=\"Coils_core_magnets\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f8ea079b",
+ "metadata": {},
+ "source": [
+ "## Turn on eddy effects\n",
+ "\n",
+ "Assign eddy effects to the magnets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aee4ed66",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.eddy_effects_on(assignment=[\"magnet_n\", \"magnet_s\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "590ad4f0",
+ "metadata": {},
+ "source": [
+ "## Turn on core loss\n",
+ "\n",
+ "Enable core loss for the core."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e592a472",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.set_core_losses(assignment=\"Core\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b3edf74",
+ "metadata": {},
+ "source": [
+ "## Create simulation setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "352a4248",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = m2d.create_setup(name=\"Setup1\")\n",
+ "setup.props[\"StopTime\"] = \"Stop_time\"\n",
+ "setup.props[\"TimeStep\"] = \"Time_step\"\n",
+ "setup.props[\"SaveFieldsType\"] = \"Every N Steps\"\n",
+ "setup.props[\"N Steps\"] = \"Save_fields_interval\"\n",
+ "setup.props[\"Steps From\"] = \"0ms\"\n",
+ "setup.props[\"Steps To\"] = \"Stop_time\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a108956f",
+ "metadata": {},
+ "source": [
+ "## Create report\n",
+ "\n",
+ "Create an XY-report with force on the coil, the position of the coil on the Y axis,\n",
+ "and time on the X axis."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "13efa88b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.post.create_report(\n",
+ " expressions=[\"Moving1.Force_x\", \"Moving1.Position\"],\n",
+ " plot_name=\"Force on Coil and Position of Coil\",\n",
+ " primary_sweep_variable=\"Time\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8374cf0c",
+ "metadata": {},
+ "source": [
+ "## Analyze project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f7441bab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup.analyze(cores=NUM_CORES, use_auto_settings=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d52c9e5",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "45e6cdf6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fa00d898",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_dir.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1c7c1b45",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/magnetic/magneto_motive_line.ipynb.txt b/version/dev/_sources/examples/low_frequency/magnetic/magneto_motive_line.ipynb.txt
new file mode 100644
index 00000000..751eae65
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/magnetic/magneto_motive_line.ipynb.txt
@@ -0,0 +1,528 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "8e166a4d",
+ "metadata": {},
+ "source": [
+ "# Magnetomotive force along a line\n",
+ "\n",
+ "This example shows how to use PyAEDT to calculate\n",
+ "the magnetomotive force along a line that changes position.\n",
+ "It shows how to leverage the PyAEDT advanced fields calculator\n",
+ "to insert a custom formula, which in this case is the integral\n",
+ "of the H field along a line.\n",
+ "The example shows two options to achieve the intent.\n",
+ "The first one creates many lines as to simulate a contour that changes position.\n",
+ "The integral of the H field is computed for each line.\n",
+ "The second option creates one parametric polyline and then uses a parametric sweep to change its position.\n",
+ "The integral of the H field is computed for each position."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38e63527",
+ "metadata": {},
+ "source": [
+ "Keywords: **Maxwell 2D**, **magnetomotive force**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88489ff3",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "838a741a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "796eb0d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b8709db2",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "562484ba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "24087981",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "466fc421",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbde2381",
+ "metadata": {},
+ "source": [
+ "## Import project\n",
+ "\n",
+ "Download the files required to run this example to the temporary working folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3f4c494d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_path = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"maxwell_magnetic_force\",\n",
+ " name=\"Maxwell_Magnetic_Force.aedt\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0c94b97",
+ "metadata": {},
+ "source": [
+ "## Initialize and launch Maxwell 2D\n",
+ "\n",
+ "Initialize and launch Maxwell 2D, providing the version and the path of the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f5625eee",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d = ansys.aedt.core.Maxwell2d(\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " project=project_path,\n",
+ " design=\"Maxwell2DDesign1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca73296c",
+ "metadata": {},
+ "source": [
+ "# First option"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d23ef0ba",
+ "metadata": {},
+ "source": [
+ "## Create a polyline\n",
+ "\n",
+ "Create a polyline, specifying its ends."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "098bf19b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "poly = m2d.modeler.create_polyline(points=[[10, -10, 0], [10, 10, 0]], name=\"polyline\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b5ee27ca",
+ "metadata": {},
+ "source": [
+ "Duplicate the polyline along a vector."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ea7436c6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "polys = [poly.name]\n",
+ "polys.extend(poly.duplicate_along_line(vector=[-0.5, 0, 0], clones=10))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0e86ed67",
+ "metadata": {},
+ "source": [
+ "## Compute magnetomotive force along each line\n",
+ "\n",
+ "Create and add a new formula to add in the PyAEDT advanced fields calculator.\n",
+ "Create the fields report object and get field data.\n",
+ "Create a data table report for the H field along each line and export it to a .csv file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "771de496",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "my_expression = {\n",
+ " \"name\": None,\n",
+ " \"description\": \"Magnetomotive force along a line\",\n",
+ " \"design_type\": [\"Maxwell 2D\", \"Maxwell 3D\"],\n",
+ " \"fields_type\": [\"Fields\"],\n",
+ " \"primary_sweep\": \"distance\",\n",
+ " \"assignment\": None,\n",
+ " \"assignment_type\": [\"Line\"],\n",
+ " \"operations\": [\n",
+ " \"Fundamental_Quantity('H')\",\n",
+ " \"Operation('Tangent')\",\n",
+ " \"Operation('Dot')\",\n",
+ " \"EnterLine('assignment')\",\n",
+ " \"Operation('LineValue')\",\n",
+ " \"Operation('Integrate')\",\n",
+ " ],\n",
+ " \"report\": [\"Data Table\"],\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "90f3a783",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "quantities = []\n",
+ "for p in polys:\n",
+ " quantity = \"H_field_{}\".format(p)\n",
+ " quantities.append(quantity)\n",
+ " my_expression[\"name\"] = quantity\n",
+ " my_expression[\"assignment\"] = quantity\n",
+ " m2d.post.fields_calculator.add_expression(my_expression, p)\n",
+ " report = m2d.post.create_report(\n",
+ " expressions=quantity,\n",
+ " context=p,\n",
+ " polyline_points=1,\n",
+ " report_category=\"Fields\",\n",
+ " plot_type=\"Data Table\",\n",
+ " plot_name=quantity,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7efea4b",
+ "metadata": {},
+ "source": [
+ "# Second option"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "09ec14f4",
+ "metadata": {},
+ "source": [
+ "## Create a design variable\n",
+ "\n",
+ "Parametrize the polyline x position."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "21641547",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d[\"xl\"] = \"10mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5f61e01b",
+ "metadata": {},
+ "source": [
+ "## Create polyline\n",
+ "\n",
+ "Create a parametrized polyline, specifying its ends."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "28c97a6c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "poly = m2d.modeler.create_polyline(\n",
+ " points=[[\"xl\", -10, 0], [\"xl\", 10, 0]], name=\"polyline_sweep\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ab23be86",
+ "metadata": {},
+ "source": [
+ "## Add parametric sweep\n",
+ "\n",
+ "Add a parametric sweep where the parameter to sweep is ``xl``.\n",
+ "Create a linear step sweep from ``10mm`` to ``15mm`` every ``1mm`` step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "42164bed",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_sweep = m2d.parametrics.add(\n",
+ " variable=\"xl\",\n",
+ " start_point=\"10mm\",\n",
+ " end_point=\"15mm\",\n",
+ " step=1,\n",
+ " variation_type=\"LinearStep\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c43d76d",
+ "metadata": {},
+ "source": [
+ "## Compute magnetomotive force along the line\n",
+ "\n",
+ "Create and add a new formula to add in the PyAEDT advanced fields calculator."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "251c3859",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "quantity_sweep = \"H_field_{}\".format(poly.name)\n",
+ "my_expression[\"name\"] = quantity_sweep\n",
+ "my_expression[\"assignment\"] = poly.name\n",
+ "m2d.post.fields_calculator.add_expression(my_expression, poly.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "55f0480b",
+ "metadata": {},
+ "source": [
+ "## Add parametric sweep calculation specifying the quantity (H) and save fields."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c8be9360",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_sweep.add_calculation(calculation=quantity_sweep, report_type=\"Fields\", ranges={})\n",
+ "param_sweep.props[\"ProdOptiSetupDataV2\"][\"SaveFields\"] = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "de26c8c0",
+ "metadata": {},
+ "source": [
+ "## Create data table report\n",
+ "\n",
+ "Create a data table report to display H for each polyline position."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b26cb24b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report_sweep = m2d.post.create_report(\n",
+ " expressions=quantity_sweep,\n",
+ " report_category=\"Fields\",\n",
+ " plot_type=\"Data Table\",\n",
+ " plot_name=quantity_sweep,\n",
+ " primary_sweep_variable=\"xl\",\n",
+ " variations={\"xl\": \"All\"},\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb1a82ff",
+ "metadata": {},
+ "source": [
+ "## Analyze parametric sweep"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7234d8bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_sweep.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8435d70",
+ "metadata": {},
+ "source": [
+ "## Export results\n",
+ "\n",
+ "Export results in a .csv file for the parametric sweep analysis (second option)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fc4d7793",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.post.export_report_to_csv(\n",
+ " project_dir=temp_folder.name,\n",
+ " plot_name=quantity_sweep,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "488eda17",
+ "metadata": {},
+ "source": [
+ "Export results in a .csv file for each polyline (first option)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e51f59f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "[\n",
+ " m2d.post.export_report_to_csv(\n",
+ " project_dir=temp_folder.name,\n",
+ " plot_name=q,\n",
+ " )\n",
+ " for q in quantities\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6f0d450",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "eb06bfa0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cf6faea",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b014914f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/magnetic/transient_winding.ipynb.txt b/version/dev/_sources/examples/low_frequency/magnetic/transient_winding.ipynb.txt
new file mode 100644
index 00000000..8bdf5c97
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/magnetic/transient_winding.ipynb.txt
@@ -0,0 +1,381 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "b3643347",
+ "metadata": {},
+ "source": [
+ "# Transient winding analysis\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a project in Maxwell 2D\n",
+ "and run a transient simulation. It runs only on Windows using CPython.\n",
+ "\n",
+ "The following libraries are required for the advanced postprocessing features\n",
+ "used in this example:\n",
+ "\n",
+ "- [Matplotlib](https://pypi.org/project/matplotlib/)\n",
+ "- [Numpy](https://pypi.org/project/numpy/)\n",
+ "- [PyVista](https://pypi.org/project/pyvista/)\n",
+ "\n",
+ "Install these libraries with this command:\n",
+ "\n",
+ "```console\n",
+ " pip install numpy pyvista matplotlib\n",
+ "```\n",
+ "\n",
+ "Keywords: **Maxwell 2D**, **transient**, **winding**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e479707",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2929527b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a92a95a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "315492cd",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "46a6b802",
+ "metadata": {
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "550d23c2",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "69dd97a2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05842a9e",
+ "metadata": {},
+ "source": [
+ "## Insert Maxwell 2D design"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ef2543bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"Transient.aedt\")\n",
+ "m2d = ansys.aedt.core.Maxwell2d(\n",
+ " solution_type=\"TransientXY\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ " project=project_name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "69b6cc7e",
+ "metadata": {},
+ "source": [
+ "## Create rectangle and duplicate it"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9a8b3fe6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rect1 = m2d.modeler.create_rectangle(\n",
+ " origin=[0, 0, 0], sizes=[10, 20], name=\"winding\", material=\"copper\"\n",
+ ")\n",
+ "duplicate = rect1.duplicate_along_line(vector=[14, 0, 0])\n",
+ "rect2 = m2d.modeler[duplicate[0]]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "63796373",
+ "metadata": {},
+ "source": [
+ "## Create air region\n",
+ "\n",
+ "Create an air region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "887933cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region = m2d.modeler.create_region([100, 100, 100, 100])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "466f6c35",
+ "metadata": {},
+ "source": [
+ "## Assign windings and balloon\n",
+ "\n",
+ "Assigns windings to the sheets and a balloon to the air region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a148ee24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_winding(\n",
+ " assignment=[rect1.name, rect2.name], current=\"1*sin(2*pi*50*Time)\", name=\"PHA\"\n",
+ ")\n",
+ "m2d.assign_balloon(assignment=region.edges)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a4923c5a",
+ "metadata": {},
+ "source": [
+ "## Create transient setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "796933b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = m2d.create_setup()\n",
+ "setup.props[\"StopTime\"] = \"0.02s\"\n",
+ "setup.props[\"TimeStep\"] = \"0.0002s\"\n",
+ "setup.props[\"SaveFieldsType\"] = \"Every N Steps\"\n",
+ "setup.props[\"N Steps\"] = \"1\"\n",
+ "setup.props[\"Steps From\"] = \"0s\"\n",
+ "setup.props[\"Steps To\"] = \"0.002s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "01aab5fe",
+ "metadata": {},
+ "source": [
+ "## Create rectangular plot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92f5cc49",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.post.create_report(\n",
+ " expressions=\"InputCurrent(PHA)\",\n",
+ " domain=\"Sweep\",\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " plot_name=\"Winding Plot 1\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f0bea11e",
+ "metadata": {},
+ "source": [
+ "## Solve model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "108822b9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.analyze(cores=NUM_CORES, use_auto_settings=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "309a5ee6",
+ "metadata": {},
+ "source": [
+ "## Create output and plot using PyVista"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cc247b48",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cutlist = [\"Global:XY\"]\n",
+ "face_lists = rect1.faces\n",
+ "face_lists += rect2.faces\n",
+ "timesteps = [str(i * 2e-4) + \"s\" for i in range(11)]\n",
+ "id_list = [f.id for f in face_lists]\n",
+ "\n",
+ "gif = m2d.post.plot_animated_field(\n",
+ " quantity=\"Mag_B\",\n",
+ " assignment=id_list,\n",
+ " plot_type=\"Surface\",\n",
+ " intrinsics={\"Time\": \"0s\"},\n",
+ " variation_variable=\"Time\",\n",
+ " variations=timesteps,\n",
+ " show=False,\n",
+ " export_gif=False,\n",
+ ")\n",
+ "gif.isometric_view = False\n",
+ "gif.camera_position = [15, 15, 80]\n",
+ "gif.focal_point = [15, 15, 0]\n",
+ "gif.roll_angle = 0\n",
+ "gif.elevation_angle = 0\n",
+ "gif.azimuth_angle = 0\n",
+ "\n",
+ "# Set off_screen to False to visualize the animation.\n",
+ "# gif.off_screen = False\n",
+ "gif.animate()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db8f6557",
+ "metadata": {},
+ "source": [
+ "## Generate plot outside of AEDT\n",
+ "\n",
+ "Generate the same plot outside AEDT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "18af4e2e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions = m2d.post.get_solution_data(\n",
+ " expressions=\"InputCurrent(PHA)\", primary_sweep_variable=\"Time\"\n",
+ ")\n",
+ "solutions.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eab293de",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "491329f6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a240ba0b",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "148a2cdb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/index.rst.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/index.rst.txt
new file mode 100644
index 00000000..8b6230f3
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/index.rst.txt
@@ -0,0 +1,97 @@
+AEDT Motor
+~~~~~~~~~~
+
+These examples use PyAEDT to show some motor applications in AEDT.
+
+.. grid:: 2
+
+ .. grid-item-card:: PM synchronous motor transient analysis
+ :padding: 2 2 2 2
+ :link: pm_synchronous
+ :link-type: doc
+
+ .. image:: _static/pm_synchronous.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a Maxwell 2D transient analysis for an interior permanent magnet (PM) electric motor.
+
+ .. grid-item-card:: Magnet segmentation
+ :padding: 2 2 2 2
+ :link: magnet_segmentation
+ :link-type: doc
+
+ .. image:: _static/magnet_segmentation.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to segment magnets of an electric motor. The method is valid and usable for any object you would like to segment.
+
+ .. grid-item-card:: IPM motor design optimization
+ :padding: 2 2 2 2
+ :link: ipm_optimization
+ :link-type: doc
+
+ .. image:: _static/ipm_optimization.png
+ :alt: IPM Motor
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to find the best machine 2D geometry to achieve high torque and low losses with an optimetrics analysis.
+
+ .. grid-item-card:: Transformer
+ :padding: 2 2 2 2
+ :link: transformer
+ :link-type: doc
+
+ .. image:: _static/transformer.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to set core loss given a set of power-volume [kw/m^3] curves at different frequencies.
+
+
+ .. grid-item-card:: Transformer leakage inductance calculation
+ :padding: 2 2 2 2
+ :link: transformer_inductance
+ :link-type: doc
+
+ .. image:: _static/transformer2.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example shows how to use PyAEDT to create a Maxwell 2D magnetostatic analysis to calculate transformer leakage inductance and reactance.
+
+
+ .. grid-item-card:: Motor creation and export
+ :padding: 2 2 2 2
+ :link: rmxpert
+ :link-type: doc
+
+ .. image:: _static/rmxpert.png
+ :alt: Maxwell general
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses PyAEDT to create a RMxprt project and export it to Maxwell 2D.
+
+
+ .. toctree::
+ :hidden:
+
+ pm_synchronous
+ magnet_segmentation
+ ipm_optimization
+ transformer
+ transformer_inductance
+ rmxpert
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/ipm_optimization.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/ipm_optimization.ipynb.txt
new file mode 100644
index 00000000..3f96fbce
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/ipm_optimization.ipynb.txt
@@ -0,0 +1,435 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "799ea96d",
+ "metadata": {},
+ "source": [
+ "# IPM geometry optimization\n",
+ "\n",
+ "This example shows how to use PyAEDT to find the best machine 2D geometry\n",
+ "to achieve high torque and low losses.\n",
+ "The example shows how to setup an optimetrics analysis to sweep geometries\n",
+ "for a single value of stator current angle.\n",
+ "The torque and losses results are then exported in a .csv file.\n",
+ "\n",
+ "Keywords: **Maxwell 2D**, **transient**, **motor**, **optimization**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "860a3308",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "20ec459a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import csv\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1d43d307",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d870bab6",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2d57a7b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "18a7c389",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "60c32dad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "801cdf24",
+ "metadata": {},
+ "source": [
+ "## Download AEDT file example\n",
+ "\n",
+ "Set the local temporary folder to export the AEDT file to."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b405f8e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt_file = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"maxwell_motor_optimization\",\n",
+ " name=\"IPM_optimization.aedt\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "140a78f9",
+ "metadata": {},
+ "source": [
+ "## Launch Maxwell 2D\n",
+ "\n",
+ "Launch AEDT and Maxwell 2D after first setting up the project, the version and the graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a522bf65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d = ansys.aedt.core.Maxwell2d(\n",
+ " project=aedt_file,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5aecd2d2",
+ "metadata": {},
+ "source": [
+ "## Add parametric setup\n",
+ "\n",
+ "Add a parametric setup made up of geometry variable sweep definitions and single value for the stator current angle.\n",
+ "Note: Step variations have been minimized to reduce the analysis time. If needed they can be increased by changing\n",
+ "the ``step`` argument."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "746f1b05",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_sweep = m2d.parametrics.add(\n",
+ " variable=\"bridge\",\n",
+ " start_point=\"0.5mm\",\n",
+ " end_point=\"1mm\",\n",
+ " step=\"0.5mm\",\n",
+ " variation_type=\"LinearStep\",\n",
+ ")\n",
+ "param_sweep.add_variation(\n",
+ " sweep_variable=\"din\",\n",
+ " start_point=70,\n",
+ " end_point=80,\n",
+ " step=10,\n",
+ " units=\"mm\",\n",
+ " variation_type=\"LinearStep\",\n",
+ ")\n",
+ "param_sweep.add_variation(\n",
+ " sweep_variable=\"phase_advance\",\n",
+ " start_point=0,\n",
+ " end_point=45,\n",
+ " step=45,\n",
+ " units=\"deg\",\n",
+ " variation_type=\"LinearStep\",\n",
+ ")\n",
+ "param_sweep.add_variation(\n",
+ " sweep_variable=\"Ipeak\", start_point=200, units=\"A\", variation_type=\"SingleValue\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4339a913",
+ "metadata": {},
+ "source": [
+ "## Analyze parametric sweep"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2babc131",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_sweep.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36ce73c8",
+ "metadata": {},
+ "source": [
+ "## Post-processing\n",
+ "\n",
+ "Create reports to get torque and loss results for all variations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41c1b0eb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report_torque = m2d.post.create_report(\n",
+ " expressions=\"Moving1.Torque\",\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " plot_type=\"Rectangular Plot\",\n",
+ " plot_name=\"TorqueAllVariations\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66a4a4bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report_solid_loss = m2d.post.create_report(\n",
+ " expressions=\"SolidLoss\",\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " plot_type=\"Rectangular Plot\",\n",
+ " plot_name=\"SolidLossAllVariations\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3aac3099",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report_core_loss = m2d.post.create_report(\n",
+ " expressions=\"CoreLoss\",\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " plot_type=\"Rectangular Plot\",\n",
+ " plot_name=\"CoreLossAllVariations\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a9ae4afd",
+ "metadata": {},
+ "source": [
+ "Get torque and loss solution data for all available variations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "078fdf3b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "torque_data = m2d.post.get_solution_data(\n",
+ " expressions=[\"Moving1.Torque\"],\n",
+ " setup_sweep_name=m2d.nominal_sweep,\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " report_category=\"Standard\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "462fd48e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solid_loss_data = m2d.post.get_solution_data(\n",
+ " expressions=[\"CoreLoss\"],\n",
+ " setup_sweep_name=m2d.nominal_sweep,\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " report_category=\"Standard\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0639b9ba",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "core_loss_data = m2d.post.get_solution_data(\n",
+ " expressions=[\"SolidLoss\"],\n",
+ " setup_sweep_name=m2d.nominal_sweep,\n",
+ " domain=\"Sweep\",\n",
+ " variations={\"bridge\": \"All\", \"din\": \"All\", \"Ipeak\": \"All\"},\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " report_category=\"Standard\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ae2bca6",
+ "metadata": {},
+ "source": [
+ "Calculate torque and loss average values for each variation and write data in a .csv file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a414434d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "csv_data = []\n",
+ "for var in core_loss_data.variations:\n",
+ " torque_data.active_variation = var\n",
+ " core_loss_data.active_variation = var\n",
+ " solid_loss_data.active_variation = var\n",
+ "\n",
+ " torque_values = torque_data.data_magnitude()\n",
+ " core_loss_values = core_loss_data.data_magnitude()\n",
+ " solid_loss_values = solid_loss_data.data_magnitude()\n",
+ "\n",
+ " torque_data_average = sum(torque_values) / len(torque_values)\n",
+ " core_loss_average = sum(core_loss_values) / len(core_loss_values)\n",
+ " solid_loss_average = sum(solid_loss_values) / len(solid_loss_values)\n",
+ "\n",
+ " csv_data.append(\n",
+ " {\n",
+ " \"active_variation\": str(torque_data.active_variation),\n",
+ " \"average_torque\": str(torque_data_average),\n",
+ " \"average_core_loss\": str(core_loss_average),\n",
+ " \"average_solid_loss\": str(solid_loss_average),\n",
+ " }\n",
+ " )\n",
+ "\n",
+ " with open(\n",
+ " os.path.join(temp_folder.name, \"motor_optimization.csv\"), \"w\", newline=\"\"\n",
+ " ) as csvfile:\n",
+ " fields = [\n",
+ " \"active_variation\",\n",
+ " \"average_torque\",\n",
+ " \"average_core_loss\",\n",
+ " \"average_solid_loss\",\n",
+ " ]\n",
+ " writer = csv.DictWriter(csvfile, fieldnames=fields)\n",
+ " writer.writeheader()\n",
+ " writer.writerows(csv_data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dc428af1",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c1c02527",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "52baba5f",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2b717b27",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/magnet_segmentation.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/magnet_segmentation.ipynb.txt
new file mode 100644
index 00000000..565ae641
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/magnet_segmentation.ipynb.txt
@@ -0,0 +1,306 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0703b9d1",
+ "metadata": {},
+ "source": [
+ "# Magnet segmentation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23c255fe",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to segment magnets of an electric motor.\n",
+ "The method is valid and usable for any object you would like to segment.\n",
+ "\n",
+ "Keywords: **Maxwell 3D**, **Magnet segmentation**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f805cdef",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6a75c3b1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "61a55829",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "276acaf6",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "357c3341",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e96fe2c9",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e1cb1c10",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9841a425",
+ "metadata": {},
+ "source": [
+ "## Download AEDT file example\n",
+ "\n",
+ "Set the local temporary folder to export the AEDT file to."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bab2b12f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt_file = ansys.aedt.core.downloads.download_file(\n",
+ " source=\"object_segmentation\",\n",
+ " name=\"Motor3D_obj_segments.aedt\",\n",
+ " destination=temp_folder.name,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "675f86bc",
+ "metadata": {},
+ "source": [
+ "## Launch Maxwell 3D\n",
+ "\n",
+ "Launch Maxwell 3D, providing the version, rgw path to the project, and the graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e65ba3cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d = ansys.aedt.core.Maxwell3d(\n",
+ " project=aedt_file,\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5afd31b6",
+ "metadata": {},
+ "source": [
+ "## Segment first magnet by specifying number of segments\n",
+ "\n",
+ "Select the first magnet to segment by specifying the number of segments.\n",
+ "The method accepts as input the list of magnets names to segment,\n",
+ "magnet IDs, or the magnet :class:`ansys.aedt.core.modeler.cad.object3d.Object3d` object.\n",
+ "When ``apply_mesh_sheets`` is enabled, the mesh sheets are also\n",
+ "applied in the geometry.\n",
+ "In the following code, the name of the magnet is also given as an input."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9cfcee83",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "segments_number = 2\n",
+ "object_name = \"PM_I1\"\n",
+ "sheets_1 = m3d.modeler.objects_segmentation(\n",
+ " object_name,\n",
+ " segments=segments_number,\n",
+ " apply_mesh_sheets=True,\n",
+ " mesh_sheets=3,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0a12a32",
+ "metadata": {},
+ "source": [
+ "## Segment second magnet by specifying number of segments\n",
+ "\n",
+ "Select the second magnet to segment by specifying the number of segments.\n",
+ "The following code gives the ID of the magnet as an input."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "68b6762b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "segments_number = 2\n",
+ "object_name = \"PM_I1_1\"\n",
+ "magnet_id = [obj.id for obj in m3d.modeler.object_list if obj.name == object_name][0]\n",
+ "sheets_2 = m3d.modeler.objects_segmentation(\n",
+ " magnet_id, segments=segments_number, apply_mesh_sheets=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "51824e60",
+ "metadata": {},
+ "source": [
+ "## Segment third magnet by specifying segmentation thickness\n",
+ "\n",
+ "Select the third magnet to segment by specifying the segmentation thickness.\n",
+ "The following code gives the magnet object type `ansys.aedt.core.modeler.cad.object3d.Object3d`\n",
+ "as an input."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "93c348ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "segmentation_thickness = 1\n",
+ "object_name = \"PM_O1\"\n",
+ "magnet = [obj for obj in m3d.modeler.object_list if obj.name == object_name][0]\n",
+ "sheets_3 = m3d.modeler.objects_segmentation(\n",
+ " magnet, segmentation_thickness=segmentation_thickness, apply_mesh_sheets=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2e4dbed",
+ "metadata": {},
+ "source": [
+ "## Segment fourth magnet by specifying number of segments\n",
+ "\n",
+ "Select the fourth magnet to segment by specifying the number of segments.\n",
+ "The following code gives the name of the magnet as input and disables the mesh sheets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d10886fd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "object_name = \"PM_O1_1\"\n",
+ "segments_number = 2\n",
+ "sheets_4 = m3d.modeler.objects_segmentation(object_name, segments=segments_number)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42a1b992",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76bc697c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.save_project()\n",
+ "m3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b1f16684",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "62383655",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/pm_synchronous.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/pm_synchronous.ipynb.txt
new file mode 100644
index 00000000..1dc98445
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/pm_synchronous.ipynb.txt
@@ -0,0 +1,1704 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "bc779ecc",
+ "metadata": {},
+ "source": [
+ "# PM synchronous motor transient analysis\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a Maxwell 2D transient analysis for\n",
+ "an interior permanent magnet (PM) electric motor.\n",
+ "\n",
+ "Keywords: **Maxwell 2D**, **transient**, **motor**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83bde869",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48317ed7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import csv\n",
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "from operator import attrgetter"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "054edc51",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57421581",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ffa48524",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "77b778c6",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory and download files\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7e79da58",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "414befbe",
+ "metadata": {},
+ "source": [
+ "## Initialize dictionaries\n",
+ "\n",
+ "Dictionaries contain all the definitions for the design variables and output variables."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "157daec5",
+ "metadata": {},
+ "source": [
+ "## Initialize definitions for th stator, rotor, and shaft\n",
+ "\n",
+ "Initialize geometry parameter definitions for the stator, rotor, and shaft.\n",
+ "The naming refers to RMxprt primitives."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "78116aa7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "geom_params = {\n",
+ " \"DiaGap\": \"132mm\",\n",
+ " \"DiaStatorYoke\": \"198mm\",\n",
+ " \"DiaStatorInner\": \"132mm\",\n",
+ " \"DiaRotorLam\": \"130mm\",\n",
+ " \"DiaShaft\": \"44.45mm\",\n",
+ " \"DiaOuter\": \"198mm\",\n",
+ " \"Airgap\": \"1mm\",\n",
+ " \"SlotNumber\": \"48\",\n",
+ " \"SlotType\": \"3\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f9be4948",
+ "metadata": {},
+ "source": [
+ "## Initialize definitions for stator windings\n",
+ "\n",
+ "Initialize geometry parameter definitions for the stator windings. The naming\n",
+ "refers to RMxprt primitives."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7c16d6f8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "wind_params = {\n",
+ " \"Layers\": \"1\",\n",
+ " \"ParallelPaths\": \"2\",\n",
+ " \"R_Phase\": \"7.5mOhm\",\n",
+ " \"WdgExt_F\": \"5mm\",\n",
+ " \"SpanExt\": \"30mm\",\n",
+ " \"SegAngle\": \"0.25\",\n",
+ " \"CoilPitch\": \"5\", # coil pitch in slots\n",
+ " \"Coil_SetBack\": \"3.605732823mm\",\n",
+ " \"SlotWidth\": \"2.814mm\", # RMxprt Bs0\n",
+ " \"Coil_Edge_Short\": \"3.769235435mm\",\n",
+ " \"Coil_Edge_Long\": \"15.37828521mm\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "598340ef",
+ "metadata": {},
+ "source": [
+ "## Initialize definitions for model setup\n",
+ "\n",
+ "Initialize geometry parameter definitions for the model setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "752ea240",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mod_params = {\n",
+ " \"NumPoles\": \"8\",\n",
+ " \"Model_Length\": \"80mm\",\n",
+ " \"SymmetryFactor\": \"8\",\n",
+ " \"Magnetic_Axial_Length\": \"150mm\",\n",
+ " \"Stator_Lam_Length\": \"0mm\",\n",
+ " \"StatorSkewAngle\": \"0deg\",\n",
+ " \"NumTorquePointsPerCycle\": \"30\",\n",
+ " \"mapping_angle\": \"0.125*4deg\",\n",
+ " \"num_m\": \"16\",\n",
+ " \"Section_Angle\": \"360deg/SymmetryFactor\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22f6638d",
+ "metadata": {},
+ "source": [
+ "## Initialize definitions for operational machine\n",
+ "\n",
+ "Initialize geometry parameter definitions for the operational machine. This\n",
+ "identifies the operating point for the transient setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b120e837",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "oper_params = {\n",
+ " \"InitialPositionMD\": \"180deg/4\",\n",
+ " \"IPeak\": \"480A\",\n",
+ " \"MachineRPM\": \"3000rpm\",\n",
+ " \"ElectricFrequency\": \"MachineRPM/60rpm*NumPoles/2*1Hz\",\n",
+ " \"ElectricPeriod\": \"1/ElectricFrequency\",\n",
+ " \"BandTicksinModel\": \"360deg/NumPoles/mapping_angle\",\n",
+ " \"TimeStep\": \"ElectricPeriod/(2*BandTicksinModel)\",\n",
+ " \"StopTime\": \"ElectricPeriod\",\n",
+ " \"Theta_i\": \"135deg\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b5aafd2",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and Maxwell 2D\n",
+ "\n",
+ "Launch AEDT and Maxwell 2D after first setting up the project and design names,\n",
+ "the solver, and the version. The following code also creates an instance of the\n",
+ "``Maxwell2d`` class named ``m2d``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb36ce8d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"PM_Motor.aedt\")\n",
+ "m2d = ansys.aedt.core.Maxwell2d(\n",
+ " project=project_name,\n",
+ " version=AEDT_VERSION,\n",
+ " design=\"Sinusoidal\",\n",
+ " solution_type=\"TransientXY\",\n",
+ " new_desktop=True,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "272e725e",
+ "metadata": {},
+ "source": [
+ "## Define modeler units"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b279cb91",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.modeler.model_units = \"mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "00d670db",
+ "metadata": {},
+ "source": [
+ "## Define variables from dictionaries\n",
+ "\n",
+ "Define design variables from the created dictionaries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fdf529ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for k, v in geom_params.items():\n",
+ " m2d[k] = v\n",
+ "for k, v in wind_params.items():\n",
+ " m2d[k] = v\n",
+ "for k, v in mod_params.items():\n",
+ " m2d[k] = v\n",
+ "for k, v in oper_params.items():\n",
+ " m2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f77bad0f",
+ "metadata": {},
+ "source": [
+ "## Define path for non-linear material properties\n",
+ "\n",
+ "Define the path for non-linear material properties.\n",
+ "Materials are stored in text files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2b92c2c6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filename_lam, filename_PM = ansys.aedt.core.downloads.download_leaf(\n",
+ " destination=temp_folder.name\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4b44db56",
+ "metadata": {},
+ "source": [
+ "## Create first material\n",
+ "\n",
+ "Create the material ``\"Copper (Annealed)_65C\"``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0d9a47eb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat_coils = m2d.materials.add_material(\"Copper (Annealed)_65C\")\n",
+ "mat_coils.update()\n",
+ "mat_coils.conductivity = \"49288048.9198\"\n",
+ "mat_coils.permeability = \"1\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d892e36e",
+ "metadata": {},
+ "source": [
+ "## Create second material\n",
+ "\n",
+ "Create the material ``\"Arnold_Magnetics_N30UH_80C\"``.\n",
+ "The BH curve is read from a tabbed CSV file. A list named ``BH_List_PM``\n",
+ "is created. This list is passed to the ``mat_PM.permeability.value``\n",
+ "variable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e67468d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat_PM = m2d.materials.add_material(name=\"Arnold_Magnetics_N30UH_80C_new\")\n",
+ "mat_PM.update()\n",
+ "mat_PM.conductivity = \"555555.5556\"\n",
+ "mat_PM.set_magnetic_coercivity(value=-800146.66287534, x=1, y=0, z=0)\n",
+ "mat_PM.mass_density = \"7500\"\n",
+ "BH_List_PM = []\n",
+ "with open(filename_PM) as f:\n",
+ " reader = csv.reader(f, delimiter=\"\\t\")\n",
+ " next(reader)\n",
+ " for row in reader:\n",
+ " BH_List_PM.append([float(row[0]), float(row[1])])\n",
+ "mat_PM.permeability.value = BH_List_PM"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90b3c1d4",
+ "metadata": {},
+ "source": [
+ "## Create third material\n",
+ "\n",
+ "Create the laminated material ``30DH_20C_smooth``.\n",
+ "This material has a BH curve and a core loss model,\n",
+ "which is set to electrical steel."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e00ffd28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat_lam = m2d.materials.add_material(\"30DH_20C_smooth\")\n",
+ "mat_lam.update()\n",
+ "mat_lam.conductivity = \"1694915.25424\"\n",
+ "kh = 71.7180985413\n",
+ "kc = 0.25092214579\n",
+ "ke = 12.1625774023\n",
+ "kdc = 0.001\n",
+ "eq_depth = 0.001\n",
+ "mat_lam.set_electrical_steel_coreloss(kh, kc, ke, kdc, eq_depth)\n",
+ "mat_lam.mass_density = \"7650\"\n",
+ "BH_List_lam = []\n",
+ "with open(filename_lam) as f:\n",
+ " reader = csv.reader(f, delimiter=\"\\t\")\n",
+ " next(reader)\n",
+ " for row in reader:\n",
+ " BH_List_lam.append([float(row[0]), float(row[1])])\n",
+ "mat_lam.permeability.value = BH_List_lam"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dcde4b50",
+ "metadata": {},
+ "source": [
+ "## Create geometry for stator\n",
+ "\n",
+ "Create the geometry for the stator. It is created via\n",
+ "the RMxprt user-defined primitive (UDP). A list of lists is\n",
+ "created with the proper UDP parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0dba76bb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "udp_par_list_stator = [\n",
+ " [\"DiaGap\", \"DiaGap\"],\n",
+ " [\"DiaYoke\", \"DiaStatorYoke\"],\n",
+ " [\"Length\", \"Stator_Lam_Length\"],\n",
+ " [\"Skew\", \"StatorSkewAngle\"],\n",
+ " [\"Slots\", \"SlotNumber\"],\n",
+ " [\"SlotType\", \"SlotType\"],\n",
+ " [\"Hs0\", \"1.2mm\"],\n",
+ " [\"Hs01\", \"0mm\"],\n",
+ " [\"Hs1\", \"0.4834227384999mm\"],\n",
+ " [\"Hs2\", \"17.287669825502mm\"],\n",
+ " [\"Bs0\", \"2.814mm\"],\n",
+ " [\"Bs1\", \"4.71154109036mm\"],\n",
+ " [\"Bs2\", \"6.9777285790998mm\"],\n",
+ " [\"Rs\", \"2mm\"],\n",
+ " [\"FilletType\", \"1\"],\n",
+ " [\"HalfSlot\", \"0\"],\n",
+ " [\"VentHoles\", \"0\"],\n",
+ " [\"HoleDiaIn\", \"0mm\"],\n",
+ " [\"HoleDiaOut\", \"0mm\"],\n",
+ " [\"HoleLocIn\", \"0mm\"],\n",
+ " [\"HoleLocOut\", \"0mm\"],\n",
+ " [\"VentDucts\", \"0\"],\n",
+ " [\"DuctWidth\", \"0mm\"],\n",
+ " [\"DuctPitch\", \"0mm\"],\n",
+ " [\"SegAngle\", \"0deg\"],\n",
+ " [\"LenRegion\", \"Model_Length\"],\n",
+ " [\"InfoCore\", \"0\"],\n",
+ "]\n",
+ "\n",
+ "stator_id = m2d.modeler.create_udp(\n",
+ " dll=\"RMxprt/VentSlotCore.dll\",\n",
+ " parameters=udp_par_list_stator,\n",
+ " library=\"syslib\",\n",
+ " name=\"my_stator\",\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd158f7b",
+ "metadata": {},
+ "source": [
+ "## Assign properties to stator\n",
+ "\n",
+ "Assign properties to the stator. The following code assigns\n",
+ "the ``material``, ``name``, ``color``, and ``solve_inside`` properties."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "764879d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_material(assignment=stator_id, material=\"30DH_20C_smooth\")\n",
+ "stator_id.name = \"Stator\"\n",
+ "stator_id.color = (0, 0, 255) # rgb"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e33311da",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# to be reassigned: m2d.assign material puts False if not dielectric\n",
+ "stator_id.solve_inside = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d714a606",
+ "metadata": {},
+ "source": [
+ "## Create outer and inner PMs\n",
+ "\n",
+ "Create the outer and inner PMs and assign color to them."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27403a3a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "IM1_points = [\n",
+ " [56.70957112, 3.104886585, 0],\n",
+ " [40.25081875, 16.67243502, 0],\n",
+ " [38.59701538, 14.66621111, 0],\n",
+ " [55.05576774, 1.098662669, 0],\n",
+ "]\n",
+ "OM1_points = [\n",
+ " [54.37758185, 22.52393189, 0],\n",
+ " [59.69688156, 9.68200639, 0],\n",
+ " [63.26490432, 11.15992981, 0],\n",
+ " [57.94560461, 24.00185531, 0],\n",
+ "]\n",
+ "IPM1_id = m2d.modeler.create_polyline(\n",
+ " points=IM1_points,\n",
+ " cover_surface=True,\n",
+ " name=\"PM_I1\",\n",
+ " material=\"Arnold_Magnetics_N30UH_80C_new\",\n",
+ ")\n",
+ "IPM1_id.color = (0, 128, 64)\n",
+ "OPM1_id = m2d.modeler.create_polyline(\n",
+ " points=OM1_points,\n",
+ " cover_surface=True,\n",
+ " name=\"PM_O1\",\n",
+ " material=\"Arnold_Magnetics_N30UH_80C_new\",\n",
+ ")\n",
+ "OPM1_id.color = (0, 128, 64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8286a6f9",
+ "metadata": {},
+ "source": [
+ "## Create coordinate system for PMs\n",
+ "\n",
+ "Create the coordinate system for the PMs.\n",
+ "In Maxwell 2D, you assign magnetization via the coordinate system.\n",
+ "The inputs are the object name, coordinate system name, and inner or outer magnetization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "166cde11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_cs_magnets(pm_id, cs_name, point_direction):\n",
+ " edges = sorted(pm_id.edges, key=attrgetter(\"length\"), reverse=True)\n",
+ "\n",
+ " if point_direction == \"outer\":\n",
+ " my_axis_pos = edges[0]\n",
+ " elif point_direction == \"inner\":\n",
+ " my_axis_pos = edges[1]\n",
+ "\n",
+ " m2d.modeler.create_face_coordinate_system(\n",
+ " face=pm_id.faces[0],\n",
+ " origin=pm_id.faces[0],\n",
+ " axis_position=my_axis_pos,\n",
+ " axis=\"X\",\n",
+ " name=cs_name,\n",
+ " )\n",
+ " pm_id.part_coordinate_system = cs_name\n",
+ " m2d.modeler.set_working_coordinate_system(\"Global\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b4f480b9",
+ "metadata": {},
+ "source": [
+ "## Create coordinate system for PMs in face center\n",
+ "\n",
+ "Create the coordinate system for PMs in the face center."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df7dc8f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "create_cs_magnets(IPM1_id, \"CS_\" + IPM1_id.name, \"outer\")\n",
+ "create_cs_magnets(OPM1_id, \"CS_\" + OPM1_id.name, \"outer\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a2868a6",
+ "metadata": {},
+ "source": [
+ "## Duplicate and mirror PMs\n",
+ "\n",
+ "Duplicate and mirror the PMs along with the local coordinate system."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c9ad3dc7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.modeler.duplicate_and_mirror(\n",
+ " assignment=[IPM1_id, OPM1_id],\n",
+ " origin=[0, 0, 0],\n",
+ " vector=[\n",
+ " \"cos((360deg/SymmetryFactor/2)+90deg)\",\n",
+ " \"sin((360deg/SymmetryFactor/2)+90deg)\",\n",
+ " 0,\n",
+ " ],\n",
+ ")\n",
+ "id_PMs = m2d.modeler.get_objects_w_string(string_name=\"PM\", case_sensitive=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "456cdd58",
+ "metadata": {},
+ "source": [
+ "## Create coils"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ad4c372",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coil_id = m2d.modeler.create_rectangle(\n",
+ " origin=[\"DiaRotorLam/2+Airgap+Coil_SetBack\", \"-Coil_Edge_Short/2\", 0],\n",
+ " sizes=[\"Coil_Edge_Long\", \"Coil_Edge_Short\", 0],\n",
+ " name=\"Coil\",\n",
+ " material=\"Copper (Annealed)_65C\",\n",
+ ")\n",
+ "coil_id.color = (255, 128, 0)\n",
+ "m2d.modeler.rotate(assignment=coil_id, axis=\"Z\", angle=\"360deg/SlotNumber/2\")\n",
+ "coil_id.duplicate_around_axis(\n",
+ " axis=\"Z\", angle=\"360deg/SlotNumber\", clones=\"CoilPitch+1\", create_new_objects=True\n",
+ ")\n",
+ "id_coils = m2d.modeler.get_objects_w_string(string_name=\"Coil\", case_sensitive=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9adfb0eb",
+ "metadata": {},
+ "source": [
+ "## Create shaft and region"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0b2ccd54",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "region_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"DiaOuter/2\",\n",
+ " num_sides=\"SegAngle\",\n",
+ " is_covered=True,\n",
+ " name=\"Region\",\n",
+ ")\n",
+ "shaft_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"DiaShaft/2\",\n",
+ " num_sides=\"SegAngle\",\n",
+ " is_covered=True,\n",
+ " name=\"Shaft\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "60e91f01",
+ "metadata": {},
+ "source": [
+ "## Create bands\n",
+ "\n",
+ "Create the inner band, band, and outer band."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "80e52f24",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bandIN_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"(DiaGap - (1.5 * Airgap))/2\",\n",
+ " num_sides=\"mapping_angle\",\n",
+ " is_covered=True,\n",
+ " name=\"Inner_Band\",\n",
+ ")\n",
+ "bandMID_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"(DiaGap - (1.0 * Airgap))/2\",\n",
+ " num_sides=\"mapping_angle\",\n",
+ " is_covered=True,\n",
+ " name=\"Band\",\n",
+ ")\n",
+ "bandOUT_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"(DiaGap - (0.5 * Airgap))/2\",\n",
+ " num_sides=\"mapping_angle\",\n",
+ " is_covered=True,\n",
+ " name=\"Outer_Band\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbf0412d",
+ "metadata": {},
+ "source": [
+ "## Assign motion setup to object\n",
+ "\n",
+ "Assign a motion setup to a ``Band`` object named ``RotatingBand_mid``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6fe74fee",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_rotate_motion(\n",
+ " assignment=\"Band\",\n",
+ " coordinate_system=\"Global\",\n",
+ " axis=\"Z\",\n",
+ " positive_movement=True,\n",
+ " start_position=\"InitialPositionMD\",\n",
+ " angular_velocity=\"MachineRPM\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f03a3187",
+ "metadata": {},
+ "source": [
+ "## Create list of vacuum objects\n",
+ "\n",
+ "Create a list of vacuum objects and assign color."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92dec465",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "vacuum_obj_id = [\n",
+ " shaft_id,\n",
+ " region_id,\n",
+ " bandIN_id,\n",
+ " bandMID_id,\n",
+ " bandOUT_id,\n",
+ "] # put shaft first\n",
+ "for item in vacuum_obj_id:\n",
+ " item.color = (128, 255, 255)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "711198ab",
+ "metadata": {},
+ "source": [
+ "## Create rotor\n",
+ "\n",
+ "Create the rotor. Holes are specific to the lamination.\n",
+ "Allocated PMs are created."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "800e2214",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rotor_id = m2d.modeler.create_circle(\n",
+ " origin=[0, 0, 0],\n",
+ " radius=\"DiaRotorLam/2\",\n",
+ " num_sides=0,\n",
+ " name=\"Rotor\",\n",
+ " material=\"30DH_20C_smooth\",\n",
+ ")\n",
+ "\n",
+ "rotor_id.color = (0, 128, 255)\n",
+ "m2d.modeler.subtract(blank_list=rotor_id, tool_list=shaft_id, keep_originals=True)\n",
+ "void_small_1_id = m2d.modeler.create_circle(\n",
+ " origin=[62, 0, 0], radius=\"2.55mm\", num_sides=0, name=\"void1\", material=\"vacuum\"\n",
+ ")\n",
+ "\n",
+ "m2d.modeler.duplicate_around_axis(\n",
+ " assignment=void_small_1_id,\n",
+ " axis=\"Z\",\n",
+ " angle=\"360deg/SymmetryFactor\",\n",
+ " clones=2,\n",
+ " create_new_objects=False,\n",
+ ")\n",
+ "\n",
+ "void_big_1_id = m2d.modeler.create_circle(\n",
+ " origin=[29.5643, 12.234389332712, 0],\n",
+ " radius=\"9.88mm/2\",\n",
+ " num_sides=0,\n",
+ " name=\"void_big\",\n",
+ " material=\"vacuum\",\n",
+ ")\n",
+ "m2d.modeler.subtract(\n",
+ " blank_list=rotor_id,\n",
+ " tool_list=[void_small_1_id, void_big_1_id],\n",
+ " keep_originals=False,\n",
+ ")\n",
+ "\n",
+ "slot_IM1_points = [\n",
+ " [37.5302872, 15.54555396, 0],\n",
+ " [55.05576774, 1.098662669, 0],\n",
+ " [57.33637589, 1.25, 0],\n",
+ " [57.28982158, 2.626565019, 0],\n",
+ " [40.25081875, 16.67243502, 0],\n",
+ "]\n",
+ "slot_OM1_points = [\n",
+ " [54.37758185, 22.52393189, 0],\n",
+ " [59.69688156, 9.68200639, 0],\n",
+ " [63.53825619, 10.5, 0],\n",
+ " [57.94560461, 24.00185531, 0],\n",
+ "]\n",
+ "slot_IM_id = m2d.modeler.create_polyline(\n",
+ " points=slot_IM1_points, cover_surface=True, name=\"slot_IM1\", material=\"vacuum\"\n",
+ ")\n",
+ "slot_OM_id = m2d.modeler.create_polyline(\n",
+ " points=slot_OM1_points, cover_surface=True, name=\"slot_OM1\", material=\"vacuum\"\n",
+ ")\n",
+ "\n",
+ "m2d.modeler.duplicate_and_mirror(\n",
+ " assignment=[slot_IM_id, slot_OM_id],\n",
+ " origin=[0, 0, 0],\n",
+ " vector=[\n",
+ " \"cos((360deg/SymmetryFactor/2)+90deg)\",\n",
+ " \"sin((360deg/SymmetryFactor/2)+90deg)\",\n",
+ " 0,\n",
+ " ],\n",
+ ")\n",
+ "\n",
+ "id_holes = m2d.modeler.get_objects_w_string(string_name=\"slot_\", case_sensitive=True)\n",
+ "m2d.modeler.subtract(rotor_id, id_holes, keep_originals=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "76407c25",
+ "metadata": {},
+ "source": [
+ "## Create section of machine\n",
+ "\n",
+ "Create a section of the machine. This allows you to take\n",
+ "advantage of symmetries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4b193bf8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "object_list = [stator_id, rotor_id] + vacuum_obj_id\n",
+ "m2d.modeler.create_coordinate_system(\n",
+ " origin=[0, 0, 0],\n",
+ " reference_cs=\"Global\",\n",
+ " name=\"Section\",\n",
+ " mode=\"axis\",\n",
+ " x_pointing=[\"cos(360deg/SymmetryFactor)\", \"sin(360deg/SymmetryFactor)\", 0],\n",
+ " y_pointing=[\"-sin(360deg/SymmetryFactor)\", \"cos(360deg/SymmetryFactor)\", 0],\n",
+ ")\n",
+ "\n",
+ "m2d.modeler.set_working_coordinate_system(\"Section\")\n",
+ "m2d.modeler.split(assignment=object_list, plane=\"ZX\", sides=\"NegativeOnly\")\n",
+ "m2d.modeler.set_working_coordinate_system(\"Global\")\n",
+ "m2d.modeler.split(assignment=object_list, plane=\"ZX\", sides=\"PositiveOnly\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "91a84f9f",
+ "metadata": {},
+ "source": [
+ "## Create boundary conditions\n",
+ "\n",
+ "Create independent and dependent boundary conditions.\n",
+ "Edges for assignment are picked by position.\n",
+ "The points for edge picking are in the airgap."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "25d007d7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pos_1 = \"((DiaGap - (1.0 * Airgap))/4)\"\n",
+ "id_bc_1 = m2d.modeler.get_edgeid_from_position(\n",
+ " position=[pos_1, 0, 0], assignment=\"Region\"\n",
+ ")\n",
+ "id_bc_2 = m2d.modeler.get_edgeid_from_position(\n",
+ " position=[\n",
+ " pos_1 + \"*cos((360deg/SymmetryFactor))\",\n",
+ " pos_1 + \"*sin((360deg/SymmetryFactor))\",\n",
+ " 0,\n",
+ " ],\n",
+ " assignment=\"Region\",\n",
+ ")\n",
+ "m2d.assign_master_slave(\n",
+ " independent=id_bc_1,\n",
+ " dependent=id_bc_2,\n",
+ " reverse_master=False,\n",
+ " reverse_slave=True,\n",
+ " same_as_master=False,\n",
+ " boundary=\"Matching\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c84a1412",
+ "metadata": {},
+ "source": [
+ "## Assign vector potential\n",
+ "\n",
+ "Assign a vector potential of ``0`` to the second position."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f2985286",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pos_2 = \"(DiaOuter/2)\"\n",
+ "id_bc_az = m2d.modeler.get_edgeid_from_position(\n",
+ " position=[\n",
+ " pos_2 + \"*cos((360deg/SymmetryFactor/2))\",\n",
+ " pos_2 + \"*sin((360deg/SymmetryFactor)/2)\",\n",
+ " 0,\n",
+ " ],\n",
+ " assignment=\"Region\",\n",
+ ")\n",
+ "m2d.assign_vector_potential(\n",
+ " assignment=id_bc_az, vector_value=0, boundary=\"VectorPotentialZero\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d87b95ca",
+ "metadata": {},
+ "source": [
+ "## Create excitations\n",
+ "\n",
+ "Create excitations, defining phase currents for the windings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b1b6bf7a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ph_a_current = \"IPeak * cos(2*pi*ElectricFrequency*time+Theta_i)\"\n",
+ "ph_b_current = \"IPeak * cos(2*pi * ElectricFrequency*time - 120deg+Theta_i)\"\n",
+ "ph_c_current = \"IPeak * cos(2*pi * ElectricFrequency*time - 240deg+Theta_i)\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "94173625",
+ "metadata": {},
+ "source": [
+ "## Define windings in phase A"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "409d8d81",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_coil(\n",
+ " assignment=[\"Coil\"],\n",
+ " conductors_number=6,\n",
+ " polarity=\"Positive\",\n",
+ " name=\"CT_Ph1_P2_C1_Go\",\n",
+ ")\n",
+ "m2d.assign_coil(\n",
+ " assignment=[\"Coil_5\"],\n",
+ " conductors_number=6,\n",
+ " polarity=\"Negative\",\n",
+ " name=\"CT_Ph1_P2_C1_Ret\",\n",
+ ")\n",
+ "m2d.assign_winding(\n",
+ " assignment=None,\n",
+ " winding_type=\"Current\",\n",
+ " is_solid=False,\n",
+ " current=ph_a_current,\n",
+ " parallel_branches=1,\n",
+ " name=\"Phase_A\",\n",
+ ")\n",
+ "m2d.add_winding_coils(\n",
+ " assignment=\"Phase_A\", coils=[\"CT_Ph1_P2_C1_Go\", \"CT_Ph1_P2_C1_Ret\"]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c358a6bd",
+ "metadata": {},
+ "source": [
+ "## Define windings in phase B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c29721b2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_coil(\n",
+ " assignment=\"Coil_3\",\n",
+ " conductors_number=6,\n",
+ " polarity=\"Positive\",\n",
+ " name=\"CT_Ph3_P1_C2_Go\",\n",
+ ")\n",
+ "m2d.assign_coil(\n",
+ " assignment=\"Coil_4\",\n",
+ " conductors_number=6,\n",
+ " polarity=\"Positive\",\n",
+ " name=\"CT_Ph3_P1_C1_Go\",\n",
+ ")\n",
+ "m2d.assign_winding(\n",
+ " assignment=None,\n",
+ " winding_type=\"Current\",\n",
+ " is_solid=False,\n",
+ " current=ph_b_current,\n",
+ " parallel_branches=1,\n",
+ " name=\"Phase_B\",\n",
+ ")\n",
+ "m2d.add_winding_coils(\n",
+ " assignment=\"Phase_B\", coils=[\"CT_Ph3_P1_C2_Go\", \"CT_Ph3_P1_C1_Go\"]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adc0de3a",
+ "metadata": {},
+ "source": [
+ "## Define windings in phase C"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8388e988",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_coil(\n",
+ " assignment=\"Coil_1\",\n",
+ " conductors_number=6,\n",
+ " polarity=\"Negative\",\n",
+ " name=\"CT_Ph2_P2_C2_Ret\",\n",
+ ")\n",
+ "m2d.assign_coil(\n",
+ " assignment=\"Coil_2\",\n",
+ " conductors_number=6,\n",
+ " polarity=\"Negative\",\n",
+ " name=\"CT_Ph2_P2_C1_Ret\",\n",
+ ")\n",
+ "m2d.assign_winding(\n",
+ " assignment=None,\n",
+ " winding_type=\"Current\",\n",
+ " is_solid=False,\n",
+ " current=ph_c_current,\n",
+ " parallel_branches=1,\n",
+ " name=\"Phase_C\",\n",
+ ")\n",
+ "m2d.add_winding_coils(\n",
+ " assignment=\"Phase_C\", coils=[\"CT_Ph2_P2_C2_Ret\", \"CT_Ph2_P2_C1_Ret\"]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "71856546",
+ "metadata": {},
+ "source": [
+ "## Assign total current on PMs\n",
+ "\n",
+ "Assign a total current of ``0`` on the PMs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "41a93738",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "PM_list = id_PMs\n",
+ "for item in PM_list:\n",
+ " m2d.assign_current(assignment=item, amplitude=0, solid=True, name=item + \"_I0\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0f1c50df",
+ "metadata": {},
+ "source": [
+ "## Create mesh operations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d0cae4ff",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=id_coils,\n",
+ " inside_selection=True,\n",
+ " maximum_length=3,\n",
+ " maximum_elements=None,\n",
+ " name=\"coils\",\n",
+ ")\n",
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=stator_id,\n",
+ " inside_selection=True,\n",
+ " maximum_length=3,\n",
+ " maximum_elements=None,\n",
+ " name=\"stator\",\n",
+ ")\n",
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=rotor_id,\n",
+ " inside_selection=True,\n",
+ " maximum_length=3,\n",
+ " maximum_elements=None,\n",
+ " name=\"rotor\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c7b73e0e",
+ "metadata": {},
+ "source": [
+ "## Turn on core loss"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb6f6c11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "core_loss_list = [\"Rotor\", \"Stator\"]\n",
+ "m2d.set_core_losses(core_loss_list, core_loss_on_field=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "93b2b58e",
+ "metadata": {},
+ "source": [
+ "## Compute transient inductance"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3acf0bfa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.change_inductance_computation(\n",
+ " compute_transient_inductance=True, incremental_matrix=False\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e3b23338",
+ "metadata": {},
+ "source": [
+ "## Set model depth"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b97afbbe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.model_depth = \"Magnetic_Axial_Length\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db0ed043",
+ "metadata": {},
+ "source": [
+ "## Set symmetry factor"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a1ccd049",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.change_symmetry_multiplier(\"SymmetryFactor\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f4db4d5f",
+ "metadata": {},
+ "source": [
+ "## Create setup and validate"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "71763514",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup_name = \"MySetupAuto\"\n",
+ "setup = m2d.create_setup(name=setup_name)\n",
+ "setup.props[\"StopTime\"] = \"StopTime\"\n",
+ "setup.props[\"TimeStep\"] = \"TimeStep\"\n",
+ "setup.props[\"SaveFieldsType\"] = \"None\"\n",
+ "setup.props[\"OutputPerObjectCoreLoss\"] = True\n",
+ "setup.props[\"OutputPerObjectSolidLoss\"] = True\n",
+ "setup.props[\"OutputError\"] = True\n",
+ "setup.update()\n",
+ "m2d.validate_simple()\n",
+ "\n",
+ "model = m2d.plot(show=False)\n",
+ "model.plot(os.path.join(temp_folder.name, \"Image.jpg\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fad197d2",
+ "metadata": {},
+ "source": [
+ "## Initialize definitions for output variables\n",
+ "\n",
+ "Initialize the definitions for the output variables.\n",
+ "These are used later to generate reports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e7fda8a4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "output_vars = {\n",
+ " \"Current_A\": \"InputCurrent(Phase_A)\",\n",
+ " \"Current_B\": \"InputCurrent(Phase_B)\",\n",
+ " \"Current_C\": \"InputCurrent(Phase_C)\",\n",
+ " \"Flux_A\": \"FluxLinkage(Phase_A)\",\n",
+ " \"Flux_B\": \"FluxLinkage(Phase_B)\",\n",
+ " \"Flux_C\": \"FluxLinkage(Phase_C)\",\n",
+ " \"pos\": \"(Moving1.Position -InitialPositionMD) *NumPoles/2\",\n",
+ " \"cos0\": \"cos(pos)\",\n",
+ " \"cos1\": \"cos(pos-2*PI/3)\",\n",
+ " \"cos2\": \"cos(pos-4*PI/3)\",\n",
+ " \"sin0\": \"sin(pos)\",\n",
+ " \"sin1\": \"sin(pos-2*PI/3)\",\n",
+ " \"sin2\": \"sin(pos-4*PI/3)\",\n",
+ " \"Flux_d\": \"2/3*(Flux_A*cos0+Flux_B*cos1+Flux_C*cos2)\",\n",
+ " \"Flux_q\": \"-2/3*(Flux_A*sin0+Flux_B*sin1+Flux_C*sin2)\",\n",
+ " \"I_d\": \"2/3*(Current_A*cos0 + Current_B*cos1 + Current_C*cos2)\",\n",
+ " \"I_q\": \"-2/3*(Current_A*sin0 + Current_B*sin1 + Current_C*sin2)\",\n",
+ " \"Irms\": \"sqrt(I_d^2+I_q^2)/sqrt(2)\",\n",
+ " \"ArmatureOhmicLoss_DC\": \"Irms^2*R_phase\",\n",
+ " \"Lad\": \"L(Phase_A,Phase_A)*cos0 + L(Phase_A,Phase_B)*cos1 + L(Phase_A,Phase_C)*cos2\",\n",
+ " \"Laq\": \"L(Phase_A,Phase_A)*sin0 + L(Phase_A,Phase_B)*sin1 + L(Phase_A,Phase_C)*sin2\",\n",
+ " \"Lbd\": \"L(Phase_B,Phase_A)*cos0 + L(Phase_B,Phase_B)*cos1 + L(Phase_B,Phase_C)*cos2\",\n",
+ " \"Lbq\": \"L(Phase_B,Phase_A)*sin0 + L(Phase_B,Phase_B)*sin1 + L(Phase_B,Phase_C)*sin2\",\n",
+ " \"Lcd\": \"L(Phase_C,Phase_A)*cos0 + L(Phase_C,Phase_B)*cos1 + L(Phase_C,Phase_C)*cos2\",\n",
+ " \"Lcq\": \"L(Phase_C,Phase_A)*sin0 + L(Phase_C,Phase_B)*sin1 + L(Phase_C,Phase_C)*sin2\",\n",
+ " \"L_d\": \"(Lad*cos0 + Lbd*cos1 + Lcd*cos2) * 2/3\",\n",
+ " \"L_q\": \"(Laq*sin0 + Lbq*sin1 + Lcq*sin2) * 2/3\",\n",
+ " \"OutputPower\": \"Moving1.Speed*Moving1.Torque\",\n",
+ " \"Ui_A\": \"InducedVoltage(Phase_A)\",\n",
+ " \"Ui_B\": \"InducedVoltage(Phase_B)\",\n",
+ " \"Ui_C\": \"InducedVoltage(Phase_C)\",\n",
+ " \"Ui_d\": \"2/3*(Ui_A*cos0 + Ui_B*cos1 + Ui_C*cos2)\",\n",
+ " \"Ui_q\": \"-2/3*(Ui_A*sin0 + Ui_B*sin1 + Ui_C*sin2)\",\n",
+ " \"U_A\": \"Ui_A+R_Phase*Current_A\",\n",
+ " \"U_B\": \"Ui_B+R_Phase*Current_B\",\n",
+ " \"U_C\": \"Ui_C+R_Phase*Current_C\",\n",
+ " \"U_d\": \"2/3*(U_A*cos0 + U_B*cos1 + U_C*cos2)\",\n",
+ " \"U_q\": \"-2/3*(U_A*sin0 + U_B*sin1 + U_C*sin2)\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1cb11f2e",
+ "metadata": {},
+ "source": [
+ "## Create output variables for postprocessing"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0cb5b909",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for k, v in output_vars.items():\n",
+ " m2d.create_output_variable(k, v)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "26686590",
+ "metadata": {},
+ "source": [
+ "## Initialize definition for postprocessing plots"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e2df3cea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "post_params = {\"Moving1.Torque\": \"TorquePlots\"}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d62a6254",
+ "metadata": {},
+ "source": [
+ "## Initialize definition for postprocessing multiplots"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7b6a1cb7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "post_params_multiplot = { # reports\n",
+ " (\"U_A\", \"U_B\", \"U_C\", \"Ui_A\", \"Ui_B\", \"Ui_C\"): \"PhaseVoltages\",\n",
+ " (\"CoreLoss\", \"SolidLoss\", \"ArmatureOhmicLoss_DC\"): \"Losses\",\n",
+ " (\n",
+ " \"InputCurrent(Phase_A)\",\n",
+ " \"InputCurrent(Phase_B)\",\n",
+ " \"InputCurrent(Phase_C)\",\n",
+ " ): \"PhaseCurrents\",\n",
+ " (\n",
+ " \"FluxLinkage(Phase_A)\",\n",
+ " \"FluxLinkage(Phase_B)\",\n",
+ " \"FluxLinkage(Phase_C)\",\n",
+ " ): \"PhaseFluxes\",\n",
+ " (\"I_d\", \"I_q\"): \"Currents_dq\",\n",
+ " (\"Flux_d\", \"Flux_q\"): \"Fluxes_dq\",\n",
+ " (\"Ui_d\", \"Ui_q\"): \"InducedVoltages_dq\",\n",
+ " (\"U_d\", \"U_q\"): \"Voltages_dq\",\n",
+ " (\n",
+ " \"L(Phase_A,Phase_A)\",\n",
+ " \"L(Phase_B,Phase_B)\",\n",
+ " \"L(Phase_C,Phase_C)\",\n",
+ " \"L(Phase_A,Phase_B)\",\n",
+ " \"L(Phase_A,Phase_C)\",\n",
+ " \"L(Phase_B,Phase_C)\",\n",
+ " ): \"PhaseInductances\",\n",
+ " (\"L_d\", \"L_q\"): \"Inductances_dq\",\n",
+ " (\"CoreLoss\", \"CoreLoss(Stator)\", \"CoreLoss(Rotor)\"): \"CoreLosses\",\n",
+ " (\n",
+ " \"EddyCurrentLoss\",\n",
+ " \"EddyCurrentLoss(Stator)\",\n",
+ " \"EddyCurrentLoss(Rotor)\",\n",
+ " ): \"EddyCurrentLosses (Core)\",\n",
+ " (\"ExcessLoss\", \"ExcessLoss(Stator)\", \"ExcessLoss(Rotor)\"): \"ExcessLosses (Core)\",\n",
+ " (\n",
+ " \"HysteresisLoss\",\n",
+ " \"HysteresisLoss(Stator)\",\n",
+ " \"HysteresisLoss(Rotor)\",\n",
+ " ): \"HysteresisLosses (Core)\",\n",
+ " (\n",
+ " \"SolidLoss\",\n",
+ " \"SolidLoss(IPM1)\",\n",
+ " \"SolidLoss(IPM1_1)\",\n",
+ " \"SolidLoss(OPM1)\",\n",
+ " \"SolidLoss(OPM1_1)\",\n",
+ " ): \"SolidLoss\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "95229a84",
+ "metadata": {},
+ "source": [
+ "## Create report."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5e4b105e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for k, v in post_params.items():\n",
+ " m2d.post.create_report(\n",
+ " expressions=k,\n",
+ " setup_sweep_name=\"\",\n",
+ " domain=\"Sweep\",\n",
+ " variations=None,\n",
+ " primary_sweep_variable=\"Time\",\n",
+ " secondary_sweep_variable=None,\n",
+ " report_category=None,\n",
+ " plot_type=\"Rectangular Plot\",\n",
+ " context=None,\n",
+ " subdesign_id=None,\n",
+ " polyline_points=1001,\n",
+ " plot_name=v,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c07089e0",
+ "metadata": {},
+ "source": [
+ "## Create multiplot report"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b90de113",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# for k, v in post_params_multiplot.items():\n",
+ "# m2d.post.create_report(expressions=list(k), setup_sweep_name=\"\",\n",
+ "# domain=\"Sweep\", variations=None,\n",
+ "# primary_sweep_variable=\"Time\", secondary_sweep_variable=None,\n",
+ "# report_category=None, plot_type=\"Rectangular Plot\",\n",
+ "# context=None, subdesign_id=None,\n",
+ "# polyline_points=1001, plotname=v)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "010a36f9",
+ "metadata": {},
+ "source": [
+ "## Analyze and save project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "98f41a6d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.analyze_setup(setup_name, use_auto_settings=False, cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "324b0b12",
+ "metadata": {},
+ "source": [
+ "## Create flux lines plot on region\n",
+ "\n",
+ "Create a flux lines plot on a region. The ``object_list`` is\n",
+ "formerly created when the section is applied."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a76df649",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "faces_reg = m2d.modeler.get_object_faces(object_list[1].name) # Region\n",
+ "plot1 = m2d.post.create_fieldplot_surface(\n",
+ " assignment=faces_reg,\n",
+ " quantity=\"Flux_Lines\",\n",
+ " intrinsics={\"Time\": m2d.variable_manager.variables[\"StopTime\"].evaluated_value},\n",
+ " plot_name=\"Flux_Lines\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3b10c7a6",
+ "metadata": {},
+ "source": [
+ "## Export a field plot to an image file\n",
+ "\n",
+ "Export the flux lines plot to an image file using Python PyVista."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48417a95",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.post.plot_field_from_fieldplot(plot1.name, show=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64d5e187",
+ "metadata": {},
+ "source": [
+ "## Get solution data\n",
+ "\n",
+ "Get a simulation result from a solved setup and cast it in a ``SolutionData`` object.\n",
+ "Plot the desired expression by using the Matplotlib ``plot()`` function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1cb7b28d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solutions = m2d.post.get_solution_data(\n",
+ " expressions=\"Moving1.Torque\", primary_sweep_variable=\"Time\"\n",
+ ")\n",
+ "# solutions.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d72dd07",
+ "metadata": {},
+ "source": [
+ "## Retrieve the data magnitude of an expression\n",
+ "\n",
+ "List of shaft torque points and compute average."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ba0ed85",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mag = solutions.data_magnitude()\n",
+ "avg = sum(mag) / len(mag)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64f41577",
+ "metadata": {},
+ "source": [
+ "## Export a report to a file\n",
+ "\n",
+ "Export 2D plot data to a CSV file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "50cb80b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.post.export_report_to_file(\n",
+ " output_dir=temp_folder.name, plot_name=\"TorquePlots\", extension=\".csv\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db204f3d",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b68eabb3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7971977",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1e645438",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/rmxpert.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/rmxpert.ipynb.txt
new file mode 100644
index 00000000..08b9178a
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/rmxpert.ipynb.txt
@@ -0,0 +1,410 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "6300d2e3",
+ "metadata": {},
+ "source": [
+ "# Motor creation and export\n",
+ "\n",
+ "This example uses PyAEDT to create a RMxprt project and export it to Maxwell 2D.\n",
+ "It shows how to create an ASSM (Adjust-Speed Synchronous Machine) in RMxprt\n",
+ "and how to access rotor and stator settings.\n",
+ "It then exports the model to a Maxwell 2D design\n",
+ "and the RMxprt settings to a JSON file to be reused.\n",
+ "\n",
+ "Keywords: **RMxprt**, **Maxwell 2D**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b01fc33",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f5a820be",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "367fbc81",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e7b3cd5e",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4168365b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "45f9202e",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4451384a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "105da019",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and RMxprt\n",
+ "\n",
+ "Launch AEDT and RMxprt after first setting up the project name.\n",
+ "This example uses ASSM (Adjust-Speed Synchronous Machine) as the solution type."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a18e71cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"ASSM.aedt\")\n",
+ "rmxprt = ansys.aedt.core.Rmxprt(\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " close_on_exit=True,\n",
+ " solution_type=\"ASSM\",\n",
+ " project=project_name,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30620a08",
+ "metadata": {},
+ "source": [
+ "## Define global machine settings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "628b8d59",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.general[\"Number of Poles\"] = 4\n",
+ "rmxprt.general[\"Rotor Position\"] = \"Inner Rotor\"\n",
+ "rmxprt.general[\"Frictional Loss\"] = \"12W\"\n",
+ "rmxprt.general[\"Windage Loss\"] = \"0W\"\n",
+ "rmxprt.general[\"Reference Speed\"] = \"1500rpm\"\n",
+ "rmxprt.general[\"Control Type\"] = \"DC\"\n",
+ "rmxprt.general[\"Circuit Type\"] = \"Y3\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98b308b8",
+ "metadata": {},
+ "source": [
+ "## Define circuit settings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b0c80a47",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.circuit[\"Trigger Pulse Width\"] = \"120deg\"\n",
+ "rmxprt.circuit[\"Transistor Drop\"] = \"2V\"\n",
+ "rmxprt.circuit[\"Diode Drop\"] = \"2V\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f27a2587",
+ "metadata": {},
+ "source": [
+ "## Define stator\n",
+ "\n",
+ "Define stator and slot and winding settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "72e3cebb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.stator[\"Outer Diameter\"] = \"122mm\"\n",
+ "rmxprt.stator[\"Inner Diameter\"] = \"75mm\"\n",
+ "rmxprt.stator[\"Length\"] = \"65mm\"\n",
+ "rmxprt.stator[\"Stacking Factor\"] = 0.95\n",
+ "rmxprt.stator[\"Steel Type\"] = \"steel_1008\"\n",
+ "rmxprt.stator[\"Number of Slots\"] = 24\n",
+ "rmxprt.stator[\"Slot Type\"] = 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8fbd01cf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Auto Design\"] = False\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Hs0\"] = \"0.5mm\"\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Hs1\"] = \"1.2mm\"\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Hs2\"] = \"8.2mm\"\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Bs0\"] = \"2.5mm\"\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Bs1\"] = \"5.6mm\"\n",
+ "rmxprt.stator.properties.children[\"Slot\"].props[\"Bs2\"] = \"7.6mm\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9cdc092f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.stator.properties.children[\"Winding\"].props[\"Winding Layers\"] = 2\n",
+ "rmxprt.stator.properties.children[\"Winding\"].props[\"Parallel Branches\"] = 1\n",
+ "rmxprt.stator.properties.children[\"Winding\"].props[\"Conductors per Slot\"] = 52\n",
+ "rmxprt.stator.properties.children[\"Winding\"].props[\"Coil Pitch\"] = 5\n",
+ "rmxprt.stator.properties.children[\"Winding\"].props[\"Number of Strands\"] = 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8a747512",
+ "metadata": {},
+ "source": [
+ "## Define rotor\n",
+ "\n",
+ "Define rotor and pole settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fc5847ea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.rotor[\"Outer Diameter\"] = \"74mm\"\n",
+ "rmxprt.rotor[\"Inner Diameter\"] = \"26mm\"\n",
+ "rmxprt.rotor[\"Length\"] = \"65mm\"\n",
+ "rmxprt.rotor[\"Stacking Factor\"] = 0.95\n",
+ "rmxprt.rotor[\"Steel Type\"] = \"steel_1008\"\n",
+ "rmxprt.rotor[\"Pole Type\"] = 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e7ceba6a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rmxprt.rotor.properties.children[\"Pole\"].props[\"Embrace\"] = 0.7\n",
+ "rmxprt.rotor.properties.children[\"Pole\"].props[\"Offset\"] = \"0mm\"\n",
+ "rmxprt.rotor.properties.children[\"Pole\"].props[\"Magnet Type\"] = [\n",
+ " \"Material:=\",\n",
+ " \"Alnico9\",\n",
+ "]\n",
+ "rmxprt.rotor.properties.children[\"Pole\"].props[\"Magnet Thickness\"] = \"3.5mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fff44b32",
+ "metadata": {},
+ "source": [
+ "## Create setup\n",
+ "\n",
+ "Create a setup and define the main settings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "750f11a1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = rmxprt.create_setup()\n",
+ "setup.props[\"RatedVoltage\"] = \"220V\"\n",
+ "setup.props[\"RatedOutputPower\"] = \"550W\"\n",
+ "setup.props[\"RatedSpeed\"] = \"1500rpm\"\n",
+ "setup.props[\"OperatingTemperature\"] = \"75cel\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88bc454a",
+ "metadata": {},
+ "source": [
+ "## Analyze setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "284176ea",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup.analyze(cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4868d714",
+ "metadata": {},
+ "source": [
+ "## Export to Maxwell\n",
+ "\n",
+ "After the project is solved, you can export it to either Maxwell 2D or Maxwell 3D."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5b6c5286",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d = rmxprt.create_maxwell_design(setup_name=setup.name, maxwell_2d=True)\n",
+ "m2d.plot(\n",
+ " show=False,\n",
+ " output_file=os.path.join(temp_folder.name, \"Image.jpg\"),\n",
+ " plot_air_objects=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a863373c",
+ "metadata": {},
+ "source": [
+ "## Export RMxprt settings\n",
+ "\n",
+ "Export all RMxprt settings to a JSON file to reuse it for another\n",
+ "project with the the import function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "043ccda0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "config = rmxprt.export_configuration(os.path.join(temp_folder.name, \"assm.json\"))\n",
+ "rmxprt2 = ansys.aedt.core.Rmxprt(\n",
+ " project=\"assm_test2\",\n",
+ " solution_type=rmxprt.solution_type,\n",
+ " design=\"from_configuration\",\n",
+ ")\n",
+ "rmxprt2.import_configuration(config)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ae9a298d",
+ "metadata": {},
+ "source": [
+ "## Save project\n",
+ "\n",
+ "Save the project containing the Maxwell design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8a1aa6d9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project(file_name=project_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "edb18654",
+ "metadata": {},
+ "source": [
+ "## Release AEDT and clean up temporary directory\n",
+ "\n",
+ "Release AEDT and remove both the project and temporary directory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "810fa788",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.release_desktop()\n",
+ "time.sleep(3)\n",
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer.ipynb.txt
new file mode 100644
index 00000000..fb70ae0b
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer.ipynb.txt
@@ -0,0 +1,285 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "fd7c49ae",
+ "metadata": {},
+ "source": [
+ "# Transformer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bdb2899f",
+ "metadata": {},
+ "source": [
+ "This example shows how to use PyAEDT to set core loss given a set\n",
+ "of power-volume [kw/m^3] curves at different frequencies.\n",
+ "\n",
+ "Keywords: **Maxwell 3D**, **Transformer**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8dd259e8",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "927e4acc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee6c508b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import Maxwell3d, downloads\n",
+ "from ansys.aedt.core.generic.constants import unit_converter\n",
+ "from ansys.aedt.core.generic.general_methods import read_csv_pandas"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "252c62f1",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a1fc23fc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "430cee09",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9a1da004",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "31ec4113",
+ "metadata": {},
+ "source": [
+ "## Download AEDT file example\n",
+ "\n",
+ "Download the files required to run this example to the temporary working folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d20d53e4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "aedt_file = downloads.download_file(\n",
+ " source=\"core_loss_transformer\",\n",
+ " name=\"Ex2-PlanarTransformer_2023R2.aedtz\",\n",
+ " destination=temp_folder.name,\n",
+ ")\n",
+ "freq_curve_csv_25kHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_25kHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "freq_curve_csv_100kHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_100kHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "freq_curve_csv_200kHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_200kHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "freq_curve_csv_400kHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_400kHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "freq_curve_csv_700kHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_700kHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "freq_curve_csv_1MHz = downloads.download_file(\n",
+ " source=\"core_loss_transformer\", name=\"mf3_1MHz.csv\", destination=temp_folder.name\n",
+ ")\n",
+ "\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_25kHz)\n",
+ "curves_csv_25kHz = list(zip(data[data.columns[0]], data[data.columns[1]]))\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_100kHz)\n",
+ "curves_csv_100kHz = list(zip(data[data.columns[0]], data[data.columns[1]]))\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_200kHz)\n",
+ "curves_csv_200kHz = list(zip(data[data.columns[0]], data[data.columns[1]]))\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_400kHz)\n",
+ "curves_csv_400kHz = list(zip(data[data.columns[0]], data[data.columns[1]]))\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_700kHz)\n",
+ "curves_csv_700kHz = list(zip(data[data.columns[0]], data[data.columns[1]]))\n",
+ "data = read_csv_pandas(input_file=freq_curve_csv_1MHz)\n",
+ "curves_csv_1MHz = list(zip(data[data.columns[0]], data[data.columns[1]]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3ade7f49",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and Maxwell 3D\n",
+ "\n",
+ "Create an instance of the ``Maxwell3d`` class named ``m3d`` by providing\n",
+ "the project and design names, the version, and the graphical mode."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0cb0f1eb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d = Maxwell3d(\n",
+ " project=aedt_file,\n",
+ " design=\"02_3D eddycurrent_CmXY_for_thermal\",\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=True,\n",
+ " non_graphical=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "68dc3b7a",
+ "metadata": {},
+ "source": [
+ "## Set core loss at frequencies\n",
+ "\n",
+ "Create a new material, create a dictionary of power-volume [kw/m^3] points\n",
+ "for a set of frequencies retrieved from datasheet provided by a supplier,\n",
+ "and finally set the Power-Ferrite core loss model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "067d4746",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat = m3d.materials.add_material(\"newmat\")\n",
+ "freq_25kHz = unit_converter(\n",
+ " values=25, unit_system=\"Freq\", input_units=\"kHz\", output_units=\"Hz\"\n",
+ ")\n",
+ "freq_100kHz = unit_converter(\n",
+ " values=100, unit_system=\"Freq\", input_units=\"kHz\", output_units=\"Hz\"\n",
+ ")\n",
+ "freq_200kHz = unit_converter(\n",
+ " values=200, unit_system=\"Freq\", input_units=\"kHz\", output_units=\"Hz\"\n",
+ ")\n",
+ "freq_400kHz = unit_converter(\n",
+ " values=400, unit_system=\"Freq\", input_units=\"kHz\", output_units=\"Hz\"\n",
+ ")\n",
+ "freq_700kHz = unit_converter(\n",
+ " values=700, unit_system=\"Freq\", input_units=\"kHz\", output_units=\"Hz\"\n",
+ ")\n",
+ "pv = {\n",
+ " freq_25kHz: curves_csv_25kHz,\n",
+ " freq_100kHz: curves_csv_100kHz,\n",
+ " freq_200kHz: curves_csv_200kHz,\n",
+ " freq_400kHz: curves_csv_400kHz,\n",
+ " freq_700kHz: curves_csv_700kHz,\n",
+ "}\n",
+ "m3d.materials[mat.name].set_coreloss_at_frequency(\n",
+ " points_at_frequency=pv,\n",
+ " coefficient_setup=\"kw_per_cubic_meter\",\n",
+ " core_loss_model_type=\"Power Ferrite\",\n",
+ ")\n",
+ "coefficients = m3d.materials[mat.name].get_core_loss_coefficients(\n",
+ " points_at_frequency=pv, coefficient_setup=\"kw_per_cubic_meter\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e7948cb1",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3fb675a8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.save_project()\n",
+ "m3d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a666a07",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c3a66f7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer_inductance.ipynb.txt b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer_inductance.ipynb.txt
new file mode 100644
index 00000000..4234b099
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/aedt_motor/transformer_inductance.ipynb.txt
@@ -0,0 +1,522 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e943f0a7",
+ "metadata": {},
+ "source": [
+ "# Transformer leakage inductance calculation\n",
+ "\n",
+ "This example shows how to use PyAEDT to create a Maxwell 2D\n",
+ "magnetostatic analysis to calculate transformer leakage\n",
+ "inductance and reactance.\n",
+ "The analysis based on this document is from page 8 in Professor S. V.\n",
+ "Kulkami's paper, [Basis of Finite Element Method](https://www.ee.iitb.ac.in/~fclab/FEM/FEM1.pdf).\n",
+ "\n",
+ "Keywords: **Maxwell 2D**, **transformer**, **motor**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f4211f03",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a3250eec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b6c6bb7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ansys.aedt.core import Maxwell2d"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0588bee8",
+ "metadata": {},
+ "source": [
+ "Define constants,"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "57bc927f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1096a075",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "78e86479",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fbfbb97",
+ "metadata": {},
+ "source": [
+ "## Initialize and launch Maxwell 2D\n",
+ "\n",
+ "Initialize and launch Maxwell 2D, providing the version, the path to the project, the design\n",
+ "name, and the type."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5ecea58a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "project_name = os.path.join(temp_folder.name, \"Magnetostatic.aedt\")\n",
+ "m2d = Maxwell2d(\n",
+ " version=AEDT_VERSION,\n",
+ " new_desktop=False,\n",
+ " design=\"Transformer_leakage_inductance\",\n",
+ " project=project_name,\n",
+ " solution_type=\"MagnetostaticXY\",\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "777b6996",
+ "metadata": {},
+ "source": [
+ "## Initialize dictionaries\n",
+ "\n",
+ "Set modeler units and initialize dictionaries\n",
+ "that contain all the definitions for the design variables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df80f271",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.modeler.model_units = \"mm\"\n",
+ "\n",
+ "dimensions = {\n",
+ " \"core_width\": \"1097mm\",\n",
+ " \"core_height\": \"2880mm\",\n",
+ " \"core_opening_x1\": \"270mm\",\n",
+ " \"core_opening_x2\": \"557mm\",\n",
+ " \"core_opening_y1\": \"540mm\",\n",
+ " \"core_opening_y2\": \"2340mm\",\n",
+ " \"core_opening_width\": \"core_opening_x2-core_opening_x1\",\n",
+ " \"core_opening_height\": \"core_opening_y2-core_opening_y1\",\n",
+ " \"LV_x1\": \"293mm\",\n",
+ " \"LV_x2\": \"345mm\",\n",
+ " \"LV_width\": \"LV_x2-LV_x1\",\n",
+ " \"LV_mean_radius\": \"LV_x1+LV_width/2\",\n",
+ " \"LV_mean_turn_length\": \"pi*2*LV_mean_radius\",\n",
+ " \"LV_y1\": \"620mm\",\n",
+ " \"LV_y2\": \"2140mm\",\n",
+ " \"LV_height\": \"LV_y2-LV_y1\",\n",
+ " \"HV_x1\": \"394mm\",\n",
+ " \"HV_x2\": \"459mm\",\n",
+ " \"HV_width\": \"HV_x2-HV_x1\",\n",
+ " \"HV_mean_radius\": \"HV_x1+HV_width/2\",\n",
+ " \"HV_mean_turn_length\": \"pi*2*HV_mean_radius\",\n",
+ " \"HV_y1\": \"620mm\",\n",
+ " \"HV_y2\": \"2140mm\",\n",
+ " \"HV_height\": \"HV_y2-HV_y1\",\n",
+ " \"HV_LV_gap_radius\": \"(LV_x2 + HV_x1)/2\",\n",
+ " \"HV_LV_gap_length\": \"pi*2*HV_LV_gap_radius\",\n",
+ "}\n",
+ "\n",
+ "specifications = {\n",
+ " \"Amp_turns\": \"135024A\",\n",
+ " \"Frequency\": \"50Hz\",\n",
+ " \"HV_turns\": \"980\",\n",
+ " \"HV_current\": \"Amp_turns/HV_turns\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "69c15098",
+ "metadata": {},
+ "source": [
+ "## Define variables from dictionaries\n",
+ "\n",
+ "Define design variables from the created dictionaries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "20e0b563",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.variable_manager.set_variable(name=\"Dimensions\")\n",
+ "\n",
+ "for k, v in dimensions.items():\n",
+ " m2d[k] = v\n",
+ "\n",
+ "m2d.variable_manager.set_variable(name=\"Windings\")\n",
+ "\n",
+ "for k, v in specifications.items():\n",
+ " m2d[k] = v"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8b801f62",
+ "metadata": {},
+ "source": [
+ "## Create design geometries\n",
+ "\n",
+ "Create the transformer core, the HV and LV windings, and the region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e9595c7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "core = m2d.modeler.create_rectangle(\n",
+ " origin=[0, 0, 0],\n",
+ " sizes=[\"core_width\", \"core_height\", 0],\n",
+ " name=\"core\",\n",
+ " material=\"steel_1008\",\n",
+ ")\n",
+ "\n",
+ "core_hole = m2d.modeler.create_rectangle(\n",
+ " origin=[\"core_opening_x1\", \"core_opening_y1\", 0],\n",
+ " sizes=[\"core_opening_width\", \"core_opening_height\", 0],\n",
+ " name=\"core_hole\",\n",
+ ")\n",
+ "\n",
+ "m2d.modeler.subtract(blank_list=[core], tool_list=[core_hole], keep_originals=False)\n",
+ "\n",
+ "lv = m2d.modeler.create_rectangle(\n",
+ " origin=[\"LV_x1\", \"LV_y1\", 0],\n",
+ " sizes=[\"LV_width\", \"LV_height\", 0],\n",
+ " name=\"LV\",\n",
+ " material=\"copper\",\n",
+ ")\n",
+ "\n",
+ "hv = m2d.modeler.create_rectangle(\n",
+ " origin=[\"HV_x1\", \"HV_y1\", 0],\n",
+ " sizes=[\"HV_width\", \"HV_height\", 0],\n",
+ " name=\"HV\",\n",
+ " material=\"copper\",\n",
+ ")\n",
+ "\n",
+ "region = m2d.modeler.create_region(pad_percent=[20, 10, 0, 10])\n",
+ "\n",
+ "# ## Assign boundary condition\n",
+ "#\n",
+ "# Assign vector potential to zero on all region boundaries. This makes x=0 edge a symmetry boundary.\n",
+ "\n",
+ "m2d.assign_vector_potential(assignment=region.edges, boundary=\"VectorPotential1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f4d183ad",
+ "metadata": {},
+ "source": [
+ "## Create initial mesh settings\n",
+ "\n",
+ "Assign a relatively dense mesh to all objects to ensure that the energy is calculated accurately."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae232cb7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.mesh.assign_length_mesh(\n",
+ " assignment=[\"core\", \"Region\", \"LV\", \"HV\"],\n",
+ " maximum_length=50,\n",
+ " maximum_elements=None,\n",
+ " name=\"all_objects\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3cb504b",
+ "metadata": {},
+ "source": [
+ "## Define excitations\n",
+ "\n",
+ "Assign the same current in amp-turns but in opposite directions to the HV and LV windings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "624c06bf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.assign_current(assignment=lv, amplitude=\"Amp_turns\", name=\"LV\")\n",
+ "m2d.assign_current(assignment=hv, amplitude=\"Amp_turns\", name=\"HV\", swap_direction=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b2ffb4f",
+ "metadata": {},
+ "source": [
+ "## Create and analyze setup\n",
+ "\n",
+ "Create and analyze the setup. Set the number of minimum passes to 3 to ensure accuracy."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d4ff9fed",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.create_setup(name=\"Setup1\", MinimumPasses=3)\n",
+ "m2d.analyze_setup(use_auto_settings=False, cores=NUM_CORES)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3dd8642c",
+ "metadata": {},
+ "source": [
+ "## Calculate transformer leakage inductance and reactance\n",
+ "\n",
+ "Calculate transformer leakage inductance from the magnetic energy with PyAEDT advanced fields calculator."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fb5312db",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "leakage_inductance = {\n",
+ " \"name\": \"Leakage_inductance\",\n",
+ " \"description\": \"Leakage inductance from the magnetic energy\",\n",
+ " \"design_type\": [\"Maxwell 2D\"],\n",
+ " \"fields_type\": [\"Fields\"],\n",
+ " \"primary_sweep\": \"Distance\",\n",
+ " \"assignment\": \"\",\n",
+ " \"assignment_type\": [\"Line\"],\n",
+ " \"operations\": [\n",
+ " \"Fundamental_Quantity('Energy')\",\n",
+ " \"EnterSurface('HV')\",\n",
+ " \"Operation('SurfaceValue')\",\n",
+ " \"Operation('Integrate')\",\n",
+ " \"Scalar_Function(FuncValue='HV_mean_turn_length')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Fundamental_Quantity('Energy')\",\n",
+ " \"EnterSurface('LV')\",\n",
+ " \"Operation('SurfaceValue')\",\n",
+ " \"Operation('Integrate')\",\n",
+ " \"Scalar_Function(FuncValue='LV_mean_turn_length')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Fundamental_Quantity('Energy')\",\n",
+ " \"EnterSurface('Region')\",\n",
+ " \"Operation('SurfaceValue')\",\n",
+ " \"Operation('Integrate')\",\n",
+ " \"Scalar_Function(FuncValue='HV_LV_gap_length')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Operation('+')\",\n",
+ " \"Operation('+')\",\n",
+ " \"Scalar_Constant(2)\",\n",
+ " \"Operation('*')\",\n",
+ " \"Scalar_Function(FuncValue='HV_current')\",\n",
+ " \"Scalar_Function(FuncValue='HV_current')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Operation('/')\",\n",
+ " ],\n",
+ " \"report\": [\"Data Table\", \"Rectangular Plot\"],\n",
+ "}\n",
+ "m2d.post.fields_calculator.add_expression(leakage_inductance, None)\n",
+ "\n",
+ "leakage_reactance = {\n",
+ " \"name\": \"Leakage_reactance\",\n",
+ " \"description\": \"Leakage reactance from the magnetic energy\",\n",
+ " \"design_type\": [\"Maxwell 2D\"],\n",
+ " \"fields_type\": [\"Fields\"],\n",
+ " \"primary_sweep\": \"Distance\",\n",
+ " \"assignment\": \"\",\n",
+ " \"assignment_type\": [\"Line\"],\n",
+ " \"operations\": [\n",
+ " \"NameOfExpression('Leakage_inductance')\",\n",
+ " \"Scalar_Constant(2)\",\n",
+ " \"Scalar_Constant(3.14159)\",\n",
+ " \"Scalar_Function(FuncValue='Frequency')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Operation('*')\",\n",
+ " \"Operation('*')\",\n",
+ " ],\n",
+ " \"report\": [\"Data Table\", \"Rectangular Plot\"],\n",
+ "}\n",
+ "m2d.post.fields_calculator.add_expression(leakage_reactance, None)\n",
+ "\n",
+ "m2d.post.create_report(\n",
+ " expressions=[\"Leakage_inductance\", \"Leakage_reactance\"],\n",
+ " report_category=\"Fields\",\n",
+ " primary_sweep_variable=\"core_width\",\n",
+ " plot_type=\"Data Table\",\n",
+ " plot_name=\"Transformer Leakage Inductance\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "beeef0a0",
+ "metadata": {},
+ "source": [
+ "## Print leakage inductance and reactance values in AEDT Message Manager"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3cb5a2f3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.logger.clear_messages()\n",
+ "m2d.logger.info(\n",
+ " \"Leakage_inductance = {:.4f}H\".format(\n",
+ " m2d.post.get_scalar_field_value(quantity=\"Leakage_inductance\")\n",
+ " )\n",
+ ")\n",
+ "m2d.logger.info(\n",
+ " \"Leakage_reactance = {:.2f}Ohm\".format(\n",
+ " m2d.post.get_scalar_field_value(quantity=\"Leakage_reactance\")\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e99da62a",
+ "metadata": {},
+ "source": [
+ "## Plot energy in the simulation domain\n",
+ "\n",
+ "Most of the energy is confined in the air between the HV and LV windings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9cfb1f27",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "energy_field_overlay = m2d.post.create_fieldplot_surface(\n",
+ " assignment=m2d.modeler.object_names,\n",
+ " quantity=\"energy\",\n",
+ " plot_name=\"Energy\",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5950e70f",
+ "metadata": {},
+ "source": [
+ "## Release AEDT"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b7d4479",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m2d.save_project()\n",
+ "m2d.release_desktop()\n",
+ "# Wait 3 seconds to allow AEDT to shut down before cleaning the temporary directory.\n",
+ "time.sleep(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5813da0f",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell\n",
+ "removes all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "899b17f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/motor/index.rst.txt b/version/dev/_sources/examples/low_frequency/motor/index.rst.txt
new file mode 100644
index 00000000..b674f056
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/motor/index.rst.txt
@@ -0,0 +1,33 @@
+Motor
+=====
+
+These examples use PyAEDT to show some motor applications.
+
+
+.. grid:: 2
+
+ .. grid-item-card:: MotorCAD
+ :padding: 2 2 2 2
+ :link: https://motorcad.docs.pyansys.com/version/stable/examples/index.html
+ :link-type: url
+
+ .. image:: ./_static/motorcad.png
+ :alt: MotorCAD
+ :width: 200px
+ :height: 150px
+ :align: center
+
+ Links to examples in PyMotorCAD documentation.
+
+ .. grid-item-card:: Motor
+ :padding: 2 2 2 2
+ :link: aedt_motor/index
+ :link-type: doc
+
+ .. image:: ./_static/motor.png
+ :alt: Motor
+ :width: 200px
+ :height: 150px
+ :align: center
+
+ Motor workflows using PyAEDT.
diff --git a/version/dev/_sources/examples/low_frequency/multiphysics/index.rst.txt b/version/dev/_sources/examples/low_frequency/multiphysics/index.rst.txt
new file mode 100644
index 00000000..276cbb17
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/multiphysics/index.rst.txt
@@ -0,0 +1,22 @@
+Multiphysics
+~~~~~~~~~~~~
+
+These examples use PyAEDT to show some multiphysics applications.
+
+.. grid-item-card:: Maxwell 3D-Icepak electrothermal analysis
+ :padding: 2 2 2 2
+ :link: maxwell_icepak
+ :link-type: doc
+
+ .. image:: _static/charging.png
+ :alt: Charging
+ :width: 250px
+ :height: 200px
+ :align: center
+
+ This example uses PyAEDT to set up a simple Maxwell design consisting of a coil and a ferrite core.
+
+.. toctree::
+ :hidden:
+
+ maxwell_icepak
\ No newline at end of file
diff --git a/version/dev/_sources/examples/low_frequency/multiphysics/maxwell_icepak.ipynb.txt b/version/dev/_sources/examples/low_frequency/multiphysics/maxwell_icepak.ipynb.txt
new file mode 100644
index 00000000..8e863786
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/multiphysics/maxwell_icepak.ipynb.txt
@@ -0,0 +1,658 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "d9a948e0",
+ "metadata": {},
+ "source": [
+ "# Maxwell 3D-Icepak electrothermal analysis\n",
+ "\n",
+ "This example uses PyAEDT to set up a simple Maxwell design consisting of a coil and a ferrite core.\n",
+ "Coil current is set to 100A, and coil resistance and ohmic loss are analyzed.\n",
+ "Ohmic loss is mapped to Icepak, and a thermal analysis is performed.\n",
+ "Icepak calculates a temperature distribution, and it is mapped back to Maxwell (2-way coupling).\n",
+ "Coil resistance and ohmic loss are analyzed again in Maxwell. Results are printed in AEDT Message Manager.\n",
+ "\n",
+ "Keywords: **Multiphysics**, **Maxwell**, **Icepak**, **Wireless Charging**.\n",
+ "\n",
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "442134b0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7250be2f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import ansys.aedt.core\n",
+ "from ansys.aedt.core.generic.constants import AXIS"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f8aecc94",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f54f0b9c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cde9978f",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4916fc77",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6396ef9",
+ "metadata": {},
+ "source": [
+ "## Launch application\n",
+ "\n",
+ "The syntax for different applications in AEDT differ\n",
+ "only in the name of the class. This template uses\n",
+ "the ``Hfss()`` class. Modify this text as needed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "11205e02",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"Maxwell-Icepak-2way-Coupling\")\n",
+ "maxwell_design_name = \"1 Maxwell\"\n",
+ "icepak_design_name = \"2 Icepak\"\n",
+ "\n",
+ "m3d = ansys.aedt.core.Maxwell3d(\n",
+ " project=project_name,\n",
+ " design=maxwell_design_name,\n",
+ " solution_type=\"EddyCurrent\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe89d191",
+ "metadata": {},
+ "source": [
+ "## Set up model\n",
+ "\n",
+ "Create the coil, coil terminal, core, and region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0e0ceec1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coil = m3d.modeler.create_rectangle(\n",
+ " orientation=\"XZ\", origin=[70, 0, -11], sizes=[11, 110], name=\"Coil\"\n",
+ ")\n",
+ "\n",
+ "coil.sweep_around_axis(axis=AXIS.Z)\n",
+ "\n",
+ "coil_terminal = m3d.modeler.create_rectangle(\n",
+ " orientation=\"XZ\", origin=[70, 0, -11], sizes=[11, 110], name=\"Coil_terminal\"\n",
+ ")\n",
+ "\n",
+ "core = m3d.modeler.create_rectangle(\n",
+ " orientation=\"XZ\", origin=[45, 0, -18], sizes=[7, 160], name=\"Core\"\n",
+ ")\n",
+ "core.sweep_around_axis(axis=AXIS.Z)\n",
+ "\n",
+ "# Magnetic flux is not concentrated by the core in +z-direction. Therefore, more padding is needed in that direction.\n",
+ "region = m3d.modeler.create_region(pad_percent=[20, 20, 20, 20, 500, 100])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d119bf21",
+ "metadata": {},
+ "source": [
+ "### Create and assign material\n",
+ "\n",
+ "Create a new cooper material: Copper AWG40 Litz wire, strand diameter = 0.08mm,\n",
+ "24 parallel strands. Then assign materials: Assign the coil to AWG40 copper,\n",
+ "the core to ferrite, and the region to vacuum."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cc1616f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "no_strands = 24\n",
+ "strand_diameter = 0.08\n",
+ "\n",
+ "cu_litz = m3d.materials.duplicate_material(\"copper\", \"copper_litz\")\n",
+ "cu_litz.stacking_type = \"Litz Wire\"\n",
+ "cu_litz.wire_diameter = str(strand_diameter) + \"mm\"\n",
+ "cu_litz.wire_type = \"Round\"\n",
+ "cu_litz.strand_number = no_strands\n",
+ "\n",
+ "m3d.assign_material(region.name, \"vacuum\")\n",
+ "m3d.assign_material(coil.name, \"copper_litz\")\n",
+ "m3d.assign_material(core.name, \"ferrite\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "39c20bca",
+ "metadata": {},
+ "source": [
+ "Assign coil current. The coil consists of 20 turns. The total current is 10A.\n",
+ "Note that each coil turn consists of 24 parallel Litz strands as indicated earlier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "24a35124",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "no_turns = 20\n",
+ "coil_current = 10\n",
+ "m3d.assign_coil([\"Coil_terminal\"], conductors_number=no_turns, name=\"Coil_terminal\")\n",
+ "m3d.assign_winding(is_solid=False, current=coil_current, name=\"Winding1\")\n",
+ "\n",
+ "m3d.add_winding_coils(assignment=\"Winding1\", coils=[\"Coil_terminal\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f58c8fae",
+ "metadata": {},
+ "source": [
+ "## Assign mesh operations\n",
+ "\n",
+ "Mesh operations are not necessary in the eddy current solver because of auto-adaptive meshing.\n",
+ "However, with appropriate mesh operations, less adaptive passes are needed"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0b716dca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.mesh.assign_length_mesh(\n",
+ " [\"Core\"], maximum_length=15, maximum_elements=None, name=\"Inside_Core\"\n",
+ ")\n",
+ "m3d.mesh.assign_length_mesh(\n",
+ " [\"Coil\"], maximum_length=30, maximum_elements=None, name=\"Inside_Coil\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "96bd0d00",
+ "metadata": {},
+ "source": [
+ "Set conductivity as a function of temperature. Resistivity increases by 0.393% per K."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aeaa42fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cu_resistivity_temp_coefficient = 0.00393\n",
+ "cu_litz.conductivity.add_thermal_modifier_free_form(\n",
+ " \"1.0/(1.0+{}*(Temp-20))\".format(cu_resistivity_temp_coefficient)\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c24f8ba",
+ "metadata": {},
+ "source": [
+ "## Set object temperature and enable feedback\n",
+ "\n",
+ "Set the temperature of the objects to the default temperature (22 degrees C)\n",
+ "and enable temperature feedback for two-way coupling."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e7659099",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.modeler.set_objects_temperature([\"Coil\"], ambient_temperature=22)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "417bac55",
+ "metadata": {},
+ "source": [
+ "## Assign matrix\n",
+ "\n",
+ "Assign matrix for resistance and inductance calculation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ee9ceae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.assign_matrix([\"Winding1\"], matrix_name=\"Matrix1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66281451",
+ "metadata": {},
+ "source": [
+ "## Create and analyze simulation setup\n",
+ "\n",
+ "The simulation frequency is 150 kHz."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f4fb13a2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "setup = m3d.create_setup(name=\"Setup1\")\n",
+ "setup.props[\"Frequency\"] = \"150kHz\"\n",
+ "m3d.analyze_setup(\"Setup1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8722fda7",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Calculate analytical DC resistance and compare it with the simulated coil\n",
+ "resistance. Print them in AEDT Message Manager, along with the ohmic loss in\n",
+ "coil before the temperature feedback."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cc987ae1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report = m3d.post.create_report(expressions=\"Matrix1.R(Winding1,Winding1)\")\n",
+ "solution = report.get_solution_data()\n",
+ "resistance = solution.data_magnitude()[0]\n",
+ "\n",
+ "report_loss = m3d.post.create_report(expressions=\"StrandedLossAC\")\n",
+ "solution_loss = report_loss.get_solution_data()\n",
+ "em_loss = solution_loss.data_magnitude()[0]\n",
+ "\n",
+ "# Analytical calculation of the DC resistance of the coil\n",
+ "cu_cond = float(cu_litz.conductivity.value)\n",
+ "# Average radius of a coil turn = 0.125m\n",
+ "l_conductor = no_turns * 2 * 0.125 * 3.1415\n",
+ "# R = resistivity * length / area / no_strand\n",
+ "r_analytical_DC = (\n",
+ " (1.0 / cu_cond)\n",
+ " * l_conductor\n",
+ " / (3.1415 * (strand_diameter / 1000 / 2) ** 2)\n",
+ " / no_strands\n",
+ ")\n",
+ "\n",
+ "# Print results in AEDT Message Manager\n",
+ "m3d.logger.info(\n",
+ " \"*******Coil analytical DC resistance = {:.2f}Ohm\".format(r_analytical_DC)\n",
+ ")\n",
+ "m3d.logger.info(\n",
+ " \"*******Coil resistance at 150kHz BEFORE temperature feedback = {:.2f}Ohm\".format(\n",
+ " resistance\n",
+ " )\n",
+ ")\n",
+ "m3d.logger.info(\n",
+ " \"*******Ohmic loss in coil BEFORE temperature feedback = {:.2f}W\".format(\n",
+ " em_loss / 1000\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c58e5f2c",
+ "metadata": {},
+ "source": [
+ "## Insert Icepak design\n",
+ "\n",
+ "Insert Icepak design, copy solid objects from Maxwell 3D, and modify region dimensions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "616bac9c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk = ansys.aedt.core.Icepak(design=icepak_design_name, version=AEDT_VERSION)\n",
+ "ipk.copy_solid_bodies_from(m3d, no_pec=False)\n",
+ "\n",
+ "# Set domain dimensions suitable for natural convection using the diameter of the coil\n",
+ "ipk.modeler[\"Region\"].delete()\n",
+ "coil_dim = coil.bounding_dimension[0]\n",
+ "ipk.modeler.create_region(0, False)\n",
+ "ipk.modeler.edit_region_dimensions(\n",
+ " [coil_dim / 2, coil_dim / 2, coil_dim / 2, coil_dim / 2, coil_dim * 2, coil_dim]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9dd517ec",
+ "metadata": {},
+ "source": [
+ "## Map coil losses\n",
+ "\n",
+ "Map ohmic losses from Maxwell 3D to the Icepak design."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "91dce80b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assign_em_losses(\n",
+ " design=\"1 Maxwell\",\n",
+ " setup=m3d.setups[0].name,\n",
+ " sweep=\"LastAdaptive\",\n",
+ " assignment=[\"Coil\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1043578c",
+ "metadata": {},
+ "source": [
+ "### Define boundary conditions\n",
+ "\n",
+ "Assign the opening."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "848eaef3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "faces = ipk.modeler[\"Region\"].faces\n",
+ "face_names = [face.id for face in faces]\n",
+ "ipk.assign_free_opening(face_names, boundary_name=\"Opening1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da504607",
+ "metadata": {},
+ "source": [
+ "### Assign monitor\n",
+ "\n",
+ "Assign the temperature monitor on the coil surface."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "33e52606",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_monitor = ipk.assign_point_monitor([70, 0, 0], monitor_name=\"PointMonitor1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2ce419bc",
+ "metadata": {},
+ "source": [
+ "Set up Icepak solution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "913fa809",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "solution_setup = ipk.create_setup()\n",
+ "solution_setup.props[\"Convergence Criteria - Max Iterations\"] = 50\n",
+ "solution_setup.props[\"Flow Regime\"] = \"Turbulent\"\n",
+ "solution_setup.props[\"Turbulent Model Eqn\"] = \"ZeroEquation\"\n",
+ "solution_setup.props[\"Radiation Model\"] = \"Discrete Ordinates Model\"\n",
+ "solution_setup.props[\"Include Flow\"] = True\n",
+ "solution_setup.props[\"Include Gravity\"] = True\n",
+ "solution_setup.props[\"Solution Initialization - Z Velocity\"] = \"0.0005m_per_sec\"\n",
+ "solution_setup.props[\"Convergence Criteria - Flow\"] = 0.0005\n",
+ "solution_setup.props[\"Flow Iteration Per Radiation Iteration\"] = \"5\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "051add1f",
+ "metadata": {},
+ "source": [
+ "## Add two-way coupling and solve the project\n",
+ "\n",
+ "Enable mapping temperature distribution back to Maxwell 3D. The default number\n",
+ "for Maxwell <–> Icepak iterations is 2. However, for increased accuracy,\n",
+ "you can increate the value for the ``number_of_iterations`` parameter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f77eab1e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.assign_2way_coupling()\n",
+ "ipk.analyze_setup(name=solution_setup.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "50129904",
+ "metadata": {},
+ "source": [
+ "## Postprocess\n",
+ "\n",
+ "Plot temperature on the object surfaces."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4c96f435",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "surface_list = []\n",
+ "for name in [\"Coil\", \"Core\"]:\n",
+ " surface_list.extend(ipk.modeler.get_object_faces(name))\n",
+ "\n",
+ "surf_temperature = ipk.post.create_fieldplot_surface(\n",
+ " surface_list, quantity=\"SurfTemperature\", plot_name=\"Surface Temperature\"\n",
+ ")\n",
+ "\n",
+ "velocity_cutplane = ipk.post.create_fieldplot_cutplane(\n",
+ " assignment=[\"Global:XZ\"], quantity=\"Velocity Vectors\", plot_name=\"Velocity Vectors\"\n",
+ ")\n",
+ "\n",
+ "surf_temperature.export_image()\n",
+ "velocity_cutplane.export_image(orientation=\"right\")\n",
+ "\n",
+ "report_temp = ipk.post.create_report(\n",
+ " expressions=\"PointMonitor1.Temperature\", primary_sweep_variable=\"X\"\n",
+ ")\n",
+ "solution_temp = report_temp.get_solution_data()\n",
+ "temp = solution_temp.data_magnitude()[0]\n",
+ "m3d.logger.info(\"*******Coil temperature = {:.2f}deg C\".format(temp))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7549b8a",
+ "metadata": {},
+ "source": [
+ "### Get new resistance from Maxwell 3D\n",
+ "\n",
+ "The temperature of the coil increases, and consequently the coil resistance increases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5d14cfbd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "report_new = m3d.post.create_report(expressions=\"Matrix1.R(Winding1,Winding1)\")\n",
+ "solution_new = report_new.get_solution_data()\n",
+ "resistance_new = solution_new.data_magnitude()[0]\n",
+ "resistance_increase = (resistance_new - resistance) / resistance * 100\n",
+ "\n",
+ "report_loss_new = m3d.post.create_report(expressions=\"StrandedLossAC\")\n",
+ "solution_loss_new = report_loss_new.get_solution_data()\n",
+ "em_loss_new = solution_loss_new.data_magnitude()[0]\n",
+ "\n",
+ "m3d.logger.info(\n",
+ " \"*******Coil resistance at 150kHz AFTER temperature feedback = {:.2f}Ohm\".format(\n",
+ " resistance_new\n",
+ " )\n",
+ ")\n",
+ "m3d.logger.info(\n",
+ " \"*******Coil resistance increased by {:.2f}%\".format(resistance_increase)\n",
+ ")\n",
+ "m3d.logger.info(\n",
+ " \"*******Ohmic loss in coil AFTER temperature feedback = {:.2f}W\".format(\n",
+ " em_loss_new / 1000\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "356e0e31",
+ "metadata": {},
+ "source": [
+ "### Save project"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1d6c72d2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ipk.save_project()\n",
+ "ipk.release_desktop()\n",
+ "time.sleep(3) # Allow AEDT to shut down before cleaning the temporary project folder."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28058d68",
+ "metadata": {},
+ "source": [
+ "## Clean up\n",
+ "\n",
+ "All project files are saved in the folder ``temp_folder.name``.\n",
+ "If you've run this example as a Jupyter notebook, you\n",
+ "can retrieve those project files. The following cell removes\n",
+ "all temporary files, including the project folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "25244295",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder.cleanup()"
+ ]
+ }
+ ],
+ "metadata": {
+ "jupytext": {
+ "cell_metadata_filter": "-all",
+ "main_language": "python",
+ "notebook_metadata_filter": "-all"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/version/dev/_sources/examples/low_frequency/team_problem/asymmetric_conductor.ipynb.txt b/version/dev/_sources/examples/low_frequency/team_problem/asymmetric_conductor.ipynb.txt
new file mode 100644
index 00000000..465d475d
--- /dev/null
+++ b/version/dev/_sources/examples/low_frequency/team_problem/asymmetric_conductor.ipynb.txt
@@ -0,0 +1,944 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3b0e3a0d",
+ "metadata": {},
+ "source": [
+ "# Asymmetric conductor analysis\n",
+ "\n",
+ "This example uses PyAEDT to set up the TEAM 7 problem for an asymmetric\n",
+ "conductor with a hole and solve it using the Maxwell 3D eddy current solver.\n",
+ "For more information on this problem, see this\n",
+ "[paper](https://www.compumag.org/wp/wp-content/uploads/2018/06/problem7.pdf).\n",
+ "\n",
+ "Keywords: **Maxwell 3D**, **Asymmetric conductor**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22f146ae",
+ "metadata": {},
+ "source": [
+ "## Perform imports and define constants\n",
+ "\n",
+ "Perform required imports."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "63cb35fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a8530ff0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from ansys.aedt.core import Maxwell3d\n",
+ "from ansys.aedt.core.generic.general_methods import write_csv"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5aeedb81",
+ "metadata": {},
+ "source": [
+ "Define constants."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f48905e5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "AEDT_VERSION = \"2024.2\"\n",
+ "NUM_CORES = 4\n",
+ "NG_MODE = False # Open AEDT UI when it is launched."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b1362b25",
+ "metadata": {},
+ "source": [
+ "## Create temporary directory\n",
+ "\n",
+ "Create a temporary directory where downloaded data or\n",
+ "dumped data can be stored.\n",
+ "If you'd like to retrieve the project data for subsequent use,\n",
+ "the temporary folder name is given by ``temp_folder.name``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ad88c72e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "temp_folder = tempfile.TemporaryDirectory(suffix=\".ansys\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c13f0557",
+ "metadata": {},
+ "source": [
+ "## Launch AEDT and Maxwell 3D\n",
+ "\n",
+ "Create an instance of the ``Maxwell3d`` class named ``m3d`` by providing\n",
+ "the project and design names, the solver, and the version."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "02c2d8fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project_name = os.path.join(temp_folder.name, \"COMPUMAG2.aedt\")\n",
+ "m3d = Maxwell3d(\n",
+ " project=project_name,\n",
+ " design=\"TEAM_7_Asymmetric_Conductor\",\n",
+ " solution_type=\"EddyCurrent\",\n",
+ " version=AEDT_VERSION,\n",
+ " non_graphical=NG_MODE,\n",
+ " new_desktop=True,\n",
+ ")\n",
+ "m3d.modeler.model_units = \"mm\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5abec32e",
+ "metadata": {},
+ "source": [
+ "## Add Maxwell 3D setup\n",
+ "\n",
+ "Add a Maxwell 3D setup with frequency points at DC, 50 Hz, and 200Hz.\n",
+ "Otherwise, the default PyAEDT setup values are used. To approximate a DC field in the\n",
+ "eddy current solver, use a low frequency value. Second-order shape functions improve\n",
+ "the smoothness of the induced currents in the plate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7c9840c5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dc_freq = 0.1\n",
+ "stop_freq = 50\n",
+ "\n",
+ "setup = m3d.create_setup(name=\"Setup1\")\n",
+ "setup.props[\"Frequency\"] = \"200Hz\"\n",
+ "setup.props[\"HasSweepSetup\"] = True\n",
+ "setup.add_eddy_current_sweep(\n",
+ " range_type=\"LinearStep\",\n",
+ " start=dc_freq,\n",
+ " end=stop_freq,\n",
+ " count=stop_freq - dc_freq,\n",
+ " clear=True,\n",
+ ")\n",
+ "setup.props[\"UseHighOrderShapeFunc\"] = True\n",
+ "setup.props[\"PercentError\"] = 0.4"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b87027f0",
+ "metadata": {},
+ "source": [
+ "## Define coil dimensions\n",
+ "\n",
+ "Define coil dimensions as shown on the TEAM7 drawing of the coil."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fcdcb3aa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coil_external = 150 + 25 + 25\n",
+ "coil_internal = 150\n",
+ "coil_r1 = 25\n",
+ "coil_r2 = 50\n",
+ "coil_thk = coil_r2 - coil_r1\n",
+ "coil_height = 100\n",
+ "coil_centre = [294 - 25 - 150 / 2, 25 + 150 / 2, 19 + 30 + 100 / 2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e69c699b",
+ "metadata": {},
+ "source": [
+ "Use expressions to construct the three dimensions needed to describe the midpoints of\n",
+ "the coil."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d15c355b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dim1 = coil_internal / 2 + (coil_external - coil_internal) / 4\n",
+ "dim2 = coil_internal / 2 - coil_r1\n",
+ "dim3 = dim2 + np.sqrt(((coil_r1 + (coil_r2 - coil_r1) / 2) ** 2) / 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29d954af",
+ "metadata": {},
+ "source": [
+ "Use coordinates to draw a polyline along which to sweep the coil cross sections."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bda37e67",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "P1 = [dim1, -dim2, 0]\n",
+ "P2 = [dim1, dim2, 0]\n",
+ "P3 = [dim3, dim3, 0]\n",
+ "P4 = [dim2, dim1, 0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53dee646",
+ "metadata": {},
+ "source": [
+ "## Create coordinate system for positioning coil"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08a79532",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.modeler.create_coordinate_system(\n",
+ " origin=coil_centre, mode=\"view\", view=\"XY\", name=\"Coil_CS\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f8fd299f",
+ "metadata": {},
+ "source": [
+ "## Create polyline\n",
+ "\n",
+ "Create a polyline. One quarter of the coil is modeled by sweeping a 2D sheet along a polyline."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da216ecb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "test = m3d.modeler.create_polyline(\n",
+ " points=[P1, P2, P3, P4], segment_type=[\"Line\", \"Arc\"], name=\"Coil\"\n",
+ ")\n",
+ "test.set_crosssection_properties(type=\"Rectangle\", width=coil_thk, height=coil_height)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "424003bf",
+ "metadata": {},
+ "source": [
+ "## Duplicate and unite polyline to create full coil"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a48693d9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.modeler.duplicate_around_axis(\n",
+ " assignment=\"Coil\",\n",
+ " axis=\"Global\",\n",
+ " angle=90,\n",
+ " clones=4,\n",
+ " create_new_objects=True,\n",
+ " is_3d_comp=False,\n",
+ ")\n",
+ "m3d.modeler.unite(\"Coil, Coil_1, Coil_2\")\n",
+ "m3d.modeler.unite(\"Coil, Coil_3\")\n",
+ "m3d.modeler.fit_all()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "270c69ea",
+ "metadata": {},
+ "source": [
+ "## Assign material and if solution is allowed inside coil\n",
+ "\n",
+ "Assign the material ``Cooper`` from the Maxwell internal library to the coil and\n",
+ "allow a solution inside the coil."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a43a1d75",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.assign_material(assignment=\"Coil\", material=\"Copper\")\n",
+ "m3d.solve_inside(\"Coil\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b8b2ae3c",
+ "metadata": {},
+ "source": [
+ "## Create terminal\n",
+ "\n",
+ "Create a terminal for the coil from a cross-section that is split and one half deleted."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d68eaf41",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.modeler.section(assignment=\"Coil\", plane=\"YZ\")\n",
+ "m3d.modeler.separate_bodies(assignment=\"Coil_Section1\")\n",
+ "m3d.modeler.delete(assignment=\"Coil_Section1_Separate1\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "101c341f",
+ "metadata": {},
+ "source": [
+ "## Add variable for coil excitation\n",
+ "\n",
+ "Add a design variable for coil excitation. The NB units here are AmpereTurns."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f88eeec2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "Coil_Excitation = 2742\n",
+ "m3d[\"Coil_Excitation\"] = str(Coil_Excitation) + \"A\"\n",
+ "m3d.assign_current(assignment=\"Coil_Section1\", amplitude=\"Coil_Excitation\", solid=False)\n",
+ "m3d.modeler.set_working_coordinate_system(\"Global\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04791686",
+ "metadata": {},
+ "source": [
+ "## Add material\n",
+ "\n",
+ "Add a material named ``team3_aluminium``."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d97c3ea6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mat = m3d.materials.add_material(\"team7_aluminium\")\n",
+ "mat.conductivity = 3.526e7"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7bdfffce",
+ "metadata": {},
+ "source": [
+ "## Model aluminium plate with a hole\n",
+ "\n",
+ "Model the aluminium plate with a hole by subtracting two rectangular cuboids."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3a163645",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plate = m3d.modeler.create_box(\n",
+ " origin=[0, 0, 0], sizes=[294, 294, 19], name=\"Plate\", material=\"team7_aluminium\"\n",
+ ")\n",
+ "m3d.modeler.fit_all()\n",
+ "hole = m3d.modeler.create_box(origin=[18, 18, 0], sizes=[108, 108, 19], name=\"Hole\")\n",
+ "m3d.modeler.subtract(blank_list=\"Plate\", tool_list=[\"Hole\"], keep_originals=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d0d22f70",
+ "metadata": {},
+ "source": [
+ "## Draw background region\n",
+ "\n",
+ "Draw a background region that uses the default properties for an air region."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a8f10cc5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.modeler.create_air_region(\n",
+ " x_pos=100, y_pos=100, z_pos=100, x_neg=100, y_neg=100, z_neg=100\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7fbe5d37",
+ "metadata": {},
+ "source": [
+ "## Adjust eddy effects for plate and coil\n",
+ "\n",
+ "Adjust the eddy effects for the plate and coil by turning off displacement currents\n",
+ "for all parts. The setting for the eddy effect is ignored for the stranded conductor type\n",
+ "used in the coil."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "79fea5d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m3d.eddy_effects_on(assignment=\"Plate\")\n",
+ "m3d.eddy_effects_on(\n",
+ " assignment=[\"Coil\", \"Region\", \"Line_A1_B1mesh\", \"Line_A2_B2mesh\"],\n",
+ " enable_eddy_effects=False,\n",
+ " enable_displacement_current=False,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06941f13",
+ "metadata": {},
+ "source": [
+ "## Create expression for Z component of B in Gauss\n",
+ "\n",
+ "Create an expression for the Z component of B in Gauss using PyAEDT advanced fields calculator."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "25ff1b14",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "bz = {\n",
+ " \"name\": \"Bz\",\n",
+ " \"description\": \"Z component of B in Gauss\",\n",
+ " \"design_type\": [\"Maxwell 3D\"],\n",
+ " \"fields_type\": [\"Fields\"],\n",
+ " \"primary_sweep\": \"Distance\",\n",
+ " \"assignment\": \"\",\n",
+ " \"assignment_type\": [\"Line\"],\n",
+ " \"operations\": [\n",
+ " \"NameOfExpression('Short
+ */ + .o-tooltip--left { + position: relative; + } + + .o-tooltip--left:after { + opacity: 0; + visibility: hidden; + position: absolute; + content: attr(data-tooltip); + padding: .2em; + font-size: .8em; + left: -.2em; + background: grey; + color: white; + white-space: nowrap; + z-index: 2; + border-radius: 2px; + transform: translateX(-102%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); +} + +.o-tooltip--left:hover:after { + display: block; + opacity: 1; + visibility: visible; + transform: translateX(-100%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); + transition-delay: .5s; +} + +/* By default the copy button shouldn't show up when printing a page */ +@media print { + button.copybtn { + display: none; + } +} diff --git a/version/dev/_static/copybutton.js b/version/dev/_static/copybutton.js new file mode 100644 index 00000000..32f83eab --- /dev/null +++ b/version/dev/_static/copybutton.js @@ -0,0 +1,248 @@ +// Localization support +const messages = { + 'en': { + 'copy': 'Copy', + 'copy_to_clipboard': 'Copy to clipboard', + 'copy_success': 'Copied!', + 'copy_failure': 'Failed to copy', + }, + 'es' : { + 'copy': 'Copiar', + 'copy_to_clipboard': 'Copiar al portapapeles', + 'copy_success': '¡Copiado!', + 'copy_failure': 'Error al copiar', + }, + 'de' : { + 'copy': 'Kopieren', + 'copy_to_clipboard': 'In die Zwischenablage kopieren', + 'copy_success': 'Kopiert!', + 'copy_failure': 'Fehler beim Kopieren', + }, + 'fr' : { + 'copy': 'Copier', + 'copy_to_clipboard': 'Copier dans le presse-papier', + 'copy_success': 'Copié !', + 'copy_failure': 'Échec de la copie', + }, + 'ru': { + 'copy': 'Скопировать', + 'copy_to_clipboard': 'Скопировать в буфер', + 'copy_success': 'Скопировано!', + 'copy_failure': 'Не удалось скопировать', + }, + 'zh-CN': { + 'copy': '复制', + 'copy_to_clipboard': '复制到剪贴板', + 'copy_success': '复制成功!', + 'copy_failure': '复制失败', + }, + 'it' : { + 'copy': 'Copiare', + 'copy_to_clipboard': 'Copiato negli appunti', + 'copy_success': 'Copiato!', + 'copy_failure': 'Errore durante la copia', + } +} + +let locale = 'en' +if( document.documentElement.lang !== undefined + && messages[document.documentElement.lang] !== undefined ) { + locale = document.documentElement.lang +} + +let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT; +if (doc_url_root == '#') { + doc_url_root = ''; +} + +/** + * SVG files for our copy buttons + */ +let iconCheck = `` + +// If the user specified their own SVG use that, otherwise use the default +let iconCopy = ``; +if (!iconCopy) { + iconCopy = `` +} + +/** + * Set up copy/paste for code blocks + */ + +const runWhenDOMLoaded = cb => { + if (document.readyState != 'loading') { + cb() + } else if (document.addEventListener) { + document.addEventListener('DOMContentLoaded', cb) + } else { + document.attachEvent('onreadystatechange', function() { + if (document.readyState == 'complete') cb() + }) + } +} + +const codeCellId = index => `codecell${index}` + +// Clears selected text since ClipboardJS will select the text when copying +const clearSelection = () => { + if (window.getSelection) { + window.getSelection().removeAllRanges() + } else if (document.selection) { + document.selection.empty() + } +} + +// Changes tooltip text for a moment, then changes it back +// We want the timeout of our `success` class to be a bit shorter than the +// tooltip and icon change, so that we can hide the icon before changing back. +var timeoutIcon = 2000; +var timeoutSuccessClass = 1500; + +const temporarilyChangeTooltip = (el, oldText, newText) => { + el.setAttribute('data-tooltip', newText) + el.classList.add('success') + // Remove success a little bit sooner than we change the tooltip + // So that we can use CSS to hide the copybutton first + setTimeout(() => el.classList.remove('success'), timeoutSuccessClass) + setTimeout(() => el.setAttribute('data-tooltip', oldText), timeoutIcon) +} + +// Changes the copy button icon for two seconds, then changes it back +const temporarilyChangeIcon = (el) => { + el.innerHTML = iconCheck; + setTimeout(() => {el.innerHTML = iconCopy}, timeoutIcon) +} + +const addCopyButtonToCodeCells = () => { + // If ClipboardJS hasn't loaded, wait a bit and try again. This + // happens because we load ClipboardJS asynchronously. + if (window.ClipboardJS === undefined) { + setTimeout(addCopyButtonToCodeCells, 250) + return + } + + // Add copybuttons to all of our code cells + const COPYBUTTON_SELECTOR = 'div.highlight pre'; + const codeCells = document.querySelectorAll(COPYBUTTON_SELECTOR) + codeCells.forEach((codeCell, index) => { + const id = codeCellId(index) + codeCell.setAttribute('id', id) + + const clipboardButton = id => + `` + codeCell.insertAdjacentHTML('afterend', clipboardButton(id)) + }) + +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} + + +var copyTargetText = (trigger) => { + var target = document.querySelector(trigger.attributes['data-clipboard-target'].value); + + // get filtered text + let exclude = '.linenos'; + + let text = filterText(target, exclude); + return formatCopyText(text, '>>> ?|\\.\\.\\. ', true, true, true, true, '', '') +} + + // Initialize with a callback so we can modify the text before copy + const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText}) + + // Update UI with error/success messages + clipboard.on('success', event => { + clearSelection() + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success']) + temporarilyChangeIcon(event.trigger) + }) + + clipboard.on('error', event => { + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure']) + }) +} + +runWhenDOMLoaded(addCopyButtonToCodeCells) \ No newline at end of file diff --git a/version/dev/_static/copybutton_funcs.js b/version/dev/_static/copybutton_funcs.js new file mode 100644 index 00000000..dbe1aaad --- /dev/null +++ b/version/dev/_static/copybutton_funcs.js @@ -0,0 +1,73 @@ +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +export function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} diff --git a/version/dev/_static/css/ansys-sphinx-theme-variable.css b/version/dev/_static/css/ansys-sphinx-theme-variable.css new file mode 100644 index 00000000..71f301bc --- /dev/null +++ b/version/dev/_static/css/ansys-sphinx-theme-variable.css @@ -0,0 +1,400 @@ +/*Contains variables for colors and fonts used in the theme*/ +@import url("https://fonts.googleapis.com/css2?family=Lato:ital,wght@0,400;0,700;0,900;1,400;1,700;1,900&family=Open+Sans:ital,wght@0,400;0,600;1,400;1,600&display=swap"); + +@font-face { + font-family: "Source Sans Pro Light"; + src: url(../fonts/SourceSansPro-Light.ttf); +} + +@font-face { + font-family: "Source Sans Pro"; + src: url(../fonts/SourceSansPro-Regular.ttf); +} + +:root { + /** Ansys specific changes to the theme */ + + /** + * Ansys Font family + * + * These are adapted from https://systemfontstack.com/ + */ + --pst-font-family-base-system: -apple-system, BlinkMacSystemFont, Segoe UI, + "Helvetica Neue", Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji, + Segoe UI Symbol; + --pst-font-family-monospace-system: "SFMono-Regular", Menlo, Consolas, Monaco, + Liberation Mono, Lucida Console, monospace; + + --pst-font-family-base: "Source Sans Pro", sans-serif, + var(--pst-font-family-base-system); + --pst-font-family-heading: "Source Sans Pro", sans-serif, + var(--pst-font-family-base-system); + --pst-font-family-monospace: monospace, Courier, + var(--pst-font-family-monospace-system); + + /** + * Ansys compatible colors + * + * Colors are defined in rgb string way, "red, green, blue" + */ + --ansysGold: rgb(255, 183, 27); /* #FFB71B */ + --ansysBronze: rgb(200, 146, 17); /* #C89211 */ + --pythonBlue: rgb(57, 114, 161); /* #3972a1 */ + --pst-font-size-h1: 36px; + --pst-font-size-h2: 32px; + --pst-font-size-h3: 28px; + --pst-font-size-h4: 20px; + --pst-font-size-h5: 14px; + --pst-font-size-h6: 11px; + --ast-global-line-height: 24px; + --bs-nav-link-font-size: 14px; + --bs-navbar-color: var(--bs-ast-navbar-color); + --ast-font-sidebar-header: var(--pst-font-size-h5); + /** + * table font sizes + */ + --pst-table-font-size: 14px; + --pst-table-header-font-size: 12px; + + /** + * sphinx design font sizes + */ + + --ast-sphinx-design-font-size: 14px; + --ast-sphinx-design-font-family: "Open Sans", sans-serif; + --ast-sphinx-design-border-radius: 4px; + + /** +* admonitions +*/ + --ast-admonitions-font-size: 14px; + --ast-admonitions-padding: 8px 16px; + --ast-admonitions-border-radius: 8px; + --ast-admonitions-icon-size: 15px; + --ast-admonition-icon-height: 24px; + --ast-admonition-icon-width: 24px; + --ast-admonition-icon-margin-left: 8px; +} + +html[data-theme="light"] { + /** + * main colors + */ + --ast-color-text: #353535; + --ast-color-active-text: #353535; + --ast-color-hover-text: #353535; + --pst-color-background: #f7f7f7; + --pst-color-primary: #353535; + --pst-color-secondary: #f2f2f2; + --pst-color-success: rgb(40, 167, 69); + --pst-color-text-base: rgb(0, 0, 0); + --pst-color-text-muted: #353535; + --pst-color-border: #686868; + --pst-color-shadow: rgb(216, 216, 216); + --pst-color-info: var(--pst-color-link); + --pst-color-link-hover: #686868; + + /** + * Navigation colors + */ + --pst-color-on-background: var( + --pst-color-background + ); /* important tag from pydata-sphinx-theme */ + --ast-navbar-color: #686868; + --ast-navbar-hover-color: var(--ast-color-hover-text); + --ast-navbar-active-color: var(--ast-color-active-text); + --ast-navbar-active-border-color: #000000; + --ast-ring-shadow-focused: 0px 0px 0px 2px #ffffff, 0px 0px 0px 4px #1a78c2; + + /** + * sidebar colors + */ + --ast-sidebar-primary-text: var(--ast-color-text); + --ast-sidebar-hover-background: #ececec; + --ast-sidebar-active-background: #d9d9d9; + + /** + * depth colors + */ + /* --pst-color-on-background: rgb(0, 0, 0); */ + --pst-color-on-surface: #f2f2f2; + + /** + * table + */ + --ast-color-table-background: #ffffff; + --ast-color-enabled-table-text: var(--ast-color-text); + --ast-color-table-row-hover-bg: #ececec; + --ast-color-table-active-bg: #e9f4fe; + --ast-color-table-header-text: #686868; + --ast-color-table-cell-text: var(--ast-color-text); + --ast-table-outer-border: #ececec; + --ast-color-table-inner-border: #ececec; + + --pst-color-panel-background: var(--pst-color-on-background); + + /** + * layout + */ + + --ast-color-link: #1e6ddc; + --ast-color-link-hover: #1856af; + --ast-color-link-active: #104188; + --ast-color-link-visited: #9a33cb; + --ast-color-link-visited-hover: #7f29a2; + --ast-color-inline-code: var( + --pst-color-text-muted + ); /* inline code color for docutils (_base.scss)*/ + --pst-color-target: rgb(255, 255, 255); + + /** + * color for sphinx-gallery-code output + */ + --pst-color-codecell: #fafae2; + --pst-color-codeout: var(--pst-color-inline-code); + --pst-color-sig: #0965c8; + --pst-color-code-s1: #b35000; + --pst-color-code-c1: #095d0a; + + --ast-sphinx-gallery-download-background: #1a1a1a; + --ast-sphinx-gallery-download-background-hover: #353535; + --ast-sphinx-gallery-download-text: #fdfdfd; + + /** + * sphinx design + */ + --sd-color-primary: var(--pst-color-text-base); + --ast-color-enable-card-background: #ffffff; + --ast-color-enable-border: #d9d9d9; + --ast-color-hover-card-background: #ececec; + --ast-dropdown-border-color: #d9d9d9; + --ast-dropdown-border-color-hover: #8e8e8e; + + --ast-color-sphinx-design-primary: #353535; + --ast-color-sphinx-design-background: #ffffff; + --sd-color-primary: #141414; + --sd-color-primary-highlight: var(--ast-color-sphinx-design-primary); + --sd-color-primary-text: var(--ast-color-sphinx-design-background); + --sd-color-secondary: var(--ast-color-sphinx-design-background); + --sd-color-secondary-text: #141414; + --sd-color-secondary-highlight: var(--ast-color-hover-card-background); + --sd-color-secondary-bg: var(--ast-color-sphinx-design-background); + --ast-sd-bg-secondary-hover: var(--ast-color-hover-card-background); + --ast-background-tab-focus: #d9d9d9; + --ast-background-tab-hover: #ececec; + --ast-tab-border-color: #d9d9d9; + --ast-tab-border-color-hover: #8e8e8e; + --ast-tab-border-color-active: #000000; + --ast-dropdown-text-color: #686868; + --ast-box-shadow-active: 0px 1px 2px 0px rgba(0, 0, 0, 0.08), + 0px 2px 4px 0px rgba(0, 0, 0, 0.12); + --ast-box-shadow-hover: 0px 1px 2px 0px rgba(0, 0, 0, 0.08), + 0px 4px 8px 2px rgba(0, 0, 0, 0.12); + /** + * search hide match + */ + --pst-color-search-match: #91969b; + + /** + * admonitions + */ + --ast-admonition-neutral-icon: #353535; + --ast-admonition-neutral-border: #686868; + --ast-admonition-info-icon: #1a78c2; + --ast-admonition-info-border: #1a78c2; + --ast-admonition-success-icon: #006600; + --ast-admonition-success-border: #008000; + --ast-admonition-warning-icon: #caad2a; + --ast-admonition-warning-border: #fdd835; + --ast-admonition-danger-icon: #b72e2a; + --ast-admonition-danger-border: #e53935; + --ast-admonitions-color: var(--ast-color-text); + + /** + * search bars + */ + --ast-search-bar-enable-background: #ffffff; + --ast-search-bar-enable-border: #d9d9d9; + --ast-search-bar-enable-text: #686868; + --ast-suggestion-header-background: #d9d9d9; + --ast-catagory-header-text: #353535; + --ast-catagory-suggestion-text: #8e8e8e; + --ast-suggestion-text-color: #000000; + + /** + * dropdown header + */ + --ast-dropdown-header-border: #d9d9d9; +} + +html[data-theme="dark"] { + /** + * main colors + */ + --ast-color-text: #ececec; + --ast-color-active-text: #d5d5d5; + --ast-color-hover-text: #d5d5d5; + --pst-color-primary: #ececec; + --pst-color-secondary: #353535; + --pst-color-success: rgb(72, 135, 87); + --pst-color-text-base: rgb(201, 209, 217); + --pst-color-text-muted: rgb(192, 192, 192); + --pst-color-border: rgb(192, 192, 192); + --pst-color-shadow: rgb(104, 102, 102); + --pst-color-background: #1a1a1a; + --pst-color-surface: rgb(41, 41, 41); + --pst-color-on-surface: rgb(55, 55, 55); + --pst-color-info: var(--pst-color-secondary); + --pst-color-link-hover: #b3b3b3; + + /** + * extensions + */ + + --pst-color-panel-background: var(--pst-color-on-background); + + /** + * Navigation colors + */ + + --pst-color-on-background: var( + --pst-color-background + ); /* important tag from pydata-sphinx-theme */ + --ast-navbar-color: #8e8e8e; + --ast-navbar-hover-color: var(--ast-color-hover-text); + --ast-navbar-active-color: var(--ast-color-active-text); + --ast-navbar-active-border-color: #ffffff; + --ast-nav-link-color: var(--ast-navbar-color); + --ast-ring-shadow-focused: 0px 0px 0px 2px #282828, 0px 0px 0px 4px #4dabf5; + + /** + * sidebar colors + */ + --ast-sidebar-primary-text: var(--ast-color-text); + --ast-sidebar-hover-background: #3d3d3d; + --ast-sidebar-active-background: #2d2d2d; + --ast-color-inline-code: var( + --pst-color-text-muted + ); /* inline code color for docutils (_base.scss)*/ + + /** + * layout + */ + + --ast-color-link: #1e6ddc; + --ast-color-link-hover: #1856af; + --ast-color-link-active: #579ce5; + --ast-color-link-visited: #c58ac5; + --ast-color-link-visited-hover: #a96ba9; + --pst-color-target: rgb(71, 39, 0); + + /** + * color for sphinx-gallery-code output + */ + --pst-color-codecell: #353535; + --pst-color-codeout: #f2f4f6; + --pst-color-sig: #d6ab1e; + --pst-color-code-s1: #d79a60; + --pst-color-code-c1: #8fb842; + + --ast-sphinx-gallery-download-background: #ffffff; + --ast-sphinx-gallery-download-background-hover: #ececec; + --ast-sphinx-gallery-download-text: #1a1a1a; + + /** + * table hovering + */ + --ast-color-table-background: #353535; + --ast-color-enabled-table-text: #ececec; + --ast-color-table-row-hover-bg: #3d3d3d; + --ast-color-table-header-text: #d3d3d3; + --ast-color-table-cell-text: #ececec; + --ast-color-table-active-bg: #3d3d3d; + --ast-table-outer-border: #d3d3d3; + --ast-color-table-inner-border: #d3d3d3; + + /** + * search hide match + */ + --pst-color-search-match: var(--pst-color-primary); + + /** + * sphinx design + */ + + --sd-color-primary: var(--pst-color-text-base); + --ast-color-enable-card-background: #282828; + --ast-color-enable-border: #e5e5e5; + --ast-color-hover-card-background: #3d3d3d; + --ast-dropdown-border-color: #3d3d3d; + --ast-dropdown-border-color-hover: #8e8e8e; + + --ast-color-sphinx-design-primary: #ececec; + --ast-color-sphinx-design-background: #282828; + --sd-color-primary: #d5d5d5; + --sd-color-primary-highlight: var(--ast-color-sphinx-design-primary); + --sd-color-primary-text: var(--ast-color-sphinx-design-background); + --sd-color-secondary: var(--ast-color-sphinx-design-background); + --sd-color-secondary-text: #d5d5d5; + --sd-color-secondary-highlight: var(--ast-color-hover-card-background); + --sd-color-secondary-bg: var(--ast-color-sphinx-design-background); + --ast-sd-bg-secondary-hover: var(--ast-color-hover-card-background); + --ast-background-tab-focus: #2d2d2d; + --ast-background-tab-hover: #3d3d3d; + --ast-tab-border-color: #e5e5e5; + --ast-tab-border-color-hover: #8e8e8e; + --ast-tab-border-color-active: #ffffff; + --ast-dropdown-text-color: #e5e5e5; + --ast-box-shadow-active: 0px 1px 2px 0px rgba(0, 0, 0, 0.4), + 0px 2px 4px 0px rgba(0, 0, 0, 0.48); + --ast-box-shadow-hover: 0px 1px 2px 0px rgba(0, 0, 0, 0.4), + 0px 4px 8px 2px rgba(0, 0, 0, 0.48); + + /** +* admonitions +*/ + --ast-admonition-neutral-icon: #ececec; + --ast-admonition-neutral-border: #8e8e8e; + --ast-admonition-info-icon: #1a78c2; + --ast-admonition-info-border: #1856af; + --ast-admonition-success-icon: #006600; + --ast-admonition-success-border: #147914; + --ast-admonition-warning-icon: #caad2a; + --ast-admonition-warning-border: #bba12e; + --ast-admonition-danger-icon: #b72e2a; + --ast-admonition-danger-border: #b12422; + --ast-admonitions-color: var(--ast-color-text); + + /** + * search bars + */ + --ast-search-bar-enable-background: #2d2d2d; + --ast-search-bar-enable-border: #3d3d3d; + --ast-search-bar-enable-text: #d3d3d3; + --ast-suggestion-header-background: #3d3d3d; + --ast-catagory-header-text: #ececec; + --ast-catagory-suggestion-text: #686868; + --ast-suggestion-text-color: #ffffff; + + /** + * dropdown header + */ + --ast-dropdown-header-border: #3d3d3d; +} + +/** +* font sizes +* body and content +*/ + +body { + font-family: "Open Sans", sans-serif; + line-height: var(--ast-global-line-height); + font-size: 14px; + color: var(--ast-color-text); +} + +h1, +h2 { + color: var(--pst-color-text-base); +} diff --git a/version/dev/_static/css/ansys_sphinx_theme.css b/version/dev/_static/css/ansys_sphinx_theme.css new file mode 100644 index 00000000..54acbf81 --- /dev/null +++ b/version/dev/_static/css/ansys_sphinx_theme.css @@ -0,0 +1,45 @@ +/* Provided by the Sphinx base theme template at build time */ + +@import "../basic.css"; +@import "../sg_gallery.css"; +@import "ansys-sphinx-theme-variables.css"; +@import "pydata-sphinx-theme-custom.css"; +@import "breadcrumbs.css"; +@import "meilisearch.css"; +@import "sphinx-design.css"; +@import "table-custom.css"; +@import "sphinx-gallery.css"; + +/* +* Code cell +*/ +.xref.std.std-ref { + color: var(--pst-color-inline-code); + font-family: "Inconsolata"; + font-weight: normal; + font-style: italic; + padding: 0.1rem 0.25rem; + padding-top: 0.1rem; + padding-right: 0.25rem; + padding-bottom: 0.1rem; + padding-left: 0.25rem; + font-size: 90%; + background-color: var(--pst-color-on-surface); + border: 1px solid var(--pst-color-border); + border-radius: 0.25rem; +} + +/* Reduce empty-space around Notes and Examples headings */ +p.rubric { + margin-top: 0.75em; + margin-bottom: 0.75em; +} + +/* +* Autosummary +*/ + +.autosummary tr:nth-child(odd), +.autosummary tr:nth-child(even) { + background-color: var(--pst-color-background); +} diff --git a/version/dev/_static/css/breadcrumbs.css b/version/dev/_static/css/breadcrumbs.css new file mode 100644 index 00000000..19c3eab0 --- /dev/null +++ b/version/dev/_static/css/breadcrumbs.css @@ -0,0 +1,110 @@ +/* Provided by the Sphinx base theme template at build time, +styles exclusively for the ansys-sphinx-theme classes. */ + +@import "ansys-sphinx-theme-variable.css"; + +/** +* Breadcrumbs +*/ + +ul.bd-breadcrumbs li.breadcrumb-item { + padding: 0px; + font-size: 12px; + display: flex; +} + +ul.bd-breadcrumbs li.breadcrumb-item:hover { + text-decoration: underline; + font-size: 12px; +} + +ul.bd-breadcrumbs li.breadcrumb-item a { + color: var(--ast-navbar-color); + font-size: 12px; +} + +ul.bd-breadcrumbs li.breadcrumb-item a:hover { + text-decoration: underline; +} + +ul.bd-breadcrumbs li.breadcrumb-item a:active { + color: var(--ast-color-text); +} + +.breadcrumb-item.active { + color: var(--ast-color-text); +} + +/** +* Version warning announcement +*/ + +#announcement_msg { + display: flex; + justify-content: center; + position: relative; + width: 100%; + padding: 0.5rem 12.5%; + text-align: center; +} + +#announcement_msg :after { + position: absolute; + width: 100%; + height: 100%; + left: 0; + top: 0; + background-color: rgb(223, 95, 114); + opacity: 0.2; + content: ""; + z-index: -1; +} + +#announcement_msg :empty { + display: none; +} + +#announcement_msg p { + font-weight: bold; + margin: auto; + color: black; +} + +html[data-theme="dark"] #announcement_msg :after { + background-color: lightpink; + opacity: 0.5; +} + +#announcement_msg a { + color: #1e6ddc; +} + +.sidebar-cheatsheets { + text-align: center; +} + +.sidebar-cheatsheets h4 { + font-weight: var(--pst-sidebar-header-font-weight) !important; + font-size: var(--pst-sidebar-header-font-size) !important; + margin-bottom: 0.5rem; +} + +.sidebar-cheatsheets a { + display: inline-flex; + border: 0.5px solid var(--pst-color-border); + padding: 0.25rem; + max-width: 80%; +} + +.sidebar-cheatsheets a:hover { + background-color: var(--pst-color-border); + color: var(--pst-color-text-base); +} + +.sidebar-cheatsheets img { + padding: 0rem; +} + +.bd-sidebar-primary { + padding: 0.5rem; +} diff --git a/version/dev/_static/css/custom.css b/version/dev/_static/css/custom.css new file mode 100644 index 00000000..9ce55e58 --- /dev/null +++ b/version/dev/_static/css/custom.css @@ -0,0 +1,41 @@ +@import "../ansys-sphinx-theme.css"; + +.col-md-3 { + flex: 0 0 30%; + max-width: 30%; +} +.col-xl-7 { + flex: 0 0 53.33333%; + max-width: 53.33333%; + } + +.bd-toc { + padding-top: 5em; +} + + +nav.bd-links ul li.toctree-l1 > a { + font-size: .90rem; +} + +nav.bd-links ul li.toctree-l2 > a { + font-size: .85rem; + text-indent: 1px; +} +nav.bd-links ul li.toctree-l3 > a { + font-size: .85rem; + text-indent: 2px; +} + +nav.bd-links ul li.toctree-l4 > a { + font-size: .8rem; + text-indent: 3px; +} + +div.cell_output { + text-align: left !important; +} + +div.nbinput.container div.input_area, div.nboutput.container div.output_area { + display: block; +} diff --git a/version/dev/_static/css/highlight.css b/version/dev/_static/css/highlight.css new file mode 100644 index 00000000..6d41658d --- /dev/null +++ b/version/dev/_static/css/highlight.css @@ -0,0 +1,83 @@ +/* + * The 'friendly' style from Pygments CSS style. Directly taken from: + * https://github.com/richleland/pygments-css + * License is 'UNLICENSE.txt'. + */ + +@import "../../ansys-sphinx-theme.css"; + +/* Do not show number cells */ +.nbinput .prompt, +.nboutput .prompt { + display: none; +} + +.highlight .hll { background-color: #ffffcc !important; } +.highlight { font-size: 1rem; background: #f0f0f0 !important; } +.highlight .c { color: #60a0b0 !important; font-style: italic !important; } /* Comment */ +.highlight .err { border: 1px solid #FF0000 !important; } /* Error */ +.highlight .k { color: #007020 !important; font-weight: bold !important; } /* Keyword */ +.highlight .o { color: #666666 !important; } /* Operator */ +.highlight .ch { color: #60a0b0 !important; font-style: italic !important; } /* Comment.Hashbang */ +.highlight .cm { color: #60a0b0 !important; font-style: italic !important; } /* Comment.Multiline */ +.highlight .cp { color: #007020 !important; } /* Comment.Preproc */ +.highlight .cpf { color: #60a0b0 !important; font-style: italic !important; } /* Comment.PreprocFile */ +.highlight .c1 { color: #60a0b0 !important; font-style: italic !important; } /* Comment.Single */ +.highlight .cs { color: #60a0b0 !important; background-color: #fff0f0 !important; } /* Comment.Special */ +.highlight .gd { color: #A00000 !important; } /* Generic.Deleted */ +.highlight .ge { font-style: italic !important; } /* Generic.Emph */ +.highlight .gr { color: #FF0000 !important; } /* Generic.Error */ +.highlight .gh { color: #000080 !important; font-weight: bold !important; } /* Generic.Heading */ +.highlight .gi { color: #00A000 !important; } /* Generic.Inserted */ +.highlight .go { color: #888888 !important; } /* Generic.Output */ +.highlight .gp { color: #c65d09 !important; font-weight: bold !important; } /* Generic.Prompt */ +.highlight .gs { font-weight: bold !important; } /* Generic.Strong */ +.highlight .gu { color: #800080 !important; font-weight: bold !important; } /* Generic.Subheading */ +.highlight .gt { color: #0044DD !important; } /* Generic.Traceback */ +.highlight .kc { color: #007020 !important; font-weight: bold !important; } /* Keyword.Constant */ +.highlight .kd { color: #007020 !important; font-weight: bold !important; } /* Keyword.Declaration */ +.highlight .kn { color: #007020 !important; font-weight: bold !important; } /* Keyword.Namespace */ +.highlight .kp { color: #007020 !important; } /* Keyword.Pseudo */ +.highlight .kr { color: #007020 !important; font-weight: bold !important; } /* Keyword.Reserved */ +.highlight .kt { color: #902000 !important; } /* Keyword.Type */ +.highlight .m { color: #40a070 !important; } /* Literal.Number */ +.highlight .s { color: #4070a0 !important; } /* Literal.String */ +.highlight .na { color: #4070a0 !important; } /* Name.Attribute */ +.highlight .nb { color: #007020 !important; } /* Name.Builtin */ +.highlight .nc { color: #0e84b5 !important; font-weight: bold !important; } /* Name.Class */ +.highlight .no { color: #60add5 !important; } /* Name.Constant */ +.highlight .nd { color: #555555 !important; font-weight: bold !important; } /* Name.Decorator */ +.highlight .ni { color: #d55537 !important; font-weight: bold !important; } /* Name.Entity */ +.highlight .ne { color: #007020 !important; } /* Name.Exception */ +.highlight .nf { color: #06287e !important; } /* Name.Function */ +.highlight .nl { color: #002070 !important; font-weight: bold !important; } /* Name.Label */ +.highlight .nn { color: #0e84b5 !important; font-weight: bold !important; } /* Name.Namespace */ +.highlight .nt { color: #062873 !important; font-weight: bold !important; } /* Name.Tag */ +.highlight .nv { color: #bb60d5 !important; } /* Name.Variable */ +.highlight .ow { color: #007020 !important; font-weight: bold !important; } /* Operator.Word */ +.highlight .w { color: #bbbbbb !important; } /* Text.Whitespace */ +.highlight .mb { color: #40a070 !important; } /* Literal.Number.Bin */ +.highlight .mf { color: #40a070 !important; } /* Literal.Number.Float */ +.highlight .mh { color: #40a070 !important; } /* Literal.Number.Hex */ +.highlight .mi { color: #40a070 !important; } /* Literal.Number.Integer */ +.highlight .mo { color: #40a070 !important; } /* Literal.Number.Oct */ +.highlight .sa { color: #4070a0 !important; } /* Literal.String.Affix */ +.highlight .sb { color: #4070a0 !important; } /* Literal.String.Backtick */ +.highlight .sc { color: #4070a0 !important; } /* Literal.String.Char */ +.highlight .dl { color: #4070a0 !important; } /* Literal.String.Delimiter */ +.highlight .sd { color: #4070a0 !important; font-style: italic !important; } /* Literal.String.Doc */ +.highlight .s2 { color: #4070a0 !important; } /* Literal.String.Double */ +.highlight .se { color: #4070a0 !important; font-weight: bold !important; } /* Literal.String.Escape */ +.highlight .sh { color: #4070a0 !important; } /* Literal.String.Heredoc */ +.highlight .si { color: #70a0d0 !important; font-style: italic !important; } /* Literal.String.Interpol */ +.highlight .sx { color: #c65d09 !important; } /* Literal.String.Other */ +.highlight .sr { color: #235388 !important; } /* Literal.String.Regex */ +.highlight .s1 { color: #4070a0 !important; } /* Literal.String.Single */ +.highlight .ss { color: #517918 !important; } /* Literal.String.Symbol */ +.highlight .bp { color: #007020 !important; } /* Name.Builtin.Pseudo */ +.highlight .fm { color: #06287e !important; } /* Name.Function.Magic */ +.highlight .vc { color: #bb60d5 !important; } /* Name.Variable.Class */ +.highlight .vg { color: #bb60d5 !important; } /* Name.Variable.Global */ +.highlight .vi { color: #bb60d5 !important; } /* Name.Variable.Instance */ +.highlight .vm { color: #bb60d5 !important; } /* Name.Variable.Magic */ +.highlight .il { color: #40a070 !important; } /* Literal.Number.Integer.Long */ diff --git a/version/dev/_static/css/meilisearch.css b/version/dev/_static/css/meilisearch.css new file mode 100644 index 00000000..fdb6b118 --- /dev/null +++ b/version/dev/_static/css/meilisearch.css @@ -0,0 +1,205 @@ +@import "https://cdn.jsdelivr.net/npm/docs-searchbar.js@latest/dist/cdn/docs-searchbar.min.css"; +@import "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css"; + +div[data-ds-theme] .searchbox { + overflow-y: scroll; + margin: auto; +} + +.docs-searchbar-suggestion--category-header { + background-color: var(--ast-suggestion-header-background); + border-radius: 4px; + text-align: left; + color: var(--ast-catagory-header-text) !important; + width: 680px; + padding: 4px; +} + +.dsb-suggestions { + width: 100%; + max-width: 140%; +} + +div[data-ds-theme] .meilisearch-autocomplete .dsb-dropdown-menu { + max-width: 1200px; + min-width: 800px; + width: 800px; +} +div[data-ds-theme] .meilisearch-autocomplete .docs-searchbar-suggestion { + width: 100%; +} + +div[data-ds-theme] .searchbox input { + height: 32px; + border-radius: 8px; + font-size: 18px; + font-family: "Open Sans", sans-serif; + box-shadow: 0px 0px 8px darkgrey; +} + +.docs-searchbar-footer { + display: none; +} + +.docs-searchbar-footer { + display: none; +} + +[class*="docs-searchbar-suggestion"] { + text-decoration: none; +} + +.docs-searchbar-suggestion--highlight { + box-shadow: none !important; +} + +div[data-ds-theme] .meilisearch-autocomplete { + text-align: center; + color: var(--pst-color-text-base); +} + +.form-control:focus, +.form-control:focus-visible, +.form-control { + background-color: var(--ast-search-bar-enable-background); + color: var(--ast-search-bar-enable-text); + font-size: 14px; + outline-color: var(--ast-search-bar-enable-border); + border: 0.5px solid var(--ast-search-bar-enable-border); + width: 670px; + max-width: 200%; + height: 40px; + margin-left: 5px; +} + +.search-button__wrapper.show input, +.search-button__wrapper.show svg { + font-size: 14px; +} + +.bd-search .search-button__kbd-shortcut { + background-color: var(--ast-search-bar-enable-background) !important; + box-shadow: none !important; + height: 40px; + display: flex; + flex-wrap: wrap; + align-content: center; +} + +.index-select { + color: var(--ast-search-bar-enable-text); + background: var(--ast-search-bar-enable-background); + height: 40px; + font-size: 14px; + font-family: "Open Sans", sans-serif; + border: 0.5px solid var(--ast-search-bar-enable-border); + border-radius: 4px; + box-shadow: none; + padding: 0px 8px; + margin-left: 2px; +} +:focus-visible { + outline: none; +} + +div[data-ds-theme] + .meilisearch-autocomplete + .dsb-dropdown-menu + [class^="dsb-dataset-"] { + position: relative; + border: 1px solid #d9d9d9; + background: var(--ast-search-bar-enable-background); + border-radius: 4px; + padding: 0 8px 8px; +} +div[data-ds-theme] .meilisearch-autocomplete .dsb-dropdown-menu { + max-height: 500px !important; + border: 1px solid #ccc; + left: -30px; + overflow-y: auto; +} + +div[data-ds-theme] .meilisearch-autocomplete .docs-searchbar-suggestion { + background: var(--ast-search-bar-enable-background); +} + +div[data-ds-theme] + .meilisearch-autocomplete + .docs-searchbar-suggestion--highlight { + color: var(--ast-suggestion-text-color) !important; + font-weight: 900; + background: transparent; + padding: 0 0.05em; +} + +.meilisearch-autocomplete .docs-searchbar-suggestion--text { + color: var(--ast-catagory-suggestion-text); + font-size: 12px; + line-height: var(--ast-global-line-height); +} + +div[data-ds-theme] + .meilisearch-autocomplete + .docs-searchbar-suggestion--subcategory-column { + width: None; + text-align: left; +} + +.meilisearch-autocomplete .docs-searchbar-suggestion--category-header { + width: 100%; + padding: 4px 8px; +} + +div[data-ds-theme] + .meilisearch-autocomplete + .docs-searchbar-suggestion--content { + display: block; +} + +div[data-ds-theme] .meilisearch-autocomplete .docs-searchbar-suggestion--title { + margin-bottom: 4px; + color: var(--ast-search-bar-enable-text); + font-size: 0.9em; + font-weight: 700; + width: 100%; +} + +/** +* Styling the scrollbar +*/ +div[data-ds-theme] + .meilisearch-autocomplete + .dsb-dropdown-menu::-webkit-scrollbar { + width: 0.5rem; + height: 0.5rem; +} + +div[data-ds-theme] + .meilisearch-autocomplete + .dsb-dropdown-menu::-webkit-scrollbar-thumb { + background: var(--ast-search-bar-enable-background); + border-radius: inherit; +} + +div[data-ds-theme] + .meilisearch-autocomplete + .dsb-dropdown-menu::-webkit-scrollbar-track { + background: var(--ast-search-bar-enable-background); +} + +.bd-search { + gap: 8px; + background-color: var(--ast-search-bar-enable-background); + border: 0px solid var(--ast-search-bar-enable-border); + margin-bottom: 300px; +} +#search-icon { + font-size: 24px; + width: 24px; + height: 24px; + color: var(--ast-search-bar-enable-text); +} + +.form-control:focus { + box-shadow: none; +} diff --git a/version/dev/_static/css/pydata-sphinx-theme-custom.css b/version/dev/_static/css/pydata-sphinx-theme-custom.css new file mode 100644 index 00000000..f966e2ab --- /dev/null +++ b/version/dev/_static/css/pydata-sphinx-theme-custom.css @@ -0,0 +1,722 @@ +/* Changes associated with the Ansys Sphinx Theme */ +/* for pydata-sphinx-theme */ +@import "../styles/pydata-sphinx-theme.css"; +@import "ansys-sphinx-theme-variable.css"; + +/* +* +* _secondary sidebar and primary sidebars +* _sidebar-primary.scss +* +*/ +.bd-sidebar-primary, +.bd-sidebar-secondary { + max-height: calc(100vh - var(--pst-header-height) - 1vh); + line-height: var(--ast-global-line-height); + border: none; + overflow: hidden; +} + +.sidebar-secondary-item { + border: none; +} + +nav.bd-links p.bd-links__title, +nav.bd-links p.caption { + font-size: var(--ast-font-sidebar-header); + color: var(--ast-sidebar-primary-text); +} + +nav.bd-links li > a { + font-size: var(--ast-font-sidebar-header); + color: var(--ast-sidebar-primary-text); + text-decoration: none; + line-height: var(--ast-global-line-height); + padding: 4px 24px; +} + +nav.bd-links li > a:hover { + color: var(--ast-sidebar-primary-text); + background: var(--ast-sidebar-hover-background); + box-shadow: 1px 1px 2px 0px var(--ast-sidebar-active-background); + border-radius: 4px; + text-decoration: none; +} + +nav.bd-links li > a.active, +nav.bd-links li > a.current { + color: var(--ast-color-text); + background: var(--ast-sidebar-active-background); + text-decoration: none; + box-shadow: 1px 1px 2px 0px var(--ast-sidebar-active-background); + border-radius: 4px; + font-weight: bold; +} + +/** +* sidebar primary with children +*/ + +.bd-sidebar-primary li.has-children .caption, +.bd-sidebar-primary li.has-children > .reference { + padding: 4px 32px; +} + +nav.bd-links .current > a { + color: var(--ast-color-text); + background: var(--ast-sidebar-active-background); + text-decoration: none; + box-shadow: 1px 1px 2px 0px var(--ast-sidebar-active-background); + border-radius: 4px; + font-weight: bold; +} +/** +* secondary sidebar +* _toc-inpage.scss +*/ +.toc-entry a.nav-link { + color: var(--ast-sidebar-primary-text); + line-height: var(--ast-global-line-height); +} + +.toc-entry a.nav-link.active, +.toc-entry a.nav-link.current { + color: var(--ast-color-link); + text-decoration: none; + box-shadow: none; +} + +.toc-entry a.nav-link.active:hover, +.toc-entry a.nav-link.current:hover { + color: var(--ast-color-link-hover); + text-decoration: none; + box-shadow: none; + font-weight: bold; +} + +.toc-h2 { + font-size: 14px; + padding: 0.05em; +} + +.toc-h3 { + font-size: 14px; +} + +.toc-h4 { + font-size: 14px; +} + +.toc-entry a.nav-link:hover { + color: var(--ast-color-link-hover); + text-decoration: none; +} + +/** +* _base.scss related changes +*/ + +.editthispage a { + color: var(--pst-color-text-base); +} + +/** +* +* Dropdown button +* _header.scss +* +*/ + +.bd-header ul.navbar-nav > li.nav-item > .nav-link { + color: var(--ast-navbar-color); + font-weight: 600; +} + +.bd-header ul.navbar-nav > li.nav-item > .nav-link:hover::before { + color: var(--ast-navbar-hover-color); + border-bottom: none; + filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.08)); +} + +.bd-header ul.navbar-nav > li.nav-item > .nav-link:hover { + color: var(--ast-navbar-hover-color); + border-color: var(--ast-navbar-hover-color); + filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.08)); +} + +.bd-header ul.navbar-nav > li.nav-item > .nav-link:active { + color: var(--ast-navbar-active-color); + border-color: var(--ast-navbar-active-border-color); + border-width: 2px; + filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.12)); +} + +.bd-header ul.navbar-nav > li.nav-item.current > .nav-link::before, +.bd-header ul.navbar-nav > li.nav-item.current > .nav-link::after { + color: var(--ast-navbar-active-color); + border-bottom: 2px solid var(--ast-navbar-active-border-color); +} + +.bd-header ul.navbar-nav > li.nav-item > .nav-link:focus-visible { + color: var(--ast-navbar-color); + box-shadow: var(--ast-ring-shadow-focused); + outline: none; + outline-offset: 0px; +} + +html .pst-navbar-icon { + color: var(--ast-navbar-color); +} + +html .pst-navbar-icon:hover { + color: var(--ast-navbar-hover-color); + border-color: var(--ast-navbar-hover-color); + filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.08)); +} + +a.nav-link.pst-navbar-icon { + color: var(--ast-navbar-color); + font-weight: bold; +} + +a.nav-link.pst-navbar-icon:hover { + color: var(--ast-navbar-hover-color); + border-color: var(--ast-navbar-hover-color); + filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.08)); + font-weight: bold; +} + +a.nav-link.pst-navbar-icon:active { + color: var(--ast-navbar-active-color); + border-color: var(--ast-navbar-active-border-color); + font-weight: bold; +} + +ul.navbar-icon-links { + column-gap: 10px; +} + +.bd-header .navbar-header-items__center, +.bd-header .navbar-header-items__end { + column-gap: 10px; +} + +/* +* dropdown button after 5 sections +*/ + +.dropdown-item:hover { + font-weight: bold; + background-color: transparent; +} + +/** +* _search.scss +* Search bar +*/ + +.search-button-field { + border-color: var(--ast-navbar-active-border-color); + font-size: var(--ast-nav-link-font-size); + background-color: transparent; + color: var(--ast-navbar-color); +} + +.search-button-field:hover { + border-color: var(--ast-navbar-active-border-color); + color: var(--ast-navbar-hover-color); + font-weight: bold; + box-shadow: 0 1px 2px rgba(0, 0, 0, 0.08); +} + +/** +* +* Side column size (first and second column from left) +* +*/ + +.col-md-3 { + flex: 0 0 20%; + max-width: 20%; +} + +a.headerlink { + color: #222; +} + +@media (min-width: 1200px) { + .container, + .container-lg, + .container-md, + .container-sm, + .container-xl { + max-width: 1200px; + } +} + +@media (min-width: 1600px) { + .container, + .container-lg, + .container-md, + .container-sm, + .container-xl { + max-width: 1600px; + } +} + +/** +* +* Navigation column (according to side column) +* _header.scss +* +*/ +.bd-header .navbar-header-items__start { + width: fit-content; + padding-right: 3rem; +} +/** +* header logo +*/ + +.bd-main .bd-content { + display: flex; + height: 100%; + justify-content: end; +} + +.bd-main .bd-content .bd-article-container .bd-article { + padding-left: 1rem; + padding-top: 1rem; + padding-right: 1rem; +} + +/** +* Bold font weight for **code** +*/ + +b, +strong { + font-weight: 900; +} + +/** +* _code.scss related changes +*/ +.docutils { + font-family: var(--pst-font-family-monospace); + font-weight: 500; +} + +#pst-back-to-top { + background: var(--ast-color-link); + color: var(--ast-color-text); +} + +/** +* _api.scss related changes +*/ + +.sig-prename.descclassname { + display: none; +} /* hide the class 'descclassname' for autoapi */ + +.sig { + font-family: "Consolas", "Menlo", "DejaVu Sans Mono", + "Bitstream Vera Sans Mono", monospace; +} + +.sig-name.descname { + color: var(--pst-color-inline-code); +} + +.sig-name { + color: var(--pst-color-sig); +} + +/** +* highlighted objects inside the api reference +*/ +dt:target, +span.highlighted { + background-color: var(--pst-color-codecell) !important; +} + +/** +* Increase empty-space around classes, methods, properties, etc. that are descendants +* of other items +*/ +dl.class dl.py { + margin-top: 2.5em; + margin-bottom: 2.5em; +} + +/** +* image padding before and after +*/ + +img { + padding-top: 1em; + padding-bottom: 1em; +} + +html[data-theme="dark"] .bd-content img:not(.only-dark):not(.dark-light) { + background: transparent; +} + +img.logo__image { + padding-top: 0rem; + padding-bottom: 0rem; +} + +/** +*Nav-bar entity right side. +*/ + +.list-group-item.active { + z-index: 2; + color: var(--pst-color-text-base) !important; +} + +/** +* admontions +*/ + +div.deprecated { + border-color: var(--pst-color-danger); + background-color: #dc354514; +} + +div.deprecated, +div.versionadded, +div.versionchanged { + background-color: transparent; +} + +.admonition, +div.admonition { + background-color: var(--pst-color-on-surface); +} + +/** +* Select only divisions that contain a dataframe, with enough specificity to override pydata css +*/ +div.nboutput + div.output_area.rendered_html.docutils.container:has(table.dataframe) { + background-color: transparent; +} + +aside.topic > p { + color: var(--pst-color-text-base) !important; +} + +/** +* search hide match +*/ + +div#searchbox p.highlight-link a { + background-color: var(--pst-color-search-match); +} + +.header-article__inner { + padding: 0 1rem; +} + +/** +* +* _links.scss +*/ + +/** +* links on paragraphs +*/ +a { + color: var(--ast-color-link); + text-decoration: none; +} + +a:active { + color: var(--ast-color-link-active); +} + +a:hover, +a:active:hover { + color: var(--ast-color-link-hover); + text-decoration: underline; +} + +a:visited:hover { + color: var(--ast-color-link-visited-hover); +} + +a:visited { + color: var(--ast-color-link-visited); +} + +a:focus-visible { + color: var(--ast-color-link); + box-shadow: var(--ast-ring-shadow-focused); +} + +a > code { + color: var(--ast-color-inline-code); +} + +code.literal { + color: var(--ast-color-inline-code); + font-family: "open sans", sans-serif; +} + +nav.bd-links li > a:focus-visible, +.nav-link:focus-visible, +a.nav-link.pst-navbar-icon:focus-visible, +.toc-entry a.nav-link:focus-visible, +nav.bd-links .current > a:focus-visible { + box-shadow: var(--ast-ring-shadow-focused); + outline: none; +} + +/** +* Admonitions +*/ + +.admonition > .admonition-title, +div.admonition > .admonition-title { + color: var(--ast-admonitions-color); + font-size: var(--ast-admonitions-font-size); + background-color: transparent !important; /* important tag because the admonition has a background color */ + margin-left: 8px; +} + +/** +* Admonitions icons +*/ +.admonition > .admonition-title:after, +div.admonition > .admonition-title:after, +span.versionmodified:before { + font-size: var(--ast-admonitions-icon-size); + height: var(--ast-admonition-icon-height); + width: var(--ast-admonition-icon-width); + left: 0px; +} + +span.versionmodified:before { + margin-right: 16px; /* separate component, to alligh with title, 8px padding + 8px padding from icon */ +} + +/** +* Admonitions title +*/ + +.admonition p.admonition-title ~ *, +div.admonition p.admonition-title ~ * { + margin-left: 40px; /* separate component, to alligh with title, 8px padding + 24px icon + 8px padding from icon */ + margin-right: 8px; + margin-top: 0px; +} + +.admonition, +div.admonition { + border: 2px solid; + padding: var(--ast-admonitions-padding); + box-shadow: none !important; /* important tag because the admonition has a box-shadow from pydata sphinx theme*/ + border-radius: var(--ast-admonitions-border-radius); +} + +/* warning attention caution important, warning */ + +.admonition.attention > .admonition-title:after, +div.admonition.attention > .admonition-title:after, +.admonition.caution > .admonition-title:after, +div.admonition.caution > .admonition-title:after, +.admonition.important > .admonition-title:after, +div.admonition.important > .admonition-title:after, +.admonition.warning > .admonition-title:after, +div.admonition.warning > .admonition-title:after { + color: var(--ast-admonition-warning-icon); +} + +.admonition.caution, +div.admonition.caution, +.admonition.attention, +div.admonition.attention, +.admonition.important, +div.admonition.important, +.admonition.warning, +div.admonition.warning { + border-color: var(--ast-admonition-warning-border); +} + +/* danger are error, danger, depreciated */ + +.admonition.danger > .admonition-title:after, +div.admonition.danger > .admonition-title:after, +.admonition.error > .admonition-title:after, +div.admonition.error > .admonition-title:after, +span.depreciated.changed:before { + color: var(--ast-admonition-danger-icon); +} + +.admonition.danger, +div.admonition.danger, +.admonition.error, +div.admonition.error, +div.deprecated { + border-color: var(--ast-admonition-danger-border); +} + +/*info are hint, note, see also, tip */ + +.admonition.info > .admonition-title:after, +div.admonition.info > .admonition-title:after, +.admonition.hint > .admonition-title:after, +div.admonition.hint > .admonition-title:after, +.admonition.note > .admonition-title:after, +div.admonition.note > .admonition-title:after, +.admonition.seealso > .admonition-title:after, +div.admonition.seealso > .admonition-title:after, +.admonition.tip > .admonition-title:after, +div.admonition.tip > .admonition-title:after { + color: var(--ast-admonition-info-icon); +} + +.admonition.info, +div.admonition.info, +.admonition.hint, +div.admonition.hint, +.admonition.note, +div.admonition.note, +.admonition.seealso, +div.admonition.seealso, +.admonition.tip, +div.admonition.tip { + border-color: var(--ast-admonition-info-border); +} + +/* success is version-added */ + +span.versionadded.changed:before { + color: var(--ast-admonition-success-icon); +} + +div.versionadded { + border-color: var(--ast-admonition-success-border); +} + +/* neutral is todo, version-change, topic */ + +div.deprecated, +div.versionadded, +div.versionchanged { + border-width: 2px; + border-style: solid; + padding: var(--ast-admonitions-padding); + border-radius: var(--ast-admonitions-border-radius); + box-shadow: none !important; /* important tag because the admonition has a box-shadow from pydata sphinx theme*/ +} + +div.deprecated > p, +div.versionadded > p, +div.versionchanged > p { + margin-left: 8px; +} + +span.versionmodified.changed:before, +.admonition.admonition-todo > .admonition-title:after, +div.admonition.admonition-todo > .admonition-title:after { + color: var(--ast-admonition-neutral-icon); +} + +.admonition.admonition-todo, +div.admonition.admonition-todo, +aside.topic, +div.versionchanged { + border-color: var(--ast-admonition-neutral-border); +} + +/** +* Dropdown _header.scss +*/ +.bd-header ul.navbar-nav > li.nav-item.dropdown > .dropdown-toggle { + color: var(--ast-navbar-color); + font-weight: 600; + font-size: var(--bs-nav-link-font-size); + border-radius: 4px; + border-color: var(--ast-dropdown-header-border); +} + +.bd-header ul.navbar-nav > li.nav-item.dropdown > .dropdown-toggle:hover { + color: var(--ast-navbar-hover-color); + border-bottom: none; + box-shadow: var(--ast-box-shadow-hover); +} + +.bd-header ul.navbar-nav .dropdown .dropdown-menu .dropdown-item { + color: var(--ast-navbar-color); + font-size: var(--bs-nav-link-font-size); + font-weight: 600; + border-radius: 4px; + border-color: var(--ast-dropdown-header-border); +} + +/** +* Dropdown _header.scss +*/ + +.version-switcher__menu a.list-group-item { + background-color: var(--ast-color-enable-card-background); + width: 200px; + border: none; + filter: drop-shadow(var(--ast-box-shadow-active)); + color: var(--ast-navbar-hover-color); + font-size: var(--ast-nav-link-font-size); + height: 40px; + padding: 0px 16px; + text-decoration: none; + border-radius: 4px; +} + +button.btn.version-switcher__button { + background-color: transparent; + border-color: var(--ast-navbar-active-border-color); + color: var(--ast-navbar-color); + font-size: var(--ast-nav-link-font-size); +} + +button.btn.version-switcher__button:hover { + border-color: var(--ast-navbar-active-border-color); + color: var(--ast-navbar-hover-color); +} + +.version-switcher__menu a.list-group-item:hover { + background-color: var(--ast-color-hover-card-background); + border: none; + color: var(--ast-navbar-hover-color); + font-size: var(--ast-nav-link-font-size); + text-decoration: none; +} + +.version-switcher__menu a.list-group-item:not(:last-child) { + border-bottom: none; +} + +.version-switcher__menu a.list-group-item.active { + box-shadow: none; +} + +.version-switcher__menu { + filter: box-shadow(var(--ast-box-shadow-active)); + border: none; +} + +/** +* Article content (_article.scss) +*/ + +.bd-main .bd-content .bd-article-container { + padding: 8px; + width: 1000px; +} + +.bd-sidebar-primary { + width: 20%; +} diff --git a/version/dev/_static/css/sphinx-design.css b/version/dev/_static/css/sphinx-design.css new file mode 100644 index 00000000..9f918dac --- /dev/null +++ b/version/dev/_static/css/sphinx-design.css @@ -0,0 +1,246 @@ +@import "../design-style.4045f2051d55cab465a707391d5b2007.min.css"; + +/** +* sphinx design button +*/ + +.sd-btn { + font-size: var(--ast-sphinx-design-font-size); + font-weight: 400; + font-family: var(--ast-sphinx-design-font-family); + padding: 8px 16px; + border-radius: var(--ast-sphinx-design-border-radius); +} + +.sd-btn-secondary { + font-size: var(--ast-sphinx-design-font-size); + font-weight: 400; + font-family: var(--ast-sphinx-design-font-family); + padding: 8px 16px; + border-radius: var(--ast-sphinx-design-border-radius); + color: var(--sd-color-secondary-text); + background-color: var(--sd-color-secondary); + border-color: var(--sd-color-secondary); +} + +blockquote { + background-color: var(--pst-color-background); +} + +/* Media query for medium-sized screens */ +@media screen and (max-width: 768px) { + .sd-card .sd-card-header { + font-size: var(--pst-font-size-h6); + } +} + +/* Media query for small-sized screens */ +@media screen and (max-width: 576px) { + .sd-card .sd-card-header { + font-size: var(--pst-font-size-h5); + } + .sd-card { + padding: 4px; + } +} +/** +* Sphinx-design dropdown +*/ + +.bd-content details.sd-dropdown:not([open]) > .sd-card-header { + border-radius: var(--ast-sphinx-design-border-radius); +} + +.bd-content details.sd-dropdown { + color: var(--ast-dropdown-text-color); + width: fit-content; + min-width: 400px; +} + +.bd-content details.sd-dropdown summary.sd-summary-title { + font-family: var(--ast-sphinx-design-font-family); + font-size: var(--ast-sphinx-design-font-size); + background: var(--ast-color-sphinx-design-background) !important; + border: 1px solid var(--ast-dropdown-border-color) !important; + border-radius: var(--ast-sphinx-design-border-radius); + padding: 8px 12px; + text-align: left; +} + +.bd-content details.sd-dropdown summary.sd-summary-title:hover { + background-color: var(--ast-color-hover-card-background) !important; + border: 1px solid var(--ast-dropdown-border-color-hover) !important; + border-radius: var(--ast-sphinx-design-border-radius); +} + +.bd-content + details.sd-dropdown + summary.sd-card-header + + div.sd-summary-content { + background-color: var(--ast-color-sphinx-design-background); + border-left: none !important; +} + +.bd-content + details.sd-dropdown + .sd-summary-title:active + + div.sd-summary-content:active { + background-color: var(--ast-color-enable-card-background); + border-color: var(--ast-color-enable-border); +} + +.bd-content + details.sd-dropdown + .sd-summary-title:hover + + div.sd-summary-content:hover { + background-color: var(--ast-color-hover-card-background); + border-color: var(--ast-color-hover-border); + border-left: none; +} + +.bd-content + details.sd-dropdown + summary.sd-summary-title:focus + + div.sd-summary-content:focus { + background-color: var(--ast-color-sphinx-design-background); + border-radius: var(--ast-sphinx-design-border-radius); + border-color: var(--pst-color-border); + border-left: none; +} + +details.sd-dropdown summary.sd-card-header + div.sd-summary-content { + color: var(--ast-color-sphinx-design-primary); + font-family: var(--ast-sphinx-design-font-family); + font-size: var(--ast-sphinx-design-font-size); +} + +/** +* Sphinx-design tab +*/ + +.bd-content .sd-tab-set > label { + font-family: var(--ast-sphinx-design-font-family); + padding: 12px 0px; + border-style: none none solid none; + color: var(--ast-color-sphinx-design-primary); + font-size: var(--ast-sphinx-design-font-size); + margin-inline-end: 16px; + transform: none; + margin-bottom: 1px; +} + +.bd-content .sd-tab-set > input:checked + label:hover, +.bd-content .sd-tab-set > input:not(:checked, :focus-visible) + label:hover { + color: var(--ast-color-sphinx-design-primary); + font-family: var(--ast-sphinx-design-font-family); +} + +.bd-content .sd-tab-set > input + label:focus-visible, +.bd-content + .sd-tab-set + > input:not(:checked, :focus-visible) + + label:focus-visible { + background-color: var(--ast-background-tab-focus); + border-color: transparent transparent var(--ast-tab-border-color-hover) + transparent; + border-width: 0px 0px 2px 0px; + text-decoration-line: none; +} + +.bd-content .sd-tab-set > input:checked + label { + background-color: transparent; + border-color: transparent transparent var(--ast-tab-border-color-active) + transparent; + border-width: 0px 0px 2px 0px; + border-style: none none solid none; + transform: none; +} + +.bd-content .sd-tab-set > input:checked + label:hover { + background-color: var(--ast-background-tab-hover); + border-color: transparent transparent var(--ast-tab-border-color-hover) + transparent; + border-width: 0px 0px 2px 0px; +} + +.bd-content .sd-tab-set > input:not(:checked, :focus-visible) + label { + background-color: transparent; + border-color: transparent transparent var(--ast-tab-border-color) transparent; + border-width: 0px 0px 1px 0px; + text-decoration-line: none; + font-weight: normal; +} + +.bd-content .sd-tab-set > input:not(:checked, :focus-visible) + label:hover { + background-color: var(--ast-background-tab-hover); + border-color: transparent transparent var(--ast-tab-border-color-hover) + transparent; + border-width: 0px 0px 2px 0px; + border-style: none none solid none; + text-decoration: none; +} + +.bd-content .sd-tab-set .sd-tab-content { + border: none; + font-family: var(--ast-sphinx-design-font-family); + font-size: var(--ast-sphinx-design-font-size); + color: var(--ast-color-sphinx-design-primary); +} + +/* Media query for medium-sized screens */ +@media screen and (max-width: 768px) { + .sd-tab-set > input:not(.focus-visible) + label { + font-size: 14px; + } +} + +/* Media query for small-sized screens */ +@media screen and (max-width: 576px) { + .sd-tab-set > input:not(.focus-visible) + label { + font-size: 12px; + } +} + +/** +* Sphinx-design card +*/ + +.bd-content .sd-card .sd-card-body, +.bd-content .sd-card .sd-card-footer { + font-size: var(--ast-sphinx-design-font-size); + border: none; + background-color: var(--ast-color-sphinx-design-background); + font-family: var(--ast-sphinx-design-font-family); + color: var(--ast-color-sphinx-design-primary); + border-radius: 8px; +} + +.bd-content .sd-card .sd-card-title, +.bd-content .sd-card .sd-card-header { + font-size: 16px; + border: none; + background-color: var(--ast-color-sphinx-design-background); + font-family: var(--ast-sphinx-design-font-family); +} + +.bd-content .sd-card { + border: none; + border-radius: 8px; + box-shadow: var(--ast-box-shadow-hover) !important; + color: var(--ast-color-sphinx-design-primary); + background-color: var(--ast-color-sphinx-design-background); +} + +.bd-content .sd-card:hover { + box-shadow: var(--ast-box-shadow-hover) !important; +} + +.sd-hide-link-text:focus { + outline: none; + box-shadow: none; +} + +.bd-content .sd-card .sd-stretched-link:focus-visible:after { + outline: none; + box-shadow: var(--ast-ring-shadow-focused); +} diff --git a/version/dev/_static/css/sphinx-gallery.css b/version/dev/_static/css/sphinx-gallery.css new file mode 100644 index 00000000..dbd25dc2 --- /dev/null +++ b/version/dev/_static/css/sphinx-gallery.css @@ -0,0 +1,56 @@ +@import "ansys-sphinx-theme-variable.css"; + +/** +* Sphinx gallery output cell +*/ + +.highlight pre { + font-size: 0.9em; +} + +/** +* Sphinx gallery download button text +*/ + +a > code.download { + font-family: var(--pst-font-family-base); + color: var(--pst-color-link); + text-decoration: none; + font-weight: normal; +} + +div.sphx-glr-download a, +div.sphx-glr-download a:hover { + background-image: none; + color: var(--ast-sphinx-gallery-download-text); + text-decoration: none; + border-radius: 4px; + height: 36px; + padding: 0px 16px; + display: flex; + align-items: flex-start; + justify-content: center; + flex-wrap: wrap; + flex-direction: column; +} +div.sphx-glr-download code.download, +a.reference.download:before { + color: var(--ast-sphinx-gallery-download-text); +} +div.sphx-glr-download a:hover { + background-color: var(--ast-sphinx-gallery-download-background-hover); +} + +div.sphx-glr-download a { + background-color: var(--ast-sphinx-gallery-download-background); +} + +.docutils.container { + display: flex; + flex-direction: row; + flex-wrap: wrap; + align-content: center; + justify-content: flex-start; + gap: 10px; + margin: initial; +} diff --git a/version/dev/_static/css/table-custom.css b/version/dev/_static/css/table-custom.css new file mode 100644 index 00000000..5411d1b7 --- /dev/null +++ b/version/dev/_static/css/table-custom.css @@ -0,0 +1,116 @@ +/** +* Table +* +* the table variables. +*/ + +.table { + --bs-table-bg: var(--ast-color-table-background); + border-spacing: 0; + border-collapse: separate; + overflow: hidden; + vertical-align: middle; + overflow-y: scroll; + scrollbar-width: none; + -ms-overflow-style: none; + border-color: var(--ast-table-outer-border); + background-color: var(--ast-color-table-background); +} + +tbody, +td, +tfoot, +th, +thead, +tr { + border-bottom: 1px solid var(--ast-color-table-inner-border); + background-color: var(--ast-color-table-background); + font-family: var(--ast-font-family-base); + font-size: var(--ast-table-font-size); +} + +.table > :not(caption) > * > * { + padding: 0px 16px; +} + +/** +* Table header +*/ +th { + line-height: 40px; + color: var(--ast-color-table-header-text) !important; + font-size: var(--ast-table-header-font-size) !important; +} + +/** +* Table body +*/ + +tr { + line-height: var(--ast-global-line-height); + height: 56px; + color: var(--ast-color-table-cell-text); +} + +/** +* Table hover +*/ + +tbody :hover, +td :hover, +tfoot :hover, +th :hover, +thead :hover, +tr :hover { + background-color: var(--ast-color-table-row-hover-bg); + font-family: var(--ast-font-family-base); +} + +.table :hover { + background-color: var(--ast-color-table-row-hover-bg); +} + +/** +* Table active +*/ + +.table :active { + background-color: var(--ast-color-table-active-bg); +} +/** +* Table dataframes +*/ + +table.dataframe tr { + font-size: var(--ast-table-font-size); + line-height: 56px; + color: var(--ast-color-table-cell-text); +} + +table.dataframe th { + font-size: var(--ast-table-font-size); + line-height: 40px; + color: var(--ast-color-table-header-text) !important; +} + +table.dataframe :hover { + background-color: var(--ast-color-table-row-hover-bg); + font-family: var(--ast-font-family-base); +} + +table.dataframe :active { + background-color: var(--ast-color-table-active-bg); + font-family: var(--ast-font-family-base); +} + +table.dataframe { + background-color: var(--ast-color-table-background); +} + +.table td ~ td, +.table td ~ th, +.table th ~ td, +.table th ~ th, +.bd-content .nboutput .output_area.rendered_html table.dataframe th ~ td { + border-left: 1px solid var(--ast-color-table-inner-border); +} diff --git a/version/dev/_static/design-tabs.js b/version/dev/_static/design-tabs.js new file mode 100644 index 00000000..2952d2e2 --- /dev/null +++ b/version/dev/_static/design-tabs.js @@ -0,0 +1,101 @@ +// @ts-check + +// Extra JS capability for selected tabs to be synced +// The selection is stored in local storage so that it persists across page loads. + +/** + * @type {Record
+
+
+
+
+