PyOpenMagnetics 1.3.13__tar.gz → 1.4.0__tar.gz

{pyopenmagnetics-1.3.13 → 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.13 → 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/")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.3.13
+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.13 → 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.13 → 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.13 → pyopenmagnetics-1.4.0}/pyproject.toml

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

{pyopenmagnetics-1.3.13 → 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.13 → 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.13 → 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

{pyopenmagnetics-1.3.13 → pyopenmagnetics-1.4.0}/src/common.h

@@ -35,6 +35,7 @@
 #include "processors/MagneticSimulator.h"
 #include "processors/CircuitSimulatorInterface.h"
 #include "processors/NgspiceRunner.h"
+#include "processors/Sweeper.h"
 #include "support/Painter.h"
 #include "support/Utils.h"