# ansys/pyaedt architecture

> Architecture diagram of the GitHub repository ansys/pyaedt, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-05-06). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/ansys/pyaedt
- Repository: https://github.com/ansys/pyaedt

## Overview

1. **Overall shape**
   - This repository is a Python library, not an application service.
   - Its main purpose is to act as a high-level automation layer over **Ansys Electronics Desktop (AEDT)** and related Ansys electronics tools.
   - The package root is `ansys.aedt.core`, with most functionality organized under solver-specific facades and shared subsystems.

2. **Primary runtime boundary**
   - The key external dependency is a **locally licensed AEDT installation**.
   - PyAEDT runs either:
     - **in-process / local** with AEDT on the same machine, or
     - **remotely** through the RPC layer, where a Python client talks to a service manager and then to AEDT.
   - This makes AEDT the central “backend,” while PyAEDT is the orchestration and abstraction layer.

3. **Top-level application facades**
   - The main entry points are solver/application classes such as `Desktop`, `Hfss`, `Icepak`, `Maxwell`, `Q3D`, `Circuit`, `TwinBuilder`, `Rmxprt`, `Mechanical`, `Edb`, and `Emit`.
   - These classes provide the user-facing API and hide solver-specific AEDT object models behind a consistent Python interface.
   - The README examples show the typical flow: create a `Desktop` session, then instantiate a solver application and operate through it.

4. **Core application layer**
   - `src/ansys/aedt/core/application` contains the common application framework:
     - desktop/session lifecycle,
     - design and analysis abstractions,
     - variable handling,
     - job management,
     - file management and unit handling.
   - This layer is the shared control plane for solver-specific implementations in `hfss.py`, `icepak.py`, `maxwell.py`, `q3d.py`, etc.

5. **Modeling subsystem**
   - `src/ansys/aedt/core/modeler` is the geometry and schematic layer.
   - It contains:
     - 2D/3D CAD primitives,
     - PCB / layout primitives,
     - circuit schematic primitives,
     - advanced CAD helpers like multipart components, coils, chokes, and stackups.
   - Data flow here is typically from Python geometry objects and design variables into AEDT modeler/editor operations.

6. **Modules subsystem**
   - `src/ansys/aedt/core/modules` holds reusable design modules that correspond to AEDT concepts:
     - boundaries,
     - mesh,
     - setups/sweeps,
     - materials,
     - variation management,
     - design exploration / optimetrics,
     - layer stackup.
   - These modules are the bridge between the modeler and solver setup/postprocessing stages, and they represent AEDT configuration objects rather than pure Python utilities.

7. **Postprocessing and visualization**
   - `src/ansys/aedt/core/visualization` covers results handling, plotting, report generation, and export.
   - It is split into:
     - `post` for solution data and field/result extraction,
     - `plot` for matplotlib / pyvista / PDF-based visualization,
     - `report` for report definitions and report generation,
     - `advanced` for specialty parsers such as far-field, RCS, Touchstone, and SBR+ related data.
   - This layer consumes solved AEDT data, exported files, and metadata, then turns them into plots, reports, or derived analysis artifacts.

8. **EMIT subsystem**
   - `src/ansys/aedt/core/emit` and `emit_core` implement EMIT-specific modeling and result structures.
   - `emit_core` includes generated node classes, schematic/coupling logic, constants, validators, and results objects.
   - The architecture here is more graph-like than geometry-like: it models radio/system interactions and coupling relationships, then produces analysis results.

9. **Filter Solutions subsystem**
   - `src/ansys/aedt/core/filtersolutions_core` is a specialized domain layer for filter synthesis and export.
   - It includes lumped and distributed filter topology models, parasitics, substrate definitions, graph setup, goals, and export-to-AEDT integration.
   - This subsystem is distinct from the generic AEDT solver wrappers: it has its own domain model and can emit designs into AEDT.

10. **Extensions and toolkit packaging**
    - `src/ansys/aedt/core/extensions` contains packaged automation tools and UI- or workflow-oriented extensions for specific products.
    - These are grouped by domain, such as HFSS, HFSS 3D Layout, Icepak, Maxwell, Circuit, Twin Builder, and common utilities.
    - The `installer` and `templates` subtrees indicate that the repo also ships tooling to register, package, or launch extensions inside AEDT’s automation framework.

