How ansys/pyaedt works
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: core Solver facades · application App framework · Resources Example assets · modules Modules
Components 20
Runtime
Execution boundaries and external backend
- AEDT · Locally installed Ansys Electronics Desktop used as the execution backend
- RPC layer · 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 · Primary session lifecycle and launch surface for AEDT control
src/ansys/aedt/core/desktop.py - Solver facades · User-facing solver/application classes such as HFSS, Icepak, Maxwell, Q3D, Circuit, Twin Builder, EDB, and EMIT
src/ansys/aedt/core - App framework · Common design, analysis, variable, job, file, and unit abstractions
src/ansys/aedt/core/application - Shared utils · Logging, constants, file utilities, settings, version checks, and environment detection
src/ansys/aedt/core/generic
Modeling
Geometry, schematic, and layout construction
- Modeler · Shared CAD, PCB, circuit, and 3D modeling layer
src/ansys/aedt/core/modeler - Advanced CAD · Multipart components, coils, chokes, stackups, and other advanced geometry helpers
src/ansys/aedt/core/modeler/advanced_cad
Modules
Reusable AEDT configuration objects
- Modules · Boundaries, mesh, setups, materials, variation, optimetrics, stackup, and cable modeling
src/ansys/aedt/core/modules - Boundaries · Solver-specific boundary and excitation definitions
src/ansys/aedt/core/modules/boundary - Setups · Setup templates, solve setups, and sweep definitions
src/ansys/aedt/core/modules/solve_setup.py
Results
Visualization, reporting, and exports
- Visualization · Postprocessing, plots, reports, and export pipelines
src/ansys/aedt/core/visualization - Postprocessing · Solution data extraction, field data, compliance, and solver-specific post objects
src/ansys/aedt/core/visualization/post - Reports · 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 · Graph-like EMIT node, coupling, and result model
src/ansys/aedt/core/emit_core - Filter synthesis · Lumped/distributed filter topology, parasitics, goals, and export logic
src/ansys/aedt/core/filtersolutions_core
Automation
CLI, RPC, and extensions
- Extensions · Packaged automation tools and product-specific workflows with catalogs and templates
src/ansys/aedt/core/extensions - Installer · Extension registration, packaging, version management, and launch helpers
src/ansys/aedt/core/extensions/installer - CLI · 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 · Example projects, configs, templates, documentation resources, and test fixtures
doc/source/Resources
Connections 23
- 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