PyOpenMagnetics 1.3.12__tar.gz → 1.4.0__tar.gz

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/.github/workflows/publish.yml

@@ -10,6 +10,11 @@ on:
         required: false
         default: false
         type: boolean
+      publish_to_pypi:
+        description: 'Publish to real PyPI instead of TestPyPI (use to rebuild a failed release without recreating the GitHub release/tag)'
+        required: false
+        default: false
+        type: boolean
 
 env:
   GIT_LFS_SKIP_SMUDGE: 1  # Skip LFS to avoid bandwidth quota issues
@@ -109,18 +114,18 @@ jobs:
               if [ $i -lt 3 ]; then sleep 60; fi
             done
           CIBW_ENVIRONMENT_LINUX: PATH=/opt/rh/gcc-toolset-13/root/usr/bin:$PATH LD_LIBRARY_PATH=/opt/rh/gcc-toolset-13/root/usr/lib64:$LD_LIBRARY_PATH
-          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core cmake ninja pybind11
+          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core "cmake<4" ninja pybind11
           CIBW_TEST_COMMAND: python -c "import PyOpenMagnetics; print(f'PyOpenMagnetics loaded successfully with {len(dir(PyOpenMagnetics))} functions')"
 
       - name: Publish Linux wheels to PyPI
-        if: github.event_name == 'release'
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.publish_to_pypi)
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
           packages-dir: wheelhouse/
 
       - name: Publish Linux wheels to TestPyPI
-        if: github.event_name == 'workflow_dispatch'
+        if: github.event_name == 'workflow_dispatch' && !inputs.publish_to_pypi
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           repository-url: https://test.pypi.org/legacy/
@@ -181,21 +186,21 @@ jobs:
           CIBW_BUILD: cp310-* cp311-* cp312-* cp313-*
           CIBW_SKIP: "*-win32 *-manylinux_i686 *musllinux* pp*"
           CIBW_BEFORE_ALL_WINDOWS: npm install -g quicktype
-          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core cmake ninja pybind11
+          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core "cmake<4" ninja pybind11
           CIBW_TEST_COMMAND: python -c "import PyOpenMagnetics; print(f'PyOpenMagnetics loaded successfully with {len(dir(PyOpenMagnetics))} functions')"
 
       - name: Install twine
         run: python -m pip install twine
 
       - name: Publish Windows wheels to PyPI