11. **CLI entry points**
    - `src/ansys/aedt/core/cli` provides a command-line interface with subcommands for project, export, documentation, scripting, and panel-related operations.
    - This is a separate front door from the Python API, but it still drives the same core application layer underneath.
    - The CLI is useful for automation outside notebook or script-based usage, but it is not the primary architecture layer.

12. **RPC / remote execution**
    - `src/ansys/aedt/core/rpc` and `common_rpc.py` implement remote-session behavior.
    - The README shows this pattern explicitly: a Python client can connect to a service manager and then control AEDT remotely.
    - This is a key architectural boundary because it separates client-side API usage from the machine hosting AEDT.

13. **Shared infrastructure and internal utilities**
    - `src/ansys/aedt/core/generic`, `internal`, and supporting files under `misc` provide cross-cutting concerns:
      - logging,
      - file utilities,
      - constants,
      - settings,
      - version checks,
      - error handling,
      - environment/session detection.
    - These utilities are the substrate used by all higher-level subsystems, but they do not represent user-facing domain functionality.

14. **Data and content-heavy assets**
    - The repository includes many JSON, TOML, YAML, CSV, PDF, and AEDT project files under `src/.../misc`, `src/.../extensions/.../resources`, `doc/source/Resources`, and `tests/.../example_models`.
    - These files are not just test fixtures; they also act as canonical inputs, templates, example projects, and configuration catalogs for extensions and workflows.
    - For an architecture diagram, these should be shown as external content artifacts feeding the modeling, extension, and postprocessing paths.

15. **Quality, docs, and release infrastructure**
    - `tests/` is broad and structured by unit, integration, system, solver-specific, layout, visualization, extension, and EMIT coverage.
    - `.github/workflows`, `.ci`, and the documentation tree under `doc/` show that the project is heavily automated for CI, release, docs generation, and cache management.
    - This infrastructure matters because the repository is validated against multiple AEDT versions and many solver workflows, which reinforces that the core architecture is a shared library spanning several product domains rather than a single-purpose tool.

Main entry points: [`src/ansys/aedt/core`](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core) (Solver facades), [`src/ansys/aedt/core/application`](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/application) (App framework), [`doc/source/Resources`](https://github.com/ansys/pyaedt/tree/main/doc/source/Resources) (Example assets), [`src/ansys/aedt/core/modules`](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modules) (Modules)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_grp_runtime["Runtime"]
  node_aedt_backend[("AEDT<br/>licensed backend")]
  node_remote_rpc["RPC layer<br/>remote session"]
end

subgraph group_grp_core["Core API"]
  node_desktop_api["Desktop<br/>session entrypoint<br/>[desktop.py]"]
  node_solver_api["Solver facades<br/>application wrappers"]
  node_app_framework["App framework<br/>shared application core"]
  node_core_utils["Shared utils<br/>infra utilities"]
end

subgraph group_grp_modeling["Modeling"]
  node_modeler_core["Modeler<br/>geometry & schematic"]
  node_advanced_cad["Advanced CAD<br/>specialized geometry"]
end

subgraph group_grp_modules["Modules"]
  node_modules_core["Modules<br/>AEDT config objects"]
  node_boundaries["Boundaries<br/>solver constraints"]
  node_analysis_setup["Setups<br/>analysis config<br/>[solve_setup.py]"]
end

subgraph group_grp_results["Results"]
  node_visualization_core["Visualization<br/>results layer"]
  node_postprocessing["Postprocessing<br/>solution data"]
  node_reporting["Reports<br/>report generation"]
end

subgraph group_grp_domain["Domain layers"]
  node_emit_core["EMIT core<br/>radio-system model"]
  node_filtersolutions_core["Filter synthesis<br/>domain model"]
end

subgraph group_grp_automation["Automation"]
  node_extensions_pkg["Extensions<br/>toolkits"]
  node_installer_tooling["Installer<br/>packaging flow"]
  node_cli_entry["CLI<br/>command interface"]
end

subgraph group_grp_assets["Assets"]
  node_example_assets["Example assets<br/>content bundle"]
end

node_desktop_api -->|"launch/control"| node_aedt_backend
node_remote_rpc -->|"remote control"| node_aedt_backend
node_solver_api -->|"built on"| node_app_framework
node_app_framework -->|"session lifecycle"| node_desktop_api
node_app_framework -->|"uses"| node_core_utils
node_solver_api -->|"drives"| node_modeler_core
node_modeler_core -->|"extends"| node_advanced_cad
node_app_framework -->|"configures"| node_modules_core
node_modules_core -->|"includes"| node_boundaries
node_modules_core -->|"includes"| node_analysis_setup
node_solver_api -->|"consumes"| node_visualization_core
node_visualization_core -->|"contains"| node_postprocessing
node_visualization_core -->|"contains"| node_reporting
node_postprocessing -->|"reads"| node_example_assets
node_reporting -->|"reads"| node_example_assets
node_emit_core -->|"specializes"| node_solver_api
node_filtersolutions_core -->|"exports to"| node_solver_api
node_extensions_pkg -->|"automates"| node_solver_api
node_installer_tooling -->|"packages"| node_extensions_pkg
node_cli_entry -->|"invokes"| node_app_framework
node_core_utils -->|"supports"| node_remote_rpc
node_extensions_pkg -->|"ships"| node_example_assets
node_example_assets -->|"feeds"| node_modeler_core

click node_remote_rpc "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/rpc"
click node_desktop_api "https://github.com/ansys/pyaedt/blob/main/src/ansys/aedt/core/desktop.py"
click node_solver_api "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core"
click node_app_framework "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/application"
click node_modeler_core "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modeler"
click node_advanced_cad "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modeler/advanced_cad"
click node_modules_core "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modules"
click node_boundaries "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modules/boundary"
click node_analysis_setup "https://github.com/ansys/pyaedt/blob/main/src/ansys/aedt/core/modules/solve_setup.py"
click node_visualization_core "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization"
click node_postprocessing "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization/post"
click node_reporting "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization/report"
click node_emit_core "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/emit_core"
click node_filtersolutions_core "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/filtersolutions_core"
click node_extensions_pkg "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/extensions"
click node_installer_tooling "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/extensions/installer"
click node_cli_entry "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/cli"
click node_core_utils "https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/generic"
click node_example_assets "https://github.com/ansys/pyaedt/tree/main/doc/source/Resources"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_aedt_backend,node_remote_rpc,node_extensions_pkg,node_installer_tooling,node_cli_entry toneBlue
class node_desktop_api,node_solver_api,node_app_framework,node_core_utils,node_example_assets toneAmber
class node_modeler_core,node_advanced_cad toneMint
class node_modules_core,node_boundaries,node_analysis_setup toneRose
class node_visualization_core,node_postprocessing,node_reporting toneIndigo
class node_emit_core,node_filtersolutions_core toneTeal
```

## Components

### Runtime

Execution boundaries and external backend

- **AEDT**: licensed backend · Locally installed Ansys Electronics Desktop used as the execution backend
- [RPC layer](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/rpc): remote session · Remote execution path between Python client, service manager, and AEDT · `src/ansys/aedt/core/rpc`

### Core API

Top-level application and shared control plane

- [Desktop](https://github.com/ansys/pyaedt/blob/main/src/ansys/aedt/core/desktop.py): session entrypoint · Primary session lifecycle and launch surface for AEDT control · `src/ansys/aedt/core/desktop.py`
- [Solver facades](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core): application wrappers · User-facing solver/application classes such as HFSS, Icepak, Maxwell, Q3D, Circuit, Twin Builder, EDB, and EMIT · `src/ansys/aedt/core`
- [App framework](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/application): shared application core · Common design, analysis, variable, job, file, and unit abstractions · `src/ansys/aedt/core/application`
- [Shared utils](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/generic): infra utilities · Logging, constants, file utilities, settings, version checks, and environment detection · `src/ansys/aedt/core/generic`

### Modeling

Geometry, schematic, and layout construction

- [Modeler](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modeler): geometry & schematic · Shared CAD, PCB, circuit, and 3D modeling layer · `src/ansys/aedt/core/modeler`
- [Advanced CAD](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modeler/advanced_cad): specialized geometry · Multipart components, coils, chokes, stackups, and other advanced geometry helpers · `src/ansys/aedt/core/modeler/advanced_cad`

### Modules

Reusable AEDT configuration objects

- [Modules](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modules): AEDT config objects · Boundaries, mesh, setups, materials, variation, optimetrics, stackup, and cable modeling · `src/ansys/aedt/core/modules`
- [Boundaries](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/modules/boundary): solver constraints · Solver-specific boundary and excitation definitions · `src/ansys/aedt/core/modules/boundary`
- [Setups](https://github.com/ansys/pyaedt/blob/main/src/ansys/aedt/core/modules/solve_setup.py): analysis config · Setup templates, solve setups, and sweep definitions · `src/ansys/aedt/core/modules/solve_setup.py`

### Results

Visualization, reporting, and exports

- [Visualization](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization): results layer · Postprocessing, plots, reports, and export pipelines · `src/ansys/aedt/core/visualization`
- [Postprocessing](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization/post): solution data · Solution data extraction, field data, compliance, and solver-specific post objects · `src/ansys/aedt/core/visualization/post`
- [Reports](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/visualization/report): report generation · Report definitions and generation for EM, eye, netlist, and standard outputs · `src/ansys/aedt/core/visualization/report`

### Domain layers

Specialized non-general subsystems

- [EMIT core](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/emit_core): radio-system model · Graph-like EMIT node, coupling, and result model · `src/ansys/aedt/core/emit_core`
- [Filter synthesis](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/filtersolutions_core): domain model · Lumped/distributed filter topology, parasitics, goals, and export logic · `src/ansys/aedt/core/filtersolutions_core`

### Automation

CLI, RPC, and extensions

- [Extensions](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/extensions): toolkits · Packaged automation tools and product-specific workflows with catalogs and templates · `src/ansys/aedt/core/extensions`
- [Installer](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/extensions/installer): packaging flow · Extension registration, packaging, version management, and launch helpers · `src/ansys/aedt/core/extensions/installer`
- [CLI](https://github.com/ansys/pyaedt/tree/main/src/ansys/aedt/core/cli): command interface · Command-line front door for project, export, docs, scripting, and panels operations · `src/ansys/aedt/core/cli`

### Assets

Example data, templates, and documentation artifacts

- [Example assets](https://github.com/ansys/pyaedt/tree/main/doc/source/Resources): content bundle · Example projects, configs, templates, documentation resources, and test fixtures · `doc/source/Resources`

## Connections

- Desktop → AEDT: launch/control · Desktop sessions attach to or launch AEDT
- RPC layer → AEDT: remote control · RPC services proxy client actions into AEDT
- Solver facades → App framework: built on · Solver facades reuse the shared application framework
- App framework → Desktop: session lifecycle · Common app layer coordinates desktop and design sessions
- App framework → Shared utils: uses · Application logic relies on shared utilities and settings
- Solver facades → Modeler: drives · Solver APIs expose geometry and schematic editing through the modeler
- Modeler → Advanced CAD: extends · Advanced CAD helpers build on the shared modeling base
- App framework → Modules: configures · Common application layer creates and manages AEDT configuration objects
- Modules → Boundaries: includes · Boundary definitions are a major module family
- Modules → Setups: includes · Setups and sweeps are central analysis modules
- Solver facades → Visualization: consumes · Solver results flow into visualization and postprocessing
- Visualization → Postprocessing: contains · Postprocessing extracts and transforms solved data
- Visualization → Reports: contains · Reporting turns solution data into reports and exports
- Postprocessing → Example assets: reads · Postprocessing consumes example files, templates, and exported artifacts
- Reports → Example assets: reads · Report generation uses bundled report examples and templates
- EMIT core → Solver facades: specializes · EMIT exposes a specialized solver-facing domain built around graph models
- Filter synthesis → Solver facades: exports to · Filter synthesis generates designs that are emitted into AEDT workflows
- Extensions → Solver facades: automates · Extensions wrap solver APIs in packaged workflows
- Installer → Extensions: packages · Installer and templates support extension distribution and registration
- CLI → App framework: invokes · CLI commands dispatch into the same core application layer
- Shared utils → RPC layer: supports · Shared infrastructure underpins remote-session behavior
- Extensions → Example assets: ships · Extensions rely on bundled icons, catalogs, resources, and templates
- Example assets → Modeler: feeds · Canonical geometry and design artifacts feed modeling workflows