-        if: github.event_name == 'release'
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.publish_to_pypi)
         run: python -m twine upload wheelhouse/*.whl
         env:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
 
       - name: Publish Windows wheels to TestPyPI
-        if: github.event_name == 'workflow_dispatch'
+        if: github.event_name == 'workflow_dispatch' && !inputs.publish_to_pypi
         run: python -m twine upload --repository-url https://test.pypi.org/legacy/ wheelhouse/*.whl
         env:
           TWINE_USERNAME: __token__
@@ -266,21 +271,21 @@ jobs:
               if [ $i -lt 5 ]; then sleep 60; fi
             done
           CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=15.0
-          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core cmake ninja pybind11
+          CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core "cmake<4" ninja pybind11
           CIBW_TEST_COMMAND: python -c "import PyOpenMagnetics; print(f'PyOpenMagnetics loaded successfully with {len(dir(PyOpenMagnetics))} functions')"
 
       - name: Install twine
         run: python -m pip install twine
 
       - name: Publish macOS wheels to PyPI
-        if: github.event_name == 'release'
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.publish_to_pypi)
         run: python -m twine upload wheelhouse/*.whl
         env:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
 
       - name: Publish macOS wheels to TestPyPI
-        if: github.event_name == 'workflow_dispatch'
+        if: github.event_name == 'workflow_dispatch' && !inputs.publish_to_pypi
         run: python -m twine upload --repository-url https://test.pypi.org/legacy/ wheelhouse/*.whl
         env:
           TWINE_USERNAME: __token__
@@ -338,14 +343,14 @@ jobs:
         run: python -m build --sdist
 
       - name: Publish sdist to PyPI
-        if: github.event_name == 'release'
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.publish_to_pypi)
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
           packages-dir: dist/
 
       - name: Publish sdist to TestPyPI
-        if: github.event_name == 'workflow_dispatch'
+        if: github.event_name == 'workflow_dispatch' && !inputs.publish_to_pypi
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           repository-url: https://test.pypi.org/legacy/

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/AGENTS.md

@@ -1,5 +1,18 @@
 # AGENTS.md — PyOpenMagnetics AI Assistant Guide
 
+> **MKF is authoritative for all magnetics math.** Before implementing any
+> magnetics calculation or assuming an API exists, consult
+> [`../MKF/CAPABILITIES.md`](../MKF/CAPABILITIES.md). If a needed capability
+> isn't listed there, ask — don't reinvent it here.
+
+> **Two stub files in this repo:**
+> - `PyOpenMagnetics.pyi` — **curated**. Authoritative on arg conventions
+>   and gotchas. Read this first.
+> - `PyOpenMagnetics.generated.pyi` — **auto-generated** from the compiled
+>   `.so` via pybind11-stubgen. Wider coverage (every exported symbol) but
+>   raw — signatures are right, conventions may not be. Use as a discovery
+>   index; when it disagrees with the curated stub, trust the curated one.
+
 > **This file is the SINGLE SOURCE OF TRUTH for any AI agent using PyOpenMagnetics.**
 > Every instruction was derived from reading the C++ source code
 > (`converter.cpp`, `magnetics.cpp`, `cores.cpp`, `wires.cpp`, `settings.cpp`,
@@ -615,26 +628,74 @@ subcircuit = PyOM.export_magnetic_as_subcircuit(magnetic)
 
 ## 11. Supported Topologies
 
-| Topology string | Method A class | Singular/Plural | Notes |
-|---|---|---|---|
-| `"flyback"` | `Flyback` | PLURAL + **mode required** | Most common |
-| `"buck"` | `Buck` | **SINGULAR** | |
-| `"boost"` | `Boost` | **SINGULAR** | |
-| `"single_switch_forward"` | `SingleSwitchForward` | PLURAL | switchingFreq REQUIRED |
-| `"two_switch_forward"` | `TwoSwitchForward` | PLURAL | switchingFreq REQUIRED |
-| `"active_clamp_forward"` | `ActiveClampForward` | PLURAL | switchingFreq REQUIRED |
-| `"push_pull"` | `PushPull` | PLURAL | Same as Forward |
-| `"llc"` | `Llc` | PLURAL | |
-| `"isolated_buck"` | `IsolatedBuck` | PLURAL | |
-| `"isolated_buck_boost"` | `IsolatedBuckBoost` | PLURAL | |
-| Others (`"cllc"`, `"dab"`, `"psfb"`, `"pshb"`) | internal fallback | varies | |
-
-Per-topology thin wrappers for `process_converter`:
+`process_converter("<topology>", json, use_ngspice)` is the universal entry
+point and accepts every string below, plus its `"advanced_<topology>"` form
+(the internal builds the `Advanced*` MKF class either way — "advanced" is
+selected by the JSON payload shape, e.g. presence of `desiredInductance` /
+`desiredMagnetizingInductance` / `desiredBoostInductance`, not by the name).
+
+### 11.1 Per-topology API parity matrix
+
+Every topology exposes the **same four surfaces** (✓ = present). Columns:
+- **inputs** — `calculate_<t>_inputs(json)` (basic) and
+  `calculate_advanced_<t>_inputs(json)` (advanced)
+- **process** — dedicated `process_<t>(json)` thin wrapper (all are also
+  reachable via the generic `process_converter`)
+- **simulate** — `simulate_<t>_ideal_waveforms(json)` (ngspice)
+- **ngspice** — `generate_<t>_ngspice_circuit(json, input_voltage_index=0, operating_point_index=0)`
+
+| Topology string | inputs (basic / advanced) | process_* | simulate | generate ngspice |
+|---|---|---|---|---|
+| `flyback` | ✓ / ✓ | ✓ | ✓ (+`simulate_flyback_with_magnetic`) | ✓ |
+| `buck` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `boost` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `single_switch_forward` | ✓ / ✓ | ✓ | ✓ (`simulate_forward_*`) | ✓ (`generate_forward_*`) |
+| `two_switch_forward` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `active_clamp_forward` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `push_pull` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `isolated_buck` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `isolated_buck_boost` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `cuk` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `sepic` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `zeta` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `four_switch_buck_boost` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `weinberg` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `llc` | ✓ / ✓ | via `process_converter` | ✓ | ✓ |
+| `cllc` | ✓ / ✓ | via `process_converter` | ✓ | ✓ |
+| `clllc` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `src` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `dab` | ✓ / ✓ | via `process_converter` | ✓ | ✓ |
+| `phase_shifted_full_bridge` (`psfb`) | ✓ / ✓ | via `process_converter` | ✓ | ✓ |
+| `phase_shifted_half_bridge` (`pshb`) | ✓ / ✓ | via `process_converter` | ✓ | ✓ |
+| `asymmetric_half_bridge` (`ahb`) | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `vienna` | ✓ / ✓ | ✓ | ✓ | ✓ |
+| `power_factor_correction` (`pfc`) | ✓ / — ¹ | via `process_converter` | ✓ (`simulate_pfc_waveforms`) | ✓ ² |
+| `current_transformer` | — ³ | ✓ ³ | — | — |
+| `common_mode_choke` (`cmc`) | `calculate_cmc_inputs` / `calculate_advanced_cmc_inputs` | — | `simulate_cmc_ideal_waveforms`, `simulate_cmc_lisn_waveforms` | `generate_cmc_ngspice_circuit` |
+| `differential_mode_choke` (`dmc`) | `calculate_dmc_inputs` | `propose_dmc_design`, `verify_dmc_attenuation` | `simulate_dmc_waveforms` | `generate_dmc_ngspice_circuit` |
+
+¹ PFC has no `AdvancedPowerFactorCorrection` class in MKF — basic-only by design;
+  there is intentionally no `calculate_advanced_pfc_inputs`.
+² `generate_pfc_ngspice_circuit(json, dc_resistance=0.1, simulation_time=0.02,
+  time_step=1e-8)` — PFC is a line-frequency model, so it takes circuit-damping
+  parameters instead of the `input_voltage_index` / `operating_point_index`
+  sweep indices used by the DC-DC family. Inductance comes from an explicit
+  `"inductance"` field or is derived from `"mode"` (CCM/CrCM/DCM).
+³ Current transformer is measurement-only: `process_current_transformer(json,
+  turns_ratio, secondary_resistance=0.0)`.
+
+### 11.2 Dedicated `process_*` thin wrappers
+
 `process_flyback()`, `process_buck()`, `process_boost()`,
 `process_single_switch_forward()`, `process_two_switch_forward()`,
 `process_active_clamp_forward()`, `process_push_pull()`,
 `process_isolated_buck()`, `process_isolated_buck_boost()`,
-`process_current_transformer(json, turns_ratio, secondary_resistance=0.0)`
+`process_cuk()`, `process_sepic()`, `process_zeta()`,
+`process_four_switch_buck_boost()`, `process_asymmetric_half_bridge()`,
+`process_weinberg()`, `process_vienna()`, `process_clllc()`, `process_src()`,
+`process_current_transformer(json, turns_ratio, secondary_resistance=0.0)`.
+Topologies without a dedicated wrapper (`llc`, `cllc`, `dab`, `psfb`, `pshb`,
+`pfc`) are reached through `process_converter("<topology>", json)`.
 
 ---
 

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/CMakeLists.txt

@@ -24,16 +24,15 @@ else ()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-deprecated-declarations -Wno-unused-parameter -Wno-switch")
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-    # set(CMAKE_BUILD_TYPE RelWithDebInfo)
     # set(CMAKE_BUILD_TYPE MinSizeRel)
-    set(CMAKE_BUILD_TYPE Release)
-    
+    # set(CMAKE_BUILD_TYPE Release)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo)
+
     # Enable Link Time Optimization to reduce binary size
     set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)  # TEMP: disable LTO (OOM)
-    
-    # Strip symbols and use size optimization
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s -Os")
-    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--strip-all")
+
+    # Debug build: keep symbols and frame pointers for gdb backtraces.
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O1 -g -fno-omit-frame-pointer")
 endif()
 
 SET(MAS_DIRECTORY "${CMAKE_BINARY_DIR}/MAS/")
@@ -123,12 +122,12 @@ if(NOT LOCAL_MKF_MAS)
     set(MKF_FORCE_REFRESH "2026-04-29-extra-components")
     # Tell MKF to disable matplotplusplus and use SVG-based Painter instead
     set(INCLUDE_PYMKF ON CACHE BOOL "Build Python interface" FORCE)
-    # GIT_SUBMODULES_RECURSE pulls in CAS/EAS (added 2026-04 alongside the
+    # GIT_SUBMODULES_RECURSE pulls in CAS/PEAS (added 2026-04 alongside the
     # ExtraComponentsMode API). MAS is also a submodule of MKF but PyMKF
-    # fetches it independently below for fast-update reasons; CAS/EAS only
+    # fetches it independently below for fast-update reasons; CAS/PEAS only
     # exist as MKF submodules, so we need them populated under MKF/.
     # NOTE: we cannot use GIT_SHALLOW with GIT_SUBMODULES — shallow clone
-    # skips submodule init. Drop the shallow flag for MKF so CAS/EAS/
+    # skips submodule init. Drop the shallow flag for MKF so CAS/PEAS/
     # cci_coords are actually checked out. cci_coords MUST stay in this
     # list — the CCI generator reads from MKF/cci_coords/coordinates/.
     # MAS is fetched separately below (not a sub-fetch of MKF here) so
@@ -137,7 +136,7 @@ if(NOT LOCAL_MKF_MAS)
             GIT_REPOSITORY https://github.com/OpenMagnetics/MKF.git
             GIT_TAG main
             GIT_PROGRESS TRUE
-            GIT_SUBMODULES "CAS" "EAS" "cci_coords"
+            GIT_SUBMODULES "CAS" "PEAS" "cci_coords"
             GIT_SUBMODULES_RECURSE TRUE)
 
     message(STATUS "Fetching mas")
@@ -262,14 +261,14 @@ add_custom_target(PyMASGeneration
 
 # ──────────────────────────────────────────────────────────────────
 # CAS.hpp generation (mirrors MKF/CMakeLists.txt:419-451)
-# CAS = Capacitor Adviser Schema. EAS = Element Adviser Schema.
+# CAS = Capacitor Adviser Schema. PEAS = Power Element Adviser Schema.
 # Both are submodules of MKF (added 2026-04). MKF/Topology.h #includes
 # <CAS.hpp> for the get_extra_components_inputs API; we must generate
 # the header here so PyOpenMagnetics's TU sees it.
 # ──────────────────────────────────────────────────────────────────
 set(CAS_DIRECTORY "${CMAKE_BINARY_DIR}/CAS/")
 set(CAS_DIR "${MKF_DIR}/CAS")
-set(EAS_DIR "${MKF_DIR}/EAS")
+set(PEAS_DIR "${MKF_DIR}/PEAS")
 file(MAKE_DIRECTORY "${CAS_DIRECTORY}")
 
 add_custom_command(
@@ -277,8 +276,10 @@ add_custom_command(
   COMMAND ${CMAKE_COMMAND} -E remove -f "${CAS_DIRECTORY}/CAS.hpp"
   COMMAND quicktype -l c++ -s schema ${CAS_DIR}/schemas/inputs.json
     -S ${CAS_DIR}/schemas/inputs/designRequirements.json
-    -S ${EAS_DIR}/schemas/utils.json
-    -S ${EAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json
+    -S ${PEAS_DIR}/schemas/utils.json
+    -S ${PEAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json
+    -S ${PEAS_DIR}/schemas/inputs/operatingConditions.json
+    -S ${PEAS_DIR}/schemas/inputs/operatingPointExcitation.json
     -o ${CAS_DIRECTORY}/CAS.hpp --namespace CAS --source-style single-source
     --type-style pascal-case --member-style underscore-case
     --enumerator-style upper-underscore-case --no-boost
@@ -286,8 +287,10 @@ add_custom_command(
   DEPENDS
     "${CAS_DIR}/schemas/inputs.json"
     "${CAS_DIR}/schemas/inputs/designRequirements.json"
-    "${EAS_DIR}/schemas/utils.json"
-    "${EAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json"
+    "${PEAS_DIR}/schemas/utils.json"
+    "${PEAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json"
+    "${PEAS_DIR}/schemas/inputs/operatingConditions.json"
+    "${PEAS_DIR}/schemas/inputs/operatingPointExcitation.json"
   USES_TERMINAL)
 
 add_custom_target(PyCASGeneration

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.3.12
+Version: 1.4.0
 Summary: Python wrapper for OpenMagnetics
 Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
 Classifier: Development Status :: 4 - Beta
@@ -314,6 +314,29 @@ magnetics = get_advised_magnetics(inputs, max_results=5)
 |----------|-------------|
 | `export_magnetic_as_subcircuit(magnetic, ...)` | Export as SPICE model |
 
+### Converter Topologies
+
+All 24 power topologies are exposed with a uniform API. Use the generic
+`process_converter("<topology>", converter, use_ngspice)` (also accepts
+`"advanced_<topology>"`), or the per-topology functions below.
+
+| Function family | Description |
+|----------|-------------|
+| `process_converter(name, json, use_ngspice=True)` | Universal dispatch for every topology |
+| `design_magnetics_from_converter(name, json, max_results, core_mode, ...)` | Converter → advised magnetic designs (single call) |
+| `calculate_<t>_inputs(json)` | Build MAS inputs (basic mode) for topology `<t>` |
+| `calculate_advanced_<t>_inputs(json)` | Build MAS inputs (advanced mode) |
+| `simulate_<t>_ideal_waveforms(json)` | ngspice ideal-waveform simulation |
+| `generate_<t>_ngspice_circuit(json, input_voltage_index=0, operating_point_index=0)` | Generate ngspice netlist |
+
+`<t>` ∈ `flyback, buck, boost, single_switch_forward, two_switch_forward,
+active_clamp_forward, push_pull, isolated_buck, isolated_buck_boost, cuk,
+sepic, zeta, four_switch_buck_boost, weinberg, llc, cllc, clllc, src, dab,
+psfb, pshb, ahb, vienna`. PFC is basic-only (`calculate_pfc_inputs`,
+`generate_pfc_ngspice_circuit(json, dc_resistance=0.1, simulation_time=0.02,
+time_step=1e-8)`); common-/differential-mode chokes use the `cmc` / `dmc`
+families. See `AGENTS.md` §11 for the full per-topology parity matrix.
+
 ## Core Materials
 
 PyOpenMagnetics includes materials from major manufacturers:

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/README.md

@@ -297,6 +297,29 @@ magnetics = get_advised_magnetics(inputs, max_results=5)
 |----------|-------------|
 | `export_magnetic_as_subcircuit(magnetic, ...)` | Export as SPICE model |
 
+### Converter Topologies
+
+All 24 power topologies are exposed with a uniform API. Use the generic
+`process_converter("<topology>", converter, use_ngspice)` (also accepts
+`"advanced_<topology>"`), or the per-topology functions below.
+
+| Function family | Description |
+|----------|-------------|
+| `process_converter(name, json, use_ngspice=True)` | Universal dispatch for every topology |
+| `design_magnetics_from_converter(name, json, max_results, core_mode, ...)` | Converter → advised magnetic designs (single call) |
+| `calculate_<t>_inputs(json)` | Build MAS inputs (basic mode) for topology `<t>` |
+| `calculate_advanced_<t>_inputs(json)` | Build MAS inputs (advanced mode) |
+| `simulate_<t>_ideal_waveforms(json)` | ngspice ideal-waveform simulation |
+| `generate_<t>_ngspice_circuit(json, input_voltage_index=0, operating_point_index=0)` | Generate ngspice netlist |
+
+`<t>` ∈ `flyback, buck, boost, single_switch_forward, two_switch_forward,
+active_clamp_forward, push_pull, isolated_buck, isolated_buck_boost, cuk,
+sepic, zeta, four_switch_buck_boost, weinberg, llc, cllc, clllc, src, dab,
+psfb, pshb, ahb, vienna`. PFC is basic-only (`calculate_pfc_inputs`,
+`generate_pfc_ngspice_circuit(json, dc_resistance=0.1, simulation_time=0.02,
+time_step=1e-8)`); common-/differential-mode chokes use the `cmc` / `dmc`
+families. See `AGENTS.md` §11 for the full per-topology parity matrix.
+
 ## Core Materials
 
 PyOpenMagnetics includes materials from major manufacturers:

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/llms.txt

@@ -763,6 +763,41 @@ inputs = {
 processed = PyOpenMagnetics.process_inputs(inputs)
 ```
 
+### Low-Level Per-Topology API (uniform across all topologies)
+
+Beyond the high-level `process_converter` / `design_magnetics_from_converter`
+entry points, every topology exposes the **same four function families**, so
+any topology can be driven the same way:
+
+```python
+# 1. Input builders — basic and advanced modes (advanced = JSON carries a
+#    desired* inductance/turns-ratio field; both reach the same MKF engine):
+inputs      = PyOpenMagnetics.calculate_dab_inputs(converter)
+inputs_adv  = PyOpenMagnetics.calculate_advanced_dab_inputs(converter)
+
+# 2. Generic dispatch (accepts "<topology>" and "advanced_<topology>"):
+inputs      = PyOpenMagnetics.process_converter("vienna", converter, True)
+
+# 3. Ideal-waveform SPICE simulation:
+waveforms   = PyOpenMagnetics.simulate_vienna_ideal_waveforms(converter)
+
+# 4. ngspice netlist generation:
+netlist     = PyOpenMagnetics.generate_vienna_ngspice_circuit(converter, 0, 0)
+```
+
+Coverage is uniform for: `flyback, buck, boost, single_switch_forward,
+two_switch_forward, active_clamp_forward, push_pull, isolated_buck,
+isolated_buck_boost, cuk, sepic, zeta, four_switch_buck_boost, weinberg, llc,
+cllc, clllc, src, dab, psfb, pshb, asymmetric_half_bridge (ahb), vienna`.
+Both `calculate_<t>_inputs` and `calculate_advanced_<t>_inputs` exist for each
+of these. Exceptions: **PFC** has no advanced variant
+(`calculate_pfc_inputs` only; `generate_pfc_ngspice_circuit(json,
+dc_resistance=0.1, simulation_time=0.02, time_step=1e-8)` uses a
+line-frequency model with no sweep indices), and **current_transformer** is
+measurement-only (`process_current_transformer`). Common- and
+differential-mode chokes have their own `calculate_cmc_inputs` /
+`calculate_advanced_cmc_inputs` / `calculate_dmc_inputs` families.
+
 ## Related Projects
 - **MKF**: C++ magnetics engine - github.com/OpenMagnetics/MKF
 - **MAS**: Magnetic Agnostic Structure JSON schema - github.com/OpenMagnetics/MAS  

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "PyOpenMagnetics"
-version = "1.3.12"
+version = "1.4.0"
 requires-python = ">=3.8"
 authors = [
   { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/src/advisers.cpp

@@ -236,6 +236,98 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
     }
 }
 
+json calculate_advised_sections(json masJson, json patternJson, int repetitions) {
+    try {
+        OpenMagnetics::Mas mas(masJson);
+        std::vector<size_t> pattern;
+        for (auto& elem : patternJson) {
+            pattern.push_back(elem);
+        }
+        auto bobbin = mas.get_magnetic().get_coil().get_bobbin();
+        if (std::holds_alternative<std::string>(bobbin)) {
+            auto bobbinString = std::get<std::string>(bobbin);
+            if (bobbinString == "Dummy") {
+                mas.get_mutable_magnetic().get_mutable_coil().set_bobbin(
+                    OpenMagnetics::Bobbin::create_quick_bobbin(mas.get_mutable_magnetic().get_mutable_core()));
+            }
+        }
+        for (size_t windingIndex = 0; windingIndex < mas.get_magnetic().get_coil().get_functional_description().size(); ++windingIndex) {
+            mas.get_mutable_magnetic().get_mutable_coil().get_mutable_functional_description()[windingIndex].set_wire("Dummy");
+        }
+        auto sections = OpenMagnetics::CoilAdviser().get_advised_sections(mas, pattern, repetitions);
+        json result = json::array();
+        for (auto& section : sections) {
+            json aux;
+            to_json(aux, section);
+            result.push_back(aux);
+        }
+        return result;
+    }
+    catch (const std::exception& exc) {
+        return json{{"error", std::string("calculate_advised_sections: ") + exc.what()}};
+    }
+}
+
+json calculate_advised_coil(json masJson) {
+    try {
+        OpenMagnetics::Settings::GetInstance().set_coil_delimit_and_compact(true);
+        OpenMagnetics::Mas mas(masJson);
+        for (size_t windingIndex = 0; windingIndex < mas.get_magnetic().get_coil().get_functional_description().size(); ++windingIndex) {
+            mas.get_mutable_magnetic().get_mutable_coil().get_mutable_functional_description()[windingIndex].set_wire("Dummy");
+        }
+        mas.get_mutable_magnetic().get_mutable_coil().set_turns_description(std::nullopt);
+        mas.get_mutable_magnetic().get_mutable_coil().set_layers_description(std::nullopt);
+        mas.get_mutable_magnetic().get_mutable_coil().set_sections_description(std::nullopt);
+        mas.get_mutable_magnetic().get_mutable_coil().set_groups_description(std::nullopt);
+        OpenMagnetics::CoilAdviser coilAdviser;
+        auto masMagneticsWithCoil = coilAdviser.get_advised_coil(mas, 1);
+        if (masMagneticsWithCoil.size() > 0) {
+            json result;
+            to_json(result, masMagneticsWithCoil[0]);
+            return result;
+        }
+        else {
+            return json{{"error", "No coil found"}};
+        }
+    }
+    catch (const std::exception& exc) {
+        return json{{"error", std::string("calculate_advised_coil: ") + exc.what()}};
+    }
+}
+
+json calculate_advised_wires(json windingJson, json sectionJson, json currentJson, json solidInsulationRequirementsJson, double temperature, uint8_t numberSections, size_t maximumNumberResults, bool usePlanarWires) {
+    try {
+        OpenMagnetics::Settings::GetInstance().set_coil_delimit_and_compact(true);
+        OpenMagnetics::Winding winding(windingJson);
+        OpenMagnetics::WireSolidInsulationRequirements wireSolidInsulationRequirements(solidInsulationRequirementsJson);
+        Section section(sectionJson);
+        SignalDescriptor current(currentJson);
+        OpenMagnetics::WireAdviser wireAdviser;
+        wireAdviser.set_wire_solid_insulation_requirements(wireSolidInsulationRequirements);
+        std::vector<std::pair<OpenMagnetics::Winding, double>> windingsWithScoring;
+        if (usePlanarWires) {
+            windingsWithScoring = wireAdviser.get_advised_planar_wire(winding, section, current, temperature, numberSections, maximumNumberResults);
+        }
+        else {
+            windingsWithScoring = wireAdviser.get_advised_wire(winding, section, current, temperature, numberSections, maximumNumberResults);
+        }
+        json results;
+        results["data"] = json::array();
+        for (auto& [w, scoring] : windingsWithScoring) {
+            json result;
+            json windingJson;
+            to_json(windingJson, w);
+            result["winding"] = windingJson;
+            result["scoring"] = scoring;
+            results["data"].push_back(result);
+        }
+        return results;
+    }
+    catch (const std::exception& exc) {
+        return json{{"error", std::string("calculate_advised_wires: ") + exc.what()}};
+    }
+}
+
 void register_adviser_bindings(py::module& m) {
     m.def("calculate_advised_cores", &calculate_advised_cores,
         R"pbdoc(
@@ -386,6 +478,20 @@ void register_adviser_bindings(py::module& m) {
             Returns "Exception: No magnetics found in cache" if cache is empty.
         )pbdoc",
         py::arg("inputs_json"), py::arg("filter_flow_json"), py::arg("max_results"));
+
+    m.def("calculate_advised_sections", &calculate_advised_sections,
+        "Get advised coil sections.",
+        py::arg("mas"), py::arg("pattern"), py::arg("repetitions"));
+
+    m.def("calculate_advised_coil", &calculate_advised_coil,
+        "Get full coil design advice.",
+        py::arg("mas"));
+
+    m.def("calculate_advised_wires", &calculate_advised_wires,
+        "Get wire selection advice.",
+        py::arg("winding"), py::arg("section"), py::arg("current"),
+        py::arg("solid_insulation_requirements"), py::arg("temperature"), py::arg("number_sections"),
+        py::arg("max_results"), py::arg("use_planar_wires") = false);
 }
 
 } // namespace PyMKF

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/src/bobbin.cpp

@@ -99,6 +99,48 @@ bool check_if_fits(json bobbinJson, double dimension, bool isHorizontalOrRadial)
     }
 }
 
+json create_simple_bobbin_from_core(json coreJson) {
+    try {
+        OpenMagnetics::Core core(coreJson, false, false, false);
+        auto bobbin = OpenMagnetics::Bobbin::create_quick_bobbin(core);
+
+        json result;
+        to_json(result, bobbin);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        return "Exception: " + std::string{exc.what()};
+    }
+}
+
+json create_simple_bobbin_from_core_with_custom_thickness(json coreJson, double thickness) {
+    try {
+        OpenMagnetics::Core core(coreJson, false, false, false);
+        auto bobbin = OpenMagnetics::Bobbin::create_quick_bobbin(core, thickness);
+
+        json result;
+        to_json(result, bobbin);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        return "Exception: " + std::string{exc.what()};
+    }
+}
+
+json create_simple_bobbin_from_core_with_custom_thicknesses(json coreJson, double wallThickness, double columnThickness) {
+    try {
+        OpenMagnetics::Core core(coreJson, false, false, false);
+        auto bobbin = OpenMagnetics::Bobbin::create_quick_bobbin(core, wallThickness, columnThickness);
+
+        json result;
+        to_json(result, bobbin);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        return "Exception: " + std::string{exc.what()};
+    }
+}
+
 void register_bobbin_bindings(py::module& m) {
     m.def("get_bobbins", &get_bobbins, "Retrieve all available bobbins as JSON objects");
     m.def("get_bobbin_names", &get_bobbin_names, "Retrieve list of all bobbin names");
@@ -108,6 +150,45 @@ void register_bobbin_bindings(py::module& m) {
     m.def("calculate_bobbin_data", &calculate_bobbin_data, "Calculate bobbin specifications");
     m.def("process_bobbin", &process_bobbin, "Process bobbin geometry");
     m.def("check_if_fits", &check_if_fits, "Check if winding fits in available space");
+
+    m.def("create_simple_bobbin_from_core", &create_simple_bobbin_from_core,
+        R"pbdoc(
+        Create a simple bobbin from core data.
+
+        Args:
+            core_json: JSON Core object.
+
+        Returns:
+            JSON Bobbin object.
+        )pbdoc",
+        py::arg("core_json"));
+
+    m.def("create_simple_bobbin_from_core_with_custom_thickness", &create_simple_bobbin_from_core_with_custom_thickness,
+        R"pbdoc(
+        Create a simple bobbin from core data with custom wall thickness.
+
+        Args:
+            core_json: JSON Core object.
+            thickness: Wall thickness in meters.
+
+        Returns:
+            JSON Bobbin object.
+        )pbdoc",
+        py::arg("core_json"), py::arg("thickness"));
+
+    m.def("create_simple_bobbin_from_core_with_custom_thicknesses", &create_simple_bobbin_from_core_with_custom_thicknesses,
+        R"pbdoc(
+        Create a simple bobbin from core data with custom wall and column thicknesses.
+
+        Args:
+            core_json: JSON Core object.
+            wall_thickness: Wall thickness in meters.
+            column_thickness: Column thickness in meters.
+
+        Returns:
+            JSON Bobbin object.
+        )pbdoc",
+        py::arg("core_json"), py::arg("wall_thickness"), py::arg("column_thickness"));
 }
 
 } // namespace PyMKF

{pyopenmagnetics-1.3.12 → pyopenmagnetics-1.4.0}/src/bobbin.h

@@ -13,6 +13,11 @@ json calculate_bobbin_data(json magneticJson);
 json process_bobbin(json bobbinJson);
 bool check_if_fits(json bobbinJson, double dimension, bool isHorizontalOrRadial);
 
+// Simple bobbin creation
+json create_simple_bobbin_from_core(json coreJson);
+json create_simple_bobbin_from_core_with_custom_thickness(json coreJson, double thickness);
+json create_simple_bobbin_from_core_with_custom_thicknesses(json coreJson, double wallThickness, double columnThickness);
+
 void register_bobbin_bindings(py::module& m);
 
 } // namespace PyMKF